Refactor of Mayo

gefeili · gefeili · commit 9ef9e788329b · 2025-03-04T16:55:37.000+10:30
diff --git a/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/GF16Utils.java b/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/GF16Utils.java
@@ -82,7 +82,7 @@ static void mulAddMUpperTriangularMatXMat(int mVecLimbs, long[] bsMat, byte[] ma
                 for (int k = 0, kmVecLimbs = 0; k < matCols; k++, kmVecLimbs += mVecLimbs)
                 {
                     // For acc: add into the m-vector at row r, column k.
-                    mVecMulAdd(mVecLimbs, bsMat, bsMatEntriesUsed, mat[cmatCols + k] & 0xFF, acc, accOff + rmatColsmVecLimbs + kmVecLimbs);
+                    mVecMulAdd(mVecLimbs, bsMat, bsMatEntriesUsed, mat[cmatCols + k], acc, accOff + rmatColsmVecLimbs + kmVecLimbs);
                 }
                 bsMatEntriesUsed += mVecLimbs;
             }
@@ -256,7 +256,7 @@ static long mulFx8(byte a, long b)
 
         // Reduction mod (x^4 + x + 1): process each byte in parallel.
         long topP = p & 0xf0f0f0f0f0f0f0f0L;
-        return (p ^ (topP >> 4) ^ (topP >> 3)) & 0x0f0f0f0f0f0f0f0fL;
+        return (p ^ (topP >>> 4) ^ (topP >>> 3)) & 0x0f0f0f0f0f0f0f0fL;
     }
 
     static void matMul(byte[] a, byte[] b, int bOff, byte[] c, int colrowAB, int rowA)
diff --git a/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/MayoSigner.java b/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/MayoSigner.java
@@ -16,7 +16,7 @@ public class MayoSigner
     implements MessageSigner
 {
     private SecureRandom random;
-    MayoParameters params;
+    private MayoParameters params;
     private MayoPublicKeyParameters pubKey;
     private MayoPrivateKeyParameters privKey;
 
@@ -57,6 +57,7 @@ public byte[] generateSignature(byte[] message)
         int v = params.getV();
         int o = params.getO();
         int n = params.getN();
+        int m = params.getM();
         int vbytes = params.getVBytes();
         int oBytes = params.getOBytes();
         int saltBytes = params.getSaltBytes();
@@ -66,16 +67,17 @@ public byte[] generateSignature(byte[] message)
         int digestBytes = params.getDigestBytes();
         int skSeedBytes = params.getSkSeedBytes();
         byte[] tenc = new byte[params.getMBytes()];
-        byte[] t = new byte[params.getM()];
-        byte[] y = new byte[params.getM()];
+        byte[] t = new byte[m];
+        byte[] y = new byte[m];
         byte[] salt = new byte[saltBytes];
         byte[] V = new byte[k * vbytes + params.getRBytes()];
         byte[] Vdec = new byte[v * k];
         int ok = k * o;
-        byte[] A = new byte[((params.getM() + 7) / 8 * 8) * (ok + 1)];
-        byte[] x = new byte[k * n];
+        int nk = k * n;
+        byte[] A = new byte[((m + 7) / 8 * 8) * (ok + 1)];
+        byte[] x = new byte[nk];
         byte[] r = new byte[ok + 1];
-        byte[] s = new byte[k * n];
+        byte[] s = new byte[nk];
         byte[] tmp = new byte[digestBytes + saltBytes + skSeedBytes + 1];
         byte[] sig = new byte[params.getSigBytes()];
         long[] P = new long[p1Limbs + params.getP2Limbs()];
@@ -121,9 +123,9 @@ public byte[] generateSignature(byte[] message)
                     {
                         // Multiply the m-vector at P1 for the current matrix entry,
                         // and accumulate into acc for row r.
-                        GF16Utils.mVecMulAdd(mVecLimbs, P, bsMatEntriesUsed, O[co + j] & 0xFF, P, iomVecLimbs + jmVecLimbs);
+                        GF16Utils.mVecMulAdd(mVecLimbs, P, bsMatEntriesUsed, O[co + j], P, iomVecLimbs + jmVecLimbs);
                         // Similarly, accumulate into acc for row c.
-                        GF16Utils.mVecMulAdd(mVecLimbs, P, bsMatEntriesUsed, O[io + j] & 0xFF, P, comVecLimbs + jmVecLimbs);
+                        GF16Utils.mVecMulAdd(mVecLimbs, P, bsMatEntriesUsed, O[io + j], P, comVecLimbs + jmVecLimbs);
                     }
                     bsMatEntriesUsed += mVecLimbs;
                 }
@@ -150,9 +152,10 @@ public byte[] generateSignature(byte[] message)
             System.arraycopy(salt, 0, tmp, digestBytes, saltBytes);
             shake.update(tmp, 0, digestBytes + saltBytes);
             shake.doFinal(tenc, 0, params.getMBytes());
-            Utils.decode(tenc, t, params.getM());
+            Utils.decode(tenc, t, m);
             int size = v * k * mVecLimbs;
             long[] Pv = new long[size];
+            byte[] Ox = new byte[v];
             for (int ctr = 0; ctr <= 255; ctr++)
             {
                 tmp[tmp.length - 1] = (byte)ctr;
@@ -182,12 +185,12 @@ public byte[] generateSignature(byte[] message)
                 computeA(Mtmp, A);
 
                 // Clear trailing bytes
-//                for (int i = 0; i < params.getM(); ++i)
+//                for (int i = 0; i < m; ++i)
 //                {
 //                    A[(i + 1) * (ok + 1) - 1] = 0;
 //                }
 
-                Utils.decode(V, k * vbytes, r, 0, ok);
+                Utils.decode(V, k * vbytes, r, ok);
 
                 if (sampleSolution(params, A, y, r, x))
                 {
@@ -201,16 +204,16 @@ public byte[] generateSignature(byte[] message)
             }
 
             // Compute final signature components
-            byte[] Ox = new byte[v];
-            for (int i = 0; i < k; i++)
+
+            for (int i = 0, io = 0, in = 0, iv = 0; i < k; i++, io += o, in+= n, iv += v)
             {
-                GF16Utils.matMul(O, x, i * o, Ox, o, n - o);
-                Bytes.xor(v, Vdec, i * v, Ox, s, i * n);
-                System.arraycopy(x, i * o, s, i * n + n - o, o);
+                GF16Utils.matMul(O, x, io, Ox, o, v);
+                Bytes.xor(v, Vdec, iv, Ox, s, in);
+                System.arraycopy(x, io, s, in + v, o);
             }
 
             // Encode and add salt
-            Utils.encode(s, sig, n * k);
+            Utils.encode(s, sig, nk);
             System.arraycopy(salt, 0, sig, sig.length - saltBytes, saltBytes);
 
             return Arrays.concatenate(sig, message);
@@ -294,13 +297,12 @@ void computeRHS(long[] vPv, byte[] t, byte[] y)
         final int k = params.getK();
         final int[] fTail = params.getFTail();
 
-        final int topPos = ((m - 1) & 15) * 4;
+        final int topPos = ((m - 1) & 15) << 2;
 
         // Zero out tails of m_vecs if necessary
         if ((m & 15) != 0)
         {
-            long mask = 1L << ((m & 15) << 2);
-            mask -= 1;
+            long mask = (1L << ((m & 15) << 2)) - 1;
             final int kSquared = k * k;
 
             for (int i = 0, index = mVecLimbs - 1; i < kSquared; i++, index += mVecLimbs)
@@ -409,7 +411,7 @@ void computeA(long[] Mtmp, byte[] AOut)
             }
         }
 
-        for (int i = 0, io = 0; i < k; i++, io += o)
+        for (int i = 0, io = 0, iomVecLimbs = 0; i < k; i++, io += o, iomVecLimbs += omVecLimbs)
         {
             for (int j = k - 1, jomVecLimbs = j * omVecLimbs, jo = j * o; j >= i; j--, jomVecLimbs -= omVecLimbs, jo -= o)
             {
@@ -433,13 +435,11 @@ void computeA(long[] Mtmp, byte[] AOut)
                 if (i != j)
                 {
                     // Process Mi
-                    int miOffset = i * mVecLimbs * o;
                     for (int c = 0, cmVecLimbs = 0; c < o; c++, cmVecLimbs += mVecLimbs)
                     {
                         for (int limb = 0, limbAWidhth = 0; limb < mVecLimbs; limb++, limbAWidhth += AWidth)
                         {
-                            long value = Mtmp[miOffset + limb + cmVecLimbs];
-
+                            long value = Mtmp[iomVecLimbs + limb + cmVecLimbs];
                             int aIndex = jo + c + wordsToShift + limbAWidhth;
                             A[aIndex] ^= value << bitsToShift;
 
@@ -461,7 +461,7 @@ void computeA(long[] Mtmp, byte[] AOut)
         }
 
         // Transpose blocks
-        for (int c = 0; c < AWidth * ((m + (k + 1) * k / 2 + 15) >>> 4); c += 16)
+        for (int c = 0; c < AWidth * ((m + (((k + 1) * k) >> 1) + 15) >>> 4); c += 16)
         {
             transpose16x16Nibbles(A, c);
         }
@@ -554,8 +554,7 @@ private static void transpose16x16Nibbles(long[] M, int offset)
         }
     }
 
-    boolean sampleSolution(MayoParameters params, byte[] A, byte[] y,
-                           byte[] r, byte[] x)
+    boolean sampleSolution(MayoParameters params, byte[] A, byte[] y, byte[] r, byte[] x)
     {
         final int k = params.getK();
         final int o = params.getO();
@@ -576,19 +575,19 @@ boolean sampleSolution(MayoParameters params, byte[] A, byte[] y,
         GF16Utils.matMul(A, r, 0, Ar, ok + 1, m);
 
         // Update last column of A with y - Ar
-        for (int i = 0; i < m; i++)
+        for (int i = 0, idx = ok; i < m; i++, idx += ok + 1)
         {
-            A[ok + i * (ok + 1)] = (byte)(y[i] ^ Ar[i]);
+            A[idx] = (byte)(y[i] ^ Ar[i]);
         }
 
         // Perform row echelon form transformation
         ef(A, m, aCols);
 
         // Check matrix rank
         boolean fullRank = false;
-        for (int i = 0; i < aCols - 1; i++)
+        for (int i = 0, idx = (m - 1) * aCols; i < aCols - 1; i++, idx++)
         {
-            fullRank |= (A[(m - 1) * aCols + i] != 0);
+            fullRank |= (A[idx] != 0);
         }
         if (!fullRank)
         {
@@ -609,7 +608,6 @@ boolean sampleSolution(MayoParameters params, byte[] A, byte[] y,
                 byte u = (byte)(correctCol & ~finished & A[rowAcols + aCols - 1]);
                 x[col] ^= u;
 
-
                 // Update matrix entries
                 for (int i = 0, iaCols_col = col, iaCols_aCols1 = aCols - 1; i < row; i += 8,
                     iaCols_col += aCols << 3, iaCols_aCols1 += aCols << 3)
@@ -647,7 +645,7 @@ boolean sampleSolution(MayoParameters params, byte[] A, byte[] y,
     void ef(byte[] A, int nrows, int ncols)
     {
         // Each 64-bit long can hold 16 nibbles (16 GF(16) elements).
-        int rowLen = (ncols + 15) / 16;
+        int rowLen = (ncols + 15) >> 4;
 
         // Allocate temporary arrays.
         long[] pivotRow = new long[rowLen];
@@ -686,11 +684,8 @@ void ef(byte[] A, int nrows, int ncols)
             int upperBound = Math.min(nrows - 1, pivotCol);
 
             // Zero out pivot row buffers.
-            for (int i = 0; i < rowLen; i++)
-            {
-                pivotRow[i] = 0;
-                pivotRow2[i] = 0;
-            }
+            Arrays.clear(pivotRow);
+            Arrays.clear(pivotRow2);
 
             // Try to select a pivot row in constant time.
             int pivot = 0;
diff --git a/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/Utils.java b/core/src/main/java/org/bouncycastle/pqc/crypto/mayo/Utils.java
@@ -22,9 +22,7 @@ public class Utils
      */
     public static void decode(byte[] m, byte[] mdec, int mdecLen)
     {
-        int i;
-        int decIndex = 0;
-        int blocks = mdecLen >> 1;
+        int i, decIndex = 0, blocks = mdecLen >> 1;
         // Process pairs of nibbles from each byte
         for (i = 0; i < blocks; i++)
         {
@@ -34,7 +32,7 @@ public static void decode(byte[] m, byte[] mdec, int mdecLen)
             mdec[decIndex++] = (byte)((m[i] >> 4) & 0x0F);
         }
         // If there is an extra nibble (odd number of nibbles), decode only the lower nibble
-        if (mdecLen % 2 == 1)
+        if ((mdecLen & 1) == 1)
         {
             mdec[decIndex] = (byte)((m[i] & 0xFF) & 0x0F);
         }
@@ -52,7 +50,7 @@ public static void decode(byte[] m, int mOff, byte[] mdec, int decIndex, int mde
             mdec[decIndex++] = (byte)((m[mOff++] >> 4) & 0x0F);
         }
         // If there is an extra nibble (odd number of nibbles), decode only the lower nibble
-        if (mdecLen % 2 == 1)
+        if ((mdecLen & 1) == 1)
         {
             mdec[decIndex] = (byte)(m[mOff] & 0x0F);
         }
@@ -68,14 +66,13 @@ public static void decode(byte[] m, int mOff, byte[] mdec, int decIndex, int mde
      */
     public static void decode(byte[] input, int inputOffset, byte[] output, int mdecLen)
     {
-        int decIndex = 0;
-        int blocks = mdecLen >> 1;
+        int decIndex = 0, blocks = mdecLen >> 1;
         for (int i = 0; i < blocks; i++)
         {
             output[decIndex++] = (byte)(input[inputOffset] & 0x0F);
             output[decIndex++] = (byte)((input[inputOffset++] >> 4) & 0x0F);
         }
-        if (mdecLen % 2 == 1)
+        if ((mdecLen & 1) == 1)
         {
             output[decIndex] = (byte)(input[inputOffset] & 0x0F);
         }
@@ -92,8 +89,7 @@ public static void decode(byte[] input, int inputOffset, byte[] output, int mdec
      */
     public static void encode(byte[] m, byte[] menc, int mlen)
     {
-        int i;
-        int srcIndex = 0;
+        int i, srcIndex = 0;
         // Process pairs of 4-bit values
         for (i = 0; i < mlen / 2; i++)
         {
@@ -103,58 +99,28 @@ public static void encode(byte[] m, byte[] menc, int mlen)
             srcIndex += 2;
         }
         // If there is an extra nibble (odd number of nibbles), store it directly in lower 4 bits.
-        if (mlen % 2 == 1)
+        if ((mlen & 1) == 1)
         {
             menc[i] = (byte)(m[srcIndex] & 0x0F);
         }
     }
 
-    /**
-     * Unpacks m-vectors from a packed byte array into an array of 64-bit limbs.
-     *
-     * @param in   the input byte array containing packed data
-     * @param out  the output long array where unpacked limbs are stored
-     * @param vecs the number of vectors
-     * @param m    the m parameter (used to compute m_vec_limbs and copy lengths)
-     */
-    public static void unpackMVecs(byte[] in, long[] out, int vecs, int m)
-    {
-        int mVecLimbs = (m + 15) / 16;
-        int bytesToCopy = m / 2; // Number of bytes to copy per vector
-        // Temporary buffer to hold mVecLimbs longs (each long is 8 bytes)
-        byte[] tmp = new byte[mVecLimbs << 3];
-
-        // Process vectors in reverse order
-        for (int i = vecs - 1; i >= 0; i--)
-        {
-            // Copy m/2 bytes from the input into tmp. The rest remains zero.
-            System.arraycopy(in, i * bytesToCopy, tmp, 0, bytesToCopy);
-
-            // Convert each 8-byte block in tmp into a long using Pack
-            for (int j = 0; j < mVecLimbs; j++)
-            {
-                out[i * mVecLimbs + j] = Pack.littleEndianToLong(tmp, j << 3);
-            }
-        }
-    }
-
     public static void unpackMVecs(byte[] in, int inOff, long[] out, int outOff, int vecs, int m)
     {
-        int mVecLimbs = (m + 15) / 16;
-        int bytesToCopy = m / 2; // Number of bytes to copy per vector
+        int mVecLimbs = (m + 15) >> 4;
+        int bytesToCopy = m >> 1; // Number of bytes to copy per vector
         // Temporary buffer to hold mVecLimbs longs (each long is 8 bytes)
-        byte[] tmp = new byte[mVecLimbs << 3];
+        int lastblockLen = 8 - (mVecLimbs << 3) + bytesToCopy;
+        int i, j;
         // Process vectors in reverse order
-        for (int i = vecs - 1; i >= 0; i--)
+        for (i = vecs - 1, outOff += i * mVecLimbs, inOff += i * bytesToCopy; i >= 0; i--, outOff -= mVecLimbs, inOff -= bytesToCopy)
         {
-            // Copy m/2 bytes from the input into tmp. The rest remains zero.
-            System.arraycopy(in, inOff + i * bytesToCopy, tmp, 0, bytesToCopy);
-
             // Convert each 8-byte block in tmp into a long using Pack
-            for (int j = 0; j < mVecLimbs; j++)
+            for (j = 0; j < mVecLimbs - 1; j++)
             {
-                out[outOff + i * mVecLimbs + j] = Pack.littleEndianToLong(tmp, j * 8);
+                out[outOff + j] = Pack.littleEndianToLong(in, inOff + (j << 3));
             }
+            out[outOff + j] = Pack.littleEndianToLong(in, inOff + (j << 3), lastblockLen);
         }
     }
 
@@ -168,23 +134,19 @@ public static void unpackMVecs(byte[] in, int inOff, long[] out, int outOff, int
      */
     public static void packMVecs(long[] in, byte[] out, int outOff, int vecs, int m)
     {
-        int mVecLimbs = (m + 15) / 16;
-        int bytesToCopy = m / 2; // Number of bytes per vector to write
-
+        int mVecLimbs = (m + 15) >> 4;
+        int bytesToCopy = m >> 1; // Number of bytes per vector to write
+        int lastBlockLen = 8 - (mVecLimbs << 3) + bytesToCopy;
+        int j;
         // Process each vector in order
-        for (int i = 0; i < vecs; i++)
+        for (int i = 0, inOff = 0; i < vecs; i++, outOff += bytesToCopy, inOff += mVecLimbs)
         {
-            // Temporary buffer to hold the bytes for this vector
-            byte[] tmp = new byte[mVecLimbs * 8];
-
             // Convert each long into 8 bytes using Pack
-            for (int j = 0; j < mVecLimbs; j++)
+            for (j = 0; j < mVecLimbs - 1; j++)
             {
-                Pack.longToLittleEndian(in[i * mVecLimbs + j], tmp, j * 8);
+                Pack.longToLittleEndian(in[inOff + j], out, outOff + (j << 3));
             }
-
-            // Copy the first m/2 bytes from tmp to the output array
-            System.arraycopy(tmp, 0, out, i * bytesToCopy + outOff, bytesToCopy);
+            Pack.longToLittleEndian(in[inOff + j], out, outOff + (j << 3), lastBlockLen);
         }
     }
 
@@ -242,6 +204,6 @@ public static void expandP1P2(MayoParameters p, long[] P, byte[] seed_pk)
 
         // Unpack the byte array 'temp' into the long array 'P'
         // using our previously defined unpackMVecs method.
-        unpackMVecs(temp, P, numVectors, p.getM());
+        unpackMVecs(temp, 0, P, 0, numVectors, p.getM());
     }
 }
diff --git a/core/src/main/java/org/bouncycastle/util/Bytes.java b/core/src/main/java/org/bouncycastle/util/Bytes.java

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ static void mulAddMUpperTriangularMatXMat(int mVecLimbs, long[] bsMat, byte[] ma`
`82`	`82`	`for (int k = 0, kmVecLimbs = 0; k < matCols; k++, kmVecLimbs += mVecLimbs)`
`83`	`83`	`{`
`84`	`84`	`// For acc: add into the m-vector at row r, column k.`
`85`		`- mVecMulAdd(mVecLimbs, bsMat, bsMatEntriesUsed, mat[cmatCols + k] & 0xFF, acc, accOff + rmatColsmVecLimbs + kmVecLimbs);`
	`85`	`+ mVecMulAdd(mVecLimbs, bsMat, bsMatEntriesUsed, mat[cmatCols + k], acc, accOff + rmatColsmVecLimbs + kmVecLimbs);`
`86`	`86`	`}`
`87`	`87`	`bsMatEntriesUsed += mVecLimbs;`
`88`	`88`	`}`
`@@ -256,7 +256,7 @@ static long mulFx8(byte a, long b)`
`256`	`256`
`257`	`257`	`// Reduction mod (x^4 + x + 1): process each byte in parallel.`
`258`	`258`	`long topP = p & 0xf0f0f0f0f0f0f0f0L;`
`259`		`- return (p ^ (topP >> 4) ^ (topP >> 3)) & 0x0f0f0f0f0f0f0f0fL;`
	`259`	`+ return (p ^ (topP >>> 4) ^ (topP >>> 3)) & 0x0f0f0f0f0f0f0f0fL;`
`260`	`260`	`}`
`261`	`261`
`262`	`262`	`static void matMul(byte[] a, byte[] b, int bOff, byte[] c, int colrowAB, int rowA)`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,7 @@ public class Utils`
`22`	`22`	`*/`
`23`	`23`	`public static void decode(byte[] m, byte[] mdec, int mdecLen)`
`24`	`24`	`{`
`25`		`- int i;`
`26`		`- int decIndex = 0;`
`27`		`- int blocks = mdecLen >> 1;`
	`25`	`+ int i, decIndex = 0, blocks = mdecLen >> 1;`
`28`	`26`	`// Process pairs of nibbles from each byte`
`29`	`27`	`for (i = 0; i < blocks; i++)`
`30`	`28`	`{`
`@@ -34,7 +32,7 @@ public static void decode(byte[] m, byte[] mdec, int mdecLen)`
`34`	`32`	`mdec[decIndex++] = (byte)((m[i] >> 4) & 0x0F);`
`35`	`33`	`}`
`36`	`34`	`// If there is an extra nibble (odd number of nibbles), decode only the lower nibble`
`37`		`- if (mdecLen % 2 == 1)`
	`35`	`+ if ((mdecLen & 1) == 1)`
`38`	`36`	`{`
`39`	`37`	`mdec[decIndex] = (byte)((m[i] & 0xFF) & 0x0F);`
`40`	`38`	`}`
`@@ -52,7 +50,7 @@ public static void decode(byte[] m, int mOff, byte[] mdec, int decIndex, int mde`
`52`	`50`	`mdec[decIndex++] = (byte)((m[mOff++] >> 4) & 0x0F);`
`53`	`51`	`}`
`54`	`52`	`// If there is an extra nibble (odd number of nibbles), decode only the lower nibble`
`55`		`- if (mdecLen % 2 == 1)`
	`53`	`+ if ((mdecLen & 1) == 1)`
`56`	`54`	`{`
`57`	`55`	`mdec[decIndex] = (byte)(m[mOff] & 0x0F);`
`58`	`56`	`}`
`@@ -68,14 +66,13 @@ public static void decode(byte[] m, int mOff, byte[] mdec, int decIndex, int mde`
`68`	`66`	`*/`
`69`	`67`	`public static void decode(byte[] input, int inputOffset, byte[] output, int mdecLen)`
`70`	`68`	`{`
`71`		`- int decIndex = 0;`
`72`		`- int blocks = mdecLen >> 1;`
	`69`	`+ int decIndex = 0, blocks = mdecLen >> 1;`
`73`	`70`	`for (int i = 0; i < blocks; i++)`
`74`	`71`	`{`
`75`	`72`	`output[decIndex++] = (byte)(input[inputOffset] & 0x0F);`
`76`	`73`	`output[decIndex++] = (byte)((input[inputOffset++] >> 4) & 0x0F);`
`77`	`74`	`}`
`78`		`- if (mdecLen % 2 == 1)`
	`75`	`+ if ((mdecLen & 1) == 1)`
`79`	`76`	`{`
`80`	`77`	`output[decIndex] = (byte)(input[inputOffset] & 0x0F);`
`81`	`78`	`}`
`@@ -92,8 +89,7 @@ public static void decode(byte[] input, int inputOffset, byte[] output, int mdec`
`92`	`89`	`*/`
`93`	`90`	`public static void encode(byte[] m, byte[] menc, int mlen)`
`94`	`91`	`{`
`95`		`- int i;`
`96`		`- int srcIndex = 0;`
	`92`	`+ int i, srcIndex = 0;`
`97`	`93`	`// Process pairs of 4-bit values`
`98`	`94`	`for (i = 0; i < mlen / 2; i++)`
`99`	`95`	`{`
`@@ -103,58 +99,28 @@ public static void encode(byte[] m, byte[] menc, int mlen)`
`103`	`99`	`srcIndex += 2;`
`104`	`100`	`}`
`105`	`101`	`// If there is an extra nibble (odd number of nibbles), store it directly in lower 4 bits.`
`106`		`- if (mlen % 2 == 1)`
	`102`	`+ if ((mlen & 1) == 1)`
`107`	`103`	`{`
`108`	`104`	`menc[i] = (byte)(m[srcIndex] & 0x0F);`
`109`	`105`	`}`
`110`	`106`	`}`
`111`	`107`
`112`		`- /**`
`113`		`- * Unpacks m-vectors from a packed byte array into an array of 64-bit limbs.`
`114`		`- *`
`115`		`- * @param in the input byte array containing packed data`
`116`		`- * @param out the output long array where unpacked limbs are stored`
`117`		`- * @param vecs the number of vectors`
`118`		`- * @param m the m parameter (used to compute m_vec_limbs and copy lengths)`
`119`		`- */`
`120`		`- public static void unpackMVecs(byte[] in, long[] out, int vecs, int m)`
`121`		`- {`
`122`		`- int mVecLimbs = (m + 15) / 16;`
`123`		`- int bytesToCopy = m / 2; // Number of bytes to copy per vector`
`124`		`- // Temporary buffer to hold mVecLimbs longs (each long is 8 bytes)`
`125`		`- byte[] tmp = new byte[mVecLimbs << 3];`
`126`		`-`
`127`		`- // Process vectors in reverse order`
`128`		`- for (int i = vecs - 1; i >= 0; i--)`
`129`		`- {`
`130`		`- // Copy m/2 bytes from the input into tmp. The rest remains zero.`
`131`		`- System.arraycopy(in, i * bytesToCopy, tmp, 0, bytesToCopy);`
`132`		`-`
`133`		`- // Convert each 8-byte block in tmp into a long using Pack`
`134`		`- for (int j = 0; j < mVecLimbs; j++)`
`135`		`- {`
`136`		`- out[i * mVecLimbs + j] = Pack.littleEndianToLong(tmp, j << 3);`
`137`		`- }`
`138`		`- }`
`139`		`- }`
`140`		`-`
`141`	`108`	`public static void unpackMVecs(byte[] in, int inOff, long[] out, int outOff, int vecs, int m)`
`142`	`109`	`{`
`143`		`- int mVecLimbs = (m + 15) / 16;`
`144`		`- int bytesToCopy = m / 2; // Number of bytes to copy per vector`
	`110`	`+ int mVecLimbs = (m + 15) >> 4;`
	`111`	`+ int bytesToCopy = m >> 1; // Number of bytes to copy per vector`
`145`	`112`	`// Temporary buffer to hold mVecLimbs longs (each long is 8 bytes)`
`146`		`- byte[] tmp = new byte[mVecLimbs << 3];`
	`113`	`+ int lastblockLen = 8 - (mVecLimbs << 3) + bytesToCopy;`
	`114`	`+ int i, j;`
`147`	`115`	`// Process vectors in reverse order`
`148`		`- for (int i = vecs - 1; i >= 0; i--)`
	`116`	`+ for (i = vecs - 1, outOff += i * mVecLimbs, inOff += i * bytesToCopy; i >= 0; i--, outOff -= mVecLimbs, inOff -= bytesToCopy)`
`149`	`117`	`{`
`150`		`- // Copy m/2 bytes from the input into tmp. The rest remains zero.`
`151`		`- System.arraycopy(in, inOff + i * bytesToCopy, tmp, 0, bytesToCopy);`
`152`		`-`
`153`	`118`	`// Convert each 8-byte block in tmp into a long using Pack`
`154`		`- for (int j = 0; j < mVecLimbs; j++)`
	`119`	`+ for (j = 0; j < mVecLimbs - 1; j++)`
`155`	`120`	`{`
`156`		`- out[outOff + i * mVecLimbs + j] = Pack.littleEndianToLong(tmp, j * 8);`
	`121`	`+ out[outOff + j] = Pack.littleEndianToLong(in, inOff + (j << 3));`
`157`	`122`	`}`
	`123`	`+ out[outOff + j] = Pack.littleEndianToLong(in, inOff + (j << 3), lastblockLen);`
`158`	`124`	`}`
`159`	`125`	`}`
`160`	`126`
`@@ -168,23 +134,19 @@ public static void unpackMVecs(byte[] in, int inOff, long[] out, int outOff, int`
`168`	`134`	`*/`
`169`	`135`	`public static void packMVecs(long[] in, byte[] out, int outOff, int vecs, int m)`
`170`	`136`	`{`
`171`		`- int mVecLimbs = (m + 15) / 16;`
`172`		`- int bytesToCopy = m / 2; // Number of bytes per vector to write`
`173`		`-`
	`137`	`+ int mVecLimbs = (m + 15) >> 4;`
	`138`	`+ int bytesToCopy = m >> 1; // Number of bytes per vector to write`
	`139`	`+ int lastBlockLen = 8 - (mVecLimbs << 3) + bytesToCopy;`
	`140`	`+ int j;`
`174`	`141`	`// Process each vector in order`
`175`		`- for (int i = 0; i < vecs; i++)`
	`142`	`+ for (int i = 0, inOff = 0; i < vecs; i++, outOff += bytesToCopy, inOff += mVecLimbs)`
`176`	`143`	`{`
`177`		`- // Temporary buffer to hold the bytes for this vector`
`178`		`- byte[] tmp = new byte[mVecLimbs * 8];`
`179`		`-`
`180`	`144`	`// Convert each long into 8 bytes using Pack`
`181`		`- for (int j = 0; j < mVecLimbs; j++)`
	`145`	`+ for (j = 0; j < mVecLimbs - 1; j++)`
`182`	`146`	`{`
`183`		`- Pack.longToLittleEndian(in[i * mVecLimbs + j], tmp, j * 8);`
	`147`	`+ Pack.longToLittleEndian(in[inOff + j], out, outOff + (j << 3));`
`184`	`148`	`}`
`185`		`-`
`186`		`- // Copy the first m/2 bytes from tmp to the output array`
`187`		`- System.arraycopy(tmp, 0, out, i * bytesToCopy + outOff, bytesToCopy);`
	`149`	`+ Pack.longToLittleEndian(in[inOff + j], out, outOff + (j << 3), lastBlockLen);`
`188`	`150`	`}`
`189`	`151`	`}`
`190`	`152`
`@@ -242,6 +204,6 @@ public static void expandP1P2(MayoParameters p, long[] P, byte[] seed_pk)`
`242`	`204`
`243`	`205`	`// Unpack the byte array 'temp' into the long array 'P'`
`244`	`206`	`// using our previously defined unpackMVecs method.`
`245`		`- unpackMVecs(temp, P, numVectors, p.getM());`
	`207`	`+ unpackMVecs(temp, 0, P, 0, numVectors, p.getM());`
`246`	`208`	`}`
`247`	`209`	`}`