#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("outlen: %d\n", kLen);
    printf("t_costs: %d\n", t);
    printf("m_costs: \tR: %d \tC: %d\n", m_cost, 256);
    printf("parallelism: %u\n", 2);
    char *spongeName = "";
    if (0 == 0) {
      spongeName = "Blake2";
    } else if (0 == 1) {
      spongeName = "BlaMka";
    } else {
      spongeName = "half-round BlaMka";
    }
    printf("sponge: %s\n", spongeName);
    printf("sponge blocks (bitrate): %u = %u bits\n", 12, 12 * 64);
    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("outlen: %d\n", kLen);
    printf("t_costs: %d\n", t);
    printf("m_costs: \tR: %d \tC: %d\n", m_cost, 256);
    printf("parallelism: %u\n", 2);
    char *spongeName = "";
    if (0 == 0) {
      spongeName = "Blake2";
    } else if (0 == 1) {
      spongeName = "BlaMka";
    } else {
      spongeName = "half-round BlaMka";
    }
    printf("sponge: %s\n", spongeName);
    printf("sponge blocks (bitrate): %u = %u bits\n", 12, 12 * 64);
    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    $0x70,%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     1434 <testVectors+0x2e4>
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    -0xc(%rbp),%esi
lea    0xd6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%esi
lea    0xd67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xd63(%rip),%rdi
mov    $0x100,%edx
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd68(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd54(%rip),%rax
mov    %rax,-0x50(%rbp)
lea    0xd5b(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rsi
lea    0xd53(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd51(%rip),%rdi
mov    $0xc,%esi
mov    $0x300,%edx
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    136a <testVectors+0x21a>
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    1336 <testVectors+0x1e6>
lea    0xcca(%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    13c1 <testVectors+0x271>
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    138d <testVectors+0x23d>
lea    0xc73(%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    1418 <testVectors+0x2c8>
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    13e4 <testVectors+0x294>
lea    0xc1c(%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     16da <testVectors+0x58a>
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,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    149a <testVectors+0x34a>
mov    -0x54(%rbp),%eax
add    $0x80,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    146b <testVectors+0x31b>
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14e5 <testVectors+0x395>
mov    -0x2c(%rbp),%eax
imul   -0x38(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14b4 <testVectors+0x364>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1501 <testVectors+0x3b1>
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    0xacb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
lea    0xac6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%esi
lea    0xac1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xabd(%rip),%rdi
mov    $0x100,%edx
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xac2(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xaae(%rip),%rax
mov    %rax,-0x60(%rbp)
lea    0xab5(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rsi
lea    0xaad(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xaab(%rip),%rdi
mov    $0xc,%esi
mov    $0x300,%edx
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xaba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1610 <testVectors+0x4c0>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xa92(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15dc <testVectors+0x48c>
lea    0xa24(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa6e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1667 <testVectors+0x517>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xa3b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1633 <testVectors+0x4e3>
lea    0x9cd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa1e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16be <testVectors+0x56e>
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0x9e4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    168a <testVectors+0x53a>
lea    0x976(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    143b <testVectors+0x2eb>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testVectors>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,0x18(%rsp)
mov    %rdi,0x28(%rsp)
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
mov    $0x40,%edi
call   1080 <malloc@plt>
mov    %rax,%rbp
lea    0xff3(%rip),%r13
xor    %r12d,%r12d
xor    %ebx,%ebx
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%r15
nopl   0x0(%rax)
lea    0x0(,%r12,8),%edi
call   1080 <malloc@plt>
mov    %rax,%rbp
test   %r12,%r12
je     136d <testVectors+0x20d>
cmp    $0x20,%r12
jae    11e0 <testVectors+0x80>
xor    %eax,%eax
jmp    1360 <testVectors+0x200>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
mov    %r12,%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    1309 <testVectors+0x1a9>
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(%rbp,%rdx,1)
movdqu %xmm1,0x10(%rbp,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqu %xmm1,0x20(%rbp,%rdx,1)
movdqu %xmm2,0x30(%rbp,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm10,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm4,%xmm2
movdqu %xmm1,0x40(%rbp,%rdx,1)
movdqu %xmm2,0x50(%rbp,%rdx,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm7,%xmm2
movdqu %xmm1,0x60(%rbp,%rdx,1)
movdqu %xmm2,0x70(%rbp,%rdx,1)
sub    $0xffffffffffffff80,%rdx
pxor   %xmm8,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1290 <testVectors+0x130>
test   $0x3,%sil
je     1368 <testVectors+0x208>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x5,%rcx
add    %rbp,%rdx
add    $0x10,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
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    1330 <testVectors+0x1d0>
jmp    1368 <testVectors+0x208>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %al,0x0(%rbp,%rax,1)
add    $0x1,%rax
cmp    %rax,%r12
jne    1360 <testVectors+0x200>
mov    $0x80,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%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,%ebx
cmp    $0x10,%ebx
mov    $0x0,%eax
cmove  %eax,%ebx
mov    %ebx,0xc(%rsp)
mov    0x10(%rsp),%rdi
mov    $0x40,%esi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r14,%r8
mov    $0x10,%r9d
push   %r15
mov    0x30(%rsp),%rbx
push   %rbx
call   1060 <PHS@plt>
add    $0x10,%rsp
lea    0xcd3(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcce(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcc7(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcc4(%rip),%rdi
mov    %r15d,%esi
mov    $0x100,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcc6(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xccb(%rip),%rdi
lea    0xcbd(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcc2(%rip),%rdi
mov    $0xc,%esi
mov    $0x300,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcd1(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %r12,%r12
je     14e8 <testVectors+0x388>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%rbp,%rbx,1),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    14d0 <testVectors+0x370>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc9a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl (%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xe(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xf(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb9a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
xchg   %ax,%ax
movzbl 0x0(%rbp,%rbx,1),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1610 <testVectors+0x4b0>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r12
cmp    $0x81,%r12
mov    0xc(%rsp),%ebx
jne    11b0 <testVectors+0x50>
mov    %ebx,%r14d
mov    $0x80,%ebx
mov    $0x1,%r15d
lea    0xb30(%rip),%r12
nopl   (%rax)
lea    -0x7f(%rbx),%eax
mov    %eax,0x24(%rsp)
lea    -0x3f8(,%rbx,8),%edi
call   1080 <malloc@plt>
mov    %rax,%r13
cmp    $0x20,%r15
mov    %rbx,0x30(%rsp)
jae    1690 <testVectors+0x530>
xor    %eax,%eax
mov    %r14d,%ebx
jmp    1830 <testVectors+0x6d0>
nopl   0x0(%rax,%rax,1)
mov    %r15,%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
mov    %r15,%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 0x9b6(%rip),%xmm5
jae    16f0 <testVectors+0x590>
xor    %edx,%edx
movdqa 0x92a(%rip),%xmm0
movdqa 0x942(%rip),%xmm4
movdqa 0x9aa(%rip),%xmm6
jmp    17d7 <testVectors+0x677>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%rdi
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
movdqa 0x8fe(%rip),%xmm1
movdqa %xmm1,%xmm0
movdqa 0x912(%rip),%xmm4
movdqa 0x97a(%rip),%xmm6
movdqa 0x981(%rip),%xmm8
movdqa 0x988(%rip),%xmm9
movdqa 0x98f(%rip),%xmm10
movdqa 0x996(%rip),%xmm11
movdqa 0x99d(%rip),%xmm12
movdqa 0x9a5(%rip),%xmm7
nopl   0x0(%rax,%rax,1)
pxor   %xmm5,%xmm0
movdqa %xmm1,%xmm2
paddb  %xmm6,%xmm2
movdqu %xmm0,0x0(%r13,%rdx,1)
movdqu %xmm2,0x10(%r13,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm8,%xmm2
movdqa %xmm1,%xmm3
paddb  %xmm9,%xmm3
movdqu %xmm2,0x20(%r13,%rdx,1)
movdqu %xmm3,0x30(%r13,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm10,%xmm2
movdqa %xmm1,%xmm3
paddb  %xmm11,%xmm3
movdqu %xmm2,0x40(%r13,%rdx,1)
movdqu %xmm3,0x50(%r13,%rdx,1)
movdqa %xmm1,%xmm2
paddb  %xmm12,%xmm2
paddb  %xmm7,%xmm1
movdqu %xmm2,0x60(%r13,%rdx,1)
movdqu %xmm1,0x70(%r13,%rdx,1)
sub    $0xffffffffffffff80,%rdx
movdqa %xmm0,%xmm1
add    $0xfffffffffffffffc,%rdi
jne    1750 <testVectors+0x5f0>
test   $0x3,%sil
je     1828 <testVectors+0x6c8>
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   (%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    1800 <testVectors+0x6a0>
cmp    %rax,%r15
mov    %r14d,%ebx
je     1841 <testVectors+0x6e1>
lea    -0x80(%rax),%ecx
mov    %cl,0x0(%r13,%rax,1)
add    $0x1,%rax
cmp    %rax,%r15
jne    1830 <testVectors+0x6d0>
mov    $0x80,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%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,%ebx
cmp    $0x10,%ebx
mov    $0x0,%eax
cmove  %eax,%ebx
mov    %ebx,0xc(%rsp)
mov    %rbp,%rdi
mov    $0x40,%esi
mov    %r13,%rdx
mov    0x24(%rsp),%ebx
mov    %ebx,%ecx
mov    %r14,%r8
mov    $0x10,%r9d
push   0x18(%rsp)
mov    0x30(%rsp),%rbp
push   %rbp
call   1060 <PHS@plt>
add    $0x10,%rsp
lea    0x7fc(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7f8(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7f1(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7ee(%rip),%rdi
mov    0x18(%rsp),%rsi
mov    $0x100,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7ee(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7f3(%rip),%rdi
lea    0x7e5(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7ea(%rip),%rdi
mov    $0xc,%esi
mov    $0x300,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7f9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rbx,1),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    19a0 <testVectors+0x840>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x7c9(%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    0x6c9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
nop
movzbl 0x0(%rbp,%rbx,1),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1ae0 <testVectors+0x980>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x30(%rsp),%rbx
add    $0x1,%ebx
add    $0x1,%r15
cmp    $0x82,%r15
mov    0xc(%rsp),%r14d
jne    1660 <testVectors+0x500>
xor    %eax,%eax
add    $0x38,%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"outlen: %d\0A\00"
@.str.2 = [13 x i8] c"t_costs: %d\0A\00"
@.str.3 = [24 x i8] c"m_costs: \09R: %d \09C: %d\0A\00"
@.str.4 = [17 x i8] c"parallelism: %u\0A\00"
@.str.5 = [1 x i8] zeroinitializer
@.str.6 = [7 x i8] c"Blake2\00"
@.str.7 = [12 x i8] c"sponge: %s\0A\00"
@.str.8 = [39 x i8] c"sponge blocks (bitrate): %u = %u bits\0A\00"
@.str.9 = [5 x i8] c"In: \00"
@.str.10 = [6 x i8] c"%02x \00"
@.str.11 = [2 x i8] c"\0A\00"
@.str.12 = [7 x i8] c"Salt: \00"
@.str.13 = [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 i8*
%16 = alloca i32
%17 = alloca i8*
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
%18 = call i32 @time(i32* null)
%19 = call i32 @srand(i32 %18)
store i32 0, i32* %12
%20 = load i32, i32* %5
%21 = call i8* @malloc(i32 %20)
store i8* %21, i8** %13
store i32 0, i32* %11
br label %22
22: ; preds = %153, %2
%23 = load i32, i32* %11
%24 = icmp sle i32 %23, 128
br i1 %24, label %25, label %156
25: ; preds = %22
%26 = load i32, i32* %11
store i32 %26, i32* %7
%27 = load i32, i32* %7
%28 = sext i32 %27 to i64
%29 = mul i64 8, %28
%30 = trunc i64 %29 to i32
%31 = call i8* @malloc(i32 %30)
store i8* %31, i8** %6
store i32 0, i32* %14
br label %32
32: ; preds = %43, %25
%33 = load i32, i32* %14
%34 = load i32, i32* %7
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %46
36: ; preds = %32
%37 = load i32, i32* %14
%38 = trunc i32 %37 to i8
%39 = load i8*, i8** %6
%40 = load i32, i32* %14
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
store i8 %38, i8* %42
br label %43
43: ; preds = %36
%44 = load i32, i32* %14
%45 = add nsw i32 %44, 1
store i32 %45, i32* %14
br label %32
46: ; preds = %32
%47 = load i32, i32* %9
%48 = sext i32 %47 to i64
%49 = mul i64 8, %48
%50 = trunc i64 %49 to i32
%51 = call i8* @malloc(i32 %50)
store i8* %51, i8** %8
store i32 0, i32* %14
br label %52
52: ; preds = %67, %46
%53 = load i32, i32* %14
%54 = load i32, i32* %9
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %70
56: ; preds = %52
%57 = load i32, i32* %9
%58 = load i32, i32* %12
%59 = mul nsw i32 %57, %58
%60 = load i32, i32* %14
%61 = add nsw i32 %59, %60
%62 = trunc i32 %61 to i8
%63 = load i8*, i8** %8
%64 = load i32, i32* %14
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %63, i64 %65
store i8 %62, i8* %66
br label %67
67: ; preds = %56
%68 = load i32, i32* %14
%69 = add nsw i32 %68, 1
store i32 %69, i32* %14
br label %52
70: ; preds = %52
%71 = load i32, i32* %12
%72 = add nsw i32 %71, 1
store i32 %72, i32* %12
%73 = load i32, i32* %12
%74 = load i32, i32* %9
%75 = icmp eq i32 %73, %74
br i1 %75, label %76, label %77
76: ; preds = %70
store i32 0, i32* %12
br label %77
77: ; preds = %76, %70
%78 = load i8*, i8** %13
%79 = load i32, i32* %5
%80 = load i8*, i8** %6
%81 = load i32, i32* %7
%82 = load i8*, i8** %8
%83 = load i32, i32* %9
%84 = load i32, i32* %3
%85 = load i32, i32* %4
%86 = call i32 @PHS(i8* %78, i32 %79, i8* %80, i32 %81, i8* %82, i32 %83, i32 %84, i32 %85)
%87 = load i32, i32* %7
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i32 %87)
%89 = load i32, i32* %5
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 %89)
%91 = load i32, i32* %3
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %91)
%93 = load i32, i32* %4
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %93, i32 256)
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 2)
store i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8** %15
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8** %15
%96 = load i8*, i8** %15
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i64 0, i64 0), i8* %96)
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.8, i64 0, i64 0), i32 12, i32 768)
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %10
br label %100
100: ; preds = %112, %77
%101 = load i32, i32* %10
%102 = load i32, i32* %7
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %115
104: ; preds = %100
%105 = load i8*, i8** %6
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %105, i64 %107
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %110)
br label %112
112: ; preds = %104
%113 = load i32, i32* %10
%114 = add nsw i32 %113, 1
store i32 %114, i32* %10
br label %100
115: ; preds = %100
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %10
br label %118
118: ; preds = %130, %115
%119 = load i32, i32* %10
%120 = load i32, i32* %9
%121 = icmp slt i32 %119, %120
br i1 %121, label %122, label %133
122: ; preds = %118
%123 = load i8*, i8** %8
%124 = load i32, i32* %10
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = load i8, i8* %126
%128 = zext i8 %127 to i32
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %128)
br label %130
130: ; preds = %122
%131 = load i32, i32* %10
%132 = add nsw i32 %131, 1
store i32 %132, i32* %10
br label %118
133: ; preds = %118
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
store i32 0, i32* %10
br label %136
136: ; preds = %148, %133
%137 = load i32, i32* %10
%138 = load i32, i32* %5
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %151
140: ; preds = %136
%141 = load i8*, i8** %13
%142 = load i32, i32* %10
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i8, i8* %141, i64 %143
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %146)
br label %148
148: ; preds = %140
%149 = load i32, i32* %10
%150 = add nsw i32 %149, 1
store i32 %150, i32* %10
br label %136
151: ; preds = %136
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
br label %153
153: ; preds = %151
%154 = load i32, i32* %11
%155 = add nsw i32 %154, 1
store i32 %155, i32* %11
br label %22
156: ; preds = %22
store i32 128, i32* %11
br label %157
157: ; preds = %290, %156
%158 = load i32, i32* %11
%159 = icmp sle i32 %158, 256
br i1 %159, label %160, label %293
160: ; preds = %157
%161 = load i32, i32* %11
%162 = sub nsw i32 %161, 127
store i32 %162, i32* %7
%163 = load i32, i32* %7
%164 = sext i32 %163 to i64
%165 = mul i64 8, %164
%166 = trunc i64 %165 to i32
%167 = call i8* @malloc(i32 %166)
store i8* %167, i8** %6
store i32 0, i32* %16
br label %168
168: ; preds = %180, %160
%169 = load i32, i32* %16
%170 = load i32, i32* %7
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %183
172: ; preds = %168
%173 = load i32, i32* %16
%174 = add nsw i32 %173, 128
%175 = trunc i32 %174 to i8
%176 = load i8*, i8** %6
%177 = load i32, i32* %16
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8, i8* %176, i64 %178
store i8 %175, i8* %179
br label %180
180: ; preds = %172
%181 = load i32, i32* %16
%182 = add nsw i32 %181, 1
store i32 %182, i32* %16
br label %168
183: ; preds = %168
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = mul i64 8, %185
%187 = trunc i64 %186 to i32
%188 = call i8* @malloc(i32 %187)
store i8* %188, i8** %8
store i32 0, i32* %16
br label %189
189: ; preds = %204, %183
%190 = load i32, i32* %16
%191 = load i32, i32* %9
%192 = icmp slt i32 %190, %191
br i1 %192, label %193, label %207
193: ; preds = %189
%194 = load i32, i32* %9
%195 = load i32, i32* %12
%196 = mul nsw i32 %194, %195
%197 = load i32, i32* %16
%198 = add nsw i32 %196, %197
%199 = trunc i32 %198 to i8
%200 = load i8*, i8** %8
%201 = load i32, i32* %16
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
store i8 %199, i8* %203
br label %204
204: ; preds = %193
%205 = load i32, i32* %16
%206 = add nsw i32 %205, 1
store i32 %206, i32* %16
br label %189
207: ; preds = %189
%208 = load i32, i32* %12
%209 = add nsw i32 %208, 1
store i32 %209, i32* %12
%210 = load i32, i32* %12
%211 = load i32, i32* %9
%212 = icmp eq i32 %210, %211
br i1 %212, label %213, label %214
213: ; preds = %207
store i32 0, i32* %12
br label %214
214: ; preds = %213, %207
%215 = load i8*, i8** %13
%216 = load i32, i32* %5
%217 = load i8*, i8** %6
%218 = load i32, i32* %7
%219 = load i8*, i8** %8
%220 = load i32, i32* %9
%221 = load i32, i32* %3
%222 = load i32, i32* %4
%223 = call i32 @PHS(i8* %215, i32 %216, i8* %217, i32 %218, i8* %219, i32 %220, i32 %221, i32 %222)
%224 = load i32, i32* %7
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i32 %224)
%226 = load i32, i32* %5
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 %226)
%228 = load i32, i32* %3
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %228)
%230 = load i32, i32* %4
%231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %230, i32 256)
%232 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 2)
store i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8** %17
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8** %17
%233 = load i8*, i8** %17
%234 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i64 0, i64 0), i8* %233)
%235 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.8, i64 0, i64 0), i32 12, i32 768)
%236 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %10
br label %237
237: ; preds = %249, %214
%238 = load i32, i32* %10
%239 = load i32, i32* %7
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %252
241: ; preds = %237
%242 = load i8*, i8** %6
%243 = load i32, i32* %10
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
%246 = load i8, i8* %245
%247 = zext i8 %246 to i32
%248 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %247)
br label %249
249: ; preds = %241
%250 = load i32, i32* %10
%251 = add nsw i32 %250, 1
store i32 %251, i32* %10
br label %237
252: ; preds = %237
%253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%254 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %10
br label %255
255: ; preds = %267, %252
%256 = load i32, i32* %10
%257 = load i32, i32* %9
%258 = icmp slt i32 %256, %257
br i1 %258, label %259, label %270
259: ; preds = %255
%260 = load i8*, i8** %8
%261 = load i32, i32* %10
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i8, i8* %260, i64 %262
%264 = load i8, i8* %263
%265 = zext i8 %264 to i32
%266 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %265)
br label %267
267: ; preds = %259
%268 = load i32, i32* %10
%269 = add nsw i32 %268, 1
store i32 %269, i32* %10
br label %255
270: ; preds = %255
%271 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%272 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
store i32 0, i32* %10
br label %273
273: ; preds = %285, %270
%274 = load i32, i32* %10
%275 = load i32, i32* %5
%276 = icmp slt i32 %274, %275
br i1 %276, label %277, label %288
277: ; preds = %273
%278 = load i8*, i8** %13
%279 = load i32, i32* %10
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i8, i8* %278, i64 %280
%282 = load i8, i8* %281
%283 = zext i8 %282 to i32
%284 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %283)
br label %285
285: ; preds = %277
%286 = load i32, i32* %10
%287 = add nsw i32 %286, 1
store i32 %287, i32* %10
br label %273
288: ; preds = %273
%289 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
br label %290
290: ; preds = %288
%291 = load i32, i32* %11
%292 = add nsw i32 %291, 1
store i32 %292, i32* %11
br label %157
293: ; preds = %157
ret i32 0
}

LLVM IR (-O2):
@.str = [12 x i8] c"\0Ainlen: %d\0A\00"
@.str.1 = [12 x i8] c"outlen: %d\0A\00"
@.str.2 = [13 x i8] c"t_costs: %d\0A\00"
@.str.3 = [24 x i8] c"m_costs: \09R: %d \09C: %d\0A\00"
@.str.4 = [17 x i8] c"parallelism: %u\0A\00"
@.str.6 = [7 x i8] c"Blake2\00"
@.str.7 = [12 x i8] c"sponge: %s\0A\00"
@.str.8 = [39 x i8] c"sponge blocks (bitrate): %u = %u bits\0A\00"
@.str.9 = [5 x i8] c"In: \00"
@.str.10 = [6 x i8] c"%02x \00"
@.str.12 = [7 x i8] c"Salt: \00"
@.str.13 = [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, %217
%7 = phi i64 [ 0, %2 ], [ %219, %217 ]
%8 = phi i32 [ 0, %2 ], [ %137, %217 ]
%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 64)
%142 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %0)
%143 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %1, i32 256)
%144 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 2)
%145 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0))
%146 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.8, i64 0, i64 0), i32 12, i32 768)
%147 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
br i1 %16, label %156, label %148
148: ; preds = %86, %148
%149 = phi i64 [ %154, %148 ], [ 0, %86 ]
%150 = getelementptr inbounds i8, i8* %15, i64 %149
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %152)
%154 = add nuw nsw i64 %149, 1
%155 = icmp eq i64 %154, %7
br i1 %155, label %156, label %148
156: ; preds = %148, %86
%157 = tail call i32 @putchar(i32 10)
%158 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
%159 = load i8, i8* %87
%160 = zext i8 %159 to i32
%161 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %160)
%162 = load i8, i8* %92
%163 = zext i8 %162 to i32
%164 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %163)
%165 = load i8, i8* %95
%166 = zext i8 %165 to i32
%167 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %166)
%168 = load i8, i8* %98
%169 = zext i8 %168 to i32
%170 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %169)
%171 = load i8, i8* %101
%172 = zext i8 %171 to i32
%173 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %172)
%174 = load i8, i8* %104
%175 = zext i8 %174 to i32
%176 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %175)
%177 = load i8, i8* %107
%178 = zext i8 %177 to i32
%179 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %178)
%180 = load i8, i8* %110
%181 = zext i8 %180 to i32
%182 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %181)
%183 = load i8, i8* %113
%184 = zext i8 %183 to i32
%185 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %184)
%186 = load i8, i8* %116
%187 = zext i8 %186 to i32
%188 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %187)
%189 = load i8, i8* %119
%190 = zext i8 %189 to i32
%191 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %190)
%192 = load i8, i8* %122
%193 = zext i8 %192 to i32
%194 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %193)
%195 = load i8, i8* %125
%196 = zext i8 %195 to i32
%197 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %196)
%198 = load i8, i8* %128
%199 = zext i8 %198 to i32
%200 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %199)
%201 = load i8, i8* %131
%202 = zext i8 %201 to i32
%203 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %202)
%204 = load i8, i8* %134
%205 = zext i8 %204 to i32
%206 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %205)
%207 = tail call i32 @putchar(i32 10)
%208 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
br label %209
209: ; preds = %156, %209
%210 = phi i64 [ 0, %156 ], [ %215, %209 ]
%211 = getelementptr inbounds i8, i8* %5, i64 %210
%212 = load i8, i8* %211
%213 = zext i8 %212 to i32
%214 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %213)
%215 = add nuw nsw i64 %210, 1
%216 = icmp eq i64 %215, 64
br i1 %216, label %217, label %209
217: ; preds = %209
%218 = tail call i32 @putchar(i32 10)
%219 = add nuw nsw i64 %7, 1
%220 = icmp eq i64 %219, 129
br i1 %220, label %221, label %6
221: ; preds = %217, %433
%222 = phi i64 [ %436, %433 ], [ 1, %217 ]
%223 = phi i32 [ %354, %433 ], [ %137, %217 ]
%224 = phi i32 [ %435, %433 ], [ 128, %217 ]
%225 = and i64 %222, 9223372036854775776
%226 = add nsw i64 %225, -32
%227 = lshr exact i64 %226, 5
%228 = add nuw nsw i64 %227, 1
%229 = add nsw i32 %224, -127
%230 = shl nsw i32 %229, 3
%231 = tail call i8* @malloc(i32 %230)
%232 = icmp ult i64 %222, 32
br i1 %232, label %294, label %233
233: ; preds = %221
%234 = and i64 %222, 9223372036854775776
%235 = and i64 %228, 3
%236 = icmp ult i64 %226, 96
br i1 %236, label %274, label %237
237: ; preds = %233
%238 = and i64 %228, 1152921504606846972
br label %239
239: ; preds = %239, %237
%240 = phi i64 [ 0, %237 ], [ %270, %239 ]
%241 = 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>, %237 ], [ %271, %239 ]
%242 = phi i64 [ 0, %237 ], [ %272, %239 ]
%243 = xor <16 x i8> %241, <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>
%244 = add <16 x i8> %241, <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>
%245 = getelementptr inbounds i8, i8* %231, i64 %240
%246 = bitcast i8* %245 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %246
%247 = getelementptr inbounds i8, i8* %245, i64 16
%248 = bitcast i8* %247 to <16 x i8>*
store <16 x i8> %244, <16 x i8>* %248
%249 = or i64 %240, 32
%250 = add <16 x i8> %241, <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>
%251 = add <16 x i8> %241, <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>
%252 = getelementptr inbounds i8, i8* %231, i64 %249
%253 = bitcast i8* %252 to <16 x i8>*
store <16 x i8> %250, <16 x i8>* %253
%254 = getelementptr inbounds i8, i8* %252, i64 16
%255 = bitcast i8* %254 to <16 x i8>*
store <16 x i8> %251, <16 x i8>* %255
%256 = or i64 %240, 64
%257 = add <16 x i8> %241, <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>
%258 = add <16 x i8> %241, <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>
%259 = getelementptr inbounds i8, i8* %231, i64 %256
%260 = bitcast i8* %259 to <16 x i8>*
store <16 x i8> %257, <16 x i8>* %260
%261 = getelementptr inbounds i8, i8* %259, i64 16
%262 = bitcast i8* %261 to <16 x i8>*
store <16 x i8> %258, <16 x i8>* %262
%263 = or i64 %240, 96
%264 = add <16 x i8> %241, <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>
%265 = add <16 x i8> %241, <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>
%266 = getelementptr inbounds i8, i8* %231, i64 %263
%267 = bitcast i8* %266 to <16 x i8>*
store <16 x i8> %264, <16 x i8>* %267
%268 = getelementptr inbounds i8, i8* %266, i64 16
%269 = bitcast i8* %268 to <16 x i8>*
store <16 x i8> %265, <16 x i8>* %269
%270 = add nuw i64 %240, 128
%271 = xor <16 x i8> %241, <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>
%272 = add i64 %242, 4
%273 = icmp eq i64 %272, %238
br i1 %273, label %274, label %239
274: ; preds = %239, %233
%275 = phi i64 [ 0, %233 ], [ %270, %239 ]
%276 = 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>, %233 ], [ %271, %239 ]
%277 = icmp eq i64 %235, 0
br i1 %277, label %292, label %278
278: ; preds = %274, %278
%279 = phi i64 [ %288, %278 ], [ %275, %274 ]
%280 = phi <16 x i8> [ %289, %278 ], [ %276, %274 ]
%281 = phi i64 [ %290, %278 ], [ 0, %274 ]
%282 = xor <16 x i8> %280, <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>
%283 = add <16 x i8> %280, <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>
%284 = getelementptr inbounds i8, i8* %231, i64 %279
%285 = bitcast i8* %284 to <16 x i8>*
store <16 x i8> %282, <16 x i8>* %285
%286 = getelementptr inbounds i8, i8* %284, i64 16
%287 = bitcast i8* %286 to <16 x i8>*
store <16 x i8> %283, <16 x i8>* %287
%288 = add nuw i64 %279, 32
%289 = add <16 x i8> %280, <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>
%290 = add i64 %281, 1
%291 = icmp eq i64 %290, %235
br i1 %291, label %292, label %278
292: ; preds = %278, %274
%293 = icmp eq i64 %222, %234
br i1 %293, label %303, label %294
294: ; preds = %221, %292
%295 = phi i64 [ 0, %221 ], [ %234, %292 ]
br label %296
296: ; preds = %294, %296
%297 = phi i64 [ %301, %296 ], [ %295, %294 ]
%298 = trunc i64 %297 to i8
%299 = xor i8 %298, -128
%300 = getelementptr inbounds i8, i8* %231, i64 %297
store i8 %299, i8* %300
%301 = add nuw nsw i64 %297, 1
%302 = icmp eq i64 %301, %222
br i1 %302, label %303, label %296
303: ; preds = %296, %292
%304 = tail call dereferenceable_or_null(128) i8* @malloc(i32 128)
%305 = shl nsw i32 %223, 4
%306 = trunc i32 %305 to i8
store i8 %306, i8* %304
%307 = trunc i32 %305 to i8
%308 = or i8 %307, 1
%309 = getelementptr inbounds i8, i8* %304, i64 1
store i8 %308, i8* %309
%310 = trunc i32 %305 to i8
%311 = or i8 %310, 2
%312 = getelementptr inbounds i8, i8* %304, i64 2
store i8 %311, i8* %312
%313 = trunc i32 %305 to i8
%314 = or i8 %313, 3
%315 = getelementptr inbounds i8, i8* %304, i64 3
store i8 %314, i8* %315
%316 = trunc i32 %305 to i8
%317 = or i8 %316, 4
%318 = getelementptr inbounds i8, i8* %304, i64 4
store i8 %317, i8* %318
%319 = trunc i32 %305 to i8
%320 = or i8 %319, 5
%321 = getelementptr inbounds i8, i8* %304, i64 5
store i8 %320, i8* %321
%322 = trunc i32 %305 to i8
%323 = or i8 %322, 6
%324 = getelementptr inbounds i8, i8* %304, i64 6
store i8 %323, i8* %324
%325 = trunc i32 %305 to i8
%326 = or i8 %325, 7
%327 = getelementptr inbounds i8, i8* %304, i64 7
store i8 %326, i8* %327
%328 = trunc i32 %305 to i8
%329 = or i8 %328, 8
%330 = getelementptr inbounds i8, i8* %304, i64 8
store i8 %329, i8* %330
%331 = trunc i32 %305 to i8
%332 = or i8 %331, 9
%333 = getelementptr inbounds i8, i8* %304, i64 9
store i8 %332, i8* %333
%334 = trunc i32 %305 to i8
%335 = or i8 %334, 10
%336 = getelementptr inbounds i8, i8* %304, i64 10
store i8 %335, i8* %336
%337 = trunc i32 %305 to i8
%338 = or i8 %337, 11
%339 = getelementptr inbounds i8, i8* %304, i64 11
store i8 %338, i8* %339
%340 = trunc i32 %305 to i8
%341 = or i8 %340, 12
%342 = getelementptr inbounds i8, i8* %304, i64 12
store i8 %341, i8* %342
%343 = trunc i32 %305 to i8
%344 = or i8 %343, 13
%345 = getelementptr inbounds i8, i8* %304, i64 13
store i8 %344, i8* %345
%346 = trunc i32 %305 to i8
%347 = or i8 %346, 14
%348 = getelementptr inbounds i8, i8* %304, i64 14
store i8 %347, i8* %348
%349 = trunc i32 %305 to i8
%350 = or i8 %349, 15
%351 = getelementptr inbounds i8, i8* %304, i64 15
store i8 %350, i8* %351
%352 = add nsw i32 %223, 1
%353 = icmp eq i32 %352, 16
%354 = select i1 %353, i32 0, i32 %352
%355 = tail call i32 @PHS(i8* %5, i32 64, i8* %231, i32 %229, i8* %304, i32 16, i32 %0, i32 %1)
%356 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i32 %229)
%357 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 64)
%358 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %0)
%359 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %1, i32 256)
%360 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 2)
%361 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0))
%362 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.8, i64 0, i64 0), i32 12, i32 768)
%363 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
br label %364
364: ; preds = %303, %364
%365 = phi i64 [ 0, %303 ], [ %370, %364 ]
%366 = getelementptr inbounds i8, i8* %231, i64 %365
%367 = load i8, i8* %366
%368 = zext i8 %367 to i32
%369 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %368)
%370 = add nuw nsw i64 %365, 1
%371 = icmp eq i64 %370, %222
br i1 %371, label %372, label %364
372: ; preds = %364
%373 = tail call i32 @putchar(i32 10)
%374 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
%375 = load i8, i8* %304
%376 = zext i8 %375 to i32
%377 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %376)
%378 = load i8, i8* %309
%379 = zext i8 %378 to i32
%380 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %379)
%381 = load i8, i8* %312
%382 = zext i8 %381 to i32
%383 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %382)
%384 = load i8, i8* %315
%385 = zext i8 %384 to i32
%386 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %385)
%387 = load i8, i8* %318
%388 = zext i8 %387 to i32
%389 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %388)
%390 = load i8, i8* %321
%391 = zext i8 %390 to i32
%392 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %391)
%393 = load i8, i8* %324
%394 = zext i8 %393 to i32
%395 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %394)
%396 = load i8, i8* %327
%397 = zext i8 %396 to i32
%398 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %397)
%399 = load i8, i8* %330
%400 = zext i8 %399 to i32
%401 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %400)
%402 = load i8, i8* %333
%403 = zext i8 %402 to i32
%404 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %403)
%405 = load i8, i8* %336
%406 = zext i8 %405 to i32
%407 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %406)
%408 = load i8, i8* %339
%409 = zext i8 %408 to i32
%410 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %409)
%411 = load i8, i8* %342
%412 = zext i8 %411 to i32
%413 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %412)
%414 = load i8, i8* %345
%415 = zext i8 %414 to i32
%416 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %415)
%417 = load i8, i8* %348
%418 = zext i8 %417 to i32
%419 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %418)
%420 = load i8, i8* %351
%421 = zext i8 %420 to i32
%422 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %421)
%423 = tail call i32 @putchar(i32 10)
%424 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
br label %425
425: ; preds = %372, %425
%426 = phi i64 [ 0, %372 ], [ %431, %425 ]
%427 = getelementptr inbounds i8, i8* %5, i64 %426
%428 = load i8, i8* %427
%429 = zext i8 %428 to i32
%430 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i32 %429)
%431 = add nuw nsw i64 %426, 1
%432 = icmp eq i64 %431, 64
br i1 %432, label %433, label %425
433: ; preds = %425
%434 = tail call i32 @putchar(i32 10)
%435 = add nuw nsw i32 %224, 1
%436 = add nuw nsw i64 %222, 1
%437 = icmp eq i64 %436, 130
br i1 %437, label %438, label %221
438: ; preds = %433
ret i32 0
}