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

/* Variables and functions */
int /*<<< orphan*/ IdeaCBCDecrypt(int *, int *, int, int);
int /*<<< orphan*/ IdeaCBCEncrypt(int *, int *, int, int);
int /*<<< orphan*/ IdeaCFBDecrypt(int *, int *, int, int);
int /*<<< orphan*/ IdeaCFBEncrypt(int *, int *, int, int);
int /*<<< orphan*/ IdeaCTR(int *, int *, int, int);
int /*<<< orphan*/ IdeaOFB(int *, int *, int, int);
int /*<<< orphan*/ IdeaPCBCDecrypt(int *, int *, int, int);
int /*<<< orphan*/ IdeaPCBCEncrypt(int *, int *, int, int);
int /*<<< orphan*/ MakeKey(int /*<<< orphan*/ *);
int /*<<< orphan*/ printf(char *);
int rand();
int /*<<< orphan*/ srand(unsigned int);
scalar_t__ time(int /*<<< orphan*/ *);
int ModeTest() {
  srand((unsigned int)time(NULL));
  uint64_t message[15];
  uint64_t messageCopy[15];
  int i, j;
  uint64_t nonce;
  uint64_t key[2];
  MakeKey((uint16_t *)key);
  for (i = 0; i < 25; i++) {
    for (j = 0; j < 15; j++)
      message[j] = messageCopy[j] = rand() * rand();
    nonce = rand();
    IdeaCBCEncrypt(message, key, nonce, 15);
    IdeaCBCDecrypt(message, key, nonce, 15);
    for (j = 0; j < 15; j++)
      if (message[j] != messageCopy[j]) {
        printf("\x1b[31m"
               "CBC ERROR\n"
               "\x1b[0m");
        return 1;
      }
  }
  printf("\x1b[32m"
         "CBC Encryption OK\n"
         "\x1b[0m");
  MakeKey((uint16_t *)key);
  for (i = 0; i < 25; i++) {
    for (j = 0; j < 15; j++)
      message[j] = messageCopy[j] = rand() * rand();
    nonce = rand();
    IdeaPCBCEncrypt(message, key, nonce, 15);
    IdeaPCBCDecrypt(message, key, nonce, 15);
    for (j = 0; j < 15; j++)
      if (message[j] != messageCopy[j]) {
        printf("\x1b[31m"
               "PCBC ERROR\n"
               "\x1b[0m");
        return 1;
      }
  }
  printf("\x1b[32m"
         "PCBC Encryption OK\n"
         "\x1b[0m");
  MakeKey((uint16_t *)key);
  for (i = 0; i < 25; i++) {
    for (j = 0; j < 15; j++)
      message[j] = messageCopy[j] = rand() * rand();
    nonce = rand() * rand();
    uint64_t nonceb = nonce;
    IdeaCFBEncrypt(message, key, nonce, 15);
    IdeaCFBDecrypt(message, key, nonceb, 15);
    for (j = 0; j < 15; j++)
      if (message[j] != messageCopy[j]) {
        printf("\x1b[31m"
               "CFB ERROR\n"
               "\x1b[0m");
        return 1;
      }
  }
  printf("\x1b[32m"
         "CFB Encryption OK\n"
         "\x1b[0m");
  MakeKey((uint16_t *)key);
  for (i = 0; i < 25; i++) {
    for (j = 0; j < 15; j++)
      message[j] = messageCopy[j] = rand() * rand();
    nonce = rand() * rand();
    IdeaOFB(message, key, nonce, 15);
    IdeaOFB(message, key, nonce, 15);
    for (j = 0; j < 15; j++)
      if (message[j] != messageCopy[j]) {
        printf("\x1b[31m"
               "OFB ERROR\n"
               "\x1b[0m");
        return 1;
      }
  }
  printf("\x1b[32m"
         "OFB Encryption OK\n"
         "\x1b[0m");
  MakeKey((uint16_t *)key);
  for (i = 0; i < 25; i++) {
    for (j = 0; j < 15; j++)
      message[j] = messageCopy[j] = rand() * rand();
    nonce = rand();
    IdeaCTR(message, key, nonce, 15);
    IdeaCTR(message, key, nonce, 15);
    for (j = 0; j < 15; j++)
      if (message[j] != messageCopy[j]) {
        printf("\x1b[31m"
               "CTR ERROR\n"
               "\x1b[0m");
        return 1;
      }
  }
  printf("\x1b[32m"
         "CTR Encryption OK\n"
         "\x1b[0m");
  return 0;
}


x86 assembly (clang, -O0):
<ModeTest>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
xor    %eax,%eax
mov    %eax,%edi
call   10b0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
lea    -0x94(%rbp),%rdi
call   1060 <MakeKey@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x19,-0x84(%rbp)
jge    132c <ModeTest+0x15c>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    126c <ModeTest+0x9c>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0x9c(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    -0x9c(%rbp),%ecx
imul   %eax,%ecx
movslq -0x88(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x88(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1218 <ModeTest+0x48>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0x8c(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   10c0 <IdeaCBCEncrypt@plt>
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   1080 <IdeaCBCDecrypt@plt>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1313 <ModeTest+0x143>
movslq -0x88(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0x88(%rbp),%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
je     12fa <ModeTest+0x12a>
lea    0xd17(%rip),%rdi
call   1090 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    18af <ModeTest+0x6df>
jmp    12ff <ModeTest+0x12f>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    12b9 <ModeTest+0xe9>
jmp    1318 <ModeTest+0x148>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1201 <ModeTest+0x31>
lea    0xce1(%rip),%rdi
call   1090 <printf@plt>
lea    -0x94(%rbp),%rdi
call   1060 <MakeKey@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x19,-0x84(%rbp)
jge    1479 <ModeTest+0x2a9>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    13b9 <ModeTest+0x1e9>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xa0(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    -0xa0(%rbp),%ecx
imul   %eax,%ecx
movslq -0x88(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x88(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1365 <ModeTest+0x195>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0x8c(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   1070 <IdeaPCBCEncrypt@plt>
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   10f0 <IdeaPCBCDecrypt@plt>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1460 <ModeTest+0x290>
movslq -0x88(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0x88(%rbp),%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
je     1447 <ModeTest+0x277>
lea    0xbfa(%rip),%rdi
call   1090 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    18af <ModeTest+0x6df>
jmp    144c <ModeTest+0x27c>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1406 <ModeTest+0x236>
jmp    1465 <ModeTest+0x295>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    134e <ModeTest+0x17e>
lea    0xbc5(%rip),%rdi
call   1090 <printf@plt>
lea    -0x94(%rbp),%rdi
call   1060 <MakeKey@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x19,-0x84(%rbp)
jge    15ea <ModeTest+0x41a>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1506 <ModeTest+0x336>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xa4(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    -0xa4(%rbp),%ecx
imul   %eax,%ecx
movslq -0x88(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x88(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    14b2 <ModeTest+0x2e2>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xa8(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   1030 <IdeaCFBEncrypt@plt>
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x98(%rbp),%edx
mov    $0xf,%ecx
call   1050 <IdeaCFBDecrypt@plt>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    15d1 <ModeTest+0x401>
movslq -0x88(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0x88(%rbp),%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
je     15b8 <ModeTest+0x3e8>
lea    0xabb(%rip),%rdi
call   1090 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    18af <ModeTest+0x6df>
jmp    15bd <ModeTest+0x3ed>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1577 <ModeTest+0x3a7>
jmp    15d6 <ModeTest+0x406>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    149b <ModeTest+0x2cb>
lea    0xa85(%rip),%rdi
call   1090 <printf@plt>
lea    -0x94(%rbp),%rdi
call   1060 <MakeKey@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x19,-0x84(%rbp)
jge    174f <ModeTest+0x57f>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1677 <ModeTest+0x4a7>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xac(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    -0xac(%rbp),%ecx
imul   %eax,%ecx
movslq -0x88(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x88(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1623 <ModeTest+0x453>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xb0(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,%ecx
mov    -0xb0(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8c(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   10d0 <IdeaOFB@plt>
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   10d0 <IdeaOFB@plt>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1736 <ModeTest+0x566>
movslq -0x88(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0x88(%rbp),%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
je     171d <ModeTest+0x54d>
lea    0x986(%rip),%rdi
call   1090 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    18af <ModeTest+0x6df>
jmp    1722 <ModeTest+0x552>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    16dc <ModeTest+0x50c>
jmp    173b <ModeTest+0x56b>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    160c <ModeTest+0x43c>
lea    0x950(%rip),%rdi
call   1090 <printf@plt>
lea    -0x94(%rbp),%rdi
call   1060 <MakeKey@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x19,-0x84(%rbp)
jge    189c <ModeTest+0x6cc>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    17dc <ModeTest+0x60c>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0xb4(%rbp)
mov    $0x0,%al
call   10e0 <rand@plt>
mov    -0xb4(%rbp),%ecx
imul   %eax,%ecx
movslq -0x88(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x88(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1788 <ModeTest+0x5b8>
mov    $0x0,%al
call   10e0 <rand@plt>
mov    %eax,-0x8c(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   1040 <IdeaCTR@plt>
lea    -0x40(%rbp),%rdi
lea    -0x94(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    $0xf,%ecx
call   1040 <IdeaCTR@plt>
movl   $0x0,-0x88(%rbp)
cmpl   $0xf,-0x88(%rbp)
jge    1883 <ModeTest+0x6b3>
movslq -0x88(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0x88(%rbp),%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
je     186a <ModeTest+0x69a>
lea    0x869(%rip),%rdi
call   1090 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    18af <ModeTest+0x6df>
jmp    186f <ModeTest+0x69f>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1829 <ModeTest+0x659>
jmp    1888 <ModeTest+0x6b8>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1771 <ModeTest+0x5a1>
lea    0x833(%rip),%rdi
call   1090 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ModeTest>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
xor    %edi,%edi
call   10b0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
lea    0x78(%rsp),%rdi
call   1060 <MakeKey@plt>
mov    $0x19,%ecx
lea    0x1dfb(%rip),%rax
mov    %rax,0x80(%rsp)
nopl   (%rax)
mov    %ecx,0x4(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x2c(%rsp)
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x28(%rsp)
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x24(%rsp)
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x20(%rsp)
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x14(%rsp)
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0xc(%rsp)
mov    %eax,0x50(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebp,%eax
mov    %eax,0x8(%rsp)
mov    %eax,0x54(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
imul   %ebp,%r15d
mov    %r15d,0x58(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r13d
imul   %ebp,%r13d
mov    %r13d,0x5c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r14d
imul   %ebp,%r14d
mov    %r14d,0x60(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
imul   %r12d,%ebp
mov    %ebp,0x64(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
imul   %ebx,%r12d
mov    %r12d,0x68(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %eax,%edx
mov    $0xf,%ecx
call   10c0 <IdeaCBCEncrypt@plt>
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %ebx,%edx
mov    $0xf,%ecx
call   1080 <IdeaCBCDecrypt@plt>
movd   0x2c(%rsp),%xmm0
movd   0x28(%rsp),%xmm1
punpckldq %xmm1,%xmm0
movd   0x24(%rsp),%xmm1
movd   0x20(%rsp),%xmm2
punpckldq %xmm2,%xmm1
punpcklqdq %xmm1,%xmm0
movd   0x1c(%rsp),%xmm1
movd   0x18(%rsp),%xmm2
punpckldq %xmm2,%xmm1
movd   0x14(%rsp),%xmm2
movd   0x10(%rsp),%xmm3
punpckldq %xmm3,%xmm2
punpcklqdq %xmm2,%xmm1
pcmpeqd 0x40(%rsp),%xmm1
pcmpeqd 0x30(%rsp),%xmm0
packssdw %xmm1,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    2005 <ModeTest+0xe35>
mov    0xc(%rsp),%eax
cmp    %eax,0x50(%rsp)
jne    2005 <ModeTest+0xe35>
mov    0x8(%rsp),%eax
cmp    %eax,0x54(%rsp)
jne    2005 <ModeTest+0xe35>
cmp    %r15d,0x58(%rsp)
jne    2005 <ModeTest+0xe35>
cmp    %r13d,0x5c(%rsp)
jne    2005 <ModeTest+0xe35>
cmp    %r14d,0x60(%rsp)
jne    2005 <ModeTest+0xe35>
cmp    %ebp,0x64(%rsp)
jne    2005 <ModeTest+0xe35>
cmp    %r12d,0x68(%rsp)
jne    2005 <ModeTest+0xe35>
mov    0x4(%rsp),%ecx
add    $0xffffffff,%ecx
jne    1210 <ModeTest+0x40>
movl   $0x1,(%rsp)
lea    0x1b58(%rip),%rdi
call   1090 <printf@plt>
lea    0x78(%rsp),%rdi
call   1060 <MakeKey@plt>
mov    $0x19,%ecx
lea    0x1b59(%rip),%rax
mov    %rax,0x80(%rsp)
nop
mov    %ecx,0x4(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x2c(%rsp)
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x28(%rsp)
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x24(%rsp)
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x20(%rsp)
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x14(%rsp)
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0xc(%rsp)
mov    %eax,0x50(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x8(%rsp)
mov    %eax,0x54(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r13d
imul   %ebx,%r13d
mov    %r13d,0x58(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
imul   %ebp,%ebx
mov    %ebx,0x5c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r14d
imul   %ebp,%r14d
mov    %r14d,0x60(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
imul   %r12d,%ebp
mov    %ebp,0x64(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
imul   %r15d,%r12d
mov    %r12d,0x68(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %eax,%edx
mov    $0xf,%ecx
call   1070 <IdeaPCBCEncrypt@plt>
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   10f0 <IdeaPCBCDecrypt@plt>
movd   0x2c(%rsp),%xmm0
movd   0x28(%rsp),%xmm1
punpckldq %xmm1,%xmm0
movd   0x24(%rsp),%xmm1
movd   0x20(%rsp),%xmm2
punpckldq %xmm2,%xmm1
movd   0x1c(%rsp),%xmm2
movd   0x18(%rsp),%xmm3
punpckldq %xmm3,%xmm2
movd   0x14(%rsp),%xmm3
movd   0x10(%rsp),%xmm4
punpckldq %xmm4,%xmm3
punpcklqdq %xmm3,%xmm2
pcmpeqd 0x40(%rsp),%xmm2
punpcklqdq %xmm1,%xmm0
pcmpeqd 0x30(%rsp),%xmm0
packssdw %xmm2,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    200c <ModeTest+0xe3c>
mov    0xc(%rsp),%eax
cmp    %eax,0x50(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x8(%rsp),%eax
cmp    %eax,0x54(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r13d,0x58(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebx,0x5c(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r14d,0x60(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebp,0x64(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r12d,0x68(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x4(%rsp),%ecx
add    $0xffffffff,%ecx
jne    14e0 <ModeTest+0x310>
lea    0x18c1(%rip),%rdi
call   1090 <printf@plt>
lea    0x78(%rsp),%rdi
call   1060 <MakeKey@plt>
mov    $0x19,%ecx
lea    0x18c3(%rip),%rax
mov    %rax,0x80(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %ecx,0x4(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x2c(%rsp)
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x28(%rsp)
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x24(%rsp)
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x20(%rsp)
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x14(%rsp)
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0xc(%rsp)
mov    %eax,0x50(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x8(%rsp)
mov    %eax,0x54(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r13d
imul   %ebx,%r13d
mov    %r13d,0x58(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
imul   %ebx,%r12d
mov    %r12d,0x5c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
imul   %ebx,%ebp
mov    %ebp,0x60(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r14d
imul   %ebx,%r14d
mov    %r14d,0x64(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
imul   %r15d,%ebx
mov    %ebx,0x68(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %eax,%r15d
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   1030 <IdeaCFBEncrypt@plt>
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   1050 <IdeaCFBDecrypt@plt>
movd   0x2c(%rsp),%xmm0
movd   0x28(%rsp),%xmm1
punpckldq %xmm1,%xmm0
movd   0x24(%rsp),%xmm1
movd   0x20(%rsp),%xmm2
punpckldq %xmm2,%xmm1
movd   0x1c(%rsp),%xmm2
movd   0x18(%rsp),%xmm3
punpckldq %xmm3,%xmm2
movd   0x14(%rsp),%xmm3
movd   0x10(%rsp),%xmm4
punpckldq %xmm4,%xmm3
punpcklqdq %xmm3,%xmm2
pcmpeqd 0x40(%rsp),%xmm2
punpcklqdq %xmm1,%xmm0
pcmpeqd 0x30(%rsp),%xmm0
packssdw %xmm2,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    200c <ModeTest+0xe3c>
mov    0xc(%rsp),%eax
cmp    %eax,0x50(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x8(%rsp),%eax
cmp    %eax,0x54(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r13d,0x58(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r12d,0x5c(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebp,0x60(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r14d,0x64(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebx,0x68(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x4(%rsp),%ecx
add    $0xffffffff,%ecx
jne    17b0 <ModeTest+0x5e0>
lea    0x1617(%rip),%rdi
call   1090 <printf@plt>
lea    0x78(%rsp),%rdi
call   1060 <MakeKey@plt>
mov    $0x19,%ecx
lea    0x1618(%rip),%rax
mov    %rax,0x80(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,0x4(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x2c(%rsp)
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x28(%rsp)
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x24(%rsp)
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x20(%rsp)
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x14(%rsp)
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0xc(%rsp)
mov    %eax,0x50(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x8(%rsp)
mov    %eax,0x54(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r13d
imul   %ebx,%r13d
mov    %r13d,0x58(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
imul   %ebp,%ebx
mov    %ebx,0x5c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r14d
imul   %ebp,%r14d
mov    %r14d,0x60(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
imul   %r12d,%ebp
mov    %ebp,0x64(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
imul   %r15d,%r12d
mov    %r12d,0x68(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %eax,%r15d
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   10d0 <IdeaOFB@plt>
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   10d0 <IdeaOFB@plt>
movd   0x2c(%rsp),%xmm0
movd   0x28(%rsp),%xmm1
punpckldq %xmm1,%xmm0
movd   0x24(%rsp),%xmm1
movd   0x20(%rsp),%xmm2
punpckldq %xmm2,%xmm1
movd   0x1c(%rsp),%xmm2
movd   0x18(%rsp),%xmm3
punpckldq %xmm3,%xmm2
movd   0x14(%rsp),%xmm3
movd   0x10(%rsp),%xmm4
punpckldq %xmm4,%xmm3
punpcklqdq %xmm3,%xmm2
pcmpeqd 0x40(%rsp),%xmm2
punpcklqdq %xmm1,%xmm0
pcmpeqd 0x30(%rsp),%xmm0
packssdw %xmm2,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    200c <ModeTest+0xe3c>
mov    0xc(%rsp),%eax
cmp    %eax,0x50(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x8(%rsp),%eax
cmp    %eax,0x54(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r13d,0x58(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebx,0x5c(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r14d,0x60(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebp,0x64(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r12d,0x68(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x4(%rsp),%ecx
add    $0xffffffff,%ecx
jne    1a90 <ModeTest+0x8c0>
lea    0x1366(%rip),%rdi
call   1090 <printf@plt>
lea    0x78(%rsp),%rdi
call   1060 <MakeKey@plt>
mov    $0x19,%ecx
lea    0x1367(%rip),%rax
mov    %rax,0x80(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,0x4(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x2c(%rsp)
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x28(%rsp)
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x24(%rsp)
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x20(%rsp)
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x14(%rsp)
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0xc(%rsp)
mov    %eax,0x50(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
imul   %ebx,%eax
mov    %eax,0x8(%rsp)
mov    %eax,0x54(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r13d
imul   %ebx,%r13d
mov    %r13d,0x58(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebx
imul   %ebp,%ebx
mov    %ebx,0x5c(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r14d
imul   %ebp,%r14d
mov    %r14d,0x60(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%ebp
imul   %r12d,%ebp
mov    %ebp,0x64(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r12d
imul   %r15d,%r12d
mov    %r12d,0x68(%rsp)
xor    %eax,%eax
call   10e0 <rand@plt>
mov    %eax,%r15d
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %eax,%edx
mov    $0xf,%ecx
call   1040 <IdeaCTR@plt>
lea    0x30(%rsp),%rdi
lea    0x78(%rsp),%rsi
mov    %r15d,%edx
mov    $0xf,%ecx
call   1040 <IdeaCTR@plt>
movd   0x2c(%rsp),%xmm0
movd   0x28(%rsp),%xmm1
punpckldq %xmm1,%xmm0
movd   0x24(%rsp),%xmm1
movd   0x20(%rsp),%xmm2
punpckldq %xmm2,%xmm1
movd   0x1c(%rsp),%xmm2
movd   0x18(%rsp),%xmm3
punpckldq %xmm3,%xmm2
movd   0x14(%rsp),%xmm3
movd   0x10(%rsp),%xmm4
punpckldq %xmm4,%xmm3
punpcklqdq %xmm3,%xmm2
pcmpeqd 0x40(%rsp),%xmm2
punpcklqdq %xmm1,%xmm0
pcmpeqd 0x30(%rsp),%xmm0
packssdw %xmm2,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    200c <ModeTest+0xe3c>
mov    0xc(%rsp),%eax
cmp    %eax,0x50(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x8(%rsp),%eax
cmp    %eax,0x54(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r13d,0x58(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebx,0x5c(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r14d,0x60(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %ebp,0x64(%rsp)
jne    200c <ModeTest+0xe3c>
cmp    %r12d,0x68(%rsp)
jne    200c <ModeTest+0xe3c>
mov    0x4(%rsp),%ecx
add    $0xffffffff,%ecx
jne    1d70 <ModeTest+0xba0>
lea    0x10e2(%rip),%rax
mov    %rax,0x80(%rsp)
movl   $0x0,(%rsp)
jmp    200c <ModeTest+0xe3c>
movl   $0x1,(%rsp)
mov    0x80(%rsp),%rdi
call   1090 <printf@plt>
mov    (%rsp),%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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