#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*/ salt;
typedef int /*<<< orphan*/ pwd;

/* Variables and functions */
int /*<<< orphan*/ PHS(unsigned char *, int, unsigned char *, int,
                       unsigned char *, int, unsigned int, unsigned int);
unsigned char *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int testVectors(unsigned int t, unsigned int m_cost) {
  int kLen = 64;
  unsigned char *pwd;
  int pwdLen = 11;
  unsigned char *salt;
  int saltLen = 16;
  srand(time(NULL));
  int i;
  int countSample;
  int indexSalt = 0;
  unsigned char *K = malloc(kLen);
  for (countSample = 0; countSample <= 128; countSample++) {
    pwdLen = countSample;
    int count;
    pwd = malloc(sizeof(pwd) * pwdLen);
    for (count = 0; count < pwdLen; count++) {
      pwd[count] = count;
    }
    salt = malloc(sizeof(salt) * saltLen);
    for (count = 0; count < saltLen; count++) {
      salt[count] = saltLen * indexSalt + count;
    }
    indexSalt++;
    if (indexSalt == saltLen)
      indexSalt = 0;
    PHS(K, kLen, pwd, pwdLen, salt, saltLen, t, m_cost);
    printf("\ninlen: %d\n", pwdLen);
    printf("t_cost: %d\n", t);
    printf("m_cost: %d\n", m_cost);
    printf("outlen: %d\n", kLen);
    printf("In: ");
    for (i = 0; i < pwdLen; i++) {
      printf("%02x ", pwd[i]);
    }
    printf("\n");
    printf("Salt: ");
    for (i = 0; i < saltLen; i++) {
      printf("%02x ", salt[i]);
    }
    printf("\n");
    printf("Out: ");
    for (i = 0; i < kLen; i++) {
      printf("%02x ", K[i]);
    }
    printf("\n");
  }
  for (countSample = 128; countSample <= 256; countSample++) {
    pwdLen = countSample - 127;
    int count;
    pwd = malloc(sizeof(pwd) * pwdLen);
    for (count = 0; count < pwdLen; count++) {
      pwd[count] = count + 128;
    }
    salt = malloc(sizeof(salt) * saltLen);
    for (count = 0; count < saltLen; count++) {
      salt[count] = saltLen * indexSalt + count;
    }
    indexSalt++;
    if (indexSalt == saltLen)
      indexSalt = 0;
    PHS(K, kLen, pwd, pwdLen, salt, saltLen, t, m_cost);
    printf("\ninlen: %d\n", pwdLen);
    printf("t_cost: %d\n", t);
    printf("m_cost: %d\n", m_cost);
    printf("outlen: %d\n", kLen);
    printf("In: ");
    for (i = 0; i < pwdLen; i++) {
      printf("%02x ", pwd[i]);
    }
    printf("\n");
    printf("Salt: ");
    for (i = 0; i < saltLen; i++) {
      printf("%02x ", salt[i]);
    }
    printf("\n");
    printf("Out: ");
    for (i = 0; i < kLen; i++) {
      printf("%02x ", K[i]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<testVectors>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movl   $0x40,-0xc(%rbp)
movl   $0xb,-0x1c(%rbp)
movl   $0x10,-0x2c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1060 <time@plt>
mov    %eax,%edi
call   1040 <srand@plt>
movl   $0x0,-0x38(%rbp)
mov    -0xc(%rbp),%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x80,-0x34(%rbp)
jg     13dc <testVectors+0x28c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f4 <testVectors+0xa4>
mov    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11ca <testVectors+0x7a>
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    123f <testVectors+0xef>
mov    -0x2c(%rbp),%eax
imul   -0x38(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    120e <testVectors+0xbe>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    125b <testVectors+0x10b>
movl   $0x0,-0x38(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%r8
mov    -0x2c(%rbp),%r9d
mov    -0x4(%rbp),%r10d
mov    -0x8(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1050 <PHS@plt>
mov    -0x1c(%rbp),%esi
lea    0xd71(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%esi
lea    0xd6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xd67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
lea    0xd62(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd60(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1312 <testVectors+0x1c2>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xd38(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12de <testVectors+0x18e>
lea    0xcf1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd14(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1369 <testVectors+0x219>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xce1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1335 <testVectors+0x1e5>
lea    0xc9a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xcc4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c0 <testVectors+0x270>
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xc8a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    138c <testVectors+0x23c>
lea    0xc43(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119d <testVectors+0x4d>
movl   $0x80,-0x34(%rbp)
cmpl   $0x100,-0x34(%rbp)
jg     162a <testVectors+0x4da>
mov    -0x34(%rbp),%eax
sub    $0x7f,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1442 <testVectors+0x2f2>
mov    -0x48(%rbp),%eax
add    $0x80,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1413 <testVectors+0x2c3>
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    148d <testVectors+0x33d>
mov    -0x2c(%rbp),%eax
imul   -0x38(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    145c <testVectors+0x30c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    14a9 <testVectors+0x359>
movl   $0x0,-0x38(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%r8
mov    -0x2c(%rbp),%r9d
mov    -0x4(%rbp),%r10d
mov    -0x8(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1050 <PHS@plt>
mov    -0x1c(%rbp),%esi
lea    0xb23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%esi
lea    0xb1e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xb19(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
lea    0xb14(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1560 <testVectors+0x410>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xaea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    152c <testVectors+0x3dc>
lea    0xaa3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xac6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15b7 <testVectors+0x467>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xa93(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1583 <testVectors+0x433>
lea    0xa4c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa76(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    160e <testVectors+0x4be>
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xa3c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15da <testVectors+0x48a>
lea    0x9f5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13e3 <testVectors+0x293>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testVectors>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,0x8(%rsp)
mov    %rdi,0x18(%rsp)
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
mov    $0x40,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
lea    0xf9b(%rip),%r12
xor    %ebp,%ebp
movl   $0x0,0x4(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x0(,%rbp,8),%edi
call   1080 <malloc@plt>
mov    %rax,%r13
test   %rbp,%rbp
je     137e <testVectors+0x21e>
cmp    $0x20,%rbp
jae    11e0 <testVectors+0x80>
xor    %eax,%eax
jmp    1370 <testVectors+0x210>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
mov    %rbp,%rax
movabs $0x7fffffffffffffe0,%rdx
ff ff 7f
and    %rdx,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
cmp    $0x60,%rdx
jae    1233 <testVectors+0xd3>
xor    %edx,%edx
movdqa 0xde2(%rip),%xmm0
movdqa 0xdfa(%rip),%xmm3
movdqa 0xde2(%rip),%xmm5
jmp    1315 <testVectors+0x1b5>
lea    0x1(%rcx),%rdi
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
movdqa 0xdbb(%rip),%xmm0
movdqa 0xdd3(%rip),%xmm3
movdqa 0xe2a(%rip),%xmm8
movdqa 0xdb2(%rip),%xmm5
movdqa 0xdc9(%rip),%xmm9
movdqa 0xdd0(%rip),%xmm10
movdqa 0xdd8(%rip),%xmm4
movdqa 0xde0(%rip),%xmm6
movdqa 0xde8(%rip),%xmm7
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm5,%xmm1
movdqu %xmm0,0x0(%r13,%rdx,1)
movdqu %xmm1,0x10(%r13,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqu %xmm1,0x20(%r13,%rdx,1)
movdqu %xmm2,0x30(%r13,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm10,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm4,%xmm2
movdqu %xmm1,0x40(%r13,%rdx,1)
movdqu %xmm2,0x50(%r13,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm7,%xmm2
movdqu %xmm1,0x60(%r13,%rdx,1)
movdqu %xmm2,0x70(%r13,%rdx,1)
sub    $0xffffffffffffff80,%rdx
pxor   %xmm8,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1290 <testVectors+0x130>
test   $0x3,%sil
je     1379 <testVectors+0x219>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x5,%rcx
add    %r13,%rdx
add    $0x10,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm5,%xmm1
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm1,(%rdx,%rsi,1)
paddb  %xmm3,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1340 <testVectors+0x1e0>
jmp    1379 <testVectors+0x219>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %al,0x0(%r13,%rax,1)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1370 <testVectors+0x210>
mov    $0x80,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    0x4(%rsp),%edx
mov    %edx,%eax
shl    $0x4,%eax
mov    %al,(%r14)
lea    0x1(%rax),%ecx
mov    %cl,0x1(%r14)
lea    0x2(%rax),%ecx
mov    %cl,0x2(%r14)
lea    0x3(%rax),%ecx
mov    %cl,0x3(%r14)
lea    0x4(%rax),%ecx
mov    %cl,0x4(%r14)
lea    0x5(%rax),%ecx
mov    %cl,0x5(%r14)
lea    0x6(%rax),%ecx
mov    %cl,0x6(%r14)
lea    0x7(%rax),%ecx
mov    %cl,0x7(%r14)
lea    0x8(%rax),%ecx
mov    %cl,0x8(%r14)
lea    0x9(%rax),%ecx
mov    %cl,0x9(%r14)
lea    0xa(%rax),%ecx
mov    %cl,0xa(%r14)
lea    0xb(%rax),%ecx
mov    %cl,0xb(%r14)
lea    0xc(%rax),%ecx
mov    %cl,0xc(%r14)
lea    0xd(%rax),%ecx
mov    %cl,0xd(%r14)
lea    0xe(%rax),%ecx
mov    %cl,0xe(%r14)
or     $0xf,%al
mov    %al,0xf(%r14)
add    $0x1,%edx
cmp    $0x10,%edx
mov    $0x0,%eax
cmove  %eax,%edx
mov    %edx,0x4(%rsp)
mov    %r15,%rdi
mov    $0x40,%esi
mov    %r13,%rdx
mov    %ebp,%ecx
mov    %r14,%r8
mov    $0x10,%r9d
push   0x8(%rsp)
mov    0x20(%rsp),%rbx
push   %rbx
call   1060 <PHS@plt>
add    $0x10,%rsp
lea    0xcbf(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcbb(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcb7(%rip),%rdi
mov    0x8(%rsp),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcb0(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xca9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %rbp,%rbp
je     14b9 <testVectors+0x359>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%r13,%rbx,1),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    14a0 <testVectors+0x340>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc71(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl (%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xe(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xf(%r14),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb71(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl (%r15,%rbx,1),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    15e0 <testVectors+0x480>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    $0x81,%rbp
jne    11b0 <testVectors+0x50>
mov    $0x80,%ebx
mov    $0x1,%r14d
lea    0xb0f(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
lea    -0x7f(%rbx),%r13d
lea    -0x3f8(,%rbx,8),%edi
call   1080 <malloc@plt>
mov    %rax,%r12
cmp    $0x20,%r14
mov    %rbx,0x20(%rsp)
jae    1660 <testVectors+0x500>
xor    %eax,%eax
jmp    1800 <testVectors+0x6a0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
mov    %r14,%rax
movabs $0x7fffffffffffffe0,%rdx
ff ff 7f
and    %rdx,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
cmp    $0x60,%rdx
movdqa 0x9e6(%rip),%xmm5
jae    16c0 <testVectors+0x560>
xor    %edx,%edx
movdqa 0x95a(%rip),%xmm0
movdqa 0x972(%rip),%xmm4
movdqa 0x9da(%rip),%xmm6
jmp    17a6 <testVectors+0x646>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%rdi
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
movdqa 0x92e(%rip),%xmm1
movdqa %xmm1,%xmm0
movdqa 0x942(%rip),%xmm4
movdqa 0x9aa(%rip),%xmm6
movdqa 0x9b1(%rip),%xmm8
movdqa 0x9b8(%rip),%xmm9
movdqa 0x9bf(%rip),%xmm10
movdqa 0x9c6(%rip),%xmm11
movdqa 0x9cd(%rip),%xmm12
movdqa 0x9d5(%rip),%xmm7
nopl   0x0(%rax,%rax,1)
pxor   %xmm5,%xmm0
movdqa %xmm1,%xmm2
paddb  %xmm6,%xmm2
movdqu %xmm0,(%r12,%rdx,1)
movdqu %xmm2,0x10(%r12,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm8,%xmm2
movdqa %xmm1,%xmm3
paddb  %xmm9,%xmm3
movdqu %xmm2,0x20(%r12,%rdx,1)
movdqu %xmm3,0x30(%r12,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm10,%xmm2
movdqa %xmm1,%xmm3
paddb  %xmm11,%xmm3
movdqu %xmm2,0x40(%r12,%rdx,1)
movdqu %xmm3,0x50(%r12,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm12,%xmm2
paddb  %xmm7,%xmm1
movdqu %xmm2,0x60(%r12,%rdx,1)
movdqu %xmm1,0x70(%r12,%rdx,1)
sub    $0xffffffffffffff80,%rdx
movdqa %xmm0,%xmm1
add    $0xfffffffffffffffc,%rdi
jne    1720 <testVectors+0x5c0>
test   $0x3,%sil
je     180b <testVectors+0x6ab>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x5,%rcx
add    %r12,%rdx
add    $0x10,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
pxor   %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm6,%xmm2
movdqu %xmm1,-0x10(%rdx,%rsi,1)
movdqu %xmm2,(%rdx,%rsi,1)
paddb  %xmm4,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    17d0 <testVectors+0x670>
jmp    180b <testVectors+0x6ab>
nopw   0x0(%rax,%rax,1)
lea    -0x80(%rax),%ecx
mov    %cl,(%r12,%rax,1)
add    $0x1,%rax
cmp    %rax,%r14
jne    1800 <testVectors+0x6a0>
mov    $0x80,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    0x4(%rsp),%edx
mov    %edx,%eax
shl    $0x4,%eax
mov    %al,(%rbx)
lea    0x1(%rax),%ecx
mov    %cl,0x1(%rbx)
lea    0x2(%rax),%ecx
mov    %cl,0x2(%rbx)
lea    0x3(%rax),%ecx
mov    %cl,0x3(%rbx)
lea    0x4(%rax),%ecx
mov    %cl,0x4(%rbx)
lea    0x5(%rax),%ecx
mov    %cl,0x5(%rbx)
lea    0x6(%rax),%ecx
mov    %cl,0x6(%rbx)
lea    0x7(%rax),%ecx
mov    %cl,0x7(%rbx)
lea    0x8(%rax),%ecx
mov    %cl,0x8(%rbx)
lea    0x9(%rax),%ecx
mov    %cl,0x9(%rbx)
lea    0xa(%rax),%ecx
mov    %cl,0xa(%rbx)
lea    0xb(%rax),%ecx
mov    %cl,0xb(%rbx)
lea    0xc(%rax),%ecx
mov    %cl,0xc(%rbx)
lea    0xd(%rax),%ecx
mov    %cl,0xd(%rbx)
lea    0xe(%rax),%ecx
mov    %cl,0xe(%rbx)
or     $0xf,%al
mov    %al,0xf(%rbx)
add    $0x1,%edx
cmp    $0x10,%edx
mov    $0x0,%eax
cmove  %eax,%edx
mov    %edx,0x4(%rsp)
mov    %r15,%rdi
mov    $0x40,%esi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    %rbx,%r8
mov    $0x10,%r9d
push   0x8(%rsp)
mov    %r13d,0x1c(%rsp)
mov    0x20(%rsp),%r13
push   %r13
call   1060 <PHS@plt>
add    $0x10,%rsp
lea    0x836(%rip),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x830(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x82b(%rip),%rdi
mov    0x8(%rsp),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x824(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x81d(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %r13d,%r13d
nopl   (%rax)
movzbl (%r12,%r13,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r13
cmp    %r13,%r14
jne    1920 <testVectors+0x7c0>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x7f2(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl (%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xe(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xf(%rbx),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x702(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebx,%ebx
nopl   0x0(%rax)
movzbl (%r15,%rbx,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1a50 <testVectors+0x8f0>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rsp),%rbx
add    $0x1,%ebx
add    $0x1,%r14
cmp    $0x82,%r14
jne    1630 <testVectors+0x4d0>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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