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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int floor(int /*<<< orphan*/);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ sqrt(int);
long sum_primes_under_with_seive(int l) {
  int loops = 0;
  int *seive = (int *)calloc(l + 1, sizeof(int));
  seive[0] = 1;
  seive[1] = 1;
  seive[2] = 0;
  seive[3] = 0;
  int i = 2;
  for (i = 4; i < l; i += 2) {
    loops++;
    seive[i] = 1;
  }
  const int limit = floor(sqrt(l));
  for (i = 3; i <= limit; i += 2) {
    if (!seive[i]) {
      int m;
      for (m = i * i; m <= l; m += 2 * i) {
        loops++;
        seive[m] = 1;
      }
    }
  }
  long s = 0;
  for (i = 1; i <= l; i++) {
    loops++;
    if (!seive[i]) {
      s += i;
    }
  }
  free(seive);
  printf("primitive seive method needs %d loops\n", loops);
  return s;
}


x86 assembly (clang, -O0):
<sum_primes_under_with_seive>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,0xc(%rax)
movl   $0x2,-0x14(%rbp)
movl   $0x4,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11e1 <sum_primes_under_with_seive+0x91>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    11af <sum_primes_under_with_seive+0x5f>
mov    -0x4(%rbp),%edi
call   1060 <sqrt@plt>
mov    %eax,%edi
call   1070 <floor@plt>
mov    %eax,-0x18(%rbp)
movl   $0x3,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     126f <sum_primes_under_with_seive+0x11f>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    125c <sum_primes_under_with_seive+0x10c>
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1257 <sum_primes_under_with_seive+0x107>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1222 <sum_primes_under_with_seive+0xd2>
jmp    125c <sum_primes_under_with_seive+0x10c>
jmp    1261 <sum_primes_under_with_seive+0x111>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    11fa <sum_primes_under_with_seive+0xaa>
movq   $0x0,-0x28(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     12c4 <sum_primes_under_with_seive+0x174>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12b1 <sum_primes_under_with_seive+0x161>
movslq -0x14(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    12b6 <sum_primes_under_with_seive+0x166>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    127e <sum_primes_under_with_seive+0x12e>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
mov    -0x8(%rbp),%esi
lea    0xd29(%rip),%rdi
call   1040 <printf@plt>
mov    -0x28(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sum_primes_under_with_seive>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edi,%r12d
lea    0x1(%r12),%r15d
mov    %r15d,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r14
movdqa 0xe88(%rip),%xmm0
movdqu %xmm0,(%rax)
xor    %ebp,%ebp
cmp    $0x5,%r12d
jl     11ff <sum_primes_under_with_seive+0xaf>
lea    -0x5(%r12),%edx
mov    %edx,%eax
shr    %eax
lea    0x1(%rax),%ebp
mov    $0x4,%ecx
cmp    $0x6,%edx
jb     11dc <sum_primes_under_with_seive+0x8c>
mov    %ebp,%edx
and    $0xfffffffc,%edx
mov    $0x4,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x1,(%r14,%rcx,4)
movl   $0x1,0x8(%r14,%rcx,4)
movl   $0x1,0x10(%r14,%rcx,4)
movl   $0x1,0x18(%r14,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffc,%edx
jne    11b0 <sum_primes_under_with_seive+0x60>
test   $0x3,%bpl
je     11ff <sum_primes_under_with_seive+0xaf>
lea    (%r14,%rcx,4),%rcx
add    $0x1,%al
movzbl %al,%eax
and    $0x3,%eax
xor    %edx,%edx
movl   $0x1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%eax
jne    11f0 <sum_primes_under_with_seive+0xa0>
mov    %r12d,%edi
call   1060 <sqrt@plt>
mov    %eax,%edi
call   1070 <floor@plt>
cmp    $0x3,%eax
jge    1231 <sum_primes_under_with_seive+0xe1>
test   %r12d,%r12d
jle    1295 <sum_primes_under_with_seive+0x145>
mov    %r15d,%eax
lea    -0x1(%rax),%rdx
cmp    $0x4,%rdx
jae    129c <sum_primes_under_with_seive+0x14c>
mov    $0x1,%ecx
xor    %ebx,%ebx
jmp    1420 <sum_primes_under_with_seive+0x2d0>
mov    %eax,%r8d
mov    $0x10,%r9d
mov    $0x3,%edx
mov    $0x9,%ecx
mov    $0x18,%edi
mov    $0x6,%ebx
jmp    1267 <sum_primes_under_with_seive+0x117>
add    $0x2,%rdx
add    %r9d,%ecx
add    $0x8,%r9d
add    $0x10,%rdi
add    $0x4,%ebx
cmp    %r8,%rdx
ja     1213 <sum_primes_under_with_seive+0xc3>
cmpl   $0x0,(%r14,%rdx,4)
jne    1250 <sum_primes_under_with_seive+0x100>
mov    %edx,%eax
imul   %edx,%eax
cmp    %r12d,%eax
jg     1250 <sum_primes_under_with_seive+0x100>
mov    %ecx,%eax
lea    (%r14,%rax,4),%rax
mov    %ecx,%esi
add    $0x1,%ebp
movl   $0x1,(%rax)
add    %rdi,%rax
add    %ebx,%esi
cmp    %r12d,%esi
jle    1280 <sum_primes_under_with_seive+0x130>
jmp    1250 <sum_primes_under_with_seive+0x100>
xor    %ebx,%ebx
jmp    143d <sum_primes_under_with_seive+0x2ed>
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     145f <sum_primes_under_with_seive+0x30f>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm12,%xmm12
movdqa 0xd41(%rip),%xmm6
mov    $0x1,%edi
movdqa 0xd43(%rip),%xmm8
movdqa 0xd4a(%rip),%xmm9
movdqa 0xd51(%rip),%xmm10
movdqa 0xd58(%rip),%xmm11
pxor   %xmm1,%xmm1
pxor   %xmm2,%xmm2
movdqa %xmm6,%xmm0
paddq  %xmm8,%xmm0
movq   (%r14,%rdi,4),%xmm5
movq   0x8(%r14,%rdi,4),%xmm4
pcmpeqd %xmm12,%xmm5
pxor   %xmm7,%xmm7
pcmpgtd %xmm5,%xmm7
punpckldq %xmm7,%xmm5
pcmpeqd %xmm12,%xmm4
pxor   %xmm7,%xmm7
pcmpgtd %xmm4,%xmm7
punpckldq %xmm7,%xmm4
pand   %xmm0,%xmm4
paddq  %xmm2,%xmm4
pand   %xmm6,%xmm5
paddq  %xmm1,%xmm5
movdqa %xmm6,%xmm0
paddq  %xmm9,%xmm0
movdqa %xmm6,%xmm7
paddq  %xmm10,%xmm7
movq   0x10(%r14,%rdi,4),%xmm1
movq   0x18(%r14,%rdi,4),%xmm2
pcmpeqd %xmm12,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm1,%xmm3
punpckldq %xmm3,%xmm1
pand   %xmm0,%xmm1
paddq  %xmm5,%xmm1
pcmpeqd %xmm12,%xmm2
pxor   %xmm0,%xmm0
pcmpgtd %xmm2,%xmm0
punpckldq %xmm0,%xmm2
pand   %xmm7,%xmm2
paddq  %xmm4,%xmm2
paddq  %xmm11,%xmm6
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1300 <sum_primes_under_with_seive+0x1b0>
test   $0x1,%bl
je     13fb <sum_primes_under_with_seive+0x2ab>
movdqa 0xc66(%rip),%xmm0
paddq  %xmm6,%xmm0
movq   (%r14,%rdi,4),%xmm3
movq   0x8(%r14,%rdi,4),%xmm4
pxor   %xmm5,%xmm5
pcmpeqd %xmm5,%xmm3
pxor   %xmm7,%xmm7
pcmpgtd %xmm3,%xmm7
punpckldq %xmm7,%xmm3
pcmpeqd %xmm5,%xmm4
pcmpgtd %xmm4,%xmm5
punpckldq %xmm5,%xmm4
pand   %xmm0,%xmm4
paddq  %xmm4,%xmm2
pand   %xmm6,%xmm3
paddq  %xmm3,%xmm1
paddq  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movq   %xmm0,%rbx
cmp    %rcx,%rdx
je     143a <sum_primes_under_with_seive+0x2ea>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,(%r14,%rcx,4)
mov    $0x0,%edx
cmove  %rcx,%rdx
add    %rdx,%rbx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1420 <sum_primes_under_with_seive+0x2d0>
add    %r12d,%ebp
mov    %r14,%rdi
call   1030 <free@plt>
lea    0xc14(%rip),%rdi
mov    %ebp,%esi
call   1040 <printf@plt>
mov    %rbx,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm1,%xmm1
movdqa 0xba5(%rip),%xmm6
mov    $0x1,%edi
pxor   %xmm2,%xmm2
test   $0x1,%bl
jne    13b2 <sum_primes_under_with_seive+0x262>
jmp    13fb <sum_primes_under_with_seive+0x2ab>

LLVM IR (-O0):
@.str = [39 x i8] c"primitive seive method needs %d loops\0A\00"
define i64 @sum_primes_under_with_seive(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i64
store i32 %0, i32* %2
store i32 0, i32* %3
%9 = load i32, i32* %2
%10 = add nsw i32 %9, 1
%11 = call i64 @calloc(i32 %10, i32 4)
%12 = inttoptr i64 %11 to i32*
store i32* %12, i32** %4
%13 = load i32*, i32** %4
%14 = getelementptr inbounds i32, i32* %13, i64 0
store i32 1, i32* %14
%15 = load i32*, i32** %4
%16 = getelementptr inbounds i32, i32* %15, i64 1
store i32 1, i32* %16
%17 = load i32*, i32** %4
%18 = getelementptr inbounds i32, i32* %17, i64 2
store i32 0, i32* %18
%19 = load i32*, i32** %4
%20 = getelementptr inbounds i32, i32* %19, i64 3
store i32 0, i32* %20
store i32 2, i32* %5
store i32 4, i32* %5
br label %21
21: ; preds = %32, %1
%22 = load i32, i32* %5
%23 = load i32, i32* %2
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %35
25: ; preds = %21
%26 = load i32, i32* %3
%27 = add nsw i32 %26, 1
store i32 %27, i32* %3
%28 = load i32*, i32** %4
%29 = load i32, i32* %5
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %28, i64 %30
store i32 1, i32* %31
br label %32
32: ; preds = %25
%33 = load i32, i32* %5
%34 = add nsw i32 %33, 2
store i32 %34, i32* %5
br label %21
35: ; preds = %21
%36 = load i32, i32* %2
%37 = call i32 @sqrt(i32 %36)
%38 = call i32 @floor(i32 %37)
store i32 %38, i32* %6
store i32 3, i32* %5
br label %39
39: ; preds = %72, %35
%40 = load i32, i32* %5
%41 = load i32, i32* %6
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %75
43: ; preds = %39
%44 = load i32*, i32** %4
%45 = load i32, i32* %5
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
%48 = load i32, i32* %47
%49 = icmp ne i32 %48, 0
br i1 %49, label %71, label %50
50: ; preds = %43
%51 = load i32, i32* %5
%52 = load i32, i32* %5
%53 = mul nsw i32 %51, %52
store i32 %53, i32* %7
br label %54
54: ; preds = %65, %50
%55 = load i32, i32* %7
%56 = load i32, i32* %2
%57 = icmp sle i32 %55, %56
br i1 %57, label %58, label %70
58: ; preds = %54
%59 = load i32, i32* %3
%60 = add nsw i32 %59, 1
store i32 %60, i32* %3
%61 = load i32*, i32** %4
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
store i32 1, i32* %64
br label %65
65: ; preds = %58
%66 = load i32, i32* %5
%67 = mul nsw i32 2, %66
%68 = load i32, i32* %7
%69 = add nsw i32 %68, %67
store i32 %69, i32* %7
br label %54
70: ; preds = %54
br label %71
71: ; preds = %70, %43
br label %72
72: ; preds = %71
%73 = load i32, i32* %5
%74 = add nsw i32 %73, 2
store i32 %74, i32* %5
br label %39
75: ; preds = %39
store i64 0, i64* %8
store i32 1, i32* %5
br label %76
76: ; preds = %95, %75
%77 = load i32, i32* %5
%78 = load i32, i32* %2
%79 = icmp sle i32 %77, %78
br i1 %79, label %80, label %98
80: ; preds = %76
%81 = load i32, i32* %3
%82 = add nsw i32 %81, 1
store i32 %82, i32* %3
%83 = load i32*, i32** %4
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %83, i64 %85
%87 = load i32, i32* %86
%88 = icmp ne i32 %87, 0
br i1 %88, label %94, label %89
89: ; preds = %80
%90 = load i32, i32* %5
%91 = sext i32 %90 to i64
%92 = load i64, i64* %8
%93 = add nsw i64 %92, %91
store i64 %93, i64* %8
br label %94
94: ; preds = %89, %80
br label %95
95: ; preds = %94
%96 = load i32, i32* %5
%97 = add nsw i32 %96, 1
store i32 %97, i32* %5
br label %76
98: ; preds = %76
%99 = load i32*, i32** %4
%100 = call i32 @free(i32* %99)
%101 = load i32, i32* %3
%102 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 %101)
%103 = load i64, i64* %8
ret i64 %103
}

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