#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void CHACHA20_ROUNDS(uint32_t st[16]) {
  int i;
  for (i = 0; i < 20; i += 2) {
    st[0] += st[4];
    st[12] = (uint32_t)(((st[12] ^ st[0]) << (16)) |
                        ((st[12] ^ st[0]) >> (32 - (16))));
    st[8] += st[12];
    st[4] = (uint32_t)(((st[4] ^ st[8]) << (12)) |
                       ((st[4] ^ st[8]) >> (32 - (12))));
    st[0] += st[4];
    st[12] = (uint32_t)(((st[12] ^ st[0]) << (8)) |
                        ((st[12] ^ st[0]) >> (32 - (8))));
    st[8] += st[12];
    st[4] =
        (uint32_t)(((st[4] ^ st[8]) << (7)) | ((st[4] ^ st[8]) >> (32 - (7))));
    st[1] += st[5];
    st[13] = (uint32_t)(((st[13] ^ st[1]) << (16)) |
                        ((st[13] ^ st[1]) >> (32 - (16))));
    st[9] += st[13];
    st[5] = (uint32_t)(((st[5] ^ st[9]) << (12)) |
                       ((st[5] ^ st[9]) >> (32 - (12))));
    st[1] += st[5];
    st[13] = (uint32_t)(((st[13] ^ st[1]) << (8)) |
                        ((st[13] ^ st[1]) >> (32 - (8))));
    st[9] += st[13];
    st[5] =
        (uint32_t)(((st[5] ^ st[9]) << (7)) | ((st[5] ^ st[9]) >> (32 - (7))));
    st[2] += st[6];
    st[14] = (uint32_t)(((st[14] ^ st[2]) << (16)) |
                        ((st[14] ^ st[2]) >> (32 - (16))));
    st[10] += st[14];
    st[6] = (uint32_t)(((st[6] ^ st[10]) << (12)) |
                       ((st[6] ^ st[10]) >> (32 - (12))));
    st[2] += st[6];
    st[14] = (uint32_t)(((st[14] ^ st[2]) << (8)) |
                        ((st[14] ^ st[2]) >> (32 - (8))));
    st[10] += st[14];
    st[6] = (uint32_t)(((st[6] ^ st[10]) << (7)) |
                       ((st[6] ^ st[10]) >> (32 - (7))));
    st[3] += st[7];
    st[15] = (uint32_t)(((st[15] ^ st[3]) << (16)) |
                        ((st[15] ^ st[3]) >> (32 - (16))));
    st[11] += st[15];
    st[7] = (uint32_t)(((st[7] ^ st[11]) << (12)) |
                       ((st[7] ^ st[11]) >> (32 - (12))));
    st[3] += st[7];
    st[15] = (uint32_t)(((st[15] ^ st[3]) << (8)) |
                        ((st[15] ^ st[3]) >> (32 - (8))));
    st[11] += st[15];
    st[7] = (uint32_t)(((st[7] ^ st[11]) << (7)) |
                       ((st[7] ^ st[11]) >> (32 - (7))));
    st[0] += st[5];
    st[15] = (uint32_t)(((st[15] ^ st[0]) << (16)) |
                        ((st[15] ^ st[0]) >> (32 - (16))));
    st[10] += st[15];
    st[5] = (uint32_t)(((st[5] ^ st[10]) << (12)) |
                       ((st[5] ^ st[10]) >> (32 - (12))));
    st[0] += st[5];
    st[15] = (uint32_t)(((st[15] ^ st[0]) << (8)) |
                        ((st[15] ^ st[0]) >> (32 - (8))));
    st[10] += st[15];
    st[5] = (uint32_t)(((st[5] ^ st[10]) << (7)) |
                       ((st[5] ^ st[10]) >> (32 - (7))));
    st[1] += st[6];
    st[12] = (uint32_t)(((st[12] ^ st[1]) << (16)) |
                        ((st[12] ^ st[1]) >> (32 - (16))));
    st[11] += st[12];
    st[6] = (uint32_t)(((st[6] ^ st[11]) << (12)) |
                       ((st[6] ^ st[11]) >> (32 - (12))));
    st[1] += st[6];
    st[12] = (uint32_t)(((st[12] ^ st[1]) << (8)) |
                        ((st[12] ^ st[1]) >> (32 - (8))));
    st[11] += st[12];
    st[6] = (uint32_t)(((st[6] ^ st[11]) << (7)) |
                       ((st[6] ^ st[11]) >> (32 - (7))));
    st[2] += st[7];
    st[13] = (uint32_t)(((st[13] ^ st[2]) << (16)) |
                        ((st[13] ^ st[2]) >> (32 - (16))));
    st[8] += st[13];
    st[7] = (uint32_t)(((st[7] ^ st[8]) << (12)) |
                       ((st[7] ^ st[8]) >> (32 - (12))));
    st[2] += st[7];
    st[13] = (uint32_t)(((st[13] ^ st[2]) << (8)) |
                        ((st[13] ^ st[2]) >> (32 - (8))));
    st[8] += st[13];
    st[7] =
        (uint32_t)(((st[7] ^ st[8]) << (7)) | ((st[7] ^ st[8]) >> (32 - (7))));
    st[3] += st[4];
    st[14] = (uint32_t)(((st[14] ^ st[3]) << (16)) |
                        ((st[14] ^ st[3]) >> (32 - (16))));
    st[9] += st[14];
    st[4] = (uint32_t)(((st[4] ^ st[9]) << (12)) |
                       ((st[4] ^ st[9]) >> (32 - (12))));
    st[3] += st[4];
    st[14] = (uint32_t)(((st[14] ^ st[3]) << (8)) |
                        ((st[14] ^ st[3]) >> (32 - (8))));
    st[9] += st[14];
    st[4] =
        (uint32_t)(((st[4] ^ st[9]) << (7)) | ((st[4] ^ st[9]) >> (32 - (7))));
  }
}


x86 assembly (clang, -O0):
<CHACHA20_ROUNDS>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x14,-0xc(%rbp)
jge    1897 <CHACHA20_ROUNDS+0x797>
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    (%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x20(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x20(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    (%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x20(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x20(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x4(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x24(%rax),%ecx
mov    %ecx,0x24(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x24(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x24(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x4(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x24(%rax),%ecx
mov    %ecx,0x24(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x24(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x24(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x38(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x28(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x28(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x38(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x28(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x28(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x3c(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x2c(%rax),%ecx
mov    %ecx,0x2c(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x2c(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x2c(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x3c(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x2c(%rax),%ecx
mov    %ecx,0x2c(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x2c(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x2c(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    (%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x3c(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x28(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x28(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    (%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x3c(%rax)
mov    -0x8(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x28(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x28(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x4(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x2c(%rax),%ecx
mov    %ecx,0x2c(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x2c(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x2c(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x4(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x2c(%rax),%ecx
mov    %ecx,0x2c(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x2c(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x2c(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x20(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x20(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x8(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x20(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x20(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x38(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x24(%rax),%ecx
mov    %ecx,0x24(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x24(%rax),%ecx
shl    $0xc,%ecx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x24(%rdx),%eax
sar    $0x14,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%eax
sar    $0x18,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x38(%rax)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x24(%rax),%ecx
mov    %ecx,0x24(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x24(%rax),%ecx
shl    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x8(%rbp),%rdx
xor    0x24(%rdx),%eax
sar    $0x19,%eax
or     %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <CHACHA20_ROUNDS+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<CHACHA20_ROUNDS>:
movdqu (%rdi),%xmm2
movdqu 0x10(%rdi),%xmm0
movdqu 0x20(%rdi),%xmm1
movups 0x30(%rdi),%xmm3
pshufd $0x39,%xmm1,%xmm1
pshufd $0x39,%xmm0,%xmm0
mov    $0xfffffffe,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
pshufd $0x93,%xmm0,%xmm4
paddd  %xmm2,%xmm4
movaps %xmm3,%xmm2
shufps $0x30,%xmm4,%xmm2
movaps %xmm4,%xmm5
shufps $0x29,%xmm2,%xmm5
movaps %xmm4,%xmm2
shufps $0x30,%xmm3,%xmm2
shufps $0x29,%xmm2,%xmm3
xorps  %xmm5,%xmm3
movaps %xmm3,%xmm2
pslld  $0x10,%xmm2
psrad  $0x10,%xmm3
por    %xmm2,%xmm3
paddd  %xmm3,%xmm1
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm2
pslld  $0xc,%xmm2
psrad  $0x14,%xmm0
por    %xmm2,%xmm0
pshufd $0x93,%xmm0,%xmm2
paddd  %xmm4,%xmm2
pshufd $0x39,%xmm2,%xmm4
pxor   %xmm3,%xmm4
movdqa %xmm4,%xmm3
pslld  $0x8,%xmm3
psrad  $0x18,%xmm4
por    %xmm3,%xmm4
paddd  %xmm4,%xmm1
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm3
pslld  $0x7,%xmm3
psrad  $0x19,%xmm0
por    %xmm3,%xmm0
paddd  %xmm0,%xmm2
movdqa %xmm2,%xmm3
shufps $0x1,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x23,%xmm2,%xmm4
shufps $0x38,%xmm2,%xmm4
xorps  %xmm3,%xmm4
movaps %xmm4,%xmm3
pslld  $0x10,%xmm3
psrad  $0x10,%xmm4
por    %xmm3,%xmm4
movdqa %xmm4,%xmm5
shufps $0x10,%xmm1,%xmm5
shufps $0x32,%xmm1,%xmm5
shufps $0x32,%xmm4,%xmm1
shufps $0x92,%xmm4,%xmm1
paddd  %xmm1,%xmm5
pxor   %xmm5,%xmm0
movdqa %xmm0,%xmm1
pslld  $0xc,%xmm1
psrad  $0x14,%xmm0
por    %xmm1,%xmm0
paddd  %xmm0,%xmm2
pshufd $0x39,%xmm2,%xmm3
pxor   %xmm4,%xmm3
movdqa %xmm3,%xmm1
pslld  $0x8,%xmm1
psrad  $0x18,%xmm3
por    %xmm1,%xmm3
pshufd $0x4e,%xmm3,%xmm4
pshufd $0x93,%xmm5,%xmm1
paddd  %xmm4,%xmm1
pshufd $0x93,%xmm0,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm4,%xmm0
pslld  $0x7,%xmm0
psrad  $0x19,%xmm4
por    %xmm0,%xmm4
pshufd $0x39,%xmm4,%xmm0
add    $0x2,%eax
cmp    $0x12,%eax
jb     1130 <CHACHA20_ROUNDS+0x30>
movdqu %xmm4,0x10(%rdi)
movdqu %xmm2,(%rdi)
movups %xmm3,0x30(%rdi)
pshufd $0x93,%xmm1,%xmm0
movdqu %xmm0,0x20(%rdi)
ret

LLVM IR (-O0):
define void @CHACHA20_ROUNDS(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
store i32* %0, i32** %2
store i32 0, i32* %3
br label %4
4: ; preds = %840, %1
%5 = load i32, i32* %3
%6 = icmp slt i32 %5, 20
br i1 %6, label %7, label %843
7: ; preds = %4
%8 = load i32*, i32** %2
%9 = getelementptr inbounds i32, i32* %8, i64 4
%10 = load i32, i32* %9
%11 = load i32*, i32** %2
%12 = getelementptr inbounds i32, i32* %11, i64 0
%13 = load i32, i32* %12
%14 = add nsw i32 %13, %10
store i32 %14, i32* %12
%15 = load i32*, i32** %2
%16 = getelementptr inbounds i32, i32* %15, i64 12
%17 = load i32, i32* %16
%18 = load i32*, i32** %2
%19 = getelementptr inbounds i32, i32* %18, i64 0
%20 = load i32, i32* %19
%21 = xor i32 %17, %20
%22 = shl i32 %21, 16
%23 = load i32*, i32** %2
%24 = getelementptr inbounds i32, i32* %23, i64 12
%25 = load i32, i32* %24
%26 = load i32*, i32** %2
%27 = getelementptr inbounds i32, i32* %26, i64 0
%28 = load i32, i32* %27
%29 = xor i32 %25, %28
%30 = ashr i32 %29, 16
%31 = or i32 %22, %30
%32 = load i32*, i32** %2
%33 = getelementptr inbounds i32, i32* %32, i64 12
store i32 %31, i32* %33
%34 = load i32*, i32** %2
%35 = getelementptr inbounds i32, i32* %34, i64 12
%36 = load i32, i32* %35
%37 = load i32*, i32** %2
%38 = getelementptr inbounds i32, i32* %37, i64 8
%39 = load i32, i32* %38
%40 = add nsw i32 %39, %36
store i32 %40, i32* %38
%41 = load i32*, i32** %2
%42 = getelementptr inbounds i32, i32* %41, i64 4
%43 = load i32, i32* %42
%44 = load i32*, i32** %2
%45 = getelementptr inbounds i32, i32* %44, i64 8
%46 = load i32, i32* %45
%47 = xor i32 %43, %46
%48 = shl i32 %47, 12
%49 = load i32*, i32** %2
%50 = getelementptr inbounds i32, i32* %49, i64 4
%51 = load i32, i32* %50
%52 = load i32*, i32** %2
%53 = getelementptr inbounds i32, i32* %52, i64 8
%54 = load i32, i32* %53
%55 = xor i32 %51, %54
%56 = ashr i32 %55, 20
%57 = or i32 %48, %56
%58 = load i32*, i32** %2
%59 = getelementptr inbounds i32, i32* %58, i64 4
store i32 %57, i32* %59
%60 = load i32*, i32** %2
%61 = getelementptr inbounds i32, i32* %60, i64 4
%62 = load i32, i32* %61
%63 = load i32*, i32** %2
%64 = getelementptr inbounds i32, i32* %63, i64 0
%65 = load i32, i32* %64
%66 = add nsw i32 %65, %62
store i32 %66, i32* %64
%67 = load i32*, i32** %2
%68 = getelementptr inbounds i32, i32* %67, i64 12
%69 = load i32, i32* %68
%70 = load i32*, i32** %2
%71 = getelementptr inbounds i32, i32* %70, i64 0
%72 = load i32, i32* %71
%73 = xor i32 %69, %72
%74 = shl i32 %73, 8
%75 = load i32*, i32** %2
%76 = getelementptr inbounds i32, i32* %75, i64 12
%77 = load i32, i32* %76
%78 = load i32*, i32** %2
%79 = getelementptr inbounds i32, i32* %78, i64 0
%80 = load i32, i32* %79
%81 = xor i32 %77, %80
%82 = ashr i32 %81, 24
%83 = or i32 %74, %82
%84 = load i32*, i32** %2
%85 = getelementptr inbounds i32, i32* %84, i64 12
store i32 %83, i32* %85
%86 = load i32*, i32** %2
%87 = getelementptr inbounds i32, i32* %86, i64 12
%88 = load i32, i32* %87
%89 = load i32*, i32** %2
%90 = getelementptr inbounds i32, i32* %89, i64 8
%91 = load i32, i32* %90
%92 = add nsw i32 %91, %88
store i32 %92, i32* %90
%93 = load i32*, i32** %2
%94 = getelementptr inbounds i32, i32* %93, i64 4
%95 = load i32, i32* %94
%96 = load i32*, i32** %2
%97 = getelementptr inbounds i32, i32* %96, i64 8
%98 = load i32, i32* %97
%99 = xor i32 %95, %98
%100 = shl i32 %99, 7
%101 = load i32*, i32** %2
%102 = getelementptr inbounds i32, i32* %101, i64 4
%103 = load i32, i32* %102
%104 = load i32*, i32** %2
%105 = getelementptr inbounds i32, i32* %104, i64 8
%106 = load i32, i32* %105
%107 = xor i32 %103, %106
%108 = ashr i32 %107, 25
%109 = or i32 %100, %108
%110 = load i32*, i32** %2
%111 = getelementptr inbounds i32, i32* %110, i64 4
store i32 %109, i32* %111
%112 = load i32*, i32** %2
%113 = getelementptr inbounds i32, i32* %112, i64 5
%114 = load i32, i32* %113
%115 = load i32*, i32** %2
%116 = getelementptr inbounds i32, i32* %115, i64 1
%117 = load i32, i32* %116
%118 = add nsw i32 %117, %114
store i32 %118, i32* %116
%119 = load i32*, i32** %2
%120 = getelementptr inbounds i32, i32* %119, i64 13
%121 = load i32, i32* %120
%122 = load i32*, i32** %2
%123 = getelementptr inbounds i32, i32* %122, i64 1
%124 = load i32, i32* %123
%125 = xor i32 %121, %124
%126 = shl i32 %125, 16
%127 = load i32*, i32** %2
%128 = getelementptr inbounds i32, i32* %127, i64 13
%129 = load i32, i32* %128
%130 = load i32*, i32** %2
%131 = getelementptr inbounds i32, i32* %130, i64 1
%132 = load i32, i32* %131
%133 = xor i32 %129, %132
%134 = ashr i32 %133, 16
%135 = or i32 %126, %134
%136 = load i32*, i32** %2
%137 = getelementptr inbounds i32, i32* %136, i64 13
store i32 %135, i32* %137
%138 = load i32*, i32** %2
%139 = getelementptr inbounds i32, i32* %138, i64 13
%140 = load i32, i32* %139
%141 = load i32*, i32** %2
%142 = getelementptr inbounds i32, i32* %141, i64 9
%143 = load i32, i32* %142
%144 = add nsw i32 %143, %140
store i32 %144, i32* %142
%145 = load i32*, i32** %2
%146 = getelementptr inbounds i32, i32* %145, i64 5
%147 = load i32, i32* %146
%148 = load i32*, i32** %2
%149 = getelementptr inbounds i32, i32* %148, i64 9
%150 = load i32, i32* %149
%151 = xor i32 %147, %150
%152 = shl i32 %151, 12
%153 = load i32*, i32** %2
%154 = getelementptr inbounds i32, i32* %153, i64 5
%155 = load i32, i32* %154
%156 = load i32*, i32** %2
%157 = getelementptr inbounds i32, i32* %156, i64 9
%158 = load i32, i32* %157
%159 = xor i32 %155, %158
%160 = ashr i32 %159, 20
%161 = or i32 %152, %160
%162 = load i32*, i32** %2
%163 = getelementptr inbounds i32, i32* %162, i64 5
store i32 %161, i32* %163
%164 = load i32*, i32** %2
%165 = getelementptr inbounds i32, i32* %164, i64 5
%166 = load i32, i32* %165
%167 = load i32*, i32** %2
%168 = getelementptr inbounds i32, i32* %167, i64 1
%169 = load i32, i32* %168
%170 = add nsw i32 %169, %166
store i32 %170, i32* %168
%171 = load i32*, i32** %2
%172 = getelementptr inbounds i32, i32* %171, i64 13
%173 = load i32, i32* %172
%174 = load i32*, i32** %2
%175 = getelementptr inbounds i32, i32* %174, i64 1
%176 = load i32, i32* %175
%177 = xor i32 %173, %176
%178 = shl i32 %177, 8
%179 = load i32*, i32** %2
%180 = getelementptr inbounds i32, i32* %179, i64 13
%181 = load i32, i32* %180
%182 = load i32*, i32** %2
%183 = getelementptr inbounds i32, i32* %182, i64 1
%184 = load i32, i32* %183
%185 = xor i32 %181, %184
%186 = ashr i32 %185, 24
%187 = or i32 %178, %186
%188 = load i32*, i32** %2
%189 = getelementptr inbounds i32, i32* %188, i64 13
store i32 %187, i32* %189
%190 = load i32*, i32** %2
%191 = getelementptr inbounds i32, i32* %190, i64 13
%192 = load i32, i32* %191
%193 = load i32*, i32** %2
%194 = getelementptr inbounds i32, i32* %193, i64 9
%195 = load i32, i32* %194
%196 = add nsw i32 %195, %192
store i32 %196, i32* %194
%197 = load i32*, i32** %2
%198 = getelementptr inbounds i32, i32* %197, i64 5
%199 = load i32, i32* %198
%200 = load i32*, i32** %2
%201 = getelementptr inbounds i32, i32* %200, i64 9
%202 = load i32, i32* %201
%203 = xor i32 %199, %202
%204 = shl i32 %203, 7
%205 = load i32*, i32** %2
%206 = getelementptr inbounds i32, i32* %205, i64 5
%207 = load i32, i32* %206
%208 = load i32*, i32** %2
%209 = getelementptr inbounds i32, i32* %208, i64 9
%210 = load i32, i32* %209
%211 = xor i32 %207, %210
%212 = ashr i32 %211, 25
%213 = or i32 %204, %212
%214 = load i32*, i32** %2
%215 = getelementptr inbounds i32, i32* %214, i64 5
store i32 %213, i32* %215
%216 = load i32*, i32** %2
%217 = getelementptr inbounds i32, i32* %216, i64 6
%218 = load i32, i32* %217
%219 = load i32*, i32** %2
%220 = getelementptr inbounds i32, i32* %219, i64 2
%221 = load i32, i32* %220
%222 = add nsw i32 %221, %218
store i32 %222, i32* %220
%223 = load i32*, i32** %2
%224 = getelementptr inbounds i32, i32* %223, i64 14
%225 = load i32, i32* %224
%226 = load i32*, i32** %2
%227 = getelementptr inbounds i32, i32* %226, i64 2
%228 = load i32, i32* %227
%229 = xor i32 %225, %228
%230 = shl i32 %229, 16
%231 = load i32*, i32** %2
%232 = getelementptr inbounds i32, i32* %231, i64 14
%233 = load i32, i32* %232
%234 = load i32*, i32** %2
%235 = getelementptr inbounds i32, i32* %234, i64 2
%236 = load i32, i32* %235
%237 = xor i32 %233, %236
%238 = ashr i32 %237, 16
%239 = or i32 %230, %238
%240 = load i32*, i32** %2
%241 = getelementptr inbounds i32, i32* %240, i64 14
store i32 %239, i32* %241
%242 = load i32*, i32** %2
%243 = getelementptr inbounds i32, i32* %242, i64 14
%244 = load i32, i32* %243
%245 = load i32*, i32** %2
%246 = getelementptr inbounds i32, i32* %245, i64 10
%247 = load i32, i32* %246
%248 = add nsw i32 %247, %244
store i32 %248, i32* %246
%249 = load i32*, i32** %2
%250 = getelementptr inbounds i32, i32* %249, i64 6
%251 = load i32, i32* %250
%252 = load i32*, i32** %2
%253 = getelementptr inbounds i32, i32* %252, i64 10
%254 = load i32, i32* %253
%255 = xor i32 %251, %254
%256 = shl i32 %255, 12
%257 = load i32*, i32** %2
%258 = getelementptr inbounds i32, i32* %257, i64 6
%259 = load i32, i32* %258
%260 = load i32*, i32** %2
%261 = getelementptr inbounds i32, i32* %260, i64 10
%262 = load i32, i32* %261
%263 = xor i32 %259, %262
%264 = ashr i32 %263, 20
%265 = or i32 %256, %264
%266 = load i32*, i32** %2
%267 = getelementptr inbounds i32, i32* %266, i64 6
store i32 %265, i32* %267
%268 = load i32*, i32** %2
%269 = getelementptr inbounds i32, i32* %268, i64 6
%270 = load i32, i32* %269
%271 = load i32*, i32** %2
%272 = getelementptr inbounds i32, i32* %271, i64 2
%273 = load i32, i32* %272
%274 = add nsw i32 %273, %270
store i32 %274, i32* %272
%275 = load i32*, i32** %2
%276 = getelementptr inbounds i32, i32* %275, i64 14
%277 = load i32, i32* %276
%278 = load i32*, i32** %2
%279 = getelementptr inbounds i32, i32* %278, i64 2
%280 = load i32, i32* %279
%281 = xor i32 %277, %280
%282 = shl i32 %281, 8
%283 = load i32*, i32** %2
%284 = getelementptr inbounds i32, i32* %283, i64 14
%285 = load i32, i32* %284
%286 = load i32*, i32** %2
%287 = getelementptr inbounds i32, i32* %286, i64 2
%288 = load i32, i32* %287
%289 = xor i32 %285, %288
%290 = ashr i32 %289, 24
%291 = or i32 %282, %290
%292 = load i32*, i32** %2
%293 = getelementptr inbounds i32, i32* %292, i64 14
store i32 %291, i32* %293
%294 = load i32*, i32** %2
%295 = getelementptr inbounds i32, i32* %294, i64 14
%296 = load i32, i32* %295
%297 = load i32*, i32** %2
%298 = getelementptr inbounds i32, i32* %297, i64 10
%299 = load i32, i32* %298
%300 = add nsw i32 %299, %296
store i32 %300, i32* %298
%301 = load i32*, i32** %2
%302 = getelementptr inbounds i32, i32* %301, i64 6
%303 = load i32, i32* %302
%304 = load i32*, i32** %2
%305 = getelementptr inbounds i32, i32* %304, i64 10
%306 = load i32, i32* %305
%307 = xor i32 %303, %306
%308 = shl i32 %307, 7
%309 = load i32*, i32** %2
%310 = getelementptr inbounds i32, i32* %309, i64 6
%311 = load i32, i32* %310
%312 = load i32*, i32** %2
%313 = getelementptr inbounds i32, i32* %312, i64 10
%314 = load i32, i32* %313
%315 = xor i32 %311, %314
%316 = ashr i32 %315, 25
%317 = or i32 %308, %316
%318 = load i32*, i32** %2
%319 = getelementptr inbounds i32, i32* %318, i64 6
store i32 %317, i32* %319
%320 = load i32*, i32** %2
%321 = getelementptr inbounds i32, i32* %320, i64 7
%322 = load i32, i32* %321
%323 = load i32*, i32** %2
%324 = getelementptr inbounds i32, i32* %323, i64 3
%325 = load i32, i32* %324
%326 = add nsw i32 %325, %322
store i32 %326, i32* %324
%327 = load i32*, i32** %2
%328 = getelementptr inbounds i32, i32* %327, i64 15
%329 = load i32, i32* %328
%330 = load i32*, i32** %2
%331 = getelementptr inbounds i32, i32* %330, i64 3
%332 = load i32, i32* %331
%333 = xor i32 %329, %332
%334 = shl i32 %333, 16
%335 = load i32*, i32** %2
%336 = getelementptr inbounds i32, i32* %335, i64 15
%337 = load i32, i32* %336
%338 = load i32*, i32** %2
%339 = getelementptr inbounds i32, i32* %338, i64 3
%340 = load i32, i32* %339
%341 = xor i32 %337, %340
%342 = ashr i32 %341, 16
%343 = or i32 %334, %342
%344 = load i32*, i32** %2
%345 = getelementptr inbounds i32, i32* %344, i64 15
store i32 %343, i32* %345
%346 = load i32*, i32** %2
%347 = getelementptr inbounds i32, i32* %346, i64 15
%348 = load i32, i32* %347
%349 = load i32*, i32** %2
%350 = getelementptr inbounds i32, i32* %349, i64 11
%351 = load i32, i32* %350
%352 = add nsw i32 %351, %348
store i32 %352, i32* %350
%353 = load i32*, i32** %2
%354 = getelementptr inbounds i32, i32* %353, i64 7
%355 = load i32, i32* %354
%356 = load i32*, i32** %2
%357 = getelementptr inbounds i32, i32* %356, i64 11
%358 = load i32, i32* %357
%359 = xor i32 %355, %358
%360 = shl i32 %359, 12
%361 = load i32*, i32** %2
%362 = getelementptr inbounds i32, i32* %361, i64 7
%363 = load i32, i32* %362
%364 = load i32*, i32** %2
%365 = getelementptr inbounds i32, i32* %364, i64 11
%366 = load i32, i32* %365
%367 = xor i32 %363, %366
%368 = ashr i32 %367, 20
%369 = or i32 %360, %368
%370 = load i32*, i32** %2
%371 = getelementptr inbounds i32, i32* %370, i64 7
store i32 %369, i32* %371
%372 = load i32*, i32** %2
%373 = getelementptr inbounds i32, i32* %372, i64 7
%374 = load i32, i32* %373
%375 = load i32*, i32** %2
%376 = getelementptr inbounds i32, i32* %375, i64 3
%377 = load i32, i32* %376
%378 = add nsw i32 %377, %374
store i32 %378, i32* %376
%379 = load i32*, i32** %2
%380 = getelementptr inbounds i32, i32* %379, i64 15
%381 = load i32, i32* %380
%382 = load i32*, i32** %2
%383 = getelementptr inbounds i32, i32* %382, i64 3
%384 = load i32, i32* %383
%385 = xor i32 %381, %384
%386 = shl i32 %385, 8
%387 = load i32*, i32** %2
%388 = getelementptr inbounds i32, i32* %387, i64 15
%389 = load i32, i32* %388
%390 = load i32*, i32** %2
%391 = getelementptr inbounds i32, i32* %390, i64 3
%392 = load i32, i32* %391
%393 = xor i32 %389, %392
%394 = ashr i32 %393, 24
%395 = or i32 %386, %394
%396 = load i32*, i32** %2
%397 = getelementptr inbounds i32, i32* %396, i64 15
store i32 %395, i32* %397
%398 = load i32*, i32** %2
%399 = getelementptr inbounds i32, i32* %398, i64 15
%400 = load i32, i32* %399
%401 = load i32*, i32** %2
%402 = getelementptr inbounds i32, i32* %401, i64 11
%403 = load i32, i32* %402
%404 = add nsw i32 %403, %400
store i32 %404, i32* %402
%405 = load i32*, i32** %2
%406 = getelementptr inbounds i32, i32* %405, i64 7
%407 = load i32, i32* %406
%408 = load i32*, i32** %2
%409 = getelementptr inbounds i32, i32* %408, i64 11
%410 = load i32, i32* %409
%411 = xor i32 %407, %410
%412 = shl i32 %411, 7
%413 = load i32*, i32** %2
%414 = getelementptr inbounds i32, i32* %413, i64 7
%415 = load i32, i32* %414
%416 = load i32*, i32** %2
%417 = getelementptr inbounds i32, i32* %416, i64 11
%418 = load i32, i32* %417
%419 = xor i32 %415, %418
%420 = ashr i32 %419, 25
%421 = or i32 %412, %420
%422 = load i32*, i32** %2
%423 = getelementptr inbounds i32, i32* %422, i64 7
store i32 %421, i32* %423
%424 = load i32*, i32** %2
%425 = getelementptr inbounds i32, i32* %424, i64 5
%426 = load i32, i32* %425
%427 = load i32*, i32** %2
%428 = getelementptr inbounds i32, i32* %427, i64 0
%429 = load i32, i32* %428
%430 = add nsw i32 %429, %426
store i32 %430, i32* %428
%431 = load i32*, i32** %2
%432 = getelementptr inbounds i32, i32* %431, i64 15
%433 = load i32, i32* %432
%434 = load i32*, i32** %2
%435 = getelementptr inbounds i32, i32* %434, i64 0
%436 = load i32, i32* %435
%437 = xor i32 %433, %436
%438 = shl i32 %437, 16
%439 = load i32*, i32** %2
%440 = getelementptr inbounds i32, i32* %439, i64 15
%441 = load i32, i32* %440
%442 = load i32*, i32** %2
%443 = getelementptr inbounds i32, i32* %442, i64 0
%444 = load i32, i32* %443
%445 = xor i32 %441, %444
%446 = ashr i32 %445, 16
%447 = or i32 %438, %446
%448 = load i32*, i32** %2
%449 = getelementptr inbounds i32, i32* %448, i64 15
store i32 %447, i32* %449
%450 = load i32*, i32** %2
%451 = getelementptr inbounds i32, i32* %450, i64 15
%452 = load i32, i32* %451
%453 = load i32*, i32** %2
%454 = getelementptr inbounds i32, i32* %453, i64 10
%455 = load i32, i32* %454
%456 = add nsw i32 %455, %452
store i32 %456, i32* %454
%457 = load i32*, i32** %2
%458 = getelementptr inbounds i32, i32* %457, i64 5
%459 = load i32, i32* %458
%460 = load i32*, i32** %2
%461 = getelementptr inbounds i32, i32* %460, i64 10
%462 = load i32, i32* %461
%463 = xor i32 %459, %462
%464 = shl i32 %463, 12
%465 = load i32*, i32** %2
%466 = getelementptr inbounds i32, i32* %465, i64 5
%467 = load i32, i32* %466
%468 = load i32*, i32** %2
%469 = getelementptr inbounds i32, i32* %468, i64 10
%470 = load i32, i32* %469
%471 = xor i32 %467, %470
%472 = ashr i32 %471, 20
%473 = or i32 %464, %472
%474 = load i32*, i32** %2
%475 = getelementptr inbounds i32, i32* %474, i64 5
store i32 %473, i32* %475
%476 = load i32*, i32** %2
%477 = getelementptr inbounds i32, i32* %476, i64 5
%478 = load i32, i32* %477
%479 = load i32*, i32** %2
%480 = getelementptr inbounds i32, i32* %479, i64 0
%481 = load i32, i32* %480
%482 = add nsw i32 %481, %478
store i32 %482, i32* %480
%483 = load i32*, i32** %2
%484 = getelementptr inbounds i32, i32* %483, i64 15
%485 = load i32, i32* %484
%486 = load i32*, i32** %2
%487 = getelementptr inbounds i32, i32* %486, i64 0
%488 = load i32, i32* %487
%489 = xor i32 %485, %488
%490 = shl i32 %489, 8
%491 = load i32*, i32** %2
%492 = getelementptr inbounds i32, i32* %491, i64 15
%493 = load i32, i32* %492
%494 = load i32*, i32** %2
%495 = getelementptr inbounds i32, i32* %494, i64 0
%496 = load i32, i32* %495
%497 = xor i32 %493, %496
%498 = ashr i32 %497, 24
%499 = or i32 %490, %498
%500 = load i32*, i32** %2
%501 = getelementptr inbounds i32, i32* %500, i64 15
store i32 %499, i32* %501
%502 = load i32*, i32** %2
%503 = getelementptr inbounds i32, i32* %502, i64 15
%504 = load i32, i32* %503
%505 = load i32*, i32** %2
%506 = getelementptr inbounds i32, i32* %505, i64 10
%507 = load i32, i32* %506
%508 = add nsw i32 %507, %504
store i32 %508, i32* %506
%509 = load i32*, i32** %2
%510 = getelementptr inbounds i32, i32* %509, i64 5
%511 = load i32, i32* %510
%512 = load i32*, i32** %2
%513 = getelementptr inbounds i32, i32* %512, i64 10
%514 = load i32, i32* %513
%515 = xor i32 %511, %514
%516 = shl i32 %515, 7
%517 = load i32*, i32** %2
%518 = getelementptr inbounds i32, i32* %517, i64 5
%519 = load i32, i32* %518
%520 = load i32*, i32** %2
%521 = getelementptr inbounds i32, i32* %520, i64 10
%522 = load i32, i32* %521
%523 = xor i32 %519, %522
%524 = ashr i32 %523, 25
%525 = or i32 %516, %524
%526 = load i32*, i32** %2
%527 = getelementptr inbounds i32, i32* %526, i64 5
store i32 %525, i32* %527
%528 = load i32*, i32** %2
%529 = getelementptr inbounds i32, i32* %528, i64 6
%530 = load i32, i32* %529
%531 = load i32*, i32** %2
%532 = getelementptr inbounds i32, i32* %531, i64 1
%533 = load i32, i32* %532
%534 = add nsw i32 %533, %530
store i32 %534, i32* %532
%535 = load i32*, i32** %2
%536 = getelementptr inbounds i32, i32* %535, i64 12
%537 = load i32, i32* %536
%538 = load i32*, i32** %2
%539 = getelementptr inbounds i32, i32* %538, i64 1
%540 = load i32, i32* %539
%541 = xor i32 %537, %540
%542 = shl i32 %541, 16
%543 = load i32*, i32** %2
%544 = getelementptr inbounds i32, i32* %543, i64 12
%545 = load i32, i32* %544
%546 = load i32*, i32** %2
%547 = getelementptr inbounds i32, i32* %546, i64 1
%548 = load i32, i32* %547
%549 = xor i32 %545, %548
%550 = ashr i32 %549, 16
%551 = or i32 %542, %550
%552 = load i32*, i32** %2
%553 = getelementptr inbounds i32, i32* %552, i64 12
store i32 %551, i32* %553
%554 = load i32*, i32** %2
%555 = getelementptr inbounds i32, i32* %554, i64 12
%556 = load i32, i32* %555
%557 = load i32*, i32** %2
%558 = getelementptr inbounds i32, i32* %557, i64 11
%559 = load i32, i32* %558
%560 = add nsw i32 %559, %556
store i32 %560, i32* %558
%561 = load i32*, i32** %2
%562 = getelementptr inbounds i32, i32* %561, i64 6
%563 = load i32, i32* %562
%564 = load i32*, i32** %2
%565 = getelementptr inbounds i32, i32* %564, i64 11
%566 = load i32, i32* %565
%567 = xor i32 %563, %566
%568 = shl i32 %567, 12
%569 = load i32*, i32** %2
%570 = getelementptr inbounds i32, i32* %569, i64 6
%571 = load i32, i32* %570
%572 = load i32*, i32** %2
%573 = getelementptr inbounds i32, i32* %572, i64 11
%574 = load i32, i32* %573
%575 = xor i32 %571, %574
%576 = ashr i32 %575, 20
%577 = or i32 %568, %576
%578 = load i32*, i32** %2
%579 = getelementptr inbounds i32, i32* %578, i64 6
store i32 %577, i32* %579
%580 = load i32*, i32** %2
%581 = getelementptr inbounds i32, i32* %580, i64 6
%582 = load i32, i32* %581
%583 = load i32*, i32** %2
%584 = getelementptr inbounds i32, i32* %583, i64 1
%585 = load i32, i32* %584
%586 = add nsw i32 %585, %582
store i32 %586, i32* %584
%587 = load i32*, i32** %2
%588 = getelementptr inbounds i32, i32* %587, i64 12
%589 = load i32, i32* %588
%590 = load i32*, i32** %2
%591 = getelementptr inbounds i32, i32* %590, i64 1
%592 = load i32, i32* %591
%593 = xor i32 %589, %592
%594 = shl i32 %593, 8
%595 = load i32*, i32** %2
%596 = getelementptr inbounds i32, i32* %595, i64 12
%597 = load i32, i32* %596
%598 = load i32*, i32** %2
%599 = getelementptr inbounds i32, i32* %598, i64 1
%600 = load i32, i32* %599
%601 = xor i32 %597, %600
%602 = ashr i32 %601, 24
%603 = or i32 %594, %602
%604 = load i32*, i32** %2
%605 = getelementptr inbounds i32, i32* %604, i64 12
store i32 %603, i32* %605
%606 = load i32*, i32** %2
%607 = getelementptr inbounds i32, i32* %606, i64 12
%608 = load i32, i32* %607
%609 = load i32*, i32** %2
%610 = getelementptr inbounds i32, i32* %609, i64 11
%611 = load i32, i32* %610
%612 = add nsw i32 %611, %608
store i32 %612, i32* %610
%613 = load i32*, i32** %2
%614 = getelementptr inbounds i32, i32* %613, i64 6
%615 = load i32, i32* %614
%616 = load i32*, i32** %2
%617 = getelementptr inbounds i32, i32* %616, i64 11
%618 = load i32, i32* %617
%619 = xor i32 %615, %618
%620 = shl i32 %619, 7
%621 = load i32*, i32** %2
%622 = getelementptr inbounds i32, i32* %621, i64 6
%623 = load i32, i32* %622
%624 = load i32*, i32** %2
%625 = getelementptr inbounds i32, i32* %624, i64 11
%626 = load i32, i32* %625
%627 = xor i32 %623, %626
%628 = ashr i32 %627, 25
%629 = or i32 %620, %628
%630 = load i32*, i32** %2
%631 = getelementptr inbounds i32, i32* %630, i64 6
store i32 %629, i32* %631
%632 = load i32*, i32** %2
%633 = getelementptr inbounds i32, i32* %632, i64 7
%634 = load i32, i32* %633
%635 = load i32*, i32** %2
%636 = getelementptr inbounds i32, i32* %635, i64 2
%637 = load i32, i32* %636
%638 = add nsw i32 %637, %634
store i32 %638, i32* %636
%639 = load i32*, i32** %2
%640 = getelementptr inbounds i32, i32* %639, i64 13
%641 = load i32, i32* %640
%642 = load i32*, i32** %2
%643 = getelementptr inbounds i32, i32* %642, i64 2
%644 = load i32, i32* %643
%645 = xor i32 %641, %644
%646 = shl i32 %645, 16
%647 = load i32*, i32** %2
%648 = getelementptr inbounds i32, i32* %647, i64 13
%649 = load i32, i32* %648
%650 = load i32*, i32** %2
%651 = getelementptr inbounds i32, i32* %650, i64 2
%652 = load i32, i32* %651
%653 = xor i32 %649, %652
%654 = ashr i32 %653, 16
%655 = or i32 %646, %654
%656 = load i32*, i32** %2
%657 = getelementptr inbounds i32, i32* %656, i64 13
store i32 %655, i32* %657
%658 = load i32*, i32** %2
%659 = getelementptr inbounds i32, i32* %658, i64 13
%660 = load i32, i32* %659
%661 = load i32*, i32** %2
%662 = getelementptr inbounds i32, i32* %661, i64 8
%663 = load i32, i32* %662
%664 = add nsw i32 %663, %660
store i32 %664, i32* %662
%665 = load i32*, i32** %2
%666 = getelementptr inbounds i32, i32* %665, i64 7
%667 = load i32, i32* %666
%668 = load i32*, i32** %2
%669 = getelementptr inbounds i32, i32* %668, i64 8
%670 = load i32, i32* %669
%671 = xor i32 %667, %670
%672 = shl i32 %671, 12
%673 = load i32*, i32** %2
%674 = getelementptr inbounds i32, i32* %673, i64 7
%675 = load i32, i32* %674
%676 = load i32*, i32** %2
%677 = getelementptr inbounds i32, i32* %676, i64 8
%678 = load i32, i32* %677
%679 = xor i32 %675, %678
%680 = ashr i32 %679, 20
%681 = or i32 %672, %680
%682 = load i32*, i32** %2
%683 = getelementptr inbounds i32, i32* %682, i64 7
store i32 %681, i32* %683
%684 = load i32*, i32** %2
%685 = getelementptr inbounds i32, i32* %684, i64 7
%686 = load i32, i32* %685
%687 = load i32*, i32** %2
%688 = getelementptr inbounds i32, i32* %687, i64 2
%689 = load i32, i32* %688
%690 = add nsw i32 %689, %686
store i32 %690, i32* %688
%691 = load i32*, i32** %2
%692 = getelementptr inbounds i32, i32* %691, i64 13
%693 = load i32, i32* %692
%694 = load i32*, i32** %2
%695 = getelementptr inbounds i32, i32* %694, i64 2
%696 = load i32, i32* %695
%697 = xor i32 %693, %696
%698 = shl i32 %697, 8
%699 = load i32*, i32** %2
%700 = getelementptr inbounds i32, i32* %699, i64 13
%701 = load i32, i32* %700
%702 = load i32*, i32** %2
%703 = getelementptr inbounds i32, i32* %702, i64 2
%704 = load i32, i32* %703
%705 = xor i32 %701, %704
%706 = ashr i32 %705, 24
%707 = or i32 %698, %706
%708 = load i32*, i32** %2
%709 = getelementptr inbounds i32, i32* %708, i64 13
store i32 %707, i32* %709
%710 = load i32*, i32** %2
%711 = getelementptr inbounds i32, i32* %710, i64 13
%712 = load i32, i32* %711
%713 = load i32*, i32** %2
%714 = getelementptr inbounds i32, i32* %713, i64 8
%715 = load i32, i32* %714
%716 = add nsw i32 %715, %712
store i32 %716, i32* %714
%717 = load i32*, i32** %2
%718 = getelementptr inbounds i32, i32* %717, i64 7
%719 = load i32, i32* %718
%720 = load i32*, i32** %2
%721 = getelementptr inbounds i32, i32* %720, i64 8
%722 = load i32, i32* %721
%723 = xor i32 %719, %722
%724 = shl i32 %723, 7
%725 = load i32*, i32** %2
%726 = getelementptr inbounds i32, i32* %725, i64 7
%727 = load i32, i32* %726
%728 = load i32*, i32** %2
%729 = getelementptr inbounds i32, i32* %728, i64 8
%730 = load i32, i32* %729
%731 = xor i32 %727, %730
%732 = ashr i32 %731, 25
%733 = or i32 %724, %732
%734 = load i32*, i32** %2
%735 = getelementptr inbounds i32, i32* %734, i64 7
store i32 %733, i32* %735
%736 = load i32*, i32** %2
%737 = getelementptr inbounds i32, i32* %736, i64 4
%738 = load i32, i32* %737
%739 = load i32*, i32** %2
%740 = getelementptr inbounds i32, i32* %739, i64 3
%741 = load i32, i32* %740
%742 = add nsw i32 %741, %738
store i32 %742, i32* %740
%743 = load i32*, i32** %2
%744 = getelementptr inbounds i32, i32* %743, i64 14
%745 = load i32, i32* %744
%746 = load i32*, i32** %2
%747 = getelementptr inbounds i32, i32* %746, i64 3
%748 = load i32, i32* %747
%749 = xor i32 %745, %748
%750 = shl i32 %749, 16
%751 = load i32*, i32** %2
%752 = getelementptr inbounds i32, i32* %751, i64 14
%753 = load i32, i32* %752
%754 = load i32*, i32** %2
%755 = getelementptr inbounds i32, i32* %754, i64 3
%756 = load i32, i32* %755
%757 = xor i32 %753, %756
%758 = ashr i32 %757, 16
%759 = or i32 %750, %758
%760 = load i32*, i32** %2
%761 = getelementptr inbounds i32, i32* %760, i64 14
store i32 %759, i32* %761
%762 = load i32*, i32** %2
%763 = getelementptr inbounds i32, i32* %762, i64 14
%764 = load i32, i32* %763
%765 = load i32*, i32** %2
%766 = getelementptr inbounds i32, i32* %765, i64 9
%767 = load i32, i32* %766
%768 = add nsw i32 %767, %764
store i32 %768, i32* %766
%769 = load i32*, i32** %2
%770 = getelementptr inbounds i32, i32* %769, i64 4
%771 = load i32, i32* %770
%772 = load i32*, i32** %2
%773 = getelementptr inbounds i32, i32* %772, i64 9
%774 = load i32, i32* %773
%775 = xor i32 %771, %774
%776 = shl i32 %775, 12
%777 = load i32*, i32** %2
%778 = getelementptr inbounds i32, i32* %777, i64 4
%779 = load i32, i32* %778
%780 = load i32*, i32** %2
%781 = getelementptr inbounds i32, i32* %780, i64 9
%782 = load i32, i32* %781
%783 = xor i32 %779, %782
%784 = ashr i32 %783, 20
%785 = or i32 %776, %784
%786 = load i32*, i32** %2
%787 = getelementptr inbounds i32, i32* %786, i64 4
store i32 %785, i32* %787
%788 = load i32*, i32** %2
%789 = getelementptr inbounds i32, i32* %788, i64 4
%790 = load i32, i32* %789
%791 = load i32*, i32** %2
%792 = getelementptr inbounds i32, i32* %791, i64 3
%793 = load i32, i32* %792
%794 = add nsw i32 %793, %790
store i32 %794, i32* %792
%795 = load i32*, i32** %2
%796 = getelementptr inbounds i32, i32* %795, i64 14
%797 = load i32, i32* %796
%798 = load i32*, i32** %2
%799 = getelementptr inbounds i32, i32* %798, i64 3
%800 = load i32, i32* %799
%801 = xor i32 %797, %800
%802 = shl i32 %801, 8
%803 = load i32*, i32** %2
%804 = getelementptr inbounds i32, i32* %803, i64 14
%805 = load i32, i32* %804
%806 = load i32*, i32** %2
%807 = getelementptr inbounds i32, i32* %806, i64 3
%808 = load i32, i32* %807
%809 = xor i32 %805, %808
%810 = ashr i32 %809, 24
%811 = or i32 %802, %810
%812 = load i32*, i32** %2
%813 = getelementptr inbounds i32, i32* %812, i64 14
store i32 %811, i32* %813
%814 = load i32*, i32** %2
%815 = getelementptr inbounds i32, i32* %814, i64 14
%816 = load i32, i32* %815
%817 = load i32*, i32** %2
%818 = getelementptr inbounds i32, i32* %817, i64 9
%819 = load i32, i32* %818
%820 = add nsw i32 %819, %816
store i32 %820, i32* %818
%821 = load i32*, i32** %2
%822 = getelementptr inbounds i32, i32* %821, i64 4
%823 = load i32, i32* %822
%824 = load i32*, i32** %2
%825 = getelementptr inbounds i32, i32* %824, i64 9
%826 = load i32, i32* %825
%827 = xor i32 %823, %826
%828 = shl i32 %827, 7
%829 = load i32*, i32** %2
%830 = getelementptr inbounds i32, i32* %829, i64 4
%831 = load i32, i32* %830
%832 = load i32*, i32** %2
%833 = getelementptr inbounds i32, i32* %832, i64 9
%834 = load i32, i32* %833
%835 = xor i32 %831, %834
%836 = ashr i32 %835, 25
%837 = or i32 %828, %836
%838 = load i32*, i32** %2
%839 = getelementptr inbounds i32, i32* %838, i64 4
store i32 %837, i32* %839
br label %840
840: ; preds = %7
%841 = load i32, i32* %3
%842 = add nsw i32 %841, 2
store i32 %842, i32* %3
br label %4
843: ; preds = %4
ret void
}

LLVM IR (-O2):
define void @CHACHA20_ROUNDS(i32* %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 4
%3 = getelementptr inbounds i32, i32* %0, i64 12
%4 = getelementptr inbounds i32, i32* %0, i64 8
%5 = bitcast i32* %2 to <4 x i32>*
%6 = load <4 x i32>, <4 x i32>* %5
%7 = bitcast i32* %0 to <4 x i32>*
%8 = load <4 x i32>, <4 x i32>* %7
%9 = bitcast i32* %3 to <4 x i32>*
%10 = load <4 x i32>, <4 x i32>* %9
%11 = bitcast i32* %4 to <4 x i32>*
%12 = load <4 x i32>, <4 x i32>* %11
%13 = shufflevector <4 x i32> %12, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
%14 = shufflevector <4 x i32> %6, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
br label %15
15: ; preds = %1, %15
%16 = phi i32 [ 0, %1 ], [ %74, %15 ]
%17 = phi <4 x i32> [ %13, %1 ], [ %68, %15 ]
%18 = phi <4 x i32> [ %14, %1 ], [ %76, %15 ]
%19 = phi <4 x i32> [ %8, %1 ], [ %60, %15 ]
%20 = phi <4 x i32> [ %10, %1 ], [ %65, %15 ]
%21 = shufflevector <4 x i32> %18, <4 x i32> undef, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%22 = add nsw <4 x i32> %19, %21
%23 = shufflevector <4 x i32> %22, <4 x i32> %20, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
%24 = shufflevector <4 x i32> %20, <4 x i32> %22, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
%25 = xor <4 x i32> %23, %24
%26 = shl <4 x i32> %25, <i32 16, i32 16, i32 16, i32 16>
%27 = ashr <4 x i32> %25, <i32 16, i32 16, i32 16, i32 16>
%28 = or <4 x i32> %26, %27
%29 = add nsw <4 x i32> %28, %17
%30 = xor <4 x i32> %29, %18
%31 = shl <4 x i32> %30, <i32 12, i32 12, i32 12, i32 12>
%32 = ashr <4 x i32> %30, <i32 20, i32 20, i32 20, i32 20>
%33 = or <4 x i32> %31, %32
%34 = shufflevector <4 x i32> %33, <4 x i32> undef, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%35 = add nsw <4 x i32> %34, %22
%36 = shufflevector <4 x i32> %35, <4 x i32> undef, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
%37 = xor <4 x i32> %36, %28
%38 = shl <4 x i32> %37, <i32 8, i32 8, i32 8, i32 8>
%39 = ashr <4 x i32> %37, <i32 24, i32 24, i32 24, i32 24>
%40 = or <4 x i32> %38, %39
%41 = add nsw <4 x i32> %40, %29
%42 = xor <4 x i32> %41, %33
%43 = shl <4 x i32> %42, <i32 7, i32 7, i32 7, i32 7>
%44 = ashr <4 x i32> %42, <i32 25, i32 25, i32 25, i32 25>
%45 = or <4 x i32> %43, %44
%46 = add nsw <4 x i32> %35, %45
%47 = shufflevector <4 x i32> %46, <4 x i32> %40, <4 x i32> <i32 1, i32 4, i32 5, i32 6>
%48 = shufflevector <4 x i32> %40, <4 x i32> %46, <4 x i32> <i32 3, i32 6, i32 7, i32 4>
%49 = xor <4 x i32> %47, %48
%50 = shl <4 x i32> %49, <i32 16, i32 16, i32 16, i32 16>
%51 = ashr <4 x i32> %49, <i32 16, i32 16, i32 16, i32 16>
%52 = or <4 x i32> %50, %51
%53 = shufflevector <4 x i32> %41, <4 x i32> %52, <4 x i32> <i32 7, i32 2, i32 5, i32 6>
%54 = shufflevector <4 x i32> %52, <4 x i32> %41, <4 x i32> <i32 5, i32 0, i32 7, i32 4>
%55 = add nsw <4 x i32> %53, %54
%56 = xor <4 x i32> %55, %45
%57 = shl <4 x i32> %56, <i32 12, i32 12, i32 12, i32 12>
%58 = ashr <4 x i32> %56, <i32 20, i32 20, i32 20, i32 20>
%59 = or <4 x i32> %57, %58
%60 = add nsw <4 x i32> %59, %46
%61 = shufflevector <4 x i32> %60, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
%62 = xor <4 x i32> %61, %52
%63 = shl <4 x i32> %62, <i32 8, i32 8, i32 8, i32 8>
%64 = ashr <4 x i32> %62, <i32 24, i32 24, i32 24, i32 24>
%65 = or <4 x i32> %63, %64
%66 = shufflevector <4 x i32> %65, <4 x i32> undef, <4 x i32> <i32 2, i32 3, i32 0, i32 1>
%67 = shufflevector <4 x i32> %55, <4 x i32> undef, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%68 = add nsw <4 x i32> %66, %67
%69 = shufflevector <4 x i32> %59, <4 x i32> poison, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%70 = xor <4 x i32> %68, %69
%71 = shl <4 x i32> %70, <i32 7, i32 7, i32 7, i32 7>
%72 = ashr <4 x i32> %70, <i32 25, i32 25, i32 25, i32 25>
%73 = or <4 x i32> %71, %72
%74 = add nuw nsw i32 %16, 2
%75 = icmp ult i32 %16, 18
%76 = shufflevector <4 x i32> %73, <4 x i32> undef, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
br i1 %75, label %15, label %77
77: ; preds = %15
%78 = bitcast i32* %2 to <4 x i32>*
store <4 x i32> %73, <4 x i32>* %78
%79 = bitcast i32* %0 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %79
%80 = bitcast i32* %3 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %80
%81 = shufflevector <4 x i32> %68, <4 x i32> poison, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%82 = bitcast i32* %4 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %82
ret void
}