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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main(void) {
  int num, count, i, j, inst, card[202], shuffle[202];
  scanf("%d%d", &num, &count);
  for (i = 1; i <= 2 * num; i++)
    card[i] = i;
  for (i = 0; i < count; i++) {
    scanf("%d", &inst);
    if (inst == 0) {
      for (j = 1; j <= 2 * num; j++)
        shuffle[j] = card[j];
      for (j = 1; j <= num; j++) {
        card[2 * j - 1] = shuffle[j];
        card[2 * j] = shuffle[j + num];
      }
    } else {
      for (j = 1; j <= inst; j++)
        shuffle[j] = card[j];
      for (j = 1; j <= 2 * num - inst; j++)
        card[j] = card[j + inst];
      for (j = 2 * num - inst + 1; j <= 2 * num; j++)
        card[j] = shuffle[j - 2 * num + inst];
    }
  }
  for (i = 1; i <= 2 * num; i++)
    printf("%d\n", card[i]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x670,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     117c <main+0x5c>
mov    -0x10(%rbp),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x340(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    114f <main+0x2f>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    132a <main+0x20a>
lea    0xe6c(%rip),%rdi
lea    -0x18(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
cmpl   $0x0,-0x18(%rbp)
jne    1248 <main+0x128>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     11e7 <main+0xc7>
movslq -0x14(%rbp),%rax
mov    -0x340(%rbp,%rax,4),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x670(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b2 <main+0x92>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1243 <main+0x123>
movslq -0x14(%rbp),%rax
mov    -0x670(%rbp,%rax,4),%ecx
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x340(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    -0x8(%rbp),%eax
cltq
mov    -0x670(%rbp,%rax,4),%ecx
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %ecx,-0x340(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ee <main+0xce>
jmp    1317 <main+0x1f7>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     127f <main+0x15f>
movslq -0x14(%rbp),%rax
mov    -0x340(%rbp,%rax,4),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x670(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    124f <main+0x12f>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jg     12c2 <main+0x1a2>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
mov    -0x340(%rbp,%rax,4),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x340(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1286 <main+0x166>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
sub    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     1312 <main+0x1f2>
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x18(%rbp),%eax
cltq
mov    -0x670(%rbp,%rax,4),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x340(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12d1 <main+0x1b1>
jmp    1317 <main+0x1f7>
jmp    131c <main+0x1fc>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1183 <main+0x63>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     1367 <main+0x247>
movslq -0x10(%rbp),%rax
mov    -0x340(%rbp,%rax,4),%esi
lea    0xcb1(%rip),%rdi
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1331 <main+0x211>
xor    %eax,%eax
add    $0x670,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x668,%rsp
lea    0xf48(%rip),%rdi
lea    0x4(%rsp),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x4(%rsp),%r15d
test   %r15d,%r15d
jle    12fd <main+0x1cd>
lea    (%r15,%r15,1),%eax
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovge %eax,%ecx
mov    $0x1,%eax
cmp    $0x8,%ecx
jb     12e7 <main+0x1b7>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    11b2 <main+0x82>
movdqa 0xe55(%rip),%xmm0
xor    %esi,%esi
jmp    128c <main+0x15c>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdi
movdqa 0xe35(%rip),%xmm0
xor    %esi,%esi
movdqa 0xe3a(%rip),%xmm8
movdqa 0xe41(%rip),%xmm9
movdqa 0xe48(%rip),%xmm10
movdqa 0xe50(%rip),%xmm4
movdqa 0xe58(%rip),%xmm5
movdqa 0xe60(%rip),%xmm6
movdqa 0xe68(%rip),%xmm7
movdqa 0xe70(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x14(%rsp,%rsi,4)
movdqu %xmm2,0x24(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x34(%rsp,%rsi,4)
movdqu %xmm3,0x44(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x54(%rsp,%rsi,4)
movdqu %xmm3,0x64(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x74(%rsp,%rsi,4)
movdqu %xmm3,0x84(%rsp,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1210 <main+0xe0>
test   %rdx,%rdx
je     12de <main+0x1ae>
movdqa 0xd77(%rip),%xmm1
movdqa 0xd7f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdi
movdqu %xmm0,0x10(%rsp,%rdi,1)
movdqu %xmm3,0x20(%rsp,%rdi,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rdx
jne    12b0 <main+0x180>
cmp    %rax,%rcx
je     12fd <main+0x1cd>
or     $0x1,%rax
add    $0x1,%rcx
nopl   0x0(%rax,%rax,1)
mov    %eax,0x10(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    12f0 <main+0x1c0>
cmpl   $0x0,0x8(%rsp)
jle    1772 <main+0x642>
lea    0x14(%rsp),%r13
lea    0xd7e(%rip),%rbp
xor    %r12d,%r12d
jmp    132f <main+0x1ff>
nopl   0x0(%rax)
add    $0x1,%r12d
cmp    0x8(%rsp),%r12d
jge    1772 <main+0x642>
mov    %rbp,%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%r14d
test   %r14,%r14
je     1670 <main+0x540>
test   %r14d,%r14d
jle    1369 <main+0x239>
lea    0x0(,%r14,4),%rdx
lea    0x344(%rsp),%rdi
mov    %r13,%rsi
call   1040 <memcpy@plt>
mov    0x4(%rsp),%r15d
lea    (%r15,%r15,1),%r9d
mov    %r9d,%ecx
sub    %r14d,%ecx
test   %ecx,%ecx
jle    14f8 <main+0x3c8>
movslq %r14d,%r8
mov    %r9d,%edx
or     $0x1,%edx
sub    %r14d,%edx
lea    -0x1(%rdx),%r10
mov    $0x1,%esi
cmp    $0x8,%r10
jb     1480 <main+0x350>
lea    (%r8,%rdx,1),%rax
lea    (%rsp,%rax,4),%rax
add    $0x10,%rax
cmp    %rax,%r13
jae    13cc <main+0x29c>
lea    (%rsp,%rdx,4),%rax
add    $0x10,%rax
lea    0x0(,%r8,4),%rdi
add    %r13,%rdi
cmp    %rax,%rdi
jb     1480 <main+0x350>
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     1750 <main+0x620>
mov    %r11,%rdi
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rdi
lea    0x30(,%r8,4),%rbx
add    %r13,%rbx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x30(%rbx,%rax,4),%xmm0
movups -0x20(%rbx,%rax,4),%xmm1
movups %xmm0,0x14(%rsp,%rax,4)
movups %xmm1,0x24(%rsp,%rax,4)
movdqu -0x10(%rbx,%rax,4),%xmm0
movdqu (%rbx,%rax,4),%xmm1
movdqu %xmm0,0x34(%rsp,%rax,4)
movdqu %xmm1,0x44(%rsp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1410 <main+0x2e0>
test   $0x1,%r11b
je     146b <main+0x33b>
or     $0x1,%rax
lea    (%rax,%r8,1),%rdi
movdqu 0x10(%rsp,%rdi,4),%xmm0
movdqu 0x20(%rsp,%rdi,4),%xmm1
movdqu %xmm0,0x10(%rsp,%rax,4)
movdqu %xmm1,0x20(%rsp,%rax,4)
cmp    %rsi,%r10
je     14f8 <main+0x3c8>
or     $0x1,%rsi
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
sub    %esi,%edi
mov    %rsi,%rax
not    %rax
add    %rdx,%rax
and    $0x3,%rdi
je     14b1 <main+0x381>
lea    (%rsp,%r8,4),%rbx
add    $0x10,%rbx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,4),%ebp
mov    %ebp,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    14a0 <main+0x370>
cmp    $0x3,%rax
lea    0xbd6(%rip),%rbp
jb     14f8 <main+0x3c8>
lea    0x8(,%r8,4),%rax
add    %r13,%rax
nopl   0x0(%rax)
mov    -0xc(%rax,%rsi,4),%edi
mov    %edi,0x10(%rsp,%rsi,4)
mov    -0x8(%rax,%rsi,4),%edi
mov    %edi,0x14(%rsp,%rsi,4)
mov    -0x4(%rax,%rsi,4),%edi
mov    %edi,0x18(%rsp,%rsi,4)
mov    (%rax,%rsi,4),%edi
mov    %edi,0x1c(%rsp,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    14d0 <main+0x3a0>
test   %r14d,%r14d
jle    1320 <main+0x1f0>
movslq %ecx,%rdx
movslq %r9d,%rcx
lea    0x1(%rdx),%rax
cmp    %rcx,%rax
mov    %rcx,%rsi
cmovg  %rax,%rsi
sub    %rdx,%rsi
cmp    $0x8,%rsi
jb     1630 <main+0x500>
cmp    %rcx,%rax
cmovle %rcx,%rax
mov    %rdx,%rdi
not    %rdi
add    %rax,%rdi
cmp    $0x7ffffffe,%edi
ja     1630 <main+0x500>
shr    $0x20,%rdi
jne    1630 <main+0x500>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1761 <main+0x631>
mov    %r10,%rax
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rax
lea    0x30(,%rdx,4),%rdi
add    %r13,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rbx),%ebp
movslq %ebp,%rbp
movups 0x340(%rsp,%rbp,4),%xmm0
movups 0x350(%rsp,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdi,%rbx,4)
movups %xmm1,-0x20(%rdi,%rbx,4)
lea    0x9(%rbx),%ebp
movslq %ebp,%rbp
movdqu 0x340(%rsp,%rbp,4),%xmm0
movdqu 0x350(%rsp,%rbp,4),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbx,4)
movdqu %xmm1,(%rdi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1590 <main+0x460>
test   $0x1,%r10b
je     1617 <main+0x4e7>
mov    %r14d,%eax
sub    %r9d,%eax
lea    (%rbx,%rdx,1),%rdi
add    $0x1,%rdi
add    %rdx,%rbx
add    %eax,%edi
movslq %edi,%rax
movdqu 0x340(%rsp,%rax,4),%xmm0
movdqu 0x350(%rsp,%rax,4),%xmm1
movdqu %xmm0,0x14(%rsp,%rbx,4)
movdqu %xmm1,0x24(%rsp,%rbx,4)
cmp    %r8,%rsi
lea    0xa71(%rip),%rbp
je     1320 <main+0x1f0>
add    %r8,%rdx
nopw   0x0(%rax,%rax,1)
sub    %r9d,%r14d
add    $0x1,%r14d
nopw   0x0(%rax,%rax,1)
lea    (%r14,%rdx,1),%eax
cltq
mov    0x340(%rsp,%rax,4),%eax
mov    %eax,0x14(%rsp,%rdx,4)
lea    0x1(%rdx),%rax
mov    %rax,%rdx
cmp    %rcx,%rax
jl     1640 <main+0x510>
jmp    1320 <main+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x4(%rsp),%r15d
test   %r15d,%r15d
jle    1320 <main+0x1f0>
lea    (%r15,%r15,1),%edx
cmp    $0x2,%edx
mov    $0x1,%eax
cmovl  %eax,%edx
shl    $0x2,%rdx
lea    0x344(%rsp),%rdi
mov    %r13,%rsi
call   1040 <memcpy@plt>
mov    $0x1,%eax
cmp    $0x4,%r15
jb     1713 <main+0x5e3>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
lea    0x1(%rcx),%rax
lea    0x344(%rsp),%rdx
lea    (%rdx,%r15,4),%rdx
add    $0x8,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movq   0x344(%rsp,%rsi,4),%xmm0
movq   0x34c(%rsp,%rsi,4),%xmm1
movq   -0x8(%rdx,%rsi,4),%xmm2
punpckldq %xmm2,%xmm0
movq   (%rdx,%rsi,4),%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,0x14(%rsp,%rsi,8)
movdqu %xmm1,0x24(%rsp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    16d0 <main+0x5a0>
cmp    %rcx,%r15
je     1320 <main+0x1f0>
lea    (%rsp,%r15,4),%rcx
add    $0x340,%rcx
lea    0x1(%r15),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x340(%rsp,%rax,4),%esi
mov    %esi,0xc(%rsp,%rax,8)
mov    (%rcx,%rax,4),%esi
mov    %esi,0x10(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1730 <main+0x600>
jmp    1320 <main+0x1f0>
xor    %eax,%eax
test   $0x1,%r11b
jne    144b <main+0x31b>
jmp    146b <main+0x33b>
xor    %ebx,%ebx
test   $0x1,%r10b
jne    15e3 <main+0x4b3>
jmp    1617 <main+0x4e7>
test   %r15d,%r15d
jle    179d <main+0x66d>
xor    %ebp,%ebp
lea    0x915(%rip),%rbx
mov    0x14(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
movslq 0x4(%rsp),%rax
add    %rax,%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1780 <main+0x650>
xor    %eax,%eax
add    $0x668,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"%d%d\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [4 x i8] c"%d\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 [202 x i32]
%8 = alloca [202 x i32]
store i32 0, i32* %1
%9 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %2, i32* %3)
store i32 1, i32* %4
br label %10
10: ; preds = %20, %0
%11 = load i32, i32* %4
%12 = load i32, i32* %2
%13 = mul nsw i32 2, %12
%14 = icmp sle i32 %11, %13
br i1 %14, label %15, label %23
15: ; preds = %10
%16 = load i32, i32* %4
%17 = load i32, i32* %4
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %18
store i32 %16, i32* %19
br label %20
20: ; preds = %15
%21 = load i32, i32* %4
%22 = add nsw i32 %21, 1
store i32 %22, i32* %4
br label %10
23: ; preds = %10
store i32 0, i32* %4
br label %24
24: ; preds = %144, %23
%25 = load i32, i32* %4
%26 = load i32, i32* %3
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %147
28: ; preds = %24
%29 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %6)
%30 = load i32, i32* %6
%31 = icmp eq i32 %30, 0
br i1 %31, label %32, label %78
32: ; preds = %28
store i32 1, i32* %5
br label %33
33: ; preds = %46, %32
%34 = load i32, i32* %5
%35 = load i32, i32* %2
%36 = mul nsw i32 2, %35
%37 = icmp sle i32 %34, %36
br i1 %37, label %38, label %49
38: ; preds = %33
%39 = load i32, i32* %5
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %40
%42 = load i32, i32* %41
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [202 x i32], [202 x i32]* %8, i64 0, i64 %44
store i32 %42, i32* %45
br label %46
46: ; preds = %38
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
br label %33
49: ; preds = %33
store i32 1, i32* %5
br label %50
50: ; preds = %74, %49
%51 = load i32, i32* %5
%52 = load i32, i32* %2
%53 = icmp sle i32 %51, %52
br i1 %53, label %54, label %77
54: ; preds = %50
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [202 x i32], [202 x i32]* %8, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = load i32, i32* %5
%60 = mul nsw i32 2, %59
%61 = sub nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %62
store i32 %58, i32* %63
%64 = load i32, i32* %5
%65 = load i32, i32* %2
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [202 x i32], [202 x i32]* %8, i64 0, i64 %67
%69 = load i32, i32* %68
%70 = load i32, i32* %5
%71 = mul nsw i32 2, %70
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %72
store i32 %69, i32* %73
br label %74
74: ; preds = %54
%75 = load i32, i32* %5
%76 = add nsw i32 %75, 1
store i32 %76, i32* %5
br label %50
77: ; preds = %50
br label %143
78: ; preds = %28
store i32 1, i32* %5
br label %79
79: ; preds = %91, %78
%80 = load i32, i32* %5
%81 = load i32, i32* %6
%82 = icmp sle i32 %80, %81
br i1 %82, label %83, label %94
83: ; preds = %79
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = load i32, i32* %5
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [202 x i32], [202 x i32]* %8, i64 0, i64 %89
store i32 %87, i32* %90
br label %91
91: ; preds = %83
%92 = load i32, i32* %5
%93 = add nsw i32 %92, 1
store i32 %93, i32* %5
br label %79
94: ; preds = %79
store i32 1, i32* %5
br label %95
95: ; preds = %112, %94
%96 = load i32, i32* %5
%97 = load i32, i32* %2
%98 = mul nsw i32 2, %97
%99 = load i32, i32* %6
%100 = sub nsw i32 %98, %99
%101 = icmp sle i32 %96, %100
br i1 %101, label %102, label %115
102: ; preds = %95
%103 = load i32, i32* %5
%104 = load i32, i32* %6
%105 = add nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %110
store i32 %108, i32* %111
br label %112
112: ; preds = %102
%113 = load i32, i32* %5
%114 = add nsw i32 %113, 1
store i32 %114, i32* %5
br label %95
115: ; preds = %95
%116 = load i32, i32* %2
%117 = mul nsw i32 2, %116
%118 = load i32, i32* %6
%119 = sub nsw i32 %117, %118
%120 = add nsw i32 %119, 1
store i32 %120, i32* %5
br label %121
121: ; preds = %139, %115
%122 = load i32, i32* %5
%123 = load i32, i32* %2
%124 = mul nsw i32 2, %123
%125 = icmp sle i32 %122, %124
br i1 %125, label %126, label %142
126: ; preds = %121
%127 = load i32, i32* %5
%128 = load i32, i32* %2
%129 = mul nsw i32 2, %128
%130 = sub nsw i32 %127, %129
%131 = load i32, i32* %6
%132 = add nsw i32 %130, %131
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [202 x i32], [202 x i32]* %8, i64 0, i64 %133
%135 = load i32, i32* %134
%136 = load i32, i32* %5
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %137
store i32 %135, i32* %138
br label %139
139: ; preds = %126
%140 = load i32, i32* %5
%141 = add nsw i32 %140, 1
store i32 %141, i32* %5
br label %121
142: ; preds = %121
br label %143
143: ; preds = %142, %77
br label %144
144: ; preds = %143
%145 = load i32, i32* %4
%146 = add nsw i32 %145, 1
store i32 %146, i32* %4
br label %24
147: ; preds = %24
store i32 1, i32* %4
br label %148
148: ; preds = %159, %147
%149 = load i32, i32* %4
%150 = load i32, i32* %2
%151 = mul nsw i32 2, %150
%152 = icmp sle i32 %149, %151
br i1 %152, label %153, label %162
153: ; preds = %148
%154 = load i32, i32* %4
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [202 x i32], [202 x i32]* %7, i64 0, i64 %155
%157 = load i32, i32* %156
%158 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %157)
br label %159
159: ; preds = %153
%160 = load i32, i32* %4
%161 = add nsw i32 %160, 1
store i32 %161, i32* %4
br label %148
162: ; preds = %148
ret i32 0
}

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