#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*/ pause();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ system(char *);
void prob6(void) {
  system("clear");
  int userin1;
  int loop1;
  int loop2;
  int loop3;
  int total = 0;
  printf("Enter the value you want primes calculated to: ");
  scanf("%d", &userin1);
  system("clear");
  int sieve[(userin1 - 1)];
  for (loop1 = 2; loop1 <= userin1; loop1++) {
    sieve[(loop1 - 2)] = loop1;
  }
  for (loop1 = 0; loop1 < userin1; loop1++) {
    for (loop2 = 2; loop2 < userin1; loop2++) {
      for (loop3 = loop2; loop3 < userin1; loop3++) {
        if ((loop2 * loop3) == sieve[loop1]) {
          sieve[loop1] = 0;
        }
      }
    }
  }
  printf("Here are the prime numbers from 0 to the number you entered: \n\n");
  for (loop1 = 0; loop1 < (userin1 - 1); loop1++) {
    if (sieve[loop1] != 0) {
      printf("%d\n", sieve[loop1]);
      total++;
    }
  }
  printf("\nThere were %d primes in this list. ", total);
  pause();
}


x86 assembly (clang, -O0):
<prob6>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
lea    0xeb1(%rip),%rdi
mov    %rdi,-0x38(%rbp)
call   1030 <system@plt>
movl   $0x0,-0x14(%rbp)
lea    0xea0(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xec2(%rip),%rdi
lea    -0x4(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <system@plt>
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x2,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     11e4 <prob6+0xa4>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11b7 <prob6+0x77>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    127c <prob6+0x13c>
movl   $0x2,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1269 <prob6+0x129>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1256 <prob6+0x116>
mov    -0x30(%rbp),%rcx
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
movslq -0x8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1243 <prob6+0x103>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1248 <prob6+0x108>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1210 <prob6+0xd0>
jmp    125b <prob6+0x11b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11fe <prob6+0xbe>
jmp    126e <prob6+0x12e>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11eb <prob6+0xab>
lea    0xdb6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12e9 <prob6+0x1a9>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12d6 <prob6+0x196>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xdb3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12db <prob6+0x19b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1291 <prob6+0x151>
mov    -0x14(%rbp),%esi
lea    0xd8a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x0,%al
call   1050 <pause@plt>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prob6>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
lea    0xf28(%rip),%rbx
mov    %rbx,%rdi
call   1040 <system@plt>
lea    0xf1f(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf41(%rip),%rdi
lea    -0x30(%rbp),%rsi
call   1070 <scanf@plt>
mov    %rbx,%rdi
call   1040 <system@plt>
mov    %rsp,-0x60(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %rsp,%rbx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
mov    -0x30(%rbp),%r8d
cmp    $0x2,%r8d
mov    %r8,-0x40(%rbp)
jl     134d <prob6+0x1fd>
lea    -0x1(%r8),%rcx
mov    $0x2,%eax
cmp    $0x8,%rcx
jb     132d <prob6+0x1dd>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    120a <prob6+0xba>
movdqa 0xdfd(%rip),%xmm0
xor    %edi,%edi
jmp    12d8 <prob6+0x188>
and    $0xfffffffffffffffc,%rsi
movdqa 0xdea(%rip),%xmm0
xor    %edi,%edi
movdqa 0xdef(%rip),%xmm8
movdqa 0xdf6(%rip),%xmm9
movdqa 0xdfd(%rip),%xmm10
movdqa 0xe05(%rip),%xmm4
movdqa 0xe0d(%rip),%xmm5
movdqa 0xe15(%rip),%xmm6
movdqa 0xe1d(%rip),%xmm7
movdqa 0xe25(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqa %xmm0,(%rbx,%rdi,4)
movdqa %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqa %xmm2,0x20(%rbx,%rdi,4)
movdqa %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqa %xmm2,0x40(%rbx,%rdi,4)
movdqa %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqa %xmm2,0x60(%rbx,%rdi,4)
movdqa %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1260 <prob6+0x110>
test   %rdx,%rdx
je     1320 <prob6+0x1d0>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd1d(%rip),%xmm1
movdqa 0xd25(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqa %xmm0,-0x10(%rsi,%rdi,1)
movdqa %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1300 <prob6+0x1b0>
cmp    %rax,%rcx
mov    -0x40(%rbp),%r8
je     134d <prob6+0x1fd>
or     $0x2,%rax
lea    0x1(%r8),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,-0x8(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1340 <prob6+0x1f0>
mov    %rbx,-0x38(%rbp)
test   %r8d,%r8d
jle    14d6 <prob6+0x386>
lea    0x2(%r8),%eax
mov    %eax,-0x4c(%rbp)
lea    -0x3(%r8),%eax
mov    %eax,-0x48(%rbp)
lea    0x2(%r8),%eax
mov    %eax,-0x44(%rbp)
xor    %ecx,%ecx
jmp    1399 <prob6+0x249>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %r14d,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %r8,%rcx
je     14d6 <prob6+0x386>
cmp    $0x3,%r8d
jb     138c <prob6+0x23c>
mov    -0x38(%rbp),%rax
mov    %rcx,-0x68(%rbp)
mov    (%rax,%rcx,4),%r14d
mov    $0x2,%esi
xor    %r13d,%r13d
mov    $0x5,%edi
mov    $0x4,%ecx
mov    $0x8,%edx
mov    -0x44(%rbp),%eax
mov    %eax,%ebx
jmp    13f4 <prob6+0x2a4>
nopl   0x0(%rax)
add    $0x1,%esi
add    $0x1,%r13d
mov    -0x54(%rbp),%edi
mov    -0x50(%rbp),%ecx
add    %edi,%ecx
add    $0x2,%edi
mov    -0x29(%rbp),%bl
add    $0x3,%bl
add    $0x4,%edx
mov    -0x40(%rbp),%r8
cmp    %r8d,%esi
je     1380 <prob6+0x230>
mov    -0x4c(%rbp),%eax
sub    %r13d,%eax
mov    -0x48(%rbp),%r10d
sub    %r13d,%r10d
test   $0x3,%al
mov    %edi,-0x54(%rbp)
mov    %ecx,-0x50(%rbp)
mov    %bl,-0x29(%rbp)
je     1450 <prob6+0x300>
movzbl %bl,%eax
and    $0x3,%eax
neg    %eax
xor    %ebx,%ebx
mov    %ecx,%edi
xor    %ecx,%ecx
nopl   0x0(%rax)
cmp    %r14d,%edi
cmove  %ecx,%r14d
add    $0xffffffff,%ebx
add    %esi,%edi
cmp    %ebx,%eax
jne    1420 <prob6+0x2d0>
mov    %esi,%r8d
sub    %ebx,%r8d
mov    %r14d,%r15d
cmp    $0x3,%r10d
jb     13d0 <prob6+0x280>
jmp    1460 <prob6+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%r15d
mov    %esi,%r8d
cmp    $0x3,%r10d
jb     13d0 <prob6+0x280>
mov    -0x40(%rbp),%rax
mov    %eax,%r12d
sub    %r8d,%r12d
lea    0x3(%r8),%r9d
imul   %esi,%r9d
lea    0x2(%r8),%r10d
imul   %esi,%r10d
lea    0x1(%r8),%r11d
imul   %esi,%r11d
imul   %esi,%r8d
jmp    14a9 <prob6+0x359>
nopl   0x0(%rax,%rax,1)
add    %edx,%r9d
add    %edx,%r10d
add    %edx,%r11d
add    %edx,%r8d
mov    %r14d,%r15d
add    $0xfffffffc,%r12d
je     13d0 <prob6+0x280>
xor    %r14d,%r14d
cmp    %r15d,%r8d
cmove  %r14d,%r15d
mov    $0x0,%eax
cmp    %r15d,%r11d
je     14c0 <prob6+0x370>
mov    %r15d,%eax
mov    $0x0,%ecx
cmp    %eax,%r10d
je     14cc <prob6+0x37c>
mov    %eax,%ecx
cmp    %ecx,%r9d
je     1490 <prob6+0x340>
mov    %ecx,%r14d
jmp    1490 <prob6+0x340>
lea    0xc15(%rip),%rdi
call   1030 <puts@plt>
mov    -0x30(%rbp),%eax
xor    %r15d,%r15d
cmp    $0x2,%eax
mov    -0x38(%rbp),%r12
jl     152a <prob6+0x3da>
lea    0xbd1(%rip),%r14
xor    %ebx,%ebx
xor    %r15d,%r15d
jmp    150f <prob6+0x3bf>
nop
add    $0x1,%rbx
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rbx
jge    152a <prob6+0x3da>
mov    (%r12,%rbx,4),%esi
test   %esi,%esi
je     1500 <prob6+0x3b0>
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%r15d
mov    -0x30(%rbp),%eax
jmp    1500 <prob6+0x3b0>
lea    0xb9c(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
call   1060 <pause@plt>
mov    -0x60(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"clear\00"
@.str.1 = [48 x i8] c"Enter the value you want primes calculated to: \00"
@.str.2 = [3 x i8] c"%d\00"
@.str.3 = [64 x i8] c"Here are the prime numbers from 0 to the number you entered: \0A\0A\00"
@.str.4 = [4 x i8] c"%d\0A\00"
@.str.5 = [37 x i8] c"\0AThere were %d primes in this list. \00"
define void @prob6() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i64
%8 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %5
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %1)
%11 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%12 = load i32, i32* %1
%13 = sub nsw i32 %12, 1
%14 = zext i32 %13 to i64
%15 = call i8* @llvm.stacksave()
store i8* %15, i8** %6
%16 = alloca i32, i64 %14
store i64 %14, i64* %7
store i32 2, i32* %2
br label %17
17: ; preds = %27, %0
%18 = load i32, i32* %2
%19 = load i32, i32* %1
%20 = icmp sle i32 %18, %19
br i1 %20, label %21, label %30
21: ; preds = %17
%22 = load i32, i32* %2
%23 = load i32, i32* %2
%24 = sub nsw i32 %23, 2
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %16, i64 %25
store i32 %22, i32* %26
br label %27
27: ; preds = %21
%28 = load i32, i32* %2
%29 = add nsw i32 %28, 1
store i32 %29, i32* %2
br label %17
30: ; preds = %17
store i32 0, i32* %2
br label %31
31: ; preds = %68, %30
%32 = load i32, i32* %2
%33 = load i32, i32* %1
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %71
35: ; preds = %31
store i32 2, i32* %3
br label %36
36: ; preds = %64, %35
%37 = load i32, i32* %3
%38 = load i32, i32* %1
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %67
40: ; preds = %36
%41 = load i32, i32* %3
store i32 %41, i32* %4
br label %42
42: ; preds = %60, %40
%43 = load i32, i32* %4
%44 = load i32, i32* %1
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %63
46: ; preds = %42
%47 = load i32, i32* %3
%48 = load i32, i32* %4
%49 = mul nsw i32 %47, %48
%50 = load i32, i32* %2
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %16, i64 %51
%53 = load i32, i32* %52
%54 = icmp eq i32 %49, %53
br i1 %54, label %55, label %59
55: ; preds = %46
%56 = load i32, i32* %2
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %16, i64 %57
store i32 0, i32* %58
br label %59
59: ; preds = %55, %46
br label %60
60: ; preds = %59
%61 = load i32, i32* %4
%62 = add nsw i32 %61, 1
store i32 %62, i32* %4
br label %42
63: ; preds = %42
br label %64
64: ; preds = %63
%65 = load i32, i32* %3
%66 = add nsw i32 %65, 1
store i32 %66, i32* %3
br label %36
67: ; preds = %36
br label %68
68: ; preds = %67
%69 = load i32, i32* %2
%70 = add nsw i32 %69, 1
store i32 %70, i32* %2
br label %31
71: ; preds = %31
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %2
br label %73
73: ; preds = %93, %71
%74 = load i32, i32* %2
%75 = load i32, i32* %1
%76 = sub nsw i32 %75, 1
%77 = icmp slt i32 %74, %76
br i1 %77, label %78, label %96
78: ; preds = %73
%79 = load i32, i32* %2
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %16, i64 %80
%82 = load i32, i32* %81
%83 = icmp ne i32 %82, 0
br i1 %83, label %84, label %92
84: ; preds = %78
%85 = load i32, i32* %2
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %16, i64 %86
%88 = load i32, i32* %87
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %88)
%90 = load i32, i32* %5
%91 = add nsw i32 %90, 1
store i32 %91, i32* %5
br label %92
92: ; preds = %84, %78
br label %93
93: ; preds = %92
%94 = load i32, i32* %2
%95 = add nsw i32 %94, 1
store i32 %95, i32* %2
br label %73
96: ; preds = %73
%97 = load i32, i32* %5
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.5, i64 0, i64 0), i32 %97)
%99 = call i32 (...) @pause()
%100 = load i8*, i8** %6
ret void
}

LLVM IR (-O2):
@.str = [6 x i8] c"clear\00"
@.str.1 = [48 x i8] c"Enter the value you want primes calculated to: \00"
@.str.2 = [3 x i8] c"%d\00"
@.str.4 = [4 x i8] c"%d\0A\00"
@.str.5 = [37 x i8] c"\0AThere were %d primes in this list. \00"
@str = [63 x i8] c"Here are the prime numbers from 0 to the number you entered: \0A\00"
define void @prob6() {
%1 = alloca i32
%2 = tail call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%3 = bitcast i32* %1 to i8*
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%5 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %1)
%6 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%7 = load i32, i32* %1
%8 = add nsw i32 %7, -1
%9 = zext i32 %8 to i64
%10 = call i8* @llvm.stacksave()
%11 = alloca i32, i64 %9
%12 = load i32, i32* %1
%13 = icmp slt i32 %12, 2
br i1 %13, label %84, label %14
14: ; preds = %0
%15 = add nuw i32 %12, 1
%16 = zext i32 %15 to i64
%17 = add nsw i64 %16, -2
%18 = icmp ult i64 %17, 8
br i1 %18, label %82, label %19
19: ; preds = %14
%20 = and i64 %17, -8
%21 = or i64 %20, 2
%22 = add nsw i64 %20, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 3
%26 = icmp ult i64 %22, 24
br i1 %26, label %63, label %27
27: ; preds = %19
%28 = and i64 %24, 4611686018427387900
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %59, %29 ]
%31 = phi <4 x i32> [ <i32 2, i32 3, i32 4, i32 5>, %27 ], [ %60, %29 ]
%32 = phi i64 [ 0, %27 ], [ %61, %29 ]
%33 = add <4 x i32> %31, <i32 4, i32 4, i32 4, i32 4>
%34 = getelementptr inbounds i32, i32* %11, i64 %30
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %35
%36 = getelementptr inbounds i32, i32* %34, i64 4
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %37
%38 = or i64 %30, 8
%39 = add <4 x i32> %31, <i32 8, i32 8, i32 8, i32 8>
%40 = add <4 x i32> %31, <i32 12, i32 12, i32 12, i32 12>
%41 = getelementptr inbounds i32, i32* %11, i64 %38
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %44
%45 = or i64 %30, 16
%46 = add <4 x i32> %31, <i32 16, i32 16, i32 16, i32 16>
%47 = add <4 x i32> %31, <i32 20, i32 20, i32 20, i32 20>
%48 = getelementptr inbounds i32, i32* %11, i64 %45
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> %46, <4 x i32>* %49
%50 = getelementptr inbounds i32, i32* %48, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %51
%52 = or i64 %30, 24
%53 = add <4 x i32> %31, <i32 24, i32 24, i32 24, i32 24>
%54 = add <4 x i32> %31, <i32 28, i32 28, i32 28, i32 28>
%55 = getelementptr inbounds i32, i32* %11, i64 %52
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> %53, <4 x i32>* %56
%57 = getelementptr inbounds i32, i32* %55, i64 4
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %54, <4 x i32>* %58
%59 = add nuw i64 %30, 32
%60 = add <4 x i32> %31, <i32 32, i32 32, i32 32, i32 32>
%61 = add i64 %32, 4
%62 = icmp eq i64 %61, %28
br i1 %62, label %63, label %29
63: ; preds = %29, %19
%64 = phi i64 [ 0, %19 ], [ %59, %29 ]
%65 = phi <4 x i32> [ <i32 2, i32 3, i32 4, i32 5>, %19 ], [ %60, %29 ]
%66 = icmp eq i64 %25, 0
br i1 %66, label %80, label %67
67: ; preds = %63, %67
%68 = phi i64 [ %76, %67 ], [ %64, %63 ]
%69 = phi <4 x i32> [ %77, %67 ], [ %65, %63 ]
%70 = phi i64 [ %78, %67 ], [ 0, %63 ]
%71 = add <4 x i32> %69, <i32 4, i32 4, i32 4, i32 4>
%72 = getelementptr inbounds i32, i32* %11, i64 %68
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %69, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %75
%76 = add nuw i64 %68, 8
%77 = add <4 x i32> %69, <i32 8, i32 8, i32 8, i32 8>
%78 = add i64 %70, 1
%79 = icmp eq i64 %78, %25
br i1 %79, label %80, label %67
80: ; preds = %67, %63
%81 = icmp eq i64 %17, %20
br i1 %81, label %84, label %82
82: ; preds = %14, %80
%83 = phi i64 [ 2, %14 ], [ %21, %80 ]
br label %91
84: ; preds = %91, %80, %0
%85 = icmp sgt i32 %12, 0
br i1 %85, label %86, label %155
86: ; preds = %84
%87 = icmp ugt i32 %12, 2
%88 = zext i32 %12 to i64
%89 = add i32 %12, 2
%90 = add i32 %12, -3
br label %98
91: ; preds = %82, %91
%92 = phi i64 [ %96, %91 ], [ %83, %82 ]
%93 = add nsw i64 %92, -2
%94 = getelementptr inbounds i32, i32* %11, i64 %93
%95 = trunc i64 %92 to i32
store i32 %95, i32* %94
%96 = add nuw nsw i64 %92, 1
%97 = icmp eq i64 %96, %16
br i1 %97, label %84, label %91
98: ; preds = %86, %152
%99 = phi i64 [ 0, %86 ], [ %153, %152 ]
br i1 %87, label %100, label %152
100: ; preds = %98
%101 = getelementptr inbounds i32, i32* %11, i64 %99
%102 = load i32, i32* %101
br label %103
103: ; preds = %146, %100
%104 = phi i32 [ %150, %146 ], [ 0, %100 ]
%105 = phi i32 [ %147, %146 ], [ %102, %100 ]
%106 = phi i32 [ %148, %146 ], [ 2, %100 ]
%107 = sub i32 %89, %104
%108 = sub i32 %90, %104
%109 = and i32 %107, 3
%110 = icmp eq i32 %109, 0
br i1 %110, label %121, label %111
111: ; preds = %103, %111
%112 = phi i32 [ %117, %111 ], [ %105, %103 ]
%113 = phi i32 [ %118, %111 ], [ %106, %103 ]
%114 = phi i32 [ %119, %111 ], [ 0, %103 ]
%115 = mul nsw i32 %113, %106
%116 = icmp eq i32 %115, %112
%117 = select i1 %116, i32 0, i32 %112
%118 = add nuw nsw i32 %113, 1
%119 = add i32 %114, 1
%120 = icmp eq i32 %119, %109
br i1 %120, label %121, label %111
121: ; preds = %111, %103
%122 = phi i32 [ undef, %103 ], [ %117, %111 ]
%123 = phi i32 [ %105, %103 ], [ %117, %111 ]
%124 = phi i32 [ %106, %103 ], [ %118, %111 ]
%125 = icmp ult i32 %108, 3
br i1 %125, label %146, label %126
126: ; preds = %121, %126
%127 = phi i32 [ %143, %126 ], [ %123, %121 ]
%128 = phi i32 [ %144, %126 ], [ %124, %121 ]
%129 = mul nsw i32 %128, %106
%130 = icmp eq i32 %129, %127
%131 = select i1 %130, i32 0, i32 %127
%132 = add nuw nsw i32 %128, 1
%133 = mul nsw i32 %132, %106
%134 = icmp eq i32 %133, %131
%135 = select i1 %134, i32 0, i32 %131
%136 = add nuw nsw i32 %128, 2
%137 = mul nsw i32 %136, %106
%138 = icmp eq i32 %137, %135
%139 = select i1 %138, i32 0, i32 %135
%140 = add nuw nsw i32 %128, 3
%141 = mul nsw i32 %140, %106
%142 = icmp eq i32 %141, %139
%143 = select i1 %142, i32 0, i32 %139
%144 = add nuw nsw i32 %128, 4
%145 = icmp eq i32 %144, %12
br i1 %145, label %146, label %126
146: ; preds = %126, %121
%147 = phi i32 [ %122, %121 ], [ %143, %126 ]
%148 = add nuw nsw i32 %106, 1
%149 = icmp eq i32 %148, %12
%150 = add i32 %104, 1
br i1 %149, label %151, label %103
151: ; preds = %146
store i32 %147, i32* %101
br label %152
152: ; preds = %151, %98
%153 = add nuw nsw i64 %99, 1
%154 = icmp eq i64 %153, %88
br i1 %154, label %155, label %98
155: ; preds = %152, %84
%156 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str, i64 0, i64 0))
%157 = load i32, i32* %1
%158 = icmp sgt i32 %157, 1
br i1 %158, label %159, label %177
159: ; preds = %155, %170
%160 = phi i32 [ %171, %170 ], [ %157, %155 ]
%161 = phi i64 [ %173, %170 ], [ 0, %155 ]
%162 = phi i32 [ %172, %170 ], [ 0, %155 ]
%163 = getelementptr inbounds i32, i32* %11, i64 %161
%164 = load i32, i32* %163
%165 = icmp eq i32 %164, 0
br i1 %165, label %170, label %166
166: ; preds = %159
%167 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %164)
%168 = add nsw i32 %162, 1
%169 = load i32, i32* %1
br label %170
170: ; preds = %159, %166
%171 = phi i32 [ %169, %166 ], [ %160, %159 ]
%172 = phi i32 [ %168, %166 ], [ %162, %159 ]
%173 = add nuw nsw i64 %161, 1
%174 = add nsw i32 %171, -1
%175 = sext i32 %174 to i64
%176 = icmp slt i64 %173, %175
br i1 %176, label %159, label %177
177: ; preds = %170, %155
%178 = phi i32 [ 0, %155 ], [ %172, %170 ]
%179 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.5, i64 0, i64 0), i32 %178)
%180 = call i32 (...) @pause()
ret void
}