some fixes to the AVX kernel

Daniel Lemire · Daniel Lemire · commit b1852074e2bf · 2024-09-03T19:23:56.000-04:00
diff --git a/README.md b/README.md
@@ -71,7 +71,7 @@ To run just one benchmark, use a filter:
 
 ```
 cd benchmark
-dotnet run --configuration Release --filter "*somefilter*"
+dotnet run -c Release --filter "SimdUnicodeBenchmarks.RealDataBenchmark.AVX2DecodingRealDataUTF8(FileName: \"data/email/\")"
 ```
 
 If you are under macOS or Linux, you may want to run the benchmarks in privileged mode:
diff --git a/src/Base64AVX2UTF16.cs b/src/Base64AVX2UTF16.cs
@@ -192,8 +192,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                     // There is at some bytes remaining beyond the last 64 bit block remaining
                     if (lastBlock != 0 && srcEnd - src + lastBlock >= 64) // We first check if there is any error and eliminate white spaces?:
                     {
-
-                        // int lastBlockSrcCount = 0;
                         while ((bufferPtr - startOfBuffer) % 64 != 0 && src < srcEnd) 
                         {
                             if (!SimdBase64.Scalar.Base64.IsValidBase64Index(*src))
@@ -247,7 +245,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                         {
                             Base64DecodeBlock(dst, subBufferPtr);
                         }
-                        // bufferBytesWritten += 48;
                         dst += 48;// 64 bits of base64 decodes to 48 bits
                     }
                     if ((bufferPtr - subBufferPtr) % 64 != 0)
@@ -302,8 +299,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                 }
                                 subBufferPtr[leftover] = (byte)(val);
                                 leftover += (val <= 63) ? 1 : 0;
-
-                                // bufferBytesConsumed +=1;
                                 src++;
                             }
 
@@ -356,20 +351,12 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                         bytesConsumed = (int)(src - srcInit);
                         bytesWritten = (int)(dst - dstInit);
 
-                        // bytesConsumed = Math.Max(0,(int)(src - srcInit) - (int)bufferBytesConsumed);
-                        // bytesWritten = Math.Max(0,(int)(dst - dstInit)  - (int)bufferBytesWritten);
-
-
-
                         int remainderBytesConsumed = 0;
                         int remainderBytesWritten = 0;
 
                         OperationStatus result =
                             SimdBase64.Scalar.Base64.Base64WithWhiteSpaceToBinaryScalar(source.Slice(bytesConsumed), dest.Slice(bytesWritten), out remainderBytesConsumed, out remainderBytesWritten, isUrl);
 
-
-
-
                         if (result == OperationStatus.InvalidData)
                         {
                             bytesConsumed += remainderBytesConsumed;
diff --git a/src/Base64AVX2UTF8.cs b/src/Base64AVX2UTF8.cs
@@ -6,25 +6,41 @@
 using System.Buffers;
 using System.Buffers.Binary;
 
+
+using System.Text;
 namespace SimdBase64
 {
     namespace AVX2
     {
         public static partial class Base64
         {
-            /*
+            
             // If needed for debugging, you can do the following:
+            /*
             static string VectorToString(Vector256<byte> vector)
             {
-                Span<byte> bytes = new byte[16];
+                Span<byte> bytes = new byte[32];
                 vector.CopyTo(bytes);
                 StringBuilder sb = new StringBuilder();
                 foreach (byte b in bytes)
                 {
                     sb.Append(b.ToString("X2") + " ");
                 }
                 return sb.ToString().TrimEnd();
-            }*/
+            }
+
+            static string VectorToStringChar(Vector256<byte> vector)
+            {
+                Span<byte> bytes = new byte[32];
+                vector.CopyTo(bytes);
+                StringBuilder sb = new StringBuilder();
+                foreach (byte b in bytes)
+                {
+                    sb.Append((char)b);
+                }
+                return sb.ToString().TrimEnd();
+            }
+            */
 
             [StructLayout(LayoutKind.Sequential)]
             private struct Block64
@@ -60,14 +76,15 @@ private unsafe static void LoadBlock(Block64* b, char* src)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private static unsafe UInt64 ToBase64Mask(bool base64Url, Block64* b, ref bool error)
             {
-                ulong m0 = ToBase64Mask(base64Url, ref b->chunk0, ref error);
-                ulong m1 = ToBase64Mask(base64Url, ref b->chunk1, ref error);
+                UInt64 m0 = ToBase64Mask(base64Url, ref b->chunk0, ref error);
+                UInt64 m1 = ToBase64Mask(base64Url, ref b->chunk1, ref error);
                 return m0 | (m1 << 32);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private static ushort ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref bool error)
+            private static UInt64 ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref bool error)
             {
+
                 Vector256<sbyte> asciiSpaceTbl = Vector256.Create(
                            0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xa,
                            0x0, 0xc, 0xd, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0,
@@ -137,18 +154,19 @@ private static ushort ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref
                 Vector256<sbyte> outVector = Avx2.AddSaturate(Avx2.Shuffle(deltaValues.AsByte(), deltaHash).AsSByte(),
                                                             src.AsSByte());
 
-                Vector256<byte> chkVector = Avx2.AddSaturate(Avx2.Shuffle(checkValues.AsByte(), checkHash).AsByte(),
-                                                src.AsByte());
+                Vector256<sbyte> chkVector = Avx2.AddSaturate(Avx2.Shuffle(checkValues.AsByte(), checkHash).AsSByte(),
+                                                src.AsSByte());
 
-                int mask = Avx2.MoveMask(chkVector.AsByte());
+                UInt32 mask = (uint)Avx2.MoveMask(chkVector.AsByte());
                 if (mask != 0)
                 {
                     Vector256<byte> asciiSpace = Avx2.CompareEqual(Avx2.Shuffle(asciiSpaceTbl.AsByte(), src), src);
-                    error |= (mask != Avx2.MoveMask(asciiSpace));
+                    UInt32 spaces = (uint)Avx2.MoveMask(asciiSpace);
+                    error |= (mask != spaces);
                 }
 
                 src = outVector.AsByte();
-                return (ushort)mask;
+                return (UInt64)mask;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -260,7 +278,6 @@ private unsafe static void Base64Decode(byte* output, Vector256<byte> input)
                 Vector256<byte> t2 = Avx2.Shuffle(t1.AsSByte(), packShuffle).AsByte();
 
                 // Store the output. This writes 16 bytes, but we only need 12.
-                // Avx2.Store(output, t2);
                 Sse2.Store(output, t2.GetLower());
                 Sse2.Store(output + 12, t2.GetUpper());
             }
@@ -290,7 +307,7 @@ private static unsafe void Base64DecodeBlockSafe(byte* outPtr, byte* srcPtr)
                 {
                     // Copy only the first 12 bytes of the decoded fourth block into the output buffer, offset by 36 bytes.
                     // This step is necessary because the fourth block may not need all 16 bytes if it contains padding characters.
-                    Buffer.MemoryCopy(bufferPtr, outPtr + 24, 24, 24);// DEGUG:Uncomment
+                    Buffer.MemoryCopy(bufferPtr, outPtr + 24, 24, 24);
                 }
             }
 
@@ -412,7 +429,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                 }
                                 else if (bufferPtr != startOfBuffer)
                                 {
-
                                     CopyBlock(&b, bufferPtr);
                                     bufferPtr += 64;
                                     bufferBytesConsumed += 64;
@@ -421,14 +437,10 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                 {
                                     if (dst >= endOfSafe64ByteZone)
                                     {
-
-
                                         Base64DecodeBlockSafe(dst, &b);
                                     }
                                     else
                                     {
-
-
                                         Base64DecodeBlock(dst, &b);
                                     }
                                     bufferBytesWritten += 48;
@@ -452,8 +464,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                         Base64DecodeBlock(dst, startOfBuffer + (blocksSize - 2) * 64);
                                     }
 
-
-
                                     dst += 48;
                                     Buffer.MemoryCopy(startOfBuffer + (blocksSize - 1) * 64, startOfBuffer, 64, 64);
                                     bufferPtr -= (blocksSize - 1) * 64;
@@ -467,14 +477,11 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                         // Optimization note: if this is almost full, then it is worth our
                         // time, otherwise, we should just decode directly.
 
-
                         int lastBlock = (int)((bufferPtr - startOfBuffer) % 64);
                         int lastBlockSrcCount = 0;
                         // There is at some bytes remaining beyond the last 64 bit block remaining
                         if (lastBlock != 0 && srcEnd - src + lastBlock >= 64) // We first check if there is any error and eliminate white spaces?:
                         {
-
-                            // int lastBlockSrcCount = 0;
                             while ((bufferPtr - startOfBuffer) % 64 != 0 && src < srcEnd)
                             {
                                 byte val = toBase64[(int)*src];
@@ -513,8 +520,7 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                             {
                                 Base64DecodeBlock(dst, subBufferPtr);
                             }
-                            // bufferBytesWritten += 48;
-                            dst += 48;// 64 bits of base64 decodes to 48 bits
+                            dst += 48; // 64 bits of base64 decodes to 48 bits
                         }
                         if ((bufferPtr - subBufferPtr) % 64 != 0)
                         {
@@ -528,29 +534,24 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                                     << 8;
                                 triple = BinaryPrimitives.ReverseEndianness(triple);
                                 Buffer.MemoryCopy(&triple, dst, 4, 4);
-
                                 dst += 3;
                                 subBufferPtr += 4;
                             }
                             if (subBufferPtr + 4 <= bufferPtr) // this may be the very last element, might be incomplete
                             {
-
-
                                 UInt32 triple = (((UInt32)((byte)(subBufferPtr[0])) << 3 * 6) +
                                                     ((UInt32)((byte)(subBufferPtr[1])) << 2 * 6) +
                                                     ((UInt32)((byte)(subBufferPtr[2])) << 1 * 6) +
                                                     ((UInt32)((byte)(subBufferPtr[3])) << 0 * 6))
                                                     << 8;
                                 triple = BinaryPrimitives.ReverseEndianness(triple);
                                 Buffer.MemoryCopy(&triple, dst, 3, 3);
-
                                 dst += 3;
                                 subBufferPtr += 4;
                             }
                             int leftover = (int)(bufferPtr - subBufferPtr);
                             if (leftover > 0)
                             {
-
                                 while (leftover < 4 && src < srcEnd)
                                 {
                                     byte val = toBase64[(byte)*src];
@@ -562,8 +563,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                                     }
                                     subBufferPtr[leftover] = (byte)(val);
                                     leftover += (val <= 63) ? 1 : 0;
-
-                                    // bufferBytesConsumed +=1;
                                     src++;
                                 }
 
@@ -610,7 +609,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS
                             }
                         }
 
-
                         if (src < srcEnd + equalsigns) // We finished processing 64-bit blocks, we're not quite at the end yet
                         {
                             bytesConsumed = (int)(src - srcInit);

Original file line number	Diff line number	Diff line change
`@@ -192,8 +192,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`192`	`192`	`// There is at some bytes remaining beyond the last 64 bit block remaining`
`193`	`193`	`if (lastBlock != 0 && srcEnd - src + lastBlock >= 64) // We first check if there is any error and eliminate white spaces?:`
`194`	`194`	`{`
`195`		`-`
`196`		`- // int lastBlockSrcCount = 0;`
`197`	`195`	`while ((bufferPtr - startOfBuffer) % 64 != 0 && src < srcEnd)`
`198`	`196`	`{`
`199`	`197`	`if (!SimdBase64.Scalar.Base64.IsValidBase64Index(*src))`
`@@ -247,7 +245,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`247`	`245`	`{`
`248`	`246`	`Base64DecodeBlock(dst, subBufferPtr);`
`249`	`247`	`}`
`250`		`- // bufferBytesWritten += 48;`
`251`	`248`	`dst += 48;// 64 bits of base64 decodes to 48 bits`
`252`	`249`	`}`
`253`	`250`	`if ((bufferPtr - subBufferPtr) % 64 != 0)`
`@@ -302,8 +299,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`302`	`299`	`}`
`303`	`300`	`subBufferPtr[leftover] = (byte)(val);`
`304`	`301`	`leftover += (val <= 63) ? 1 : 0;`
`305`		`-`
`306`		`- // bufferBytesConsumed +=1;`
`307`	`302`	`src++;`
`308`	`303`	`}`
`309`	`304`
`@@ -356,20 +351,12 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`356`	`351`	`bytesConsumed = (int)(src - srcInit);`
`357`	`352`	`bytesWritten = (int)(dst - dstInit);`
`358`	`353`
`359`		`- // bytesConsumed = Math.Max(0,(int)(src - srcInit) - (int)bufferBytesConsumed);`
`360`		`- // bytesWritten = Math.Max(0,(int)(dst - dstInit) - (int)bufferBytesWritten);`
`361`		`-`
`362`		`-`
`363`		`-`
`364`	`354`	`int remainderBytesConsumed = 0;`
`365`	`355`	`int remainderBytesWritten = 0;`
`366`	`356`
`367`	`357`	`OperationStatus result =`
`368`	`358`	`SimdBase64.Scalar.Base64.Base64WithWhiteSpaceToBinaryScalar(source.Slice(bytesConsumed), dest.Slice(bytesWritten), out remainderBytesConsumed, out remainderBytesWritten, isUrl);`
`369`	`359`
`370`		`-`
`371`		`-`
`372`		`-`
`373`	`360`	`if (result == OperationStatus.InvalidData)`
`374`	`361`	`{`
`375`	`362`	`bytesConsumed += remainderBytesConsumed;`
Original file line number	Diff line number	Diff line change
`@@ -6,25 +6,41 @@`
`6`	`6`	`using System.Buffers;`
`7`	`7`	`using System.Buffers.Binary;`
`8`	`8`
	`9`	`+`
	`10`	`+using System.Text;`
`9`	`11`	`namespace SimdBase64`
`10`	`12`	`{`
`11`	`13`	`namespace AVX2`
`12`	`14`	`{`
`13`	`15`	`public static partial class Base64`
`14`	`16`	`{`
`15`		`- /*`
	`17`	`+`
`16`	`18`	`// If needed for debugging, you can do the following:`
	`19`	`+ /*`
`17`	`20`	`static string VectorToString(Vector256<byte> vector)`
`18`	`21`	`{`
`19`		`- Span<byte> bytes = new byte[16];`
	`22`	`+ Span<byte> bytes = new byte[32];`
`20`	`23`	`vector.CopyTo(bytes);`
`21`	`24`	`StringBuilder sb = new StringBuilder();`
`22`	`25`	`foreach (byte b in bytes)`
`23`	`26`	`{`
`24`	`27`	`sb.Append(b.ToString("X2") + " ");`
`25`	`28`	`}`
`26`	`29`	`return sb.ToString().TrimEnd();`
`27`		`- }*/`
	`30`	`+ }`
	`31`	`+`
	`32`	`+ static string VectorToStringChar(Vector256<byte> vector)`
	`33`	`+ {`
	`34`	`+ Span<byte> bytes = new byte[32];`
	`35`	`+ vector.CopyTo(bytes);`
	`36`	`+ StringBuilder sb = new StringBuilder();`
	`37`	`+ foreach (byte b in bytes)`
	`38`	`+ {`
	`39`	`+ sb.Append((char)b);`
	`40`	`+ }`
	`41`	`+ return sb.ToString().TrimEnd();`
	`42`	`+ }`
	`43`	`+ */`
`28`	`44`
`29`	`45`	`[StructLayout(LayoutKind.Sequential)]`
`30`	`46`	`private struct Block64`
`@@ -60,14 +76,15 @@ private unsafe static void LoadBlock(Block64* b, char* src)`
`60`	`76`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`61`	`77`	`private static unsafe UInt64 ToBase64Mask(bool base64Url, Block64* b, ref bool error)`
`62`	`78`	`{`
`63`		`- ulong m0 = ToBase64Mask(base64Url, ref b->chunk0, ref error);`
`64`		`- ulong m1 = ToBase64Mask(base64Url, ref b->chunk1, ref error);`
	`79`	`+ UInt64 m0 = ToBase64Mask(base64Url, ref b->chunk0, ref error);`
	`80`	`+ UInt64 m1 = ToBase64Mask(base64Url, ref b->chunk1, ref error);`
`65`	`81`	`return m0 \| (m1 << 32);`
`66`	`82`	`}`
`67`	`83`
`68`	`84`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`69`		`- private static ushort ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref bool error)`
	`85`	`+ private static UInt64 ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref bool error)`
`70`	`86`	`{`
	`87`	`+`
`71`	`88`	`Vector256<sbyte> asciiSpaceTbl = Vector256.Create(`
`72`	`89`	`0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xa,`
`73`	`90`	`0x0, 0xc, 0xd, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0,`
`@@ -137,18 +154,19 @@ private static ushort ToBase64Mask(bool base64Url, ref Vector256<byte> src, ref`
`137`	`154`	`Vector256<sbyte> outVector = Avx2.AddSaturate(Avx2.Shuffle(deltaValues.AsByte(), deltaHash).AsSByte(),`
`138`	`155`	`src.AsSByte());`
`139`	`156`
`140`		`- Vector256<byte> chkVector = Avx2.AddSaturate(Avx2.Shuffle(checkValues.AsByte(), checkHash).AsByte(),`
`141`		`- src.AsByte());`
	`157`	`+ Vector256<sbyte> chkVector = Avx2.AddSaturate(Avx2.Shuffle(checkValues.AsByte(), checkHash).AsSByte(),`
	`158`	`+ src.AsSByte());`
`142`	`159`
`143`		`- int mask = Avx2.MoveMask(chkVector.AsByte());`
	`160`	`+ UInt32 mask = (uint)Avx2.MoveMask(chkVector.AsByte());`
`144`	`161`	`if (mask != 0)`
`145`	`162`	`{`
`146`	`163`	`Vector256<byte> asciiSpace = Avx2.CompareEqual(Avx2.Shuffle(asciiSpaceTbl.AsByte(), src), src);`
`147`		`- error \|= (mask != Avx2.MoveMask(asciiSpace));`
	`164`	`+ UInt32 spaces = (uint)Avx2.MoveMask(asciiSpace);`
	`165`	`+ error \|= (mask != spaces);`
`148`	`166`	`}`
`149`	`167`
`150`	`168`	`src = outVector.AsByte();`
`151`		`- return (ushort)mask;`
	`169`	`+ return (UInt64)mask;`
`152`	`170`	`}`
`153`	`171`
`154`	`172`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`@@ -260,7 +278,6 @@ private unsafe static void Base64Decode(byte* output, Vector256<byte> input)`
`260`	`278`	`Vector256<byte> t2 = Avx2.Shuffle(t1.AsSByte(), packShuffle).AsByte();`
`261`	`279`
`262`	`280`	`// Store the output. This writes 16 bytes, but we only need 12.`
`263`		`- // Avx2.Store(output, t2);`
`264`	`281`	`Sse2.Store(output, t2.GetLower());`
`265`	`282`	`Sse2.Store(output + 12, t2.GetUpper());`
`266`	`283`	`}`
`@@ -290,7 +307,7 @@ private static unsafe void Base64DecodeBlockSafe(byte* outPtr, byte* srcPtr)`
`290`	`307`	`{`
`291`	`308`	`// Copy only the first 12 bytes of the decoded fourth block into the output buffer, offset by 36 bytes.`
`292`	`309`	`// This step is necessary because the fourth block may not need all 16 bytes if it contains padding characters.`
`293`		`- Buffer.MemoryCopy(bufferPtr, outPtr + 24, 24, 24);// DEGUG:Uncomment`
	`310`	`+ Buffer.MemoryCopy(bufferPtr, outPtr + 24, 24, 24);`
`294`	`311`	`}`
`295`	`312`	`}`
`296`	`313`
`@@ -412,7 +429,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`412`	`429`	`}`
`413`	`430`	`else if (bufferPtr != startOfBuffer)`
`414`	`431`	`{`
`415`		`-`
`416`	`432`	`CopyBlock(&b, bufferPtr);`
`417`	`433`	`bufferPtr += 64;`
`418`	`434`	`bufferBytesConsumed += 64;`
`@@ -421,14 +437,10 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`421`	`437`	`{`
`422`	`438`	`if (dst >= endOfSafe64ByteZone)`
`423`	`439`	`{`
`424`		`-`
`425`		`-`
`426`	`440`	`Base64DecodeBlockSafe(dst, &b);`
`427`	`441`	`}`
`428`	`442`	`else`
`429`	`443`	`{`
`430`		`-`
`431`		`-`
`432`	`444`	`Base64DecodeBlock(dst, &b);`
`433`	`445`	`}`
`434`	`446`	`bufferBytesWritten += 48;`
`@@ -452,8 +464,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`452`	`464`	`Base64DecodeBlock(dst, startOfBuffer + (blocksSize - 2) * 64);`
`453`	`465`	`}`
`454`	`466`
`455`		`-`
`456`		`-`
`457`	`467`	`dst += 48;`
`458`	`468`	`Buffer.MemoryCopy(startOfBuffer + (blocksSize - 1) * 64, startOfBuffer, 64, 64);`
`459`	`469`	`bufferPtr -= (blocksSize - 1) * 64;`
`@@ -467,14 +477,11 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`467`	`477`	`// Optimization note: if this is almost full, then it is worth our`
`468`	`478`	`// time, otherwise, we should just decode directly.`
`469`	`479`
`470`		`-`
`471`	`480`	`int lastBlock = (int)((bufferPtr - startOfBuffer) % 64);`
`472`	`481`	`int lastBlockSrcCount = 0;`
`473`	`482`	`// There is at some bytes remaining beyond the last 64 bit block remaining`
`474`	`483`	`if (lastBlock != 0 && srcEnd - src + lastBlock >= 64) // We first check if there is any error and eliminate white spaces?:`
`475`	`484`	`{`
`476`		`-`
`477`		`- // int lastBlockSrcCount = 0;`
`478`	`485`	`while ((bufferPtr - startOfBuffer) % 64 != 0 && src < srcEnd)`
`479`	`486`	`{`
`480`	`487`	`byte val = toBase64[(int)*src];`
`@@ -513,8 +520,7 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`513`	`520`	`{`
`514`	`521`	`Base64DecodeBlock(dst, subBufferPtr);`
`515`	`522`	`}`
`516`		`- // bufferBytesWritten += 48;`
`517`		`- dst += 48;// 64 bits of base64 decodes to 48 bits`
	`523`	`+ dst += 48; // 64 bits of base64 decodes to 48 bits`
`518`	`524`	`}`
`519`	`525`	`if ((bufferPtr - subBufferPtr) % 64 != 0)`
`520`	`526`	`{`
`@@ -528,29 +534,24 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`528`	`534`	`<< 8;`
`529`	`535`	`triple = BinaryPrimitives.ReverseEndianness(triple);`
`530`	`536`	`Buffer.MemoryCopy(&triple, dst, 4, 4);`
`531`		`-`
`532`	`537`	`dst += 3;`
`533`	`538`	`subBufferPtr += 4;`
`534`	`539`	`}`
`535`	`540`	`if (subBufferPtr + 4 <= bufferPtr) // this may be the very last element, might be incomplete`
`536`	`541`	`{`
`537`		`-`
`538`		`-`
`539`	`542`	`UInt32 triple = (((UInt32)((byte)(subBufferPtr[0])) << 3 * 6) +`
`540`	`543`	`((UInt32)((byte)(subBufferPtr[1])) << 2 * 6) +`
`541`	`544`	`((UInt32)((byte)(subBufferPtr[2])) << 1 * 6) +`
`542`	`545`	`((UInt32)((byte)(subBufferPtr[3])) << 0 * 6))`
`543`	`546`	`<< 8;`
`544`	`547`	`triple = BinaryPrimitives.ReverseEndianness(triple);`
`545`	`548`	`Buffer.MemoryCopy(&triple, dst, 3, 3);`
`546`		`-`
`547`	`549`	`dst += 3;`
`548`	`550`	`subBufferPtr += 4;`
`549`	`551`	`}`
`550`	`552`	`int leftover = (int)(bufferPtr - subBufferPtr);`
`551`	`553`	`if (leftover > 0)`
`552`	`554`	`{`
`553`		`-`
`554`	`555`	`while (leftover < 4 && src < srcEnd)`
`555`	`556`	`{`
`556`	`557`	`byte val = toBase64[(byte)*src];`
`@@ -562,8 +563,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`562`	`563`	`}`
`563`	`564`	`subBufferPtr[leftover] = (byte)(val);`
`564`	`565`	`leftover += (val <= 63) ? 1 : 0;`
`565`		`-`
`566`		`- // bufferBytesConsumed +=1;`
`567`	`566`	`src++;`
`568`	`567`	`}`
`569`	`568`
`@@ -610,7 +609,6 @@ private unsafe static OperationStatus InnerDecodeFromBase64AVX2Regular(ReadOnlyS`
`610`	`609`	`}`
`611`	`610`	`}`
`612`	`611`
`613`		`-`
`614`	`612`	`if (src < srcEnd + equalsigns) // We finished processing 64-bit blocks, we're not quite at the end yet`
`615`	`613`	`{`
`616`	`614`	`bytesConsumed = (int)(src - srcInit);`