#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*/ garble(unsigned char *, unsigned char *, unsigned char *,
                          unsigned char *, unsigned char *);
int /*<<< orphan*/ printf(char *);
int rol8(int, int);
void sap_hash(unsigned char *blockIn, unsigned char *keyOut) {
  uint32_t *block_words = (uint32_t *)blockIn;
  uint32_t *out_words = (uint32_t *)keyOut;
  unsigned char buffer0[20] = {0x96, 0x5F, 0xC6, 0x53, 0xF8, 0x46, 0xCC,
                               0x18, 0xDF, 0xBE, 0xB2, 0xF8, 0x38, 0xD7,
                               0xEC, 0x22, 0x03, 0xD1, 0x20, 0x8F};
  unsigned char buffer1[210];
  unsigned char buffer2[35] = {
      0x43, 0x54, 0x62, 0x7A, 0x18, 0xC3, 0xD6, 0xB3, 0x9A, 0x56, 0xF6, 0x1C,
      0x14, 0x3F, 0x0C, 0x1D, 0x3B, 0x36, 0x83, 0xB1, 0x39, 0x51, 0x4A, 0xAA,
      0x09, 0x3E, 0xFE, 0x44, 0xAF, 0xDE, 0xC3, 0x20, 0x9D, 0x42, 0x3A};
  unsigned char buffer3[132];
  unsigned char buffer4[21] = {0xED, 0x25, 0xD1, 0xBB, 0xBC, 0x27, 0x9F,
                               0x02, 0xA2, 0xA9, 0x11, 0x00, 0x0C, 0xB3,
                               0x52, 0xC0, 0xBD, 0xE3, 0x1B, 0x49, 0xC7};
  int i0_index[11] = {18, 22, 23, 0, 5, 19, 32, 31, 10, 21, 30};
  uint8_t w, x, y, z;
  int i, j;
  for (i = 0; i < 210; i++) {
    uint32_t in_word = block_words[((i % 64) >> 2)];
    uint32_t in_byte = (in_word >> ((3 - (i % 4)) << 3)) & 0xff;
    buffer1[i] = in_byte;
  }
  for (i = 0; i < 840; i++) {
    x = buffer1[((i - 155) & 0xffffffff) % 210];
    y = buffer1[((i - 57) & 0xffffffff) % 210];
    z = buffer1[((i - 13) & 0xffffffff) % 210];
    w = buffer1[(i & 0xffffffff) % 210];
    buffer1[i % 210] = (rol8(y, 5) + (rol8(z, 3) ^ w) - rol8(x, 7)) & 0xff;
  }
  printf("Garbling...\n");
  garble(buffer0, buffer1, buffer2, buffer3, buffer4);
  for (i = 0; i < 16; i++)
    keyOut[i] = 0xE1;
  for (i = 0; i < 11; i++) {
    if (i == 3)
      keyOut[i] = 0x3d;
    else
      keyOut[i] = ((keyOut[i] + buffer3[i0_index[i] * 4]) & 0xff);
  }
  for (i = 0; i < 20; i++)
    keyOut[i % 16] ^= buffer0[i];
  for (i = 0; i < 35; i++)
    keyOut[i % 16] ^= buffer2[i];
  for (i = 0; i < 210; i++)
    keyOut[(i % 16)] ^= buffer1[i];
  for (j = 0; j < 16; j++) {
    for (i = 0; i < 16; i++) {
      x = keyOut[((i - 7) & 0xffffffff) % 16];
      y = keyOut[i % 16];
      z = keyOut[((i - 37) & 0xffffffff) % 16];
      w = keyOut[((i - 177) & 0xffffffff) % 16];
      keyOut[i] = rol8(x, 1) ^ y ^ rol8(z, 6) ^ rol8(w, 5);
    }
  }
}


x86 assembly (clang, -O0):
<sap_hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x290,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    0xe96(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xe93(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe91(%rip),%eax
mov    %eax,-0x30(%rbp)
lea    -0x150(%rbp),%rdi
lea    0xe90(%rip),%rsi
mov    $0x23,%edx
call   1050 <memcpy@plt>
mov    0xeaf(%rip),%rax
mov    %rax,-0x200(%rbp)
mov    0xea9(%rip),%rax
mov    %rax,-0x1f8(%rbp)
mov    0xea4(%rip),%eax
mov    %eax,-0x1f0(%rbp)
mov    0xe9c(%rip),%al
mov    %al,-0x1ec(%rbp)
lea    -0x230(%rbp),%rdi
lea    0xe94(%rip),%rsi
mov    $0x2c,%edx
call   1050 <memcpy@plt>
movl   $0x0,-0x244(%rbp)
cmpl   $0xd2,-0x244(%rbp)
jge    1290 <sap_hash+0x150>
mov    -0x18(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    -0x260(%rbp),%rax
sar    $0x2,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24c(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,-0x254(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0x254(%rbp),%eax
mov    $0x3,%ecx
sub    %edx,%ecx
shl    $0x3,%ecx
sar    %cl,%eax
and    $0xff,%eax
mov    %eax,-0x250(%rbp)
mov    -0x250(%rbp),%eax
mov    %al,%cl
movslq -0x244(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    11f0 <sap_hash+0xb0>
movl   $0x0,-0x244(%rbp)
cmpl   $0x348,-0x244(%rbp)
jge    13c6 <sap_hash+0x286>
mov    -0x244(%rbp),%eax
sub    $0x9b,%eax
and    $0xffffffff,%eax
mov    $0xd2,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,%eax
movzbl -0x120(%rbp,%rax,1),%eax
ff
mov    %eax,-0x238(%rbp)
mov    -0x244(%rbp),%eax
sub    $0x39,%eax
and    $0xffffffff,%eax
mov    $0xd2,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,%eax
movzbl -0x120(%rbp,%rax,1),%eax
ff
mov    %eax,-0x23c(%rbp)
mov    -0x244(%rbp),%eax
sub    $0xd,%eax
and    $0xffffffff,%eax
mov    $0xd2,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,%eax
movzbl -0x120(%rbp,%rax,1),%eax
ff
mov    %eax,-0x240(%rbp)
mov    -0x244(%rbp),%eax
and    $0xffffffff,%eax
mov    $0xd2,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,%eax
movzbl -0x120(%rbp,%rax,1),%eax
ff
mov    %eax,-0x234(%rbp)
mov    -0x23c(%rbp),%edi
mov    $0x5,%esi
call   1060 <rol8@plt>
mov    %eax,-0x268(%rbp)
mov    -0x240(%rbp),%edi
mov    $0x3,%esi
call   1060 <rol8@plt>
mov    %eax,%ecx
mov    -0x268(%rbp),%eax
xor    -0x234(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x264(%rbp)
mov    -0x238(%rbp),%edi
mov    $0x7,%esi
call   1060 <rol8@plt>
mov    %eax,%ecx
mov    -0x264(%rbp),%eax
sub    %ecx,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x244(%rbp),%eax
mov    $0xd2,%esi
cltd
idiv   %esi
movslq %edx,%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    129a <sap_hash+0x15a>
lea    0xccf(%rip),%rdi
call   1030 <printf@plt>
lea    -0x40(%rbp),%rdi
lea    -0x120(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x1e0(%rbp),%rcx
lea    -0x200(%rbp),%r8
call   1040 <garble@plt>
movl   $0x0,-0x244(%rbp)
cmpl   $0x10,-0x244(%rbp)
jge    1431 <sap_hash+0x2f1>
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
movb   $0xe1,(%rax,%rcx,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1401 <sap_hash+0x2c1>
movl   $0x0,-0x244(%rbp)
cmpl   $0xb,-0x244(%rbp)
jge    14c4 <sap_hash+0x384>
cmpl   $0x3,-0x244(%rbp)
jne    1469 <sap_hash+0x329>
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
movb   $0x3d,(%rax,%rcx,1)
jmp    14ab <sap_hash+0x36b>
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x244(%rbp),%rcx
mov    -0x230(%rbp,%rcx,4),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movzbl -0x1e0(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14b0 <sap_hash+0x370>
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    143b <sap_hash+0x2fb>
movl   $0x0,-0x244(%rbp)
cmpl   $0x14,-0x244(%rbp)
jge    1527 <sap_hash+0x3e7>
movslq -0x244(%rbp),%rax
movzbl -0x40(%rbp,%rax,1),%esi
mov    -0x10(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x270(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    14ce <sap_hash+0x38e>
movl   $0x0,-0x244(%rbp)
cmpl   $0x23,-0x244(%rbp)
jge    158d <sap_hash+0x44d>
movslq -0x244(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%esi
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x278(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1531 <sap_hash+0x3f1>
movl   $0x0,-0x244(%rbp)
cmpl   $0xd2,-0x244(%rbp)
jge    15f6 <sap_hash+0x4b6>
movslq -0x244(%rbp),%rax
movzbl -0x120(%rbp,%rax,1),%esi
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x280(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1597 <sap_hash+0x457>
movl   $0x0,-0x248(%rbp)
cmpl   $0x10,-0x248(%rbp)
jge    1744 <sap_hash+0x604>
movl   $0x0,-0x244(%rbp)
cmpl   $0x10,-0x244(%rbp)
jge    172b <sap_hash+0x5eb>
mov    -0x10(%rbp),%rax
mov    -0x244(%rbp),%ecx
sub    $0x7,%ecx
and    $0xffffffff,%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x238(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x244(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x290(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x23c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x244(%rbp),%ecx
sub    $0x25,%ecx
and    $0xffffffff,%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x240(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x244(%rbp),%ecx
sub    $0xb1,%ecx
and    $0xffffffff,%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x234(%rbp)
mov    -0x238(%rbp),%edi
mov    $0x1,%esi
call   1060 <rol8@plt>
xor    -0x23c(%rbp),%eax
mov    %eax,-0x288(%rbp)
mov    -0x240(%rbp),%edi
mov    $0x6,%esi
call   1060 <rol8@plt>
mov    %eax,%ecx
mov    -0x288(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x284(%rbp)
mov    -0x234(%rbp),%edi
mov    $0x5,%esi
call   1060 <rol8@plt>
mov    %eax,%ecx
mov    -0x284(%rbp),%eax
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1617 <sap_hash+0x4d7>
jmp    1730 <sap_hash+0x5f0>
mov    -0x248(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x248(%rbp)
jmp    1600 <sap_hash+0x4c0>
add    $0x290,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sap_hash>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
mov    %rsi,%r13
movaps 0xec5(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movl   $0x8f20d103,0x20(%rsp)
8f
movaps 0xee1(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xec5(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movl   $0x3a429d20,0x5f(%rsp)
3a
movaps 0xee1(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movabs $0xc7491be3bdc052b3,%rax
1b 49 c7
mov    %rax,0x7d(%rsp)
xor    %edx,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    %esi,%ebp
and    $0x3c,%ebp
mov    (%rdi,%rbp,1),%ebx
mov    %edx,%eax
and    $0x10,%al
mov    %eax,%ecx
xor    $0x18,%cl
sar    %cl,%ebx
mov    %bl,0x120(%rsp,%rsi,1)
mov    (%rdi,%rbp,1),%ebp
xor    $0x10,%al
mov    %eax,%ecx
sar    %cl,%ebp
mov    %bpl,0x121(%rsp,%rsi,1)
add    $0x2,%rsi
add    $0x10,%edx
cmp    $0xd2,%rsi
jne    11a0 <sap_hash+0x70>
mov    $0x348,%eax
mov    $0xffffff65,%ecx
mov    $0xffffffc7,%ebx
mov    $0xfffffff3,%r14d
lea    0x120(%rsp),%r15
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %rdx,0x38(%rsp)
mov    %ecx,(%rsp)
mov    %eax,0xc(%rsp)
mov    %ecx,%eax
shr    %eax
mov    $0x9c09c09d,%edi
imul   %rdi,%rax
shr    $0x26,%rax
imul   $0xd2,%eax,%eax
mov    (%rsp),%ecx
sub    %eax,%ecx
mov    %ebx,%eax
shr    %eax
imul   %rdi,%rax
shr    $0x26,%rax
imul   $0xd2,%eax,%eax
mov    %ebx,%esi
sub    %eax,%esi
mov    %r14d,%eax
shr    %eax
imul   %rdi,%rax
shr    $0x26,%rax
imul   $0xd2,%eax,%eax
mov    %r14d,%ebp
sub    %eax,%ebp
mov    %rdx,%rax
movabs $0x4e04e04e04e04e05,%rdx
e0 04 4e
mul    %rdx
shr    $0x6,%rdx
imul   $0xffffffffffffff2e,%rdx,%rax
mov    %rax,0x30(%rsp)
movzbl 0x120(%rsp,%rcx,1),%ecx
mov    %ecx,0x8(%rsp)
movzbl 0x120(%rsp,%rsi,1),%edi
movzbl 0x120(%rsp,%rbp,1),%ebp
movzbl (%r15,%rax,1),%eax
mov    %eax,0x4(%rsp)
mov    $0x5,%esi
call   1050 <rol8@plt>
mov    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1050 <rol8@plt>
mov    %eax,%ebp
xor    0x4(%rsp),%ebp
add    %r12d,%ebp
mov    0x8(%rsp),%edi
mov    $0x7,%esi
call   1050 <rol8@plt>
mov    0x38(%rsp),%rdx
mov    (%rsp),%ecx
sub    %eax,%ebp
mov    0xc(%rsp),%eax
mov    0x30(%rsp),%rsi
mov    %bpl,(%r15,%rsi,1)
add    $0x1,%ecx
add    $0x1,%ebx
add    $0x1,%r14d
add    $0x1,%r15
add    $0x1,%rdx
add    $0xffffffff,%eax
jne    1200 <sap_hash+0xd0>
lea    0xd71(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
lea    0x120(%rsp),%rsi
lea    0x40(%rsp),%rdx
lea    0x90(%rsp),%rcx
lea    0x70(%rsp),%r8
call   1040 <garble@plt>
movaps 0xccc(%rip),%xmm0
movups %xmm0,0x0(%r13)
mov    0xd8(%rsp),%al
mov    0xe8(%rsp),%cl
add    $0xe1,%cl
mov    %cl,0x1(%r13)
mov    0xec(%rsp),%cl
add    $0xe1,%cl
mov    %cl,0x2(%r13)
movb   $0x3d,0x3(%r13)
mov    0xa4(%rsp),%cl
add    %cl,0x4(%r13)
mov    0xdc(%rsp),%cl
add    %cl,0x5(%r13)
mov    0x110(%rsp),%cl
add    %cl,0x6(%r13)
mov    0x10c(%rsp),%cl
add    %cl,0x7(%r13)
mov    0xb8(%rsp),%cl
add    %cl,0x8(%r13)
mov    0xe4(%rsp),%cl
add    %cl,0x9(%r13)
mov    0x108(%rsp),%cl
add    %cl,0xa(%r13)
add    $0xe1,%al
movzwl 0x2(%r13),%ecx
movd   %ecx,%xmm0
movd   0x4(%r13),%xmm1
movzbl %al,%eax
movzbl 0x1(%r13),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm2
punpcklwd %xmm0,%xmm2
pxor   0x10(%rsp),%xmm2
movsd  0x8(%r13),%xmm0
punpcklqdq %xmm1,%xmm2
shufps $0x48,%xmm0,%xmm2
movdqu 0x14(%rsp),%xmm0
pshufd $0x93,%xmm0,%xmm0
pxor   %xmm2,%xmm0
movdqu %xmm0,0x0(%r13)
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rax),%ecx
movzbl 0x3f(%rsp,%rax,1),%edx
and    $0xe,%ecx
xor    %dl,0x0(%r13,%rcx,1)
cmp    $0x23,%rax
je     143b <sap_hash+0x30b>
movzbl 0x40(%rsp,%rax,1),%ecx
mov    %eax,%edx
and    $0xf,%edx
xor    %cl,0x0(%r13,%rdx,1)
add    $0x2,%rax
jmp    1410 <sap_hash+0x2e0>
mov    $0x2,%eax
lea    -0x2(%rax),%ecx
movzbl 0x11e(%rsp,%rax,1),%edx
and    $0xf,%ecx
xor    %dl,0x0(%r13,%rcx,1)
lea    -0x1(%rax),%ecx
movzbl 0x11f(%rsp,%rax,1),%edx
and    $0xf,%ecx
xor    %dl,0x0(%r13,%rcx,1)
movzbl 0x120(%rsp,%rax,1),%ecx
mov    %eax,%edx
and    $0xf,%edx
xor    %cl,0x0(%r13,%rdx,1)
add    $0x3,%rax
cmp    $0xd4,%rax
jne    1440 <sap_hash+0x310>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    %eax,(%rsp)
mov    $0xf,%ebp
nopl   0x0(%rax,%rax,1)
lea    -0x6(%rbp),%eax
and    $0xf,%eax
movzbl 0x0(%r13,%rax,1),%edi
movzbl -0xf(%r13,%rbp,1),%r15d
lea    -0x4(%rbp),%eax
and    $0xf,%eax
movzbl 0x0(%r13,%rax,1),%r12d
mov    %ebp,%eax
and    $0xf,%eax
movzbl 0x0(%r13,%rax,1),%r14d
mov    $0x1,%esi
call   1050 <rol8@plt>
mov    %eax,%ebx
xor    %r15d,%ebx
mov    %r12d,%edi
mov    $0x6,%esi
call   1050 <rol8@plt>
mov    %eax,%r12d
mov    %r14d,%edi
mov    $0x5,%esi
call   1050 <rol8@plt>
xor    %r12d,%eax
xor    %ebx,%eax
mov    %al,-0xf(%r13,%rbp,1)
add    $0x1,%rbp
cmp    $0x1f,%rbp
jne    14a0 <sap_hash+0x370>
mov    (%rsp),%eax
add    $0x1,%eax
cmp    $0x10,%eax
jne    1490 <sap_hash+0x360>
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.sap_hash.buffer0 = [20 x i8] c"\96_\C6S\F8F\CC\18\DF\BE\B2\F88\D7\EC\22\03\D1 \8F"
@__const.sap_hash.buffer2 = [35 x i8] c"CTbz\18\C3\D6\B3\9AV\F6\1C\14?\0C\1D;6\83\B19QJ\AA\09>\FED\AF\DE\C3 \9DB:"
@__const.sap_hash.buffer4 = [21 x i8] c"\ED%\D1\BB\BC'\9F\02\A2\A9\11\00\0C\B3R\C0\BD\E3\1BI\C7"
@str = [12 x i8] c"Garbling...\00"
define void @sap_hash(i8* nocapture %0, i8* nocapture %1) {
%3 = alloca [20 x i8]
%4 = alloca [210 x i8]
%5 = alloca [35 x i8]
%6 = alloca [132 x i8]
%7 = alloca [21 x i8]
%8 = bitcast i8* %0 to i32*
%9 = getelementptr inbounds [20 x i8], [20 x i8]* %3, i64 0, i64 0
%10 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 0
%11 = getelementptr inbounds [35 x i8], [35 x i8]* %5, i64 0, i64 0
%12 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 0
%13 = getelementptr inbounds [21 x i8], [21 x i8]* %7, i64 0, i64 0
br label %14
14: ; preds = %14, %2
%15 = phi i64 [ 0, %2 ], [ %39, %14 ]
%16 = lshr i64 %15, 2
%17 = and i64 %16, 15
%18 = getelementptr inbounds i32, i32* %8, i64 %17
%19 = load i32, i32* %18
%20 = trunc i64 %15 to i32
%21 = shl i32 %20, 3
%22 = and i32 %21, 16
%23 = xor i32 %22, 24
%24 = ashr i32 %19, %23
%25 = trunc i32 %24 to i8
%26 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %15
store i8 %25, i8* %26
%27 = or i64 %15, 1
%28 = lshr i64 %15, 2
%29 = and i64 %28, 15
%30 = getelementptr inbounds i32, i32* %8, i64 %29
%31 = load i32, i32* %30
%32 = trunc i64 %15 to i32
%33 = shl i32 %32, 3
%34 = and i32 %33, 16
%35 = xor i32 %34, 16
%36 = ashr i32 %31, %35
%37 = trunc i32 %36 to i8
%38 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %27
store i8 %37, i8* %38
%39 = add nuw nsw i64 %15, 2
%40 = icmp eq i64 %39, 210
br i1 %40, label %41, label %14
41: ; preds = %14, %41
%42 = phi i32 [ %74, %41 ], [ 0, %14 ]
%43 = add nsw i32 %42, -155
%44 = urem i32 %43, 210
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %45
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = add nsw i32 %42, -57
%50 = urem i32 %49, 210
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %51
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = add nsw i32 %42, -13
%56 = urem i32 %55, 210
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %57
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = trunc i32 %42 to i16
%62 = urem i16 %61, 210
%63 = zext i16 %62 to i64
%64 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
%67 = tail call i32 @rol8(i32 %54, i32 5)
%68 = tail call i32 @rol8(i32 %60, i32 3)
%69 = xor i32 %68, %66
%70 = add nsw i32 %69, %67
%71 = tail call i32 @rol8(i32 %48, i32 7)
%72 = sub i32 %70, %71
%73 = trunc i32 %72 to i8
store i8 %73, i8* %64
%74 = add nuw nsw i32 %42, 1
%75 = icmp eq i32 %74, 840
br i1 %75, label %76, label %41
76: ; preds = %41
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str, i64 0, i64 0))
%78 = call i32 @garble(i8* %9, i8* %10, i8* %11, i8* %12, i8* %13)
%79 = getelementptr inbounds i8, i8* %1, i64 3
%80 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 72
%81 = load i8, i8* %80
%82 = getelementptr inbounds i8, i8* %1, i64 1
%83 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 88
%84 = load i8, i8* %83
%85 = add i8 %84, -31
store i8 %85, i8* %82
%86 = getelementptr inbounds i8, i8* %1, i64 2
%87 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 92
%88 = load i8, i8* %87
%89 = add i8 %88, -31
store i8 %89, i8* %86
store i8 61, i8* %79
%90 = add i8 %81, -31
%91 = getelementptr inbounds i8, i8* %1, i64 4
%92 = load i8, i8* %91
%93 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 20
%94 = load i8, i8* %93
%95 = add i8 %94, %92
store i8 %95, i8* %91
%96 = getelementptr inbounds i8, i8* %1, i64 5
%97 = load i8, i8* %96
%98 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 76
%99 = load i8, i8* %98
%100 = add i8 %99, %97
store i8 %100, i8* %96
%101 = getelementptr inbounds i8, i8* %1, i64 6
%102 = load i8, i8* %101
%103 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 128
%104 = load i8, i8* %103
%105 = add i8 %104, %102
store i8 %105, i8* %101
%106 = getelementptr inbounds i8, i8* %1, i64 7
%107 = load i8, i8* %106
%108 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 124
%109 = load i8, i8* %108
%110 = add i8 %109, %107
store i8 %110, i8* %106
%111 = getelementptr inbounds i8, i8* %1, i64 8
%112 = load i8, i8* %111
%113 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 40
%114 = load i8, i8* %113
%115 = add i8 %114, %112
store i8 %115, i8* %111
%116 = getelementptr inbounds i8, i8* %1, i64 9
%117 = load i8, i8* %116
%118 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 84
%119 = load i8, i8* %118
%120 = add i8 %119, %117
store i8 %120, i8* %116
%121 = getelementptr inbounds i8, i8* %1, i64 10
%122 = load i8, i8* %121
%123 = getelementptr inbounds [132 x i8], [132 x i8]* %6, i64 0, i64 120
%124 = load i8, i8* %123
%125 = add i8 %124, %122
store i8 %125, i8* %121
%126 = getelementptr inbounds i8, i8* %1, i64 1
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %1, i64 2
%129 = bitcast i8* %128 to <2 x i8>*
%130 = load <2 x i8>, <2 x i8>* %129
%131 = getelementptr inbounds i8, i8* %1, i64 4
%132 = bitcast i8* %131 to <4 x i8>*
%133 = load <4 x i8>, <4 x i8>* %132
%134 = getelementptr inbounds i8, i8* %1, i64 8
%135 = bitcast i8* %134 to <8 x i8>*
%136 = load <8 x i8>, <8 x i8>* %135
%137 = bitcast [20 x i8]* %3 to <4 x i8>*
%138 = load <4 x i8>, <4 x i8>* %137
%139 = insertelement <4 x i8> poison, i8 %90, i64 0
%140 = insertelement <4 x i8> %139, i8 %127, i64 1
%141 = shufflevector <2 x i8> %130, <2 x i8> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%142 = shufflevector <4 x i8> %140, <4 x i8> %141, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%143 = xor <4 x i8> %142, %138
%144 = getelementptr inbounds [20 x i8], [20 x i8]* %3, i64 0, i64 4
%145 = bitcast i8* %144 to <16 x i8>*
%146 = load <16 x i8>, <16 x i8>* %145
%147 = shufflevector <4 x i8> %133, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%148 = shufflevector <8 x i8> %136, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%149 = shufflevector <16 x i8> %147, <16 x i8> %148, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 undef, i32 undef, i32 undef, i32 undef>
%150 = shufflevector <4 x i8> %143, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%151 = shufflevector <16 x i8> %149, <16 x i8> %150, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 16, i32 17, i32 18, i32 19>
%152 = xor <16 x i8> %151, %146
%153 = shufflevector <16 x i8> %152, <16 x i8> poison, <16 x i32> <i32 12, i32 13, i32 14, i32 15, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11>
%154 = bitcast i8* %1 to <16 x i8>*
store <16 x i8> %153, <16 x i8>* %154
br label %155
155: ; preds = %165, %76
%156 = phi i64 [ 0, %76 ], [ %172, %165 ]
%157 = getelementptr inbounds [35 x i8], [35 x i8]* %5, i64 0, i64 %156
%158 = load i8, i8* %157
%159 = and i64 %156, 14
%160 = getelementptr inbounds i8, i8* %1, i64 %159
%161 = load i8, i8* %160
%162 = xor i8 %161, %158
store i8 %162, i8* %160
%163 = or i64 %156, 1
%164 = icmp eq i64 %163, 35
br i1 %164, label %173, label %165
165: ; preds = %155
%166 = getelementptr inbounds [35 x i8], [35 x i8]* %5, i64 0, i64 %163
%167 = load i8, i8* %166
%168 = and i64 %163, 15
%169 = getelementptr inbounds i8, i8* %1, i64 %168
%170 = load i8, i8* %169
%171 = xor i8 %170, %167
store i8 %171, i8* %169
%172 = add nuw nsw i64 %156, 2
br label %155
173: ; preds = %155, %173
%174 = phi i64 [ %195, %173 ], [ 0, %155 ]
%175 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %174
%176 = load i8, i8* %175
%177 = and i64 %174, 15
%178 = getelementptr inbounds i8, i8* %1, i64 %177
%179 = load i8, i8* %178
%180 = xor i8 %179, %176
store i8 %180, i8* %178
%181 = add nuw nsw i64 %174, 1
%182 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %181
%183 = load i8, i8* %182
%184 = and i64 %181, 15
%185 = getelementptr inbounds i8, i8* %1, i64 %184
%186 = load i8, i8* %185
%187 = xor i8 %186, %183
store i8 %187, i8* %185
%188 = add nuw nsw i64 %174, 2
%189 = getelementptr inbounds [210 x i8], [210 x i8]* %4, i64 0, i64 %188
%190 = load i8, i8* %189
%191 = and i64 %188, 15
%192 = getelementptr inbounds i8, i8* %1, i64 %191
%193 = load i8, i8* %192
%194 = xor i8 %193, %190
store i8 %194, i8* %192
%195 = add nuw nsw i64 %174, 3
%196 = icmp eq i64 %195, 210
br i1 %196, label %197, label %173
197: ; preds = %173, %228
%198 = phi i32 [ %229, %228 ], [ 0, %173 ]
br label %199
199: ; preds = %197, %199
%200 = phi i64 [ 0, %197 ], [ %226, %199 ]
%201 = add nuw i64 %200, 9
%202 = and i64 %201, 15
%203 = getelementptr inbounds i8, i8* %1, i64 %202
%204 = load i8, i8* %203
%205 = zext i8 %204 to i32
%206 = getelementptr inbounds i8, i8* %1, i64 %200
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = add nuw i64 %200, 11
%210 = and i64 %209, 15
%211 = getelementptr inbounds i8, i8* %1, i64 %210
%212 = load i8, i8* %211
%213 = zext i8 %212 to i32
%214 = add nuw i64 %200, 15
%215 = and i64 %214, 15
%216 = getelementptr inbounds i8, i8* %1, i64 %215
%217 = load i8, i8* %216
%218 = zext i8 %217 to i32
%219 = call i32 @rol8(i32 %205, i32 1)
%220 = xor i32 %219, %208
%221 = call i32 @rol8(i32 %213, i32 6)
%222 = xor i32 %220, %221
%223 = call i32 @rol8(i32 %218, i32 5)
%224 = xor i32 %222, %223
%225 = trunc i32 %224 to i8
store i8 %225, i8* %206
%226 = add nuw nsw i64 %200, 1
%227 = icmp eq i64 %226, 16
br i1 %227, label %228, label %199
228: ; preds = %199
%229 = add nuw nsw i32 %198, 1
%230 = icmp eq i32 %229, 16
br i1 %230, label %231, label %197
231: ; preds = %228
ret void
}