#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 /*<<< orphan*/ uint8_t;
typedef int uint64_t;
typedef scalar_t__ uint32_t;

/* Variables and functions */
int /*<<< orphan*/ E512(scalar_t__ *, scalar_t__ *, scalar_t__ *, scalar_t__ *,
                        scalar_t__ *);
void Compress512(const uint8_t *message_block, uint8_t *chaining_value,
                 uint64_t counter, const uint8_t salt[64]) {
  uint32_t pt[16], ct[16];
  uint32_t msg_u32[32];
  uint32_t salt_u32[16];
  uint32_t cnt[4];
  int i;
  for (i = 0; i < 16; i++)
    pt[i] = (((uint32_t *)(chaining_value + 4 * i))[0]);
  for (i = 0; i < 32; i++)
    msg_u32[i] = (((uint32_t *)(message_block + 4 * i))[0]);
  for (i = 0; i < 16; i++)
    salt_u32[i] = (((uint32_t *)(salt + 4 * i))[0]);
  cnt[1] = (uint32_t)(counter >> 32);
  cnt[0] = (uint32_t)(counter & 0xFFFFFFFFULL);
  cnt[2] = 0;
  cnt[3] = 0;
  E512(pt, ct, msg_u32, salt_u32, cnt);
  for (i = 0; i < 16; i++)
    pt[i] ^= ct[i];
  for (i = 0; i < 16; i++)
    ((uint32_t *)(chaining_value + i * 4))[0] = pt[i];
  return;
}


x86 assembly (clang, -O0):
<Compress512>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2d0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x2c4(%rbp)
cmpl   $0x10,-0x2c4(%rbp)
jge    1178 <Compress512+0x68>
mov    -0x10(%rbp),%rax
mov    -0x2c4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%rcx
movslq -0x2c4(%rbp),%rax
mov    %rcx,-0xa0(%rbp,%rax,8)
ff
mov    -0x2c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c4(%rbp)
jmp    1134 <Compress512+0x24>
movl   $0x0,-0x2c4(%rbp)
cmpl   $0x20,-0x2c4(%rbp)
jge    11c6 <Compress512+0xb6>
mov    -0x8(%rbp),%rax
mov    -0x2c4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%rcx
movslq -0x2c4(%rbp),%rax
mov    %rcx,-0x220(%rbp,%rax,8)
ff
mov    -0x2c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c4(%rbp)
jmp    1182 <Compress512+0x72>
movl   $0x0,-0x2c4(%rbp)
cmpl   $0x10,-0x2c4(%rbp)
jge    1214 <Compress512+0x104>
mov    -0x20(%rbp),%rax
mov    -0x2c4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%rcx
movslq -0x2c4(%rbp),%rax
mov    %rcx,-0x2a0(%rbp,%rax,8)
ff
mov    -0x2c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c4(%rbp)
jmp    11d0 <Compress512+0xc0>
mov    -0x14(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
cltq
mov    %rax,-0x2b8(%rbp)
movslq -0x14(%rbp),%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x2c0(%rbp)
movq   $0x0,-0x2b0(%rbp)
movq   $0x0,-0x2a8(%rbp)
lea    -0xa0(%rbp),%rdi
lea    -0x120(%rbp),%rsi
lea    -0x220(%rbp),%rdx
lea    -0x2a0(%rbp),%rcx
lea    -0x2c0(%rbp),%r8
call   1030 <E512@plt>
movl   $0x0,-0x2c4(%rbp)
cmpl   $0x10,-0x2c4(%rbp)
jge    12ce <Compress512+0x1be>
movslq -0x2c4(%rbp),%rax
mov    -0x120(%rbp,%rax,8),%rcx
ff
movslq -0x2c4(%rbp),%rax
xor    -0xa0(%rbp,%rax,8),%rcx
ff
mov    %rcx,-0xa0(%rbp,%rax,8)
ff
mov    -0x2c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c4(%rbp)
jmp    1287 <Compress512+0x177>
movl   $0x0,-0x2c4(%rbp)
cmpl   $0x10,-0x2c4(%rbp)
jge    131c <Compress512+0x20c>
movslq -0x2c4(%rbp),%rax
mov    -0xa0(%rbp,%rax,8),%rdx
ff
mov    -0x10(%rbp),%rax
mov    -0x2c4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,4)
mov    -0x2c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c4(%rbp)
jmp    12d8 <Compress512+0x1c8>
add    $0x2d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Compress512>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2c8,%rsp
mov    %rsi,%rbx
mov    (%rsi),%rax
mov    %rax,(%rsp)
mov    0x10(%rsi),%rax
mov    %rax,0x8(%rsp)
mov    0x20(%rsi),%rax
mov    %rax,0x10(%rsp)
mov    0x30(%rsi),%rax
mov    %rax,0x18(%rsp)
mov    0x40(%rsi),%rax
mov    %rax,0x20(%rsp)
mov    0x50(%rsi),%rax
mov    %rax,0x28(%rsp)
mov    0x60(%rsi),%rax
mov    %rax,0x30(%rsp)
mov    0x70(%rsi),%rax
mov    %rax,0x38(%rsp)
mov    0x80(%rsi),%rax
mov    %rax,0x40(%rsp)
mov    0x90(%rsi),%rax
mov    %rax,0x48(%rsp)
mov    0xa0(%rsi),%rax
mov    %rax,0x50(%rsp)
mov    0xb0(%rsi),%rax
mov    %rax,0x58(%rsp)
mov    0xc0(%rsi),%rax
mov    %rax,0x60(%rsp)
mov    0xd0(%rsi),%rax
mov    %rax,0x68(%rsp)
mov    0xe0(%rsi),%rax
mov    %rax,0x70(%rsp)
mov    0xf0(%rsi),%rax
mov    %rax,0x78(%rsp)
movups (%rdi),%xmm0
movups 0x10(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x1c0(%rsp)
movups 0x20(%rdi),%xmm0
movups 0x30(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x1d0(%rsp)
movups 0x40(%rdi),%xmm0
movups 0x50(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x1e0(%rsp)
movups 0x60(%rdi),%xmm0
movups 0x70(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x1f0(%rsp)
movups 0x80(%rdi),%xmm0
movups 0x90(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x200(%rsp)
movups 0xa0(%rdi),%xmm0
movups 0xb0(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x210(%rsp)
movups 0xc0(%rdi),%xmm0
movups 0xd0(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x220(%rsp)
movups 0xe0(%rdi),%xmm0
movups 0xf0(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x230(%rsp)
movups 0x100(%rdi),%xmm0
movups 0x110(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x240(%rsp)
movups 0x120(%rdi),%xmm0
movups 0x130(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x250(%rsp)
movups 0x140(%rdi),%xmm0
movups 0x150(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x260(%rsp)
movups 0x160(%rdi),%xmm0
movups 0x170(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x270(%rsp)
movups 0x180(%rdi),%xmm0
movups 0x190(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x280(%rsp)
movups 0x1a0(%rdi),%xmm0
movups 0x1b0(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x290(%rsp)
movups 0x1c0(%rdi),%xmm0
movups 0x1d0(%rdi),%xmm1
movlhps %xmm1,%xmm0
movaps %xmm0,0x2a0(%rsp)
mov    0x1e0(%rdi),%rax
mov    %rax,0x2b0(%rsp)
mov    0x1f0(%rdi),%rax
mov    %rax,0x2b8(%rsp)
mov    (%rcx),%rax
mov    %rax,0xa0(%rsp)
mov    0x10(%rcx),%rax
mov    %rax,0xa8(%rsp)
mov    0x20(%rcx),%rax
mov    %rax,0xb0(%rsp)
mov    0x30(%rcx),%rax
mov    %rax,0xb8(%rsp)
mov    0x40(%rcx),%rax
mov    %rax,0xc0(%rsp)
mov    0x50(%rcx),%rax
mov    %rax,0xc8(%rsp)
mov    0x60(%rcx),%rax
mov    %rax,0xd0(%rsp)
mov    0x70(%rcx),%rax
mov    %rax,0xd8(%rsp)
mov    0x80(%rcx),%rax
mov    %rax,0xe0(%rsp)
mov    0x90(%rcx),%rax
mov    %rax,0xe8(%rsp)
mov    0xa0(%rcx),%rax
mov    %rax,0xf0(%rsp)
mov    0xb0(%rcx),%rax
mov    %rax,0xf8(%rsp)
mov    0xc0(%rcx),%rax
mov    %rax,0x100(%rsp)
mov    0xd0(%rcx),%rax
mov    %rax,0x108(%rsp)
mov    0xe0(%rcx),%rax
mov    %rax,0x110(%rsp)
mov    0xf0(%rcx),%rax
mov    %rax,0x118(%rsp)
mov    %edx,%eax
mov    %rax,0x1a0(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x1b0(%rsp)
mov    %rsp,%rdi
lea    0x120(%rsp),%rsi
lea    0x1c0(%rsp),%rdx
lea    0xa0(%rsp),%rcx
lea    0x1a0(%rsp),%r8
call   1030 <E512@plt>
mov    (%rsp),%rax
mov    0x8(%rsp),%rcx
xor    0x120(%rsp),%rax
mov    %rax,0x98(%rsp)
xor    0x128(%rsp),%rcx
mov    %rcx,0x90(%rsp)
mov    0x10(%rsp),%rax
xor    0x130(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x18(%rsp),%rax
xor    0x138(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x20(%rsp),%r14
xor    0x140(%rsp),%r14
mov    0x28(%rsp),%r15
xor    0x148(%rsp),%r15
mov    0x30(%rsp),%r12
xor    0x150(%rsp),%r12
mov    0x38(%rsp),%r13
xor    0x158(%rsp),%r13
mov    0x40(%rsp),%r11
xor    0x160(%rsp),%r11
mov    0x48(%rsp),%r9
xor    0x168(%rsp),%r9
mov    0x50(%rsp),%r8
xor    0x170(%rsp),%r8
mov    0x58(%rsp),%rsi
xor    0x178(%rsp),%rsi
mov    0x60(%rsp),%rdx
xor    0x180(%rsp),%rdx
mov    0x68(%rsp),%rbp
xor    0x188(%rsp),%rbp
mov    0x70(%rsp),%rcx
xor    0x190(%rsp),%rcx
mov    0x78(%rsp),%rax
xor    0x198(%rsp),%rax
mov    0x98(%rsp),%r10
mov    %r10,(%rbx)
mov    0x90(%rsp),%rdi
mov    %rdi,0x10(%rbx)
mov    0x88(%rsp),%rdi
mov    %rdi,0x20(%rbx)
mov    0x80(%rsp),%rdi
mov    %rdi,0x30(%rbx)
mov    %r14,0x40(%rbx)
mov    %r15,0x50(%rbx)
mov    %r12,0x60(%rbx)
mov    %r13,0x70(%rbx)
mov    %r11,0x80(%rbx)
mov    %r9,0x90(%rbx)
mov    %r8,0xa0(%rbx)
mov    %rsi,0xb0(%rbx)
mov    %rdx,0xc0(%rbx)
mov    %rbp,0xd0(%rbx)
mov    %rcx,0xe0(%rbx)
mov    %rax,0xf0(%rbx)
add    $0x2c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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