#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 _gcd(int, int);
int /*<<< orphan*/ gets(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, char *);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int n, m, p, i, j, k = 0, gcd, q;
  scanf("%d ", &m);
  char *s1, *s2, *str, *str1, *str2, *sgcd;
  s1 = (char *)malloc((m + 1) * sizeof(char *));
  gets(s1);
  scanf("\n%d ", &n);
  s2 = (char *)malloc((n + 1) * sizeof(char *));
  str = (char *)malloc((n + 1) * sizeof(char *));
  gets(s2);
  gcd = _gcd(m, n);
  if (n % m == 0) {
    p = n / m;
    for (i = 0; i < p; i++)
      for (j = 0; j < m; j++) {
        str[k] = s1[j];
        k++;
      }
    str[k] = '\0';
    j = 0;
    for (i = 0; i < n; i++)
      if (str[i] == s2[i])
        j++;
    if (j == n)
      printf("%s", s1);
  } else {
    p = m / gcd;
    q = n / gcd;
    sgcd = (char *)malloc((gcd + 1) * sizeof(char *));
    str1 = (char *)malloc((m + 1) * sizeof(char *));
    for (i = 0; i < gcd; i++)
      sgcd[i] = s1[i];
    sgcd[i] = '\0';
    k = 0;
    for (i = 0; i < p; i++)
      for (j = 0; j < gcd; j++) {
        str1[k] = sgcd[j];
        k++;
      }
    str1[k] = '\0';
    str2 = (char *)malloc((n + 1) * sizeof(char *));
    k = 0;
    for (i = 0; i < q; i++)
      for (j = 0; j < gcd; j++) {
        str2[k] = sgcd[j];
        k++;
      }
    str2[k] = '\0';
    j = 0;
    for (i = 0; i < m; i++)
      if (str1[i] == s1[i])
        j++;
    k = 0;
    for (i = 0; i < n; i++)
      if (str2[i] == s2[i])
        k++;
    if (j == m && k == n)
      printf("%s", sgcd);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    0xe94(%rip),%rdi
lea    -0xc(%rbp),%rsi
call   1070 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1050 <gets@plt>
lea    0xe63(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1070 <scanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
call   1050 <gets@plt>
mov    -0xc(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1030 <_gcd@plt>
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
cltd
idivl  -0xc(%rbp)
cmp    $0x0,%edx
jne    12ee <main+0x19e>
mov    -0x8(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    126b <main+0x11b>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1258 <main+0x108>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    121f <main+0xcf>
jmp    125d <main+0x10d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    120c <main+0xbc>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12cd <main+0x17d>
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    12ba <main+0x16a>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12bf <main+0x16f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1285 <main+0x135>
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    12e9 <main+0x199>
mov    -0x30(%rbp),%rsi
lea    0xd21(%rip),%rdi
call   1040 <printf@plt>
jmp    1555 <main+0x405>
mov    -0xc(%rbp),%eax
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1367 <main+0x217>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1337 <main+0x1e7>
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13e0 <main+0x290>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13cd <main+0x27d>
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1394 <main+0x244>
jmp    13d2 <main+0x282>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1381 <main+0x231>
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1470 <main+0x320>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    145d <main+0x30d>
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1424 <main+0x2d4>
jmp    1462 <main+0x312>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1411 <main+0x2c1>
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14d2 <main+0x382>
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    14bf <main+0x36f>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14c4 <main+0x374>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    148a <main+0x33a>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1528 <main+0x3d8>
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1515 <main+0x3c5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    151a <main+0x3ca>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14e0 <main+0x390>
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1550 <main+0x400>
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1550 <main+0x400>
mov    -0x58(%rbp),%rsi
lea    0xaba(%rip),%rdi
call   1040 <printf@plt>
jmp    1555 <main+0x405>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
lea    0xeac(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1070 <scanf@plt>
mov    0x4(%rsp),%eax
lea    0x8(,%rax,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    %rax,%rdi
call   1050 <gets@plt>
lea    0xe7f(%rip),%rdi
mov    %rsp,%rsi
call   1070 <scanf@plt>
mov    (%rsp),%eax
lea    0x8(,%rax,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    (%rsp),%eax
lea    0x8(,%rax,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    %r12,%rdi
call   1050 <gets@plt>
mov    0x4(%rsp),%edi
mov    (%rsp),%esi
call   1030 <_gcd@plt>
mov    %eax,%r13d
mov    (%rsp),%esi
mov    0x4(%rsp),%ecx
mov    %esi,%eax
cltd
idiv   %ecx
test   %edx,%edx
je     12c4 <main+0x174>
mov    %r12,0x20(%rsp)
mov    %ecx,%eax
cltd
idiv   %r13d
mov    %eax,0x8(%rsp)
mov    %esi,%eax
cltd
idiv   %r13d
mov    %eax,0x1c(%rsp)
lea    0x8(,%r13,8),%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    0x4(%rsp),%eax
lea    0x8(,%rax,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r12
xor    %eax,%eax
mov    %r13d,%ebp
test   %r13d,%r13d
jle    133f <main+0x1ef>
cmp    $0x8,%r13d
jb     1252 <main+0x102>
lea    (%r15,%rbp,1),%rcx
cmp    %rbx,%rcx
jbe    1c77 <main+0xb27>
lea    (%rbx,%rbp,1),%rcx
cmp    %r15,%rcx
jbe    1c77 <main+0xb27>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %rbp,%rdi
mov    %rbp,%rsi
and    $0x3,%rsi
je     1282 <main+0x132>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%edx
mov    %dl,(%rbx,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1270 <main+0x120>
cmp    $0x3,%rdi
jb     12bf <main+0x16f>
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%edx
mov    %dl,(%rbx,%rcx,1)
movzbl 0x1(%r15,%rcx,1),%edx
mov    %dl,0x1(%rbx,%rcx,1)
movzbl 0x2(%r15,%rcx,1),%edx
mov    %dl,0x2(%rbx,%rcx,1)
movzbl 0x3(%r15,%rcx,1),%edx
mov    %dl,0x3(%rbx,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1290 <main+0x140>
mov    %rbp,%rcx
jmp    1341 <main+0x1f1>
xor    %edx,%edx
mov    $0x0,%esi
test   %eax,%eax
jle    131a <main+0x1ca>
xor    %edi,%edi
xor    %esi,%esi
jmp    12e7 <main+0x197>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%edi
cmp    %eax,%edi
je     131a <main+0x1ca>
test   %ecx,%ecx
jle    12e0 <main+0x190>
movslq %esi,%rbx
add    %r14,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r15,%rbp,1),%ecx
mov    %cl,(%rbx,%rbp,1)
add    $0x1,%rbp
movslq 0x4(%rsp),%rcx
cmp    %rcx,%rbp
jl     1300 <main+0x1b0>
add    %ebp,%esi
jmp    12e0 <main+0x190>
movslq %esi,%rax
movb   $0x0,(%r14,%rax,1)
mov    (%rsp),%eax
test   %eax,%eax
jle    1c6a <main+0xb1a>
cmp    $0x8,%eax
jae    1b05 <main+0x9b5>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1c50 <main+0xb00>
xor    %ecx,%ecx
mov    0x8(%rsp),%edi
movb   $0x0,(%rbx,%rcx,1)
test   %edi,%edi
jle    1557 <main+0x407>
lea    (%r12,%rbp,1),%rax
mov    %rax,0x58(%rsp)
lea    (%rbx,%rbp,1),%rax
mov    %rax,0x10(%rsp)
mov    %ebp,%r9d
and    $0xffffffe0,%r9d
lea    -0x20(%r9),%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
movabs $0xffffffffffffffc,%rax
ff ff 0f
and    %rax,%rcx
mov    %rcx,0x30(%rsp)
mov    %ebp,%r14d
and    $0x3,%r14d
lea    0x70(%r12),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x40(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0x38(%rsp)
mov    %r10,0x48(%rsp)
shl    $0x5,%r10
xor    %r8d,%r8d
xor    %eax,%eax
jmp    13dd <main+0x28d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8d
cmp    %edi,%r8d
je     1557 <main+0x407>
test   %r13d,%r13d
jle    13d0 <main+0x280>
cltq
cmp    $0x20,%r13d
jb     1407 <main+0x2b7>
lea    (%r12,%rax,1),%rdx
cmp    0x10(%rsp),%rdx
jae    1478 <main+0x328>
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
cmp    %rbx,%rdx
jbe    1478 <main+0x328>
xor    %esi,%esi
mov    %rsi,%r11
not    %r11
add    %rbp,%r11
test   %r14,%r14
je     1436 <main+0x2e6>
mov    %r14,%rdx
nopw   0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%ecx
mov    %cl,(%r12,%rax,1)
add    $0x1,%rax
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1420 <main+0x2d0>
cmp    $0x3,%r11
jb     13d0 <main+0x280>
nopl   0x0(%rax)
movzbl (%rbx,%rsi,1),%ecx
mov    %cl,(%r12,%rax,1)
movzbl 0x1(%rbx,%rsi,1),%ecx
mov    %cl,0x1(%r12,%rax,1)
movzbl 0x2(%rbx,%rsi,1),%ecx
mov    %cl,0x2(%r12,%rax,1)
movzbl 0x3(%rbx,%rsi,1),%ecx
mov    %cl,0x3(%r12,%rax,1)
add    $0x4,%rax
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1440 <main+0x2f0>
jmp    13d0 <main+0x280>
cmpq   $0x60,0x50(%rsp)
jae    1484 <main+0x334>
xor    %esi,%esi
jmp    14fc <main+0x3ac>
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%rdi
mov    0x30(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x70(%rdi,%rsi,1)
movups %xmm1,-0x60(%rdi,%rsi,1)
movups 0x20(%rbx,%rsi,1),%xmm0
movups 0x30(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x50(%rdi,%rsi,1)
movups %xmm1,-0x40(%rdi,%rsi,1)
movups 0x40(%rbx,%rsi,1),%xmm0
movups 0x50(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdi,%rsi,1)
movups %xmm1,-0x20(%rdi,%rsi,1)
movdqu 0x60(%rbx,%rsi,1),%xmm0
movdqu 0x70(%rbx,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rsi,1)
movdqu %xmm1,(%rdi,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    14a0 <main+0x350>
cmpq   $0x0,0x48(%rsp)
je     153f <main+0x3ef>
mov    0x40(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdx
add    %rax,%rsi
add    0x38(%rsp),%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1520 <main+0x3d0>
add    %r9,%rax
mov    %r9,%rsi
cmp    %rbp,%r9
mov    0x8(%rsp),%edi
je     13d0 <main+0x280>
jmp    1409 <main+0x2b9>
cltq
movb   $0x0,(%r12,%rax,1)
mov    (%rsp),%eax
lea    0x8(,%rax,8),%edi
call   1060 <malloc@plt>
xor    %r11d,%r11d
mov    $0x0,%r8d
mov    0x1c(%rsp),%r14d
test   %r14d,%r14d
jle    17c8 <main+0x678>
lea    (%rax,%rbp,1),%rcx
mov    %rcx,0x8(%rsp)
lea    (%rbx,%rbp,1),%rcx
mov    %rcx,0x58(%rsp)
mov    %ebp,%ecx
and    $0xffffffe0,%ecx
mov    %rcx,0x50(%rsp)
add    $0xffffffffffffffe0,%rcx
mov    %rcx,0x48(%rsp)
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
movabs $0xffffffffffffffc,%rcx
ff ff 0f
and    %rcx,%rdx
mov    %rdx,0x28(%rsp)
mov    %ebp,%edx
and    $0x3,%edx
lea    0x70(%rax),%rcx
mov    %rcx,0x60(%rsp)
mov    %rbx,%rcx
add    $0x10,%rcx
mov    %rcx,0x38(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x30(%rsp)
mov    %r10,0x40(%rsp)
shl    $0x5,%r10
xor    %r9d,%r9d
xor    %r8d,%r8d
mov    %rdx,0x10(%rsp)
jmp    161d <main+0x4cd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9d
cmp    %r14d,%r9d
je     17c8 <main+0x678>
test   %r13d,%r13d
jle    1610 <main+0x4c0>
movslq %r8d,%r8
cmp    $0x20,%r13d
jae    1640 <main+0x4f0>
xor    %edi,%edi
jmp    1750 <main+0x600>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rax,%r8,1),%rdx
cmp    0x58(%rsp),%rdx
jae    1665 <main+0x515>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r8,1),%rdx
cmp    %rbx,%rdx
jbe    1665 <main+0x515>
xor    %edi,%edi
mov    0x10(%rsp),%rdx
jmp    1750 <main+0x600>
cmpq   $0x60,0x48(%rsp)
jae    1671 <main+0x521>
xor    %edi,%edi
jmp    16ec <main+0x59c>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r8,1),%rsi
mov    0x28(%rsp),%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,-0x70(%rsi,%rdi,1)
movups %xmm1,-0x60(%rsi,%rdi,1)
movups 0x20(%rbx,%rdi,1),%xmm0
movups 0x30(%rbx,%rdi,1),%xmm1
movups %xmm0,-0x50(%rsi,%rdi,1)
movups %xmm1,-0x40(%rsi,%rdi,1)
movups 0x40(%rbx,%rdi,1),%xmm0
movups 0x50(%rbx,%rdi,1),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,1)
movups %xmm1,-0x20(%rsi,%rdi,1)
movdqu 0x60(%rbx,%rdi,1),%xmm0
movdqu 0x70(%rbx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm1,(%rsi,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%r14
jne    1690 <main+0x540>
cmpq   $0x0,0x40(%rsp)
je     172f <main+0x5df>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rdi,1),%rdx
add    %r8,%rdi
add    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rsi,1),%xmm0
movdqu (%rdx,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rsi,1)
movdqu %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    1710 <main+0x5c0>
mov    0x50(%rsp),%rcx
add    %rcx,%r8
mov    %rcx,%rdi
cmp    %rbp,%rcx
mov    0x1c(%rsp),%r14d
mov    0x10(%rsp),%rdx
je     1610 <main+0x4c0>
nopl   (%rax)
mov    %rdi,%rsi
not    %rsi
add    %rbp,%rsi
test   %rdx,%rdx
je     1776 <main+0x626>
xchg   %ax,%ax
movzbl (%rbx,%rdi,1),%ecx
mov    %cl,(%rax,%r8,1)
add    $0x1,%r8
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1760 <main+0x610>
cmp    $0x3,%rsi
mov    0x10(%rsp),%rdx
jb     1610 <main+0x4c0>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rdi,1),%ecx
mov    %cl,(%rax,%r8,1)
movzbl 0x1(%rbx,%rdi,1),%ecx
mov    %cl,0x1(%rax,%r8,1)
movzbl 0x2(%rbx,%rdi,1),%ecx
mov    %cl,0x2(%rax,%r8,1)
movzbl 0x3(%rbx,%rdi,1),%ecx
mov    %cl,0x3(%rax,%r8,1)
add    $0x4,%r8
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1790 <main+0x640>
jmp    1610 <main+0x4c0>
movslq %r8d,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    0x4(%rsp),%r9d
test   %r9d,%r9d
jle    195a <main+0x80a>
cmp    $0x8,%r9d
jae    17ed <main+0x69d>
xor    %esi,%esi
xor    %r11d,%r11d
jmp    1940 <main+0x7f0>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     1c84 <main+0xb34>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
pxor   %xmm0,%xmm0
xor    %edi,%edi
movdqa 0x7e0(%rip),%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   (%r12,%rdi,1),%xmm4
movd   0x4(%r12,%rdi,1),%xmm5
movd   (%r15,%rdi,1),%xmm3
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%r15,%rdi,1),%xmm4
pcmpeqb %xmm5,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm3
paddd  %xmm0,%xmm3
pand   %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%r12,%rdi,1),%xmm1
movd   0xc(%r12,%rdi,1),%xmm5
movd   0x8(%r15,%rdi,1),%xmm0
pcmpeqb %xmm1,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%r15,%rdi,1),%xmm1
pcmpeqb %xmm5,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm2,%xmm0
paddd  %xmm3,%xmm0
pand   %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1830 <main+0x6e0>
test   $0x1,%bpl
je     1914 <main+0x7c4>
movd   (%r12,%rdi,1),%xmm2
movd   0x4(%r12,%rdi,1),%xmm3
movd   (%r15,%rdi,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%r15,%rdi,1),%xmm2
pcmpeqb %xmm3,%xmm2
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0x704(%rip),%xmm3
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm0
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r11d
cmp    %r9,%rsi
je     195a <main+0x80a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rsi,1),%ecx
xor    %edx,%edx
cmp    (%r15,%rsi,1),%cl
sete   %dl
add    %edx,%r11d
add    $0x1,%rsi
cmp    %rsi,%r9
jne    1940 <main+0x7f0>
mov    (%rsp),%r10d
test   %r10d,%r10d
jle    1977 <main+0x827>
cmp    $0x8,%r10d
jae    197e <main+0x82e>
xor    %edi,%edi
xor    %edx,%edx
mov    0x20(%rsp),%rsi
jmp    1ac0 <main+0x970>
xor    %edx,%edx
jmp    1ad8 <main+0x988>
mov    %r10d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1c9d <main+0xb4d>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
movdqa 0x64f(%rip),%xmm2
pxor   %xmm1,%xmm1
mov    0x20(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movd   (%rax,%rbp,1),%xmm4
movd   0x4(%rax,%rbp,1),%xmm5
movd   (%rsi,%rbp,1),%xmm3
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%rsi,%rbp,1),%xmm4
pcmpeqb %xmm5,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm3
paddd  %xmm0,%xmm3
pand   %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rax,%rbp,1),%xmm1
movd   0xc(%rax,%rbp,1),%xmm5
movd   0x8(%rsi,%rbp,1),%xmm0
pcmpeqb %xmm1,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%rsi,%rbp,1),%xmm1
pcmpeqb %xmm5,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm2,%xmm0
paddd  %xmm3,%xmm0
pand   %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdx
jne    19c0 <main+0x870>
test   $0x1,%r8b
je     1a98 <main+0x948>
movd   (%rax,%rbp,1),%xmm2
movd   0x4(%rax,%rbp,1),%xmm3
movd   (%rsi,%rbp,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%rsi,%rbp,1),%xmm2
pcmpeqb %xmm3,%xmm2
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0x580(%rip),%xmm3
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm0
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %r10,%rdi
je     1ad8 <main+0x988>
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rdi,1),%ecx
xor    %ebp,%ebp
cmp    (%rsi,%rdi,1),%cl
sete   %bpl
add    %ebp,%edx
add    $0x1,%rdi
cmp    %rdi,%r10
jne    1ac0 <main+0x970>
cmp    %r9d,%r11d
jne    1af4 <main+0x9a4>
mov    %rbx,%r15
cmp    %r10d,%edx
jne    1af4 <main+0x9a4>
lea    0x529(%rip),%rdi
mov    %r15,%rsi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1ce3 <main+0xb93>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
movdqa 0x4c9(%rip),%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movd   (%r14,%rsi,1),%xmm4
movd   0x4(%r14,%rsi,1),%xmm5
movd   (%r12,%rsi,1),%xmm3
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%r12,%rsi,1),%xmm4
pcmpeqb %xmm5,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm3
paddd  %xmm0,%xmm3
pand   %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%r14,%rsi,1),%xmm1
movd   0xc(%r14,%rsi,1),%xmm5
movd   0x8(%r12,%rsi,1),%xmm0
pcmpeqb %xmm1,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%r12,%rsi,1),%xmm1
pcmpeqb %xmm5,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm2,%xmm0
paddd  %xmm3,%xmm0
pand   %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b40 <main+0x9f0>
test   $0x1,%dl
je     1c23 <main+0xad3>
movd   (%r14,%rsi,1),%xmm2
movd   0x4(%r14,%rsi,1),%xmm3
movd   (%r12,%rsi,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%r12,%rsi,1),%xmm2
pcmpeqb %xmm3,%xmm2
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0x3f5(%rip),%xmm3
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm0
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     1c6a <main+0xb1a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rcx,1),%ebx
xor    %esi,%esi
cmp    (%r12,%rcx,1),%bl
sete   %sil
add    %esi,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1c50 <main+0xb00>
cmp    %eax,%edx
je     1ae5 <main+0x995>
jmp    1af4 <main+0x9a4>
cmp    $0x20,%r13d
jae    1cbb <main+0xb6b>
xor    %ecx,%ecx
jmp    1dc2 <main+0xc72>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
test   $0x1,%bpl
jne    18ca <main+0x77a>
jmp    1914 <main+0x7c4>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
mov    0x20(%rsp),%rsi
test   $0x1,%r8b
jne    1a52 <main+0x902>
jmp    1a98 <main+0x948>
mov    %ebp,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    1cfb <main+0xbab>
xor    %edi,%edi
jmp    1d74 <main+0xc24>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    1bd9 <main+0xa89>
jmp    1c23 <main+0xad3>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%r15,%rdi,1),%xmm0
movups 0x10(%r15,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movups 0x20(%r15,%rdi,1),%xmm0
movups 0x30(%r15,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
movups 0x40(%r15,%rdi,1),%xmm0
movups 0x50(%r15,%rdi,1),%xmm1
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm1,0x50(%rbx,%rdi,1)
movdqu 0x60(%r15,%rdi,1),%xmm0
movdqu 0x70(%r15,%rdi,1),%xmm1
movdqu %xmm0,0x60(%rbx,%rdi,1)
movdqu %xmm1,0x70(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1d10 <main+0xbc0>
test   %r8,%r8
je     1daf <main+0xc5f>
lea    (%rbx,%rdi,1),%rsi
add    $0x10,%rsi
add    %r15,%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
xchg   %ax,%ax
movdqu -0x10(%rdi,%rdx,1),%xmm0
movdqu (%rdi,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movdqu %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1d90 <main+0xc40>
cmp    %rbp,%rcx
je     12bf <main+0x16f>
test   $0x18,%bpl
je     1254 <main+0x104>
mov    %rcx,%rdx
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdx,1),%rsi
mov    %rsi,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1dd0 <main+0xc80>
cmp    %rbp,%rcx
je     12bf <main+0x16f>
jmp    1254 <main+0x104>

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

LLVM IR (-O2):
@.str = [4 x i8] c"%d \00"
@.str.1 = [5 x i8] c"\0A%d \00"
@.str.2 = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = bitcast i32* %1 to i8*
%4 = bitcast i32* %2 to i8*
%5 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %2)
%6 = load i32, i32* %2
%7 = shl i32 %6, 3
%8 = add i32 %7, 8
%9 = call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to i8*
%11 = call i32 @gets(i8* %10)
%12 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%13 = load i32, i32* %1
%14 = shl i32 %13, 3
%15 = add i32 %14, 8
%16 = call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to i8*
%18 = load i32, i32* %1
%19 = shl i32 %18, 3
%20 = add i32 %19, 8
%21 = call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to i8*
%23 = call i32 @gets(i8* %17)
%24 = load i32, i32* %2
%25 = load i32, i32* %1
%26 = call i32 @_gcd(i32 %24, i32 %25)
%27 = load i32, i32* %1
%28 = load i32, i32* %2
%29 = srem i32 %27, %28
%30 = sdiv i32 %27, %28
%31 = icmp eq i32 %29, 0
br i1 %31, label %32, label %172
32: ; preds = %0
%33 = icmp sgt i32 %30, 0
br i1 %33, label %34, label %59
34: ; preds = %32, %54
%35 = phi i32 [ %55, %54 ], [ %28, %32 ]
%36 = phi i32 [ %57, %54 ], [ 0, %32 ]
%37 = phi i32 [ %56, %54 ], [ 0, %32 ]
%38 = icmp sgt i32 %35, 0
br i1 %38, label %39, label %54
39: ; preds = %34
%40 = sext i32 %37 to i64
br label %41
41: ; preds = %39, %41
%42 = phi i64 [ %40, %39 ], [ %47, %41 ]
%43 = phi i64 [ 0, %39 ], [ %48, %41 ]
%44 = getelementptr inbounds i8, i8* %10, i64 %43
%45 = load i8, i8* %44
%46 = getelementptr inbounds i8, i8* %22, i64 %42
store i8 %45, i8* %46
%47 = add nsw i64 %42, 1
%48 = add nuw nsw i64 %43, 1
%49 = load i32, i32* %2
%50 = sext i32 %49 to i64
%51 = icmp slt i64 %48, %50
br i1 %51, label %41, label %52
52: ; preds = %41
%53 = trunc i64 %47 to i32
br label %54
54: ; preds = %52, %34
%55 = phi i32 [ %35, %34 ], [ %49, %52 ]
%56 = phi i32 [ %37, %34 ], [ %53, %52 ]
%57 = add nuw nsw i32 %36, 1
%58 = icmp eq i32 %57, %30
br i1 %58, label %59, label %34
59: ; preds = %54, %32
%60 = phi i32 [ 0, %32 ], [ %56, %54 ]
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %22, i64 %61
store i8 0, i8* %62
%63 = load i32, i32* %1
%64 = icmp sgt i32 %63, 0
br i1 %64, label %65, label %169
65: ; preds = %59
%66 = zext i32 %63 to i64
%67 = icmp ult i32 %63, 8
br i1 %67, label %154, label %68
68: ; preds = %65
%69 = and i64 %66, 4294967288
%70 = add nsw i64 %69, -8
%71 = lshr exact i64 %70, 3
%72 = add nuw nsw i64 %71, 1
%73 = and i64 %72, 1
%74 = icmp eq i64 %70, 0
br i1 %74, label %122, label %75
75: ; preds = %68
%76 = and i64 %72, 4611686018427387902
br label %77
77: ; preds = %77, %75
%78 = phi i64 [ 0, %75 ], [ %119, %77 ]
%79 = phi <4 x i32> [ zeroinitializer, %75 ], [ %117, %77 ]
%80 = phi <4 x i32> [ zeroinitializer, %75 ], [ %118, %77 ]
%81 = phi i64 [ 0, %75 ], [ %120, %77 ]
%82 = getelementptr inbounds i8, i8* %22, i64 %78
%83 = bitcast i8* %82 to <4 x i8>*
%84 = load <4 x i8>, <4 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 4
%86 = bitcast i8* %85 to <4 x i8>*
%87 = load <4 x i8>, <4 x i8>* %86
%88 = getelementptr inbounds i8, i8* %17, i64 %78
%89 = bitcast i8* %88 to <4 x i8>*
%90 = load <4 x i8>, <4 x i8>* %89
%91 = getelementptr inbounds i8, i8* %88, i64 4
%92 = bitcast i8* %91 to <4 x i8>*
%93 = load <4 x i8>, <4 x i8>* %92
%94 = icmp eq <4 x i8> %84, %90
%95 = icmp eq <4 x i8> %87, %93
%96 = zext <4 x i1> %94 to <4 x i32>
%97 = zext <4 x i1> %95 to <4 x i32>
%98 = add <4 x i32> %79, %96
%99 = add <4 x i32> %80, %97
%100 = or i64 %78, 8
%101 = getelementptr inbounds i8, i8* %22, i64 %100
%102 = bitcast i8* %101 to <4 x i8>*
%103 = load <4 x i8>, <4 x i8>* %102
%104 = getelementptr inbounds i8, i8* %101, i64 4
%105 = bitcast i8* %104 to <4 x i8>*
%106 = load <4 x i8>, <4 x i8>* %105
%107 = getelementptr inbounds i8, i8* %17, i64 %100
%108 = bitcast i8* %107 to <4 x i8>*
%109 = load <4 x i8>, <4 x i8>* %108
%110 = getelementptr inbounds i8, i8* %107, i64 4
%111 = bitcast i8* %110 to <4 x i8>*
%112 = load <4 x i8>, <4 x i8>* %111
%113 = icmp eq <4 x i8> %103, %109
%114 = icmp eq <4 x i8> %106, %112
%115 = zext <4 x i1> %113 to <4 x i32>
%116 = zext <4 x i1> %114 to <4 x i32>
%117 = add <4 x i32> %98, %115
%118 = add <4 x i32> %99, %116
%119 = add nuw i64 %78, 16
%120 = add i64 %81, 2
%121 = icmp eq i64 %120, %76
br i1 %121, label %122, label %77
122: ; preds = %77, %68
%123 = phi <4 x i32> [ undef, %68 ], [ %117, %77 ]
%124 = phi <4 x i32> [ undef, %68 ], [ %118, %77 ]
%125 = phi i64 [ 0, %68 ], [ %119, %77 ]
%126 = phi <4 x i32> [ zeroinitializer, %68 ], [ %117, %77 ]
%127 = phi <4 x i32> [ zeroinitializer, %68 ], [ %118, %77 ]
%128 = icmp eq i64 %73, 0
br i1 %128, label %148, label %129
129: ; preds = %122
%130 = getelementptr inbounds i8, i8* %22, i64 %125
%131 = bitcast i8* %130 to <4 x i8>*
%132 = load <4 x i8>, <4 x i8>* %131
%133 = getelementptr inbounds i8, i8* %130, i64 4
%134 = bitcast i8* %133 to <4 x i8>*
%135 = load <4 x i8>, <4 x i8>* %134
%136 = getelementptr inbounds i8, i8* %17, i64 %125
%137 = bitcast i8* %136 to <4 x i8>*
%138 = load <4 x i8>, <4 x i8>* %137
%139 = getelementptr inbounds i8, i8* %136, i64 4
%140 = bitcast i8* %139 to <4 x i8>*
%141 = load <4 x i8>, <4 x i8>* %140
%142 = icmp eq <4 x i8> %132, %138
%143 = icmp eq <4 x i8> %135, %141
%144 = zext <4 x i1> %142 to <4 x i32>
%145 = zext <4 x i1> %143 to <4 x i32>
%146 = add <4 x i32> %126, %144
%147 = add <4 x i32> %127, %145
br label %148
148: ; preds = %122, %129
%149 = phi <4 x i32> [ %123, %122 ], [ %146, %129 ]
%150 = phi <4 x i32> [ %124, %122 ], [ %147, %129 ]
%151 = add <4 x i32> %150, %149
%152 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %151)
%153 = icmp eq i64 %69, %66
br i1 %153, label %169, label %154
154: ; preds = %65, %148
%155 = phi i64 [ 0, %65 ], [ %69, %148 ]
%156 = phi i32 [ 0, %65 ], [ %152, %148 ]
br label %157
157: ; preds = %154, %157
%158 = phi i64 [ %167, %157 ], [ %155, %154 ]
%159 = phi i32 [ %166, %157 ], [ %156, %154 ]
%160 = getelementptr inbounds i8, i8* %22, i64 %158
%161 = load i8, i8* %160
%162 = getelementptr inbounds i8, i8* %17, i64 %158
%163 = load i8, i8* %162
%164 = icmp eq i8 %161, %163
%165 = zext i1 %164 to i32
%166 = add nuw nsw i32 %159, %165
%167 = add nuw nsw i64 %158, 1
%168 = icmp eq i64 %167, %66
br i1 %168, label %169, label %157
169: ; preds = %157, %148, %59
%170 = phi i32 [ 0, %59 ], [ %152, %148 ], [ %166, %157 ]
%171 = icmp eq i32 %170, %63
br i1 %171, label %878, label %881
172: ; preds = %0
%173 = sdiv i32 %28, %26
%174 = sdiv i32 %27, %26
%175 = shl i32 %26, 3
%176 = add i32 %175, 8
%177 = call i64 @malloc(i32 %176)
%178 = inttoptr i64 %177 to i8*
%179 = load i32, i32* %2
%180 = shl i32 %179, 3
%181 = add i32 %180, 8
%182 = call i64 @malloc(i32 %181)
%183 = inttoptr i64 %182 to i8*
%184 = icmp sgt i32 %26, 0
br i1 %184, label %185, label %331
185: ; preds = %172
%186 = zext i32 %26 to i64
%187 = icmp ult i32 %26, 8
br i1 %187, label %292, label %188
188: ; preds = %185
%189 = getelementptr i8, i8* %178, i64 %186
%190 = getelementptr i8, i8* %10, i64 %186
%191 = icmp ugt i8* %190, %178
%192 = icmp ugt i8* %189, %10
%193 = and i1 %191, %192
br i1 %193, label %292, label %194
194: ; preds = %188
%195 = icmp ult i32 %26, 32
br i1 %195, label %278, label %196
196: ; preds = %194
%197 = and i64 %186, 4294967264
%198 = add nsw i64 %197, -32
%199 = lshr exact i64 %198, 5
%200 = add nuw nsw i64 %199, 1
%201 = and i64 %200, 3
%202 = icmp ult i64 %198, 96
br i1 %202, label %254, label %203
203: ; preds = %196
%204 = and i64 %200, 1152921504606846972
br label %205
205: ; preds = %205, %203
%206 = phi i64 [ 0, %203 ], [ %251, %205 ]
%207 = phi i64 [ 0, %203 ], [ %252, %205 ]
%208 = getelementptr inbounds i8, i8* %10, i64 %206
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds i8, i8* %208, i64 16
%212 = bitcast i8* %211 to <16 x i8>*
%213 = load <16 x i8>, <16 x i8>* %212
%214 = getelementptr inbounds i8, i8* %178, i64 %206
%215 = bitcast i8* %214 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %215
%216 = getelementptr inbounds i8, i8* %214, i64 16
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %213, <16 x i8>* %217
%218 = or i64 %206, 32
%219 = getelementptr inbounds i8, i8* %10, i64 %218
%220 = bitcast i8* %219 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = getelementptr inbounds i8, i8* %219, i64 16
%223 = bitcast i8* %222 to <16 x i8>*
%224 = load <16 x i8>, <16 x i8>* %223
%225 = getelementptr inbounds i8, i8* %178, i64 %218
%226 = bitcast i8* %225 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %226
%227 = getelementptr inbounds i8, i8* %225, i64 16
%228 = bitcast i8* %227 to <16 x i8>*
store <16 x i8> %224, <16 x i8>* %228
%229 = or i64 %206, 64
%230 = getelementptr inbounds i8, i8* %10, i64 %229
%231 = bitcast i8* %230 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = getelementptr inbounds i8, i8* %230, i64 16
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = getelementptr inbounds i8, i8* %178, i64 %229
%237 = bitcast i8* %236 to <16 x i8>*
store <16 x i8> %232, <16 x i8>* %237
%238 = getelementptr inbounds i8, i8* %236, i64 16
%239 = bitcast i8* %238 to <16 x i8>*
store <16 x i8> %235, <16 x i8>* %239
%240 = or i64 %206, 96
%241 = getelementptr inbounds i8, i8* %10, i64 %240
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = getelementptr inbounds i8, i8* %241, i64 16
%245 = bitcast i8* %244 to <16 x i8>*
%246 = load <16 x i8>, <16 x i8>* %245
%247 = getelementptr inbounds i8, i8* %178, i64 %240
%248 = bitcast i8* %247 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %248
%249 = getelementptr inbounds i8, i8* %247, i64 16
%250 = bitcast i8* %249 to <16 x i8>*
store <16 x i8> %246, <16 x i8>* %250
%251 = add nuw i64 %206, 128
%252 = add i64 %207, 4
%253 = icmp eq i64 %252, %204
br i1 %253, label %254, label %205
254: ; preds = %205, %196
%255 = phi i64 [ 0, %196 ], [ %251, %205 ]
%256 = icmp eq i64 %201, 0
br i1 %256, label %273, label %257
257: ; preds = %254, %257
%258 = phi i64 [ %270, %257 ], [ %255, %254 ]
%259 = phi i64 [ %271, %257 ], [ 0, %254 ]
%260 = getelementptr inbounds i8, i8* %10, i64 %258
%261 = bitcast i8* %260 to <16 x i8>*
%262 = load <16 x i8>, <16 x i8>* %261
%263 = getelementptr inbounds i8, i8* %260, i64 16
%264 = bitcast i8* %263 to <16 x i8>*
%265 = load <16 x i8>, <16 x i8>* %264
%266 = getelementptr inbounds i8, i8* %178, i64 %258
%267 = bitcast i8* %266 to <16 x i8>*
store <16 x i8> %262, <16 x i8>* %267
%268 = getelementptr inbounds i8, i8* %266, i64 16
%269 = bitcast i8* %268 to <16 x i8>*
store <16 x i8> %265, <16 x i8>* %269
%270 = add nuw i64 %258, 32
%271 = add i64 %259, 1
%272 = icmp eq i64 %271, %201
br i1 %272, label %273, label %257
273: ; preds = %257, %254
%274 = icmp eq i64 %197, %186
br i1 %274, label %329, label %275
275: ; preds = %273
%276 = and i64 %186, 24
%277 = icmp eq i64 %276, 0
br i1 %277, label %292, label %278
278: ; preds = %194, %275
%279 = phi i64 [ %197, %275 ], [ 0, %194 ]
%280 = and i64 %186, 4294967288
br label %281
281: ; preds = %281, %278
%282 = phi i64 [ %279, %278 ], [ %288, %281 ]
%283 = getelementptr inbounds i8, i8* %10, i64 %282
%284 = bitcast i8* %283 to <8 x i8>*
%285 = load <8 x i8>, <8 x i8>* %284
%286 = getelementptr inbounds i8, i8* %178, i64 %282
%287 = bitcast i8* %286 to <8 x i8>*
store <8 x i8> %285, <8 x i8>* %287
%288 = add nuw i64 %282, 8
%289 = icmp eq i64 %288, %280
br i1 %289, label %290, label %281
290: ; preds = %281
%291 = icmp eq i64 %280, %186
br i1 %291, label %329, label %292
292: ; preds = %188, %185, %275, %290
%293 = phi i64 [ 0, %185 ], [ 0, %188 ], [ %197, %275 ], [ %280, %290 ]
%294 = xor i64 %293, -1
%295 = add nsw i64 %294, %186
%296 = and i64 %186, 3
%297 = icmp eq i64 %296, 0
br i1 %297, label %307, label %298
298: ; preds = %292, %298
%299 = phi i64 [ %304, %298 ], [ %293, %292 ]
%300 = phi i64 [ %305, %298 ], [ 0, %292 ]
%301 = getelementptr inbounds i8, i8* %10, i64 %299
%302 = load i8, i8* %301
%303 = getelementptr inbounds i8, i8* %178, i64 %299
store i8 %302, i8* %303
%304 = add nuw nsw i64 %299, 1
%305 = add i64 %300, 1
%306 = icmp eq i64 %305, %296
br i1 %306, label %307, label %298
307: ; preds = %298, %292
%308 = phi i64 [ %293, %292 ], [ %304, %298 ]
%309 = icmp ult i64 %295, 3
br i1 %309, label %329, label %310
310: ; preds = %307, %310
%311 = phi i64 [ %327, %310 ], [ %308, %307 ]
%312 = getelementptr inbounds i8, i8* %10, i64 %311
%313 = load i8, i8* %312
%314 = getelementptr inbounds i8, i8* %178, i64 %311
store i8 %313, i8* %314
%315 = add nuw nsw i64 %311, 1
%316 = getelementptr inbounds i8, i8* %10, i64 %315
%317 = load i8, i8* %316
%318 = getelementptr inbounds i8, i8* %178, i64 %315
store i8 %317, i8* %318
%319 = add nuw nsw i64 %311, 2
%320 = getelementptr inbounds i8, i8* %10, i64 %319
%321 = load i8, i8* %320
%322 = getelementptr inbounds i8, i8* %178, i64 %319
store i8 %321, i8* %322
%323 = add nuw nsw i64 %311, 3
%324 = getelementptr inbounds i8, i8* %10, i64 %323
%325 = load i8, i8* %324
%326 = getelementptr inbounds i8, i8* %178, i64 %323
store i8 %325, i8* %326
%327 = add nuw nsw i64 %311, 4
%328 = icmp eq i64 %327, %186
br i1 %328, label %329, label %310
329: ; preds = %307, %310, %290, %273
%330 = zext i32 %26 to i64
br label %331
331: ; preds = %172, %329
%332 = phi i64 [ %330, %329 ], [ 0, %172 ]
%333 = getelementptr inbounds i8, i8* %178, i64 %332
store i8 0, i8* %333
%334 = icmp sgt i32 %173, 0
br i1 %334, label %335, label %490
335: ; preds = %331
%336 = zext i32 %26 to i64
%337 = getelementptr i8, i8* %183, i64 %336
%338 = getelementptr i8, i8* %178, i64 %336
%339 = and i64 %336, 4294967264
%340 = add nsw i64 %339, -32
%341 = lshr exact i64 %340, 5
%342 = add nuw nsw i64 %341, 1
%343 = icmp ult i32 %26, 32
%344 = and i64 %336, 4294967264
%345 = and i64 %342, 3
%346 = icmp ult i64 %340, 96
%347 = and i64 %342, 1152921504606846972
%348 = icmp eq i64 %345, 0
%349 = icmp eq i64 %344, %336
%350 = and i64 %336, 3
%351 = icmp eq i64 %350, 0
br label %352
352: ; preds = %335, %486
%353 = phi i32 [ 0, %335 ], [ %488, %486 ]
%354 = phi i32 [ 0, %335 ], [ %487, %486 ]
br i1 %184, label %355, label %486
355: ; preds = %352
%356 = sext i32 %354 to i64
br i1 %343, label %438, label %357
357: ; preds = %355
%358 = getelementptr i8, i8* %183, i64 %356
%359 = getelementptr i8, i8* %337, i64 %356
%360 = icmp ult i8* %358, %338
%361 = icmp ugt i8* %359, %178
%362 = and i1 %360, %361
br i1 %362, label %438, label %363
363: ; preds = %357
%364 = add nsw i64 %344, %356
br i1 %346, label %418, label %365
365: ; preds = %363, %365
%366 = phi i64 [ %415, %365 ], [ 0, %363 ]
%367 = phi i64 [ %416, %365 ], [ 0, %363 ]
%368 = add i64 %366, %356
%369 = getelementptr inbounds i8, i8* %178, i64 %366
%370 = bitcast i8* %369 to <16 x i8>*
%371 = load <16 x i8>, <16 x i8>* %370
%372 = getelementptr inbounds i8, i8* %369, i64 16
%373 = bitcast i8* %372 to <16 x i8>*
%374 = load <16 x i8>, <16 x i8>* %373
%375 = getelementptr inbounds i8, i8* %183, i64 %368
%376 = bitcast i8* %375 to <16 x i8>*
store <16 x i8> %371, <16 x i8>* %376
%377 = getelementptr inbounds i8, i8* %375, i64 16
%378 = bitcast i8* %377 to <16 x i8>*
store <16 x i8> %374, <16 x i8>* %378
%379 = or i64 %366, 32
%380 = add i64 %379, %356
%381 = getelementptr inbounds i8, i8* %178, i64 %379
%382 = bitcast i8* %381 to <16 x i8>*
%383 = load <16 x i8>, <16 x i8>* %382
%384 = getelementptr inbounds i8, i8* %381, i64 16
%385 = bitcast i8* %384 to <16 x i8>*
%386 = load <16 x i8>, <16 x i8>* %385
%387 = getelementptr inbounds i8, i8* %183, i64 %380
%388 = bitcast i8* %387 to <16 x i8>*
store <16 x i8> %383, <16 x i8>* %388
%389 = getelementptr inbounds i8, i8* %387, i64 16
%390 = bitcast i8* %389 to <16 x i8>*
store <16 x i8> %386, <16 x i8>* %390
%391 = or i64 %366, 64
%392 = add i64 %391, %356
%393 = getelementptr inbounds i8, i8* %178, i64 %391
%394 = bitcast i8* %393 to <16 x i8>*
%395 = load <16 x i8>, <16 x i8>* %394
%396 = getelementptr inbounds i8, i8* %393, i64 16
%397 = bitcast i8* %396 to <16 x i8>*
%398 = load <16 x i8>, <16 x i8>* %397
%399 = getelementptr inbounds i8, i8* %183, i64 %392
%400 = bitcast i8* %399 to <16 x i8>*
store <16 x i8> %395, <16 x i8>* %400
%401 = getelementptr inbounds i8, i8* %399, i64 16
%402 = bitcast i8* %401 to <16 x i8>*
store <16 x i8> %398, <16 x i8>* %402
%403 = or i64 %366, 96
%404 = add i64 %403, %356
%405 = getelementptr inbounds i8, i8* %178, i64 %403
%406 = bitcast i8* %405 to <16 x i8>*
%407 = load <16 x i8>, <16 x i8>* %406
%408 = getelementptr inbounds i8, i8* %405, i64 16
%409 = bitcast i8* %408 to <16 x i8>*
%410 = load <16 x i8>, <16 x i8>* %409
%411 = getelementptr inbounds i8, i8* %183, i64 %404
%412 = bitcast i8* %411 to <16 x i8>*
store <16 x i8> %407, <16 x i8>* %412
%413 = getelementptr inbounds i8, i8* %411, i64 16
%414 = bitcast i8* %413 to <16 x i8>*
store <16 x i8> %410, <16 x i8>* %414
%415 = add nuw i64 %366, 128
%416 = add i64 %367, 4
%417 = icmp eq i64 %416, %347
br i1 %417, label %418, label %365
418: ; preds = %365, %363
%419 = phi i64 [ 0, %363 ], [ %415, %365 ]
br i1 %348, label %437, label %420
420: ; preds = %418, %420
%421 = phi i64 [ %434, %420 ], [ %419, %418 ]
%422 = phi i64 [ %435, %420 ], [ 0, %418 ]
%423 = add i64 %421, %356
%424 = getelementptr inbounds i8, i8* %178, i64 %421
%425 = bitcast i8* %424 to <16 x i8>*
%426 = load <16 x i8>, <16 x i8>* %425
%427 = getelementptr inbounds i8, i8* %424, i64 16
%428 = bitcast i8* %427 to <16 x i8>*
%429 = load <16 x i8>, <16 x i8>* %428
%430 = getelementptr inbounds i8, i8* %183, i64 %423
%431 = bitcast i8* %430 to <16 x i8>*
store <16 x i8> %426, <16 x i8>* %431
%432 = getelementptr inbounds i8, i8* %430, i64 16
%433 = bitcast i8* %432 to <16 x i8>*
store <16 x i8> %429, <16 x i8>* %433
%434 = add nuw i64 %421, 32
%435 = add i64 %422, 1
%436 = icmp eq i64 %435, %345
br i1 %436, label %437, label %420
437: ; preds = %420, %418
br i1 %349, label %483, label %438
438: ; preds = %357, %355, %437
%439 = phi i64 [ %356, %357 ], [ %356, %355 ], [ %364, %437 ]
%440 = phi i64 [ 0, %357 ], [ 0, %355 ], [ %344, %437 ]
%441 = xor i64 %440, -1
%442 = add nsw i64 %441, %336
br i1 %351, label %454, label %443
443: ; preds = %438, %443
%444 = phi i64 [ %450, %443 ], [ %439, %438 ]
%445 = phi i64 [ %451, %443 ], [ %440, %438 ]
%446 = phi i64 [ %452, %443 ], [ 0, %438 ]
%447 = getelementptr inbounds i8, i8* %178, i64 %445
%448 = load i8, i8* %447
%449 = getelementptr inbounds i8, i8* %183, i64 %444
store i8 %448, i8* %449
%450 = add nsw i64 %444, 1
%451 = add nuw nsw i64 %445, 1
%452 = add i64 %446, 1
%453 = icmp eq i64 %452, %350
br i1 %453, label %454, label %443
454: ; preds = %443, %438
%455 = phi i64 [ undef, %438 ], [ %450, %443 ]
%456 = phi i64 [ %439, %438 ], [ %450, %443 ]
%457 = phi i64 [ %440, %438 ], [ %451, %443 ]
%458 = icmp ult i64 %442, 3
br i1 %458, label %483, label %459
459: ; preds = %454, %459
%460 = phi i64 [ %480, %459 ], [ %456, %454 ]
%461 = phi i64 [ %481, %459 ], [ %457, %454 ]
%462 = getelementptr inbounds i8, i8* %178, i64 %461
%463 = load i8, i8* %462
%464 = getelementptr inbounds i8, i8* %183, i64 %460
store i8 %463, i8* %464
%465 = add nsw i64 %460, 1
%466 = add nuw nsw i64 %461, 1
%467 = getelementptr inbounds i8, i8* %178, i64 %466
%468 = load i8, i8* %467
%469 = getelementptr inbounds i8, i8* %183, i64 %465
store i8 %468, i8* %469
%470 = add nsw i64 %460, 2
%471 = add nuw nsw i64 %461, 2
%472 = getelementptr inbounds i8, i8* %178, i64 %471
%473 = load i8, i8* %472
%474 = getelementptr inbounds i8, i8* %183, i64 %470
store i8 %473, i8* %474
%475 = add nsw i64 %460, 3
%476 = add nuw nsw i64 %461, 3
%477 = getelementptr inbounds i8, i8* %178, i64 %476
%478 = load i8, i8* %477
%479 = getelementptr inbounds i8, i8* %183, i64 %475
store i8 %478, i8* %479
%480 = add nsw i64 %460, 4
%481 = add nuw nsw i64 %461, 4
%482 = icmp eq i64 %481, %336
br i1 %482, label %483, label %459
483: ; preds = %454, %459, %437
%484 = phi i64 [ %364, %437 ], [ %455, %454 ], [ %480, %459 ]
%485 = trunc i64 %484 to i32
br label %486
486: ; preds = %483, %352
%487 = phi i32 [ %354, %352 ], [ %485, %483 ]
%488 = add nuw nsw i32 %353, 1
%489 = icmp eq i32 %488, %173
br i1 %489, label %490, label %352
490: ; preds = %486, %331
%491 = phi i32 [ 0, %331 ], [ %487, %486 ]
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds i8, i8* %183, i64 %492
store i8 0, i8* %493
%494 = load i32, i32* %1
%495 = shl i32 %494, 3
%496 = add i32 %495, 8
%497 = call i64 @malloc(i32 %496)
%498 = inttoptr i64 %497 to i8*
%499 = icmp sgt i32 %174, 0
br i1 %499, label %500, label %655
500: ; preds = %490
%501 = zext i32 %26 to i64
%502 = getelementptr i8, i8* %498, i64 %501
%503 = getelementptr i8, i8* %178, i64 %501
%504 = and i64 %501, 4294967264
%505 = add nsw i64 %504, -32
%506 = lshr exact i64 %505, 5
%507 = add nuw nsw i64 %506, 1
%508 = icmp ult i32 %26, 32
%509 = and i64 %501, 4294967264
%510 = and i64 %507, 3
%511 = icmp ult i64 %505, 96
%512 = and i64 %507, 1152921504606846972
%513 = icmp eq i64 %510, 0
%514 = icmp eq i64 %509, %501
%515 = and i64 %501, 3
%516 = icmp eq i64 %515, 0
br label %517
517: ; preds = %500, %651
%518 = phi i32 [ 0, %500 ], [ %653, %651 ]
%519 = phi i32 [ 0, %500 ], [ %652, %651 ]
br i1 %184, label %520, label %651
520: ; preds = %517
%521 = sext i32 %519 to i64
br i1 %508, label %603, label %522
522: ; preds = %520
%523 = getelementptr i8, i8* %498, i64 %521
%524 = getelementptr i8, i8* %502, i64 %521
%525 = icmp ult i8* %523, %503
%526 = icmp ugt i8* %524, %178
%527 = and i1 %525, %526
br i1 %527, label %603, label %528
528: ; preds = %522
%529 = add nsw i64 %509, %521
br i1 %511, label %583, label %530
530: ; preds = %528, %530
%531 = phi i64 [ %580, %530 ], [ 0, %528 ]
%532 = phi i64 [ %581, %530 ], [ 0, %528 ]
%533 = add i64 %531, %521
%534 = getelementptr inbounds i8, i8* %178, i64 %531
%535 = bitcast i8* %534 to <16 x i8>*
%536 = load <16 x i8>, <16 x i8>* %535
%537 = getelementptr inbounds i8, i8* %534, i64 16
%538 = bitcast i8* %537 to <16 x i8>*
%539 = load <16 x i8>, <16 x i8>* %538
%540 = getelementptr inbounds i8, i8* %498, i64 %533
%541 = bitcast i8* %540 to <16 x i8>*
store <16 x i8> %536, <16 x i8>* %541
%542 = getelementptr inbounds i8, i8* %540, i64 16
%543 = bitcast i8* %542 to <16 x i8>*
store <16 x i8> %539, <16 x i8>* %543
%544 = or i64 %531, 32
%545 = add i64 %544, %521
%546 = getelementptr inbounds i8, i8* %178, i64 %544
%547 = bitcast i8* %546 to <16 x i8>*
%548 = load <16 x i8>, <16 x i8>* %547
%549 = getelementptr inbounds i8, i8* %546, i64 16
%550 = bitcast i8* %549 to <16 x i8>*
%551 = load <16 x i8>, <16 x i8>* %550
%552 = getelementptr inbounds i8, i8* %498, i64 %545
%553 = bitcast i8* %552 to <16 x i8>*
store <16 x i8> %548, <16 x i8>* %553
%554 = getelementptr inbounds i8, i8* %552, i64 16
%555 = bitcast i8* %554 to <16 x i8>*
store <16 x i8> %551, <16 x i8>* %555
%556 = or i64 %531, 64
%557 = add i64 %556, %521
%558 = getelementptr inbounds i8, i8* %178, i64 %556
%559 = bitcast i8* %558 to <16 x i8>*
%560 = load <16 x i8>, <16 x i8>* %559
%561 = getelementptr inbounds i8, i8* %558, i64 16
%562 = bitcast i8* %561 to <16 x i8>*
%563 = load <16 x i8>, <16 x i8>* %562
%564 = getelementptr inbounds i8, i8* %498, i64 %557
%565 = bitcast i8* %564 to <16 x i8>*
store <16 x i8> %560, <16 x i8>* %565
%566 = getelementptr inbounds i8, i8* %564, i64 16
%567 = bitcast i8* %566 to <16 x i8>*
store <16 x i8> %563, <16 x i8>* %567
%568 = or i64 %531, 96
%569 = add i64 %568, %521
%570 = getelementptr inbounds i8, i8* %178, i64 %568
%571 = bitcast i8* %570 to <16 x i8>*
%572 = load <16 x i8>, <16 x i8>* %571
%573 = getelementptr inbounds i8, i8* %570, i64 16
%574 = bitcast i8* %573 to <16 x i8>*
%575 = load <16 x i8>, <16 x i8>* %574
%576 = getelementptr inbounds i8, i8* %498, i64 %569
%577 = bitcast i8* %576 to <16 x i8>*
store <16 x i8> %572, <16 x i8>* %577
%578 = getelementptr inbounds i8, i8* %576, i64 16
%579 = bitcast i8* %578 to <16 x i8>*
store <16 x i8> %575, <16 x i8>* %579
%580 = add nuw i64 %531, 128
%581 = add i64 %532, 4
%582 = icmp eq i64 %581, %512
br i1 %582, label %583, label %530
583: ; preds = %530, %528
%584 = phi i64 [ 0, %528 ], [ %580, %530 ]
br i1 %513, label %602, label %585
585: ; preds = %583, %585
%586 = phi i64 [ %599, %585 ], [ %584, %583 ]
%587 = phi i64 [ %600, %585 ], [ 0, %583 ]
%588 = add i64 %586, %521
%589 = getelementptr inbounds i8, i8* %178, i64 %586
%590 = bitcast i8* %589 to <16 x i8>*
%591 = load <16 x i8>, <16 x i8>* %590
%592 = getelementptr inbounds i8, i8* %589, i64 16
%593 = bitcast i8* %592 to <16 x i8>*
%594 = load <16 x i8>, <16 x i8>* %593
%595 = getelementptr inbounds i8, i8* %498, i64 %588
%596 = bitcast i8* %595 to <16 x i8>*
store <16 x i8> %591, <16 x i8>* %596
%597 = getelementptr inbounds i8, i8* %595, i64 16
%598 = bitcast i8* %597 to <16 x i8>*
store <16 x i8> %594, <16 x i8>* %598
%599 = add nuw i64 %586, 32
%600 = add i64 %587, 1
%601 = icmp eq i64 %600, %510
br i1 %601, label %602, label %585
602: ; preds = %585, %583
br i1 %514, label %648, label %603
603: ; preds = %522, %520, %602
%604 = phi i64 [ %521, %522 ], [ %521, %520 ], [ %529, %602 ]
%605 = phi i64 [ 0, %522 ], [ 0, %520 ], [ %509, %602 ]
%606 = xor i64 %605, -1
%607 = add nsw i64 %606, %501
br i1 %516, label %619, label %608
608: ; preds = %603, %608
%609 = phi i64 [ %615, %608 ], [ %604, %603 ]
%610 = phi i64 [ %616, %608 ], [ %605, %603 ]
%611 = phi i64 [ %617, %608 ], [ 0, %603 ]
%612 = getelementptr inbounds i8, i8* %178, i64 %610
%613 = load i8, i8* %612
%614 = getelementptr inbounds i8, i8* %498, i64 %609
store i8 %613, i8* %614
%615 = add nsw i64 %609, 1
%616 = add nuw nsw i64 %610, 1
%617 = add i64 %611, 1
%618 = icmp eq i64 %617, %515
br i1 %618, label %619, label %608
619: ; preds = %608, %603
%620 = phi i64 [ undef, %603 ], [ %615, %608 ]
%621 = phi i64 [ %604, %603 ], [ %615, %608 ]
%622 = phi i64 [ %605, %603 ], [ %616, %608 ]
%623 = icmp ult i64 %607, 3
br i1 %623, label %648, label %624
624: ; preds = %619, %624
%625 = phi i64 [ %645, %624 ], [ %621, %619 ]
%626 = phi i64 [ %646, %624 ], [ %622, %619 ]
%627 = getelementptr inbounds i8, i8* %178, i64 %626
%628 = load i8, i8* %627
%629 = getelementptr inbounds i8, i8* %498, i64 %625
store i8 %628, i8* %629
%630 = add nsw i64 %625, 1
%631 = add nuw nsw i64 %626, 1
%632 = getelementptr inbounds i8, i8* %178, i64 %631
%633 = load i8, i8* %632
%634 = getelementptr inbounds i8, i8* %498, i64 %630
store i8 %633, i8* %634
%635 = add nsw i64 %625, 2
%636 = add nuw nsw i64 %626, 2
%637 = getelementptr inbounds i8, i8* %178, i64 %636
%638 = load i8, i8* %637
%639 = getelementptr inbounds i8, i8* %498, i64 %635
store i8 %638, i8* %639
%640 = add nsw i64 %625, 3
%641 = add nuw nsw i64 %626, 3
%642 = getelementptr inbounds i8, i8* %178, i64 %641
%643 = load i8, i8* %642
%644 = getelementptr inbounds i8, i8* %498, i64 %640
store i8 %643, i8* %644
%645 = add nsw i64 %625, 4
%646 = add nuw nsw i64 %626, 4
%647 = icmp eq i64 %646, %501
br i1 %647, label %648, label %624
648: ; preds = %619, %624, %602
%649 = phi i64 [ %529, %602 ], [ %620, %619 ], [ %645, %624 ]
%650 = trunc i64 %649 to i32
br label %651
651: ; preds = %648, %517
%652 = phi i32 [ %519, %517 ], [ %650, %648 ]
%653 = add nuw nsw i32 %518, 1
%654 = icmp eq i32 %653, %174
br i1 %654, label %655, label %517
655: ; preds = %651, %490
%656 = phi i32 [ 0, %490 ], [ %652, %651 ]
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds i8, i8* %498, i64 %657
store i8 0, i8* %658
%659 = load i32, i32* %2
%660 = icmp sgt i32 %659, 0
br i1 %660, label %661, label %753
661: ; preds = %655
%662 = zext i32 %659 to i64
%663 = icmp ult i32 %659, 8
br i1 %663, label %750, label %664
664: ; preds = %661
%665 = and i64 %662, 4294967288
%666 = add nsw i64 %665, -8
%667 = lshr exact i64 %666, 3
%668 = add nuw nsw i64 %667, 1
%669 = and i64 %668, 1
%670 = icmp eq i64 %666, 0
br i1 %670, label %718, label %671
671: ; preds = %664
%672 = and i64 %668, 4611686018427387902
br label %673
673: ; preds = %673, %671
%674 = phi i64 [ 0, %671 ], [ %715, %673 ]
%675 = phi <4 x i32> [ zeroinitializer, %671 ], [ %713, %673 ]
%676 = phi <4 x i32> [ zeroinitializer, %671 ], [ %714, %673 ]
%677 = phi i64 [ 0, %671 ], [ %716, %673 ]
%678 = getelementptr inbounds i8, i8* %183, i64 %674
%679 = bitcast i8* %678 to <4 x i8>*
%680 = load <4 x i8>, <4 x i8>* %679
%681 = getelementptr inbounds i8, i8* %678, i64 4
%682 = bitcast i8* %681 to <4 x i8>*
%683 = load <4 x i8>, <4 x i8>* %682
%684 = getelementptr inbounds i8, i8* %10, i64 %674
%685 = bitcast i8* %684 to <4 x i8>*
%686 = load <4 x i8>, <4 x i8>* %685
%687 = getelementptr inbounds i8, i8* %684, i64 4
%688 = bitcast i8* %687 to <4 x i8>*
%689 = load <4 x i8>, <4 x i8>* %688
%690 = icmp eq <4 x i8> %680, %686
%691 = icmp eq <4 x i8> %683, %689
%692 = zext <4 x i1> %690 to <4 x i32>
%693 = zext <4 x i1> %691 to <4 x i32>
%694 = add <4 x i32> %675, %692
%695 = add <4 x i32> %676, %693
%696 = or i64 %674, 8
%697 = getelementptr inbounds i8, i8* %183, i64 %696
%698 = bitcast i8* %697 to <4 x i8>*
%699 = load <4 x i8>, <4 x i8>* %698
%700 = getelementptr inbounds i8, i8* %697, i64 4
%701 = bitcast i8* %700 to <4 x i8>*
%702 = load <4 x i8>, <4 x i8>* %701
%703 = getelementptr inbounds i8, i8* %10, i64 %696
%704 = bitcast i8* %703 to <4 x i8>*
%705 = load <4 x i8>, <4 x i8>* %704
%706 = getelementptr inbounds i8, i8* %703, i64 4
%707 = bitcast i8* %706 to <4 x i8>*
%708 = load <4 x i8>, <4 x i8>* %707
%709 = icmp eq <4 x i8> %699, %705
%710 = icmp eq <4 x i8> %702, %708
%711 = zext <4 x i1> %709 to <4 x i32>
%712 = zext <4 x i1> %710 to <4 x i32>
%713 = add <4 x i32> %694, %711
%714 = add <4 x i32> %695, %712
%715 = add nuw i64 %674, 16
%716 = add i64 %677, 2
%717 = icmp eq i64 %716, %672
br i1 %717, label %718, label %673
718: ; preds = %673, %664
%719 = phi <4 x i32> [ undef, %664 ], [ %713, %673 ]
%720 = phi <4 x i32> [ undef, %664 ], [ %714, %673 ]
%721 = phi i64 [ 0, %664 ], [ %715, %673 ]
%722 = phi <4 x i32> [ zeroinitializer, %664 ], [ %713, %673 ]
%723 = phi <4 x i32> [ zeroinitializer, %664 ], [ %714, %673 ]
%724 = icmp eq i64 %669, 0
br i1 %724, label %744, label %725
725: ; preds = %718
%726 = getelementptr inbounds i8, i8* %183, i64 %721
%727 = bitcast i8* %726 to <4 x i8>*
%728 = load <4 x i8>, <4 x i8>* %727
%729 = getelementptr inbounds i8, i8* %726, i64 4
%730 = bitcast i8* %729 to <4 x i8>*
%731 = load <4 x i8>, <4 x i8>* %730
%732 = getelementptr inbounds i8, i8* %10, i64 %721
%733 = bitcast i8* %732 to <4 x i8>*
%734 = load <4 x i8>, <4 x i8>* %733
%735 = getelementptr inbounds i8, i8* %732, i64 4
%736 = bitcast i8* %735 to <4 x i8>*
%737 = load <4 x i8>, <4 x i8>* %736
%738 = icmp eq <4 x i8> %728, %734
%739 = icmp eq <4 x i8> %731, %737
%740 = zext <4 x i1> %738 to <4 x i32>
%741 = zext <4 x i1> %739 to <4 x i32>
%742 = add <4 x i32> %722, %740
%743 = add <4 x i32> %723, %741
br label %744
744: ; preds = %718, %725
%745 = phi <4 x i32> [ %719, %718 ], [ %742, %725 ]
%746 = phi <4 x i32> [ %720, %718 ], [ %743, %725 ]
%747 = add <4 x i32> %746, %745
%748 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %747)
%749 = icmp eq i64 %665, %662
br i1 %749, label %753, label %750
750: ; preds = %661, %744
%751 = phi i64 [ 0, %661 ], [ %665, %744 ]
%752 = phi i32 [ 0, %661 ], [ %748, %744 ]
br label %849
753: ; preds = %849, %744, %655
%754 = phi i32 [ 0, %655 ], [ %748, %744 ], [ %858, %849 ]
%755 = load i32, i32* %1
%756 = icmp sgt i32 %755, 0
br i1 %756, label %757, label %873
757: ; preds = %753
%758 = zext i32 %755 to i64
%759 = icmp ult i32 %755, 8
br i1 %759, label %846, label %760
760: ; preds = %757
%761 = and i64 %758, 4294967288
%762 = add nsw i64 %761, -8
%763 = lshr exact i64 %762, 3
%764 = add nuw nsw i64 %763, 1
%765 = and i64 %764, 1
%766 = icmp eq i64 %762, 0
br i1 %766, label %814, label %767
767: ; preds = %760
%768 = and i64 %764, 4611686018427387902
br label %769
769: ; preds = %769, %767
%770 = phi i64 [ 0, %767 ], [ %811, %769 ]
%771 = phi <4 x i32> [ zeroinitializer, %767 ], [ %809, %769 ]
%772 = phi <4 x i32> [ zeroinitializer, %767 ], [ %810, %769 ]
%773 = phi i64 [ 0, %767 ], [ %812, %769 ]
%774 = getelementptr inbounds i8, i8* %498, i64 %770
%775 = bitcast i8* %774 to <4 x i8>*
%776 = load <4 x i8>, <4 x i8>* %775
%777 = getelementptr inbounds i8, i8* %774, i64 4
%778 = bitcast i8* %777 to <4 x i8>*
%779 = load <4 x i8>, <4 x i8>* %778
%780 = getelementptr inbounds i8, i8* %17, i64 %770
%781 = bitcast i8* %780 to <4 x i8>*
%782 = load <4 x i8>, <4 x i8>* %781
%783 = getelementptr inbounds i8, i8* %780, i64 4
%784 = bitcast i8* %783 to <4 x i8>*
%785 = load <4 x i8>, <4 x i8>* %784
%786 = icmp eq <4 x i8> %776, %782
%787 = icmp eq <4 x i8> %779, %785
%788 = zext <4 x i1> %786 to <4 x i32>
%789 = zext <4 x i1> %787 to <4 x i32>
%790 = add <4 x i32> %771, %788
%791 = add <4 x i32> %772, %789
%792 = or i64 %770, 8
%793 = getelementptr inbounds i8, i8* %498, i64 %792
%794 = bitcast i8* %793 to <4 x i8>*
%795 = load <4 x i8>, <4 x i8>* %794
%796 = getelementptr inbounds i8, i8* %793, i64 4
%797 = bitcast i8* %796 to <4 x i8>*
%798 = load <4 x i8>, <4 x i8>* %797
%799 = getelementptr inbounds i8, i8* %17, i64 %792
%800 = bitcast i8* %799 to <4 x i8>*
%801 = load <4 x i8>, <4 x i8>* %800
%802 = getelementptr inbounds i8, i8* %799, i64 4
%803 = bitcast i8* %802 to <4 x i8>*
%804 = load <4 x i8>, <4 x i8>* %803
%805 = icmp eq <4 x i8> %795, %801
%806 = icmp eq <4 x i8> %798, %804
%807 = zext <4 x i1> %805 to <4 x i32>
%808 = zext <4 x i1> %806 to <4 x i32>
%809 = add <4 x i32> %790, %807
%810 = add <4 x i32> %791, %808
%811 = add nuw i64 %770, 16
%812 = add i64 %773, 2
%813 = icmp eq i64 %812, %768
br i1 %813, label %814, label %769
814: ; preds = %769, %760
%815 = phi <4 x i32> [ undef, %760 ], [ %809, %769 ]
%816 = phi <4 x i32> [ undef, %760 ], [ %810, %769 ]
%817 = phi i64 [ 0, %760 ], [ %811, %769 ]
%818 = phi <4 x i32> [ zeroinitializer, %760 ], [ %809, %769 ]
%819 = phi <4 x i32> [ zeroinitializer, %760 ], [ %810, %769 ]
%820 = icmp eq i64 %765, 0
br i1 %820, label %840, label %821
821: ; preds = %814
%822 = getelementptr inbounds i8, i8* %498, i64 %817
%823 = bitcast i8* %822 to <4 x i8>*
%824 = load <4 x i8>, <4 x i8>* %823
%825 = getelementptr inbounds i8, i8* %822, i64 4
%826 = bitcast i8* %825 to <4 x i8>*
%827 = load <4 x i8>, <4 x i8>* %826
%828 = getelementptr inbounds i8, i8* %17, i64 %817
%829 = bitcast i8* %828 to <4 x i8>*
%830 = load <4 x i8>, <4 x i8>* %829
%831 = getelementptr inbounds i8, i8* %828, i64 4
%832 = bitcast i8* %831 to <4 x i8>*
%833 = load <4 x i8>, <4 x i8>* %832
%834 = icmp eq <4 x i8> %824, %830
%835 = icmp eq <4 x i8> %827, %833
%836 = zext <4 x i1> %834 to <4 x i32>
%837 = zext <4 x i1> %835 to <4 x i32>
%838 = add <4 x i32> %818, %836
%839 = add <4 x i32> %819, %837
br label %840
840: ; preds = %814, %821
%841 = phi <4 x i32> [ %815, %814 ], [ %838, %821 ]
%842 = phi <4 x i32> [ %816, %814 ], [ %839, %821 ]
%843 = add <4 x i32> %842, %841
%844 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %843)
%845 = icmp eq i64 %761, %758
br i1 %845, label %873, label %846
846: ; preds = %757, %840
%847 = phi i64 [ 0, %757 ], [ %761, %840 ]
%848 = phi i32 [ 0, %757 ], [ %844, %840 ]
br label %861
849: ; preds = %750, %849
%850 = phi i64 [ %859, %849 ], [ %751, %750 ]
%851 = phi i32 [ %858, %849 ], [ %752, %750 ]
%852 = getelementptr inbounds i8, i8* %183, i64 %850
%853 = load i8, i8* %852
%854 = getelementptr inbounds i8, i8* %10, i64 %850
%855 = load i8, i8* %854
%856 = icmp eq i8 %853, %855
%857 = zext i1 %856 to i32
%858 = add nuw nsw i32 %851, %857
%859 = add nuw nsw i64 %850, 1
%860 = icmp eq i64 %859, %662
br i1 %860, label %753, label %849
861: ; preds = %846, %861
%862 = phi i64 [ %871, %861 ], [ %847, %846 ]
%863 = phi i32 [ %870, %861 ], [ %848, %846 ]
%864 = getelementptr inbounds i8, i8* %498, i64 %862
%865 = load i8, i8* %864
%866 = getelementptr inbounds i8, i8* %17, i64 %862
%867 = load i8, i8* %866
%868 = icmp eq i8 %865, %867
%869 = zext i1 %868 to i32
%870 = add nuw nsw i32 %863, %869
%871 = add nuw nsw i64 %862, 1
%872 = icmp eq i64 %871, %758
br i1 %872, label %873, label %861
873: ; preds = %861, %840, %753
%874 = phi i32 [ 0, %753 ], [ %844, %840 ], [ %870, %861 ]
%875 = icmp eq i32 %754, %659
%876 = icmp eq i32 %874, %755
%877 = select i1 %875, i1 %876, i1 false
br i1 %877, label %878, label %881
878: ; preds = %873, %169
%879 = phi i8* [ %10, %169 ], [ %178, %873 ]
%880 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %879)
br label %881
881: ; preds = %878, %873, %169
ret i32 0
}