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

/* Variables and functions */
int pow(int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int key[3][16] = {{0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0},
                    {1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0},
                    {0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1}};
  int perm[16] = {3, 2, 16, 1, 15, 11, 4, 7, 8, 13, 9, 10, 14, 5, 12, 6};
  int subs[16] = {14, 4, 13, 1, 2, 15, 11, 8, 9, 10, 6, 12, 5, 9, 0, 7};
  int msg[16];
  int i, j, k, n, xored[16], pxored[16], hex[4], subbed[4], l, bin[16];
  printf("Enter plaintext (16 integers) : ");
  for (i = 0; i < 16; i++)
    scanf("%d", &msg[i]);
  printf("\nEnter no. of iterations : ");
  scanf("%d", &n);
  for (i = 0; i < n; i++) {
    printf("\n#%d:", i);
    for (j = 0; j < 16; j++) {
      xored[j] = msg[j] ^ key[i][j];
    }
    printf("\nXOR : ");
    for (j = 0; j < 16; j++) {
      printf("%d", xored[j]);
    }
    for (j = 0; j < 16; j = j + 4) {
      hex[j / 4] = 0;
      for (k = 0; k < 4; k++) {
        hex[j / 4] += xored[j + k] * pow(2, (3 - k));
      }
    }
    printf("\nHEX : ");
    for (j = 0; j < 4; j++) {
      printf("%d ", hex[j]);
    }
    for (j = 0; j < 4; j++) {
      subbed[j] = subs[hex[j]];
    }
    printf("\nSUBSTITUTED : ");
    for (j = 0; j < 4; j++) {
      printf("%d ", subbed[j]);
    }
    for (j = 0, k = 0; j < 4; j++) {
      for (l = 1 << 3; l > 0; l = l / 2) {
        if (subbed[j] & l)
          bin[k++] = 1;
        else
          bin[k++] = 0;
      }
    }
    printf("\nCONVERTED : ");
    for (j = 0; j < 16; j++) {
      printf("%d", bin[j]);
      if ((j + 1) % 4 == 0)
        printf(" ");
    }
    for (j = 0; j < 16; j++) {
      pxored[j] = bin[perm[j] - 1];
    }
    printf("\nPERMUTATED : ");
    for (j = 0; j < 16; j++) {
      printf("%d", pxored[j]);
      if ((j + 1) % 4 == 0)
        printf(" ");
    }
  }
  printf("\nPlain text : ");
  for (i = 0; i < 16; i++)
    printf("%d", msg[i]);
  printf("\nCiphertext : ");
  for (i = 0; i < 16; i++)
    printf("%d", pxored[i]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xd0(%rbp),%rdi
lea    0xea0(%rip),%rsi
mov    $0xc0,%edx
call   1040 <memcpy@plt>
lea    -0x110(%rbp),%rdi
lea    0xf48(%rip),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    -0x150(%rbp),%rdi
lea    0xf70(%rip),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    0xf9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x194(%rbp)
cmpl   $0x10,-0x194(%rbp)
jge    11f4 <main+0xb4>
movslq -0x194(%rbp),%rax
lea    -0x190(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xf86(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    11b2 <main+0x72>
lea    0xf69(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf58(%rip),%rdi
lea    -0x1a0(%rbp),%rsi
call   1050 <scanf@plt>
movl   $0x0,-0x194(%rbp)
mov    -0x194(%rbp),%eax
cmp    -0x1a0(%rbp),%eax
jge    1703 <main+0x5c3>
mov    -0x194(%rbp),%esi
lea    0xf42(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    12ab <main+0x16b>
movslq -0x198(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x194(%rbp),%rdx
lea    -0xd0(%rbp),%rax
shl    $0x6,%rdx
add    %rdx,%rax
movslq -0x198(%rbp),%rdx
xor    (%rax,%rdx,4),%ecx
movslq -0x198(%rbp),%rax
mov    %ecx,-0x1e0(%rbp,%rax,4)
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    124f <main+0x10f>
lea    0xed4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    1300 <main+0x1c0>
movslq -0x198(%rbp),%rax
mov    -0x1e0(%rbp,%rax,4),%esi
lea    0xe7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    12c3 <main+0x183>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    13cd <main+0x28d>
mov    -0x198(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cltq
movl   $0x0,-0x230(%rbp,%rax,4)
movl   $0x0,-0x19c(%rbp)
cmpl   $0x4,-0x19c(%rbp)
jge    13b4 <main+0x274>
mov    -0x198(%rbp),%eax
add    -0x19c(%rbp),%eax
cltq
mov    -0x1e0(%rbp,%rax,4),%eax
mov    %eax,-0x294(%rbp)
mov    $0x3,%esi
sub    -0x19c(%rbp),%esi
mov    $0x2,%edi
call   1060 <pow@plt>
mov    -0x294(%rbp),%ecx
imul   %eax,%ecx
mov    -0x198(%rbp),%eax
mov    $0x4,%esi
cltd
idiv   %esi
cltq
add    -0x230(%rbp,%rax,4),%ecx
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x19c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19c(%rbp)
jmp    133c <main+0x1fc>
jmp    13b9 <main+0x279>
mov    -0x198(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x198(%rbp)
jmp    130a <main+0x1ca>
lea    0xdba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x4,-0x198(%rbp)
jge    1422 <main+0x2e2>
movslq -0x198(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%esi
lea    0xd8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    13e5 <main+0x2a5>
movl   $0x0,-0x198(%rbp)
cmpl   $0x4,-0x198(%rbp)
jge    1471 <main+0x331>
movslq -0x198(%rbp),%rax
movslq -0x230(%rbp,%rax,4),%rax
ff
mov    -0x150(%rbp,%rax,4),%ecx
movslq -0x198(%rbp),%rax
mov    %ecx,-0x240(%rbp,%rax,4)
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    142c <main+0x2ec>
lea    0xd22(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x4,-0x198(%rbp)
jge    14c6 <main+0x386>
movslq -0x198(%rbp),%rax
mov    -0x240(%rbp,%rax,4),%esi
lea    0xceb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    1489 <main+0x349>
movl   $0x0,-0x198(%rbp)
movl   $0x0,-0x19c(%rbp)
cmpl   $0x4,-0x198(%rbp)
jge    1593 <main+0x453>
movl   $0x8,-0x244(%rbp)
cmpl   $0x0,-0x244(%rbp)
jle    157a <main+0x43a>
movslq -0x198(%rbp),%rax
mov    -0x240(%rbp,%rax,4),%eax
and    -0x244(%rbp),%eax
cmp    $0x0,%eax
je     153e <main+0x3fe>
mov    -0x19c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x19c(%rbp)
cltq
movl   $0x1,-0x290(%rbp,%rax,4)
jmp    155c <main+0x41c>
mov    -0x19c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x19c(%rbp)
cltq
movl   $0x0,-0x290(%rbp,%rax,4)
jmp    1561 <main+0x421>
mov    -0x244(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x244(%rbp)
jmp    14f1 <main+0x3b1>
jmp    157f <main+0x43f>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    14da <main+0x39a>
lea    0xc10(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    1615 <main+0x4d5>
movslq -0x198(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%esi
lea    0xb94(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    15fc <main+0x4bc>
lea    0xb6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1601 <main+0x4c1>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    15ab <main+0x46b>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    1668 <main+0x528>
movslq -0x198(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%eax
sub    $0x1,%eax
cltq
mov    -0x290(%rbp,%rax,4),%ecx
movslq -0x198(%rbp),%rax
mov    %ecx,-0x220(%rbp,%rax,4)
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    161f <main+0x4df>
lea    0xb49(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x198(%rbp)
cmpl   $0x10,-0x198(%rbp)
jge    16ea <main+0x5aa>
movslq -0x198(%rbp),%rax
mov    -0x220(%rbp,%rax,4),%esi
lea    0xabf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    16d1 <main+0x591>
lea    0xa95(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16d6 <main+0x596>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    1680 <main+0x540>
jmp    16ef <main+0x5af>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    121f <main+0xdf>
lea    0xabd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x194(%rbp)
cmpl   $0x10,-0x194(%rbp)
jge    1758 <main+0x618>
movslq -0x194(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%esi
lea    0xa24(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    171b <main+0x5db>
lea    0xa77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x194(%rbp)
cmpl   $0x10,-0x194(%rbp)
jge    17ad <main+0x66d>
movslq -0x194(%rbp),%rax
mov    -0x220(%rbp,%rax,4),%esi
lea    0x9cf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1770 <main+0x630>
xor    %eax,%eax
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
lea    0xfd8(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xfeb(%rip),%rbx
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x14(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x18(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x1c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x20(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x24(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x28(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x2c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x30(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x34(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x38(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x3c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x40(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x44(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x48(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x4c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0xf17(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x6c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
cmpl   $0x0,0x6c(%rsp)
jle    191d <main+0x7dd>
lea    0xeee(%rip),%r15
xor    %ebx,%ebx
jmp    128a <main+0x14a>
nopw   0x0(%rax,%rax,1)
mov    0x120(%rsp),%rbx
add    $0x1,%rbx
movslq 0x6c(%rsp),%rax
cmp    %rax,%rbx
jge    191d <main+0x7dd>
lea    0xedf(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,0x120(%rsp)
mov    %rbx,%rax
shl    $0x6,%rax
lea    0xd80(%rip),%rcx
mov    (%rax,%rcx,1),%r13d
mov    0x4(%rax,%rcx,1),%ebp
xor    0x10(%rsp),%r13d
xor    0x14(%rsp),%ebp
mov    %ebp,0x78(%rsp)
mov    0x8(%rax,%rcx,1),%ebx
xor    0x18(%rsp),%ebx
mov    %ebx,0xc(%rsp)
mov    0xc(%rax,%rcx,1),%r12d
xor    0x1c(%rsp),%r12d
mov    0x10(%rax,%rcx,1),%r14d
xor    0x20(%rsp),%r14d
mov    %r14d,0x7c(%rsp)
mov    0x14(%rax,%rcx,1),%edx
xor    0x24(%rsp),%edx
mov    %edx,0x50(%rsp)
mov    0x18(%rax,%rcx,1),%edx
xor    0x28(%rsp),%edx
mov    %edx,0x54(%rsp)
mov    0x1c(%rax,%rcx,1),%edx
xor    0x2c(%rsp),%edx
mov    %edx,0x58(%rsp)
mov    0x20(%rax,%rcx,1),%edx
xor    0x30(%rsp),%edx
mov    %edx,0x5c(%rsp)
mov    0x24(%rax,%rcx,1),%edx
xor    0x34(%rsp),%edx
mov    %edx,0x60(%rsp)
mov    0x28(%rax,%rcx,1),%edx
xor    0x38(%rsp),%edx
mov    %edx,0x64(%rsp)
mov    0x2c(%rax,%rcx,1),%edx
xor    0x3c(%rsp),%edx
mov    %edx,0x68(%rsp)
mov    0x30(%rax,%rcx,1),%edx
xor    0x40(%rsp),%edx
mov    %edx,0x8(%rsp)
mov    0x34(%rax,%rcx,1),%edx
xor    0x44(%rsp),%edx
mov    %edx,0x70(%rsp)
mov    0x38(%rax,%rcx,1),%edx
xor    0x48(%rsp),%edx
mov    %edx,0xc0(%rsp)
mov    0x3c(%rax,%rcx,1),%eax
xor    0x4c(%rsp),%eax
mov    %eax,0x110(%rsp)
lea    0xdfb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x50(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x54(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x58(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x5c(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x60(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x64(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x68(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x8(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x70(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0xc0(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    0x110(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x2,%edi
mov    $0x3,%esi
call   1060 <pow@plt>
mov    %eax,%r14d
imul   %r13d,%r14d
mov    $0x2,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
mov    %eax,%ebp
imul   0x78(%rsp),%ebp
add    %r14d,%ebp
mov    $0x2,%edi
mov    $0x1,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0xc(%rsp),%ebx
add    %ebp,%ebx
mov    $0x2,%edi
xor    %esi,%esi
call   1060 <pow@plt>
imul   %r12d,%eax
add    %ebx,%eax
mov    %eax,0xc(%rsp)
mov    $0x2,%edi
mov    $0x3,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x7c(%rsp),%ebx
mov    $0x2,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
mov    %eax,%ebp
imul   0x50(%rsp),%ebp
add    %ebx,%ebp
mov    $0x2,%edi
mov    $0x1,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x54(%rsp),%ebx
add    %ebp,%ebx
mov    $0x2,%edi
xor    %esi,%esi
call   1060 <pow@plt>
mov    %eax,%r14d
imul   0x58(%rsp),%r14d
add    %ebx,%r14d
mov    $0x2,%edi
mov    $0x3,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x5c(%rsp),%ebx
mov    $0x2,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
mov    %eax,%ebp
imul   0x60(%rsp),%ebp
add    %ebx,%ebp
mov    $0x2,%edi
mov    $0x1,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x64(%rsp),%ebx
add    %ebp,%ebx
mov    $0x2,%edi
xor    %esi,%esi
call   1060 <pow@plt>
mov    %eax,%r13d
imul   0x68(%rsp),%r13d
add    %ebx,%r13d
mov    $0x2,%edi
mov    $0x3,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x8(%rsp),%ebx
mov    $0x2,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
mov    %eax,%ebp
imul   0x70(%rsp),%ebp
add    %ebx,%ebp
mov    $0x2,%edi
mov    $0x1,%esi
call   1060 <pow@plt>
mov    %eax,%r12d
imul   0xc0(%rsp),%r12d
add    %ebp,%r12d
mov    $0x2,%edi
xor    %esi,%esi
call   1060 <pow@plt>
mov    %eax,%ebx
imul   0x110(%rsp),%ebx
add    %r12d,%ebx
lea    0xb98(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb92(%rip),%r12
mov    %r12,%rdi
mov    0xc(%rsp),%ebp
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movslq %ebp,%rax
movq   %rax,%xmm0
movdqa %xmm0,0xc0(%rsp)
lea    0xaae(%rip),%rcx
mov    (%rcx,%rax,4),%ebp
movslq %r14d,%r14
mov    (%rcx,%r14,4),%eax
mov    %eax,0x8(%rsp)
movslq %r13d,%rax
mov    %rax,0x70(%rsp)
mov    (%rcx,%rax,4),%r13d
movslq %ebx,%rax
movq   %rax,%xmm0
movdqa %xmm0,0x110(%rsp)
mov    (%rcx,%rax,4),%ebx
lea    0xb13(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    0x8(%rsp),%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movdqa 0x947(%rip),%xmm1
movdqa %xmm1,%xmm0
movdqa 0xc0(%rsp),%xmm3
psrlq  %xmm3,%xmm0
movdqa 0x93e(%rip),%xmm2
movdqa %xmm2,%xmm4
psrlq  %xmm3,%xmm4
shufps $0x88,%xmm0,%xmm4
movaps 0x93b(%rip),%xmm3
andnps %xmm3,%xmm4
movaps %xmm4,0xc0(%rsp)
mov    $0xd41a,%r12d
mov    %r14d,%ecx
shr    %cl,%r12
movaps %xmm4,0xd0(%rsp)
not    %r12d
and    $0x1,%r12d
mov    %r12d,0xe0(%rsp)
mov    $0x63d8,%r13d
shr    %cl,%r13
not    %r13d
and    $0x1,%r13d
mov    %r13d,0xe4(%rsp)
mov    $0x798e,%eax
shr    %cl,%rax
not    %eax
mov    $0x4e93,%edx
shr    %cl,%rdx
and    $0x1,%eax
mov    %eax,0xe8(%rsp)
not    %edx
and    $0x1,%edx
mov    $0xd41a,%eax
mov    0x70(%rsp),%rcx
shr    %cl,%rax
mov    %edx,0xec(%rsp)
not    %eax
and    $0x1,%eax
mov    %eax,0xf0(%rsp)
mov    $0x63d8,%eax
shr    %cl,%rax
not    %eax
and    $0x1,%eax
mov    %eax,0xf4(%rsp)
mov    $0x798e,%eax
shr    %cl,%rax
not    %eax
mov    $0x4e93,%ebx
shr    %cl,%rbx
and    $0x1,%eax
mov    %eax,0xf8(%rsp)
not    %ebx
and    $0x1,%ebx
movdqa %xmm1,%xmm0
movdqa 0x110(%rsp),%xmm4
psrlq  %xmm4,%xmm0
movdqa %xmm2,%xmm1
psrlq  %xmm4,%xmm1
mov    %ebx,0xfc(%rsp)
shufps $0x88,%xmm0,%xmm1
andnps %xmm3,%xmm1
movaps %xmm1,0x100(%rsp)
lea    0x9c3(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movdqa 0xc0(%rsp),%xmm0
movd   %xmm0,%esi
mov    $0x1,%ebp
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   $0x3,%bpl
jne    180a <main+0x6ca>
mov    $0x20,%edi
call   1030 <putchar@plt>
cmp    $0x10,%rbp
je     1820 <main+0x6e0>
mov    0xd0(%rsp,%rbp,4),%esi
add    $0x1,%rbp
jmp    17f0 <main+0x6b0>
nopl   (%rax)
mov    0xd8(%rsp),%eax
mov    %eax,0x80(%rsp)
mov    0xd0(%rsp),%eax
mov    0xd4(%rsp),%ecx
mov    %ecx,0x84(%rsp)
mov    0x10c(%rsp),%ecx
mov    %ecx,0x88(%rsp)
mov    %eax,0x8c(%rsp)
mov    0x108(%rsp),%eax
mov    %eax,0x90(%rsp)
mov    0xf8(%rsp),%eax
mov    %eax,0x94(%rsp)
mov    0xdc(%rsp),%eax
mov    %eax,0x98(%rsp)
mov    0xe8(%rsp),%rax
mov    %rax,0x9c(%rsp)
mov    0x100(%rsp),%eax
mov    %eax,0xa4(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x104(%rsp),%eax
mov    %eax,0xb0(%rsp)
mov    %r12d,0xb4(%rsp)
mov    %ebx,0xb8(%rsp)
mov    %r13d,0xbc(%rsp)
lea    0x8cc(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%ebx
jmp    18fe <main+0x7be>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x11,%rbx
je     1270 <main+0x130>
mov    0x7c(%rsp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   $0x3,%bl
jne    18f0 <main+0x7b0>
mov    $0x20,%edi
call   1030 <putchar@plt>
jmp    18f0 <main+0x7b0>
lea    0x893(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%esi
lea    0x81b(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x7ad(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x80(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x84(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x88(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x90(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x94(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x98(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x9c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xac(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xbc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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