Try updating G mix function again; rounds need to be updated next.

diff --git a/src/lib/workers/powgpu.ts b/src/lib/workers/powgpu.ts
index c5cb6bc878520d1d39b43e525c589fd3428db361..7f467b24160c99588979d60008768901c0ddf536 100644 (file)
--- a/src/lib/workers/powgpu.ts
+++ b/src/lib/workers/powgpu.ts
@@ -76,89 +76,95 @@ export class PowGpu extends WorkerInterface {
                /**
                * G Mixing function
                */
-               fn G (v: ptr<function, array<u32, 32>>, va0: ptr<function, u32>, va1: ptr<function, u32>, a: u32, b: u32, c: u32, d: u32, mx0: u32, mx1: u32, my0: u32, my1: u32) {
+               fn G (
+                       va0: ptr<function, u32>, va1: ptr<function, u32>,
+                       vb0: ptr<function, u32>, vb1: ptr<function, u32>,
+                       vc0: ptr<function, u32>, vc1: ptr<function, u32>,
+                       vd0: ptr<function, u32>, vd1: ptr<function, u32>,
+                       mx0: u32, mx1: u32, my0: u32, my1: u32
+               ) {
                        var o0: u32;
                        var o1: u32;
                        var xor0: u32;
                        var xor1: u32;
 
                        // a = a + b;
-                       o0 = (*v)[a] + (*v)[b];
-                       o1 = (*v)[a+1u] + (*v)[b+1u];
-                       if ((*v)[a] > 0xFFFFFFFFu - (*v)[b]) {
+                       o0 = *va0 + *vb0;
+                       o1 = *va1 + *vb1;
+                       if (*va0 > 0xFFFFFFFFu - *vb0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[a] = o0;
-                       (*v)[a+1u] = o1;
+                       *va0 = o0;
+                       *va1 = o1;
 
                        // a = a + m[sigma[r][2*i+0]];
-                       o0 = (*v)[a] + mx0;
-                       o1 = (*v)[a+1u] + mx1;
-                       if ((*v)[a] > 0xFFFFFFFFu - mx0) {
+                       o0 = *va0 + mx0;
+                       o1 = *va1 + mx1;
+                       if (*va0 > 0xFFFFFFFFu - mx0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[a] = o0;
-                       (*v)[a+1u] = o1;
+                       *va0 = o0;
+                       *va1 = o1;
 
                        // d = rotr64(d ^ a, 32);
-                       xor0 = (*v)[d] ^ (*v)[a];
-                       xor1 = (*v)[d+1u] ^ (*v)[a+1u];
-                       (*v)[d] = xor1;
-                       (*v)[d+1u] = xor0;
+                       xor0 = *vd0 ^ *va0;
+                       xor1 = *vd1 ^ *va1;
+                       *vd0 = xor1;
+                       *vd1 = xor0;
 
                        // c = c + d;
-                       o0 = (*v)[c] + (*v)[d];
-                       o1 = (*v)[c+1u] + (*v)[d+1u];
-                       if ((*v)[c] > 0xFFFFFFFFu - (*v)[d]) {
+                       o0 = *vc0 + *vd0;
+                       o1 = *vc1 + *vd1;
+                       if (*vc0 > 0xFFFFFFFFu - *vd0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[c] = o0;
-                       (*v)[c+1u] = o1;
+                       *vc0 = o0;
+                       *vc1 = o1;
 
                        // b = rotr64(b ^ c, 24);
-                       xor0 = (*v)[b] ^ (*v)[c];
-                       xor1 = (*v)[b+1u] ^ (*v)[c+1u];
-                       (*v)[b] = (xor0 >> 24u) ^ (xor1 << 8u);
-                       (*v)[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
+                       xor0 = *vb0 ^ *vc0;
+                       xor1 = *vb1 ^ *vc1;
+                       *vb0 = (xor0 >> 24u) ^ (xor1 << 8u);
+                       *vb1 = (xor1 >> 24u) ^ (xor0 << 8u);
 
                        // a = a + b;
-                       o0 = (*v)[a] + (*v)[b];
-                       o1 = (*v)[a+1u] + (*v)[b+1u];
-                       if ((*v)[a] > 0xFFFFFFFFu - (*v)[b]) {
+                       o0 = *va0 + *vb0;
+                       o1 = *va1 + *vb1;
+                       if (*va0 > 0xFFFFFFFFu - *vb0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[a] = o0;
-                       (*v)[a+1u] = o1;
+                       *va0 = o0;
+                       *va1 = o1;
 
                        // a = a + m[sigma[r][2*i+1]];
-                       o0 = (*v)[a] + my0;
-                       o1 = (*v)[a+1u] + my1;
-                       if ((*v)[a] > 0xFFFFFFFFu - my0) {
+                       o0 = *va0 + my0;
+                       o1 = *va1 + my1;
+                       if (*va0 > 0xFFFFFFFFu - my0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[a] = o0;
-                       (*v)[a+1u] = o1;
+                       *va0 = o0;
+                       *va1 = o1;
 
                        // d = rotr64(d ^ a, 16)
-                       xor0 = (*v)[d] ^ (*v)[a];
-                       xor1 = (*v)[d+1u] ^ (*v)[a+1u];
-                       (*v)[d] = (xor0 >> 16u) ^ (xor1 << 16u);
-                       (*v)[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
+                       xor0 = *vd0 ^ *va0;
+                       xor1 = *vd1 ^ *va1;
+                       *vd0 = (xor0 >> 16u) ^ (xor1 << 16u);
+                       *vd1 = (xor1 >> 16u) ^ (xor0 << 16u);
 
                        // c = c + d;
-                       o0 = (*v)[c] + (*v)[d];
-                       o1 = (*v)[c+1u] + (*v)[d+1u];
-                       if ((*v)[c] > 0xFFFFFFFFu - (*v)[d]) {
+                       o0 = *vc0 + *vd0;
+                       o1 = *vc1 + *vd1;
+                       if (*vc0 > 0xFFFFFFFFu - *vd0) {
                                o1 = o1 + 1u;
                        }
-                       (*v)[c] = o0;
-                       (*v)[c+1u] = o1;
+                       *vc0 = o0;
+                       *vc1 = o1;
 
                        // b = rotr64(b ^ c, 63)
-                       xor0 = (*v)[b] ^ (*v)[c];
-                       xor1 = (*v)[b+1u] ^ (*v)[c+1u];
-                       (*v)[b] = (xor1 >> 31u) ^ (xor0 << 1u);
-                       (*v)[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
+                       xor0 = *vb0 ^ *vc0;
+                       xor1 = *vb1 ^ *vc1;
+                       *vb0 = (xor1 >> 31u) ^ (xor0 << 1u);
+                       *vb1 = (xor0 >> 31u) ^ (xor1 << 1u);
                }
 
                /**