Use span for some Astc helper methods

ds5678 · ds5678 · commit b3371b34d333 · 2023-09-17T00:19:01.000-04:00
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.cs
@@ -363,7 +363,7 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 					case 0:
 						fixed (int* endpoint = &pBlock.endpoints[cemOff])
 						{
-							SetEndpoint(endpoint, v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);
+							SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);
 						}
 						break;
 					case 1:
@@ -372,14 +372,14 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 							int l1 = Clamp(l0 + (v[1] & 0x3f));
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpoint(endpoint, l0, l0, l0, 255, l1, l1, l1, 255);
+								SetEndpoint(new Span<int>(endpoint, 8), l0, l0, l0, 255, l1, l1, l1, 255);
 							}
 						}
 						break;
 					case 4:
 						fixed (int* endpoint = &pBlock.endpoints[cemOff])
 						{
-							SetEndpoint(endpoint, v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);
+							SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);
 						}
 						break;
 					case 5:
@@ -388,28 +388,28 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 						v[1] += v[0];
 						fixed (int* endpoint = &pBlock.endpoints[cemOff])
 						{
-							SetEndpointClamp(endpoint, v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);
+							SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);
 						}
 						break;
 					case 6:
 						fixed (int* endpoint = &pBlock.endpoints[cemOff])
 						{
-							SetEndpoint(endpoint, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);
+							SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);
 						}
 						break;
 					case 8:
 						if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpoint(endpoint, v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);
+								SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);
 							}
 						}
 						else
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointBlue(endpoint, v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);
+								SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);
 							}
 						}
 
@@ -422,37 +422,37 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointClamp(endpoint, v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);
+								SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);
 							}
 						}
 						else
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointBlueClamp(endpoint, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);
+								SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);
 							}
 						}
 
 						break;
 					case 10:
 						fixed (int* endpoint = &pBlock.endpoints[cemOff])
 						{
-							SetEndpoint(endpoint, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);
+							SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);
 						}
 						break;
 					case 12:
 						if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpoint(endpoint, v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);
+								SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);
 							}
 						}
 						else
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointBlue(endpoint, v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);
+								SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);
 							}
 						}
 
@@ -466,14 +466,14 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointClamp(endpoint, v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);
+								SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);
 							}
 						}
 						else
 						{
 							fixed (int* endpoint = &pBlock.endpoints[cemOff])
 							{
-								SetEndpointBlueClamp(endpoint, v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);
+								SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);
 							}
 						}
 
@@ -914,26 +914,26 @@ private static ulong BitReverseU64(ulong d, int bits)
 			unchecked
 			{
 				ret =
-				   (ulong)BitReverseTable[(int)(d >> 0 & 0xff)] << 56 |
-				   (ulong)BitReverseTable[(int)(d >> 8 & 0xff)] << 48 |
-				   (ulong)BitReverseTable[(int)(d >> 16 & 0xff)] << 40 |
-				   (ulong)BitReverseTable[(int)(d >> 24 & 0xff)] << 32 |
-				   (ulong)BitReverseTable[(int)(d >> 32 & 0xff)] << 24 |
-				   (ulong)BitReverseTable[(int)(d >> 40 & 0xff)] << 16 |
-				   (ulong)BitReverseTable[(int)(d >> 48 & 0xff)] << 8 |
-				   (ulong)BitReverseTable[(int)(d >> 56 & 0xff)];
+					(ulong)BitReverseTable[(int)(d >> 0 & 0xff)] << 56 |
+					(ulong)BitReverseTable[(int)(d >> 8 & 0xff)] << 48 |
+					(ulong)BitReverseTable[(int)(d >> 16 & 0xff)] << 40 |
+					(ulong)BitReverseTable[(int)(d >> 24 & 0xff)] << 32 |
+					(ulong)BitReverseTable[(int)(d >> 32 & 0xff)] << 24 |
+					(ulong)BitReverseTable[(int)(d >> 40 & 0xff)] << 16 |
+					(ulong)BitReverseTable[(int)(d >> 48 & 0xff)] << 8 |
+					(ulong)BitReverseTable[(int)(d >> 56 & 0xff)];
 			}
 			return ret >> (64 - bits);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static int GetBits(ReadOnlySpan<byte> input, int bit, int len)
+		private static int GetBits(ReadOnlySpan<byte> input, int bit, int len)
 		{
 			return (BinaryPrimitives.ReadInt32LittleEndian(input[(bit / 8)..]) >> (bit % 8)) & ((1 << len) - 1);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static ulong GetBits64(ReadOnlySpan<byte> input, int bit, int len)
+		private static ulong GetBits64(ReadOnlySpan<byte> input, int bit, int len)
 		{
 			ulong mask = len == 64 ? 0xffffffffffffffff : (1UL << len) - 1;
 			if (len < 1)
@@ -976,7 +976,7 @@ private static unsafe void BitTransferSigned(int* a, int* b)
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static void SetEndpoint(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
+		private static void SetEndpoint(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
 		{
 			endpoint[0] = r1;
 			endpoint[1] = g1;
@@ -989,7 +989,7 @@ private unsafe static void SetEndpoint(int* endpoint, int r1, int g1, int b1, in
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static void SetEndpointClamp(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
+		private static void SetEndpointClamp(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
 		{
 			endpoint[0] = Clamp(r1);
 			endpoint[1] = Clamp(g1);
@@ -1002,7 +1002,7 @@ private unsafe static void SetEndpointClamp(int* endpoint, int r1, int g1, int b
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static void SetEndpointBlue(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
+		private static void SetEndpointBlue(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
 		{
 			endpoint[0] = (r1 + b1) >> 1;
 			endpoint[1] = (g1 + b1) >> 1;
@@ -1015,7 +1015,7 @@ private unsafe static void SetEndpointBlue(int* endpoint, int r1, int g1, int b1
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-		private unsafe static void SetEndpointBlueClamp(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
+		private static void SetEndpointBlueClamp(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)
 		{
 			endpoint[0] = Clamp((r1 + b1) >> 1);
 			endpoint[1] = Clamp((g1 + b1) >> 1);

Original file line number	Diff line number	Diff line change
`@@ -363,7 +363,7 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`363`	`363`	`case 0:`
`364`	`364`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`365`	`365`	`{`
`366`		`- SetEndpoint(endpoint, v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);`
	`366`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);`
`367`	`367`	`}`
`368`	`368`	`break;`
`369`	`369`	`case 1:`
`@@ -372,14 +372,14 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`372`	`372`	`int l1 = Clamp(l0 + (v[1] & 0x3f));`
`373`	`373`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`374`	`374`	`{`
`375`		`- SetEndpoint(endpoint, l0, l0, l0, 255, l1, l1, l1, 255);`
	`375`	`+ SetEndpoint(new Span<int>(endpoint, 8), l0, l0, l0, 255, l1, l1, l1, 255);`
`376`	`376`	`}`
`377`	`377`	`}`
`378`	`378`	`break;`
`379`	`379`	`case 4:`
`380`	`380`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`381`	`381`	`{`
`382`		`- SetEndpoint(endpoint, v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);`
	`382`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);`
`383`	`383`	`}`
`384`	`384`	`break;`
`385`	`385`	`case 5:`
`@@ -388,28 +388,28 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`388`	`388`	`v[1] += v[0];`
`389`	`389`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`390`	`390`	`{`
`391`		`- SetEndpointClamp(endpoint, v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);`
	`391`	`+ SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);`
`392`	`392`	`}`
`393`	`393`	`break;`
`394`	`394`	`case 6:`
`395`	`395`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`396`	`396`	`{`
`397`		`- SetEndpoint(endpoint, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);`
	`397`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);`
`398`	`398`	`}`
`399`	`399`	`break;`
`400`	`400`	`case 8:`
`401`	`401`	`if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])`
`402`	`402`	`{`
`403`	`403`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`404`	`404`	`{`
`405`		`- SetEndpoint(endpoint, v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);`
	`405`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`	`else`
`409`	`409`	`{`
`410`	`410`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`411`	`411`	`{`
`412`		`- SetEndpointBlue(endpoint, v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);`
	`412`	`+ SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);`
`413`	`413`	`}`
`414`	`414`	`}`
`415`	`415`
`@@ -422,37 +422,37 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`422`	`422`	`{`
`423`	`423`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`424`	`424`	`{`
`425`		`- SetEndpointClamp(endpoint, v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);`
	`425`	`+ SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);`
`426`	`426`	`}`
`427`	`427`	`}`
`428`	`428`	`else`
`429`	`429`	`{`
`430`	`430`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`431`	`431`	`{`
`432`		`- SetEndpointBlueClamp(endpoint, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);`
	`432`	`+ SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);`
`433`	`433`	`}`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`break;`
`437`	`437`	`case 10:`
`438`	`438`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`439`	`439`	`{`
`440`		`- SetEndpoint(endpoint, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);`
	`440`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);`
`441`	`441`	`}`
`442`	`442`	`break;`
`443`	`443`	`case 12:`
`444`	`444`	`if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])`
`445`	`445`	`{`
`446`	`446`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`447`	`447`	`{`
`448`		`- SetEndpoint(endpoint, v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);`
	`448`	`+ SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);`
`449`	`449`	`}`
`450`	`450`	`}`
`451`	`451`	`else`
`452`	`452`	`{`
`453`	`453`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`454`	`454`	`{`
`455`		`- SetEndpointBlue(endpoint, v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);`
	`455`	`+ SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);`
`456`	`456`	`}`
`457`	`457`	`}`
`458`	`458`
`@@ -466,14 +466,14 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`466`	`466`	`{`
`467`	`467`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`468`	`468`	`{`
`469`		`- SetEndpointClamp(endpoint, v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);`
	`469`	`+ SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);`
`470`	`470`	`}`
`471`	`471`	`}`
`472`	`472`	`else`
`473`	`473`	`{`
`474`	`474`	`fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`475`	`475`	`{`
`476`		`- SetEndpointBlueClamp(endpoint, v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);`
	`476`	`+ SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);`
`477`	`477`	`}`
`478`	`478`	`}`
`479`	`479`
`@@ -914,26 +914,26 @@ private static ulong BitReverseU64(ulong d, int bits)`
`914`	`914`	`unchecked`
`915`	`915`	`{`
`916`	`916`	`ret =`
`917`		`- (ulong)BitReverseTable[(int)(d >> 0 & 0xff)] << 56 \|`
`918`		`- (ulong)BitReverseTable[(int)(d >> 8 & 0xff)] << 48 \|`
`919`		`- (ulong)BitReverseTable[(int)(d >> 16 & 0xff)] << 40 \|`
`920`		`- (ulong)BitReverseTable[(int)(d >> 24 & 0xff)] << 32 \|`
`921`		`- (ulong)BitReverseTable[(int)(d >> 32 & 0xff)] << 24 \|`
`922`		`- (ulong)BitReverseTable[(int)(d >> 40 & 0xff)] << 16 \|`
`923`		`- (ulong)BitReverseTable[(int)(d >> 48 & 0xff)] << 8 \|`
`924`		`- (ulong)BitReverseTable[(int)(d >> 56 & 0xff)];`
	`917`	`+ (ulong)BitReverseTable[(int)(d >> 0 & 0xff)] << 56 \|`
	`918`	`+ (ulong)BitReverseTable[(int)(d >> 8 & 0xff)] << 48 \|`
	`919`	`+ (ulong)BitReverseTable[(int)(d >> 16 & 0xff)] << 40 \|`
	`920`	`+ (ulong)BitReverseTable[(int)(d >> 24 & 0xff)] << 32 \|`
	`921`	`+ (ulong)BitReverseTable[(int)(d >> 32 & 0xff)] << 24 \|`
	`922`	`+ (ulong)BitReverseTable[(int)(d >> 40 & 0xff)] << 16 \|`
	`923`	`+ (ulong)BitReverseTable[(int)(d >> 48 & 0xff)] << 8 \|`
	`924`	`+ (ulong)BitReverseTable[(int)(d >> 56 & 0xff)];`
`925`	`925`	`}`
`926`	`926`	`return ret >> (64 - bits);`
`927`	`927`	`}`
`928`	`928`
`929`	`929`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`930`		`- private unsafe static int GetBits(ReadOnlySpan<byte> input, int bit, int len)`
	`930`	`+ private static int GetBits(ReadOnlySpan<byte> input, int bit, int len)`
`931`	`931`	`{`
`932`	`932`	`return (BinaryPrimitives.ReadInt32LittleEndian(input[(bit / 8)..]) >> (bit % 8)) & ((1 << len) - 1);`
`933`	`933`	`}`
`934`	`934`
`935`	`935`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`936`		`- private unsafe static ulong GetBits64(ReadOnlySpan<byte> input, int bit, int len)`
	`936`	`+ private static ulong GetBits64(ReadOnlySpan<byte> input, int bit, int len)`
`937`	`937`	`{`
`938`	`938`	`ulong mask = len == 64 ? 0xffffffffffffffff : (1UL << len) - 1;`
`939`	`939`	`if (len < 1)`
`@@ -976,7 +976,7 @@ private static unsafe void BitTransferSigned(int* a, int* b)`
`976`	`976`	`}`
`977`	`977`
`978`	`978`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`979`		`- private unsafe static void SetEndpoint(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
	`979`	`+ private static void SetEndpoint(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
`980`	`980`	`{`
`981`	`981`	`endpoint[0] = r1;`
`982`	`982`	`endpoint[1] = g1;`
`@@ -989,7 +989,7 @@ private unsafe static void SetEndpoint(int* endpoint, int r1, int g1, int b1, in`
`989`	`989`	`}`
`990`	`990`
`991`	`991`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`992`		`- private unsafe static void SetEndpointClamp(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
	`992`	`+ private static void SetEndpointClamp(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
`993`	`993`	`{`
`994`	`994`	`endpoint[0] = Clamp(r1);`
`995`	`995`	`endpoint[1] = Clamp(g1);`
`@@ -1002,7 +1002,7 @@ private unsafe static void SetEndpointClamp(int* endpoint, int r1, int g1, int b`
`1002`	`1002`	`}`
`1003`	`1003`
`1004`	`1004`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`1005`		`- private unsafe static void SetEndpointBlue(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
	`1005`	`+ private static void SetEndpointBlue(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
`1006`	`1006`	`{`
`1007`	`1007`	`endpoint[0] = (r1 + b1) >> 1;`
`1008`	`1008`	`endpoint[1] = (g1 + b1) >> 1;`
`@@ -1015,7 +1015,7 @@ private unsafe static void SetEndpointBlue(int* endpoint, int r1, int g1, int b1`
`1015`	`1015`	`}`
`1016`	`1016`
`1017`	`1017`	`[MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
`1018`		`- private unsafe static void SetEndpointBlueClamp(int* endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
	`1018`	`+ private static void SetEndpointBlueClamp(Span<int> endpoint, int r1, int g1, int b1, int a1, int r2, int g2, int b2, int a2)`
`1019`	`1019`	`{`
`1020`	`1020`	`endpoint[0] = Clamp((r1 + b1) >> 1);`
`1021`	`1021`	`endpoint[1] = Clamp((g1 + b1) >> 1);`