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

/* Variables and functions */
int /*<<< orphan*/ memcpy(int *, int *, int);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  int b[16], b2[16], x, y, z;
  for (x = 0; x < 16; x++)
    b[x] = x;
  printf("void saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, "
         "symmetric_key *skey)\n"
         "{\n"
         "   int x;\n"
         "   unsigned char b[16];\n"
         "\n"
         "   LTC_ARGCHK(pt   != NULL);\n"
         "   LTC_ARGCHK(ct   != NULL);\n"
         "   LTC_ARGCHK(skey != NULL);\n"
         "\n"
         "   /* do eight rounds */\n"
         "   for (x = 0; x < 16; x++) {\n"
         "       b[x] = pt[x];\n"
         "   }\n");
  for (x = 0; x < 8; x++) {
    for (y = 0; y < 16; y++) {
      printf("b[%d] = (safer_%cbox[(b[%d] %c skey->saferp.K[%d][%d]) & 255] %c "
             "skey->saferp.K[%d][%d]) & 255;\n",
             b[y], "elle"[y & 3], b[y], "^++^"[y & 3], x * 2, y, "+^^+"[y & 3],
             x * 2 + 1, y);
    }
    for (y = 0; y < 4; y++) {
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[0], b[0], b[1], b[0], b[1]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[2], b[2], b[3], b[3], b[2]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[4], b[4], b[5], b[5], b[4]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[6], b[6], b[7], b[7], b[6]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[8], b[8], b[9], b[9], b[8]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[10], b[10], b[11], b[11], b[10]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[12], b[12], b[13], b[13], b[12]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[14], b[14], b[15], b[15], b[14]);
      if (y < 3) {
        b2[0] = b[8];
        b2[1] = b[11];
        b2[2] = b[12];
        b2[3] = b[15];
        b2[4] = b[2];
        b2[5] = b[1];
        b2[6] = b[6];
        b2[7] = b[5];
        b2[8] = b[10];
        b2[9] = b[9];
        b2[10] = b[14];
        b2[11] = b[13];
        b2[12] = b[0];
        b2[13] = b[7];
        b2[14] = b[4];
        b2[15] = b[3];
        memcpy(b, b2, sizeof(b));
        ;
      }
    }
  }
  printf("   if (skey->saferp.rounds <= 8) {\n");
  for (x = 0; x < 16; x++) {
    printf("      ct[%d] = (b[%d] %c "
           "skey->saferp.K[skey->saferp.rounds*2][%d]) & 255;\n",
           x, b[x], "^++^"[x & 3], x);
  }
  printf("      return;\n   }\n");
  printf("   /* 192-bit key? */\n"
         "   if (skey->saferp.rounds > 8) {\n");
  for (x = 8; x < 12; x++) {
    for (y = 0; y < 16; y++) {
      printf("b[%d] = (safer_%cbox[(b[%d] %c skey->saferp.K[%d][%d]) & 255] %c "
             "skey->saferp.K[%d][%d]) & 255;\n",
             b[y], "elle"[y & 3], b[y], "^++^"[y & 3], x * 2, y, "+^^+"[y & 3],
             x * 2 + 1, y);
    }
    for (y = 0; y < 4; y++) {
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[0], b[0], b[1], b[0], b[1]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[2], b[2], b[3], b[3], b[2]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[4], b[4], b[5], b[5], b[4]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[6], b[6], b[7], b[7], b[6]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[8], b[8], b[9], b[9], b[8]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[10], b[10], b[11], b[11], b[10]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[12], b[12], b[13], b[13], b[12]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[14], b[14], b[15], b[15], b[14]);
      if (y < 3) {
        b2[0] = b[8];
        b2[1] = b[11];
        b2[2] = b[12];
        b2[3] = b[15];
        b2[4] = b[2];
        b2[5] = b[1];
        b2[6] = b[6];
        b2[7] = b[5];
        b2[8] = b[10];
        b2[9] = b[9];
        b2[10] = b[14];
        b2[11] = b[13];
        b2[12] = b[0];
        b2[13] = b[7];
        b2[14] = b[4];
        b2[15] = b[3];
        memcpy(b, b2, sizeof(b));
        ;
      }
    }
  }
  printf("}\n");
  printf("   if (skey->saferp.rounds <= 12) {\n");
  for (x = 0; x < 16; x++) {
    printf("      ct[%d] = (b[%d] %c "
           "skey->saferp.K[skey->saferp.rounds*2][%d]) & 255;\n",
           x, b[x], "^++^"[x & 3], x);
  }
  printf("      return;\n   }\n");
  printf("   /* 256-bit key? */\n"
         "   if (skey->saferp.rounds > 12) {\n");
  for (x = 12; x < 16; x++) {
    for (y = 0; y < 16; y++) {
      printf("b[%d] = (safer_%cbox[(b[%d] %c skey->saferp.K[%d][%d]) & 255] %c "
             "skey->saferp.K[%d][%d]) & 255;\n",
             b[y], "elle"[y & 3], b[y], "^++^"[y & 3], x * 2, y, "+^^+"[y & 3],
             x * 2 + 1, y);
    }
    for (y = 0; y < 4; y++) {
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[0], b[0], b[1], b[0], b[1]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[2], b[2], b[3], b[3], b[2]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[4], b[4], b[5], b[5], b[4]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[6], b[6], b[7], b[7], b[6]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[8], b[8], b[9], b[9], b[8]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[10], b[10], b[11], b[11], b[10]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[12], b[12], b[13], b[13], b[12]);
      printf("   b[%d]  = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\n",
             b[14], b[14], b[15], b[15], b[14]);
      if (y < 3) {
        b2[0] = b[8];
        b2[1] = b[11];
        b2[2] = b[12];
        b2[3] = b[15];
        b2[4] = b[2];
        b2[5] = b[1];
        b2[6] = b[6];
        b2[7] = b[5];
        b2[8] = b[10];
        b2[9] = b[9];
        b2[10] = b[14];
        b2[11] = b[13];
        b2[12] = b[0];
        b2[13] = b[7];
        b2[14] = b[4];
        b2[15] = b[3];
        memcpy(b, b2, sizeof(b));
        ;
      }
    }
  }
  for (x = 0; x < 16; x++) {
    printf("      ct[%d] = (b[%d] %c "
           "skey->saferp.K[skey->saferp.rounds*2][%d]) & 255;\n",
           x, b[x], "^++^"[x & 3], x);
  }
  printf("   return;\n");
  printf("   }\n}\n\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xb8,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    116f <main+0x4f>
mov    -0x94(%rbp),%ecx
movslq -0x94(%rbp),%rax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    113d <main+0x1d>
lea    0xe8a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x94(%rbp)
cmpl   $0x8,-0x94(%rbp)
jge    1430 <main+0x310>
movl   $0x0,-0x98(%rbp)
cmpl   $0x10,-0x98(%rbp)
jge    1261 <main+0x141>
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0xfc0(%rip),%rax
movsbl (%rax,%rcx,1),%edx
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0xfa3(%rip),%rax
movsbl (%rax,%rdi,1),%r8d
mov    -0x94(%rbp),%r9d
shl    $0x1,%r9d
mov    -0x98(%rbp),%ebx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0xf7f(%rip),%rax
movsbl (%rax,%rdi,1),%r11d
mov    -0x94(%rbp),%r10d
shl    $0x1,%r10d
add    $0x1,%r10d
mov    -0x98(%rbp),%eax
lea    0xef3(%rip),%rdi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    119e <main+0x7e>
movl   $0x0,-0x98(%rbp)
cmpl   $0x4,-0x98(%rbp)
jge    1417 <main+0x2f7>
mov    -0x50(%rbp),%esi
mov    -0x50(%rbp),%edx
mov    -0x4c(%rbp),%ecx
mov    -0x50(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
lea    0xf08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x48(%rbp),%esi
mov    -0x48(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    -0x44(%rbp),%r8d
mov    -0x48(%rbp),%r9d
lea    0xee9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%r9d
lea    0xeca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%r8d
mov    -0x38(%rbp),%r9d
lea    0xeab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
lea    0xe8c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
lea    0xe6d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
lea    0xe4e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x18(%rbp),%r9d
lea    0xe2f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x3,-0x98(%rbp)
jge    13fe <main+0x2de>
mov    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
lea    -0x50(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
jmp    1403 <main+0x2e3>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    126b <main+0x14b>
jmp    141c <main+0x2fc>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1187 <main+0x67>
lea    0xd9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    14a6 <main+0x386>
mov    -0x94(%rbp),%esi
movslq -0x94(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%edx
mov    -0x94(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0xd15(%rip),%rax
movsbl (%rax,%rcx,1),%ecx
mov    -0x94(%rbp),%r8d
lea    0xd6f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1448 <main+0x328>
lea    0xd99(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x8,-0x94(%rbp)
cmpl   $0xc,-0x94(%rbp)
jge    1775 <main+0x655>
movl   $0x0,-0x98(%rbp)
cmpl   $0x10,-0x98(%rbp)
jge    15a6 <main+0x486>
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0xc7b(%rip),%rax
movsbl (%rax,%rcx,1),%edx
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0xc5e(%rip),%rax
movsbl (%rax,%rdi,1),%r8d
mov    -0x94(%rbp),%r9d
shl    $0x1,%r9d
mov    -0x98(%rbp),%ebx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0xc3a(%rip),%rax
movsbl (%rax,%rdi,1),%r11d
mov    -0x94(%rbp),%r10d
shl    $0x1,%r10d
add    $0x1,%r10d
mov    -0x98(%rbp),%eax
lea    0xbae(%rip),%rdi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    14e3 <main+0x3c3>
movl   $0x0,-0x98(%rbp)
cmpl   $0x4,-0x98(%rbp)
jge    175c <main+0x63c>
mov    -0x50(%rbp),%esi
mov    -0x50(%rbp),%edx
mov    -0x4c(%rbp),%ecx
mov    -0x50(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
lea    0xbc3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x48(%rbp),%esi
mov    -0x48(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    -0x44(%rbp),%r8d
mov    -0x48(%rbp),%r9d
lea    0xba4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%r9d
lea    0xb85(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%r8d
mov    -0x38(%rbp),%r9d
lea    0xb66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
lea    0xb47(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
lea    0xb28(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
lea    0xb09(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x18(%rbp),%r9d
lea    0xaea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x3,-0x98(%rbp)
jge    1743 <main+0x623>
mov    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
lea    -0x50(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
jmp    1748 <main+0x628>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15b0 <main+0x490>
jmp    1761 <main+0x641>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    14cc <main+0x3ac>
lea    0x9a9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xb09(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    17f9 <main+0x6d9>
mov    -0x94(%rbp),%esi
movslq -0x94(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%edx
mov    -0x94(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x9c2(%rip),%rax
movsbl (%rax,%rcx,1),%ecx
mov    -0x94(%rbp),%r8d
lea    0xa1c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    179b <main+0x67b>
lea    0xa46(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xaaa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xc,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    1ac8 <main+0x9a8>
movl   $0x0,-0x98(%rbp)
cmpl   $0x10,-0x98(%rbp)
jge    18f9 <main+0x7d9>
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x928(%rip),%rax
movsbl (%rax,%rcx,1),%edx
movslq -0x98(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0x90b(%rip),%rax
movsbl (%rax,%rdi,1),%r8d
mov    -0x94(%rbp),%r9d
shl    $0x1,%r9d
mov    -0x98(%rbp),%ebx
mov    -0x98(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rdi
lea    0x8e7(%rip),%rax
movsbl (%rax,%rdi,1),%r11d
mov    -0x94(%rbp),%r10d
shl    $0x1,%r10d
add    $0x1,%r10d
mov    -0x98(%rbp),%eax
lea    0x85b(%rip),%rdi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1836 <main+0x716>
movl   $0x0,-0x98(%rbp)
cmpl   $0x4,-0x98(%rbp)
jge    1aaf <main+0x98f>
mov    -0x50(%rbp),%esi
mov    -0x50(%rbp),%edx
mov    -0x4c(%rbp),%ecx
mov    -0x50(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
lea    0x870(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x48(%rbp),%esi
mov    -0x48(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    -0x44(%rbp),%r8d
mov    -0x48(%rbp),%r9d
lea    0x851(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%r9d
lea    0x832(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%r8d
mov    -0x38(%rbp),%r9d
lea    0x813(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
lea    0x7f4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
lea    0x7d5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
lea    0x7b6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x18(%rbp),%r9d
lea    0x797(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x3,-0x98(%rbp)
jge    1a96 <main+0x976>
mov    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
lea    -0x50(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
jmp    1a9b <main+0x97b>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1903 <main+0x7e3>
jmp    1ab4 <main+0x994>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    181f <main+0x6ff>
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    1b30 <main+0xa10>
mov    -0x94(%rbp),%esi
movslq -0x94(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%edx
mov    -0x94(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x68b(%rip),%rax
movsbl (%rax,%rcx,1),%ecx
mov    -0x94(%rbp),%r8d
lea    0x6e5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1ad2 <main+0x9b2>
lea    0x7bb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x7b9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movaps 0x1eb8(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0x1ebd(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0x1ec1(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0x1ec5(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
lea    0x1fb4(%rip),%rdi
call   1030 <puts@plt>
lea    0x1f1e(%rip),%rbx
mov    %rsp,%r15
lea    0x50(%rsp),%r12
xor    %ecx,%ecx
xor    %eax,%eax
nop
lea    (%rax,%rax,1),%ebp
mov    %rax,0x48(%rsp)
lea    (%rax,%rax,1),%r14d
add    $0x1,%r14d
lea    0x1e99(%rip),%r13
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x0
push   %r14
push   $0x2b
push   $0x0
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x4(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x1
push   %r14
push   $0x5e
push   $0x1
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x2
push   %r14
push   $0x5e
push   $0x2
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0xc(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x3
push   %r14
push   $0x2b
push   $0x3
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x10(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x4
push   %r14
push   $0x2b
push   $0x4
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x14(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x5
push   %r14
push   $0x5e
push   $0x5
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x18(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x6
push   %r14
push   $0x5e
push   $0x6
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x1c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x7
push   %r14
push   $0x2b
push   $0x7
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x8
push   %r14
push   $0x2b
push   $0x8
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x24(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0x9
push   %r14
push   $0x5e
push   $0x9
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x28(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xa
push   %r14
push   $0x5e
push   $0xa
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x2c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xb
push   %r14
push   $0x2b
push   $0xb
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x30(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xc
push   %r14
push   $0x2b
push   $0xc
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x34(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xd
push   %r14
push   $0x5e
push   $0xd
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x38(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xe
push   %r14
push   $0x5e
push   $0xe
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x3c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
push   $0xf
push   %r14
push   $0x2b
push   $0xf
call   1040 <printf@plt>
add    $0x20,%rsp
mov    $0x3,%ebp
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%edx
mov    0x4(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %edx,%r8d
mov    %ecx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    0xc(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    0x1c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    0x34(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    0x3c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
sub    $0x1,%ebp
jb     15b0 <main+0x480>
mov    0x20(%rsp),%eax
mov    %eax,0x50(%rsp)
mov    0x2c(%rsp),%rax
mov    %rax,0x54(%rsp)
mov    0x3c(%rsp),%eax
mov    %eax,0x5c(%rsp)
movsd  0x4(%rsp),%xmm0
movsd  0x14(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
movsd  0x24(%rsp),%xmm0
movsd  0x34(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x70(%rsp)
mov    (%rsp),%eax
mov    0x10(%rsp),%ecx
mov    %eax,0x80(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x84(%rsp)
mov    %ecx,0x88(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    %r15,%rdi
mov    %r12,%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
jmp    1450 <main+0x320>
nopl   0x0(%rax)
mov    0x48(%rsp),%rax
add    $0x1,%eax
cmp    $0x8,%eax
je     15c5 <main+0x495>
mov    (%rsp),%ecx
jmp    1190 <main+0x60>
lea    0x1c86(%rip),%rdi
call   1030 <puts@plt>
mov    (%rsp),%edx
lea    0x1b04(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x5e,%ecx
xor    %r8d,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%edx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2b,%ecx
mov    $0x1,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2b,%ecx
mov    $0x2,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%edx
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x5e,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x5e,%ecx
mov    $0x4,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%edx
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x2b,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x2b,%ecx
mov    $0x6,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%edx
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x5e,%ecx
mov    $0x7,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    $0x8,%ebp
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x5e,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%edx
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x2b,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x2b,%ecx
mov    $0xa,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0x5e,%ecx
mov    $0xb,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0x5e,%ecx
mov    $0xc,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%edx
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0x2b,%ecx
mov    $0xd,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    %rbx,%rdi
mov    $0xe,%esi
mov    $0x2b,%ecx
mov    $0xe,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xf,%esi
mov    $0x5e,%ecx
mov    $0xf,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1b14(%rip),%rdi
call   1030 <puts@plt>
lea    0x1aac(%rip),%rdi
call   1030 <puts@plt>
lea    0x18cc(%rip),%rbx
mov    %rsp,%r15
lea    0x50(%rsp),%r12
jmp    17f1 <main+0x6c1>
nop
mov    0x48(%rsp),%rbp
add    $0x1,%ebp
cmp    $0xc,%ebp
je     1c0c <main+0xadc>
lea    0x0(%rbp,%rbp,1),%r14d
mov    %rbp,0x48(%rsp)
lea    0x1(%rbp,%rbp,1),%r13d
mov    (%rsp),%ecx
lea    0x1836(%rip),%rbp
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x0
push   %r13
push   $0x2b
push   $0x0
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x4(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x1
push   %r13
push   $0x5e
push   $0x1
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x2
push   %r13
push   $0x5e
push   $0x2
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0xc(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x3
push   %r13
push   $0x2b
push   $0x3
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x10(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x4
push   %r13
push   $0x2b
push   $0x4
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x14(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x5
push   %r13
push   $0x5e
push   $0x5
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x18(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x6
push   %r13
push   $0x5e
push   $0x6
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x1c(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x7
push   %r13
push   $0x2b
push   $0x7
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x8
push   %r13
push   $0x2b
push   $0x8
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x24(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0x9
push   %r13
push   $0x5e
push   $0x9
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x28(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xa
push   %r13
push   $0x5e
push   $0xa
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x2c(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xb
push   %r13
push   $0x2b
push   $0xb
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x30(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xc
push   %r13
push   $0x2b
push   $0xc
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x34(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xd
push   %r13
push   $0x5e
push   $0xd
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x38(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xe
push   %r13
push   $0x5e
push   $0xe
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x3c(%rsp),%ecx
mov    %rbp,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
push   $0xf
push   %r13
push   $0x2b
push   $0xf
call   1040 <printf@plt>
add    $0x20,%rsp
mov    $0x3,%ebp
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%edx
mov    0x4(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %edx,%r8d
mov    %ecx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    0xc(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    0x1c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    0x34(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    0x3c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
sub    $0x1,%ebp
jb     17e0 <main+0x6b0>
mov    0x20(%rsp),%eax
mov    %eax,0x50(%rsp)
mov    0x2c(%rsp),%rax
mov    %rax,0x54(%rsp)
mov    0x3c(%rsp),%eax
mov    %eax,0x5c(%rsp)
movsd  0x4(%rsp),%xmm0
movsd  0x14(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
movsd  0x24(%rsp),%xmm0
movsd  0x34(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x70(%rsp)
mov    (%rsp),%eax
mov    0x10(%rsp),%ecx
mov    %eax,0x80(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x84(%rsp)
mov    %ecx,0x88(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    %r15,%rdi
mov    %r12,%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
jmp    1ab0 <main+0x980>
lea    0x163d(%rip),%rdi
call   1030 <puts@plt>
lea    0x168e(%rip),%rdi
call   1030 <puts@plt>
mov    (%rsp),%edx
lea    0x14b1(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x5e,%ecx
xor    %r8d,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%edx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2b,%ecx
mov    $0x1,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2b,%ecx
mov    $0x2,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%edx
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x5e,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x5e,%ecx
mov    $0x4,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%edx
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x2b,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x2b,%ecx
mov    $0x6,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%edx
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x5e,%ecx
mov    $0x7,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x5e,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%edx
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x2b,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x2b,%ecx
mov    $0xa,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0x5e,%ecx
mov    $0xb,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    $0xc,%ebp
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0x5e,%ecx
mov    $0xc,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%edx
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0x2b,%ecx
mov    $0xd,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    %rbx,%rdi
mov    $0xe,%esi
mov    $0x2b,%ecx
mov    $0xe,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xf,%esi
mov    $0x5e,%ecx
mov    $0xf,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x14c1(%rip),%rdi
call   1030 <puts@plt>
lea    0x14c8(%rip),%rdi
call   1030 <puts@plt>
lea    0x1279(%rip),%rbx
lea    0x50(%rsp),%r12
jmp    1e41 <main+0xd11>
nop
mov    0x48(%rsp),%rbp
add    $0x1,%ebp
cmp    $0x10,%ebp
je     225c <main+0x112c>
lea    0x0(%rbp,%rbp,1),%r15d
mov    %rbp,0x48(%rsp)
lea    0x1(%rbp,%rbp,1),%r14d
mov    (%rsp),%ecx
lea    0x11e6(%rip),%r13
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x0
push   %r14
push   $0x2b
push   $0x0
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x4(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x1
push   %r14
push   $0x5e
push   $0x1
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x2
push   %r14
push   $0x5e
push   $0x2
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0xc(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x3
push   %r14
push   $0x2b
push   $0x3
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x10(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x4
push   %r14
push   $0x2b
push   $0x4
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x14(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x5
push   %r14
push   $0x5e
push   $0x5
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x18(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x6
push   %r14
push   $0x5e
push   $0x6
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x1c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x7
push   %r14
push   $0x2b
push   $0x7
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x8
push   %r14
push   $0x2b
push   $0x8
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x24(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0x9
push   %r14
push   $0x5e
push   $0x9
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x28(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xa
push   %r14
push   $0x5e
push   $0xa
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x2c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xb
push   %r14
push   $0x2b
push   $0xb
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x30(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xc
push   %r14
push   $0x2b
push   $0xc
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x34(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xd
push   %r14
push   $0x5e
push   $0xd
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x38(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x6c,%edx
mov    $0x2b,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xe
push   %r14
push   $0x5e
push   $0xe
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0x3c(%rsp),%ecx
mov    %r13,%rdi
mov    %ecx,%esi
mov    $0x65,%edx
mov    $0x5e,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   $0xf
push   %r14
lea    0x10(%rsp),%r14
push   $0x2b
push   $0xf
call   1040 <printf@plt>
add    $0x20,%rsp
mov    $0x3,%ebp
mov    (%rsp),%edx
mov    0x4(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %edx,%r8d
mov    %ecx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    0xc(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    0x1c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    0x34(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    0x3c(%rsp),%ecx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%r8d
mov    %edx,%r9d
xor    %eax,%eax
call   1040 <printf@plt>
sub    $0x1,%ebp
jb     1e30 <main+0xd00>
mov    0x20(%rsp),%eax
mov    %eax,0x50(%rsp)
mov    0x2c(%rsp),%rax
mov    %rax,0x54(%rsp)
mov    0x3c(%rsp),%eax
mov    %eax,0x5c(%rsp)
movsd  0x4(%rsp),%xmm0
movsd  0x14(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
movsd  0x24(%rsp),%xmm0
movsd  0x34(%rsp),%xmm1
shufps $0x11,%xmm1,%xmm0
movaps %xmm0,0x70(%rsp)
mov    (%rsp),%eax
mov    0x10(%rsp),%ecx
mov    %eax,0x80(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x84(%rsp)
mov    %ecx,0x88(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    %r14,%rdi
mov    %r12,%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
jmp    2100 <main+0xfd0>
mov    (%rsp),%edx
lea    0xe79(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x5e,%ecx
xor    %r8d,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%edx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2b,%ecx
mov    $0x1,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%edx
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2b,%ecx
mov    $0x2,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%edx
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x5e,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%edx
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x5e,%ecx
mov    $0x4,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%edx
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x2b,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x2b,%ecx
mov    $0x6,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%edx
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x5e,%ecx
mov    $0x7,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x5e,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%edx
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x2b,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x2b,%ecx
mov    $0xa,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0x5e,%ecx
mov    $0xb,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0x5e,%ecx
mov    $0xc,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%edx
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0x2b,%ecx
mov    $0xd,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%edx
mov    %rbx,%rdi
mov    $0xe,%esi
mov    $0x2b,%ecx
mov    $0xe,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%edx
mov    %rbx,%rdi
mov    $0xf,%esi
mov    $0x5e,%ecx
mov    $0xf,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeda(%rip),%rdi
call   1030 <puts@plt>
lea    0xed9(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [296 x i8] c"void saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)\0A{\0A int x;\0A unsigned char b[16];\0A\0A LTC_ARGCHK(pt != NULL);\0A LTC_ARGCHK(ct != NULL);\0A LTC_ARGCHK(skey != NULL);\0A\0A /* do eight rounds */\0A for (x = 0; x < 16; x++) {\0A b[x] = pt[x];\0A }\0A\00"
@.str.1 = [97 x i8] c"b[%d] = (safer_%cbox[(b[%d] %c skey->saferp.K[%d][%d]) & 255] %c skey->saferp.K[%d][%d]) & 255;\0A\00"
@.str.2 = [5 x i8] c"elle\00"
@.str.3 = [5 x i8] c"^++^\00"
@.str.4 = [5 x i8] c"+^^+\00"
@.str.5 = [62 x i8] c" b[%d] = (b[%d] + (b[%d] = (b[%d] + b[%d]) & 255)) & 255;\0A\00"
@.str.6 = [36 x i8] c" if (skey->saferp.rounds <= 8) {\0A\00"
@.str.7 = [76 x i8] c" ct[%d] = (b[%d] %c skey->saferp.K[skey->saferp.rounds*2][%d]) & 255;\0A\00"
@.str.8 = [20 x i8] c" return;\0A }\0A\00"
@.str.9 = [57 x i8] c" /* 192-bit key? */\0A if (skey->saferp.rounds > 8) {\0A\00"
@.str.10 = [3 x i8] c"}\0A\00"
@.str.11 = [37 x i8] c" if (skey->saferp.rounds <= 12) {\0A\00"
@.str.12 = [58 x i8] c" /* 256-bit key? */\0A if (skey->saferp.rounds > 12) {\0A\00"
@.str.13 = [12 x i8] c" return;\0A\00"
@.str.14 = [9 x i8] c" }\0A}\0A\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [16 x i32]
%3 = alloca [16 x i32]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %4
br label %7
7: ; preds = %15, %0
%8 = load i32, i32* %4
%9 = icmp slt i32 %8, 16
br i1 %9, label %10, label %18
10: ; preds = %7
%11 = load i32, i32* %4
%12 = load i32, i32* %4
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %13
store i32 %11, i32* %14
br label %15
15: ; preds = %10
%16 = load i32, i32* %4
%17 = add nsw i32 %16, 1
store i32 %17, i32* %4
br label %7
18: ; preds = %7
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([296 x i8], [296 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %4
br label %20
20: ; preds = %217, %18
%21 = load i32, i32* %4
%22 = icmp slt i32 %21, 8
br i1 %22, label %23, label %220
23: ; preds = %20
store i32 0, i32* %5
br label %24
24: ; preds = %62, %23
%25 = load i32, i32* %5
%26 = icmp slt i32 %25, 16
br i1 %26, label %27, label %65
27: ; preds = %24
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %29
%31 = load i32, i32* %30
%32 = load i32, i32* %5
%33 = and i32 %32, 3
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.2, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = load i32, i32* %5
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %39
%41 = load i32, i32* %40
%42 = load i32, i32* %5
%43 = and i32 %42, 3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = load i32, i32* %4
%49 = mul nsw i32 %48, 2
%50 = load i32, i32* %5
%51 = load i32, i32* %5
%52 = and i32 %51, 3
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.4, i64 0, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = load i32, i32* %4
%58 = mul nsw i32 %57, 2
%59 = add nsw i32 %58, 1
%60 = load i32, i32* %5
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.1, i64 0, i64 0), i32 %31, i32 %37, i32 %41, i32 %47, i32 %49, i32 %50, i32 %56, i32 %59, i32 %60)
br label %62
62: ; preds = %27
%63 = load i32, i32* %5
%64 = add nsw i32 %63, 1
store i32 %64, i32* %5
br label %24
65: ; preds = %24
store i32 0, i32* %5
br label %66
66: ; preds = %213, %65
%67 = load i32, i32* %5
%68 = icmp slt i32 %67, 4
br i1 %68, label %69, label %216
69: ; preds = %66
%70 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%71 = load i32, i32* %70
%72 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%73 = load i32, i32* %72
%74 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%75 = load i32, i32* %74
%76 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%77 = load i32, i32* %76
%78 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%79 = load i32, i32* %78
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %71, i32 %73, i32 %75, i32 %77, i32 %79)
%81 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%82 = load i32, i32* %81
%83 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%84 = load i32, i32* %83
%85 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%86 = load i32, i32* %85
%87 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%88 = load i32, i32* %87
%89 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%90 = load i32, i32* %89
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %82, i32 %84, i32 %86, i32 %88, i32 %90)
%92 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%93 = load i32, i32* %92
%94 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%95 = load i32, i32* %94
%96 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%97 = load i32, i32* %96
%98 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%99 = load i32, i32* %98
%100 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%101 = load i32, i32* %100
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %93, i32 %95, i32 %97, i32 %99, i32 %101)
%103 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%104 = load i32, i32* %103
%105 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%106 = load i32, i32* %105
%107 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%108 = load i32, i32* %107
%109 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%110 = load i32, i32* %109
%111 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%112 = load i32, i32* %111
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %104, i32 %106, i32 %108, i32 %110, i32 %112)
%114 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%115 = load i32, i32* %114
%116 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%117 = load i32, i32* %116
%118 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%119 = load i32, i32* %118
%120 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%121 = load i32, i32* %120
%122 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%123 = load i32, i32* %122
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %115, i32 %117, i32 %119, i32 %121, i32 %123)
%125 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%126 = load i32, i32* %125
%127 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%128 = load i32, i32* %127
%129 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%130 = load i32, i32* %129
%131 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%132 = load i32, i32* %131
%133 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%134 = load i32, i32* %133
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %126, i32 %128, i32 %130, i32 %132, i32 %134)
%136 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%137 = load i32, i32* %136
%138 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%139 = load i32, i32* %138
%140 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%141 = load i32, i32* %140
%142 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%143 = load i32, i32* %142
%144 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%145 = load i32, i32* %144
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %137, i32 %139, i32 %141, i32 %143, i32 %145)
%147 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%148 = load i32, i32* %147
%149 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%150 = load i32, i32* %149
%151 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%152 = load i32, i32* %151
%153 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%154 = load i32, i32* %153
%155 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%156 = load i32, i32* %155
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %148, i32 %150, i32 %152, i32 %154, i32 %156)
%158 = load i32, i32* %5
%159 = icmp slt i32 %158, 3
br i1 %159, label %160, label %212
160: ; preds = %69
%161 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%162 = load i32, i32* %161
%163 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
store i32 %162, i32* %163
%164 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%165 = load i32, i32* %164
%166 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 1
store i32 %165, i32* %166
%167 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%168 = load i32, i32* %167
%169 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 2
store i32 %168, i32* %169
%170 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%171 = load i32, i32* %170
%172 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 3
store i32 %171, i32* %172
%173 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%174 = load i32, i32* %173
%175 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 4
store i32 %174, i32* %175
%176 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%177 = load i32, i32* %176
%178 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 5
store i32 %177, i32* %178
%179 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%180 = load i32, i32* %179
%181 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 6
store i32 %180, i32* %181
%182 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%183 = load i32, i32* %182
%184 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 7
store i32 %183, i32* %184
%185 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%186 = load i32, i32* %185
%187 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 8
store i32 %186, i32* %187
%188 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%189 = load i32, i32* %188
%190 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 9
store i32 %189, i32* %190
%191 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%192 = load i32, i32* %191
%193 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 10
store i32 %192, i32* %193
%194 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%195 = load i32, i32* %194
%196 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 11
store i32 %195, i32* %196
%197 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%198 = load i32, i32* %197
%199 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 12
store i32 %198, i32* %199
%200 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%201 = load i32, i32* %200
%202 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 13
store i32 %201, i32* %202
%203 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%204 = load i32, i32* %203
%205 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 14
store i32 %204, i32* %205
%206 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%207 = load i32, i32* %206
%208 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 15
store i32 %207, i32* %208
%209 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%210 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
%211 = call i32 @memcpy(i32* %209, i32* %210, i32 64)
br label %212
212: ; preds = %160, %69
br label %213
213: ; preds = %212
%214 = load i32, i32* %5
%215 = add nsw i32 %214, 1
store i32 %215, i32* %5
br label %66
216: ; preds = %66
br label %217
217: ; preds = %216
%218 = load i32, i32* %4
%219 = add nsw i32 %218, 1
store i32 %219, i32* %4
br label %20
220: ; preds = %20
%221 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %4
br label %222
222: ; preds = %239, %220
%223 = load i32, i32* %4
%224 = icmp slt i32 %223, 16
br i1 %224, label %225, label %242
225: ; preds = %222
%226 = load i32, i32* %4
%227 = load i32, i32* %4
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = load i32, i32* %4
%232 = and i32 %231, 3
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %233
%235 = load i8, i8* %234
%236 = sext i8 %235 to i32
%237 = load i32, i32* %4
%238 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.7, i64 0, i64 0), i32 %226, i32 %230, i32 %236, i32 %237)
br label %239
239: ; preds = %225
%240 = load i32, i32* %4
%241 = add nsw i32 %240, 1
store i32 %241, i32* %4
br label %222
242: ; preds = %222
%243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.8, i64 0, i64 0))
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.9, i64 0, i64 0))
store i32 8, i32* %4
br label %245
245: ; preds = %442, %242
%246 = load i32, i32* %4
%247 = icmp slt i32 %246, 12
br i1 %247, label %248, label %445
248: ; preds = %245
store i32 0, i32* %5
br label %249
249: ; preds = %287, %248
%250 = load i32, i32* %5
%251 = icmp slt i32 %250, 16
br i1 %251, label %252, label %290
252: ; preds = %249
%253 = load i32, i32* %5
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %254
%256 = load i32, i32* %255
%257 = load i32, i32* %5
%258 = and i32 %257, 3
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.2, i64 0, i64 %259
%261 = load i8, i8* %260
%262 = sext i8 %261 to i32
%263 = load i32, i32* %5
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %264
%266 = load i32, i32* %265
%267 = load i32, i32* %5
%268 = and i32 %267, 3
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %269
%271 = load i8, i8* %270
%272 = sext i8 %271 to i32
%273 = load i32, i32* %4
%274 = mul nsw i32 %273, 2
%275 = load i32, i32* %5
%276 = load i32, i32* %5
%277 = and i32 %276, 3
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.4, i64 0, i64 %278
%280 = load i8, i8* %279
%281 = sext i8 %280 to i32
%282 = load i32, i32* %4
%283 = mul nsw i32 %282, 2
%284 = add nsw i32 %283, 1
%285 = load i32, i32* %5
%286 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.1, i64 0, i64 0), i32 %256, i32 %262, i32 %266, i32 %272, i32 %274, i32 %275, i32 %281, i32 %284, i32 %285)
br label %287
287: ; preds = %252
%288 = load i32, i32* %5
%289 = add nsw i32 %288, 1
store i32 %289, i32* %5
br label %249
290: ; preds = %249
store i32 0, i32* %5
br label %291
291: ; preds = %438, %290
%292 = load i32, i32* %5
%293 = icmp slt i32 %292, 4
br i1 %293, label %294, label %441
294: ; preds = %291
%295 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%296 = load i32, i32* %295
%297 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%298 = load i32, i32* %297
%299 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%300 = load i32, i32* %299
%301 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%302 = load i32, i32* %301
%303 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%304 = load i32, i32* %303
%305 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %296, i32 %298, i32 %300, i32 %302, i32 %304)
%306 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%307 = load i32, i32* %306
%308 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%309 = load i32, i32* %308
%310 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%311 = load i32, i32* %310
%312 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%313 = load i32, i32* %312
%314 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%315 = load i32, i32* %314
%316 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %307, i32 %309, i32 %311, i32 %313, i32 %315)
%317 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%318 = load i32, i32* %317
%319 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%320 = load i32, i32* %319
%321 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%322 = load i32, i32* %321
%323 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%324 = load i32, i32* %323
%325 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%326 = load i32, i32* %325
%327 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %318, i32 %320, i32 %322, i32 %324, i32 %326)
%328 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%329 = load i32, i32* %328
%330 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%331 = load i32, i32* %330
%332 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%333 = load i32, i32* %332
%334 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%335 = load i32, i32* %334
%336 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%337 = load i32, i32* %336
%338 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %329, i32 %331, i32 %333, i32 %335, i32 %337)
%339 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%340 = load i32, i32* %339
%341 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%342 = load i32, i32* %341
%343 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%344 = load i32, i32* %343
%345 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%346 = load i32, i32* %345
%347 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%348 = load i32, i32* %347
%349 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %340, i32 %342, i32 %344, i32 %346, i32 %348)
%350 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%351 = load i32, i32* %350
%352 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%353 = load i32, i32* %352
%354 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%355 = load i32, i32* %354
%356 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%357 = load i32, i32* %356
%358 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%359 = load i32, i32* %358
%360 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %351, i32 %353, i32 %355, i32 %357, i32 %359)
%361 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%362 = load i32, i32* %361
%363 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%364 = load i32, i32* %363
%365 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%366 = load i32, i32* %365
%367 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%368 = load i32, i32* %367
%369 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%370 = load i32, i32* %369
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %362, i32 %364, i32 %366, i32 %368, i32 %370)
%372 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%373 = load i32, i32* %372
%374 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%375 = load i32, i32* %374
%376 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%377 = load i32, i32* %376
%378 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%379 = load i32, i32* %378
%380 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%381 = load i32, i32* %380
%382 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %373, i32 %375, i32 %377, i32 %379, i32 %381)
%383 = load i32, i32* %5
%384 = icmp slt i32 %383, 3
br i1 %384, label %385, label %437
385: ; preds = %294
%386 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%387 = load i32, i32* %386
%388 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
store i32 %387, i32* %388
%389 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%390 = load i32, i32* %389
%391 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 1
store i32 %390, i32* %391
%392 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%393 = load i32, i32* %392
%394 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 2
store i32 %393, i32* %394
%395 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%396 = load i32, i32* %395
%397 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 3
store i32 %396, i32* %397
%398 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%399 = load i32, i32* %398
%400 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 4
store i32 %399, i32* %400
%401 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%402 = load i32, i32* %401
%403 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 5
store i32 %402, i32* %403
%404 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%405 = load i32, i32* %404
%406 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 6
store i32 %405, i32* %406
%407 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%408 = load i32, i32* %407
%409 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 7
store i32 %408, i32* %409
%410 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%411 = load i32, i32* %410
%412 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 8
store i32 %411, i32* %412
%413 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%414 = load i32, i32* %413
%415 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 9
store i32 %414, i32* %415
%416 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%417 = load i32, i32* %416
%418 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 10
store i32 %417, i32* %418
%419 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%420 = load i32, i32* %419
%421 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 11
store i32 %420, i32* %421
%422 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%423 = load i32, i32* %422
%424 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 12
store i32 %423, i32* %424
%425 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%426 = load i32, i32* %425
%427 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 13
store i32 %426, i32* %427
%428 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%429 = load i32, i32* %428
%430 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 14
store i32 %429, i32* %430
%431 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%432 = load i32, i32* %431
%433 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 15
store i32 %432, i32* %433
%434 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%435 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
%436 = call i32 @memcpy(i32* %434, i32* %435, i32 64)
br label %437
437: ; preds = %385, %294
br label %438
438: ; preds = %437
%439 = load i32, i32* %5
%440 = add nsw i32 %439, 1
store i32 %440, i32* %5
br label %291
441: ; preds = %291
br label %442
442: ; preds = %441
%443 = load i32, i32* %4
%444 = add nsw i32 %443, 1
store i32 %444, i32* %4
br label %245
445: ; preds = %245
%446 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%447 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %4
br label %448
448: ; preds = %465, %445
%449 = load i32, i32* %4
%450 = icmp slt i32 %449, 16
br i1 %450, label %451, label %468
451: ; preds = %448
%452 = load i32, i32* %4
%453 = load i32, i32* %4
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %454
%456 = load i32, i32* %455
%457 = load i32, i32* %4
%458 = and i32 %457, 3
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %459
%461 = load i8, i8* %460
%462 = sext i8 %461 to i32
%463 = load i32, i32* %4
%464 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.7, i64 0, i64 0), i32 %452, i32 %456, i32 %462, i32 %463)
br label %465
465: ; preds = %451
%466 = load i32, i32* %4
%467 = add nsw i32 %466, 1
store i32 %467, i32* %4
br label %448
468: ; preds = %448
%469 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.8, i64 0, i64 0))
%470 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
store i32 12, i32* %4
br label %471
471: ; preds = %668, %468
%472 = load i32, i32* %4
%473 = icmp slt i32 %472, 16
br i1 %473, label %474, label %671
474: ; preds = %471
store i32 0, i32* %5
br label %475
475: ; preds = %513, %474
%476 = load i32, i32* %5
%477 = icmp slt i32 %476, 16
br i1 %477, label %478, label %516
478: ; preds = %475
%479 = load i32, i32* %5
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %480
%482 = load i32, i32* %481
%483 = load i32, i32* %5
%484 = and i32 %483, 3
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.2, i64 0, i64 %485
%487 = load i8, i8* %486
%488 = sext i8 %487 to i32
%489 = load i32, i32* %5
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %490
%492 = load i32, i32* %491
%493 = load i32, i32* %5
%494 = and i32 %493, 3
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %495
%497 = load i8, i8* %496
%498 = sext i8 %497 to i32
%499 = load i32, i32* %4
%500 = mul nsw i32 %499, 2
%501 = load i32, i32* %5
%502 = load i32, i32* %5
%503 = and i32 %502, 3
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.4, i64 0, i64 %504
%506 = load i8, i8* %505
%507 = sext i8 %506 to i32
%508 = load i32, i32* %4
%509 = mul nsw i32 %508, 2
%510 = add nsw i32 %509, 1
%511 = load i32, i32* %5
%512 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.1, i64 0, i64 0), i32 %482, i32 %488, i32 %492, i32 %498, i32 %500, i32 %501, i32 %507, i32 %510, i32 %511)
br label %513
513: ; preds = %478
%514 = load i32, i32* %5
%515 = add nsw i32 %514, 1
store i32 %515, i32* %5
br label %475
516: ; preds = %475
store i32 0, i32* %5
br label %517
517: ; preds = %664, %516
%518 = load i32, i32* %5
%519 = icmp slt i32 %518, 4
br i1 %519, label %520, label %667
520: ; preds = %517
%521 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%522 = load i32, i32* %521
%523 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%524 = load i32, i32* %523
%525 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%526 = load i32, i32* %525
%527 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%528 = load i32, i32* %527
%529 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%530 = load i32, i32* %529
%531 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %522, i32 %524, i32 %526, i32 %528, i32 %530)
%532 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%533 = load i32, i32* %532
%534 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%535 = load i32, i32* %534
%536 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%537 = load i32, i32* %536
%538 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%539 = load i32, i32* %538
%540 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%541 = load i32, i32* %540
%542 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %533, i32 %535, i32 %537, i32 %539, i32 %541)
%543 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%544 = load i32, i32* %543
%545 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%546 = load i32, i32* %545
%547 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%548 = load i32, i32* %547
%549 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%550 = load i32, i32* %549
%551 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%552 = load i32, i32* %551
%553 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %544, i32 %546, i32 %548, i32 %550, i32 %552)
%554 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%555 = load i32, i32* %554
%556 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%557 = load i32, i32* %556
%558 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%559 = load i32, i32* %558
%560 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%561 = load i32, i32* %560
%562 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%563 = load i32, i32* %562
%564 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %555, i32 %557, i32 %559, i32 %561, i32 %563)
%565 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%566 = load i32, i32* %565
%567 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%568 = load i32, i32* %567
%569 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%570 = load i32, i32* %569
%571 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%572 = load i32, i32* %571
%573 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%574 = load i32, i32* %573
%575 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %566, i32 %568, i32 %570, i32 %572, i32 %574)
%576 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%577 = load i32, i32* %576
%578 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%579 = load i32, i32* %578
%580 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%581 = load i32, i32* %580
%582 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%583 = load i32, i32* %582
%584 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%585 = load i32, i32* %584
%586 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %577, i32 %579, i32 %581, i32 %583, i32 %585)
%587 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%588 = load i32, i32* %587
%589 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%590 = load i32, i32* %589
%591 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%592 = load i32, i32* %591
%593 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%594 = load i32, i32* %593
%595 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%596 = load i32, i32* %595
%597 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %588, i32 %590, i32 %592, i32 %594, i32 %596)
%598 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%599 = load i32, i32* %598
%600 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%601 = load i32, i32* %600
%602 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%603 = load i32, i32* %602
%604 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%605 = load i32, i32* %604
%606 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%607 = load i32, i32* %606
%608 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.5, i64 0, i64 0), i32 %599, i32 %601, i32 %603, i32 %605, i32 %607)
%609 = load i32, i32* %5
%610 = icmp slt i32 %609, 3
br i1 %610, label %611, label %663
611: ; preds = %520
%612 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%613 = load i32, i32* %612
%614 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
store i32 %613, i32* %614
%615 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%616 = load i32, i32* %615
%617 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 1
store i32 %616, i32* %617
%618 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%619 = load i32, i32* %618
%620 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 2
store i32 %619, i32* %620
%621 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%622 = load i32, i32* %621
%623 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 3
store i32 %622, i32* %623
%624 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%625 = load i32, i32* %624
%626 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 4
store i32 %625, i32* %626
%627 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%628 = load i32, i32* %627
%629 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 5
store i32 %628, i32* %629
%630 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%631 = load i32, i32* %630
%632 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 6
store i32 %631, i32* %632
%633 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%634 = load i32, i32* %633
%635 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 7
store i32 %634, i32* %635
%636 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%637 = load i32, i32* %636
%638 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 8
store i32 %637, i32* %638
%639 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%640 = load i32, i32* %639
%641 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 9
store i32 %640, i32* %641
%642 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 14
%643 = load i32, i32* %642
%644 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 10
store i32 %643, i32* %644
%645 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%646 = load i32, i32* %645
%647 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 11
store i32 %646, i32* %647
%648 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%649 = load i32, i32* %648
%650 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 12
store i32 %649, i32* %650
%651 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%652 = load i32, i32* %651
%653 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 13
store i32 %652, i32* %653
%654 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%655 = load i32, i32* %654
%656 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 14
store i32 %655, i32* %656
%657 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%658 = load i32, i32* %657
%659 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 15
store i32 %658, i32* %659
%660 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%661 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
%662 = call i32 @memcpy(i32* %660, i32* %661, i32 64)
br label %663
663: ; preds = %611, %520
br label %664
664: ; preds = %663
%665 = load i32, i32* %5
%666 = add nsw i32 %665, 1
store i32 %666, i32* %5
br label %517
667: ; preds = %517
br label %668
668: ; preds = %667
%669 = load i32, i32* %4
%670 = add nsw i32 %669, 1
store i32 %670, i32* %4
br label %471
671: ; preds = %471
store i32 0, i32* %4
br label %672
672: ; preds = %689, %671
%673 = load i32, i32* %4
%674 = icmp slt i32 %673, 16
br i1 %674, label %675, label %692
675: ; preds = %672
%676 = load i32, i32* %4
%677 = load i32, i32* %4
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %678
%680 = load i32, i32* %679
%681 = load i32, i32* %4
%682 = and i32 %681, 3
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds [5 x i8], [5 x i8]* @.str.3, i64 0, i64 %683
%685 = load i8, i8* %684
%686 = sext i8 %685 to i32
%687 = load i32, i32* %4
%688 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.7, i64 0, i64 0), i32 %676, i32 %680, i32 %686, i32 %687)
br label %689
689: ; preds = %675
%690 = load i32, i32* %4
%691 = add nsw i32 %690, 1
store i32 %691, i32* %4
br label %672
692: ; preds = %672
%693 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.13, i64 0, i64 0))
%694 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i64 0, i64 0))
ret i32 0
}

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