#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*/ getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main(void) {
  int numero;
  int id;
  int criba[200000][2];
  int i, j;
  printf("Este programa calcula la Criba de Eratostenes hasta un numero \n");
  printf("dado por el usuario. \n");
  printf("Introduce un numero natural mayor de 2: ");
  scanf("%d", &numero);
  for (i = 0; i < numero - 1; i++) {
    criba[i][0] = i + 2;
    criba[i][1] = 0;
  }
  criba[0][1] = 2;
  for (i = 2; i < numero - 1; i = i + 2)
    criba[i][1] = 1;
  for (i = 1; i < numero - 1; i++) {
    if (criba[i][1] == 0) {
      criba[i][1] = 2;
      for (j = (2 * criba[i - 1][0]); j < numero - 1; j = j + criba[i][0]) {
        criba[j][1] = 1;
      }
    }
  }
  printf("Criba de Eratostenes del 2 al %d: \n", numero);
  for (i = 0; i < numero - 1; i++) {
    if (criba[i][1] == 2)
      printf("%03d ", criba[i][0]);
  }
  getchar();
  getchar();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x186a20,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xee9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xef2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf0d(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
movl   $0x0,-0x186a14(%rbp)
mov    -0x186a14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11d7 <main+0xa7>
mov    -0x186a14(%rbp),%ecx
add    $0x2,%ecx
movslq -0x186a14(%rbp),%rax
mov    %ecx,-0x186a10(%rbp,%rax,8)
movslq -0x186a14(%rbp),%rax
movl   $0x0,-0x186a0c(%rbp,%rax,8)
mov    -0x186a14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186a14(%rbp)
jmp    1186 <main+0x56>
movl   $0x2,-0x186a0c(%rbp)
movl   $0x2,-0x186a14(%rbp)
mov    -0x186a14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1225 <main+0xf5>
movslq -0x186a14(%rbp),%rax
movl   $0x1,-0x186a0c(%rbp,%rax,8)
mov    -0x186a14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x186a14(%rbp)
jmp    11eb <main+0xbb>
movl   $0x1,-0x186a14(%rbp)
mov    -0x186a14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12e8 <main+0x1b8>
movslq -0x186a14(%rbp),%rax
cmpl   $0x0,-0x186a0c(%rbp,%rax,8)
jne    12cf <main+0x19f>
movslq -0x186a14(%rbp),%rax
movl   $0x2,-0x186a0c(%rbp,%rax,8)
mov    -0x186a14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x186a10(%rbp,%rax,8),%eax
shl    $0x1,%eax
mov    %eax,-0x186a18(%rbp)
mov    -0x186a18(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12ca <main+0x19a>
movslq -0x186a18(%rbp),%rax
movl   $0x1,-0x186a0c(%rbp,%rax,8)
mov    -0x186a18(%rbp),%eax
movslq -0x186a14(%rbp),%rcx
add    -0x186a10(%rbp,%rcx,8),%eax
mov    %eax,-0x186a18(%rbp)
jmp    1285 <main+0x155>
jmp    12cf <main+0x19f>
jmp    12d4 <main+0x1a4>
mov    -0x186a14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186a14(%rbp)
jmp    122f <main+0xff>
mov    -0x8(%rbp),%esi
lea    0xd91(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x186a14(%rbp)
mov    -0x186a14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1361 <main+0x231>
movslq -0x186a14(%rbp),%rax
cmpl   $0x2,-0x186a0c(%rbp,%rax,8)
02
jne    1348 <main+0x218>
movslq -0x186a14(%rbp),%rax
mov    -0x186a10(%rbp,%rax,8),%esi
lea    0xd66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    134d <main+0x21d>
mov    -0x186a14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186a14(%rbp)
jmp    1303 <main+0x1d3>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    -0x4(%rbp),%eax
add    $0x186a20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x186a18,%rsp
lea    0xf55(%rip),%rdi
call   1030 <puts@plt>
lea    0xf88(%rip),%rdi
call   1030 <puts@plt>
lea    0xee7(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf02(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1060 <scanf@plt>
mov    0xc(%rsp),%esi
cmp    $0x1,%esi
jle    119b <main+0x5b>
lea    -0x1(%rsi),%eax
mov    %eax,%ecx
cmp    $0x4,%eax
jae    11a8 <main+0x68>
xor    %edx,%edx
jmp    12a0 <main+0x160>
movl   $0x2,0x14(%rsp)
jmp    1331 <main+0x1f1>
mov    %ecx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rdi
mov    %rdi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     13a5 <main+0x265>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
movdqa 0xe2c(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe32(%rip),%xmm1
movdqa 0xe3a(%rip),%xmm2
pxor   %xmm3,%xmm3
movdqa 0xe3e(%rip),%xmm4
movdqa 0xe46(%rip),%xmm5
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm2,%xmm7
punpckldq %xmm3,%xmm6
movdqa %xmm6,0x10(%rsp,%rdi,8)
punpckldq %xmm3,%xmm7
movdqa %xmm7,0x20(%rsp,%rdi,8)
movdqa %xmm0,%xmm6
paddd  %xmm4,%xmm6
paddd  %xmm5,%xmm0
punpckldq %xmm3,%xmm6
movdqa %xmm6,0x30(%rsp,%rdi,8)
movdqa %xmm0,%xmm6
punpckldq %xmm3,%xmm6
movdqa %xmm6,0x40(%rsp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1200 <main+0xc0>
test   $0x1,%r8b
je     1290 <main+0x150>
movdqa 0xdb0(%rip),%xmm1
paddd  %xmm0,%xmm1
paddd  0xdb4(%rip),%xmm0
lea    0x0(,%rdi,8),%rbx
or     $0x10,%rbx
pxor   %xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqa %xmm1,0x10(%rsp,%rdi,8)
punpckldq %xmm2,%xmm0
movdqa %xmm0,0x10(%rsp,%rbx,1)
cmp    %rcx,%rdx
je     12b8 <main+0x178>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x2(%rdx),%edi
mov    %edi,0x10(%rsp,%rdx,8)
movl   $0x0,0x14(%rsp,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    12a0 <main+0x160>
movl   $0x2,0x14(%rsp)
cmp    $0x4,%esi
jl     12e1 <main+0x1a1>
mov    $0x2,%edx
nopw   0x0(%rax,%rax,1)
movl   $0x1,0x14(%rsp,%rdx,8)
add    $0x2,%rdx
cmp    %rcx,%rdx
jb     12d0 <main+0x190>
cmp    $0x3,%esi
jl     1331 <main+0x1f1>
mov    $0x1,%edx
jmp    12f9 <main+0x1b9>
nopl   (%rax)
add    $0x1,%rdx
cmp    %rcx,%rdx
je     1331 <main+0x1f1>
cmpl   $0x0,0x14(%rsp,%rdx,8)
jne    12f0 <main+0x1b0>
movl   $0x2,0x14(%rsp,%rdx,8)
mov    0x8(%rsp,%rdx,8),%ebx
add    %ebx,%ebx
cmp    %eax,%ebx
jge    12f0 <main+0x1b0>
movslq 0x10(%rsp,%rdx,8),%rdi
movslq %ebx,%rbx
nopw   0x0(%rax,%rax,1)
movl   $0x1,0x14(%rsp,%rbx,8)
add    %rdi,%rbx
cmp    %eax,%ebx
jl     1320 <main+0x1e0>
jmp    12f0 <main+0x1b0>
lea    0xd44(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
cmp    $0x2,%eax
jl     138a <main+0x24a>
lea    0xd51(%rip),%r14
xor    %ebx,%ebx
jmp    136f <main+0x22f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rbx
jge    138a <main+0x24a>
cmpl   $0x2,0x14(%rsp,%rbx,8)
jne    1360 <main+0x220>
mov    0x10(%rsp,%rbx,8),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
jmp    1360 <main+0x220>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
add    $0x186a18,%rsp
pop    %rbx
pop    %r14
ret
movdqa 0xc53(%rip),%xmm0
xor    %edi,%edi
test   $0x1,%r8b
jne    1258 <main+0x118>
jmp    1290 <main+0x150>

LLVM IR (-O0):
@.str = [64 x i8] c"Este programa calcula la Criba de Eratostenes hasta un numero \0A\00"
@.str.1 = [23 x i8] c"dado por el usuario. \0A\00"
@.str.2 = [41 x i8] c"Introduce un numero natural mayor de 2: \00"
@.str.3 = [3 x i8] c"%d\00"
@.str.4 = [36 x i8] c"Criba de Eratostenes del 2 al %d: \0A\00"
@.str.5 = [6 x i8] c"%03d \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [200000 x [2 x i32]]
%5 = alloca i32
%6 = alloca i32
store i32 0, i32* %1
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str, i64 0, i64 0))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.2, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %2)
store i32 0, i32* %5
br label %11
11: ; preds = %27, %0
%12 = load i32, i32* %5
%13 = load i32, i32* %2
%14 = sub nsw i32 %13, 1
%15 = icmp slt i32 %12, %14
br i1 %15, label %16, label %30
16: ; preds = %11
%17 = load i32, i32* %5
%18 = add nsw i32 %17, 2
%19 = load i32, i32* %5
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %20
%22 = getelementptr inbounds [2 x i32], [2 x i32]* %21, i64 0, i64 0
store i32 %18, i32* %22
%23 = load i32, i32* %5
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %24
%26 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 1
store i32 0, i32* %26
br label %27
27: ; preds = %16
%28 = load i32, i32* %5
%29 = add nsw i32 %28, 1
store i32 %29, i32* %5
br label %11
30: ; preds = %11
%31 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 0
%32 = getelementptr inbounds [2 x i32], [2 x i32]* %31, i64 0, i64 1
store i32 2, i32* %32
store i32 2, i32* %5
br label %33
33: ; preds = %43, %30
%34 = load i32, i32* %5
%35 = load i32, i32* %2
%36 = sub nsw i32 %35, 1
%37 = icmp slt i32 %34, %36
br i1 %37, label %38, label %46
38: ; preds = %33
%39 = load i32, i32* %5
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %40
%42 = getelementptr inbounds [2 x i32], [2 x i32]* %41, i64 0, i64 1
store i32 1, i32* %42
br label %43
43: ; preds = %38
%44 = load i32, i32* %5
%45 = add nsw i32 %44, 2
store i32 %45, i32* %5
br label %33
46: ; preds = %33
store i32 1, i32* %5
br label %47
47: ; preds = %91, %46
%48 = load i32, i32* %5
%49 = load i32, i32* %2
%50 = sub nsw i32 %49, 1
%51 = icmp slt i32 %48, %50
br i1 %51, label %52, label %94
52: ; preds = %47
%53 = load i32, i32* %5
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %54
%56 = getelementptr inbounds [2 x i32], [2 x i32]* %55, i64 0, i64 1
%57 = load i32, i32* %56
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %90
59: ; preds = %52
%60 = load i32, i32* %5
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %61
%63 = getelementptr inbounds [2 x i32], [2 x i32]* %62, i64 0, i64 1
store i32 2, i32* %63
%64 = load i32, i32* %5
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %66
%68 = getelementptr inbounds [2 x i32], [2 x i32]* %67, i64 0, i64 0
%69 = load i32, i32* %68
%70 = mul nsw i32 2, %69
store i32 %70, i32* %6
br label %71
71: ; preds = %81, %59
%72 = load i32, i32* %6
%73 = load i32, i32* %2
%74 = sub nsw i32 %73, 1
%75 = icmp slt i32 %72, %74
br i1 %75, label %76, label %89
76: ; preds = %71
%77 = load i32, i32* %6
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %78
%80 = getelementptr inbounds [2 x i32], [2 x i32]* %79, i64 0, i64 1
store i32 1, i32* %80
br label %81
81: ; preds = %76
%82 = load i32, i32* %6
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %84
%86 = getelementptr inbounds [2 x i32], [2 x i32]* %85, i64 0, i64 0
%87 = load i32, i32* %86
%88 = add nsw i32 %82, %87
store i32 %88, i32* %6
br label %71
89: ; preds = %71
br label %90
90: ; preds = %89, %52
br label %91
91: ; preds = %90
%92 = load i32, i32* %5
%93 = add nsw i32 %92, 1
store i32 %93, i32* %5
br label %47
94: ; preds = %47
%95 = load i32, i32* %2
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0), i32 %95)
store i32 0, i32* %5
br label %97
97: ; preds = %117, %94
%98 = load i32, i32* %5
%99 = load i32, i32* %2
%100 = sub nsw i32 %99, 1
%101 = icmp slt i32 %98, %100
br i1 %101, label %102, label %120
102: ; preds = %97
%103 = load i32, i32* %5
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %104
%106 = getelementptr inbounds [2 x i32], [2 x i32]* %105, i64 0, i64 1
%107 = load i32, i32* %106
%108 = icmp eq i32 %107, 2
br i1 %108, label %109, label %116
109: ; preds = %102
%110 = load i32, i32* %5
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %4, i64 0, i64 %111
%113 = getelementptr inbounds [2 x i32], [2 x i32]* %112, i64 0, i64 0
%114 = load i32, i32* %113
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), i32 %114)
br label %116
116: ; preds = %109, %102
br label %117
117: ; preds = %116
%118 = load i32, i32* %5
%119 = add nsw i32 %118, 1
store i32 %119, i32* %5
br label %97
120: ; preds = %97
%121 = call i32 (...) @getchar()
%122 = call i32 (...) @getchar()
%123 = load i32, i32* %1
ret i32 %123
}

LLVM IR (-O2):
@.str.2 = [41 x i8] c"Introduce un numero natural mayor de 2: \00"
@.str.3 = [3 x i8] c"%d\00"
@.str.4 = [36 x i8] c"Criba de Eratostenes del 2 al %d: \0A\00"
@.str.5 = [6 x i8] c"%03d \00"
@str = [63 x i8] c"Este programa calcula la Criba de Eratostenes hasta un numero \00"
@str.6 = [22 x i8] c"dado por el usuario. \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [200000 x [2 x i32]]
%3 = bitcast i32* %1 to i8*
%4 = bitcast [200000 x [2 x i32]]* %2 to i8*
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.6, i64 0, i64 0))
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %1)
%9 = load i32, i32* %1
%10 = add i32 %9, -1
%11 = icmp sgt i32 %9, 1
br i1 %11, label %14, label %12
12: ; preds = %0
%13 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 0, i64 1
store i32 2, i32* %13
br label %116
14: ; preds = %0
%15 = zext i32 %10 to i64
%16 = icmp ult i32 %10, 4
br i1 %16, label %69, label %17
17: ; preds = %14
%18 = and i64 %15, 4294967292
%19 = add nsw i64 %18, -4
%20 = lshr exact i64 %19, 2
%21 = add nuw nsw i64 %20, 1
%22 = and i64 %21, 1
%23 = icmp eq i64 %19, 0
br i1 %23, label %53, label %24
24: ; preds = %17
%25 = and i64 %21, 9223372036854775806
br label %26
26: ; preds = %26, %24
%27 = phi i64 [ 0, %24 ], [ %49, %26 ]
%28 = phi <2 x i32> [ <i32 0, i32 1>, %24 ], [ %50, %26 ]
%29 = phi i64 [ 0, %24 ], [ %51, %26 ]
%30 = or i64 %27, 2
%31 = add <2 x i32> %28, <i32 2, i32 2>
%32 = add <2 x i32> %28, <i32 4, i32 4>
%33 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %27, i64 0
%34 = bitcast i32* %33 to <4 x i32>*
%35 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %30, i64 0
%36 = bitcast i32* %35 to <4 x i32>*
%37 = shufflevector <2 x i32> %31, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %37, <4 x i32>* %34
%38 = shufflevector <2 x i32> %32, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %38, <4 x i32>* %36
%39 = or i64 %27, 4
%40 = or i64 %27, 6
%41 = add <2 x i32> %28, <i32 6, i32 6>
%42 = add <2 x i32> %28, <i32 8, i32 8>
%43 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %39, i64 0
%44 = bitcast i32* %43 to <4 x i32>*
%45 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %40, i64 0
%46 = bitcast i32* %45 to <4 x i32>*
%47 = shufflevector <2 x i32> %41, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %47, <4 x i32>* %44
%48 = shufflevector <2 x i32> %42, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %48, <4 x i32>* %46
%49 = add nuw i64 %27, 8
%50 = add <2 x i32> %28, <i32 8, i32 8>
%51 = add i64 %29, 2
%52 = icmp eq i64 %51, %25
br i1 %52, label %53, label %26
53: ; preds = %26, %17
%54 = phi i64 [ 0, %17 ], [ %49, %26 ]
%55 = phi <2 x i32> [ <i32 0, i32 1>, %17 ], [ %50, %26 ]
%56 = icmp eq i64 %22, 0
br i1 %56, label %67, label %57
57: ; preds = %53
%58 = or i64 %54, 2
%59 = add <2 x i32> %55, <i32 2, i32 2>
%60 = add <2 x i32> %55, <i32 4, i32 4>
%61 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %54, i64 0
%62 = bitcast i32* %61 to <4 x i32>*
%63 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %58, i64 0
%64 = bitcast i32* %63 to <4 x i32>*
%65 = shufflevector <2 x i32> %59, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %65, <4 x i32>* %62
%66 = shufflevector <2 x i32> %60, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %66, <4 x i32>* %64
br label %67
67: ; preds = %53, %57
%68 = icmp eq i64 %18, %15
br i1 %68, label %79, label %69
69: ; preds = %14, %67
%70 = phi i64 [ 0, %14 ], [ %18, %67 ]
br label %71
71: ; preds = %69, %71
%72 = phi i64 [ %77, %71 ], [ %70, %69 ]
%73 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %72, i64 0
%74 = trunc i64 %72 to i32
%75 = add i32 %74, 2
store i32 %75, i32* %73
%76 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %72, i64 1
store i32 0, i32* %76
%77 = add nuw nsw i64 %72, 1
%78 = icmp eq i64 %77, %15
br i1 %78, label %79, label %71
79: ; preds = %71, %67
%80 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 0, i64 1
store i32 2, i32* %80
%81 = icmp sgt i32 %9, 3
br i1 %81, label %82, label %84
82: ; preds = %79
%83 = zext i32 %10 to i64
br label %88
84: ; preds = %88, %79
%85 = icmp sgt i32 %9, 2
br i1 %85, label %86, label %116
86: ; preds = %84
%87 = zext i32 %10 to i64
br label %93
88: ; preds = %82, %88
%89 = phi i64 [ 2, %82 ], [ %91, %88 ]
%90 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %89, i64 1
store i32 1, i32* %90
%91 = add nuw nsw i64 %89, 2
%92 = icmp ult i64 %91, %83
br i1 %92, label %88, label %84
93: ; preds = %86, %113
%94 = phi i64 [ 1, %86 ], [ %114, %113 ]
%95 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %94, i64 1
%96 = load i32, i32* %95
%97 = icmp eq i32 %96, 0
br i1 %97, label %98, label %113
98: ; preds = %93
store i32 2, i32* %95
%99 = add nsw i64 %94, -1
%100 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %99, i64 0
%101 = load i32, i32* %100
%102 = shl nsw i32 %101, 1
%103 = icmp slt i32 %102, %10
br i1 %103, label %104, label %113
104: ; preds = %98
%105 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %94, i64 0
%106 = load i32, i32* %105
br label %107
107: ; preds = %104, %107
%108 = phi i32 [ %102, %104 ], [ %111, %107 ]
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %109, i64 1
store i32 1, i32* %110
%111 = add nsw i32 %106, %108
%112 = icmp slt i32 %111, %10
br i1 %112, label %107, label %113
113: ; preds = %107, %98, %93
%114 = add nuw nsw i64 %94, 1
%115 = icmp eq i64 %114, %87
br i1 %115, label %116, label %93
116: ; preds = %113, %12, %84
%117 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0), i32 %9)
%118 = load i32, i32* %1
%119 = icmp sgt i32 %118, 1
br i1 %119, label %120, label %137
120: ; preds = %116, %131
%121 = phi i32 [ %132, %131 ], [ %118, %116 ]
%122 = phi i64 [ %133, %131 ], [ 0, %116 ]
%123 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %122, i64 1
%124 = load i32, i32* %123
%125 = icmp eq i32 %124, 2
br i1 %125, label %126, label %131
126: ; preds = %120
%127 = getelementptr inbounds [200000 x [2 x i32]], [200000 x [2 x i32]]* %2, i64 0, i64 %122, i64 0
%128 = load i32, i32* %127
%129 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), i32 %128)
%130 = load i32, i32* %1
br label %131
131: ; preds = %120, %126
%132 = phi i32 [ %121, %120 ], [ %130, %126 ]
%133 = add nuw nsw i64 %122, 1
%134 = add nsw i32 %132, -1
%135 = sext i32 %134 to i64
%136 = icmp slt i64 %133, %135
br i1 %136, label %120, label %137
137: ; preds = %131, %116
%138 = call i32 (...) @getchar()
%139 = call i32 (...) @getchar()
ret i32 0
}