#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 */

/* Variables and functions */
int /*<<< orphan*/ haraka512_perm(unsigned char *, unsigned char *);
void haraka_S_absorb(unsigned char *s, unsigned int r, const unsigned char *m,
                     unsigned long long mlen, unsigned char p) {
  unsigned long long i;
  unsigned char t[r];
  while (mlen >= r) {
    for (i = 0; i < r; ++i) {
      s[i] ^= m[i];
    }
    haraka512_perm(s, s);
    mlen -= r;
    m += r;
  }
  for (i = 0; i < r; ++i) {
    t[i] = 0;
  }
  for (i = 0; i < mlen; ++i) {
    t[i] = m[i];
  }
  t[i] = p;
  t[r - 1] |= 128;
  for (i = 0; i < r; ++i) {
    s[i] ^= t[i];
  }
}


x86 assembly (clang, -O0):
<haraka_S_absorb>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %r8b,%al
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %al,-0x21(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
cmp    %rcx,%rax
jb     11db <haraka_S_absorb+0xcb>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
cmp    %rcx,%rax
jae    11a9 <haraka_S_absorb+0x99>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    116b <haraka_S_absorb+0x5b>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <haraka512_perm@plt>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    1153 <haraka_S_absorb+0x43>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
cmp    %rcx,%rax
jae    1210 <haraka_S_absorb+0x100>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11e3 <haraka_S_absorb+0xd3>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    124d <haraka_S_absorb+0x13d>
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rdx
mov    (%rcx,%rdx,1),%dl
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1218 <haraka_S_absorb+0x108>
mov    -0x48(%rbp),%rax
mov    -0x21(%rbp),%dl
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edx
or     $0x80,%edx
mov    %dl,(%rax,%rcx,1)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
cmp    %rcx,%rax
jae    12b6 <haraka_S_absorb+0x1a6>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1278 <haraka_S_absorb+0x168>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<haraka_S_absorb>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8d,-0x34(%rbp)
mov    %rcx,%r13
mov    %rdx,%r12
mov    %esi,%r8d
mov    %rdi,%rbx
mov    %esi,%r14d
mov    %rsp,%rcx
lea    0xf(%r14),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
cmp    %r13,%r14
jbe    123e <haraka_S_absorb+0x11e>
test   %r8d,%r8d
mov    -0x60(%rbp),%r15
je     1180 <haraka_S_absorb+0x60>
mov    %r15,%rdi
xor    %esi,%esi
mov    %r14,%rdx
mov    %r8,-0x30(%rbp)
call   1030 <memset@plt>
mov    -0x30(%rbp),%r8
test   %r13,%r13
je     1213 <haraka_S_absorb+0xf3>
cmp    $0x8,%r13
jb     11a9 <haraka_S_absorb+0x89>
lea    (%r12,%r13,1),%rax
cmp    %rax,%r15
jae    1459 <haraka_S_absorb+0x339>
lea    (%r15,%r13,1),%rax
cmp    %rax,%r12
jae    1459 <haraka_S_absorb+0x339>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r13,%rsi
mov    %r13,%rdx
and    $0x3,%rdx
je     11d3 <haraka_S_absorb+0xb3>
nopl   (%rax)
movzbl (%r12,%rax,1),%ecx
mov    %cl,(%r15,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11c0 <haraka_S_absorb+0xa0>
cmp    $0x3,%rsi
jb     1213 <haraka_S_absorb+0xf3>
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%ecx
mov    %cl,(%r15,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
mov    %cl,0x1(%r15,%rax,1)
movzbl 0x2(%r12,%rax,1),%ecx
mov    %cl,0x2(%r15,%rax,1)
movzbl 0x3(%r12,%rax,1),%ecx
mov    %cl,0x3(%r15,%rax,1)
add    $0x4,%rax
cmp    %rax,%r13
jne    11e0 <haraka_S_absorb+0xc0>
lea    -0x1(%r8),%eax
mov    -0x34(%rbp),%ecx
mov    %cl,(%r15,%r13,1)
orb    $0x80,(%r15,%rax,1)
cmp    $0x1,%r8d
jb     1551 <haraka_S_absorb+0x431>
cmp    $0x8,%r8d
jae    144c <haraka_S_absorb+0x32c>
xor    %eax,%eax
jmp    1540 <haraka_S_absorb+0x420>
lea    (%rbx,%r14,1),%rax
mov    %rax,-0x70(%rbp)
mov    %r14d,%eax
and    $0xffffffe0,%eax
mov    %rax,-0x40(%rbp)
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x58(%rbp)
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x50(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x48(%rbp)
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x68(%rbp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,-0x80(%rbp)
xor    %r15d,%r15d
mov    %r12,-0x78(%rbp)
jmp    12b8 <haraka_S_absorb+0x198>
nop
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %r8,%r13
call   1040 <haraka512_perm@plt>
mov    %r13,%r8
mov    -0x30(%rbp),%r13
sub    %r14,%r13
add    %r14,%r12
add    $0x1,%r15
cmp    %r14,%r13
jb     1162 <haraka_S_absorb+0x42>
mov    %r13,-0x30(%rbp)
test   %r8d,%r8d
je     1290 <haraka_S_absorb+0x170>
cmp    $0x8,%r8d
jb     12e0 <haraka_S_absorb+0x1c0>
mov    %r15,%rax
imul   %r14,%rax
add    %r14,%rax
add    -0x78(%rbp),%rax
cmp    %rbx,%rax
jbe    1354 <haraka_S_absorb+0x234>
cmp    -0x70(%rbp),%r12
jae    1354 <haraka_S_absorb+0x234>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r14,%rsi
mov    -0x80(%rbp),%rdx
test   %rdx,%rdx
je     1312 <haraka_S_absorb+0x1f2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1300 <haraka_S_absorb+0x1e0>
cmp    $0x3,%rsi
jb     1290 <haraka_S_absorb+0x170>
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
xor    %cl,0x1(%rbx,%rax,1)
movzbl 0x2(%r12,%rax,1),%ecx
xor    %cl,0x2(%rbx,%rax,1)
movzbl 0x3(%r12,%rax,1),%ecx
xor    %cl,0x3(%rbx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r14
jne    1320 <haraka_S_absorb+0x200>
jmp    1290 <haraka_S_absorb+0x170>
cmp    $0x20,%r8d
jae    1361 <haraka_S_absorb+0x241>
xor    %ecx,%ecx
jmp    1417 <haraka_S_absorb+0x2f7>
cmpq   $0x0,-0x58(%rbp)
je     1442 <haraka_S_absorb+0x322>
mov    -0x48(%rbp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups (%rbx,%rax,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rbx,%rax,1),%xmm1
movups 0x30(%rbx,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm0,0x10(%rbx,%rax,1)
movups 0x20(%r12,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%r12,%rax,1),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rbx,%rax,1)
movups %xmm1,0x30(%rbx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    1380 <haraka_S_absorb+0x260>
testb  $0x1,-0x50(%rbp)
je     13fc <haraka_S_absorb+0x2dc>
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups (%rbx,%rax,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rbx,%rax,1)
movups %xmm0,0x10(%rbx,%rax,1)
cmp    %r14,-0x40(%rbp)
je     1290 <haraka_S_absorb+0x170>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
test   $0x18,%r14b
je     12e2 <haraka_S_absorb+0x1c2>
mov    -0x68(%rbp),%rdx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,1),%rax
xor    %rax,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1420 <haraka_S_absorb+0x300>
mov    %rdx,%rax
cmp    %r14,%rdx
je     1290 <haraka_S_absorb+0x170>
jmp    12e2 <haraka_S_absorb+0x1c2>
xor    %eax,%eax
testb  $0x1,-0x50(%rbp)
jne    13d9 <haraka_S_absorb+0x2b9>
jmp    13fc <haraka_S_absorb+0x2dc>
cmp    $0x20,%r8d
jae    146a <haraka_S_absorb+0x34a>
xor    %eax,%eax
jmp    1514 <haraka_S_absorb+0x3f4>
cmp    $0x20,%r13
jae    1560 <haraka_S_absorb+0x440>
xor    %eax,%eax
jmp    166e <haraka_S_absorb+0x54e>
mov    %r14d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1588 <haraka_S_absorb+0x468>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
movups 0x20(%rbx,%rcx,1),%xmm2
movups 0x30(%rbx,%rcx,1),%xmm3
xorps  (%r15,%rcx,1),%xmm0
xorps  0x10(%r15,%rcx,1),%xmm1
movups %xmm0,(%rbx,%rcx,1)
movups %xmm1,0x10(%rbx,%rcx,1)
xorps  0x20(%r15,%rcx,1),%xmm2
xorps  0x30(%r15,%rcx,1),%xmm3
movups %xmm2,0x20(%rbx,%rcx,1)
movups %xmm3,0x30(%rbx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    14a0 <haraka_S_absorb+0x380>
test   $0x1,%dl
je     1509 <haraka_S_absorb+0x3e9>
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
xorps  (%r15,%rcx,1),%xmm0
xorps  0x10(%r15,%rcx,1),%xmm1
movups %xmm0,(%rbx,%rcx,1)
movups %xmm1,0x10(%rbx,%rcx,1)
cmp    %r14,%rax
je     1551 <haraka_S_absorb+0x431>
test   $0x18,%r14b
je     1540 <haraka_S_absorb+0x420>
mov    %rax,%rcx
mov    %r14d,%eax
and    $0xfffffff8,%eax
nopl   (%rax)
mov    (%r15,%rcx,1),%rdx
xor    %rdx,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1520 <haraka_S_absorb+0x400>
cmp    %r14,%rax
je     1551 <haraka_S_absorb+0x431>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
add    $0x1,%rax
cmp    %rax,%r14
jne    1540 <haraka_S_absorb+0x420>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1598 <haraka_S_absorb+0x478>
xor    %esi,%esi
jmp    1618 <haraka_S_absorb+0x4f8>
xor    %ecx,%ecx
test   $0x1,%dl
jne    14ec <haraka_S_absorb+0x3cc>
jmp    1509 <haraka_S_absorb+0x3e9>
movabs $0xffffffffffffffe,%rsi
ff ff 0f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%r12,%rsi,1),%xmm0
movups 0x10(%r12,%rsi,1),%xmm1
movaps %xmm0,(%r15,%rsi,1)
movaps %xmm1,0x10(%r15,%rsi,1)
movups 0x20(%r12,%rsi,1),%xmm0
movups 0x30(%r12,%rsi,1),%xmm1
movaps %xmm0,0x20(%r15,%rsi,1)
movaps %xmm1,0x30(%r15,%rsi,1)
movups 0x40(%r12,%rsi,1),%xmm0
movups 0x50(%r12,%rsi,1),%xmm1
movaps %xmm0,0x40(%r15,%rsi,1)
movaps %xmm1,0x50(%r15,%rsi,1)
movups 0x60(%r12,%rsi,1),%xmm0
movups 0x70(%r12,%rsi,1),%xmm1
movaps %xmm0,0x60(%r15,%rsi,1)
movaps %xmm1,0x70(%r15,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    15b0 <haraka_S_absorb+0x490>
test   %rcx,%rcx
je     165b <haraka_S_absorb+0x53b>
lea    (%r15,%rsi,1),%rdx
add    $0x10,%rdx
add    %r12,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movaps %xmm0,-0x10(%rdx,%rdi,1)
movaps %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1640 <haraka_S_absorb+0x520>
cmp    %rax,%r13
je     1213 <haraka_S_absorb+0xf3>
test   $0x18,%r13b
je     11ab <haraka_S_absorb+0x8b>
mov    %rax,%rcx
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,1),%rdx
mov    %rdx,(%r15,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1680 <haraka_S_absorb+0x560>
cmp    %rax,%r13
je     1213 <haraka_S_absorb+0xf3>
jmp    11ab <haraka_S_absorb+0x8b>

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

LLVM IR (-O2):
define void @haraka_S_absorb(i8* %0, i32 %1, i8* nocapture %2, i64 %3, i8 zeroext %4) {
%6 = zext i32 %1 to i64
%7 = alloca i8, i64 %6
%8 = icmp ugt i64 %6, %3
br i1 %8, label %137, label %9
9: ; preds = %5
%10 = icmp eq i32 %1, 0
%11 = getelementptr i8, i8* %0, i64 %6
%12 = and i64 %6, 4294967264
%13 = add nsw i64 %12, -32
%14 = lshr exact i64 %13, 5
%15 = add nuw nsw i64 %14, 1
%16 = icmp ult i32 %1, 8
%17 = icmp ult i32 %1, 32
%18 = and i64 %6, 4294967264
%19 = and i64 %15, 1
%20 = icmp eq i64 %13, 0
%21 = and i64 %15, 1152921504606846974
%22 = icmp eq i64 %19, 0
%23 = icmp eq i64 %18, %6
%24 = and i64 %6, 24
%25 = icmp eq i64 %24, 0
%26 = and i64 %6, 4294967288
%27 = icmp eq i64 %26, %6
%28 = and i64 %6, 3
%29 = icmp eq i64 %28, 0
br label %30
30: ; preds = %9, %169
%31 = phi i64 [ 0, %9 ], [ %174, %169 ]
%32 = phi i8* [ %2, %9 ], [ %172, %169 ]
%33 = phi i64 [ %3, %9 ], [ %171, %169 ]
%34 = mul i64 %31, %6
%35 = add i64 %34, %6
%36 = getelementptr i8, i8* %2, i64 %35
br i1 %10, label %169, label %37
37: ; preds = %30
br i1 %16, label %119, label %38
38: ; preds = %37
%39 = icmp ugt i8* %36, %0
%40 = icmp ult i8* %32, %11
%41 = and i1 %39, %40
br i1 %41, label %119, label %42
42: ; preds = %38
br i1 %17, label %104, label %43
43: ; preds = %42
br i1 %20, label %83, label %44
44: ; preds = %43, %44
%45 = phi i64 [ %80, %44 ], [ 0, %43 ]
%46 = phi i64 [ %81, %44 ], [ 0, %43 ]
%47 = getelementptr inbounds i8, i8* %32, i64 %45
%48 = bitcast i8* %47 to <16 x i8>*
%49 = load <16 x i8>, <16 x i8>* %48
%50 = getelementptr inbounds i8, i8* %47, i64 16
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %0, i64 %45
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = getelementptr inbounds i8, i8* %53, i64 16
%57 = bitcast i8* %56 to <16 x i8>*
%58 = load <16 x i8>, <16 x i8>* %57
%59 = xor <16 x i8> %55, %49
%60 = xor <16 x i8> %58, %52
%61 = bitcast i8* %53 to <16 x i8>*
store <16 x i8> %59, <16 x i8>* %61
%62 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %60, <16 x i8>* %62
%63 = or i64 %45, 32
%64 = getelementptr inbounds i8, i8* %32, i64 %63
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %0, i64 %63
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = getelementptr inbounds i8, i8* %70, i64 16
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = xor <16 x i8> %72, %66
%77 = xor <16 x i8> %75, %69
%78 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %78
%79 = bitcast i8* %73 to <16 x i8>*
store <16 x i8> %77, <16 x i8>* %79
%80 = add nuw i64 %45, 64
%81 = add i64 %46, 2
%82 = icmp eq i64 %81, %21
br i1 %82, label %83, label %44
83: ; preds = %44, %43
%84 = phi i64 [ 0, %43 ], [ %80, %44 ]
br i1 %22, label %102, label %85
85: ; preds = %83
%86 = getelementptr inbounds i8, i8* %32, i64 %84
%87 = bitcast i8* %86 to <16 x i8>*
%88 = load <16 x i8>, <16 x i8>* %87
%89 = getelementptr inbounds i8, i8* %86, i64 16
%90 = bitcast i8* %89 to <16 x i8>*
%91 = load <16 x i8>, <16 x i8>* %90
%92 = getelementptr inbounds i8, i8* %0, i64 %84
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %92, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = xor <16 x i8> %94, %88
%99 = xor <16 x i8> %97, %91
%100 = bitcast i8* %92 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %100
%101 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %99, <16 x i8>* %101
br label %102
102: ; preds = %83, %85
br i1 %23, label %169, label %103
103: ; preds = %102
br i1 %25, label %119, label %104
104: ; preds = %42, %103
%105 = phi i64 [ %18, %103 ], [ 0, %42 ]
br label %106
106: ; preds = %106, %104
%107 = phi i64 [ %105, %104 ], [ %116, %106 ]
%108 = getelementptr inbounds i8, i8* %32, i64 %107
%109 = bitcast i8* %108 to <8 x i8>*
%110 = load <8 x i8>, <8 x i8>* %109
%111 = getelementptr inbounds i8, i8* %0, i64 %107
%112 = bitcast i8* %111 to <8 x i8>*
%113 = load <8 x i8>, <8 x i8>* %112
%114 = xor <8 x i8> %113, %110
%115 = bitcast i8* %111 to <8 x i8>*
store <8 x i8> %114, <8 x i8>* %115
%116 = add nuw i64 %107, 8
%117 = icmp eq i64 %116, %26
br i1 %117, label %118, label %106
118: ; preds = %106
br i1 %27, label %169, label %119
119: ; preds = %38, %37, %103, %118
%120 = phi i64 [ 0, %37 ], [ 0, %38 ], [ %18, %103 ], [ %26, %118 ]
%121 = xor i64 %120, -1
%122 = add nsw i64 %121, %6
br i1 %29, label %134, label %123
123: ; preds = %119, %123
%124 = phi i64 [ %131, %123 ], [ %120, %119 ]
%125 = phi i64 [ %132, %123 ], [ 0, %119 ]
%126 = getelementptr inbounds i8, i8* %32, i64 %124
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %0, i64 %124
%129 = load i8, i8* %128
%130 = xor i8 %129, %127
store i8 %130, i8* %128
%131 = add nuw nsw i64 %124, 1
%132 = add i64 %125, 1
%133 = icmp eq i64 %132, %28
br i1 %133, label %134, label %123
134: ; preds = %123, %119
%135 = phi i64 [ %120, %119 ], [ %131, %123 ]
%136 = icmp ult i64 %122, 3
br i1 %136, label %169, label %142
137: ; preds = %169, %5
%138 = phi i64 [ %3, %5 ], [ %171, %169 ]
%139 = phi i8* [ %2, %5 ], [ %172, %169 ]
%140 = icmp eq i32 %1, 0
br i1 %140, label %175, label %141
141: ; preds = %137
br label %175
142: ; preds = %134, %142
%143 = phi i64 [ %167, %142 ], [ %135, %134 ]
%144 = getelementptr inbounds i8, i8* %32, i64 %143
%145 = load i8, i8* %144
%146 = getelementptr inbounds i8, i8* %0, i64 %143
%147 = load i8, i8* %146
%148 = xor i8 %147, %145
store i8 %148, i8* %146
%149 = add nuw nsw i64 %143, 1
%150 = getelementptr inbounds i8, i8* %32, i64 %149
%151 = load i8, i8* %150
%152 = getelementptr inbounds i8, i8* %0, i64 %149
%153 = load i8, i8* %152
%154 = xor i8 %153, %151
store i8 %154, i8* %152
%155 = add nuw nsw i64 %143, 2
%156 = getelementptr inbounds i8, i8* %32, i64 %155
%157 = load i8, i8* %156
%158 = getelementptr inbounds i8, i8* %0, i64 %155
%159 = load i8, i8* %158
%160 = xor i8 %159, %157
store i8 %160, i8* %158
%161 = add nuw nsw i64 %143, 3
%162 = getelementptr inbounds i8, i8* %32, i64 %161
%163 = load i8, i8* %162
%164 = getelementptr inbounds i8, i8* %0, i64 %161
%165 = load i8, i8* %164
%166 = xor i8 %165, %163
store i8 %166, i8* %164
%167 = add nuw nsw i64 %143, 4
%168 = icmp eq i64 %167, %6
br i1 %168, label %169, label %142
169: ; preds = %134, %142, %102, %118, %30
%170 = tail call i32 @haraka512_perm(i8* %0, i8* %0)
%171 = sub i64 %33, %6
%172 = getelementptr inbounds i8, i8* %32, i64 %6
%173 = icmp ult i64 %171, %6
%174 = add i64 %31, 1
br i1 %173, label %137, label %30
175: ; preds = %141, %137
%176 = icmp eq i64 %138, 0
br i1 %176, label %320, label %177
177: ; preds = %175
%178 = icmp ult i64 %138, 8
br i1 %178, label %283, label %179
179: ; preds = %177
%180 = getelementptr i8, i8* %7, i64 %138
%181 = getelementptr i8, i8* %139, i64 %138
%182 = icmp ult i8* %7, %181
%183 = icmp ult i8* %139, %180
%184 = and i1 %182, %183
br i1 %184, label %283, label %185
185: ; preds = %179
%186 = icmp ult i64 %138, 32
br i1 %186, label %269, label %187
187: ; preds = %185
%188 = and i64 %138, -32
%189 = add i64 %188, -32
%190 = lshr exact i64 %189, 5
%191 = add nuw nsw i64 %190, 1
%192 = and i64 %191, 3
%193 = icmp ult i64 %189, 96
br i1 %193, label %245, label %194
194: ; preds = %187
%195 = and i64 %191, 1152921504606846972
br label %196
196: ; preds = %196, %194
%197 = phi i64 [ 0, %194 ], [ %242, %196 ]
%198 = phi i64 [ 0, %194 ], [ %243, %196 ]
%199 = getelementptr inbounds i8, i8* %139, i64 %197
%200 = bitcast i8* %199 to <16 x i8>*
%201 = load <16 x i8>, <16 x i8>* %200
%202 = getelementptr inbounds i8, i8* %199, i64 16
%203 = bitcast i8* %202 to <16 x i8>*
%204 = load <16 x i8>, <16 x i8>* %203
%205 = getelementptr inbounds i8, i8* %7, i64 %197
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %206
%207 = getelementptr inbounds i8, i8* %205, i64 16
%208 = bitcast i8* %207 to <16 x i8>*
store <16 x i8> %204, <16 x i8>* %208
%209 = or i64 %197, 32
%210 = getelementptr inbounds i8, i8* %139, i64 %209
%211 = bitcast i8* %210 to <16 x i8>*
%212 = load <16 x i8>, <16 x i8>* %211
%213 = getelementptr inbounds i8, i8* %210, i64 16
%214 = bitcast i8* %213 to <16 x i8>*
%215 = load <16 x i8>, <16 x i8>* %214
%216 = getelementptr inbounds i8, i8* %7, i64 %209
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %212, <16 x i8>* %217
%218 = getelementptr inbounds i8, i8* %216, i64 16
%219 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %215, <16 x i8>* %219
%220 = or i64 %197, 64
%221 = getelementptr inbounds i8, i8* %139, i64 %220
%222 = bitcast i8* %221 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = getelementptr inbounds i8, i8* %221, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = getelementptr inbounds i8, i8* %7, i64 %220
%228 = bitcast i8* %227 to <16 x i8>*
store <16 x i8> %223, <16 x i8>* %228
%229 = getelementptr inbounds i8, i8* %227, i64 16
%230 = bitcast i8* %229 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %230
%231 = or i64 %197, 96
%232 = getelementptr inbounds i8, i8* %139, i64 %231
%233 = bitcast i8* %232 to <16 x i8>*
%234 = load <16 x i8>, <16 x i8>* %233
%235 = getelementptr inbounds i8, i8* %232, i64 16
%236 = bitcast i8* %235 to <16 x i8>*
%237 = load <16 x i8>, <16 x i8>* %236
%238 = getelementptr inbounds i8, i8* %7, i64 %231
%239 = bitcast i8* %238 to <16 x i8>*
store <16 x i8> %234, <16 x i8>* %239
%240 = getelementptr inbounds i8, i8* %238, i64 16
%241 = bitcast i8* %240 to <16 x i8>*
store <16 x i8> %237, <16 x i8>* %241
%242 = add nuw i64 %197, 128
%243 = add i64 %198, 4
%244 = icmp eq i64 %243, %195
br i1 %244, label %245, label %196
245: ; preds = %196, %187
%246 = phi i64 [ 0, %187 ], [ %242, %196 ]
%247 = icmp eq i64 %192, 0
br i1 %247, label %264, label %248
248: ; preds = %245, %248
%249 = phi i64 [ %261, %248 ], [ %246, %245 ]
%250 = phi i64 [ %262, %248 ], [ 0, %245 ]
%251 = getelementptr inbounds i8, i8* %139, i64 %249
%252 = bitcast i8* %251 to <16 x i8>*
%253 = load <16 x i8>, <16 x i8>* %252
%254 = getelementptr inbounds i8, i8* %251, i64 16
%255 = bitcast i8* %254 to <16 x i8>*
%256 = load <16 x i8>, <16 x i8>* %255
%257 = getelementptr inbounds i8, i8* %7, i64 %249
%258 = bitcast i8* %257 to <16 x i8>*
store <16 x i8> %253, <16 x i8>* %258
%259 = getelementptr inbounds i8, i8* %257, i64 16
%260 = bitcast i8* %259 to <16 x i8>*
store <16 x i8> %256, <16 x i8>* %260
%261 = add nuw i64 %249, 32
%262 = add i64 %250, 1
%263 = icmp eq i64 %262, %192
br i1 %263, label %264, label %248
264: ; preds = %248, %245
%265 = icmp eq i64 %138, %188
br i1 %265, label %320, label %266
266: ; preds = %264
%267 = and i64 %138, 24
%268 = icmp eq i64 %267, 0
br i1 %268, label %283, label %269
269: ; preds = %185, %266
%270 = phi i64 [ %188, %266 ], [ 0, %185 ]
%271 = and i64 %138, -8
br label %272
272: ; preds = %272, %269
%273 = phi i64 [ %270, %269 ], [ %279, %272 ]
%274 = getelementptr inbounds i8, i8* %139, i64 %273
%275 = bitcast i8* %274 to <8 x i8>*
%276 = load <8 x i8>, <8 x i8>* %275
%277 = getelementptr inbounds i8, i8* %7, i64 %273
%278 = bitcast i8* %277 to <8 x i8>*
store <8 x i8> %276, <8 x i8>* %278
%279 = add nuw i64 %273, 8
%280 = icmp eq i64 %279, %271
br i1 %280, label %281, label %272
281: ; preds = %272
%282 = icmp eq i64 %138, %271
br i1 %282, label %320, label %283
283: ; preds = %179, %177, %266, %281
%284 = phi i64 [ 0, %177 ], [ 0, %179 ], [ %188, %266 ], [ %271, %281 ]
%285 = xor i64 %284, -1
%286 = add i64 %138, %285
%287 = and i64 %138, 3
%288 = icmp eq i64 %287, 0
br i1 %288, label %298, label %289
289: ; preds = %283, %289
%290 = phi i64 [ %295, %289 ], [ %284, %283 ]
%291 = phi i64 [ %296, %289 ], [ 0, %283 ]
%292 = getelementptr inbounds i8, i8* %139, i64 %290
%293 = load i8, i8* %292
%294 = getelementptr inbounds i8, i8* %7, i64 %290
store i8 %293, i8* %294
%295 = add nuw i64 %290, 1
%296 = add i64 %291, 1
%297 = icmp eq i64 %296, %287
br i1 %297, label %298, label %289
298: ; preds = %289, %283
%299 = phi i64 [ %284, %283 ], [ %295, %289 ]
%300 = icmp ult i64 %286, 3
br i1 %300, label %320, label %301
301: ; preds = %298, %301
%302 = phi i64 [ %318, %301 ], [ %299, %298 ]
%303 = getelementptr inbounds i8, i8* %139, i64 %302
%304 = load i8, i8* %303
%305 = getelementptr inbounds i8, i8* %7, i64 %302
store i8 %304, i8* %305
%306 = add nuw i64 %302, 1
%307 = getelementptr inbounds i8, i8* %139, i64 %306
%308 = load i8, i8* %307
%309 = getelementptr inbounds i8, i8* %7, i64 %306
store i8 %308, i8* %309
%310 = add nuw i64 %302, 2
%311 = getelementptr inbounds i8, i8* %139, i64 %310
%312 = load i8, i8* %311
%313 = getelementptr inbounds i8, i8* %7, i64 %310
store i8 %312, i8* %313
%314 = add nuw i64 %302, 3
%315 = getelementptr inbounds i8, i8* %139, i64 %314
%316 = load i8, i8* %315
%317 = getelementptr inbounds i8, i8* %7, i64 %314
store i8 %316, i8* %317
%318 = add nuw i64 %302, 4
%319 = icmp eq i64 %318, %138
br i1 %319, label %320, label %301
320: ; preds = %298, %301, %264, %281, %175
%321 = getelementptr inbounds i8, i8* %7, i64 %138
store i8 %4, i8* %321
%322 = add i32 %1, -1
%323 = zext i32 %322 to i64
%324 = getelementptr inbounds i8, i8* %7, i64 %323
%325 = load i8, i8* %324
%326 = or i8 %325, -128
store i8 %326, i8* %324
br i1 %140, label %432, label %327
327: ; preds = %320
%328 = icmp ult i32 %1, 8
br i1 %328, label %421, label %329
329: ; preds = %327
%330 = icmp ult i32 %1, 32
br i1 %330, label %404, label %331
331: ; preds = %329
%332 = and i64 %6, 4294967264
%333 = add nsw i64 %332, -32
%334 = lshr exact i64 %333, 5
%335 = add nuw nsw i64 %334, 1
%336 = and i64 %335, 1
%337 = icmp eq i64 %333, 0
br i1 %337, label %379, label %338
338: ; preds = %331
%339 = and i64 %335, 1152921504606846974
br label %340
340: ; preds = %340, %338
%341 = phi i64 [ 0, %338 ], [ %376, %340 ]
%342 = phi i64 [ 0, %338 ], [ %377, %340 ]
%343 = getelementptr inbounds i8, i8* %7, i64 %341
%344 = bitcast i8* %343 to <16 x i8>*
%345 = load <16 x i8>, <16 x i8>* %344
%346 = getelementptr inbounds i8, i8* %343, i64 16
%347 = bitcast i8* %346 to <16 x i8>*
%348 = load <16 x i8>, <16 x i8>* %347
%349 = getelementptr inbounds i8, i8* %0, i64 %341
%350 = bitcast i8* %349 to <16 x i8>*
%351 = load <16 x i8>, <16 x i8>* %350
%352 = getelementptr inbounds i8, i8* %349, i64 16
%353 = bitcast i8* %352 to <16 x i8>*
%354 = load <16 x i8>, <16 x i8>* %353
%355 = xor <16 x i8> %351, %345
%356 = xor <16 x i8> %354, %348
%357 = bitcast i8* %349 to <16 x i8>*
store <16 x i8> %355, <16 x i8>* %357
%358 = bitcast i8* %352 to <16 x i8>*
store <16 x i8> %356, <16 x i8>* %358
%359 = or i64 %341, 32
%360 = getelementptr inbounds i8, i8* %7, i64 %359
%361 = bitcast i8* %360 to <16 x i8>*
%362 = load <16 x i8>, <16 x i8>* %361
%363 = getelementptr inbounds i8, i8* %360, i64 16
%364 = bitcast i8* %363 to <16 x i8>*
%365 = load <16 x i8>, <16 x i8>* %364
%366 = getelementptr inbounds i8, i8* %0, i64 %359
%367 = bitcast i8* %366 to <16 x i8>*
%368 = load <16 x i8>, <16 x i8>* %367
%369 = getelementptr inbounds i8, i8* %366, i64 16
%370 = bitcast i8* %369 to <16 x i8>*
%371 = load <16 x i8>, <16 x i8>* %370
%372 = xor <16 x i8> %368, %362
%373 = xor <16 x i8> %371, %365
%374 = bitcast i8* %366 to <16 x i8>*
store <16 x i8> %372, <16 x i8>* %374
%375 = bitcast i8* %369 to <16 x i8>*
store <16 x i8> %373, <16 x i8>* %375
%376 = add nuw i64 %341, 64
%377 = add i64 %342, 2
%378 = icmp eq i64 %377, %339
br i1 %378, label %379, label %340
379: ; preds = %340, %331
%380 = phi i64 [ 0, %331 ], [ %376, %340 ]
%381 = icmp eq i64 %336, 0
br i1 %381, label %399, label %382
382: ; preds = %379
%383 = getelementptr inbounds i8, i8* %7, i64 %380
%384 = bitcast i8* %383 to <16 x i8>*
%385 = load <16 x i8>, <16 x i8>* %384
%386 = getelementptr inbounds i8, i8* %383, i64 16
%387 = bitcast i8* %386 to <16 x i8>*
%388 = load <16 x i8>, <16 x i8>* %387
%389 = getelementptr inbounds i8, i8* %0, i64 %380
%390 = bitcast i8* %389 to <16 x i8>*
%391 = load <16 x i8>, <16 x i8>* %390
%392 = getelementptr inbounds i8, i8* %389, i64 16
%393 = bitcast i8* %392 to <16 x i8>*
%394 = load <16 x i8>, <16 x i8>* %393
%395 = xor <16 x i8> %391, %385
%396 = xor <16 x i8> %394, %388
%397 = bitcast i8* %389 to <16 x i8>*
store <16 x i8> %395, <16 x i8>* %397
%398 = bitcast i8* %392 to <16 x i8>*
store <16 x i8> %396, <16 x i8>* %398
br label %399
399: ; preds = %379, %382
%400 = icmp eq i64 %332, %6
br i1 %400, label %432, label %401
401: ; preds = %399
%402 = and i64 %6, 24
%403 = icmp eq i64 %402, 0
br i1 %403, label %421, label %404
404: ; preds = %329, %401
%405 = phi i64 [ %332, %401 ], [ 0, %329 ]
%406 = and i64 %6, 4294967288
br label %407
407: ; preds = %407, %404
%408 = phi i64 [ %405, %404 ], [ %417, %407 ]
%409 = getelementptr inbounds i8, i8* %7, i64 %408
%410 = bitcast i8* %409 to <8 x i8>*
%411 = load <8 x i8>, <8 x i8>* %410
%412 = getelementptr inbounds i8, i8* %0, i64 %408
%413 = bitcast i8* %412 to <8 x i8>*
%414 = load <8 x i8>, <8 x i8>* %413
%415 = xor <8 x i8> %414, %411
%416 = bitcast i8* %412 to <8 x i8>*
store <8 x i8> %415, <8 x i8>* %416
%417 = add nuw i64 %408, 8
%418 = icmp eq i64 %417, %406
br i1 %418, label %419, label %407
419: ; preds = %407
%420 = icmp eq i64 %406, %6
br i1 %420, label %432, label %421
421: ; preds = %327, %401, %419
%422 = phi i64 [ 0, %327 ], [ %332, %401 ], [ %406, %419 ]
br label %423
423: ; preds = %421, %423
%424 = phi i64 [ %430, %423 ], [ %422, %421 ]
%425 = getelementptr inbounds i8, i8* %7, i64 %424
%426 = load i8, i8* %425
%427 = getelementptr inbounds i8, i8* %0, i64 %424
%428 = load i8, i8* %427
%429 = xor i8 %428, %426
store i8 %429, i8* %427
%430 = add nuw nsw i64 %424, 1
%431 = icmp eq i64 %430, %6
br i1 %431, label %432, label %423
432: ; preds = %423, %399, %419, %320
ret void
}