making some of the arm code prettier

Author: lemire

src/UTF8.cs

@@ -1364,13 +1364,13 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                     {
 
                         Vector128<byte> currentBlock = AdvSimd.LoadVector128(pInputBuffer + processedLength);
-                        if (AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(AdvSimd.And(currentBlock, v80))).ToScalar() == 0)
+                        if ((currentBlock & v80) == Vector128<byte>.Zero)
                         // We could also use (AdvSimd.Arm64.MaxAcross(currentBlock).ToScalar() <= 127) but it is slower on some
                         // hardware.
                         {
                             // We have an ASCII block, no need to process it, but
                             // we need to check if the previous block was incomplete.
-                            if (AdvSimd.Arm64.MaxAcross(prevIncomplete).ToScalar() != 0)
+                            if (prevIncomplete != Vector128<byte>.Zero)
                             {
                                 int off = processedLength >= 3 ? processedLength - 3 : processedLength;
                                 byte* invalidBytePointer = SimdUnicode.UTF8.SimpleRewindAndValidateWithErrors(16 - 3, pInputBuffer + processedLength - 3, inputLength - processedLength + 3);
@@ -1404,7 +1404,7 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                                         Vector128<byte> block4 = AdvSimd.LoadVector128(pInputBuffer + processedLength + localasciirun + 48);
                                         Vector128<byte> or = AdvSimd.Or(AdvSimd.Or(block1, block2), AdvSimd.Or(block3, block4));
 
-                                        if (AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(AdvSimd.And(or, v80))).ToScalar() != 0)
+                                        if ((or & v80) != Vector128<byte>.Zero)
                                         {
                                             break;
                                         }
@@ -1435,7 +1435,7 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                             // AdvSimd.Arm64.MaxAcross(error) works, but it might be slower
                             // than AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(error)) on some
                             // hardware:
-                            if (AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(error)).ToScalar() != 0)
+                            if (error != Vector128<byte>.Zero)
                             {
                                 byte* invalidBytePointer;
                                 if (processedLength == 0)
@@ -1461,16 +1461,15 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                             prevIncomplete = AdvSimd.SubtractSaturate(currentBlock, maxValue);
                             contbytes += -AdvSimd.Arm64.AddAcross(AdvSimd.CompareLessThanOrEqual(Vector128.AsSByte(currentBlock), largestcont)).ToScalar();
                             Vector128<byte> largerthan0f = AdvSimd.CompareGreaterThan(currentBlock, fourthByteMinusOne);
-                            ulong n4marker = AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(largerthan0f)).ToScalar();
-                            if (n4marker != 0)
+                            if (largerthan0f != Vector128<byte>.Zero)
                             {
                                 byte n4add = (byte)AdvSimd.Arm64.AddAcross(largerthan0f).ToScalar();
                                 int negn4add = (int)(byte)-n4add;
                                 n4 += negn4add;
                             }
                         }
                     }
-                    bool hasIncompete = AdvSimd.Arm64.MaxAcross(Vector128.AsUInt32(prevIncomplete)).ToScalar() != 0;
+                    bool hasIncompete = (prevIncomplete !=  Vector128<byte>.Zero);
                     if (processedLength < inputLength || hasIncompete)
                     {
                         byte* invalidBytePointer;