#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 uint8_t;
typedef int uint32_t;

/* Variables and functions */
int /*<<< orphan*/ memcpy(int *, void const *, int);
int /*<<< orphan*/ memxor(int *, int *, int);
void bmw_small_f2(uint32_t *h, uint32_t *q, const void *m) {
  uint32_t xl = 0, xh;
  uint8_t i;
  for (i = 16; i < 24; ++i) {
    xl ^= q[i];
  }
  xh = xl;
  for (i = 24; i < 32; ++i) {
    xh ^= q[i];
  }
  memcpy(h, m, 16 * 4);
  h[0] ^= ((xh) << (5)) ^ ((q[16]) >> (5));
  h[1] ^= ((xh) >> (7)) ^ ((q[17]) << (8));
  h[2] ^= ((xh) >> (5)) ^ ((q[18]) << (5));
  h[3] ^= ((xh) >> (1)) ^ ((q[19]) << (5));
  h[4] ^= ((xh) >> (3)) ^ q[20];
  h[5] ^= ((xh) << (6)) ^ ((q[21]) >> (6));
  h[6] ^= ((xh) >> (4)) ^ ((q[22]) << (6));
  h[7] ^= ((xh) >> (11)) ^ ((q[23]) << (2));
  for (i = 0; i < 8; ++i) {
    h[i] += xl ^ q[24 + i] ^ q[i];
  }
  for (i = 0; i < 8; ++i) {
    h[8 + i] ^= xh ^ q[24 + i];
    h[8 + i] +=
        (((h[(4 + i) % 8]) << (i + 9)) | ((h[(4 + i) % 8]) >> (32 - (i + 9))));
  }
  memxor(q + 9, q + 16, 7 * 4);
  q[8] ^= q[23];
  h[8] += ((xl) << (8)) ^ q[8];
  h[9] += ((xl) >> (6)) ^ q[9];
  h[10] += ((xl) << (6)) ^ q[10];
  h[11] += ((xl) << (4)) ^ q[11];
  h[12] += ((xl) >> (3)) ^ q[12];
  h[13] += ((xl) >> (4)) ^ q[13];
  h[14] += ((xl) >> (7)) ^ q[14];
  h[15] += ((xl) >> (2)) ^ q[15];
}


x86 assembly (clang, -O0):
<bmw_small_f2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x10,-0x24(%rbp)
cmpl   $0x18,-0x24(%rbp)
jge    116b <bmw_small_f2+0x4b>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1142 <bmw_small_f2+0x22>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x18,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jge    11a1 <bmw_small_f2+0x81>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1178 <bmw_small_f2+0x58>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%eax
sar    $0x5,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x20(%rbp),%ecx
sar    $0x7,%ecx
mov    -0x10(%rbp),%rax
mov    0x44(%rax),%eax
shl    $0x8,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%ecx
sar    $0x5,%ecx
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%eax
shl    $0x5,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%ecx
sar    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    0x4c(%rax),%eax
shl    $0x5,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x20(%rbp),%ecx
sar    $0x3,%ecx
mov    -0x10(%rbp),%rax
xor    0x50(%rax),%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x20(%rbp),%ecx
shl    $0x6,%ecx
mov    -0x10(%rbp),%rax
mov    0x54(%rax),%eax
sar    $0x6,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x20(%rbp),%ecx
sar    $0x4,%ecx
mov    -0x10(%rbp),%rax
mov    0x58(%rax),%eax
shl    $0x6,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x20(%rbp),%ecx
sar    $0xb,%ecx
mov    -0x10(%rbp),%rax
mov    0x5c(%rax),%eax
shl    $0x2,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
movl   $0x0,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jge    12d7 <bmw_small_f2+0x1b7>
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x18,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xor    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1293 <bmw_small_f2+0x173>
movl   $0x0,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jge    1390 <bmw_small_f2+0x270>
mov    -0x20(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x18,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x38(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x24(%rbp),%ecx
add    $0x9,%ecx
shl    %cl,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x30(%rbp),%rax
mov    %edx,%ecx
mov    -0x28(%rbp),%edx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x24(%rbp),%esi
add    $0x9,%esi
mov    $0x20,%ecx
sub    %esi,%ecx
sar    %cl,%eax
or     %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12de <bmw_small_f2+0x1be>
mov    -0x10(%rbp),%rdi
add    $0x24,%rdi
mov    -0x10(%rbp),%rsi
add    $0x40,%rsi
mov    $0x1c,%edx
call   1030 <memxor@plt>
mov    -0x10(%rbp),%rax
mov    0x5c(%rax),%ecx
mov    -0x10(%rbp),%rax
xor    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x1c(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
xor    0x20(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x20(%rax),%ecx
mov    %ecx,0x20(%rax)
mov    -0x1c(%rbp),%ecx
sar    $0x6,%ecx
mov    -0x10(%rbp),%rax
xor    0x24(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x24(%rax),%ecx
mov    %ecx,0x24(%rax)
mov    -0x1c(%rbp),%ecx
shl    $0x6,%ecx
mov    -0x10(%rbp),%rax
xor    0x28(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
mov    -0x1c(%rbp),%ecx
shl    $0x4,%ecx
mov    -0x10(%rbp),%rax
xor    0x2c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x2c(%rax),%ecx
mov    %ecx,0x2c(%rax)
mov    -0x1c(%rbp),%ecx
sar    $0x3,%ecx
mov    -0x10(%rbp),%rax
xor    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x30(%rax),%ecx
mov    %ecx,0x30(%rax)
mov    -0x1c(%rbp),%ecx
sar    $0x4,%ecx
mov    -0x10(%rbp),%rax
xor    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x34(%rax),%ecx
mov    %ecx,0x34(%rax)
mov    -0x1c(%rbp),%ecx
sar    $0x7,%ecx
mov    -0x10(%rbp),%rax
xor    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x38(%rax),%ecx
mov    %ecx,0x38(%rax)
mov    -0x1c(%rbp),%ecx
sar    $0x2,%ecx
mov    -0x10(%rbp),%rax
xor    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
add    0x3c(%rax),%ecx
mov    %ecx,0x3c(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bmw_small_f2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
lea    0x40(%rsi),%r15
mov    0x44(%rsi),%r12d
xor    0x40(%rsi),%r12d
xor    0x48(%rsi),%r12d
xor    0x4c(%rsi),%r12d
xor    0x50(%rsi),%r12d
xor    0x54(%rsi),%r12d
xor    0x58(%rsi),%r12d
xor    0x5c(%rsi),%r12d
mov    0x60(%rsi),%r13d
xor    %r12d,%r13d
xor    0x64(%rsi),%r13d
xor    0x68(%rsi),%r13d
xor    0x6c(%rsi),%r13d
xor    0x70(%rsi),%r13d
xor    0x74(%rsi),%r13d
xor    0x78(%rsi),%r13d
xor    0x7c(%rsi),%r13d
mov    %rdx,%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
mov    %r13d,%eax
shl    $0x5,%eax
mov    0x40(%rbx),%r8d
sar    $0x5,%r8d
xor    %eax,%r8d
xor    (%r14),%r8d
mov    %r8d,(%r14)
mov    %r13d,%eax
sar    $0x7,%eax
mov    0x44(%rbx),%r9d
shl    $0x8,%r9d
xor    %eax,%r9d
xor    0x4(%r14),%r9d
mov    %r9d,0x4(%r14)
mov    %r13d,%eax
sar    $0x5,%eax
mov    0x48(%rbx),%r10d
shl    $0x5,%r10d
xor    %eax,%r10d
xor    0x8(%r14),%r10d
mov    %r10d,0x8(%r14)
mov    %r13d,%eax
sar    %eax
mov    0x4c(%rbx),%ecx
shl    $0x5,%ecx
xor    %eax,%ecx
xor    0xc(%r14),%ecx
mov    %ecx,0xc(%r14)
mov    %r13d,%edi
sar    $0x3,%edi
xor    0x50(%rbx),%edi
xor    0x10(%r14),%edi
mov    %edi,0x10(%r14)
mov    %r13d,%eax
shl    $0x6,%eax
mov    0x54(%rbx),%esi
sar    $0x6,%esi
xor    %eax,%esi
xor    0x14(%r14),%esi
mov    %esi,0x14(%r14)
mov    %r13d,%edx
sar    $0x4,%edx
mov    0x58(%rbx),%eax
shl    $0x6,%eax
xor    %edx,%eax
xor    0x18(%r14),%eax
mov    %eax,0x18(%r14)
mov    %r13d,%ebp
sar    $0xb,%ebp
mov    0x5c(%rbx),%edx
shl    $0x2,%edx
xor    %ebp,%edx
xor    0x1c(%r14),%edx
mov    %edx,0x1c(%r14)
mov    0x60(%rbx),%ebp
xor    %r12d,%ebp
xor    (%rbx),%ebp
add    %r8d,%ebp
mov    %ebp,(%r14)
mov    0x64(%rbx),%ebp
xor    %r12d,%ebp
xor    0x4(%rbx),%ebp
add    %r9d,%ebp
mov    %ebp,0x4(%r14)
mov    0x68(%rbx),%ebp
xor    %r12d,%ebp
xor    0x8(%rbx),%ebp
add    %r10d,%ebp
mov    %ebp,0x8(%r14)
mov    0x6c(%rbx),%ebp
xor    %r12d,%ebp
xor    0xc(%rbx),%ebp
add    %ecx,%ebp
mov    %ebp,0xc(%r14)
mov    0x70(%rbx),%ecx
xor    %r12d,%ecx
xor    0x10(%rbx),%ecx
add    %edi,%ecx
mov    %ecx,0x10(%r14)
mov    0x74(%rbx),%edi
xor    %r12d,%edi
xor    0x14(%rbx),%edi
add    %esi,%edi
mov    %edi,0x14(%r14)
mov    0x78(%rbx),%esi
xor    %r12d,%esi
xor    0x18(%rbx),%esi
add    %eax,%esi
mov    %esi,0x18(%r14)
mov    0x7c(%rbx),%eax
xor    %r12d,%eax
xor    0x1c(%rbx),%eax
add    %edx,%eax
mov    %eax,0x1c(%r14)
mov    0x60(%rbx),%edx
xor    %r13d,%edx
xor    0x20(%r14),%edx
mov    %ecx,%ebp
shl    $0x9,%ebp
sar    $0x17,%ecx
or     %ebp,%ecx
add    %edx,%ecx
mov    %ecx,0x20(%r14)
mov    0x64(%rbx),%ecx
xor    %r13d,%ecx
xor    0x24(%r14),%ecx
mov    %edi,%edx
shl    $0xa,%edx
sar    $0x16,%edi
or     %edx,%edi
add    %ecx,%edi
mov    %edi,0x24(%r14)
mov    0x68(%rbx),%ecx
xor    %r13d,%ecx
xor    0x28(%r14),%ecx
mov    %esi,%edx
shl    $0xb,%edx
sar    $0x15,%esi
or     %edx,%esi
add    %ecx,%esi
mov    %esi,0x28(%r14)
mov    0x6c(%rbx),%ecx
xor    %r13d,%ecx
xor    0x2c(%r14),%ecx
mov    %eax,%edx
shl    $0xc,%edx
sar    $0x14,%eax
or     %edx,%eax
add    %ecx,%eax
mov    %eax,0x2c(%r14)
mov    0x70(%rbx),%eax
xor    %r13d,%eax
xor    0x30(%r14),%eax
mov    (%r14),%ecx
mov    %ecx,%edx
shl    $0xd,%edx
sar    $0x13,%ecx
or     %edx,%ecx
add    %eax,%ecx
mov    %ecx,0x30(%r14)
mov    0x74(%rbx),%eax
xor    %r13d,%eax
xor    0x34(%r14),%eax
mov    0x4(%r14),%ecx
mov    %ecx,%edx
shl    $0xe,%edx
sar    $0x12,%ecx
or     %edx,%ecx
add    %eax,%ecx
mov    %ecx,0x34(%r14)
mov    0x78(%rbx),%eax
xor    %r13d,%eax
xor    0x38(%r14),%eax
mov    0x8(%r14),%ecx
mov    %ecx,%edx
shl    $0xf,%edx
sar    $0x11,%ecx
or     %edx,%ecx
add    %eax,%ecx
mov    %ecx,0x38(%r14)
xor    0x7c(%rbx),%r13d
xor    0x3c(%r14),%r13d
mov    0xc(%r14),%eax
mov    %eax,%ecx
shl    $0x10,%ecx
sar    $0x10,%eax
or     %ecx,%eax
add    %r13d,%eax
mov    %eax,0x3c(%r14)
lea    0x24(%rbx),%rdi
mov    %r15,%rsi
mov    $0x1c,%edx
call   1030 <memxor@plt>
mov    0x20(%rbx),%eax
xor    0x5c(%rbx),%eax
mov    %eax,0x20(%rbx)
mov    %r12d,%ecx
shl    $0x8,%ecx
xor    %eax,%ecx
add    %ecx,0x20(%r14)
mov    %r12d,%eax
sar    $0x6,%eax
xor    0x24(%rbx),%eax
add    %eax,0x24(%r14)
mov    %r12d,%eax
shl    $0x6,%eax
xor    0x28(%rbx),%eax
add    %eax,0x28(%r14)
mov    %r12d,%eax
shl    $0x4,%eax
xor    0x2c(%rbx),%eax
add    %eax,0x2c(%r14)
mov    %r12d,%eax
sar    $0x3,%eax
xor    0x30(%rbx),%eax
add    %eax,0x30(%r14)
mov    %r12d,%eax
sar    $0x4,%eax
xor    0x34(%rbx),%eax
add    %eax,0x34(%r14)
mov    %r12d,%eax
sar    $0x7,%eax
xor    0x38(%rbx),%eax
add    %eax,0x38(%r14)
sar    $0x2,%r12d
xor    0x3c(%rbx),%r12d
add    %r12d,0x3c(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @bmw_small_f2(i32* %0, i32* %1, i8* %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i8* %2, i8** %6
store i32 0, i32* %7
store i32 16, i32* %9
br label %10
10: ; preds = %21, %3
%11 = load i32, i32* %9
%12 = icmp slt i32 %11, 24
br i1 %12, label %13, label %24
13: ; preds = %10
%14 = load i32*, i32** %5
%15 = load i32, i32* %9
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i32, i32* %14, i64 %16
%18 = load i32, i32* %17
%19 = load i32, i32* %7
%20 = xor i32 %19, %18
store i32 %20, i32* %7
br label %21
21: ; preds = %13
%22 = load i32, i32* %9
%23 = add nsw i32 %22, 1
store i32 %23, i32* %9
br label %10
24: ; preds = %10
%25 = load i32, i32* %7
store i32 %25, i32* %8
store i32 24, i32* %9
br label %26
26: ; preds = %37, %24
%27 = load i32, i32* %9
%28 = icmp slt i32 %27, 32
br i1 %28, label %29, label %40
29: ; preds = %26
%30 = load i32*, i32** %5
%31 = load i32, i32* %9
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %30, i64 %32
%34 = load i32, i32* %33
%35 = load i32, i32* %8
%36 = xor i32 %35, %34
store i32 %36, i32* %8
br label %37
37: ; preds = %29
%38 = load i32, i32* %9
%39 = add nsw i32 %38, 1
store i32 %39, i32* %9
br label %26
40: ; preds = %26
%41 = load i32*, i32** %4
%42 = load i8*, i8** %6
%43 = call i32 @memcpy(i32* %41, i8* %42, i32 64)
%44 = load i32, i32* %8
%45 = shl i32 %44, 5
%46 = load i32*, i32** %5
%47 = getelementptr inbounds i32, i32* %46, i64 16
%48 = load i32, i32* %47
%49 = ashr i32 %48, 5
%50 = xor i32 %45, %49
%51 = load i32*, i32** %4
%52 = getelementptr inbounds i32, i32* %51, i64 0
%53 = load i32, i32* %52
%54 = xor i32 %53, %50
store i32 %54, i32* %52
%55 = load i32, i32* %8
%56 = ashr i32 %55, 7
%57 = load i32*, i32** %5
%58 = getelementptr inbounds i32, i32* %57, i64 17
%59 = load i32, i32* %58
%60 = shl i32 %59, 8
%61 = xor i32 %56, %60
%62 = load i32*, i32** %4
%63 = getelementptr inbounds i32, i32* %62, i64 1
%64 = load i32, i32* %63
%65 = xor i32 %64, %61
store i32 %65, i32* %63
%66 = load i32, i32* %8
%67 = ashr i32 %66, 5
%68 = load i32*, i32** %5
%69 = getelementptr inbounds i32, i32* %68, i64 18
%70 = load i32, i32* %69
%71 = shl i32 %70, 5
%72 = xor i32 %67, %71
%73 = load i32*, i32** %4
%74 = getelementptr inbounds i32, i32* %73, i64 2
%75 = load i32, i32* %74
%76 = xor i32 %75, %72
store i32 %76, i32* %74
%77 = load i32, i32* %8
%78 = ashr i32 %77, 1
%79 = load i32*, i32** %5
%80 = getelementptr inbounds i32, i32* %79, i64 19
%81 = load i32, i32* %80
%82 = shl i32 %81, 5
%83 = xor i32 %78, %82
%84 = load i32*, i32** %4
%85 = getelementptr inbounds i32, i32* %84, i64 3
%86 = load i32, i32* %85
%87 = xor i32 %86, %83
store i32 %87, i32* %85
%88 = load i32, i32* %8
%89 = ashr i32 %88, 3
%90 = load i32*, i32** %5
%91 = getelementptr inbounds i32, i32* %90, i64 20
%92 = load i32, i32* %91
%93 = xor i32 %89, %92
%94 = load i32*, i32** %4
%95 = getelementptr inbounds i32, i32* %94, i64 4
%96 = load i32, i32* %95
%97 = xor i32 %96, %93
store i32 %97, i32* %95
%98 = load i32, i32* %8
%99 = shl i32 %98, 6
%100 = load i32*, i32** %5
%101 = getelementptr inbounds i32, i32* %100, i64 21
%102 = load i32, i32* %101
%103 = ashr i32 %102, 6
%104 = xor i32 %99, %103
%105 = load i32*, i32** %4
%106 = getelementptr inbounds i32, i32* %105, i64 5
%107 = load i32, i32* %106
%108 = xor i32 %107, %104
store i32 %108, i32* %106
%109 = load i32, i32* %8
%110 = ashr i32 %109, 4
%111 = load i32*, i32** %5
%112 = getelementptr inbounds i32, i32* %111, i64 22
%113 = load i32, i32* %112
%114 = shl i32 %113, 6
%115 = xor i32 %110, %114
%116 = load i32*, i32** %4
%117 = getelementptr inbounds i32, i32* %116, i64 6
%118 = load i32, i32* %117
%119 = xor i32 %118, %115
store i32 %119, i32* %117
%120 = load i32, i32* %8
%121 = ashr i32 %120, 11
%122 = load i32*, i32** %5
%123 = getelementptr inbounds i32, i32* %122, i64 23
%124 = load i32, i32* %123
%125 = shl i32 %124, 2
%126 = xor i32 %121, %125
%127 = load i32*, i32** %4
%128 = getelementptr inbounds i32, i32* %127, i64 7
%129 = load i32, i32* %128
%130 = xor i32 %129, %126
store i32 %130, i32* %128
store i32 0, i32* %9
br label %131
131: ; preds = %155, %40
%132 = load i32, i32* %9
%133 = icmp slt i32 %132, 8
br i1 %133, label %134, label %158
134: ; preds = %131
%135 = load i32, i32* %7
%136 = load i32*, i32** %5
%137 = load i32, i32* %9
%138 = add nsw i32 24, %137
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %136, i64 %139
%141 = load i32, i32* %140
%142 = xor i32 %135, %141
%143 = load i32*, i32** %5
%144 = load i32, i32* %9
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %143, i64 %145
%147 = load i32, i32* %146
%148 = xor i32 %142, %147
%149 = load i32*, i32** %4
%150 = load i32, i32* %9
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
%153 = load i32, i32* %152
%154 = add nsw i32 %153, %148
store i32 %154, i32* %152
br label %155
155: ; preds = %134
%156 = load i32, i32* %9
%157 = add nsw i32 %156, 1
store i32 %157, i32* %9
br label %131
158: ; preds = %131
store i32 0, i32* %9
br label %159
159: ; preds = %207, %158
%160 = load i32, i32* %9
%161 = icmp slt i32 %160, 8
br i1 %161, label %162, label %210
162: ; preds = %159
%163 = load i32, i32* %8
%164 = load i32*, i32** %5
%165 = load i32, i32* %9
%166 = add nsw i32 24, %165
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %164, i64 %167
%169 = load i32, i32* %168
%170 = xor i32 %163, %169
%171 = load i32*, i32** %4
%172 = load i32, i32* %9
%173 = add nsw i32 8, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %171, i64 %174
%176 = load i32, i32* %175
%177 = xor i32 %176, %170
store i32 %177, i32* %175
%178 = load i32*, i32** %4
%179 = load i32, i32* %9
%180 = add nsw i32 4, %179
%181 = srem i32 %180, 8
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %178, i64 %182
%184 = load i32, i32* %183
%185 = load i32, i32* %9
%186 = add nsw i32 %185, 9
%187 = shl i32 %184, %186
%188 = load i32*, i32** %4
%189 = load i32, i32* %9
%190 = add nsw i32 4, %189
%191 = srem i32 %190, 8
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %188, i64 %192
%194 = load i32, i32* %193
%195 = load i32, i32* %9
%196 = add nsw i32 %195, 9
%197 = sub nsw i32 32, %196
%198 = ashr i32 %194, %197
%199 = or i32 %187, %198
%200 = load i32*, i32** %4
%201 = load i32, i32* %9
%202 = add nsw i32 8, %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32, i32* %200, i64 %203
%205 = load i32, i32* %204
%206 = add nsw i32 %205, %199
store i32 %206, i32* %204
br label %207
207: ; preds = %162
%208 = load i32, i32* %9
%209 = add nsw i32 %208, 1
store i32 %209, i32* %9
br label %159
210: ; preds = %159
%211 = load i32*, i32** %5
%212 = getelementptr inbounds i32, i32* %211, i64 9
%213 = load i32*, i32** %5
%214 = getelementptr inbounds i32, i32* %213, i64 16
%215 = call i32 @memxor(i32* %212, i32* %214, i32 28)
%216 = load i32*, i32** %5
%217 = getelementptr inbounds i32, i32* %216, i64 23
%218 = load i32, i32* %217
%219 = load i32*, i32** %5
%220 = getelementptr inbounds i32, i32* %219, i64 8
%221 = load i32, i32* %220
%222 = xor i32 %221, %218
store i32 %222, i32* %220
%223 = load i32, i32* %7
%224 = shl i32 %223, 8
%225 = load i32*, i32** %5
%226 = getelementptr inbounds i32, i32* %225, i64 8
%227 = load i32, i32* %226
%228 = xor i32 %224, %227
%229 = load i32*, i32** %4
%230 = getelementptr inbounds i32, i32* %229, i64 8
%231 = load i32, i32* %230
%232 = add nsw i32 %231, %228
store i32 %232, i32* %230
%233 = load i32, i32* %7
%234 = ashr i32 %233, 6
%235 = load i32*, i32** %5
%236 = getelementptr inbounds i32, i32* %235, i64 9
%237 = load i32, i32* %236
%238 = xor i32 %234, %237
%239 = load i32*, i32** %4
%240 = getelementptr inbounds i32, i32* %239, i64 9
%241 = load i32, i32* %240
%242 = add nsw i32 %241, %238
store i32 %242, i32* %240
%243 = load i32, i32* %7
%244 = shl i32 %243, 6
%245 = load i32*, i32** %5
%246 = getelementptr inbounds i32, i32* %245, i64 10
%247 = load i32, i32* %246
%248 = xor i32 %244, %247
%249 = load i32*, i32** %4
%250 = getelementptr inbounds i32, i32* %249, i64 10
%251 = load i32, i32* %250
%252 = add nsw i32 %251, %248
store i32 %252, i32* %250
%253 = load i32, i32* %7
%254 = shl i32 %253, 4
%255 = load i32*, i32** %5
%256 = getelementptr inbounds i32, i32* %255, i64 11
%257 = load i32, i32* %256
%258 = xor i32 %254, %257
%259 = load i32*, i32** %4
%260 = getelementptr inbounds i32, i32* %259, i64 11
%261 = load i32, i32* %260
%262 = add nsw i32 %261, %258
store i32 %262, i32* %260
%263 = load i32, i32* %7
%264 = ashr i32 %263, 3
%265 = load i32*, i32** %5
%266 = getelementptr inbounds i32, i32* %265, i64 12
%267 = load i32, i32* %266
%268 = xor i32 %264, %267
%269 = load i32*, i32** %4
%270 = getelementptr inbounds i32, i32* %269, i64 12
%271 = load i32, i32* %270
%272 = add nsw i32 %271, %268
store i32 %272, i32* %270
%273 = load i32, i32* %7
%274 = ashr i32 %273, 4
%275 = load i32*, i32** %5
%276 = getelementptr inbounds i32, i32* %275, i64 13
%277 = load i32, i32* %276
%278 = xor i32 %274, %277
%279 = load i32*, i32** %4
%280 = getelementptr inbounds i32, i32* %279, i64 13
%281 = load i32, i32* %280
%282 = add nsw i32 %281, %278
store i32 %282, i32* %280
%283 = load i32, i32* %7
%284 = ashr i32 %283, 7
%285 = load i32*, i32** %5
%286 = getelementptr inbounds i32, i32* %285, i64 14
%287 = load i32, i32* %286
%288 = xor i32 %284, %287
%289 = load i32*, i32** %4
%290 = getelementptr inbounds i32, i32* %289, i64 14
%291 = load i32, i32* %290
%292 = add nsw i32 %291, %288
store i32 %292, i32* %290
%293 = load i32, i32* %7
%294 = ashr i32 %293, 2
%295 = load i32*, i32** %5
%296 = getelementptr inbounds i32, i32* %295, i64 15
%297 = load i32, i32* %296
%298 = xor i32 %294, %297
%299 = load i32*, i32** %4
%300 = getelementptr inbounds i32, i32* %299, i64 15
%301 = load i32, i32* %300
%302 = add nsw i32 %301, %298
store i32 %302, i32* %300
ret void
}

LLVM IR (-O2):
define void @bmw_small_f2(i32* %0, i32* %1, i8* %2) {
%4 = getelementptr inbounds i32, i32* %1, i64 16
%5 = load i32, i32* %4
%6 = getelementptr inbounds i32, i32* %1, i64 17
%7 = load i32, i32* %6
%8 = xor i32 %7, %5
%9 = getelementptr inbounds i32, i32* %1, i64 18
%10 = load i32, i32* %9
%11 = xor i32 %10, %8
%12 = getelementptr inbounds i32, i32* %1, i64 19
%13 = load i32, i32* %12
%14 = xor i32 %13, %11
%15 = getelementptr inbounds i32, i32* %1, i64 20
%16 = load i32, i32* %15
%17 = xor i32 %16, %14
%18 = getelementptr inbounds i32, i32* %1, i64 21
%19 = load i32, i32* %18
%20 = xor i32 %19, %17
%21 = getelementptr inbounds i32, i32* %1, i64 22
%22 = load i32, i32* %21
%23 = xor i32 %22, %20
%24 = getelementptr inbounds i32, i32* %1, i64 23
%25 = load i32, i32* %24
%26 = xor i32 %25, %23
%27 = getelementptr inbounds i32, i32* %1, i64 24
%28 = load i32, i32* %27
%29 = xor i32 %28, %26
%30 = getelementptr inbounds i32, i32* %1, i64 25
%31 = load i32, i32* %30
%32 = xor i32 %31, %29
%33 = getelementptr inbounds i32, i32* %1, i64 26
%34 = load i32, i32* %33
%35 = xor i32 %34, %32
%36 = getelementptr inbounds i32, i32* %1, i64 27
%37 = load i32, i32* %36
%38 = xor i32 %37, %35
%39 = getelementptr inbounds i32, i32* %1, i64 28
%40 = load i32, i32* %39
%41 = xor i32 %40, %38
%42 = getelementptr inbounds i32, i32* %1, i64 29
%43 = load i32, i32* %42
%44 = xor i32 %43, %41
%45 = getelementptr inbounds i32, i32* %1, i64 30
%46 = load i32, i32* %45
%47 = xor i32 %46, %44
%48 = getelementptr inbounds i32, i32* %1, i64 31
%49 = load i32, i32* %48
%50 = xor i32 %49, %47
%51 = tail call i32 @memcpy(i32* %0, i8* %2, i32 64)
%52 = shl i32 %50, 5
%53 = load i32, i32* %4
%54 = ashr i32 %53, 5
%55 = xor i32 %54, %52
%56 = load i32, i32* %0
%57 = xor i32 %55, %56
store i32 %57, i32* %0
%58 = ashr i32 %50, 7
%59 = load i32, i32* %6
%60 = shl i32 %59, 8
%61 = xor i32 %60, %58
%62 = getelementptr inbounds i32, i32* %0, i64 1
%63 = load i32, i32* %62
%64 = xor i32 %61, %63
store i32 %64, i32* %62
%65 = ashr i32 %50, 5
%66 = load i32, i32* %9
%67 = shl i32 %66, 5
%68 = xor i32 %67, %65
%69 = getelementptr inbounds i32, i32* %0, i64 2
%70 = load i32, i32* %69
%71 = xor i32 %68, %70
store i32 %71, i32* %69
%72 = ashr i32 %50, 1
%73 = load i32, i32* %12
%74 = shl i32 %73, 5
%75 = xor i32 %74, %72
%76 = getelementptr inbounds i32, i32* %0, i64 3
%77 = load i32, i32* %76
%78 = xor i32 %75, %77
store i32 %78, i32* %76
%79 = ashr i32 %50, 3
%80 = load i32, i32* %15
%81 = xor i32 %80, %79
%82 = getelementptr inbounds i32, i32* %0, i64 4
%83 = load i32, i32* %82
%84 = xor i32 %81, %83
store i32 %84, i32* %82
%85 = shl i32 %50, 6
%86 = load i32, i32* %18
%87 = ashr i32 %86, 6
%88 = xor i32 %87, %85
%89 = getelementptr inbounds i32, i32* %0, i64 5
%90 = load i32, i32* %89
%91 = xor i32 %88, %90
store i32 %91, i32* %89
%92 = ashr i32 %50, 4
%93 = load i32, i32* %21
%94 = shl i32 %93, 6
%95 = xor i32 %94, %92
%96 = getelementptr inbounds i32, i32* %0, i64 6
%97 = load i32, i32* %96
%98 = xor i32 %95, %97
store i32 %98, i32* %96
%99 = ashr i32 %50, 11
%100 = load i32, i32* %24
%101 = shl i32 %100, 2
%102 = xor i32 %101, %99
%103 = getelementptr inbounds i32, i32* %0, i64 7
%104 = load i32, i32* %103
%105 = xor i32 %102, %104
store i32 %105, i32* %103
%106 = load i32, i32* %27
%107 = xor i32 %106, %26
%108 = load i32, i32* %1
%109 = xor i32 %107, %108
%110 = add nsw i32 %57, %109
store i32 %110, i32* %0
%111 = load i32, i32* %30
%112 = xor i32 %111, %26
%113 = getelementptr inbounds i32, i32* %1, i64 1
%114 = load i32, i32* %113
%115 = xor i32 %112, %114
%116 = add nsw i32 %64, %115
store i32 %116, i32* %62
%117 = load i32, i32* %33
%118 = xor i32 %117, %26
%119 = getelementptr inbounds i32, i32* %1, i64 2
%120 = load i32, i32* %119
%121 = xor i32 %118, %120
%122 = add nsw i32 %71, %121
store i32 %122, i32* %69
%123 = load i32, i32* %36
%124 = xor i32 %123, %26
%125 = getelementptr inbounds i32, i32* %1, i64 3
%126 = load i32, i32* %125
%127 = xor i32 %124, %126
%128 = add nsw i32 %78, %127
store i32 %128, i32* %76
%129 = load i32, i32* %39
%130 = xor i32 %129, %26
%131 = getelementptr inbounds i32, i32* %1, i64 4
%132 = load i32, i32* %131
%133 = xor i32 %130, %132
%134 = add nsw i32 %84, %133
store i32 %134, i32* %82
%135 = load i32, i32* %42
%136 = xor i32 %135, %26
%137 = getelementptr inbounds i32, i32* %1, i64 5
%138 = load i32, i32* %137
%139 = xor i32 %136, %138
%140 = add nsw i32 %91, %139
store i32 %140, i32* %89
%141 = load i32, i32* %45
%142 = xor i32 %141, %26
%143 = getelementptr inbounds i32, i32* %1, i64 6
%144 = load i32, i32* %143
%145 = xor i32 %142, %144
%146 = add nsw i32 %98, %145
store i32 %146, i32* %96
%147 = load i32, i32* %48
%148 = xor i32 %147, %26
%149 = getelementptr inbounds i32, i32* %1, i64 7
%150 = load i32, i32* %149
%151 = xor i32 %148, %150
%152 = add nsw i32 %105, %151
store i32 %152, i32* %103
%153 = load i32, i32* %27
%154 = xor i32 %153, %50
%155 = getelementptr inbounds i32, i32* %0, i64 8
%156 = load i32, i32* %155
%157 = xor i32 %154, %156
%158 = shl i32 %134, 9
%159 = ashr i32 %134, 23
%160 = or i32 %158, %159
%161 = add nsw i32 %160, %157
store i32 %161, i32* %155
%162 = load i32, i32* %30
%163 = xor i32 %162, %50
%164 = getelementptr inbounds i32, i32* %0, i64 9
%165 = load i32, i32* %164
%166 = xor i32 %163, %165
%167 = shl i32 %140, 10
%168 = ashr i32 %140, 22
%169 = or i32 %167, %168
%170 = add nsw i32 %169, %166
store i32 %170, i32* %164
%171 = load i32, i32* %33
%172 = xor i32 %171, %50
%173 = getelementptr inbounds i32, i32* %0, i64 10
%174 = load i32, i32* %173
%175 = xor i32 %172, %174
%176 = shl i32 %146, 11
%177 = ashr i32 %146, 21
%178 = or i32 %176, %177
%179 = add nsw i32 %178, %175
store i32 %179, i32* %173
%180 = load i32, i32* %36
%181 = xor i32 %180, %50
%182 = getelementptr inbounds i32, i32* %0, i64 11
%183 = load i32, i32* %182
%184 = xor i32 %181, %183
%185 = shl i32 %152, 12
%186 = ashr i32 %152, 20
%187 = or i32 %185, %186
%188 = add nsw i32 %187, %184
store i32 %188, i32* %182
%189 = load i32, i32* %39
%190 = xor i32 %189, %50
%191 = getelementptr inbounds i32, i32* %0, i64 12
%192 = load i32, i32* %191
%193 = xor i32 %190, %192
%194 = load i32, i32* %0
%195 = shl i32 %194, 13
%196 = ashr i32 %194, 19
%197 = or i32 %195, %196
%198 = add nsw i32 %197, %193
store i32 %198, i32* %191
%199 = load i32, i32* %42
%200 = xor i32 %199, %50
%201 = getelementptr inbounds i32, i32* %0, i64 13
%202 = load i32, i32* %201
%203 = xor i32 %200, %202
%204 = load i32, i32* %62
%205 = shl i32 %204, 14
%206 = ashr i32 %204, 18
%207 = or i32 %205, %206
%208 = add nsw i32 %207, %203
store i32 %208, i32* %201
%209 = load i32, i32* %45
%210 = xor i32 %209, %50
%211 = getelementptr inbounds i32, i32* %0, i64 14
%212 = load i32, i32* %211
%213 = xor i32 %210, %212
%214 = load i32, i32* %69
%215 = shl i32 %214, 15
%216 = ashr i32 %214, 17
%217 = or i32 %215, %216
%218 = add nsw i32 %217, %213
store i32 %218, i32* %211
%219 = load i32, i32* %48
%220 = xor i32 %219, %50
%221 = getelementptr inbounds i32, i32* %0, i64 15
%222 = load i32, i32* %221
%223 = xor i32 %220, %222
%224 = load i32, i32* %76
%225 = shl i32 %224, 16
%226 = ashr i32 %224, 16
%227 = or i32 %225, %226
%228 = add nsw i32 %227, %223
store i32 %228, i32* %221
%229 = getelementptr inbounds i32, i32* %1, i64 9
%230 = tail call i32 @memxor(i32* %229, i32* %4, i32 28)
%231 = load i32, i32* %24
%232 = getelementptr inbounds i32, i32* %1, i64 8
%233 = load i32, i32* %232
%234 = xor i32 %233, %231
store i32 %234, i32* %232
%235 = shl i32 %26, 8
%236 = xor i32 %234, %235
%237 = load i32, i32* %155
%238 = add nsw i32 %237, %236
store i32 %238, i32* %155
%239 = ashr i32 %26, 6
%240 = load i32, i32* %229
%241 = xor i32 %240, %239
%242 = load i32, i32* %164
%243 = add nsw i32 %242, %241
store i32 %243, i32* %164
%244 = shl i32 %26, 6
%245 = getelementptr inbounds i32, i32* %1, i64 10
%246 = load i32, i32* %245
%247 = xor i32 %246, %244
%248 = load i32, i32* %173
%249 = add nsw i32 %248, %247
store i32 %249, i32* %173
%250 = shl i32 %26, 4
%251 = getelementptr inbounds i32, i32* %1, i64 11
%252 = load i32, i32* %251
%253 = xor i32 %252, %250
%254 = load i32, i32* %182
%255 = add nsw i32 %254, %253
store i32 %255, i32* %182
%256 = ashr i32 %26, 3
%257 = getelementptr inbounds i32, i32* %1, i64 12
%258 = load i32, i32* %257
%259 = xor i32 %258, %256
%260 = load i32, i32* %191
%261 = add nsw i32 %260, %259
store i32 %261, i32* %191
%262 = ashr i32 %26, 4
%263 = getelementptr inbounds i32, i32* %1, i64 13
%264 = load i32, i32* %263
%265 = xor i32 %264, %262
%266 = load i32, i32* %201
%267 = add nsw i32 %266, %265
store i32 %267, i32* %201
%268 = ashr i32 %26, 7
%269 = getelementptr inbounds i32, i32* %1, i64 14
%270 = load i32, i32* %269
%271 = xor i32 %270, %268
%272 = load i32, i32* %211
%273 = add nsw i32 %272, %271
store i32 %273, i32* %211
%274 = ashr i32 %26, 2
%275 = getelementptr inbounds i32, i32* %1, i64 15
%276 = load i32, i32* %275
%277 = xor i32 %276, %274
%278 = load i32, i32* %221
%279 = add nsw i32 %278, %277
store i32 %279, i32* %221
ret void
}