From f32a6e5be094f50571970eb1116b65c080781d05 Mon Sep 17 00:00:00 2001
From: Mary <mary@mary.zone>
Date: Wed, 27 Oct 2021 01:20:03 +0200
Subject: [PATCH] Regenerate StructArrayHelpers with a max element value of 256

---
 Ryujinx.Common/Memory/StructArrayHelpers.cs | 1920 +++++++++++++++++++
 1 file changed, 1920 insertions(+)

diff --git a/Ryujinx.Common/Memory/StructArrayHelpers.cs b/Ryujinx.Common/Memory/StructArrayHelpers.cs
index fbb2902d5..c16d0b2e1 100644
--- a/Ryujinx.Common/Memory/StructArrayHelpers.cs
+++ b/Ryujinx.Common/Memory/StructArrayHelpers.cs
@@ -640,4 +640,1924 @@ namespace Ryujinx.Common.Memory
         public ref T this[int index] => ref ToSpan()[index];
         public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 64);
     }
+    public struct Array65<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array64<T> _other;
+#pragma warning restore CS0169
+        public int Length => 65;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 65);
+    }
+    public struct Array66<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array65<T> _other;
+#pragma warning restore CS0169
+        public int Length => 66;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 66);
+    }
+    public struct Array67<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array66<T> _other;
+#pragma warning restore CS0169
+        public int Length => 67;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 67);
+    }
+    public struct Array68<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array67<T> _other;
+#pragma warning restore CS0169
+        public int Length => 68;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 68);
+    }
+    public struct Array69<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array68<T> _other;
+#pragma warning restore CS0169
+        public int Length => 69;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 69);
+    }
+    public struct Array70<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array69<T> _other;
+#pragma warning restore CS0169
+        public int Length => 70;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 70);
+    }
+    public struct Array71<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array70<T> _other;
+#pragma warning restore CS0169
+        public int Length => 71;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 71);
+    }
+    public struct Array72<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array71<T> _other;
+#pragma warning restore CS0169
+        public int Length => 72;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 72);
+    }
+    public struct Array73<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array72<T> _other;
+#pragma warning restore CS0169
+        public int Length => 73;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 73);
+    }
+    public struct Array74<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array73<T> _other;
+#pragma warning restore CS0169
+        public int Length => 74;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 74);
+    }
+    public struct Array75<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array74<T> _other;
+#pragma warning restore CS0169
+        public int Length => 75;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 75);
+    }
+    public struct Array76<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array75<T> _other;
+#pragma warning restore CS0169
+        public int Length => 76;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 76);
+    }
+    public struct Array77<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array76<T> _other;
+#pragma warning restore CS0169
+        public int Length => 77;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 77);
+    }
+    public struct Array78<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array77<T> _other;
+#pragma warning restore CS0169
+        public int Length => 78;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 78);
+    }
+    public struct Array79<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array78<T> _other;
+#pragma warning restore CS0169
+        public int Length => 79;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 79);
+    }
+    public struct Array80<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array79<T> _other;
+#pragma warning restore CS0169
+        public int Length => 80;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 80);
+    }
+    public struct Array81<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array80<T> _other;
+#pragma warning restore CS0169
+        public int Length => 81;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 81);
+    }
+    public struct Array82<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array81<T> _other;
+#pragma warning restore CS0169
+        public int Length => 82;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 82);
+    }
+    public struct Array83<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array82<T> _other;
+#pragma warning restore CS0169
+        public int Length => 83;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 83);
+    }
+    public struct Array84<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array83<T> _other;
+#pragma warning restore CS0169
+        public int Length => 84;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 84);
+    }
+    public struct Array85<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array84<T> _other;
+#pragma warning restore CS0169
+        public int Length => 85;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 85);
+    }
+    public struct Array86<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array85<T> _other;
+#pragma warning restore CS0169
+        public int Length => 86;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 86);
+    }
+    public struct Array87<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array86<T> _other;
+#pragma warning restore CS0169
+        public int Length => 87;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 87);
+    }
+    public struct Array88<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array87<T> _other;
+#pragma warning restore CS0169
+        public int Length => 88;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 88);
+    }
+    public struct Array89<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array88<T> _other;
+#pragma warning restore CS0169
+        public int Length => 89;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 89);
+    }
+    public struct Array90<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array89<T> _other;
+#pragma warning restore CS0169
+        public int Length => 90;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 90);
+    }
+    public struct Array91<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array90<T> _other;
+#pragma warning restore CS0169
+        public int Length => 91;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 91);
+    }
+    public struct Array92<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array91<T> _other;
+#pragma warning restore CS0169
+        public int Length => 92;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 92);
+    }
+    public struct Array93<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array92<T> _other;
+#pragma warning restore CS0169
+        public int Length => 93;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 93);
+    }
+    public struct Array94<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array93<T> _other;
+#pragma warning restore CS0169
+        public int Length => 94;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 94);
+    }
+    public struct Array95<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array94<T> _other;
+#pragma warning restore CS0169
+        public int Length => 95;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 95);
+    }
+    public struct Array96<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array95<T> _other;
+#pragma warning restore CS0169
+        public int Length => 96;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 96);
+    }
+    public struct Array97<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array96<T> _other;
+#pragma warning restore CS0169
+        public int Length => 97;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 97);
+    }
+    public struct Array98<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array97<T> _other;
+#pragma warning restore CS0169
+        public int Length => 98;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 98);
+    }
+    public struct Array99<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array98<T> _other;
+#pragma warning restore CS0169
+        public int Length => 99;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 99);
+    }
+    public struct Array100<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array99<T> _other;
+#pragma warning restore CS0169
+        public int Length => 100;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 100);
+    }
+    public struct Array101<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array100<T> _other;
+#pragma warning restore CS0169
+        public int Length => 101;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 101);
+    }
+    public struct Array102<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array101<T> _other;
+#pragma warning restore CS0169
+        public int Length => 102;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 102);
+    }
+    public struct Array103<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array102<T> _other;
+#pragma warning restore CS0169
+        public int Length => 103;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 103);
+    }
+    public struct Array104<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array103<T> _other;
+#pragma warning restore CS0169
+        public int Length => 104;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 104);
+    }
+    public struct Array105<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array104<T> _other;
+#pragma warning restore CS0169
+        public int Length => 105;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 105);
+    }
+    public struct Array106<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array105<T> _other;
+#pragma warning restore CS0169
+        public int Length => 106;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 106);
+    }
+    public struct Array107<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array106<T> _other;
+#pragma warning restore CS0169
+        public int Length => 107;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 107);
+    }
+    public struct Array108<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array107<T> _other;
+#pragma warning restore CS0169
+        public int Length => 108;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 108);
+    }
+    public struct Array109<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array108<T> _other;
+#pragma warning restore CS0169
+        public int Length => 109;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 109);
+    }
+    public struct Array110<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array109<T> _other;
+#pragma warning restore CS0169
+        public int Length => 110;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 110);
+    }
+    public struct Array111<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array110<T> _other;
+#pragma warning restore CS0169
+        public int Length => 111;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 111);
+    }
+    public struct Array112<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array111<T> _other;
+#pragma warning restore CS0169
+        public int Length => 112;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 112);
+    }
+    public struct Array113<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array112<T> _other;
+#pragma warning restore CS0169
+        public int Length => 113;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 113);
+    }
+    public struct Array114<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array113<T> _other;
+#pragma warning restore CS0169
+        public int Length => 114;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 114);
+    }
+    public struct Array115<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array114<T> _other;
+#pragma warning restore CS0169
+        public int Length => 115;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 115);
+    }
+    public struct Array116<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array115<T> _other;
+#pragma warning restore CS0169
+        public int Length => 116;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 116);
+    }
+    public struct Array117<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array116<T> _other;
+#pragma warning restore CS0169
+        public int Length => 117;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 117);
+    }
+    public struct Array118<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array117<T> _other;
+#pragma warning restore CS0169
+        public int Length => 118;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 118);
+    }
+    public struct Array119<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array118<T> _other;
+#pragma warning restore CS0169
+        public int Length => 119;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 119);
+    }
+    public struct Array120<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array119<T> _other;
+#pragma warning restore CS0169
+        public int Length => 120;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 120);
+    }
+    public struct Array121<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array120<T> _other;
+#pragma warning restore CS0169
+        public int Length => 121;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 121);
+    }
+    public struct Array122<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array121<T> _other;
+#pragma warning restore CS0169
+        public int Length => 122;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 122);
+    }
+    public struct Array123<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array122<T> _other;
+#pragma warning restore CS0169
+        public int Length => 123;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 123);
+    }
+    public struct Array124<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array123<T> _other;
+#pragma warning restore CS0169
+        public int Length => 124;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 124);
+    }
+    public struct Array125<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array124<T> _other;
+#pragma warning restore CS0169
+        public int Length => 125;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 125);
+    }
+    public struct Array126<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array125<T> _other;
+#pragma warning restore CS0169
+        public int Length => 126;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 126);
+    }
+    public struct Array127<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array126<T> _other;
+#pragma warning restore CS0169
+        public int Length => 127;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 127);
+    }
+    public struct Array128<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array127<T> _other;
+#pragma warning restore CS0169
+        public int Length => 128;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 128);
+    }
+    public struct Array129<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array128<T> _other;
+#pragma warning restore CS0169
+        public int Length => 129;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 129);
+    }
+    public struct Array130<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array129<T> _other;
+#pragma warning restore CS0169
+        public int Length => 130;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 130);
+    }
+    public struct Array131<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array130<T> _other;
+#pragma warning restore CS0169
+        public int Length => 131;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 131);
+    }
+    public struct Array132<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array131<T> _other;
+#pragma warning restore CS0169
+        public int Length => 132;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 132);
+    }
+    public struct Array133<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array132<T> _other;
+#pragma warning restore CS0169
+        public int Length => 133;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 133);
+    }
+    public struct Array134<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array133<T> _other;
+#pragma warning restore CS0169
+        public int Length => 134;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 134);
+    }
+    public struct Array135<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array134<T> _other;
+#pragma warning restore CS0169
+        public int Length => 135;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 135);
+    }
+    public struct Array136<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array135<T> _other;
+#pragma warning restore CS0169
+        public int Length => 136;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 136);
+    }
+    public struct Array137<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array136<T> _other;
+#pragma warning restore CS0169
+        public int Length => 137;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 137);
+    }
+    public struct Array138<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array137<T> _other;
+#pragma warning restore CS0169
+        public int Length => 138;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 138);
+    }
+    public struct Array139<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array138<T> _other;
+#pragma warning restore CS0169
+        public int Length => 139;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 139);
+    }
+    public struct Array140<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array139<T> _other;
+#pragma warning restore CS0169
+        public int Length => 140;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 140);
+    }
+    public struct Array141<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array140<T> _other;
+#pragma warning restore CS0169
+        public int Length => 141;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 141);
+    }
+    public struct Array142<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array141<T> _other;
+#pragma warning restore CS0169
+        public int Length => 142;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 142);
+    }
+    public struct Array143<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array142<T> _other;
+#pragma warning restore CS0169
+        public int Length => 143;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 143);
+    }
+    public struct Array144<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array143<T> _other;
+#pragma warning restore CS0169
+        public int Length => 144;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 144);
+    }
+    public struct Array145<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array144<T> _other;
+#pragma warning restore CS0169
+        public int Length => 145;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 145);
+    }
+    public struct Array146<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array145<T> _other;
+#pragma warning restore CS0169
+        public int Length => 146;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 146);
+    }
+    public struct Array147<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array146<T> _other;
+#pragma warning restore CS0169
+        public int Length => 147;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 147);
+    }
+    public struct Array148<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array147<T> _other;
+#pragma warning restore CS0169
+        public int Length => 148;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 148);
+    }
+    public struct Array149<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array148<T> _other;
+#pragma warning restore CS0169
+        public int Length => 149;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 149);
+    }
+    public struct Array150<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array149<T> _other;
+#pragma warning restore CS0169
+        public int Length => 150;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 150);
+    }
+    public struct Array151<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array150<T> _other;
+#pragma warning restore CS0169
+        public int Length => 151;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 151);
+    }
+    public struct Array152<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array151<T> _other;
+#pragma warning restore CS0169
+        public int Length => 152;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 152);
+    }
+    public struct Array153<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array152<T> _other;
+#pragma warning restore CS0169
+        public int Length => 153;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 153);
+    }
+    public struct Array154<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array153<T> _other;
+#pragma warning restore CS0169
+        public int Length => 154;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 154);
+    }
+    public struct Array155<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array154<T> _other;
+#pragma warning restore CS0169
+        public int Length => 155;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 155);
+    }
+    public struct Array156<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array155<T> _other;
+#pragma warning restore CS0169
+        public int Length => 156;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 156);
+    }
+    public struct Array157<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array156<T> _other;
+#pragma warning restore CS0169
+        public int Length => 157;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 157);
+    }
+    public struct Array158<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array157<T> _other;
+#pragma warning restore CS0169
+        public int Length => 158;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 158);
+    }
+    public struct Array159<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array158<T> _other;
+#pragma warning restore CS0169
+        public int Length => 159;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 159);
+    }
+    public struct Array160<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array159<T> _other;
+#pragma warning restore CS0169
+        public int Length => 160;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 160);
+    }
+    public struct Array161<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array160<T> _other;
+#pragma warning restore CS0169
+        public int Length => 161;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 161);
+    }
+    public struct Array162<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array161<T> _other;
+#pragma warning restore CS0169
+        public int Length => 162;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 162);
+    }
+    public struct Array163<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array162<T> _other;
+#pragma warning restore CS0169
+        public int Length => 163;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 163);
+    }
+    public struct Array164<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array163<T> _other;
+#pragma warning restore CS0169
+        public int Length => 164;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 164);
+    }
+    public struct Array165<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array164<T> _other;
+#pragma warning restore CS0169
+        public int Length => 165;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 165);
+    }
+    public struct Array166<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array165<T> _other;
+#pragma warning restore CS0169
+        public int Length => 166;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 166);
+    }
+    public struct Array167<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array166<T> _other;
+#pragma warning restore CS0169
+        public int Length => 167;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 167);
+    }
+    public struct Array168<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array167<T> _other;
+#pragma warning restore CS0169
+        public int Length => 168;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 168);
+    }
+    public struct Array169<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array168<T> _other;
+#pragma warning restore CS0169
+        public int Length => 169;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 169);
+    }
+    public struct Array170<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array169<T> _other;
+#pragma warning restore CS0169
+        public int Length => 170;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 170);
+    }
+    public struct Array171<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array170<T> _other;
+#pragma warning restore CS0169
+        public int Length => 171;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 171);
+    }
+    public struct Array172<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array171<T> _other;
+#pragma warning restore CS0169
+        public int Length => 172;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 172);
+    }
+    public struct Array173<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array172<T> _other;
+#pragma warning restore CS0169
+        public int Length => 173;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 173);
+    }
+    public struct Array174<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array173<T> _other;
+#pragma warning restore CS0169
+        public int Length => 174;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 174);
+    }
+    public struct Array175<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array174<T> _other;
+#pragma warning restore CS0169
+        public int Length => 175;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 175);
+    }
+    public struct Array176<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array175<T> _other;
+#pragma warning restore CS0169
+        public int Length => 176;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 176);
+    }
+    public struct Array177<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array176<T> _other;
+#pragma warning restore CS0169
+        public int Length => 177;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 177);
+    }
+    public struct Array178<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array177<T> _other;
+#pragma warning restore CS0169
+        public int Length => 178;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 178);
+    }
+    public struct Array179<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array178<T> _other;
+#pragma warning restore CS0169
+        public int Length => 179;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 179);
+    }
+    public struct Array180<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array179<T> _other;
+#pragma warning restore CS0169
+        public int Length => 180;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 180);
+    }
+    public struct Array181<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array180<T> _other;
+#pragma warning restore CS0169
+        public int Length => 181;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 181);
+    }
+    public struct Array182<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array181<T> _other;
+#pragma warning restore CS0169
+        public int Length => 182;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 182);
+    }
+    public struct Array183<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array182<T> _other;
+#pragma warning restore CS0169
+        public int Length => 183;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 183);
+    }
+    public struct Array184<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array183<T> _other;
+#pragma warning restore CS0169
+        public int Length => 184;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 184);
+    }
+    public struct Array185<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array184<T> _other;
+#pragma warning restore CS0169
+        public int Length => 185;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 185);
+    }
+    public struct Array186<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array185<T> _other;
+#pragma warning restore CS0169
+        public int Length => 186;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 186);
+    }
+    public struct Array187<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array186<T> _other;
+#pragma warning restore CS0169
+        public int Length => 187;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 187);
+    }
+    public struct Array188<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array187<T> _other;
+#pragma warning restore CS0169
+        public int Length => 188;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 188);
+    }
+    public struct Array189<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array188<T> _other;
+#pragma warning restore CS0169
+        public int Length => 189;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 189);
+    }
+    public struct Array190<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array189<T> _other;
+#pragma warning restore CS0169
+        public int Length => 190;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 190);
+    }
+    public struct Array191<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array190<T> _other;
+#pragma warning restore CS0169
+        public int Length => 191;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 191);
+    }
+    public struct Array192<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array191<T> _other;
+#pragma warning restore CS0169
+        public int Length => 192;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 192);
+    }
+    public struct Array193<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array192<T> _other;
+#pragma warning restore CS0169
+        public int Length => 193;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 193);
+    }
+    public struct Array194<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array193<T> _other;
+#pragma warning restore CS0169
+        public int Length => 194;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 194);
+    }
+    public struct Array195<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array194<T> _other;
+#pragma warning restore CS0169
+        public int Length => 195;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 195);
+    }
+    public struct Array196<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array195<T> _other;
+#pragma warning restore CS0169
+        public int Length => 196;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 196);
+    }
+    public struct Array197<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array196<T> _other;
+#pragma warning restore CS0169
+        public int Length => 197;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 197);
+    }
+    public struct Array198<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array197<T> _other;
+#pragma warning restore CS0169
+        public int Length => 198;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 198);
+    }
+    public struct Array199<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array198<T> _other;
+#pragma warning restore CS0169
+        public int Length => 199;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 199);
+    }
+    public struct Array200<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array199<T> _other;
+#pragma warning restore CS0169
+        public int Length => 200;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 200);
+    }
+    public struct Array201<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array200<T> _other;
+#pragma warning restore CS0169
+        public int Length => 201;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 201);
+    }
+    public struct Array202<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array201<T> _other;
+#pragma warning restore CS0169
+        public int Length => 202;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 202);
+    }
+    public struct Array203<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array202<T> _other;
+#pragma warning restore CS0169
+        public int Length => 203;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 203);
+    }
+    public struct Array204<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array203<T> _other;
+#pragma warning restore CS0169
+        public int Length => 204;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 204);
+    }
+    public struct Array205<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array204<T> _other;
+#pragma warning restore CS0169
+        public int Length => 205;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 205);
+    }
+    public struct Array206<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array205<T> _other;
+#pragma warning restore CS0169
+        public int Length => 206;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 206);
+    }
+    public struct Array207<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array206<T> _other;
+#pragma warning restore CS0169
+        public int Length => 207;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 207);
+    }
+    public struct Array208<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array207<T> _other;
+#pragma warning restore CS0169
+        public int Length => 208;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 208);
+    }
+    public struct Array209<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array208<T> _other;
+#pragma warning restore CS0169
+        public int Length => 209;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 209);
+    }
+    public struct Array210<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array209<T> _other;
+#pragma warning restore CS0169
+        public int Length => 210;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 210);
+    }
+    public struct Array211<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array210<T> _other;
+#pragma warning restore CS0169
+        public int Length => 211;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 211);
+    }
+    public struct Array212<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array211<T> _other;
+#pragma warning restore CS0169
+        public int Length => 212;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 212);
+    }
+    public struct Array213<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array212<T> _other;
+#pragma warning restore CS0169
+        public int Length => 213;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 213);
+    }
+    public struct Array214<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array213<T> _other;
+#pragma warning restore CS0169
+        public int Length => 214;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 214);
+    }
+    public struct Array215<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array214<T> _other;
+#pragma warning restore CS0169
+        public int Length => 215;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 215);
+    }
+    public struct Array216<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array215<T> _other;
+#pragma warning restore CS0169
+        public int Length => 216;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 216);
+    }
+    public struct Array217<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array216<T> _other;
+#pragma warning restore CS0169
+        public int Length => 217;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 217);
+    }
+    public struct Array218<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array217<T> _other;
+#pragma warning restore CS0169
+        public int Length => 218;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 218);
+    }
+    public struct Array219<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array218<T> _other;
+#pragma warning restore CS0169
+        public int Length => 219;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 219);
+    }
+    public struct Array220<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array219<T> _other;
+#pragma warning restore CS0169
+        public int Length => 220;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 220);
+    }
+    public struct Array221<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array220<T> _other;
+#pragma warning restore CS0169
+        public int Length => 221;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 221);
+    }
+    public struct Array222<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array221<T> _other;
+#pragma warning restore CS0169
+        public int Length => 222;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 222);
+    }
+    public struct Array223<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array222<T> _other;
+#pragma warning restore CS0169
+        public int Length => 223;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 223);
+    }
+    public struct Array224<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array223<T> _other;
+#pragma warning restore CS0169
+        public int Length => 224;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 224);
+    }
+    public struct Array225<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array224<T> _other;
+#pragma warning restore CS0169
+        public int Length => 225;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 225);
+    }
+    public struct Array226<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array225<T> _other;
+#pragma warning restore CS0169
+        public int Length => 226;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 226);
+    }
+    public struct Array227<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array226<T> _other;
+#pragma warning restore CS0169
+        public int Length => 227;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 227);
+    }
+    public struct Array228<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array227<T> _other;
+#pragma warning restore CS0169
+        public int Length => 228;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 228);
+    }
+    public struct Array229<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array228<T> _other;
+#pragma warning restore CS0169
+        public int Length => 229;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 229);
+    }
+    public struct Array230<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array229<T> _other;
+#pragma warning restore CS0169
+        public int Length => 230;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 230);
+    }
+    public struct Array231<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array230<T> _other;
+#pragma warning restore CS0169
+        public int Length => 231;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 231);
+    }
+    public struct Array232<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array231<T> _other;
+#pragma warning restore CS0169
+        public int Length => 232;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 232);
+    }
+    public struct Array233<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array232<T> _other;
+#pragma warning restore CS0169
+        public int Length => 233;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 233);
+    }
+    public struct Array234<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array233<T> _other;
+#pragma warning restore CS0169
+        public int Length => 234;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 234);
+    }
+    public struct Array235<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array234<T> _other;
+#pragma warning restore CS0169
+        public int Length => 235;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 235);
+    }
+    public struct Array236<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array235<T> _other;
+#pragma warning restore CS0169
+        public int Length => 236;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 236);
+    }
+    public struct Array237<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array236<T> _other;
+#pragma warning restore CS0169
+        public int Length => 237;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 237);
+    }
+    public struct Array238<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array237<T> _other;
+#pragma warning restore CS0169
+        public int Length => 238;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 238);
+    }
+    public struct Array239<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array238<T> _other;
+#pragma warning restore CS0169
+        public int Length => 239;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 239);
+    }
+    public struct Array240<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array239<T> _other;
+#pragma warning restore CS0169
+        public int Length => 240;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 240);
+    }
+    public struct Array241<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array240<T> _other;
+#pragma warning restore CS0169
+        public int Length => 241;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 241);
+    }
+    public struct Array242<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array241<T> _other;
+#pragma warning restore CS0169
+        public int Length => 242;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 242);
+    }
+    public struct Array243<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array242<T> _other;
+#pragma warning restore CS0169
+        public int Length => 243;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 243);
+    }
+    public struct Array244<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array243<T> _other;
+#pragma warning restore CS0169
+        public int Length => 244;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 244);
+    }
+    public struct Array245<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array244<T> _other;
+#pragma warning restore CS0169
+        public int Length => 245;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 245);
+    }
+    public struct Array246<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array245<T> _other;
+#pragma warning restore CS0169
+        public int Length => 246;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 246);
+    }
+    public struct Array247<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array246<T> _other;
+#pragma warning restore CS0169
+        public int Length => 247;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 247);
+    }
+    public struct Array248<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array247<T> _other;
+#pragma warning restore CS0169
+        public int Length => 248;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 248);
+    }
+    public struct Array249<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array248<T> _other;
+#pragma warning restore CS0169
+        public int Length => 249;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 249);
+    }
+    public struct Array250<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array249<T> _other;
+#pragma warning restore CS0169
+        public int Length => 250;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 250);
+    }
+    public struct Array251<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array250<T> _other;
+#pragma warning restore CS0169
+        public int Length => 251;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 251);
+    }
+    public struct Array252<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array251<T> _other;
+#pragma warning restore CS0169
+        public int Length => 252;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 252);
+    }
+    public struct Array253<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array252<T> _other;
+#pragma warning restore CS0169
+        public int Length => 253;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 253);
+    }
+    public struct Array254<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array253<T> _other;
+#pragma warning restore CS0169
+        public int Length => 254;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 254);
+    }
+    public struct Array255<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array254<T> _other;
+#pragma warning restore CS0169
+        public int Length => 255;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 255);
+    }
+    public struct Array256<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array255<T> _other;
+#pragma warning restore CS0169
+        public int Length => 256;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 256);
+    }
 }