#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 EXIT_SUCCESS;
char getchar();
int hasSameNum(int *, int);
int isBiggest(int *, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main(int argc, char **argv) {
  int case_num;
  int i;
  scanf("%d\n", &case_num);
  for (i = 1; i <= case_num; i++) {
    int t1, switch_times, size;
    int data[6];
    for (size = 0; size < 6; size++) {
      data[size] = -1;
    }
    size = 0;
    while (1) {
      char t = getchar();
      if (t != ' ') {
        data[size++] = t - '0';
      } else {
        break;
      }
    }
    scanf("%d\n", &switch_times);
    int left_p = 0;
    for (t1 = switch_times; t1 > 0; t1--) {
      if (isBiggest(data, size) == 1) {
        if (t1 % 2 == 0) {
          t1 = 0;
        } else {
          if (hasSameNum(data, size) == 1) {
            t1 = 0;
            break;
          }
          int tmp = data[size - 1];
          data[size - 1] = data[size - 2];
          data[size - 2] = tmp;
          t1 = 0;
        }
      } else {
        int max = 0;
        int max_num = 0;
        int j;
        int max_pos = -1;
        for (j = (size - 1); j >= left_p; j--) {
          max = (data[j] > max) ? data[j] : max;
        }
        for (j = (size - 1); j >= left_p; j--) {
          if (data[j] == max) {
            if (max_pos == -1) {
              max_pos = j;
            }
            ++max_num;
          }
        }
        if (data[left_p] == max) {
          left_p++;
          t1++;
          continue;
        }
        if (max_num == 1 || t1 == 1) {
          if (max == data[left_p]) {
            left_p++;
            t1++;
            continue;
          } else {
            data[max_pos] = data[left_p];
            data[left_p] = max;
            left_p++;
          }
        } else {
          int remain_times = t1;
          int smaller_than_max = 0;
          for (j = (max_pos - 1); j >= left_p; j--) {
            if (data[j] < max) {
              smaller_than_max++;
            }
          }
          int k = (remain_times < smaller_than_max) ? remain_times
                                                    : smaller_than_max;
          k = (k < max_num) ? k : max_num;
          int tmp[10] = {0};
          for (j = (max_pos - 1); j >= left_p; j--) {
            if (data[j] == max) {
              continue;
            }
            tmp[data[j]]++;
          }
          int l = 0;
          for (j = 9; j >= 0; j--) {
            if (tmp[j] != 0) {
              k--;
              if (k == 0) {
                l = j;
                break;
              }
            }
          }
          for (j = (max_pos - 1); j >= left_p; j--) {
            if (data[j] == l) {
              data[max_pos] = data[j];
              data[j] = max;
              break;
            }
          }
        }
      }
    }
    printf("#%d ", i);
    for (t1 = 0; t1 < size; t1++) {
      printf("%d", data[t1]);
    }
    printf("\n");
  }
  return (EXIT_SUCCESS);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xe80(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1070 <scanf@plt>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1668 <main+0x508>
movl   $0x0,-0x24(%rbp)
cmpl   $0x6,-0x24(%rbp)
jge    11c7 <main+0x67>
movslq -0x24(%rbp),%rax
movl   $0xffffffff,-0x40(%rbp,%rax,4)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a3 <main+0x43>
movl   $0x0,-0x24(%rbp)
mov    $0x0,%al
call   1060 <getchar@plt>
mov    %al,-0x41(%rbp)
movsbl -0x41(%rbp),%eax
cmp    $0x20,%eax
je     1202 <main+0xa2>
movsbl -0x41(%rbp),%ecx
sub    $0x30,%ecx
mov    -0x24(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
cltq
mov    %ecx,-0x40(%rbp,%rax,4)
jmp    1207 <main+0xa7>
jmp    120c <main+0xac>
jmp    11ce <main+0x6e>
lea    0xded(%rip),%rdi
lea    -0x20(%rbp),%rsi
call   1070 <scanf@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1604 <main+0x4a4>
lea    -0x40(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1040 <isBiggest@plt>
cmp    $0x1,%eax
jne    12cb <main+0x16b>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1268 <main+0x108>
movl   $0x0,-0x1c(%rbp)
jmp    12c6 <main+0x166>
lea    -0x40(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1080 <hasSameNum@plt>
cmp    $0x1,%eax
jne    1289 <main+0x129>
movl   $0x0,-0x1c(%rbp)
jmp    1604 <main+0x4a4>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
cltq
mov    -0x40(%rbp,%rax,4),%ecx
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x4c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
cltq
mov    %ecx,-0x40(%rbp,%rax,4)
movl   $0x0,-0x1c(%rbp)
jmp    15f1 <main+0x491>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     1339 <main+0x1d9>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x50(%rbp),%eax
jle    1319 <main+0x1b9>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x98(%rbp)
jmp    1322 <main+0x1c2>
mov    -0x50(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    12e9 <main+0x189>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     138b <main+0x22b>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x50(%rbp),%eax
jne    1378 <main+0x218>
cmpl   $0xffffffff,-0x5c(%rbp)
jne    136f <main+0x20f>
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    137d <main+0x21d>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    1342 <main+0x1e2>
movslq -0x48(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x50(%rbp),%eax
jne    13b3 <main+0x253>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15f6 <main+0x496>
cmpl   $0x1,-0x54(%rbp)
je     13c7 <main+0x267>
cmpl   $0x1,-0x1c(%rbp)
jne    1418 <main+0x2b8>
mov    -0x50(%rbp),%eax
movslq -0x48(%rbp),%rcx
cmp    -0x40(%rbp,%rcx,4),%eax
jne    13ef <main+0x28f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15f6 <main+0x496>
movslq -0x48(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
movslq -0x5c(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x50(%rbp),%ecx
movslq -0x48(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15ec <main+0x48c>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     1467 <main+0x307>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x50(%rbp),%eax
jge    1454 <main+0x2f4>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1459 <main+0x2f9>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    142e <main+0x2ce>
mov    -0x60(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1481 <main+0x321>
mov    -0x60(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    148a <main+0x32a>
mov    -0x64(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    14ad <main+0x34d>
mov    -0x68(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    14b6 <main+0x356>
mov    -0x54(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x68(%rbp)
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     1525 <main+0x3c5>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x50(%rbp),%eax
jne    14fd <main+0x39d>
jmp    1517 <main+0x3b7>
movslq -0x58(%rbp),%rax
movslq -0x40(%rbp,%rax,4),%rax
mov    -0x90(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    14db <main+0x37b>
movl   $0x0,-0x94(%rbp)
movl   $0x9,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     158b <main+0x42b>
movslq -0x58(%rbp),%rax
cmpl   $0x0,-0x90(%rbp,%rax,4)
je     1578 <main+0x418>
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x68(%rbp)
jne    1573 <main+0x413>
mov    -0x58(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    158b <main+0x42b>
jmp    1578 <main+0x418>
jmp    157d <main+0x41d>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    1536 <main+0x3d6>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     15e7 <main+0x487>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x94(%rbp),%eax
jne    15d4 <main+0x474>
movslq -0x58(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
movslq -0x5c(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x50(%rbp),%ecx
movslq -0x58(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
jmp    15e7 <main+0x487>
jmp    15d9 <main+0x479>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    1594 <main+0x434>
jmp    15ec <main+0x48c>
jmp    15f1 <main+0x491>
jmp    15f6 <main+0x496>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1229 <main+0xc9>
mov    -0x18(%rbp),%esi
lea    0x9f6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    164c <main+0x4ec>
movslq -0x1c(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
lea    0x9d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    161c <main+0x4bc>
lea    0x9af(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1190 <main+0x30>
mov    0x2971(%rip),%rax
mov    (%rax),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
lea    0xe98(%rip),%rdi
lea    0x28(%rsp),%rsi
call   1070 <scanf@plt>
cmpl   $0x0,0x28(%rsp)
jle    197b <main+0x81b>
mov    $0x1,%eax
mov    %rsp,%rbx
jmp    11bc <main+0x5c>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r15),%eax
cmp    0x28(%rsp),%r15d
mov    %rsp,%rbx
jge    197b <main+0x81b>
mov    %rax,0x80(%rsp)
pcmpeqd %xmm0,%xmm0
movdqa %xmm0,(%rsp)
movq   $0xffffffffffffffff,0x10(%rsp)
ff ff
xor    %eax,%eax
call   1060 <getchar@plt>
mov    $0x0,%r14d
cmp    $0x20,%al
je     1209 <main+0xa9>
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
movsbl %al,%eax
add    $0xffffffd0,%eax
mov    %eax,(%rsp,%r14,4)
add    $0x1,%r14
xor    %eax,%eax
call   1060 <getchar@plt>
cmp    $0x20,%al
jne    11f0 <main+0x90>
lea    0xe00(%rip),%rdi
lea    0x2c(%rsp),%rsi
call   1070 <scanf@plt>
mov    0x2c(%rsp),%r13d
test   %r13d,%r13d
jle    1930 <main+0x7d0>
lea    -0x1(%r14),%eax
cltq
mov    %rax,0x68(%rsp)
lea    -0x2(%r14),%eax
cltq
mov    %rax,0x60(%rsp)
movslq %r14d,%rcx
lea    -0x1(%rcx),%rax
mov    %rax,0x20(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x88(%rsp)
lea    -0x10(%rsp),%rax
mov    %rcx,0x90(%rsp)
lea    (%rax,%rcx,4),%r12
xor    %r15d,%r15d
jmp    1289 <main+0x129>
xchg   %ax,%ax
add    $0x1,%r15d
add    $0x1,%r13d
lea    -0x1(%r13),%eax
cmp    $0x1,%r13d
mov    %eax,%r13d
jle    1930 <main+0x7d0>
mov    %rbx,%rdi
mov    %r14d,%esi
call   1050 <isBiggest@plt>
cmp    $0x1,%eax
je     1900 <main+0x7a0>
mov    $0xffffffff,%r9d
xor    %edx,%edx
movslq %r15d,%rax
cmp    %r15d,%r14d
jle    14b0 <main+0x350>
mov    0x90(%rsp),%r8
sub    %rax,%r8
xor    %edx,%edx
mov    0x20(%rsp),%rdi
cmp    $0x8,%r8
jb     144a <main+0x2ea>
mov    %r8,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     17a4 <main+0x644>
mov    %rdx,%rdi
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%rdi
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu -0x30(%r12,%rbp,4),%xmm2
movdqu -0x20(%r12,%rbp,4),%xmm3
movdqu -0x10(%r12,%rbp,4),%xmm4
movdqu (%r12,%rbp,4),%xmm5
pshufd $0x1b,%xmm5,%xmm5
pshufd $0x1b,%xmm4,%xmm4
movdqa %xmm5,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm5
pandn  %xmm0,%xmm6
por    %xmm5,%xmm6
movdqa %xmm4,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm4
pandn  %xmm1,%xmm5
por    %xmm4,%xmm5
pshufd $0x1b,%xmm3,%xmm1
pshufd $0x1b,%xmm2,%xmm2
movdqa %xmm1,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm6,%xmm0
por    %xmm1,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1310 <main+0x1b0>
neg    %rbp
test   $0x1,%dl
je     13f3 <main+0x293>
mov    0x20(%rsp),%rcx
sub    %rbp,%rcx
movdqu -0x1c(%rsp,%rcx,4),%xmm2
movdqu -0xc(%rsp,%rcx,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
pshufd $0x1b,%xmm2,%xmm2
movdqa %xmm3,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm0,%xmm4
por    %xmm3,%xmm4
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqa %xmm4,%xmm0
movdqa %xmm3,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%edx
cmp    %rsi,%r8
je     1462 <main+0x302>
mov    0x20(%rsp),%rdi
sub    %rsi,%rdi
add    $0x1,%rdi
xchg   %ax,%ax
mov    -0x4(%rsp,%rdi,4),%ecx
cmp    %edx,%ecx
cmovg  %ecx,%edx
add    $0xffffffffffffffff,%rdi
cmp    %rax,%rdi
jg     1450 <main+0x2f0>
xor    %esi,%esi
cmp    %r15d,%r14d
jle    14b2 <main+0x352>
mov    %rax,%rcx
not    %rcx
cmp    0x88(%rsp),%rcx
jne    1712 <main+0x5b2>
xor    %esi,%esi
mov    $0xffffffff,%r9d
mov    0x20(%rsp),%rbp
test   $0x1,%r8b
je     14a9 <main+0x349>
cmp    $0xffffffff,%r9d
mov    %ebp,%ecx
cmovne %r9d,%ecx
xor    %edi,%edi
cmp    %edx,(%rsp,%rbp,4)
sete   %dil
cmove  %ecx,%r9d
add    %edi,%esi
mov    %rsp,%rbx
jmp    14b2 <main+0x352>
xchg   %ax,%ax
xor    %esi,%esi
mov    (%rsp,%rax,4),%edi
cmp    %edx,%edi
je     1270 <main+0x110>
cmp    $0x1,%esi
je     1700 <main+0x5a0>
cmp    $0x1,%r13d
je     1700 <main+0x5a0>
cmp    %r15d,%r9d
jle    1774 <main+0x614>
movslq %r9d,%r10
lea    -0x1(%r10),%r11
cmp    %r11,%rax
cmovl  %rax,%r11
mov    %r10,%r8
sub    %r11,%r8
xor    %edi,%edi
mov    %r10,%rbp
cmp    $0x8,%r8
jb     1630 <main+0x4d0>
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rcx),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rdi,%rdi
je     1893 <main+0x733>
mov    %rcx,0x70(%rsp)
mov    %rbx,%rdi
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%rdi
lea    -0x10(%rsp),%rcx
mov    %r10,0x78(%rsp)
lea    (%rcx,%r10,4),%r10
pxor   %xmm1,%xmm1
xor    %ebp,%ebp
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%r10,%rbp,4),%xmm3
movdqu -0x20(%r10,%rbp,4),%xmm4
movdqu -0x10(%r10,%rbp,4),%xmm5
movdqu (%r10,%rbp,4),%xmm6
pshufd $0x1b,%xmm6,%xmm6
pshufd $0x1b,%xmm5,%xmm5
movdqa %xmm0,%xmm7
pcmpgtd %xmm6,%xmm7
psubd  %xmm7,%xmm1
movdqa %xmm0,%xmm6
pcmpgtd %xmm5,%xmm6
psubd  %xmm6,%xmm2
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
movdqa %xmm0,%xmm5
pcmpgtd %xmm4,%xmm5
psubd  %xmm5,%xmm1
movdqa %xmm0,%xmm4
pcmpgtd %xmm3,%xmm4
psubd  %xmm4,%xmm2
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1560 <main+0x400>
neg    %rbp
mov    0x78(%rsp),%r10
mov    0x70(%rsp),%rcx
test   $0x1,%bl
je     160b <main+0x4ab>
not    %rbp
add    %r10,%rbp
movdqu -0x1c(%rsp,%rbp,4),%xmm3
movdqu -0xc(%rsp,%rbp,4),%xmm4
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
movdqa %xmm0,%xmm5
pcmpgtd %xmm4,%xmm5
psubd  %xmm5,%xmm1
pcmpgtd %xmm3,%xmm0
psubd  %xmm0,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edi
cmp    %rcx,%r8
je     1647 <main+0x4e7>
mov    %r10,%rbp
sub    %rcx,%rbp
xor    %ebx,%ebx
cmp    %edx,-0x4(%rsp,%rbp,4)
lea    -0x1(%rbp),%rcx
setl   %bl
add    %ebx,%edi
mov    %rcx,%rbp
cmp    %rax,%rcx
jg     1630 <main+0x4d0>
cmp    %edi,%r13d
cmovl  %r13d,%edi
cmp    %esi,%edi
cmovge %esi,%edi
pxor   %xmm0,%xmm0
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x30(%rsp)
movq   $0x0,0x50(%rsp)
cmp    %r15d,%r9d
jle    17bc <main+0x65c>
movslq %r9d,%rsi
test   $0x1,%r8b
mov    %rsp,%rbx
je     1693 <main+0x533>
movslq -0x4(%rsp,%rsi,4),%rcx
add    $0xffffffffffffffff,%rsi
cmp    %edx,%ecx
je     1693 <main+0x533>
addl   $0x1,0x30(%rsp,%rcx,4)
not    %r11
add    %r10,%r11
jne    16d5 <main+0x575>
cmpl   $0x0,0x54(%rsp)
je     179b <main+0x63b>
add    $0xffffffff,%edi
jne    179b <main+0x63b>
mov    $0x9,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rax,%rsi
jle    169b <main+0x53b>
movslq -0x4(%rsp,%rsi,4),%rcx
cmp    %edx,%ecx
je     16e3 <main+0x583>
addl   $0x1,0x30(%rsp,%rcx,4)
movslq -0x8(%rsp,%rsi,4),%rcx
add    $0xfffffffffffffffe,%rsi
cmp    %edx,%ecx
je     16d0 <main+0x570>
addl   $0x1,0x30(%rsp,%rcx,4)
jmp    16d0 <main+0x570>
nopw   0x0(%rax,%rax,1)
movslq %r9d,%rcx
mov    %edi,(%rsp,%rcx,4)
mov    %edx,(%rsp,%rax,4)
add    $0x1,%r15d
jmp    1278 <main+0x118>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    $0xffffffff,%r9d
mov    0x20(%rsp),%rbp
jmp    1750 <main+0x5f0>
nopl   0x0(%rax,%rax,1)
mov    %r9d,%ecx
xor    %ebx,%ebx
cmp    %edx,-0x4(%rsp,%rbp,4)
cmove  %ecx,%r9d
sete   %bl
add    %ebx,%esi
add    $0xfffffffffffffffe,%rbp
add    $0xfffffffffffffffe,%rdi
je     148a <main+0x32a>
mov    %ebp,%ecx
cmp    $0xffffffff,%r9d
je     175b <main+0x5fb>
mov    %r9d,%ecx
xor    %ebx,%ebx
cmp    %edx,(%rsp,%rbp,4)
sete   %bl
cmove  %ecx,%r9d
add    %ebx,%esi
cmp    $0xffffffff,%r9d
jne    1730 <main+0x5d0>
lea    -0x1(%rbp),%ecx
jmp    1733 <main+0x5d3>
mov    %r13d,%edi
sar    $0x1f,%edi
and    %r13d,%edi
cmp    %esi,%edi
cmovge %esi,%edi
pxor   %xmm0,%xmm0
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x30(%rsp)
movq   $0x0,0x50(%rsp)
cmpl   $0x0,0x50(%rsp)
jne    17c6 <main+0x666>
jmp    17cf <main+0x66f>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    13a5 <main+0x245>
jmp    13f3 <main+0x293>
mov    %rsp,%rbx
cmpl   $0x0,0x50(%rsp)
je     17cf <main+0x66f>
add    $0xffffffff,%edi
je     1853 <main+0x6f3>
cmpl   $0x0,0x4c(%rsp)
je     17df <main+0x67f>
add    $0xffffffff,%edi
je     1863 <main+0x703>
cmpl   $0x0,0x48(%rsp)
je     17ef <main+0x68f>
add    $0xffffffff,%edi
je     1873 <main+0x713>
cmpl   $0x0,0x44(%rsp)
je     17ff <main+0x69f>
add    $0xffffffff,%edi
je     1883 <main+0x723>
cmpl   $0x0,0x40(%rsp)
je     180f <main+0x6af>
add    $0xffffffff,%edi
je     18ab <main+0x74b>
cmpl   $0x0,0x3c(%rsp)
je     181f <main+0x6bf>
add    $0xffffffff,%edi
je     18bb <main+0x75b>
cmpl   $0x0,0x38(%rsp)
je     182f <main+0x6cf>
add    $0xffffffff,%edi
je     18cb <main+0x76b>
cmpl   $0x0,0x34(%rsp)
setne  %cl
cmp    $0x1,%edi
sete   %bl
and    %cl,%bl
movzbl %bl,%esi
mov    %rsp,%rbx
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x8,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x7,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x6,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x5,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
pxor   %xmm1,%xmm1
xor    %ebp,%ebp
pxor   %xmm2,%xmm2
test   $0x1,%bl
jne    15db <main+0x47b>
jmp    160b <main+0x4ab>
mov    $0x4,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x3,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
jmp    18d9 <main+0x779>
mov    $0x2,%esi
cmp    %r15d,%r9d
jle    1278 <main+0x118>
movslq %r9d,%rcx
mov    %rcx,%rdi
nop
cmp    %esi,-0x4(%rsp,%rdi,4)
je     18f4 <main+0x794>
add    $0xffffffffffffffff,%rdi
cmp    %rax,%rdi
jg     18e0 <main+0x780>
jmp    1278 <main+0x118>
mov    %esi,(%rsp,%rcx,4)
mov    %edx,-0x4(%rsp,%rdi,4)
jmp    1278 <main+0x118>
test   $0x1,%r13b
je     1930 <main+0x7d0>
mov    %rbx,%rdi
mov    %r14d,%esi
call   1080 <hasSameNum@plt>
cmp    $0x1,%eax
je     1930 <main+0x7d0>
mov    0x68(%rsp),%rdx
mov    (%rsp,%rdx,4),%eax
mov    0x60(%rsp),%rsi
mov    (%rsp,%rsi,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
mov    %eax,(%rsp,%rsi,4)
nopl   0x0(%rax)
lea    0x6dd(%rip),%rdi
mov    0x80(%rsp),%r15
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
test   %r14d,%r14d
lea    0x6c6(%rip),%r12
je     11a0 <main+0x40>
mov    %r14d,%ebx
xor    %ebp,%ebp
xchg   %ax,%ax
mov    (%rsp,%rbp,4),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1960 <main+0x800>
jmp    11a0 <main+0x40>
mov    0x265e(%rip),%rax
mov    (%rax),%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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