#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 /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, ...);
int /*<<< orphan*/ strcpy(char *, char *);
long long strlen(char *);
int main() {
  long long int d;
  scanf("%lld", &d);
  while (d--) {
    long long int i = 0, l = 0, count[30] = {0}, flag = 0, t = -1, p = 0,
                  secondhalf = 0;
    long long int j = 0, mid = 0, cnt = 0, temp = 0, who = 0, firsthalf = 0,
                  z = 0;
    char a[1000020], b[1000020];
    scanf("%s", &a);
    l = strlen(a);
    if (l == 1) {
      printf("NO\n");
    } else {
      mid = (l / 2);
      for (i = 0; i < l; i++) {
        temp = (int)a[i] - 96;
        count[temp]++;
      }
      for (i = 0; i < 30; i++) {
        if (count[i] % 2 == 1) {
          flag++;
          who = i + 96;
        }
      }
      if (flag > 1) {
        printf("NO\n");
      } else {
        for (i = 0; i < mid; i++) {
          if (who == ((int)a[i])) {
            firsthalf++;
          }
        }
        for (i = mid; i < l; i++) {
          if (who == ((int)a[i])) {
            secondhalf++;
          }
        }
        if (secondhalf >= firsthalf) {
          i = 0;
          j = mid = (l / 2);
          if (l % 2 == 0) {
            while (1) {
              if (i < mid && j < l) {
                if (a[i] != a[j]) {
                  cnt = 10;
                  break;
                } else {
                  i++;
                  j++;
                }
              } else {
                break;
              }
            }
          } else {
            while (1) {
              if (i < mid && j < l) {
                if (a[i] != a[j]) {
                  cnt++;
                  j++;
                } else {
                  i++;
                  j++;
                }
              } else {
                break;
              }
            }
            while (j < l) {
              cnt++;
              j++;
            }
          }
          l = l - cnt;
          if (cnt < 2 && l % 2 == 0) {
            printf("YES\n");
          } else {
            while (a[++t] != '\0')
              ;
            while (t >= 0)
              b[p++] = a[--t];
            b[p] = '\0';
            strcpy(a, b);
            l = strlen(a);
            i = 0;
            j = mid = (l / 2);
            cnt = 0;
            if (l % 2 == 0) {
              while (1) {
                if (i < mid || j < l) {
                  if (a[i] != a[j]) {
                    cnt = 10;
                    break;
                  } else {
                    i++;
                    j++;
                  }
                } else {
                  break;
                }
              }
              while (j < l) {
                cnt++;
                j++;
              }
            } else {
              while (1) {
                if (i < mid && j < l) {
                  if (a[i] != a[j]) {
                    cnt++;
                    j++;
                  } else {
                    i++;
                    j++;
                  }
                } else {
                  break;
                }
              }
              while (j < l) {
                cnt++;
                j++;
              }
            }
            l = l - cnt;
            if (cnt < 2 && l % 2 == 0) {
              printf("YES\n");
            } else {
              printf("NO\n");
            }
          }
        } else {
          while (a[++t] != '\0')
            ;
          while (t >= 0)
            b[p++] = a[--t];
          b[p] = '\0';
          strcpy(a, b);
          i = 0;
          j = mid = (l / 2);
          if (l % 2 == 0) {
            while (1) {
              if (i < mid || j < l) {
                if (a[i] != a[j]) {
                  cnt = 10;
                  break;
                } else {
                  i++;
                  j++;
                }
              } else {
                break;
              }
            }
            while (j < l) {
              cnt++;
              j++;
            }
          } else {
            while (1) {
              if (i < mid && j < l) {
                if (a[i] != a[j]) {
                  cnt++;
                  j++;
                } else {
                  i++;
                  j++;
                }
              } else {
                break;
              }
            }
            while (j < l) {
              cnt++;
              j++;
            }
          }
          l = l - cnt;
          if (cnt < 2 && l % 2 == 0) {
            printf("YES\n");
          } else {
            printf("NO\n");
          }
        }
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e8620,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe97(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
cmp    $0x0,%rax
je     1c1f <main+0xacf>
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0xf0,%edx
call   1060 <memset@plt>
movq   $0x0,-0x118(%rbp)
movq   $0xffffffffffffffff,-0x120(%rbp)
ff ff ff ff
movq   $0x0,-0x128(%rbp)
movq   $0x0,-0x130(%rbp)
movq   $0x0,-0x138(%rbp)
movq   $0x0,-0x140(%rbp)
movq   $0x0,-0x148(%rbp)
movq   $0x0,-0x150(%rbp)
movq   $0x0,-0x158(%rbp)
movq   $0x0,-0x160(%rbp)
movq   $0x0,-0x168(%rbp)
lea    0xdd5(%rip),%rdi
lea    -0xf43c0(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
lea    -0xf43c0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x1,-0x20(%rbp)
jne    126a <main+0x11a>
lea    0xda8(%rip),%rdi
call   1050 <printf@plt>
jmp    1c1a <main+0xaca>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x140(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    12d9 <main+0x189>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
sub    $0x60,%eax
cltq
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
mov    -0x110(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x110(%rbp,%rax,8)
ff
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1287 <main+0x137>
movq   $0x0,-0x18(%rbp)
cmpq   $0x1e,-0x18(%rbp)
jge    1343 <main+0x1f3>
mov    -0x18(%rbp),%rax
mov    -0x110(%rbp,%rax,8),%rax
ff
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x1,%rdx
jne    132d <main+0x1dd>
mov    -0x118(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x118(%rbp)
mov    -0x18(%rbp),%rax
add    $0x60,%rax
mov    %rax,-0x158(%rbp)
jmp    1332 <main+0x1e2>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    12e1 <main+0x191>
cmpq   $0x1,-0x118(%rbp)
01
jle    1362 <main+0x212>
lea    0xcb0(%rip),%rdi
call   1050 <printf@plt>
jmp    1c15 <main+0xac5>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jge    13c2 <main+0x272>
mov    -0x158(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    13ac <main+0x25c>
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    13b1 <main+0x261>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    136a <main+0x21a>
mov    -0x140(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1422 <main+0x2d2>
mov    -0x158(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    140c <main+0x2bc>
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
jmp    1411 <main+0x2c1>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    13cd <main+0x27d>
mov    -0x130(%rbp),%rax
cmp    -0x160(%rbp),%rax
jl     192c <main+0x7dc>
movq   $0x0,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x140(%rbp)
mov    %rax,-0x138(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    14fe <main+0x3ae>
jmp    1477 <main+0x327>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jge    14ef <main+0x39f>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    14ef <main+0x39f>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     14cc <main+0x37c>
movq   $0xa,-0x148(%rbp)
jmp    14f9 <main+0x3a9>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    14f4 <main+0x3a4>
jmp    14f9 <main+0x3a9>
jmp    1477 <main+0x327>
jmp    15e2 <main+0x492>
jmp    1503 <main+0x3b3>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jge    1594 <main+0x444>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1594 <main+0x444>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     1571 <main+0x421>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    158f <main+0x43f>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1599 <main+0x449>
jmp    159e <main+0x44e>
jmp    1503 <main+0x3b3>
jmp    15a3 <main+0x453>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    15dd <main+0x48d>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    15a3 <main+0x453>
jmp    15e2 <main+0x492>
mov    -0x20(%rbp),%rax
sub    -0x148(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x2,-0x148(%rbp)
02
jge    1628 <main+0x4d8>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    1628 <main+0x4d8>
lea    0x9ee(%rip),%rdi
call   1050 <printf@plt>
jmp    1927 <main+0x7d7>
jmp    162d <main+0x4dd>
mov    -0x120(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x120(%rbp)
movsbl -0xf43bf(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1658 <main+0x508>
jmp    162d <main+0x4dd>
jmp    165d <main+0x50d>
cmpq   $0x0,-0x120(%rbp)
jl     16a8 <main+0x558>
mov    -0x120(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x120(%rbp)
mov    -0xf43c1(%rbp,%rax,1),%cl
mov    -0x128(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x128(%rbp)
mov    %cl,-0x1e8620(%rbp,%rax,1)
jmp    165d <main+0x50d>
mov    -0x128(%rbp),%rax
movb   $0x0,-0x1e8620(%rbp,%rax,1)
lea    -0xf43c0(%rbp),%rdi
lea    -0x1e8620(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0xf43c0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x20(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x140(%rbp)
mov    %rax,-0x138(%rbp)
movq   $0x0,-0x148(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    17ec <main+0x69c>
jmp    1726 <main+0x5d6>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jl     1748 <main+0x5f8>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    179e <main+0x64e>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     177b <main+0x62b>
movq   $0xa,-0x148(%rbp)
jmp    17a8 <main+0x658>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    17a3 <main+0x653>
jmp    17a8 <main+0x658>
jmp    1726 <main+0x5d6>
jmp    17ad <main+0x65d>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    17e7 <main+0x697>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    17ad <main+0x65d>
jmp    18d0 <main+0x780>
jmp    17f1 <main+0x6a1>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jge    1882 <main+0x732>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1882 <main+0x732>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     185f <main+0x70f>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    187d <main+0x72d>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1887 <main+0x737>
jmp    188c <main+0x73c>
jmp    17f1 <main+0x6a1>
jmp    1891 <main+0x741>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    18cb <main+0x77b>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1891 <main+0x741>
jmp    18d0 <main+0x780>
mov    -0x20(%rbp),%rax
sub    -0x148(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x2,-0x148(%rbp)
02
jge    1916 <main+0x7c6>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    1916 <main+0x7c6>
lea    0x700(%rip),%rdi
call   1050 <printf@plt>
jmp    1922 <main+0x7d2>
lea    0x6eb(%rip),%rdi
call   1050 <printf@plt>
jmp    1927 <main+0x7d7>
jmp    1c10 <main+0xac0>
jmp    1931 <main+0x7e1>
mov    -0x120(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x120(%rbp)
movsbl -0xf43bf(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     195c <main+0x80c>
jmp    1931 <main+0x7e1>
jmp    1961 <main+0x811>
cmpq   $0x0,-0x120(%rbp)
jl     19ac <main+0x85c>
mov    -0x120(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x120(%rbp)
mov    -0xf43c1(%rbp,%rax,1),%cl
mov    -0x128(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x128(%rbp)
mov    %cl,-0x1e8620(%rbp,%rax,1)
jmp    1961 <main+0x811>
mov    -0x128(%rbp),%rax
movb   $0x0,-0x1e8620(%rbp,%rax,1)
lea    -0xf43c0(%rbp),%rdi
lea    -0x1e8620(%rbp),%rsi
call   1030 <strcpy@plt>
movq   $0x0,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x140(%rbp)
mov    %rax,-0x138(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    1ad5 <main+0x985>
jmp    1a0f <main+0x8bf>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jl     1a31 <main+0x8e1>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1a87 <main+0x937>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     1a64 <main+0x914>
movq   $0xa,-0x148(%rbp)
jmp    1a91 <main+0x941>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1a8c <main+0x93c>
jmp    1a91 <main+0x941>
jmp    1a0f <main+0x8bf>
jmp    1a96 <main+0x946>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1ad0 <main+0x980>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1a96 <main+0x946>
jmp    1bb9 <main+0xa69>
jmp    1ada <main+0x98a>
mov    -0x18(%rbp),%rax
cmp    -0x140(%rbp),%rax
jge    1b6b <main+0xa1b>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1b6b <main+0xa1b>
mov    -0x18(%rbp),%rax
movsbl -0xf43c0(%rbp,%rax,1),%eax
ff
mov    -0x138(%rbp),%rcx
movsbl -0xf43c0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     1b48 <main+0x9f8>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1b66 <main+0xa16>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1b70 <main+0xa20>
jmp    1b75 <main+0xa25>
jmp    1ada <main+0x98a>
jmp    1b7a <main+0xa2a>
mov    -0x138(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1bb4 <main+0xa64>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
mov    -0x138(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    1b7a <main+0xa2a>
jmp    1bb9 <main+0xa69>
mov    -0x20(%rbp),%rax
sub    -0x148(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x2,-0x148(%rbp)
02
jge    1bff <main+0xaaf>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    1bff <main+0xaaf>
lea    0x417(%rip),%rdi
call   1050 <printf@plt>
jmp    1c0b <main+0xabb>
lea    0x402(%rip),%rdi
call   1050 <printf@plt>
jmp    1c10 <main+0xac0>
jmp    1c15 <main+0xac5>
jmp    1c1a <main+0xaca>
jmp    1174 <main+0x24>
xor    %eax,%eax
add    $0x1e8620,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e85b8,%rsp
lea    0xea8(%rip),%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
subq   $0x1,0x8(%rsp)
jae    1180 <main+0x40>
xor    %eax,%eax
add    $0x1e85b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
lea    0x100(%rsp),%r12
lea    0xe79(%rip),%r13
jmp    11b1 <main+0x71>
mov    %r13,%rdi
nopl   0x0(%rax,%rax,1)
call   1040 <puts@plt>
subq   $0x1,0x8(%rsp)
pxor   %xmm0,%xmm0
jb     116c <main+0x2c>
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0x90(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x10(%rsp)
lea    0xddb(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
mov    %r13,%rdi
cmp    $0x1,%rax
je     11a0 <main+0x60>
mov    %rax,%r14
mov    %rax,%r15
shr    $0x3f,%r15
add    %rax,%r15
test   %rax,%rax
jle    12b5 <main+0x175>
cmp    $0x1,%r14
jne    1265 <main+0x125>
xor    %eax,%eax
jmp    129d <main+0x15d>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movsbq 0x100(%rsp,%rax,1),%rdx
addq   $0x1,-0x2f0(%rsp,%rdx,8)
ff 01
movsbq 0x101(%rsp,%rax,1),%rdx
addq   $0x1,-0x2f0(%rsp,%rdx,8)
ff 01
add    $0x2,%rax
cmp    %rax,%rcx
jne    1270 <main+0x130>
test   $0x1,%r14b
je     12b5 <main+0x175>
movsbq 0x100(%rsp,%rax,1),%rax
addq   $0x1,-0x2f0(%rsp,%rax,8)
ff 01
sar    %r15
mov    $0x60,%ecx
xor    %ebx,%ebx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x2f0(%rsp,%rcx,8),%rbp
ff
mov    -0x2e8(%rsp,%rcx,8),%rdi
ff
mov    %rbp,%rsi
shr    $0x3f,%rsi
add    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
sub    %rsi,%rbp
xor    %esi,%esi
cmp    $0x1,%rbp
sete   %sil
mov    %rbx,%rax
cmove  %rcx,%rax
add    %rdx,%rsi
mov    %rdi,%rdx
shr    $0x3f,%rdx
add    %rdi,%rdx
and    $0xfffffffffffffffe,%rdx
sub    %rdx,%rdi
lea    0x1(%rcx),%rbx
xor    %edx,%edx
cmp    $0x1,%rdi
cmovne %rax,%rbx
sete   %dl
add    %rsi,%rdx
add    $0x2,%rcx
cmp    $0x7e,%rcx
jne    12d0 <main+0x190>
mov    %r13,%rdi
cmp    $0x1,%rdx
ja     11a0 <main+0x60>
cmp    $0x2,%r14
jl     135d <main+0x21d>
lea    -0x1(%r15),%rax
mov    %r15d,%edx
and    $0x3,%edx
cmp    $0x3,%rax
jae    1364 <main+0x224>
xor    %esi,%esi
xor    %ecx,%ecx
jmp    13cb <main+0x28b>
xor    %ecx,%ecx
jmp    13fa <main+0x2ba>
mov    %r15,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
xor    %ecx,%ecx
nop
movsbq 0x100(%rsp,%rsi,1),%rax
xor    %ebp,%ebp
cmp    %rax,%rbx
sete   %bpl
add    %rcx,%rbp
movsbq 0x101(%rsp,%rsi,1),%rax
xor    %ecx,%ecx
cmp    %rax,%rbx
sete   %cl
add    %rbp,%rcx
movsbq 0x102(%rsp,%rsi,1),%rax
xor    %ebp,%ebp
cmp    %rax,%rbx
sete   %bpl
add    %rcx,%rbp
movsbq 0x103(%rsp,%rsi,1),%rax
xor    %ecx,%ecx
cmp    %rax,%rbx
sete   %cl
add    %rbp,%rcx
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1370 <main+0x230>
test   %rdx,%rdx
je     13fa <main+0x2ba>
add    %rsp,%rsi
add    $0x100,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movsbq (%rsi,%rdi,1),%rax
xor    %ebp,%ebp
cmp    %rax,%rbx
sete   %bpl
add    %rbp,%rcx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    13e0 <main+0x2a0>
mov    %r14,%r9
sub    %r15,%r9
jle    141f <main+0x2df>
mov    %r15,%rax
not    %rax
add    %r14,%rax
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1426 <main+0x2e6>
mov    %r15,%rax
xor    %esi,%esi
jmp    148d <main+0x34d>
xor    %esi,%esi
jmp    14b9 <main+0x379>
and    $0xfffffffffffffffc,%r9
mov    %r15,%rax
xor    %esi,%esi
nop
movsbq 0x100(%rsp,%rax,1),%rbp
xor    %edx,%edx
cmp    %rbp,%rbx
sete   %dl
add    %rsi,%rdx
movsbq 0x101(%rsp,%rax,1),%rsi
xor    %ebp,%ebp
cmp    %rsi,%rbx
sete   %bpl
add    %rdx,%rbp
movsbq 0x102(%rsp,%rax,1),%rdx
xor    %edi,%edi
cmp    %rdx,%rbx
sete   %dil
add    %rbp,%rdi
movsbq 0x103(%rsp,%rax,1),%rdx
xor    %esi,%esi
cmp    %rdx,%rbx
sete   %sil
add    %rdi,%rsi
add    $0x4,%rax
add    $0xfffffffffffffffc,%r9
jne    1430 <main+0x2f0>
test   %r8,%r8
je     14b9 <main+0x379>
lea    (%rsp,%rax,1),%rdi
add    $0x100,%rdi
xor    %ebp,%ebp
nop
movsbq (%rdi,%rbp,1),%rax
xor    %edx,%edx
cmp    %rax,%rbx
sete   %dl
add    %rdx,%rsi
add    $0x1,%rbp
cmp    %rbp,%r8
jne    14a0 <main+0x360>
cmp    %rcx,%rsi
jae    1525 <main+0x3e5>
mov    $0xffffffffffffffff,%rax
mov    $0x1,%esi
lea    0xf8(%rsp),%rdx
lea    0xf0(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
mov    %rax,%rdi
mov    %rbp,%rcx
mov    %rsi,%r10
mov    %rdx,%rbx
add    $0x1,%rax
add    $0x1,%rbp
add    $0x1,%rsi
add    $0x1,%rdx
cmpb   $0x0,0x101(%rsp,%rdi,1)
jne    14e0 <main+0x3a0>
cmp    $0xffffffffffffffff,%rdi
jl     158b <main+0x44b>
lea    0x2(%rdi),%r8
cmp    $0x8,%r8
pxor   %xmm3,%xmm3
jae    15d9 <main+0x499>
xor    %edx,%edx
jmp    18c3 <main+0x783>
cmp    %r15,%r14
setg   %cl
cmp    $0x2,%r14
setge  %al
and    %cl,%al
test   $0x1,%r14b
jne    1593 <main+0x453>
test   %al,%al
je     15d5 <main+0x495>
lea    (%rsp,%r15,1),%rax
add    $0x100,%rax
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0xff(%rsp,%rcx,1),%edx
cmp    -0x1(%rax,%rcx,1),%dl
jne    1617 <main+0x4d7>
cmp    %r15,%rcx
jge    15d5 <main+0x495>
lea    (%r15,%rcx,1),%rsi
add    $0x1,%rcx
mov    $0x0,%edx
cmp    %r14,%rsi
jl     1560 <main+0x420>
jmp    1603 <main+0x4c3>
xor    %r8d,%r8d
jmp    18e7 <main+0x7a7>
test   %al,%al
je     15ea <main+0x4aa>
xor    %edx,%edx
xor    %ecx,%ecx
mov    %r15,%rax
xchg   %ax,%ax
mov    %rcx,%rsi
mov    %rdx,%rdi
movzbl 0x100(%rsp,%rdx,1),%ebx
xor    %edx,%edx
xor    %ecx,%ecx
cmp    0x100(%rsp,%rax,1),%bl
sete   %dl
setne  %cl
add    %rsi,%rcx
add    %rdi,%rdx
add    $0x1,%rax
cmp    %r15,%rdx
jge    15ef <main+0x4af>
cmp    %r14,%rax
jl     15a0 <main+0x460>
jmp    15ef <main+0x4af>
xor    %edx,%edx
jmp    1603 <main+0x4c3>
cmp    $0x20,%r8
jae    169a <main+0x55a>
xor    %edx,%edx
jmp    174b <main+0x60b>
mov    %r15,%rax
xor    %ecx,%ecx
lea    (%r14,%rcx,1),%rdx
sub    %rax,%rdx
cmp    %r14,%rax
cmovge %rcx,%rdx
cmp    $0x2,%rdx
jae    1617 <main+0x4d7>
sub    %edx,%r14d
lea    0x9fb(%rip),%rdi
test   $0x1,%r14b
je     11a0 <main+0x60>
mov    $0xffffffffffffffff,%rax
mov    $0x1,%edx
lea    0xf8(%rsp),%rsi
lea    0xf0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rdi
mov    %rbx,%rcx
mov    %rdx,%r10
mov    %rsi,%rbp
add    $0x1,%rax
add    $0x1,%rbx
add    $0x1,%rdx
add    $0x1,%rsi
cmpb   $0x0,0x101(%rsp,%rdi,1)
jne    1640 <main+0x500>
cmp    $0xffffffffffffffff,%rdi
jl     1681 <main+0x541>
lea    0x2(%rdi),%r8
cmp    $0x8,%r8
pxor   %xmm3,%xmm3
jae    1689 <main+0x549>
xor    %esi,%esi
jmp    1a00 <main+0x8c0>
xor    %r8d,%r8d
jmp    1a27 <main+0x8e7>
cmp    $0x20,%r8
jae    17af <main+0x66f>
xor    %esi,%esi
jmp    185b <main+0x71b>
mov    %r8,%rdx
and    $0xffffffffffffffe0,%rdx
mov    %r10,%r9
and    $0xffffffffffffffe0,%r9
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rcx),%xmm0
movdqu (%rcx),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm1,0xf4360(%rsp,%rsi,1)
movdqa %xmm0,0xf4370(%rsp,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rcx
cmp    %rsi,%r9
jne    16b0 <main+0x570>
cmp    %rdx,%r8
je     18e7 <main+0x7a7>
test   $0x18,%r8b
je     18c0 <main+0x780>
mov    %rdx,%rsi
add    $0x2,%rdi
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
sub    %rdx,%rax
sub    %rsi,%rbx
mov    %r10,%rbp
and    $0xfffffffffffffff8,%rbp
cs nopw 0x0(%rax,%rax,1)
movq   (%rbx),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0xf4360(%rsp,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rbx
cmp    %rsi,%rbp
jne    1770 <main+0x630>
cmp    %rdx,%rdi
jne    18c3 <main+0x783>
jmp    18e7 <main+0x7a7>
mov    %r8,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %r10,%r9
and    $0xffffffffffffffe0,%r9
xor    %edx,%edx
nop
movdqu -0x10(%rcx),%xmm0
movdqu (%rcx),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm1,0xf4360(%rsp,%rdx,1)
movdqa %xmm0,0xf4370(%rsp,%rdx,1)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rcx
cmp    %rdx,%r9
jne    17c0 <main+0x680>
cmp    %rsi,%r8
je     1a27 <main+0x8e7>
test   $0x18,%r8b
je     19fd <main+0x8bd>
mov    %rsi,%rdx
add    $0x2,%rdi
mov    %rdi,%rsi
and    $0xfffffffffffffff8,%rsi
sub    %rsi,%rax
sub    %rdx,%rbp
mov    %r10,%rbx
and    $0xfffffffffffffff8,%rbx
cs nopw 0x0(%rax,%rax,1)
movq   0x0(%rbp),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0xf4360(%rsp,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbp
cmp    %rdx,%rbx
jne    1880 <main+0x740>
cmp    %rsi,%rdi
jne    1a00 <main+0x8c0>
jmp    1a27 <main+0x8e7>
sub    %rdx,%rax
lea    0xff(%rsp),%rcx
add    %rcx,%rax
xchg   %ax,%ax
movzbl (%rax),%ecx
mov    %cl,0xf4360(%rsp,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
cmp    %rdx,%r10
jne    18d0 <main+0x790>
movb   $0x0,0xf4360(%rsp,%r8,1)
mov    %r12,%rdi
lea    0xf4360(%rsp),%rsi
call   1030 <strcpy@plt>
test   $0x1,%r14b
jne    1959 <main+0x819>
cmp    $0x1,%r14
jg     1911 <main+0x7d1>
cmp    %r15,%r14
jle    194d <main+0x80d>
lea    (%rsp,%r15,1),%rax
add    $0x100,%rax
mov    $0x1,%ecx
mov    %rcx,%rdx
movzbl 0xff(%rsp,%rcx,1),%ecx
cmp    -0x1(%rax,%rdx,1),%cl
jne    19bd <main+0x87d>
lea    0x1(%rdx),%rcx
cmp    %r15,%rdx
jl     1920 <main+0x7e0>
add    %r15,%rdx
cmp    %r14,%rdx
jl     1920 <main+0x7e0>
add    %rcx,%r15
add    $0xffffffffffffffff,%r15
xor    %eax,%eax
cmp    %r14,%r15
jl     19ce <main+0x88e>
jmp    19da <main+0x89a>
cmp    $0x2,%r14
jl     19a5 <main+0x865>
cmp    %r15,%r14
jle    19a5 <main+0x865>
xor    %edx,%edx
xor    %eax,%eax
mov    %r15,%rcx
nopl   0x0(%rax,%rax,1)
mov    %rax,%rsi
mov    %rdx,%rdi
movzbl 0x100(%rsp,%rdx,1),%ebx
xor    %edx,%edx
xor    %eax,%eax
cmp    0x100(%rsp,%rcx,1),%bl
sete   %dl
setne  %al
add    %rsi,%rax
add    %rdi,%rdx
add    $0x1,%rcx
cmp    %r15,%rdx
jge    19aa <main+0x86a>
cmp    %r14,%rcx
jl     1970 <main+0x830>
jmp    19aa <main+0x86a>
mov    %r15,%rcx
xor    %eax,%eax
cmp    %r14,%rcx
jge    19da <main+0x89a>
mov    %r14,%rdx
add    %rax,%rdx
sub    %rcx,%rdx
mov    %rdx,%rax
jmp    19da <main+0x89a>
add    %rdx,%r15
add    $0xffffffffffffffff,%r15
mov    $0xa,%eax
cmp    %r14,%r15
jge    19da <main+0x89a>
mov    %r14,%rcx
add    %rax,%rcx
sub    %r15,%rcx
mov    %rcx,%rax
cmp    $0x1,%rax
jg     1195 <main+0x55>
sub    %eax,%r14d
lea    0x61a(%rip),%rdi
test   $0x1,%r14b
jne    1195 <main+0x55>
jmp    11a0 <main+0x60>
sub    %rsi,%rax
lea    0xff(%rsp),%rcx
add    %rcx,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
mov    %cl,0xf4360(%rsp,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
cmp    %rsi,%r10
jne    1a10 <main+0x8d0>
movb   $0x0,0xf4360(%rsp,%r8,1)
mov    %r12,%rdi
lea    0xf4360(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
mov    %rax,%r8
shr    $0x3f,%r8
add    %rax,%r8
sar    %r8
test   $0x1,%al
jne    1ab6 <main+0x976>
cmp    $0x1,%rax
jg     1a64 <main+0x924>
cmp    %rax,%r8
jge    1aad <main+0x96d>
lea    (%rsp,%r8,1),%rdx
add    $0x100,%rdx
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rsi,%rdi
movzbl 0xff(%rsp,%rsi,1),%ebx
cmp    -0x1(%rdx,%rsi,1),%bl
jne    1b18 <main+0x9d8>
lea    0x1(%rdi),%rsi
cmp    %r8,%rdi
jl     1a80 <main+0x940>
add    %r8,%rdi
cmp    %rax,%rdi
jl     1a80 <main+0x940>
add    %rsi,%r8
add    $0xffffffffffffffff,%r8
xor    %edx,%edx
cmp    %rax,%r8
jl     1b29 <main+0x9e9>
jmp    1b2f <main+0x9ef>
cmp    $0x2,%rax
jl     1b06 <main+0x9c6>
cmp    %rax,%r8
jge    1b06 <main+0x9c6>
xor    %edi,%edi
xor    %edx,%edx
mov    %r8,%rsi
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rbp
mov    %rdi,%rbx
movzbl 0x100(%rsp,%rdi,1),%ecx
xor    %edi,%edi
xor    %edx,%edx
cmp    0x100(%rsp,%rsi,1),%cl
sete   %dil
setne  %dl
add    %rbp,%rdx
add    %rbx,%rdi
add    $0x1,%rsi
cmp    %r8,%rdi
jge    1b0b <main+0x9cb>
cmp    %rax,%rsi
jl     1ad0 <main+0x990>
jmp    1b0b <main+0x9cb>
mov    %r8,%rsi
xor    %edx,%edx
cmp    %rax,%rsi
jge    1b2f <main+0x9ef>
add    %rax,%rdx
sub    %rsi,%rdx
jmp    1b2f <main+0x9ef>
add    %rdi,%r8
add    $0xffffffffffffffff,%r8
mov    $0xa,%edx
cmp    %rax,%r8
jge    1b2f <main+0x9ef>
add    %rax,%rdx
sub    %r8,%rdx
cmp    $0x1,%rdx
jg     1195 <main+0x55>
sub    %edx,%eax
lea    0x4c6(%rip),%rdi
test   $0x1,%al
jne    1195 <main+0x55>
jmp    11a0 <main+0x60>

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

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