Inline XOR part of bit rotation step so that an assignment is eliminated.

diff --git a/src/shaders/compute.wgsl b/src/shaders/compute.wgsl
index 94a52c15b019b1cbbb1773b9cdd98c092d20300c..fc984b9ff3506441baf99eff0333d732c5e51b8d 100644 (file)
--- a/src/shaders/compute.wgsl
+++ b/src/shaders/compute.wgsl
@@ -110,7 +110,6 @@ fn main(id: vec3<u32>) {
        * sigma i index is doubled due to using two u32 array elements to represent
        * one uint64_t.
        */
-       var xor: vec2<u32>;
 
        /****************************************************************************
        *                                                                                                                               ROUND(0)                                                                                                                                        *
@@ -133,8 +132,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -143,15 +141,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + m1 + vec2(0u, u32(v0.x + m1.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -174,8 +170,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -184,15 +179,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m3 + vec2(0u, u32(v1.x + m3.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -215,8 +208,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -225,15 +217,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -256,8 +246,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -266,15 +255,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -297,8 +284,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -307,15 +293,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -338,8 +322,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -348,15 +331,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -379,8 +360,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -389,15 +369,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -420,8 +398,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -430,15 +407,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -465,8 +440,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -475,15 +449,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -506,8 +478,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -516,15 +487,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -547,8 +516,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -557,15 +525,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -588,8 +554,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -598,15 +563,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -629,8 +592,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -639,15 +601,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -670,8 +630,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -680,15 +639,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m2 + vec2(0u, u32(v1.x + m2.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -711,8 +668,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -721,15 +677,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -752,8 +706,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -762,15 +715,13 @@ fn main(id: vec3<u32>) {
        v3 = v3 + m3 + vec2(0u, u32(v3.x + m3.x < v3.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -797,8 +748,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -807,15 +757,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -838,8 +786,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -848,15 +795,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + nonce + vec2(0u, u32(v1.x + nonce.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -879,8 +824,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -889,15 +833,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m2 + vec2(0u, u32(v2.x + m2.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -920,8 +862,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -930,15 +871,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -961,8 +900,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -971,15 +909,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1002,8 +938,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -1012,15 +947,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1043,8 +976,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -1053,15 +985,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m1 + vec2(0u, u32(v2.x + m1.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1084,8 +1014,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -1094,15 +1023,13 @@ fn main(id: vec3<u32>) {
        v3 = v3 + m4 + vec2(0u, u32(v3.x + m4.x < v3.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1129,8 +1056,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -1139,15 +1065,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1170,8 +1094,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -1180,15 +1103,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m1 + vec2(0u, u32(v1.x + m1.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1211,8 +1132,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -1221,15 +1141,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1252,8 +1170,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -1262,15 +1179,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1293,8 +1208,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -1303,15 +1217,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1334,8 +1246,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -1344,15 +1255,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1375,8 +1284,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -1385,15 +1293,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + nonce + vec2(0u, u32(v2.x + nonce.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1416,8 +1322,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -1426,15 +1331,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1461,8 +1364,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -1471,15 +1373,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + nonce + vec2(0u, u32(v0.x + nonce.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1502,8 +1402,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -1512,15 +1411,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1543,8 +1440,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -1553,15 +1449,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m4 + vec2(0u, u32(v2.x + m4.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1584,8 +1478,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -1594,15 +1487,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1625,8 +1516,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -1635,15 +1525,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + m1 + vec2(0u, u32(v0.x + m1.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1666,8 +1554,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -1676,15 +1563,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1707,8 +1592,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -1717,15 +1601,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1748,8 +1630,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -1758,15 +1639,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1793,8 +1672,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -1803,15 +1681,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -1834,8 +1710,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -1844,15 +1719,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -1875,8 +1748,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -1885,15 +1757,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1916,8 +1786,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -1926,15 +1795,13 @@ fn main(id: vec3<u32>) {
        v3 = v3 + m3 + vec2(0u, u32(v3.x + m3.x < v3.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -1957,8 +1824,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -1967,15 +1833,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -1998,8 +1862,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -2008,15 +1871,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2039,8 +1900,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -2049,15 +1909,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2080,8 +1938,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -2090,15 +1947,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2125,8 +1980,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -2135,15 +1989,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2166,8 +2018,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -2176,15 +2027,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2207,8 +2056,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -2217,15 +2065,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2248,8 +2094,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -2258,15 +2103,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2289,8 +2132,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -2299,15 +2141,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2330,8 +2170,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -2340,15 +2179,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m3 + vec2(0u, u32(v1.x + m3.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2371,8 +2208,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -2381,15 +2217,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m2 + vec2(0u, u32(v2.x + m2.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2412,8 +2246,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -2422,15 +2255,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2457,8 +2288,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -2467,15 +2297,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2498,8 +2326,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -2508,15 +2335,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2539,8 +2364,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -2549,15 +2373,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m1 + vec2(0u, u32(v2.x + m1.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2580,8 +2402,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -2590,15 +2411,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2621,8 +2440,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -2631,15 +2449,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + nonce + vec2(0u, u32(v0.x + nonce.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2662,8 +2478,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -2672,15 +2487,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m4 + vec2(0u, u32(v1.x + m4.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2703,8 +2516,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -2713,15 +2525,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2744,8 +2554,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -2754,15 +2563,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2789,8 +2596,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -2799,15 +2605,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -2830,8 +2634,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -2840,15 +2643,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -2871,8 +2672,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -2881,15 +2681,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m3 + vec2(0u, u32(v2.x + m3.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2912,8 +2710,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -2922,15 +2719,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -2953,8 +2748,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -2963,15 +2757,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + m2 + vec2(0u, u32(v0.x + m2.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -2994,8 +2786,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -3004,15 +2795,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3035,8 +2824,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -3045,15 +2833,13 @@ fn main(id: vec3<u32>) {
        v2 = v2 + m4 + vec2(0u, u32(v2.x + m4.x < v2.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3076,8 +2862,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -3086,15 +2871,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3121,8 +2904,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -3131,15 +2913,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + m2 + vec2(0u, u32(v0.x + m2.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3162,8 +2942,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -3172,15 +2951,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m4 + vec2(0u, u32(v1.x + m4.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3203,8 +2980,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -3213,15 +2989,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3244,8 +3018,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -3254,15 +3027,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3285,8 +3056,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -3295,15 +3065,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3326,8 +3094,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -3336,15 +3103,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3367,8 +3132,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -3377,15 +3141,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3408,8 +3170,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -3418,15 +3179,13 @@ fn main(id: vec3<u32>) {
        v3 = v3 + nonce + vec2(0u, u32(v3.x + nonce.x < v3.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3453,8 +3212,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -3463,15 +3221,13 @@ fn main(id: vec3<u32>) {
        v0 = v0 + m1 + vec2(0u, u32(v0.x + m1.x < v0.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3494,8 +3250,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -3504,15 +3259,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m3 + vec2(0u, u32(v1.x + m3.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3535,8 +3288,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -3545,15 +3297,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3576,8 +3326,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -3586,15 +3335,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3617,8 +3364,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -3627,15 +3373,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3658,8 +3402,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -3668,15 +3411,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3699,8 +3440,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -3709,15 +3449,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3740,8 +3478,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -3750,15 +3487,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3785,8 +3520,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v8).xy >> ROTATE_24) | ((v4 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v4 + vec2(0u, u32(v0.x + v4.x < v0.x));
@@ -3795,15 +3529,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v0;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v0).xy >> ROTATE_16) | ((v12 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v12 + vec2(0u, u32(v8.x + v12.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v8;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v8).xy << ROTATE_1) | ((v4 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -3826,8 +3558,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v9).xy >> ROTATE_24) | ((v5 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v5 + vec2(0u, u32(v1.x + v5.x < v1.x));
@@ -3836,15 +3567,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v1;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v1).xy >> ROTATE_16) | ((v13 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v13 + vec2(0u, u32(v9.x + v13.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v9;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v9).xy << ROTATE_1) | ((v5 ^ v9).yx >> ROTATE_31);
 
 
 
@@ -3867,8 +3596,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v10).xy >> ROTATE_24) | ((v6 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v6 + vec2(0u, u32(v2.x + v6.x < v2.x));
@@ -3877,15 +3605,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v2;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v2).xy >> ROTATE_16) | ((v14 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v14 + vec2(0u, u32(v10.x + v14.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v10;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v10).xy << ROTATE_1) | ((v6 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3908,8 +3634,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v11).xy >> ROTATE_24) | ((v7 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v7 + vec2(0u, u32(v3.x + v7.x < v3.x));
@@ -3918,15 +3643,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v3;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v3).xy >> ROTATE_16) | ((v15 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v15 + vec2(0u, u32(v11.x + v15.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v11;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v11).xy << ROTATE_1) | ((v7 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -3949,8 +3672,7 @@ fn main(id: vec3<u32>) {
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v5 = ((v5 ^ v10).xy >> ROTATE_24) | ((v5 ^ v10).yx << ROTATE_8);
 
        // a = a + b
        v0 = v0 + v5 + vec2(0u, u32(v0.x + v5.x < v0.x));
@@ -3959,15 +3681,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v15 ^ v0;
-       v15 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v15 = ((v15 ^ v0).xy >> ROTATE_16) | ((v15 ^ v0).yx << ROTATE_16);
 
        // c = c + d
        v10 = v10 + v15 + vec2(0u, u32(v10.x + v15.x < v10.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v5 ^ v10;
-       v5 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v5 = ((v5 ^ v10).xy << ROTATE_1) | ((v5 ^ v10).yx >> ROTATE_31);
 
 
 
@@ -3990,8 +3710,7 @@ fn main(id: vec3<u32>) {
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v6 = ((v6 ^ v11).xy >> ROTATE_24) | ((v6 ^ v11).yx << ROTATE_8);
 
        // a = a + b
        v1 = v1 + v6 + vec2(0u, u32(v1.x + v6.x < v1.x));
@@ -4000,15 +3719,13 @@ fn main(id: vec3<u32>) {
        v1 = v1 + m2 + vec2(0u, u32(v1.x + m2.x < v1.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v12 ^ v1;
-       v12 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v12 = ((v12 ^ v1).xy >> ROTATE_16) | ((v12 ^ v1).yx << ROTATE_16);
 
        // c = c + d
        v11 = v11 + v12 + vec2(0u, u32(v11.x + v12.x < v11.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v6 ^ v11;
-       v6 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v6 = ((v6 ^ v11).xy << ROTATE_1) | ((v6 ^ v11).yx >> ROTATE_31);
 
 
 
@@ -4031,8 +3748,7 @@ fn main(id: vec3<u32>) {
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v7 = ((v7 ^ v8).xy >> ROTATE_24) | ((v7 ^ v8).yx << ROTATE_8);
 
        // a = a + b
        v2 = v2 + v7 + vec2(0u, u32(v2.x + v7.x < v2.x));
@@ -4041,15 +3757,13 @@ fn main(id: vec3<u32>) {
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v13 ^ v2;
-       v13 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v13 = ((v13 ^ v2).xy >> ROTATE_16) | ((v13 ^ v2).yx << ROTATE_16);
 
        // c = c + d
        v8 = v8 + v13 + vec2(0u, u32(v8.x + v13.x < v8.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v7 ^ v8;
-       v7 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v7 = ((v7 ^ v8).xy << ROTATE_1) | ((v7 ^ v8).yx >> ROTATE_31);
 
 
 
@@ -4072,8 +3786,7 @@ fn main(id: vec3<u32>) {
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 24)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy >> ROTATE_24) | (xor.yx << ROTATE_8));
+       v4 = ((v4 ^ v9).xy >> ROTATE_24) | ((v4 ^ v9).yx << ROTATE_8);
 
        // a = a + b
        v3 = v3 + v4 + vec2(0u, u32(v3.x + v4.x < v3.x));
@@ -4082,15 +3795,13 @@ fn main(id: vec3<u32>) {
        v3 = v3 + m3 + vec2(0u, u32(v3.x + m3.x < v3.x));
 
        // d = rotr64(d ^ a, 16)
-       xor = v14 ^ v3;
-       v14 = vec2((xor.xy >> ROTATE_16) | (xor.yx << ROTATE_16));
+       v14 = ((v14 ^ v3).xy >> ROTATE_16) | ((v14 ^ v3).yx << ROTATE_16);
 
        // c = c + d
        v9 = v9 + v14 + vec2(0u, u32(v9.x + v14.x < v9.x));
 
        // b = rotr64(b ^ c, 63)
-       xor = v4 ^ v9;
-       v4 = vec2((xor.xy << ROTATE_1) | (xor.yx >> ROTATE_31));
+       v4 = ((v4 ^ v9).xy << ROTATE_1) | ((v4 ^ v9).yx >> ROTATE_31);