#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 */
scalar_t__ calloc(size_t, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, ...);
size_t strlen(char *);
int main() {
  int flips;
  scanf("%d", &flips);
  char buffer[1001];
  scanf("%s", buffer);
  size_t len = strlen(buffer);
  size_t padding = 32 - len % 32;
  if (padding == 32) {
    size_t arr_size = len / 32;
    int *number = (int *)calloc(arr_size, sizeof(int));
    for (size_t i = 0; i < arr_size; i++) {
      for (int j = 0; j < 32; j++) {
        if (buffer[i * 32 + j] == '1')
          *(number + i) |= (1 << j);
      }
      if (flips & 1)
        *(number + i) = ~*(number + i);
    }
    int successful = 1;
    scanf("%s", buffer);
    int *second = (int *)calloc(arr_size, sizeof(int));
    for (size_t i = 0; i < arr_size; i++) {
      for (int j = 0; j < 32; j++) {
        if (buffer[i * 32 + j] == '1')
          *(second + i) |= (1 << j);
      }
      if (*(second + i) != *(number + i)) {
        successful = 0;
        break;
      }
    }
    printf(successful ? "Deletion succeeded\n" : "Deletion failed\n");
  } else {
    size_t arr_size = len / 32 + 1;
    int *number = (int *)calloc(arr_size, sizeof(int));
    for (size_t i = 0; i < arr_size; i++) {
      if (i == arr_size - 1) {
        for (int j = 0; j < 32 - padding; j++) {
          if (buffer[i * 32 + j] == '1')
            *(number + i) |= (1 << j);
        }
      } else {
        for (int j = 0; j < 32; j++) {
          if (buffer[i * 32 + j] == '1')
            *(number + i) |= (1 << j);
        }
      }
      if (flips & 1)
        *(number + i) = ~*(number + i);
    }
    int successful = 1;
    scanf("%s", buffer);
    int *second = (int *)calloc(arr_size, sizeof(int));
    for (size_t i = 0; i < arr_size; i++) {
      if (i == arr_size - 1) {
        for (int j = 0; j < 32 - padding; j++) {
          if (buffer[i * 32 + j] == '1')
            *(second + i) |= (1 << j);
        }
        if (flips & 1) {
          for (size_t j = 32 - padding; j < 32; j++) {
            *(second + i) |= (1 << j);
          }
        }
      } else {
        for (int j = 0; j < 32; j++) {
          if (buffer[i * 32 + j] == '1')
            *(second + i) |= (1 << j);
        }
      }
      if (*(second + i) != *(number + i)) {
        successful = 0;
        break;
      }
    }
    printf(successful ? "Deletion succeeded\n" : "Deletion failed\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4a0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xea7(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
lea    -0x400(%rbp),%rsi
lea    0xe91(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
lea    -0x400(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x408(%rbp)
mov    -0x408(%rbp),%rcx
and    $0x1f,%rcx
mov    $0x20,%eax
sub    %rcx,%rax
mov    %rax,-0x410(%rbp)
cmpq   $0x20,-0x410(%rbp)
20
jne    1409 <main+0x2c9>
mov    -0x408(%rbp),%rax
shr    $0x5,%rax
mov    %rax,-0x418(%rbp)
mov    -0x418(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x420(%rbp)
movq   $0x0,-0x428(%rbp)
mov    -0x428(%rbp),%rax
cmp    -0x418(%rbp),%rax
jae    12c4 <main+0x184>
movl   $0x0,-0x42c(%rbp)
cmpl   $0x20,-0x42c(%rbp)
jge    1274 <main+0x134>
mov    -0x428(%rbp),%rax
shl    $0x5,%rax
movslq -0x42c(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    125b <main+0x11b>
mov    -0x42c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x420(%rbp),%rax
mov    -0x428(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1260 <main+0x120>
mov    -0x42c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x42c(%rbp)
jmp    1207 <main+0xc7>
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12a8 <main+0x168>
mov    -0x420(%rbp),%rax
mov    -0x428(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
xor    $0xffffffff,%edx
mov    -0x420(%rbp),%rax
mov    -0x428(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12ad <main+0x16d>
mov    -0x428(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x428(%rbp)
jmp    11e9 <main+0xa9>
movl   $0x1,-0x430(%rbp)
lea    -0x400(%rbp),%rsi
lea    0xd27(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x418(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x438(%rbp)
movq   $0x0,-0x440(%rbp)
mov    -0x440(%rbp),%rax
cmp    -0x418(%rbp),%rax
jae    13e4 <main+0x2a4>
movl   $0x0,-0x444(%rbp)
cmpl   $0x20,-0x444(%rbp)
jge    1391 <main+0x251>
mov    -0x440(%rbp),%rax
shl    $0x5,%rax
movslq -0x444(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    1378 <main+0x238>
mov    -0x444(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x438(%rbp),%rax
mov    -0x440(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    137d <main+0x23d>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    1324 <main+0x1e4>
mov    -0x438(%rbp),%rax
mov    -0x440(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x420(%rbp),%rcx
mov    -0x440(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     13c8 <main+0x288>
movl   $0x0,-0x430(%rbp)
jmp    13e4 <main+0x2a4>
jmp    13cd <main+0x28d>
mov    -0x440(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x440(%rbp)
jmp    1306 <main+0x1c6>
mov    -0x430(%rbp),%ecx
lea    0xc29(%rip),%rdi
lea    0xc0e(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdi
call   1040 <printf@plt>
jmp    1823 <main+0x6e3>
mov    -0x408(%rbp),%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %rax,-0x450(%rbp)
mov    -0x450(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x458(%rbp)
movq   $0x0,-0x460(%rbp)
mov    -0x460(%rbp),%rax
cmp    -0x450(%rbp),%rax
jae    15c8 <main+0x488>
mov    -0x460(%rbp),%rax
mov    -0x450(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jne    14fc <main+0x3bc>
movl   $0x0,-0x464(%rbp)
movslq -0x464(%rbp),%rax
mov    $0x20,%ecx
sub    -0x410(%rbp),%rcx
cmp    %rcx,%rax
jae    14f7 <main+0x3b7>
mov    -0x460(%rbp),%rax
shl    $0x5,%rax
movslq -0x464(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    14de <main+0x39e>
mov    -0x464(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x458(%rbp),%rax
mov    -0x460(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    14e3 <main+0x3a3>
mov    -0x464(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x464(%rbp)
jmp    147b <main+0x33b>
jmp    1578 <main+0x438>
movl   $0x0,-0x468(%rbp)
cmpl   $0x20,-0x468(%rbp)
jge    1573 <main+0x433>
mov    -0x460(%rbp),%rax
shl    $0x5,%rax
movslq -0x468(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    155a <main+0x41a>
mov    -0x468(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x458(%rbp),%rax
mov    -0x460(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    155f <main+0x41f>
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1506 <main+0x3c6>
jmp    1578 <main+0x438>
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     15ac <main+0x46c>
mov    -0x458(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
xor    $0xffffffff,%edx
mov    -0x458(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15b1 <main+0x471>
mov    -0x460(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x460(%rbp)
jmp    1442 <main+0x302>
movl   $0x1,-0x46c(%rbp)
lea    -0x400(%rbp),%rsi
lea    0xa23(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x450(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x478(%rbp)
movq   $0x0,-0x480(%rbp)
mov    -0x480(%rbp),%rax
cmp    -0x450(%rbp),%rax
jae    1803 <main+0x6c3>
mov    -0x480(%rbp),%rax
mov    -0x450(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jne    1734 <main+0x5f4>
movl   $0x0,-0x484(%rbp)
movslq -0x484(%rbp),%rax
mov    $0x20,%ecx
sub    -0x410(%rbp),%rcx
cmp    %rcx,%rax
jae    16bf <main+0x57f>
mov    -0x480(%rbp),%rax
shl    $0x5,%rax
movslq -0x484(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    16a6 <main+0x566>
mov    -0x484(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x478(%rbp),%rax
mov    -0x480(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    16ab <main+0x56b>
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    1643 <main+0x503>
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     172f <main+0x5ef>
mov    $0x20,%eax
sub    -0x410(%rbp),%rax
mov    %rax,-0x490(%rbp)
cmpq   $0x20,-0x490(%rbp)
20
jae    172a <main+0x5ea>
mov    -0x490(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x478(%rbp),%rax
mov    -0x480(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x490(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x490(%rbp)
jmp    16e1 <main+0x5a1>
jmp    172f <main+0x5ef>
jmp    17b0 <main+0x670>
movl   $0x0,-0x494(%rbp)
cmpl   $0x20,-0x494(%rbp)
jge    17ab <main+0x66b>
mov    -0x480(%rbp),%rax
shl    $0x5,%rax
movslq -0x494(%rbp),%rcx
add    %rcx,%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    1792 <main+0x652>
mov    -0x494(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x478(%rbp),%rax
mov    -0x480(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1797 <main+0x657>
mov    -0x494(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x494(%rbp)
jmp    173e <main+0x5fe>
jmp    17b0 <main+0x670>
mov    -0x478(%rbp),%rax
mov    -0x480(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x458(%rbp),%rcx
mov    -0x480(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     17e7 <main+0x6a7>
movl   $0x0,-0x46c(%rbp)
jmp    1803 <main+0x6c3>
jmp    17ec <main+0x6ac>
mov    -0x480(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x480(%rbp)
jmp    160a <main+0x4ca>
mov    -0x46c(%rbp),%ecx
lea    0x80a(%rip),%rdi
lea    0x7ef(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x4a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
lea    0xea8(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xe98(%rip),%rdi
lea    0x30(%rsp),%r14
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %rax,%r13
mov    %rax,%r15
shr    $0x5,%r15
mov    %rax,%rbp
and    $0x1f,%rbp
je     1488 <main+0x348>
lea    0x1(%r15),%rdi
mov    %rdi,0x10(%rsp)
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r12
mov    %r13,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x1(%rbp),%r10
mov    %r13,0x20(%rsp)
mov    %r13d,%r8d
and    $0x1,%r8d
mov    %rbp,0x18(%rsp)
mov    %rbp,%rbx
sub    %r8,%rbx
lea    0x31(%rsp),%rdi
mov    %r14,%rsi
lea    (%r9,%r14,1),%r13
add    $0x1,%r13
xor    %ebp,%ebp
jmp    1204 <main+0xc4>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rbp),%rax
add    $0x20,%rdi
cmp    %r15,%rbp
mov    %rax,%rbp
je     12b6 <main+0x176>
xor    %eax,%eax
cmp    %r15,%rbp
jne    124a <main+0x10a>
test   %r10,%r10
jne    1289 <main+0x149>
test   %r8,%r8
je     1230 <main+0xf0>
lea    (%rax,%r9,1),%rcx
cmpb   $0x31,0x30(%rsp,%rcx,1)
jne    1230 <main+0xf0>
mov    $0x1,%edx
mov    %eax,%ecx
shl    %cl,%edx
or     %edx,(%r12,%r15,4)
nopl   (%rax)
testb  $0x1,0xc(%rsp)
je     11f0 <main+0xb0>
notl   (%r12,%rbp,4)
jmp    11f0 <main+0xb0>
nopl   (%rax)
add    $0x2,%rax
cmp    $0x20,%rax
je     1230 <main+0xf0>
cmpb   $0x31,-0x1(%rdi,%rax,1)
jne    125e <main+0x11e>
mov    $0x1,%edx
mov    %eax,%ecx
shl    %cl,%edx
or     %edx,(%r12,%rbp,4)
cmpb   $0x31,(%rdi,%rax,1)
jne    1240 <main+0x100>
lea    0x1(%rax),%ecx
mov    $0x1,%edx
shl    %cl,%edx
or     %edx,(%r12,%rbp,4)
jmp    1240 <main+0x100>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%rbx
je     1210 <main+0xd0>
cmpb   $0x31,-0x1(%r13,%rax,1)
jne    129e <main+0x15e>
mov    $0x1,%edx
mov    %eax,%ecx
shl    %cl,%edx
or     %edx,(%r12,%r15,4)
cmpb   $0x31,0x0(%r13,%rax,1)
jne    1280 <main+0x140>
lea    0x1(%rax),%ecx
mov    $0x1,%edx
shl    %cl,%edx
or     %edx,(%r12,%r15,4)
jmp    1280 <main+0x140>
mov    %r10,%rbx
mov    %r9,0x28(%rsp)
lea    0xd3e(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x10(%rsp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    0x20(%rsp),%rdi
mov    %edi,%r11d
neg    %r11d
mov    0x18(%rsp),%r10
mov    %r10,%rcx
xor    $0x1f,%rcx
mov    %rcx,0x10(%rsp)
and    $0x1,%edi
sub    %rdi,%r10
and    $0x7,%r11d
lea    0x31(%rsp),%rsi
mov    %rdi,%r8
nopl   0x0(%rax)
xor    %edx,%edx
cmp    %r15,%r14
jne    139e <main+0x25e>
test   %rbx,%rbx
jne    13dd <main+0x29d>
test   %rdi,%rdi
je     134a <main+0x20a>
mov    0x28(%rsp),%rcx
add    %rdx,%rcx
cmpb   $0x31,0x30(%rsp,%rcx,1)
jne    134a <main+0x20a>
mov    $0x1,%r9d
mov    %edx,%ecx
shl    %cl,%r9d
or     %r9d,(%rax,%r15,4)
mov    %r8,%rdi
testb  $0x1,0xc(%rsp)
je     145a <main+0x31a>
mov    (%rax,%r15,4),%ecx
test   %r11,%r11
je     140a <main+0x2ca>
mov    %r11,%r9
mov    0x18(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
bts    %edx,%ecx
add    $0x1,%rdx
add    $0xffffffffffffffff,%r9
jne    1370 <main+0x230>
jmp    140f <main+0x2cf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rdx
cmp    $0x20,%rdx
je     145a <main+0x31a>
cmpb   $0x31,-0x1(%rsi,%rdx,1)
jne    13b2 <main+0x272>
mov    $0x1,%ebp
mov    %edx,%ecx
shl    %cl,%ebp
or     %ebp,(%rax,%r14,4)
cmpb   $0x31,(%rsi,%rdx,1)
jne    1390 <main+0x250>
lea    0x1(%rdx),%ecx
mov    $0x1,%ebp
shl    %cl,%ebp
or     %ebp,(%rax,%r14,4)
jmp    1390 <main+0x250>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdx
cmp    %rdx,%r10
je     1324 <main+0x1e4>
cmpb   $0x31,-0x1(%r13,%rdx,1)
jne    13f2 <main+0x2b2>
mov    $0x1,%ebp
mov    %edx,%ecx
shl    %cl,%ebp
or     %ebp,(%rax,%r15,4)
cmpb   $0x31,0x0(%r13,%rdx,1)
jne    13d0 <main+0x290>
lea    0x1(%rdx),%ecx
mov    $0x1,%ebp
shl    %cl,%ebp
or     %ebp,(%rax,%r15,4)
jmp    13d0 <main+0x290>
mov    0x18(%rsp),%rdx
cmpq   $0x7,0x10(%rsp)
mov    %r8,%rdi
jb     1456 <main+0x316>
add    $0xffffffffffffffe0,%rdx
xchg   %ax,%ax
lea    0x20(%rdx),%ebp
bts    %ebp,%ecx
lea    0x21(%rdx),%ebp
bts    %ebp,%ecx
lea    0x22(%rdx),%ebp
bts    %ebp,%ecx
lea    0x23(%rdx),%ebp
bts    %ebp,%ecx
lea    0x24(%rdx),%ebp
bts    %ebp,%ecx
lea    0x25(%rdx),%ebp
bts    %ebp,%ecx
lea    0x26(%rdx),%ebp
bts    %ebp,%ecx
lea    0x27(%rdx),%ebp
bts    %ebp,%ecx
add    $0x8,%rdx
jne    1420 <main+0x2e0>
mov    %ecx,(%rax,%r15,4)
mov    (%rax,%r14,4),%ecx
cmp    (%r12,%r14,4),%ecx
jne    156f <main+0x42f>
lea    0x1(%r14),%rcx
add    $0x20,%rsi
cmp    %r15,%r14
mov    %rcx,%r14
jne    1310 <main+0x1d0>
lea    0xb83(%rip),%rdi
jmp    1610 <main+0x4d0>
mov    %r15,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r14
mov    %r13,%rbx
cmp    $0x20,%r13
jae    157b <main+0x43b>
lea    0xb57(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %r15,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
lea    0xb3a(%rip),%rdi
cmp    $0x20,%rbx
jb     1610 <main+0x4d0>
cmp    $0x2,%r15
mov    $0x1,%r8d
cmovae %r15,%r8
lea    0x31(%rsp),%rbp
xor    %esi,%esi
lea    0xb28(%rip),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
jmp    151a <main+0x3da>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rdx
cmp    $0x20,%rdx
je     1550 <main+0x410>
cmpb   $0x31,-0x1(%rbp,%rdx,1)
jne    152d <main+0x3ed>
mov    $0x1,%ebx
mov    %edx,%ecx
shl    %cl,%ebx
or     %ebx,(%rax,%rsi,4)
cmpb   $0x31,0x0(%rbp,%rdx,1)
jne    1510 <main+0x3d0>
lea    0x1(%rdx),%ecx
mov    $0x1,%ebx
shl    %cl,%ebx
or     %ebx,(%rax,%rsi,4)
jmp    1510 <main+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rsi,4),%ecx
cmp    (%r14,%rsi,4),%ecx
jne    160d <main+0x4cd>
add    $0x1,%rsi
add    $0x20,%rbp
cmp    %r8,%rsi
jne    1500 <main+0x3c0>
jmp    1610 <main+0x4d0>
lea    0xaa4(%rip),%rdi
jmp    1610 <main+0x4d0>
cmp    $0x2,%r15
mov    $0x1,%edx
cmovae %r15,%rdx
lea    0x31(%rsp),%rsi
xor    %edi,%edi
jmp    15b1 <main+0x471>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x20,%rsi
cmp    %rdx,%rdi
je     14a5 <main+0x365>
xor    %eax,%eax
jmp    15ca <main+0x48a>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rax
cmp    $0x20,%rax
je     1600 <main+0x4c0>
cmpb   $0x31,-0x1(%rsi,%rax,1)
jne    15de <main+0x49e>
mov    $0x1,%ebp
mov    %eax,%ecx
shl    %cl,%ebp
or     %ebp,(%r14,%rdi,4)
cmpb   $0x31,(%rsi,%rax,1)
jne    15c0 <main+0x480>
lea    0x1(%rax),%ecx
mov    $0x1,%ebp
shl    %cl,%ebp
or     %ebp,(%r14,%rdi,4)
jmp    15c0 <main+0x480>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
testb  $0x1,0xc(%rsp)
je     15a0 <main+0x460>
notl   (%r14,%rdi,4)
jmp    15a0 <main+0x460>
mov    %r9,%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [20 x i8] c"Deletion succeeded\0A\00"
@.str.3 = [17 x i8] c"Deletion failed\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [1001 x i8]
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i32*
%8 = alloca i64
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i64
%13 = alloca i32
%14 = alloca i64
%15 = alloca i32*
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i64
%22 = alloca i32
%23 = alloca i64
%24 = alloca i32
store i32 0, i32* %1
%25 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%26 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 0
%27 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %26)
%28 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 0
%29 = call i64 @strlen(i8* %28)
store i64 %29, i64* %4
%30 = load i64, i64* %4
%31 = urem i64 %30, 32
%32 = sub i64 32, %31
store i64 %32, i64* %5
%33 = load i64, i64* %5
%34 = icmp eq i64 %33, 32
br i1 %34, label %35, label %145
35: ; preds = %0
%36 = load i64, i64* %4
%37 = udiv i64 %36, 32
store i64 %37, i64* %6
%38 = load i64, i64* %6
%39 = call i64 @calloc(i64 %38, i32 4)
%40 = inttoptr i64 %39 to i32*
store i32* %40, i32** %7
store i64 0, i64* %8
br label %41
41: ; preds = %85, %35
%42 = load i64, i64* %8
%43 = load i64, i64* %6
%44 = icmp ult i64 %42, %43
br i1 %44, label %45, label %88
45: ; preds = %41
store i32 0, i32* %9
br label %46
46: ; preds = %68, %45
%47 = load i32, i32* %9
%48 = icmp slt i32 %47, 32
br i1 %48, label %49, label %71
49: ; preds = %46
%50 = load i64, i64* %8
%51 = mul i64 %50, 32
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = add i64 %51, %53
%55 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %54
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = icmp eq i32 %57, 49
br i1 %58, label %59, label %67
59: ; preds = %49
%60 = load i32, i32* %9
%61 = shl i32 1, %60
%62 = load i32*, i32** %7
%63 = load i64, i64* %8
%64 = getelementptr inbounds i32, i32* %62, i64 %63
%65 = load i32, i32* %64
%66 = or i32 %65, %61
store i32 %66, i32* %64
br label %67
67: ; preds = %59, %49
br label %68
68: ; preds = %67
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
store i32 %70, i32* %9
br label %46
71: ; preds = %46
%72 = load i32, i32* %2
%73 = and i32 %72, 1
%74 = icmp ne i32 %73, 0
br i1 %74, label %75, label %84
75: ; preds = %71
%76 = load i32*, i32** %7
%77 = load i64, i64* %8
%78 = getelementptr inbounds i32, i32* %76, i64 %77
%79 = load i32, i32* %78
%80 = xor i32 %79, -1
%81 = load i32*, i32** %7
%82 = load i64, i64* %8
%83 = getelementptr inbounds i32, i32* %81, i64 %82
store i32 %80, i32* %83
br label %84
84: ; preds = %75, %71
br label %85
85: ; preds = %84
%86 = load i64, i64* %8
%87 = add i64 %86, 1
store i64 %87, i64* %8
br label %41
88: ; preds = %41
store i32 1, i32* %10
%89 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 0
%90 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %89)
%91 = load i64, i64* %6
%92 = call i64 @calloc(i64 %91, i32 4)
%93 = inttoptr i64 %92 to i32*
store i32* %93, i32** %11
store i64 0, i64* %12
br label %94
94: ; preds = %136, %88
%95 = load i64, i64* %12
%96 = load i64, i64* %6
%97 = icmp ult i64 %95, %96
br i1 %97, label %98, label %139
98: ; preds = %94
store i32 0, i32* %13
br label %99
99: ; preds = %121, %98
%100 = load i32, i32* %13
%101 = icmp slt i32 %100, 32
br i1 %101, label %102, label %124
102: ; preds = %99
%103 = load i64, i64* %12
%104 = mul i64 %103, 32
%105 = load i32, i32* %13
%106 = sext i32 %105 to i64
%107 = add i64 %104, %106
%108 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %107
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = icmp eq i32 %110, 49
br i1 %111, label %112, label %120
112: ; preds = %102
%113 = load i32, i32* %13
%114 = shl i32 1, %113
%115 = load i32*, i32** %11
%116 = load i64, i64* %12
%117 = getelementptr inbounds i32, i32* %115, i64 %116
%118 = load i32, i32* %117
%119 = or i32 %118, %114
store i32 %119, i32* %117
br label %120
120: ; preds = %112, %102
br label %121
121: ; preds = %120
%122 = load i32, i32* %13
%123 = add nsw i32 %122, 1
store i32 %123, i32* %13
br label %99
124: ; preds = %99
%125 = load i32*, i32** %11
%126 = load i64, i64* %12
%127 = getelementptr inbounds i32, i32* %125, i64 %126
%128 = load i32, i32* %127
%129 = load i32*, i32** %7
%130 = load i64, i64* %12
%131 = getelementptr inbounds i32, i32* %129, i64 %130
%132 = load i32, i32* %131
%133 = icmp ne i32 %128, %132
br i1 %133, label %134, label %135
134: ; preds = %124
store i32 0, i32* %10
br label %139
135: ; preds = %124
br label %136
136: ; preds = %135
%137 = load i64, i64* %12
%138 = add i64 %137, 1
store i64 %138, i64* %12
br label %94
139: ; preds = %134, %94
%140 = load i32, i32* %10
%141 = icmp ne i32 %140, 0
%142 = zext i1 %141 to i64
%143 = select i1 %141, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0)
%144 = call i32 @printf(i8* %143)
br label %351
145: ; preds = %0
%146 = load i64, i64* %4
%147 = udiv i64 %146, 32
%148 = add i64 %147, 1
store i64 %148, i64* %14
%149 = load i64, i64* %14
%150 = call i64 @calloc(i64 %149, i32 4)
%151 = inttoptr i64 %150 to i32*
store i32* %151, i32** %15
store i64 0, i64* %16
br label %152
152: ; preds = %232, %145
%153 = load i64, i64* %16
%154 = load i64, i64* %14
%155 = icmp ult i64 %153, %154
br i1 %155, label %156, label %235
156: ; preds = %152
%157 = load i64, i64* %16
%158 = load i64, i64* %14
%159 = sub i64 %158, 1
%160 = icmp eq i64 %157, %159
br i1 %160, label %161, label %191
161: ; preds = %156
store i32 0, i32* %17
br label %162
162: ; preds = %187, %161
%163 = load i32, i32* %17
%164 = sext i32 %163 to i64
%165 = load i64, i64* %5
%166 = sub i64 32, %165
%167 = icmp ult i64 %164, %166
br i1 %167, label %168, label %190
168: ; preds = %162
%169 = load i64, i64* %16
%170 = mul i64 %169, 32
%171 = load i32, i32* %17
%172 = sext i32 %171 to i64
%173 = add i64 %170, %172
%174 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %173
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = icmp eq i32 %176, 49
br i1 %177, label %178, label %186
178: ; preds = %168
%179 = load i32, i32* %17
%180 = shl i32 1, %179
%181 = load i32*, i32** %15
%182 = load i64, i64* %16
%183 = getelementptr inbounds i32, i32* %181, i64 %182
%184 = load i32, i32* %183
%185 = or i32 %184, %180
store i32 %185, i32* %183
br label %186
186: ; preds = %178, %168
br label %187
187: ; preds = %186
%188 = load i32, i32* %17
%189 = add nsw i32 %188, 1
store i32 %189, i32* %17
br label %162
190: ; preds = %162
br label %218
191: ; preds = %156
store i32 0, i32* %18
br label %192
192: ; preds = %214, %191
%193 = load i32, i32* %18
%194 = icmp slt i32 %193, 32
br i1 %194, label %195, label %217
195: ; preds = %192
%196 = load i64, i64* %16
%197 = mul i64 %196, 32
%198 = load i32, i32* %18
%199 = sext i32 %198 to i64
%200 = add i64 %197, %199
%201 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %200
%202 = load i8, i8* %201
%203 = sext i8 %202 to i32
%204 = icmp eq i32 %203, 49
br i1 %204, label %205, label %213
205: ; preds = %195
%206 = load i32, i32* %18
%207 = shl i32 1, %206
%208 = load i32*, i32** %15
%209 = load i64, i64* %16
%210 = getelementptr inbounds i32, i32* %208, i64 %209
%211 = load i32, i32* %210
%212 = or i32 %211, %207
store i32 %212, i32* %210
br label %213
213: ; preds = %205, %195
br label %214
214: ; preds = %213
%215 = load i32, i32* %18
%216 = add nsw i32 %215, 1
store i32 %216, i32* %18
br label %192
217: ; preds = %192
br label %218
218: ; preds = %217, %190
%219 = load i32, i32* %2
%220 = and i32 %219, 1
%221 = icmp ne i32 %220, 0
br i1 %221, label %222, label %231
222: ; preds = %218
%223 = load i32*, i32** %15
%224 = load i64, i64* %16
%225 = getelementptr inbounds i32, i32* %223, i64 %224
%226 = load i32, i32* %225
%227 = xor i32 %226, -1
%228 = load i32*, i32** %15
%229 = load i64, i64* %16
%230 = getelementptr inbounds i32, i32* %228, i64 %229
store i32 %227, i32* %230
br label %231
231: ; preds = %222, %218
br label %232
232: ; preds = %231
%233 = load i64, i64* %16
%234 = add i64 %233, 1
store i64 %234, i64* %16
br label %152
235: ; preds = %152
store i32 1, i32* %19
%236 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 0
%237 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %236)
%238 = load i64, i64* %14
%239 = call i64 @calloc(i64 %238, i32 4)
%240 = inttoptr i64 %239 to i32*
store i32* %240, i32** %20
store i64 0, i64* %21
br label %241
241: ; preds = %342, %235
%242 = load i64, i64* %21
%243 = load i64, i64* %14
%244 = icmp ult i64 %242, %243
br i1 %244, label %245, label %345
245: ; preds = %241
%246 = load i64, i64* %21
%247 = load i64, i64* %14
%248 = sub i64 %247, 1
%249 = icmp eq i64 %246, %248
br i1 %249, label %250, label %303
250: ; preds = %245
store i32 0, i32* %22
br label %251
251: ; preds = %276, %250
%252 = load i32, i32* %22
%253 = sext i32 %252 to i64
%254 = load i64, i64* %5
%255 = sub i64 32, %254
%256 = icmp ult i64 %253, %255
br i1 %256, label %257, label %279
257: ; preds = %251
%258 = load i64, i64* %21
%259 = mul i64 %258, 32
%260 = load i32, i32* %22
%261 = sext i32 %260 to i64
%262 = add i64 %259, %261
%263 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %262
%264 = load i8, i8* %263
%265 = sext i8 %264 to i32
%266 = icmp eq i32 %265, 49
br i1 %266, label %267, label %275
267: ; preds = %257
%268 = load i32, i32* %22
%269 = shl i32 1, %268
%270 = load i32*, i32** %20
%271 = load i64, i64* %21
%272 = getelementptr inbounds i32, i32* %270, i64 %271
%273 = load i32, i32* %272
%274 = or i32 %273, %269
store i32 %274, i32* %272
br label %275
275: ; preds = %267, %257
br label %276
276: ; preds = %275
%277 = load i32, i32* %22
%278 = add nsw i32 %277, 1
store i32 %278, i32* %22
br label %251
279: ; preds = %251
%280 = load i32, i32* %2
%281 = and i32 %280, 1
%282 = icmp ne i32 %281, 0
br i1 %282, label %283, label %302
283: ; preds = %279
%284 = load i64, i64* %5
%285 = sub i64 32, %284
store i64 %285, i64* %23
br label %286
286: ; preds = %298, %283
%287 = load i64, i64* %23
%288 = icmp ult i64 %287, 32
br i1 %288, label %289, label %301
289: ; preds = %286
%290 = load i64, i64* %23
%291 = trunc i64 %290 to i32
%292 = shl i32 1, %291
%293 = load i32*, i32** %20
%294 = load i64, i64* %21
%295 = getelementptr inbounds i32, i32* %293, i64 %294
%296 = load i32, i32* %295
%297 = or i32 %296, %292
store i32 %297, i32* %295
br label %298
298: ; preds = %289
%299 = load i64, i64* %23
%300 = add i64 %299, 1
store i64 %300, i64* %23
br label %286
301: ; preds = %286
br label %302
302: ; preds = %301, %279
br label %330
303: ; preds = %245
store i32 0, i32* %24
br label %304
304: ; preds = %326, %303
%305 = load i32, i32* %24
%306 = icmp slt i32 %305, 32
br i1 %306, label %307, label %329
307: ; preds = %304
%308 = load i64, i64* %21
%309 = mul i64 %308, 32
%310 = load i32, i32* %24
%311 = sext i32 %310 to i64
%312 = add i64 %309, %311
%313 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %312
%314 = load i8, i8* %313
%315 = sext i8 %314 to i32
%316 = icmp eq i32 %315, 49
br i1 %316, label %317, label %325
317: ; preds = %307
%318 = load i32, i32* %24
%319 = shl i32 1, %318
%320 = load i32*, i32** %20
%321 = load i64, i64* %21
%322 = getelementptr inbounds i32, i32* %320, i64 %321
%323 = load i32, i32* %322
%324 = or i32 %323, %319
store i32 %324, i32* %322
br label %325
325: ; preds = %317, %307
br label %326
326: ; preds = %325
%327 = load i32, i32* %24
%328 = add nsw i32 %327, 1
store i32 %328, i32* %24
br label %304
329: ; preds = %304
br label %330
330: ; preds = %329, %302
%331 = load i32*, i32** %20
%332 = load i64, i64* %21
%333 = getelementptr inbounds i32, i32* %331, i64 %332
%334 = load i32, i32* %333
%335 = load i32*, i32** %15
%336 = load i64, i64* %21
%337 = getelementptr inbounds i32, i32* %335, i64 %336
%338 = load i32, i32* %337
%339 = icmp ne i32 %334, %338
br i1 %339, label %340, label %341
340: ; preds = %330
store i32 0, i32* %19
br label %345
341: ; preds = %330
br label %342
342: ; preds = %341
%343 = load i64, i64* %21
%344 = add i64 %343, 1
store i64 %344, i64* %21
br label %241
345: ; preds = %340, %241
%346 = load i32, i32* %19
%347 = icmp ne i32 %346, 0
%348 = zext i1 %347 to i64
%349 = select i1 %347, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0)
%350 = call i32 @printf(i8* %349)
br label %351
351: ; preds = %345, %139
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [20 x i8] c"Deletion succeeded\0A\00"
@.str.3 = [17 x i8] c"Deletion failed\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1001 x i8]
%3 = bitcast i32* %1 to i8*
%4 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%5 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 0
%6 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%7 = call i64 @strlen(i8* %5)
%8 = and i64 %7, 31
%9 = icmp eq i64 %8, 0
%10 = lshr i64 %7, 5
br i1 %9, label %11, label %99
11: ; preds = %0
%12 = call i64 @calloc(i64 %10, i32 4)
%13 = inttoptr i64 %12 to i32*
%14 = icmp ult i64 %7, 32
br i1 %14, label %21, label %15
15: ; preds = %11
%16 = call i64 @llvm.umax.i64(i64 %10, i64 1)
br label %17
17: ; preds = %15, %59
%18 = phi i64 [ %60, %59 ], [ 0, %15 ]
%19 = shl i64 %18, 5
%20 = getelementptr inbounds i32, i32* %13, i64 %18
br label %31
21: ; preds = %59, %11
%22 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%23 = call i64 @calloc(i64 %10, i32 4)
%24 = inttoptr i64 %23 to i32*
br i1 %14, label %345, label %25
25: ; preds = %21
%26 = call i64 @llvm.umax.i64(i64 %10, i64 1)
br label %64
27: ; preds = %53
%28 = load i32, i32* %1
%29 = and i32 %28, 1
%30 = icmp eq i32 %29, 0
br i1 %30, label %59, label %56
31: ; preds = %53, %17
%32 = phi i64 [ 0, %17 ], [ %54, %53 ]
%33 = add nuw nsw i64 %19, %32
%34 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %33
%35 = load i8, i8* %34
%36 = icmp eq i8 %35, 49
br i1 %36, label %37, label %42
37: ; preds = %31
%38 = trunc i64 %32 to i32
%39 = shl nuw i32 1, %38
%40 = load i32, i32* %20
%41 = or i32 %40, %39
store i32 %41, i32* %20
br label %42
42: ; preds = %31, %37
%43 = or i64 %32, 1
%44 = add nuw nsw i64 %19, %43
%45 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %44
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 49
br i1 %47, label %48, label %53
48: ; preds = %42
%49 = trunc i64 %43 to i32
%50 = shl nuw i32 1, %49
%51 = load i32, i32* %20
%52 = or i32 %51, %50
store i32 %52, i32* %20
br label %53
53: ; preds = %48, %42
%54 = add nuw nsw i64 %32, 2
%55 = icmp eq i64 %54, 32
br i1 %55, label %27, label %31
56: ; preds = %27
%57 = load i32, i32* %20
%58 = xor i32 %57, -1
store i32 %58, i32* %20
br label %59
59: ; preds = %27, %56
%60 = add nuw nsw i64 %18, 1
%61 = icmp eq i64 %60, %16
br i1 %61, label %21, label %17
62: ; preds = %68
%63 = icmp eq i64 %73, %26
br i1 %63, label %345, label %64
64: ; preds = %25, %62
%65 = phi i64 [ %73, %62 ], [ 0, %25 ]
%66 = shl i64 %65, 5
%67 = getelementptr inbounds i32, i32* %24, i64 %65
br label %74
68: ; preds = %96
%69 = load i32, i32* %67
%70 = getelementptr inbounds i32, i32* %13, i64 %65
%71 = load i32, i32* %70
%72 = icmp eq i32 %69, %71
%73 = add nuw nsw i64 %65, 1
br i1 %72, label %62, label %345
74: ; preds = %96, %64
%75 = phi i64 [ 0, %64 ], [ %97, %96 ]
%76 = add nuw nsw i64 %66, %75
%77 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %76
%78 = load i8, i8* %77
%79 = icmp eq i8 %78, 49
br i1 %79, label %80, label %85
80: ; preds = %74
%81 = trunc i64 %75 to i32
%82 = shl nuw i32 1, %81
%83 = load i32, i32* %67
%84 = or i32 %83, %82
store i32 %84, i32* %67
br label %85
85: ; preds = %74, %80
%86 = or i64 %75, 1
%87 = add nuw nsw i64 %66, %86
%88 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = icmp eq i8 %89, 49
br i1 %90, label %91, label %96
91: ; preds = %85
%92 = trunc i64 %86 to i32
%93 = shl nuw i32 1, %92
%94 = load i32, i32* %67
%95 = or i32 %94, %93
store i32 %95, i32* %67
br label %96
96: ; preds = %91, %85
%97 = add nuw nsw i64 %75, 2
%98 = icmp eq i64 %97, 32
br i1 %98, label %68, label %74
99: ; preds = %0
%100 = add nuw nsw i64 %10, 1
%101 = call i64 @calloc(i64 %100, i32 4)
%102 = inttoptr i64 %101 to i32*
%103 = and i64 %7, -32
%104 = getelementptr inbounds i32, i32* %102, i64 %10
%105 = add nsw i64 %8, -1
%106 = and i64 %7, 1
%107 = icmp eq i64 %105, 0
%108 = sub nsw i64 %8, %106
%109 = icmp eq i64 %106, 0
br label %125
110: ; preds = %204
%111 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%112 = call i64 @calloc(i64 %100, i32 4)
%113 = inttoptr i64 %112 to i32*
%114 = and i64 %7, -32
%115 = getelementptr inbounds i32, i32* %113, i64 %10
%116 = sub i64 0, %7
%117 = xor i64 %8, 31
%118 = and i64 %7, 1
%119 = icmp eq i64 %105, 0
%120 = sub nsw i64 %8, %118
%121 = icmp eq i64 %118, 0
%122 = and i64 %116, 7
%123 = icmp eq i64 %122, 0
%124 = icmp ult i64 %117, 7
br label %210
125: ; preds = %99, %204
%126 = phi i64 [ 0, %99 ], [ %205, %204 ]
%127 = icmp eq i64 %126, %10
br i1 %127, label %128, label %129
128: ; preds = %125
br i1 %107, label %184, label %132
129: ; preds = %125
%130 = shl i64 %126, 5
%131 = getelementptr inbounds i32, i32* %102, i64 %126
br label %159
132: ; preds = %128, %155
%133 = phi i64 [ %156, %155 ], [ 0, %128 ]
%134 = phi i64 [ %157, %155 ], [ 0, %128 ]
%135 = add nuw nsw i64 %133, %103
%136 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %135
%137 = load i8, i8* %136
%138 = icmp eq i8 %137, 49
br i1 %138, label %139, label %144
139: ; preds = %132
%140 = trunc i64 %133 to i32
%141 = shl nuw i32 1, %140
%142 = load i32, i32* %104
%143 = or i32 %142, %141
store i32 %143, i32* %104
br label %144
144: ; preds = %132, %139
%145 = or i64 %133, 1
%146 = add nuw nsw i64 %145, %103
%147 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %146
%148 = load i8, i8* %147
%149 = icmp eq i8 %148, 49
br i1 %149, label %150, label %155
150: ; preds = %144
%151 = trunc i64 %145 to i32
%152 = shl nuw i32 1, %151
%153 = load i32, i32* %104
%154 = or i32 %153, %152
store i32 %154, i32* %104
br label %155
155: ; preds = %150, %144
%156 = add nuw nsw i64 %133, 2
%157 = add i64 %134, 2
%158 = icmp eq i64 %157, %108
br i1 %158, label %184, label %132
159: ; preds = %181, %129
%160 = phi i64 [ 0, %129 ], [ %182, %181 ]
%161 = add nuw nsw i64 %130, %160
%162 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %161
%163 = load i8, i8* %162
%164 = icmp eq i8 %163, 49
br i1 %164, label %165, label %170
165: ; preds = %159
%166 = trunc i64 %160 to i32
%167 = shl nuw i32 1, %166
%168 = load i32, i32* %131
%169 = or i32 %168, %167
store i32 %169, i32* %131
br label %170
170: ; preds = %159, %165
%171 = or i64 %160, 1
%172 = add nuw nsw i64 %130, %171
%173 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %172
%174 = load i8, i8* %173
%175 = icmp eq i8 %174, 49
br i1 %175, label %176, label %181
176: ; preds = %170
%177 = trunc i64 %171 to i32
%178 = shl nuw i32 1, %177
%179 = load i32, i32* %131
%180 = or i32 %179, %178
store i32 %180, i32* %131
br label %181
181: ; preds = %176, %170
%182 = add nuw nsw i64 %160, 2
%183 = icmp eq i64 %182, 32
br i1 %183, label %196, label %159
184: ; preds = %155, %128
%185 = phi i64 [ 0, %128 ], [ %156, %155 ]
br i1 %109, label %196, label %186
186: ; preds = %184
%187 = add nuw nsw i64 %185, %103
%188 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %187
%189 = load i8, i8* %188
%190 = icmp eq i8 %189, 49
br i1 %190, label %191, label %196
191: ; preds = %186
%192 = trunc i64 %185 to i32
%193 = shl nuw i32 1, %192
%194 = load i32, i32* %104
%195 = or i32 %194, %193
store i32 %195, i32* %104
br label %196
196: ; preds = %181, %184, %191, %186
%197 = load i32, i32* %1
%198 = and i32 %197, 1
%199 = icmp eq i32 %198, 0
br i1 %199, label %204, label %200
200: ; preds = %196
%201 = getelementptr inbounds i32, i32* %102, i64 %126
%202 = load i32, i32* %201
%203 = xor i32 %202, -1
store i32 %203, i32* %201
br label %204
204: ; preds = %196, %200
%205 = add nuw nsw i64 %126, 1
%206 = icmp eq i64 %126, %10
br i1 %206, label %110, label %125
207: ; preds = %339
%208 = add nuw nsw i64 %211, 1
%209 = icmp eq i64 %211, %10
br i1 %209, label %345, label %210
210: ; preds = %110, %207
%211 = phi i64 [ 0, %110 ], [ %208, %207 ]
%212 = icmp eq i64 %211, %10
br i1 %212, label %213, label %214
213: ; preds = %210
br i1 %119, label %217, label %249
214: ; preds = %210
%215 = shl i64 %211, 5
%216 = getelementptr inbounds i32, i32* %113, i64 %211
br label %312
217: ; preds = %272, %213
%218 = phi i64 [ 0, %213 ], [ %273, %272 ]
br i1 %121, label %229, label %219
219: ; preds = %217
%220 = add nuw nsw i64 %218, %114
%221 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %220
%222 = load i8, i8* %221
%223 = icmp eq i8 %222, 49
br i1 %223, label %224, label %229
224: ; preds = %219
%225 = trunc i64 %218 to i32
%226 = shl nuw i32 1, %225
%227 = load i32, i32* %115
%228 = or i32 %227, %226
store i32 %228, i32* %115
br label %229
229: ; preds = %219, %224, %217
%230 = load i32, i32* %1
%231 = and i32 %230, 1
%232 = icmp eq i32 %231, 0
br i1 %232, label %339, label %233
233: ; preds = %229
%234 = load i32, i32* %115
br i1 %123, label %245, label %235
235: ; preds = %233, %235
%236 = phi i64 [ %242, %235 ], [ %8, %233 ]
%237 = phi i32 [ %241, %235 ], [ %234, %233 ]
%238 = phi i64 [ %243, %235 ], [ 0, %233 ]
%239 = trunc i64 %236 to i32
%240 = shl nuw i32 1, %239
%241 = or i32 %237, %240
%242 = add nuw nsw i64 %236, 1
%243 = add i64 %238, 1
%244 = icmp eq i64 %243, %122
br i1 %244, label %245, label %235
245: ; preds = %235, %233
%246 = phi i32 [ undef, %233 ], [ %241, %235 ]
%247 = phi i64 [ %8, %233 ], [ %242, %235 ]
%248 = phi i32 [ %234, %233 ], [ %241, %235 ]
br i1 %124, label %337, label %276
249: ; preds = %213, %272
%250 = phi i64 [ %273, %272 ], [ 0, %213 ]
%251 = phi i64 [ %274, %272 ], [ 0, %213 ]
%252 = add nuw nsw i64 %250, %114
%253 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %252
%254 = load i8, i8* %253
%255 = icmp eq i8 %254, 49
br i1 %255, label %256, label %261
256: ; preds = %249
%257 = trunc i64 %250 to i32
%258 = shl nuw i32 1, %257
%259 = load i32, i32* %115
%260 = or i32 %259, %258
store i32 %260, i32* %115
br label %261
261: ; preds = %249, %256
%262 = or i64 %250, 1
%263 = add nuw nsw i64 %262, %114
%264 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %263
%265 = load i8, i8* %264
%266 = icmp eq i8 %265, 49
br i1 %266, label %267, label %272
267: ; preds = %261
%268 = trunc i64 %262 to i32
%269 = shl nuw i32 1, %268
%270 = load i32, i32* %115
%271 = or i32 %270, %269
store i32 %271, i32* %115
br label %272
272: ; preds = %267, %261
%273 = add nuw nsw i64 %250, 2
%274 = add i64 %251, 2
%275 = icmp eq i64 %274, %120
br i1 %275, label %217, label %249
276: ; preds = %245, %276
%277 = phi i64 [ %310, %276 ], [ %247, %245 ]
%278 = phi i32 [ %309, %276 ], [ %248, %245 ]
%279 = trunc i64 %277 to i32
%280 = shl nuw i32 1, %279
%281 = or i32 %278, %280
%282 = trunc i64 %277 to i32
%283 = add i32 %282, 1
%284 = shl nuw i32 1, %283
%285 = or i32 %281, %284
%286 = trunc i64 %277 to i32
%287 = add i32 %286, 2
%288 = shl nuw i32 1, %287
%289 = or i32 %285, %288
%290 = trunc i64 %277 to i32
%291 = add i32 %290, 3
%292 = shl nuw i32 1, %291
%293 = or i32 %289, %292
%294 = trunc i64 %277 to i32
%295 = add i32 %294, 4
%296 = shl nuw i32 1, %295
%297 = or i32 %293, %296
%298 = trunc i64 %277 to i32
%299 = add i32 %298, 5
%300 = shl nuw i32 1, %299
%301 = or i32 %297, %300
%302 = trunc i64 %277 to i32
%303 = add i32 %302, 6
%304 = shl nuw i32 1, %303
%305 = or i32 %301, %304
%306 = trunc i64 %277 to i32
%307 = add i32 %306, 7
%308 = shl nuw i32 1, %307
%309 = or i32 %305, %308
%310 = add nuw nsw i64 %277, 8
%311 = icmp eq i64 %310, 32
br i1 %311, label %337, label %276
312: ; preds = %334, %214
%313 = phi i64 [ 0, %214 ], [ %335, %334 ]
%314 = add nuw nsw i64 %215, %313
%315 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %314
%316 = load i8, i8* %315
%317 = icmp eq i8 %316, 49
br i1 %317, label %318, label %323
318: ; preds = %312
%319 = trunc i64 %313 to i32
%320 = shl nuw i32 1, %319
%321 = load i32, i32* %216
%322 = or i32 %321, %320
store i32 %322, i32* %216
br label %323
323: ; preds = %312, %318
%324 = or i64 %313, 1
%325 = add nuw nsw i64 %215, %324
%326 = getelementptr inbounds [1001 x i8], [1001 x i8]* %2, i64 0, i64 %325
%327 = load i8, i8* %326
%328 = icmp eq i8 %327, 49
br i1 %328, label %329, label %334
329: ; preds = %323
%330 = trunc i64 %324 to i32
%331 = shl nuw i32 1, %330
%332 = load i32, i32* %216
%333 = or i32 %332, %331
store i32 %333, i32* %216
br label %334
334: ; preds = %329, %323
%335 = add nuw nsw i64 %313, 2
%336 = icmp eq i64 %335, 32
br i1 %336, label %339, label %312
337: ; preds = %276, %245
%338 = phi i32 [ %246, %245 ], [ %309, %276 ]
store i32 %338, i32* %115
br label %339
339: ; preds = %334, %337, %229
%340 = getelementptr inbounds i32, i32* %113, i64 %211
%341 = load i32, i32* %340
%342 = getelementptr inbounds i32, i32* %102, i64 %211
%343 = load i32, i32* %342
%344 = icmp eq i32 %341, %343
br i1 %344, label %207, label %345
345: ; preds = %207, %339, %68, %62, %21
%346 = phi i8* [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), %21 ], [ getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), %68 ], [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), %62 ], [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), %207 ], [ getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), %339 ]
%347 = call i32 @printf(i8* dereferenceable(1) %346)
ret i32 0
}