Rename `v` vectors to align with reference implementation.

diff --git a/src/shaders/compute.wgsl b/src/shaders/compute.wgsl
index 1af909d53a089057eba3863f3117da3d60d3a601..4df2fb03c6bf1671582f4c103074ab2eb8d2243b 100644 (file)
--- a/src/shaders/compute.wgsl
+++ b/src/shaders/compute.wgsl
@@ -47,7 +47,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        var m9: u32 = ubo.blockhash[1u].w;
 
        /**
-       * Compression buffer intialized to 2 instances of initialization vector
+       * Compression buffer initialized to 2 instances of initialization vector
        * The following values have been modified from the BLAKE2B_IV:
        * OUTLEN is constant 8 bytes
        * v[0u] ^= 0x01010000u ^ uint(OUTLEN);
@@ -57,22 +57,22 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        * v[28u] = ~v[28u];
        * v[29u] = ~v[29u];
        */
-       var v_01: vec2<u32> = vec2(0xF2BDC900u, 0x6A09E667u);
-       var v_23: vec2<u32> = vec2(0x84CAA73Bu, 0xBB67AE85u);
-       var v_45: vec2<u32> = vec2(0xFE94F82Bu, 0x3C6EF372u);
-       var v_67: vec2<u32> = vec2(0x5F1D36F1u, 0xA54FF53Au);
-       var v_89: vec2<u32> = vec2(0xADE682D1u, 0x510E527Fu);
-       var v_1011: vec2<u32> = vec2(0x2B3E6C1Fu, 0x9B05688Cu);
-       var v_1213: vec2<u32> = vec2(0xFB41BD6Bu, 0x1F83D9ABu);
-       var v_1415: vec2<u32> = vec2(0x137E2179u, 0x5BE0CD19u);
-       var v_1617: vec2<u32> = vec2(0xF3BCC908u, 0x6A09E667u);
-       var v_1819: vec2<u32> = vec2(0x84CAA73Bu, 0xBB67AE85u);
-       var v_2021: vec2<u32> = vec2(0xFE94F82Bu, 0x3C6EF372u);
-       var v_2223: vec2<u32> = vec2(0x5F1D36F1u, 0xA54FF53Au);
-       var v_2425: vec2<u32> = vec2(0xADE682F9u, 0x510E527Fu);
-       var v_2627: vec2<u32> = vec2(0x2B3E6C1Fu, 0x9B05688Cu);
-       var v_2829: vec2<u32> = vec2(0x04BE4294u, 0xE07C2654u);
-       var v_3031: vec2<u32> = vec2(0x137E2179u, 0x5BE0CD19u);
+       var v0: vec2<u32> = vec2(0xF2BDC900u, 0x6A09E667u);
+       var v1: vec2<u32> = vec2(0x84CAA73Bu, 0xBB67AE85u);
+       var v2: vec2<u32> = vec2(0xFE94F82Bu, 0x3C6EF372u);
+       var v3: vec2<u32> = vec2(0x5F1D36F1u, 0xA54FF53Au);
+       var v4: vec2<u32> = vec2(0xADE682D1u, 0x510E527Fu);
+       var v5: vec2<u32> = vec2(0x2B3E6C1Fu, 0x9B05688Cu);
+       var v6: vec2<u32> = vec2(0xFB41BD6Bu, 0x1F83D9ABu);
+       var v7: vec2<u32> = vec2(0x137E2179u, 0x5BE0CD19u);
+       var v8: vec2<u32> = vec2(0xF3BCC908u, 0x6A09E667u);
+       var v9: vec2<u32> = vec2(0x84CAA73Bu, 0xBB67AE85u);
+       var v10: vec2<u32> = vec2(0xFE94F82Bu, 0x3C6EF372u);
+       var v11: vec2<u32> = vec2(0x5F1D36F1u, 0xA54FF53Au);
+       var v12: vec2<u32> = vec2(0xADE682F9u, 0x510E527Fu);
+       var v13: vec2<u32> = vec2(0x2B3E6C1Fu, 0x9B05688Cu);
+       var v14: vec2<u32> = vec2(0x04BE4294u, 0xE07C2654u);
+       var v15: vec2<u32> = vec2(0x137E2179u, 0x5BE0CD19u);
 
        /**
        * Twelve rounds of G mixing as part of BLAKE2b compression step.
@@ -91,38 +91,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m0 < v_01.x);
+       v0 = v0 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m0 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m2 < v_01.x);
+       v0 = v0 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m2 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -133,38 +133,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m4 < v_23.x);
+       v1 = v1 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m4 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m6 < v_23.x);
+       v1 = v1 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m6 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -175,38 +175,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m8 < v_45.x);
+       v2 = v2 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m8 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -217,38 +217,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -259,38 +259,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -301,38 +301,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -343,38 +343,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -385,38 +385,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -431,38 +431,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -473,38 +473,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m8 < v_23.x);
+       v1 = v1 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m8 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -515,38 +515,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -557,38 +557,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -599,38 +599,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m2 < v_01.x);
+       v0 = v0 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m2 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -641,38 +641,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m0 < v_23.x);
+       v1 = v1 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m0 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m4 < v_23.x);
+       v1 = v1 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m4 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -683,38 +683,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -725,38 +725,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_67 = v_67 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m6 < v_67.x);
+       v3 = v3 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m6 < v3.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -771,38 +771,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -813,38 +813,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m0 < v_23.x);
+       v1 = v1 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m0 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -855,38 +855,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m4 < v_45.x);
+       v2 = v2 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m4 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -897,38 +897,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -939,38 +939,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -981,38 +981,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m6 < v_23.x);
+       v1 = v1 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m6 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1023,38 +1023,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m2 < v_45.x);
+       v2 = v2 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m2 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1065,38 +1065,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_67 = v_67 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m8 < v_67.x);
+       v3 = v3 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m8 < v3.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1111,38 +1111,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1153,38 +1153,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m6 < v_23.x);
+       v1 = v1 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m6 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m2 < v_23.x);
+       v1 = v1 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m2 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1195,38 +1195,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1237,38 +1237,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1279,38 +1279,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m4 < v_01.x);
+       v0 = v0 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m4 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1321,38 +1321,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1363,38 +1363,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m8 < v_45.x);
+       v2 = v2 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m8 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m0 < v_45.x);
+       v2 = v2 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m0 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1405,38 +1405,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1451,38 +1451,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m0 < v_01.x);
+       v0 = v0 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m0 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1493,38 +1493,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1535,38 +1535,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m4 < v_45.x);
+       v2 = v2 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m4 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m8 < v_45.x);
+       v2 = v2 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m8 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1577,38 +1577,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1619,38 +1619,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m2 < v_01.x);
+       v0 = v0 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m2 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1661,38 +1661,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1703,38 +1703,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1745,38 +1745,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m6 < v_67.x);
+       v3 = v3 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m6 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1791,38 +1791,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m4 < v_01.x);
+       v0 = v0 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m4 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1833,38 +1833,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1875,38 +1875,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m0 < v_45.x);
+       v2 = v2 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m0 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1917,38 +1917,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_67 = v_67 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m6 < v_67.x);
+       v3 = v3 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m6 < v3.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -1959,38 +1959,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m8 < v_01.x);
+       v0 = v0 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m8 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2001,38 +2001,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2043,38 +2043,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2085,38 +2085,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m2 < v_67.x);
+       v3 = v3 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m2 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2131,38 +2131,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2173,38 +2173,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m2 < v_23.x);
+       v1 = v1 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m2 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2215,38 +2215,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2257,38 +2257,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m8 < v_67.x);
+       v3 = v3 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m8 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2299,38 +2299,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m0 < v_01.x);
+       v0 = v0 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m0 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2341,38 +2341,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m6 < v_23.x);
+       v1 = v1 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m6 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2383,38 +2383,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m4 < v_45.x);
+       v2 = v2 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m4 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2425,38 +2425,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2471,38 +2471,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2513,38 +2513,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2555,38 +2555,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m2 < v_45.x);
+       v2 = v2 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m2 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2597,38 +2597,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m6 < v_67.x);
+       v3 = v3 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m6 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2639,38 +2639,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m0 < v_01.x);
+       v0 = v0 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m0 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2681,38 +2681,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m8 < v_23.x);
+       v1 = v1 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m8 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2723,38 +2723,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2765,38 +2765,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m4 < v_67.x);
+       v3 = v3 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m4 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2811,38 +2811,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2853,38 +2853,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2895,38 +2895,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m6 < v_45.x);
+       v2 = v2 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m6 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2937,38 +2937,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m0 < v_67.x);
+       v3 = v3 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m0 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -2979,38 +2979,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m4 < v_01.x);
+       v0 = v0 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m4 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3021,38 +3021,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3063,38 +3063,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m2 < v_45.x);
+       v2 = v2 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m2 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_45 = v_45 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m8 < v_45.x);
+       v2 = v2 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m8 < v2.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3105,38 +3105,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3151,38 +3151,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m4 < v_01.x);
+       v0 = v0 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m4 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3193,38 +3193,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m8 < v_23.x);
+       v1 = v1 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m8 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3235,38 +3235,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3277,38 +3277,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_67 = v_67 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m2 < v_67.x);
+       v3 = v3 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m2 < v3.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3319,38 +3319,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3361,38 +3361,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3403,38 +3403,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m6 < v_45.x);
+       v2 = v2 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m6 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3445,38 +3445,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_67 = v_67 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m0 < v_67.x);
+       v3 = v3 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m0 < v3.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3491,38 +3491,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m0 < v_01.x);
+       v0 = v0 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m0 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_01 = v_01 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m2 < v_01.x);
+       v0 = v0 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m2 < v0.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3533,38 +3533,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m4 < v_23.x);
+       v1 = v1 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m4 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m6 < v_23.x);
+       v1 = v1 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m6 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3575,38 +3575,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_45 = v_45 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + m8 < v_45.x);
+       v2 = v2 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + m8 < v2.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3617,38 +3617,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3659,38 +3659,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3701,38 +3701,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3743,38 +3743,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3785,38 +3785,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3831,38 +3831,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v0;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_89.x < v_01.x);
+       v0 = v0 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v4.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_01;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v0;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2425.x < v_1617.x);
+       v8 = v8 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v12.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1617;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v8;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3873,38 +3873,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m8 < v_23.x);
+       v1 = v1 + vec2(m8, m9) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m8 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v1;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1011.x < v_23.x);
+       v1 = v1 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v5.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_23;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v1;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2627.x < v_1819.x);
+       v9 = v9 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v13.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_1819;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v9;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3915,38 +3915,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v2;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1213.x < v_45.x);
+       v2 = v2 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v6.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_45;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v2;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_2829.x < v_2021.x);
+       v10 = v10 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v14.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2021;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v10;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3957,38 +3957,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v3;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_1415.x < v_67.x);
+       v3 = v3 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v7.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_67;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v3;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_3031.x < v_2223.x);
+       v11 = v11 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v15.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_2223;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v11;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -3999,38 +3999,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_01 = v_01 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + m2 < v_01.x);
+       v0 = v0 + vec2(m2, m3) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + m2 < v0.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2(xor.y, xor.x);
+       xor = v15 ^ v0;
+       v15 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_01 = v_01 + v_1011 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_01.x + v_1011.x < v_01.x);
+       v0 = v0 + v5 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v0.x + v5.x < v0.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_3031 ^ v_01;
-       v_3031 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v15 ^ v0;
+       v15 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2021 = v_2021 + v_3031 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2021.x + v_3031.x < v_2021.x);
+       v10 = v10 + v15 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v10.x + v15.x < v10.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1011 ^ v_2021;
-       v_1011 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v5 ^ v10;
+       v5 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -4041,38 +4041,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+0]]
-       v_23 = v_23 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m0 < v_23.x);
+       v1 = v1 + vec2(m0, m1) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m0 < v1.x);
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2(xor.y, xor.x);
+       xor = v12 ^ v1;
+       v12 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_23 = v_23 + v_1213 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + v_1213.x < v_23.x);
+       v1 = v1 + v6 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + v6.x < v1.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_23 = v_23 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_23.x + m4 < v_23.x);
+       v1 = v1 + vec2(m4, m5) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v1.x + m4 < v1.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2425 ^ v_23;
-       v_2425 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v12 ^ v1;
+       v12 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_2223 = v_2223 + v_2425 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_2223.x + v_2425.x < v_2223.x);
+       v11 = v11 + v12 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v11.x + v12.x < v11.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1213 ^ v_2223;
-       v_1213 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v6 ^ v11;
+       v6 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -4083,38 +4083,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2(xor.y, xor.x);
+       xor = v13 ^ v2;
+       v13 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_45 = v_45 + v_1415 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_45.x + v_1415.x < v_45.x);
+       v2 = v2 + v7 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v2.x + v7.x < v2.x);
 
        // a = a + m[sigma[r][2*i+1]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2627 ^ v_45;
-       v_2627 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v13 ^ v2;
+       v13 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1617 = v_1617 + v_2627 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1617.x + v_2627.x < v_1617.x);
+       v8 = v8 + v13 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v8.x + v13.x < v8.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_1415 ^ v_1617;
-       v_1415 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v7 ^ v8;
+       v7 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -4125,38 +4125,38 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        */
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+0]]
        // skip since adding 0u does nothing
 
        // d = rotr64(d ^ a, 32)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2(xor.y, xor.x);
+       xor = v14 ^ v3;
+       v14 = vec2(xor.y, xor.x);
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 24)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x >> 24u) | (xor.y << 8u), (xor.y >> 24u) | (xor.x << 8u));
 
        // a = a + b
-       v_67 = v_67 + v_89 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + v_89.x < v_67.x);
+       v3 = v3 + v4 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + v4.x < v3.x);
 
        // a = a + m[sigma[r][2*i+1]]
-       v_67 = v_67 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_67.x + m6 < v_67.x);
+       v3 = v3 + vec2(m6, m7) + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v3.x + m6 < v3.x);
 
        // d = rotr64(d ^ a, 16)
-       xor = v_2829 ^ v_67;
-       v_2829 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
+       xor = v14 ^ v3;
+       v14 = vec2((xor.x >> 16u) | (xor.y << 16u), (xor.y >> 16u) | (xor.x << 16u));
 
        // c = c + d
-       v_1819 = v_1819 + v_2829 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v_1819.x + v_2829.x < v_1819.x);
+       v9 = v9 + v14 + select(vec2<u32>(0u), vec2<u32>(0u, 1u), v9.x + v14.x < v9.x);
 
        // b = rotr64(b ^ c, 63)
-       xor = v_89 ^ v_1819;
-       v_89 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
+       xor = v4 ^ v9;
+       v4 = vec2((xor.x << 1u) | (xor.y >> 31u), (xor.y << 1u) | (xor.x >> 31u));
 
 
 
@@ -4169,7 +4169,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
        /**
        * Set nonce if it passes the threshold and no other thread has set it
        */
-       if ((BLAKE2B_IV32_1 ^ v_01.y ^ v_1617.y) > threshold && atomicLoad(&work.found) == 0u) {
+       if ((BLAKE2B_IV32_1 ^ v0.y ^ v8.y) > threshold && atomicLoad(&work.found) == 0u) {
                atomicStore(&work.found, 1u);
                work.nonce.x = m0;
                work.nonce.y = m1;