#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ EOF;
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ putchar(char);
scalar_t__ scanf(char *, int *, int *, int *, int *, int *, int *);
int main() {
  int n, m, i, j, k, sum, bag[120010], ar[7], cas = 1;
  while (scanf("%d %d %d %d %d %d", &ar[1], &ar[2], &ar[3], &ar[4], &ar[5],
               &ar[6]) != EOF &&
         (ar[1] || ar[2] || ar[3] || ar[4] || ar[5] || ar[6])) {
    printf("Collection #%d:\n", cas++);
    sum = ar[1] * 1 + ar[2] * 2 + ar[3] * 3 + ar[4] * 4 + ar[5] * 5 + ar[6] * 6;
    if (sum % 2 != 0) {
      printf("Can't be divided.\n");
      putchar('\n');
      continue;
    }
    sum /= 2;
    for (i = 1; i <= sum; i++)
      bag[i] = -100000000;
    bag[0] = 0;
    for (i = 1; i <= 6; i++) {
      if (ar[i] == 0)
        continue;
      if (ar[i] * i >= sum) {
        for (j = i; j <= 120000; j++)
          bag[j] = (bag[j] > bag[j - i] + i) ? bag[j] : (bag[j - i] + i);
      } else {
        k = 1;
        while (k <= ar[i]) {
          for (j = sum; j >= k * i; j--)
            bag[j] = (bag[j] > bag[j - k * i] + k * i)
                         ? bag[j]
                         : (bag[j - k * i] + k * i);
          ar[i] -= k;
          k *= 2;
        }
        if (ar[i])
          for (j = sum; j >= ar[i] * i; j--)
            bag[j] = (bag[j] > bag[j - ar[i] * i] + ar[i] * i)
                         ? bag[j]
                         : (bag[j - ar[i] * i] + ar[i] * i);
      }
    }
    if (bag[sum] > 0)
      printf("Can be divided.\n");
    else
      printf("Can't be divided.\n");
    putchar('\n');
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x75390,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x75374(%rbp)
lea    -0x75370(%rbp),%rsi
add    $0x4,%rsi
lea    -0x75370(%rbp),%rdx
add    $0x8,%rdx
lea    -0x75370(%rbp),%rcx
add    $0xc,%rcx
lea    -0x75370(%rbp),%r8
add    $0x10,%r8
lea    -0x75370(%rbp),%r9
add    $0x14,%r9
lea    -0x75370(%rbp),%rax
add    $0x18,%rax
lea    0xe6b(%rip),%rdi
mov    %rax,(%rsp)
call   1050 <scanf@plt>
mov    %rax,%rcx
xor    %eax,%eax
mov    0x2e3e(%rip),%rdx
cmp    (%rdx),%rcx
mov    %al,-0x75375(%rbp)
je     123e <main+0x10e>
mov    $0x1,%al
cmpl   $0x0,-0x7536c(%rbp)
mov    %al,-0x75376(%rbp)
jne    1232 <main+0x102>
mov    $0x1,%al
cmpl   $0x0,-0x75368(%rbp)
mov    %al,-0x75376(%rbp)
jne    1232 <main+0x102>
mov    $0x1,%al
cmpl   $0x0,-0x75364(%rbp)
mov    %al,-0x75376(%rbp)
jne    1232 <main+0x102>
mov    $0x1,%al
cmpl   $0x0,-0x75360(%rbp)
mov    %al,-0x75376(%rbp)
jne    1232 <main+0x102>
mov    $0x1,%al
cmpl   $0x0,-0x7535c(%rbp)
mov    %al,-0x75376(%rbp)
jne    1232 <main+0x102>
cmpl   $0x0,-0x75358(%rbp)
setne  %al
mov    %al,-0x75376(%rbp)
mov    -0x75376(%rbp),%al
mov    %al,-0x75375(%rbp)
mov    -0x75375(%rbp),%al
test   $0x1,%al
jne    1251 <main+0x121>
jmp    1610 <main+0x4e0>
mov    -0x75374(%rbp),%esi
mov    %esi,%eax
add    $0x1,%eax
mov    %eax,-0x75374(%rbp)
lea    0xda9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x7536c(%rbp),%eax
shl    $0x0,%eax
mov    -0x75368(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
imul   $0x3,-0x75364(%rbp),%ecx
add    %ecx,%eax
mov    -0x75360(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
imul   $0x5,-0x7535c(%rbp),%ecx
add    %ecx,%eax
imul   $0x6,-0x75358(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12de <main+0x1ae>
lea    0xd5b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    114c <main+0x1c>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     131c <main+0x1ec>
movslq -0x10(%rbp),%rax
movl   $0xfa0a1f00,-0x75350(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12f3 <main+0x1c3>
movl   $0x0,-0x75350(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x6,-0x10(%rbp)
jg     15ce <main+0x49e>
movslq -0x10(%rbp),%rax
cmpl   $0x0,-0x75370(%rbp,%rax,4)
jne    134e <main+0x21e>
jmp    15c0 <main+0x490>
movslq -0x10(%rbp),%rax
mov    -0x75370(%rbp,%rax,4),%eax
imul   -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     13f1 <main+0x2c1>
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1d4c0,-0x14(%rbp)
jg     13ec <main+0x2bc>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    -0x14(%rbp),%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    -0x75350(%rbp,%rcx,4),%ecx
add    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jle    13b5 <main+0x285>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    %eax,-0x7537c(%rbp)
jmp    13cd <main+0x29d>
mov    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
mov    -0x75350(%rbp,%rax,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x7537c(%rbp)
mov    -0x7537c(%rbp),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x75350(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    136c <main+0x23c>
jmp    15bb <main+0x48b>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
movslq -0x10(%rbp),%rcx
cmp    -0x75370(%rbp,%rcx,4),%eax
jg     14d4 <main+0x3a4>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jl     14af <main+0x37f>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0x10(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
mov    -0x75350(%rbp,%rcx,4),%ecx
mov    -0x18(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jle    146c <main+0x33c>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    %eax,-0x75380(%rbp)
jmp    1490 <main+0x360>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    %ecx,%eax
cltq
mov    -0x75350(%rbp,%rax,4),%eax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x75380(%rbp)
mov    -0x75380(%rbp),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x75350(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1412 <main+0x2e2>
mov    -0x18(%rbp),%edx
movslq -0x10(%rbp),%rax
mov    -0x75370(%rbp,%rax,4),%ecx
sub    %edx,%ecx
mov    %ecx,-0x75370(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13f8 <main+0x2c8>
movslq -0x10(%rbp),%rax
cmpl   $0x0,-0x75370(%rbp,%rax,4)
je     15b6 <main+0x486>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
movslq -0x10(%rbp),%rcx
mov    -0x75370(%rbp,%rcx,4),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jl     15b1 <main+0x481>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    -0x14(%rbp),%ecx
movslq -0x10(%rbp),%rdx
mov    -0x75370(%rbp,%rdx,4),%edx
imul   -0x10(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
mov    -0x75350(%rbp,%rcx,4),%ecx
movslq -0x10(%rbp),%rdx
mov    -0x75370(%rbp,%rdx,4),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jle    155e <main+0x42e>
movslq -0x14(%rbp),%rax
mov    -0x75350(%rbp,%rax,4),%eax
mov    %eax,-0x75384(%rbp)
jmp    1592 <main+0x462>
mov    -0x14(%rbp),%eax
movslq -0x10(%rbp),%rcx
mov    -0x75370(%rbp,%rcx,4),%ecx
imul   -0x10(%rbp),%ecx
sub    %ecx,%eax
cltq
mov    -0x75350(%rbp,%rax,4),%eax
movslq -0x10(%rbp),%rcx
mov    -0x75370(%rbp,%rcx,4),%ecx
imul   -0x10(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x75384(%rbp)
mov    -0x75384(%rbp),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x75350(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    14ec <main+0x3bc>
jmp    15b6 <main+0x486>
jmp    15bb <main+0x48b>
jmp    15c0 <main+0x490>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    132d <main+0x1fd>
movslq -0x1c(%rbp),%rax
cmpl   $0x0,-0x75350(%rbp,%rax,4)
jle    15f3 <main+0x4c3>
lea    0xa4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1601 <main+0x4d1>
lea    0xa29(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    114c <main+0x1c>
xor    %eax,%eax
add    $0x75390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x753a8,%rsp
lea    0x14(%rsp),%r14
lea    0x18(%rsp),%r15
lea    0x1c(%rsp),%r12
lea    0x20(%rsp),%r13
lea    0x24(%rsp),%rbx
lea    0x28(%rsp),%rax
mov    %rax,(%rsp)
lea    0xea6(%rip),%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r13,%r8
mov    %rbx,%r9
call   1060 <scanf@plt>
mov    0x2e53(%rip),%rcx
cmp    (%rcx),%rax
jne    11ae <main+0x6e>
xor    %eax,%eax
add    $0x753a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebp
jmp    1242 <main+0x102>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
cmpl   $0x0,0x80(%rsp,%rax,4)
lea    0xe7f(%rip),%rdi
lea    0xe68(%rip),%rax
cmovg  %rax,%rdi
lea    0x14(%rsp),%r14
lea    0x18(%rsp),%r15
lea    0x1c(%rsp),%r12
lea    0x20(%rsp),%r13
lea    0x24(%rsp),%rbx
mov    0x44(%rsp),%ebp
add    $0x1,%ebp
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x28(%rsp),%rax
mov    %rax,(%rsp)
lea    0xe02(%rip),%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r13,%r8
mov    %rbx,%r9
call   1060 <scanf@plt>
mov    0x2daf(%rip),%rcx
cmp    (%rcx),%rax
je     119a <main+0x5a>
movdqu 0x14(%rsp),%xmm0
pcmpeqd 0xdc0(%rip),%xmm0
movmskps %xmm0,%eax
cmp    $0xf,%eax
jne    126a <main+0x12a>
cmpl   $0x0,0x24(%rsp)
jne    126a <main+0x12a>
cmpl   $0x0,0x28(%rsp)
je     119a <main+0x5a>
lea    0xdc1(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x14(%rsp),%esi
mov    0x18(%rsp),%eax
lea    (%rsi,%rax,2),%eax
mov    0x1c(%rsp),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %eax,%ecx
mov    0x20(%rsp),%eax
lea    (%rcx,%rax,4),%eax
mov    0x24(%rsp),%ecx
lea    (%rcx,%rcx,4),%ecx
add    %eax,%ecx
mov    0x28(%rsp),%eax
lea    (%rax,%rax,2),%eax
lea    (%rcx,%rax,2),%eax
lea    0xda4(%rip),%rdi
test   $0x1,%al
jne    11fc <main+0xbc>
mov    %ebp,0x44(%rsp)
mov    %eax,%r10d
shr    $0x1f,%r10d
add    %eax,%r10d
sar    %r10d
cmp    $0x2,%eax
movdqa 0xd2d(%rip),%xmm0
jl     13d4 <main+0x294>
lea    0x1(%r10),%eax
lea    -0x1(%rax),%rdi
mov    $0x1,%edx
cmp    $0x8,%rdi
jb     13c0 <main+0x280>
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rbx
mov    %rbx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%ebp
and    $0x3,%ebp
cmp    $0x18,%rbx
jae    1315 <main+0x1d5>
xor    %ebx,%ebx
jmp    1372 <main+0x232>
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,0x84(%rsp,%rbx,4)
movdqu %xmm0,0x94(%rsp,%rbx,4)
movdqu %xmm0,0xa4(%rsp,%rbx,4)
movdqu %xmm0,0xb4(%rsp,%rbx,4)
movdqu %xmm0,0xc4(%rsp,%rbx,4)
movdqu %xmm0,0xd4(%rsp,%rbx,4)
movdqu %xmm0,0xe4(%rsp,%rbx,4)
movdqu %xmm0,0xf4(%rsp,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1320 <main+0x1e0>
test   %rbp,%rbp
je     13a8 <main+0x268>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rbx,4),%rcx
or     $0x4,%rcx
movdqu %xmm0,0x80(%rsp,%rcx,1)
movdqu %xmm0,0x90(%rsp,%rcx,1)
add    $0x8,%rbx
add    $0xffffffffffffffff,%rbp
jne    1380 <main+0x240>
cmp    %rdx,%rdi
je     13d4 <main+0x294>
or     $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0xfa0a1f00,0x80(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    13c0 <main+0x280>
movl   $0x0,0x80(%rsp)
movslq %r10d,%rcx
lea    (%rsp,%rcx,4),%rax
add    $0x80,%rax
mov    %rax,0x38(%rsp)
lea    0x84(%rsp),%rax
lea    (%rax,%rcx,4),%rdx
mov    %rdx,0x58(%rsp)
lea    0x1(%rcx),%rdx
mov    %rdx,0x68(%rsp)
lea    -0x10(%rax,%rcx,4),%rax
mov    %rax,0x48(%rsp)
mov    $0x1,%r12d
mov    $0x1d4c0,%r14d
lea    0x80(%rsp),%rbx
lea    0x94(%rsp),%r15
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    %r10,0x50(%rsp)
mov    %rcx,0x8(%rsp)
test   %esi,%esi
je     1810 <main+0x6d0>
nopw   0x0(%rax,%rax,1)
mov    %esi,%eax
imul   %r12d,%eax
cmp    %r10d,%eax
jge    1640 <main+0x500>
test   %esi,%esi
jle    17b3 <main+0x673>
mov    %rbx,0x70(%rsp)
mov    %r14,0x78(%rsp)
mov    $0x1,%r13d
jmp    148f <main+0x34f>
nopl   0x0(%rax)
sub    %r13d,%esi
add    %r13d,%r13d
cmp    %r13d,%esi
jl     17a0 <main+0x660>
mov    %r13d,%r9d
imul   %r12d,%r9d
cmp    %r9d,%r10d
jl     1480 <main+0x340>
movslq %r9d,%r8
mov    0x68(%rsp),%rbx
sub    %r8,%rbx
mov    0x8(%rsp),%rdx
cmp    $0x8,%rbx
jb     15f0 <main+0x4b0>
mov    0x8(%rsp),%rcx
mov    %rcx,%rax
sub    %r8,%rax
mov    $0x4,%edx
mul    %rdx
seto   %r11b
mov    0x38(%rsp),%rbp
mov    %rbp,%rdi
sub    %rax,%rdi
mov    %rcx,%rdx
cmp    %rbp,%rdi
ja     15f0 <main+0x4b0>
mov    0x8(%rsp),%rdx
test   %r11b,%r11b
jne    15f0 <main+0x4b0>
lea    0x0(,%r8,4),%r14
mov    0x38(%rsp),%rdi
sub    %r14,%rdi
mov    %rdi,%rbp
sub    %rax,%rbp
mov    0x8(%rsp),%rdx
cmp    %rdi,%rbp
ja     15f0 <main+0x4b0>
mov    0x8(%rsp),%rdx
test   %r11b,%r11b
jne    15f0 <main+0x4b0>
lea    0x80(%rsp),%rax
mov    0x58(%rsp),%rdx
cmp    %rdx,%rax
setb   %al
lea    (%rsp,%r8,4),%rcx
add    $0x80,%rcx
sub    %r14,%rdx
cmp    %rdx,%rcx
jae    1556 <main+0x416>
mov    0x8(%rsp),%rdx
test   %al,%al
jne    15f0 <main+0x4b0>
mov    %rbx,%r11
and    $0xfffffffffffffff8,%r11
mov    0x8(%rsp),%rdx
sub    %r11,%rdx
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm0
neg    %r14
mov    0x48(%rsp),%r10
mov    %r11,%rax
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%r10),%xmm1
movdqu (%r10),%xmm2
movdqu -0x10(%r10,%r14,1),%xmm3
movdqu (%r10,%r14,1),%xmm4
pshufd $0x1b,%xmm0,%xmm5
paddd  %xmm5,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm4,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm4,%xmm6
por    %xmm2,%xmm6
movdqu %xmm6,(%r10)
paddd  %xmm5,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqu %xmm2,-0x10(%r10)
add    $0xffffffffffffffe0,%r10
add    $0xfffffffffffffff8,%rax
jne    1580 <main+0x440>
cmp    %r11,%rbx
mov    0x50(%rsp),%r10
je     1480 <main+0x340>
add    $0x1,%rdx
lea    0x0(,%r8,4),%rax
neg    %rax
add    %rsp,%rax
add    $0x80,%rax
nopl   0x0(%rax,%rax,1)
mov    0x7c(%rsp,%rdx,4),%ecx
mov    -0x4(%rax,%rdx,4),%edi
add    %r9d,%edi
cmp    %edi,%ecx
cmovg  %ecx,%edi
mov    %edi,0x7c(%rsp,%rdx,4)
add    $0xffffffffffffffff,%rdx
cmp    %r8,%rdx
jg     1610 <main+0x4d0>
jmp    1480 <main+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1d4c0,%edx
sub    0x60(%rsp),%rdx
mov    %r12,%rax
cmp    $0x8,%rdx
jb     170e <main+0x5ce>
lea    (%rsp,%r12,4),%rcx
add    $0x80,%rcx
lea    (%rsp,%rdx,4),%rsi
add    $0x80,%rsi
mov    %r12,%rax
cmp    %rsi,%rcx
jb     170e <main+0x5ce>
lea    0x0(,%r14,4),%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rdx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    (%r12,%rdi,1),%rax
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqu -0x10(%r15,%rcx,1),%xmm1
movdqu (%r15,%rcx,1),%xmm2
movdqa 0x80(%rsp,%rcx,1),%xmm3
paddd  %xmm0,%xmm3
movdqa 0x90(%rsp,%rcx,1),%xmm4
paddd  %xmm0,%xmm4
movdqa %xmm1,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm5,%xmm1
pandn  %xmm3,%xmm5
por    %xmm1,%xmm5
movdqa %xmm2,%xmm1
pcmpgtd %xmm4,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm4,%xmm1
por    %xmm2,%xmm1
movdqu %xmm5,-0x10(%r15,%rcx,1)
movdqu %xmm1,(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    16a0 <main+0x560>
cmp    %rdi,%rdx
je     1810 <main+0x6d0>
mov    $0x1,%edx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1744 <main+0x604>
mov    0x80(%rsp,%rax,4),%ecx
mov    %rax,%rdx
sub    %r12,%rdx
mov    0x80(%rsp,%rdx,4),%edx
add    %r12d,%edx
cmp    %edx,%ecx
cmovg  %ecx,%edx
mov    %edx,0x80(%rsp,%rax,4)
lea    0x1(%rax),%rcx
cmp    $0x1d4c0,%rax
je     1810 <main+0x6d0>
mov    -0x4(%rbx,%rcx,4),%eax
add    %r12d,%eax
mov    0x80(%rsp,%rcx,4),%edx
mov    0x84(%rsp,%rcx,4),%esi
cmp    %eax,%edx
cmovg  %edx,%eax
mov    %eax,0x80(%rsp,%rcx,4)
mov    (%rbx,%rcx,4),%eax
add    %r12d,%eax
cmp    %eax,%esi
cmovg  %esi,%eax
mov    %eax,0x84(%rsp,%rcx,4)
add    $0x2,%rcx
cmp    $0x1d4c1,%rcx
jne    1750 <main+0x610>
jmp    1810 <main+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,0x10(%rsp,%r12,4)
test   %esi,%esi
mov    0x78(%rsp),%r14
mov    0x70(%rsp),%rbx
je     1810 <main+0x6d0>
imul   %r12d,%esi
cmp    %esi,%r10d
jl     1810 <main+0x6d0>
movslq %esi,%r13
mov    0x68(%rsp),%r8
sub    %r13,%r8
mov    0x8(%rsp),%rdx
cmp    $0x8,%r8
jae    183f <main+0x6ff>
add    $0x1,%rdx
lea    0x0(,%r13,4),%rax
neg    %rax
add    %rsp,%rax
add    $0x80,%rax
nopw   0x0(%rax,%rax,1)
mov    0x7c(%rsp,%rdx,4),%ecx
mov    -0x4(%rax,%rdx,4),%edi
add    %esi,%edi
cmp    %edi,%ecx
cmovg  %ecx,%edi
mov    %edi,0x7c(%rsp,%rdx,4)
add    $0xffffffffffffffff,%rdx
cmp    %r13,%rdx
jg     17f0 <main+0x6b0>
nopl   0x0(%rax)
add    $0x1,%r12
cmp    $0x7,%r12
je     11c0 <main+0x80>
mov    0x10(%rsp,%r12,4),%esi
addq   $0x1,0x60(%rsp)
add    $0xffffffffffffffff,%r14
add    $0x4,%r15
add    $0xfffffffffffffffc,%rbx
test   %esi,%esi
jne    1450 <main+0x310>
jmp    1810 <main+0x6d0>
mov    0x8(%rsp),%rbp
mov    %rbp,%rax
sub    %r13,%rax
mov    $0x4,%ecx
mul    %rcx
seto   %r11b
mov    0x38(%rsp),%rcx
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rbp,%rdx
cmp    %rcx,%rdi
ja     17d2 <main+0x692>
mov    0x8(%rsp),%rdx
test   %r11b,%r11b
jne    17d2 <main+0x692>
lea    0x0(,%r13,4),%r9
mov    0x38(%rsp),%rdi
sub    %r9,%rdi
mov    %rdi,%rbp
sub    %rax,%rbp
mov    0x8(%rsp),%rdx
cmp    %rdi,%rbp
ja     17d2 <main+0x692>
mov    0x8(%rsp),%rdx
test   %r11b,%r11b
jne    17d2 <main+0x692>
lea    0x80(%rsp),%rax
mov    0x58(%rsp),%rdx
cmp    %rdx,%rax
setb   %al
lea    (%rsp,%r13,4),%rcx
add    $0x80,%rcx
sub    %r9,%rdx
cmp    %rdx,%rcx
jae    18e0 <main+0x7a0>
mov    0x8(%rsp),%rdx
test   %al,%al
jne    17d2 <main+0x692>
mov    %r8,%r10
and    $0xfffffffffffffff8,%r10
mov    0x8(%rsp),%rdx
sub    %r10,%rdx
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
neg    %r9
mov    0x48(%rsp),%rax
mov    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rax),%xmm1
movdqu (%rax),%xmm2
movdqu -0x10(%rax,%r9,1),%xmm3
movdqu (%rax,%r9,1),%xmm4
pshufd $0x1b,%xmm0,%xmm5
paddd  %xmm5,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm4,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm4,%xmm6
por    %xmm2,%xmm6
movdqu %xmm6,(%rax)
paddd  %xmm5,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqu %xmm2,-0x10(%rax)
add    $0xffffffffffffffe0,%rax
add    $0xfffffffffffffff8,%rcx
jne    1910 <main+0x7d0>
cmp    %r10,%r8
mov    0x50(%rsp),%r10
jne    17d2 <main+0x692>
jmp    1810 <main+0x6d0>

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

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