#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 /*<<< orphan*/ uint64_t;

/* Variables and functions */
int /*<<< orphan*/ Flap(int *, int const, int, int const *, int const, int *);
int /*<<< orphan*/ __Hash2(int *, int, int *, int, int *);
int /*<<< orphan*/ __Hash4(int const *, int, int *, int, int const *, int,
                           int const *, int, int *);
int /*<<< orphan*/ memcpy(int *, int const *, int const);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int const);
void CI_Keyed_Update(const uint8_t *old_hash, const uint8_t lambda,
                     const uint8_t *salt, const uint8_t saltlen,
                     const uint8_t old_garlic, const uint8_t new_garlic,
                     const uint8_t hashlen, const uint8_t *key,
                     const uint64_t uuid, uint8_t *new_hash) {
  uint8_t keystream[64];
  uint64_t tmp = (uuid);
  uint8_t c;
  uint8_t x[64];
  memcpy(x, old_hash, hashlen);
  memset(x + hashlen, 0, 64 - hashlen);
  __Hash4(key, 16, (uint8_t *)&tmp, 8, &old_garlic, sizeof(uint8_t), key, 16,
          keystream);
  for (int i = 0; i < hashlen; i++)
    x[i] ^= keystream[i];
  for (c = old_garlic + 1; c <= new_garlic; c++) {
    Flap(x, lambda, c, salt, saltlen, x);
    __Hash2(&c, 1, x, 64, x);
    memset(x + hashlen, 0, 64 - hashlen);
  }
  __Hash4(key, 16, (uint8_t *)&tmp, 8, &new_garlic, sizeof(uint8_t), key, 16,
          keystream);
  for (int i = 0; i < hashlen; i++)
    x[i] ^= keystream[i];
  memcpy(new_hash, x, hashlen);
}


x86 assembly (clang, -O0):
<CI_Keyed_Update>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    0x20(%rbp),%eax
mov    %eax,-0x134(%rbp)
lea    -0x240(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    0x10(%rbp),%edx
call   1050 <memcpy@plt>
lea    -0x240(%rbp),%rdi
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    $0x40,%edx
sub    0x10(%rbp),%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x18(%rbp),%rdi
mov    0x18(%rbp),%r10
lea    -0x130(%rbp),%rax
mov    $0x10,%esi
lea    -0x134(%rbp),%rdx
mov    $0x8,%ecx
lea    -0x20(%rbp),%r8
mov    $0x4,%r9d
mov    %r10,(%rsp)
movl   $0x10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1060 <__Hash4@plt>
movl   $0x0,-0x244(%rbp)
mov    -0x244(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    124c <CI_Keyed_Update+0xfc>
movslq -0x244(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%ecx
movslq -0x244(%rbp),%rax
xor    -0x240(%rbp,%rax,4),%ecx
mov    %ecx,-0x240(%rbp,%rax,4)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1206 <CI_Keyed_Update+0xb6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12e4 <CI_Keyed_Update+0x194>
lea    -0x240(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x138(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
lea    -0x240(%rbp),%r9
call   1030 <Flap@plt>
lea    -0x240(%rbp),%rdx
lea    -0x240(%rbp),%r8
lea    -0x138(%rbp),%rdi
mov    $0x1,%esi
mov    $0x40,%ecx
call   1070 <__Hash2@plt>
lea    -0x240(%rbp),%rdi
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    $0x40,%edx
sub    0x10(%rbp),%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1258 <CI_Keyed_Update+0x108>
mov    0x18(%rbp),%rdi
mov    0x18(%rbp),%r10
lea    -0x130(%rbp),%rax
mov    $0x10,%esi
lea    -0x134(%rbp),%rdx
mov    $0x8,%ecx
lea    -0x24(%rbp),%r8
mov    $0x4,%r9d
mov    %r10,(%rsp)
movl   $0x10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1060 <__Hash4@plt>
movl   $0x0,-0x248(%rbp)
mov    -0x248(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1374 <CI_Keyed_Update+0x224>
movslq -0x248(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%ecx
movslq -0x248(%rbp),%rax
xor    -0x240(%rbp,%rax,4),%ecx
mov    %ecx,-0x240(%rbp,%rax,4)
mov    -0x248(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x248(%rbp)
jmp    132e <CI_Keyed_Update+0x1de>
mov    0x28(%rbp),%rdi
lea    -0x240(%rbp),%rsi
mov    0x10(%rbp),%edx
call   1050 <memcpy@plt>
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CI_Keyed_Update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x248,%rsp
mov    %r9d,%r14d
mov    %ecx,0x14(%rsp)
mov    %rdx,0x20(%rsp)
mov    %esi,%r15d
mov    %rdi,%rsi
movslq 0x280(%rsp),%r12
mov    0x288(%rsp),%rbx
mov    0x290(%rsp),%eax
mov    %r8d,0x10(%rsp)
mov    %r9d,0x1c(%rsp)
mov    %eax,0xc(%rsp)
lea    0x40(%rsp),%rdi
mov    %r12d,%edx
call   1050 <memcpy@plt>
lea    (%rsp,%r12,4),%rdi
add    $0x40,%rdi
mov    $0x40,%edx
sub    %r12d,%edx
mov    %rdi,0x38(%rsp)
xor    %esi,%esi
mov    %edx,%r13d
call   1040 <memset@plt>
sub    $0x8,%rsp
lea    0x148(%rsp),%rax
lea    0x14(%rsp),%rdx
lea    0x18(%rsp),%r8
mov    %rbx,%rdi
mov    $0x10,%esi
mov    $0x8,%ecx
mov    $0x4,%r9d
push   %rax
push   $0x10
push   %rbx
call   1060 <__Hash4@plt>
add    $0x20,%rsp
mov    %r12d,%edi
test   %r12,%r12
jle    12d4 <CI_Keyed_Update+0x184>
cmp    $0x8,%r12d
jae    1213 <CI_Keyed_Update+0xc3>
xor    %eax,%eax
jmp    12c0 <CI_Keyed_Update+0x170>
mov    %edi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     14c3 <CI_Keyed_Update+0x373>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movaps 0x40(%rsp,%rcx,4),%xmm0
movaps 0x50(%rsp,%rcx,4),%xmm1
movaps 0x60(%rsp,%rcx,4),%xmm2
movaps 0x70(%rsp,%rcx,4),%xmm3
xorps  0x140(%rsp,%rcx,4),%xmm0
xorps  0x150(%rsp,%rcx,4),%xmm1
movaps %xmm0,0x40(%rsp,%rcx,4)
movaps %xmm1,0x50(%rsp,%rcx,4)
xorps  0x160(%rsp,%rcx,4),%xmm2
xorps  0x170(%rsp,%rcx,4),%xmm3
movaps %xmm2,0x60(%rsp,%rcx,4)
movaps %xmm3,0x70(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1240 <CI_Keyed_Update+0xf0>
test   $0x1,%dl
je     12bb <CI_Keyed_Update+0x16b>
movaps 0x40(%rsp,%rcx,4),%xmm0
movaps 0x50(%rsp,%rcx,4),%xmm1
xorps  0x140(%rsp,%rcx,4),%xmm0
xorps  0x150(%rsp,%rcx,4),%xmm1
movaps %xmm0,0x40(%rsp,%rcx,4)
movaps %xmm1,0x50(%rsp,%rcx,4)
cmp    %rdi,%rax
je     12d4 <CI_Keyed_Update+0x184>
mov    0x140(%rsp,%rax,4),%ecx
xor    %ecx,0x40(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    12c0 <CI_Keyed_Update+0x170>
mov    %rdi,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    0x10(%rsp),%eax
lea    0x1(%rax),%edx
mov    %edx,0x8(%rsp)
cmp    %r14d,%eax
mov    0x14(%rsp),%ebp
mov    0x20(%rsp),%rbx
mov    %r13d,0x18(%rsp)
jge    136c <CI_Keyed_Update+0x21c>
mov    %r15d,%ecx
lea    0x40(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rdi
mov    %ecx,%r13d
mov    %ecx,%esi
mov    %rbx,%rcx
mov    %r14d,%r15d
mov    %ebp,%r14d
mov    %ebp,%r8d
mov    %r12,%r9
call   1030 <Flap@plt>
lea    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    %r12,%rdx
mov    $0x40,%ecx
mov    %r12,%r8
call   1070 <__Hash2@plt>
mov    0x38(%rsp),%rdi
xor    %esi,%esi
mov    0x18(%rsp),%edx
call   1040 <memset@plt>
mov    %r13d,%ecx
mov    %r15d,%r14d
mov    0x8(%rsp),%eax
lea    0x1(%rax),%edx
mov    %edx,0x8(%rsp)
cmp    %r15d,%eax
jl     1310 <CI_Keyed_Update+0x1c0>
mov    0x298(%rsp),%rbp
sub    $0x8,%rsp
lea    0x14(%rsp),%rdx
lea    0x24(%rsp),%r8
mov    0x290(%rsp),%rdi
mov    $0x10,%esi
mov    $0x8,%ecx
mov    $0x4,%r9d
lea    0x148(%rsp),%rax
push   %rax
push   $0x10
push   %rdi
call   1060 <__Hash4@plt>
add    $0x20,%rsp
mov    0x30(%rsp),%rdx
test   %edx,%edx
mov    0x28(%rsp),%rbx
jle    14a4 <CI_Keyed_Update+0x354>
cmp    $0x8,%edx
jae    13cd <CI_Keyed_Update+0x27d>
xor    %eax,%eax
jmp    1490 <CI_Keyed_Update+0x340>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     14d3 <CI_Keyed_Update+0x383>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps 0x40(%rsp,%rcx,4),%xmm0
movaps 0x50(%rsp,%rcx,4),%xmm1
movaps 0x60(%rsp,%rcx,4),%xmm2
movaps 0x70(%rsp,%rcx,4),%xmm3
xorps  0x140(%rsp,%rcx,4),%xmm0
xorps  0x150(%rsp,%rcx,4),%xmm1
movaps %xmm0,0x40(%rsp,%rcx,4)
movaps %xmm1,0x50(%rsp,%rcx,4)
xorps  0x160(%rsp,%rcx,4),%xmm2
xorps  0x170(%rsp,%rcx,4),%xmm3
movaps %xmm2,0x60(%rsp,%rcx,4)
movaps %xmm3,0x70(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1400 <CI_Keyed_Update+0x2b0>
test   $0x1,%dil
je     147c <CI_Keyed_Update+0x32c>
movaps 0x40(%rsp,%rcx,4),%xmm0
movaps 0x50(%rsp,%rcx,4),%xmm1
xorps  0x140(%rsp,%rcx,4),%xmm0
xorps  0x150(%rsp,%rcx,4),%xmm1
movaps %xmm0,0x40(%rsp,%rcx,4)
movaps %xmm1,0x50(%rsp,%rcx,4)
cmp    %rbx,%rax
je     14a4 <CI_Keyed_Update+0x354>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x140(%rsp,%rax,4),%ecx
xor    %ecx,0x40(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1490 <CI_Keyed_Update+0x340>
lea    0x40(%rsp),%rsi
mov    %rbp,%rdi
call   1050 <memcpy@plt>
add    $0x248,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    1297 <CI_Keyed_Update+0x147>
jmp    12bb <CI_Keyed_Update+0x16b>
xor    %ecx,%ecx
test   $0x1,%dil
jne    1458 <CI_Keyed_Update+0x308>
jmp    147c <CI_Keyed_Update+0x32c>

LLVM IR (-O0):
define void @CI_Keyed_Update(i32* %0, i32 %1, i32* %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* %7, i32 %8, i32* %9) {
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32*
%21 = alloca [64 x i32]
%22 = alloca i32
%23 = alloca i32
%24 = alloca [64 x i32]
%25 = alloca i32
%26 = alloca i32
store i32* %0, i32** %11
store i32 %1, i32* %12
store i32* %2, i32** %13
store i32 %3, i32* %14
store i32 %4, i32* %15
store i32 %5, i32* %16
store i32 %6, i32* %17
store i32* %7, i32** %18
store i32 %8, i32* %19
store i32* %9, i32** %20
%27 = load i32, i32* %19
store i32 %27, i32* %22
%28 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%29 = load i32*, i32** %11
%30 = load i32, i32* %17
%31 = call i32 @memcpy(i32* %28, i32* %29, i32 %30)
%32 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%33 = load i32, i32* %17
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
%36 = load i32, i32* %17
%37 = sub nsw i32 64, %36
%38 = call i32 @memset(i32* %35, i32 0, i32 %37)
%39 = load i32*, i32** %18
%40 = load i32*, i32** %18
%41 = getelementptr inbounds [64 x i32], [64 x i32]* %21, i64 0, i64 0
%42 = call i32 @__Hash4(i32* %39, i32 16, i32* %22, i32 8, i32* %15, i32 4, i32* %40, i32 16, i32* %41)
store i32 0, i32* %25
br label %43
43: ; preds = %57, %10
%44 = load i32, i32* %25
%45 = load i32, i32* %17
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %60
47: ; preds = %43
%48 = load i32, i32* %25
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [64 x i32], [64 x i32]* %21, i64 0, i64 %49
%51 = load i32, i32* %50
%52 = load i32, i32* %25
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = xor i32 %55, %51
store i32 %56, i32* %54
br label %57
57: ; preds = %47
%58 = load i32, i32* %25
%59 = add nsw i32 %58, 1
store i32 %59, i32* %25
br label %43
60: ; preds = %43
%61 = load i32, i32* %15
%62 = add nsw i32 %61, 1
store i32 %62, i32* %23
br label %63
63: ; preds = %85, %60
%64 = load i32, i32* %23
%65 = load i32, i32* %16
%66 = icmp sle i32 %64, %65
br i1 %66, label %67, label %88
67: ; preds = %63
%68 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%69 = load i32, i32* %12
%70 = load i32, i32* %23
%71 = load i32*, i32** %13
%72 = load i32, i32* %14
%73 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%74 = call i32 @Flap(i32* %68, i32 %69, i32 %70, i32* %71, i32 %72, i32* %73)
%75 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%76 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%77 = call i32 @__Hash2(i32* %23, i32 1, i32* %75, i32 64, i32* %76)
%78 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%79 = load i32, i32* %17
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
%82 = load i32, i32* %17
%83 = sub nsw i32 64, %82
%84 = call i32 @memset(i32* %81, i32 0, i32 %83)
br label %85
85: ; preds = %67
%86 = load i32, i32* %23
%87 = add nsw i32 %86, 1
store i32 %87, i32* %23
br label %63
88: ; preds = %63
%89 = load i32*, i32** %18
%90 = load i32*, i32** %18
%91 = getelementptr inbounds [64 x i32], [64 x i32]* %21, i64 0, i64 0
%92 = call i32 @__Hash4(i32* %89, i32 16, i32* %22, i32 8, i32* %16, i32 4, i32* %90, i32 16, i32* %91)
store i32 0, i32* %26
br label %93
93: ; preds = %107, %88
%94 = load i32, i32* %26
%95 = load i32, i32* %17
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %110
97: ; preds = %93
%98 = load i32, i32* %26
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [64 x i32], [64 x i32]* %21, i64 0, i64 %99
%101 = load i32, i32* %100
%102 = load i32, i32* %26
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 %103
%105 = load i32, i32* %104
%106 = xor i32 %105, %101
store i32 %106, i32* %104
br label %107
107: ; preds = %97
%108 = load i32, i32* %26
%109 = add nsw i32 %108, 1
store i32 %109, i32* %26
br label %93
110: ; preds = %93
%111 = load i32*, i32** %20
%112 = getelementptr inbounds [64 x i32], [64 x i32]* %24, i64 0, i64 0
%113 = load i32, i32* %17
%114 = call i32 @memcpy(i32* %111, i32* %112, i32 %113)
ret void
}

LLVM IR (-O2):
define void @CI_Keyed_Update(i32* %0, i32 %1, i32* %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* %7, i32 %8, i32* %9) {
%11 = alloca i32
%12 = alloca i32
%13 = alloca [64 x i32]
%14 = alloca i32
%15 = alloca i32
%16 = alloca [64 x i32]
store i32 %4, i32* %11
store i32 %5, i32* %12
%17 = bitcast [64 x i32]* %13 to i8*
%18 = bitcast i32* %14 to i8*
store i32 %8, i32* %14
%19 = bitcast i32* %15 to i8*
%20 = bitcast [64 x i32]* %16 to i8*
%21 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 0
%22 = call i32 @memcpy(i32* %21, i32* %0, i32 %6)
%23 = sext i32 %6 to i64
%24 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %23
%25 = sub nsw i32 64, %6
%26 = call i32 @memset(i32* %24, i32 0, i32 %25)
%27 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 0
%28 = call i32 @__Hash4(i32* %7, i32 16, i32* %14, i32 8, i32* %11, i32 4, i32* %7, i32 16, i32* %27)
%29 = icmp sgt i32 %6, 0
br i1 %29, label %30, label %105
30: ; preds = %10
%31 = zext i32 %6 to i64
%32 = icmp ult i32 %6, 8
br i1 %32, label %103, label %33
33: ; preds = %30
%34 = and i64 %31, 4294967288
%35 = add nsw i64 %34, -8
%36 = lshr exact i64 %35, 3
%37 = add nuw nsw i64 %36, 1
%38 = and i64 %37, 1
%39 = icmp eq i64 %35, 0
br i1 %39, label %81, label %40
40: ; preds = %33
%41 = and i64 %37, 4611686018427387902
br label %42
42: ; preds = %42, %40
%43 = phi i64 [ 0, %40 ], [ %78, %42 ]
%44 = phi i64 [ 0, %40 ], [ %79, %42 ]
%45 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %43
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = getelementptr inbounds i32, i32* %45, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %43
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %51, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = xor <4 x i32> %53, %47
%58 = xor <4 x i32> %56, %50
%59 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %59
%60 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %60
%61 = or i64 %43, 8
%62 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %61
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %62, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %61
%69 = bitcast i32* %68 to <4 x i32>*
%70 = load <4 x i32>, <4 x i32>* %69
%71 = getelementptr inbounds i32, i32* %68, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = xor <4 x i32> %70, %64
%75 = xor <4 x i32> %73, %67
%76 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %74, <4 x i32>* %76
%77 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %77
%78 = add nuw i64 %43, 16
%79 = add i64 %44, 2
%80 = icmp eq i64 %79, %41
br i1 %80, label %81, label %42
81: ; preds = %42, %33
%82 = phi i64 [ 0, %33 ], [ %78, %42 ]
%83 = icmp eq i64 %38, 0
br i1 %83, label %101, label %84
84: ; preds = %81
%85 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %82
%86 = bitcast i32* %85 to <4 x i32>*
%87 = load <4 x i32>, <4 x i32>* %86
%88 = getelementptr inbounds i32, i32* %85, i64 4
%89 = bitcast i32* %88 to <4 x i32>*
%90 = load <4 x i32>, <4 x i32>* %89
%91 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %82
%92 = bitcast i32* %91 to <4 x i32>*
%93 = load <4 x i32>, <4 x i32>* %92
%94 = getelementptr inbounds i32, i32* %91, i64 4
%95 = bitcast i32* %94 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = xor <4 x i32> %93, %87
%98 = xor <4 x i32> %96, %90
%99 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %97, <4 x i32>* %99
%100 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> %98, <4 x i32>* %100
br label %101
101: ; preds = %81, %84
%102 = icmp eq i64 %34, %31
br i1 %102, label %105, label %103
103: ; preds = %30, %101
%104 = phi i64 [ 0, %30 ], [ %34, %101 ]
br label %109
105: ; preds = %109, %101, %10
%106 = load i32, i32* %11
%107 = add nsw i32 %106, 1
store i32 %107, i32* %15
%108 = icmp slt i32 %106, %5
br i1 %108, label %118, label %126
109: ; preds = %103, %109
%110 = phi i64 [ %116, %109 ], [ %104, %103 ]
%111 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %110
%112 = load i32, i32* %111
%113 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %110
%114 = load i32, i32* %113
%115 = xor i32 %114, %112
store i32 %115, i32* %113
%116 = add nuw nsw i64 %110, 1
%117 = icmp eq i64 %116, %31
br i1 %117, label %105, label %109
118: ; preds = %105, %118
%119 = phi i32 [ %124, %118 ], [ %107, %105 ]
%120 = call i32 @Flap(i32* %21, i32 %1, i32 %119, i32* %2, i32 %3, i32* %21)
%121 = call i32 @__Hash2(i32* %15, i32 1, i32* %21, i32 64, i32* %21)
%122 = call i32 @memset(i32* %24, i32 0, i32 %25)
%123 = load i32, i32* %15
%124 = add nsw i32 %123, 1
store i32 %124, i32* %15
%125 = icmp slt i32 %123, %5
br i1 %125, label %118, label %126
126: ; preds = %118, %105
%127 = call i32 @__Hash4(i32* %7, i32 16, i32* %14, i32 8, i32* %12, i32 4, i32* %7, i32 16, i32* %27)
br i1 %29, label %128, label %203
128: ; preds = %126
%129 = zext i32 %6 to i64
%130 = icmp ult i32 %6, 8
br i1 %130, label %201, label %131
131: ; preds = %128
%132 = and i64 %129, 4294967288
%133 = add nsw i64 %132, -8
%134 = lshr exact i64 %133, 3
%135 = add nuw nsw i64 %134, 1
%136 = and i64 %135, 1
%137 = icmp eq i64 %133, 0
br i1 %137, label %179, label %138
138: ; preds = %131
%139 = and i64 %135, 4611686018427387902
br label %140
140: ; preds = %140, %138
%141 = phi i64 [ 0, %138 ], [ %176, %140 ]
%142 = phi i64 [ 0, %138 ], [ %177, %140 ]
%143 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %141
%144 = bitcast i32* %143 to <4 x i32>*
%145 = load <4 x i32>, <4 x i32>* %144
%146 = getelementptr inbounds i32, i32* %143, i64 4
%147 = bitcast i32* %146 to <4 x i32>*
%148 = load <4 x i32>, <4 x i32>* %147
%149 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %141
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %149, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = xor <4 x i32> %151, %145
%156 = xor <4 x i32> %154, %148
%157 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %155, <4 x i32>* %157
%158 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %156, <4 x i32>* %158
%159 = or i64 %141, 8
%160 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %159
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds i32, i32* %160, i64 4
%164 = bitcast i32* %163 to <4 x i32>*
%165 = load <4 x i32>, <4 x i32>* %164
%166 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %159
%167 = bitcast i32* %166 to <4 x i32>*
%168 = load <4 x i32>, <4 x i32>* %167
%169 = getelementptr inbounds i32, i32* %166, i64 4
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = xor <4 x i32> %168, %162
%173 = xor <4 x i32> %171, %165
%174 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %172, <4 x i32>* %174
%175 = bitcast i32* %169 to <4 x i32>*
store <4 x i32> %173, <4 x i32>* %175
%176 = add nuw i64 %141, 16
%177 = add i64 %142, 2
%178 = icmp eq i64 %177, %139
br i1 %178, label %179, label %140
179: ; preds = %140, %131
%180 = phi i64 [ 0, %131 ], [ %176, %140 ]
%181 = icmp eq i64 %136, 0
br i1 %181, label %199, label %182
182: ; preds = %179
%183 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %180
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = getelementptr inbounds i32, i32* %183, i64 4
%187 = bitcast i32* %186 to <4 x i32>*
%188 = load <4 x i32>, <4 x i32>* %187
%189 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %180
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = getelementptr inbounds i32, i32* %189, i64 4
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = xor <4 x i32> %191, %185
%196 = xor <4 x i32> %194, %188
%197 = bitcast i32* %189 to <4 x i32>*
store <4 x i32> %195, <4 x i32>* %197
%198 = bitcast i32* %192 to <4 x i32>*
store <4 x i32> %196, <4 x i32>* %198
br label %199
199: ; preds = %179, %182
%200 = icmp eq i64 %132, %129
br i1 %200, label %203, label %201
201: ; preds = %128, %199
%202 = phi i64 [ 0, %128 ], [ %132, %199 ]
br label %205
203: ; preds = %205, %199, %126
%204 = call i32 @memcpy(i32* %9, i32* %21, i32 %6)
ret void
205: ; preds = %201, %205
%206 = phi i64 [ %212, %205 ], [ %202, %201 ]
%207 = getelementptr inbounds [64 x i32], [64 x i32]* %13, i64 0, i64 %206
%208 = load i32, i32* %207
%209 = getelementptr inbounds [64 x i32], [64 x i32]* %16, i64 0, i64 %206
%210 = load i32, i32* %209
%211 = xor i32 %210, %208
store i32 %211, i32* %209
%212 = add nuw nsw i64 %206, 1
%213 = icmp eq i64 %212, %129
br i1 %213, label %203, label %205
}