#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*/ debug(char *, double);
int sqrt(double);
int main() {
  int i, j;
  double a[100000], b[100000], c[100000];
  double r = 0;
  for (i = 0; i < 100000; i++) {
    a[i] = sqrt(i);
    b[i] = 0;
    c[i] = 0;
  }
#pragma omp parallel
  {
#pragma omp for private(i, j) nowait
    for (i = 0; i < 100000; i++) {
      for (j = 0; j < ((i / 10000) + 1) * 10; j++) {
        b[i] = b[i] + sqrt(a[i]) / 3;
      }
    }
#pragma omp for private(i, j)
    for (i = 0; i < 100000; i++) {
      for (j = 0; j < ((i / 10000) + 1) * 10; j++) {
        c[i] = c[i] + sqrt(a[i]);
      }
    }
#pragma omp for private(i, j)
    for (i = 0; i < 100000; i++) {
      for (j = 0; j < ((i / 10000) + 1) * 10; j++) {
        b[i] = b[i] + sqrt(a[i]) / 3 + c[i];
      }
    }
#pragma omp barrier
#pragma omp master
    {
      for (i = 0; i < 100000; i++) {
        r = r + b[i];
      }
      debug("r = %lf\n", r);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x249f50,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x249f18(%rbp)
ff
movl   $0x0,-0x8(%rbp)
cmpl   $0x186a0,-0x8(%rbp)
jge    119a <main+0x7a>
cvtsi2sdl -0x8(%rbp),%xmm0
call   1040 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0xc3510(%rbp,%rax,8)
f3 ff
movslq -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x186a10(%rbp,%rax,8)
e7 ff
movslq -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x249f10(%rbp,%rax,8)
db ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1144 <main+0x24>
movl   $0x0,-0x8(%rbp)
cmpl   $0x186a0,-0x8(%rbp)
jge    124c <main+0x12c>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x249f1c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x249f1c(%rbp),%eax
add    $0x1,%ecx
imul   $0xa,%ecx,%ecx
cmp    %ecx,%eax
jge    1239 <main+0x119>
movslq -0x8(%rbp),%rax
movsd  -0x186a10(%rbp,%rax,8),%xmm0
e7 ff
movsd  %xmm0,-0x249f28(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0xc3510(%rbp,%rax,8),%xmm0
f3 ff
call   1040 <sqrt@plt>
movsd  -0x249f28(%rbp),%xmm0
ff
mov    $0x3,%ecx
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0x186a10(%rbp,%rax,8)
e7 ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11b5 <main+0x95>
jmp    123e <main+0x11e>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11a1 <main+0x81>
movl   $0x0,-0x8(%rbp)
cmpl   $0x186a0,-0x8(%rbp)
jge    12f6 <main+0x1d6>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x249f2c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x249f2c(%rbp),%eax
add    $0x1,%ecx
imul   $0xa,%ecx,%ecx
cmp    %ecx,%eax
jge    12e3 <main+0x1c3>
movslq -0x8(%rbp),%rax
movsd  -0x249f10(%rbp,%rax,8),%xmm0
db ff
movsd  %xmm0,-0x249f38(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0xc3510(%rbp,%rax,8),%xmm0
f3 ff
call   1040 <sqrt@plt>
movsd  -0x249f38(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0x249f10(%rbp,%rax,8)
db ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1267 <main+0x147>
jmp    12e8 <main+0x1c8>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1253 <main+0x133>
movl   $0x0,-0x8(%rbp)
cmpl   $0x186a0,-0x8(%rbp)
jge    13b5 <main+0x295>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x249f3c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x249f3c(%rbp),%eax
add    $0x1,%ecx
imul   $0xa,%ecx,%ecx
cmp    %ecx,%eax
jge    13a2 <main+0x282>
movslq -0x8(%rbp),%rax
movsd  -0x186a10(%rbp,%rax,8),%xmm0
e7 ff
movsd  %xmm0,-0x249f48(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0xc3510(%rbp,%rax,8),%xmm0
f3 ff
call   1040 <sqrt@plt>
movsd  -0x249f48(%rbp),%xmm0
ff
mov    $0x3,%ecx
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
addsd  -0x249f10(%rbp,%rax,8),%xmm0
db ff
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0x186a10(%rbp,%rax,8)
e7 ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1311 <main+0x1f1>
jmp    13a7 <main+0x287>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12fd <main+0x1dd>
movl   $0x0,-0x8(%rbp)
cmpl   $0x186a0,-0x8(%rbp)
jge    13f4 <main+0x2d4>
movsd  -0x249f18(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
addsd  -0x186a10(%rbp,%rax,8),%xmm0
e7 ff
movsd  %xmm0,-0x249f18(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13bc <main+0x29c>
movsd  -0x249f18(%rbp),%xmm0
ff
lea    0xbfd(%rip),%rdi
call   1030 <debug@plt>
xor    %eax,%eax
add    $0x249f50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x249f10,%rsp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x186a10(%rsp,%rbx,8)
movq   $0x0,0x10(%rsp,%rbx,8)
movq   $0x0,0xc3510(%rsp,%rbx,8)
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x186a18(%rsp,%rbx,8)
movq   $0x0,0x18(%rsp,%rbx,8)
movq   $0x0,0xc3518(%rsp,%rbx,8)
add    $0x2,%rbx
cmp    $0x186a0,%rbx
jne    1140 <main+0x20>
xor    %ebx,%ebx
mov    $0xd1b71759,%r14d
nopw   0x0(%rax,%rax,1)
mov    %ebx,%eax
imul   %r14,%rax
shr    $0x2d,%rax
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,1),%ebp
add    $0xa,%ebp
movsd  0x186a10(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp,%rbx,8),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
add    $0xfffffffe,%ebp
jne    11f0 <main+0xd0>
movsd  %xmm0,0x10(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0x186a0,%rbx
jne    11c0 <main+0xa0>
xor    %r12d,%r12d
mov    $0xd1b71759,%r14d
jmp    129b <main+0x17b>
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,0xc3510(%rsp,%r12,8)
add    $0x1,%r12
cmp    $0x186a0,%r12
je     138a <main+0x26a>
mov    %r12d,%eax
imul   %r14,%rax
shr    $0x2d,%rax
lea    (%rax,%rax,4),%ecx
add    $0x1,%al
movzbl %al,%ebp
and    $0x1,%ebp
add    %ebp,%ebp
lea    (%rcx,%rcx,1),%r15d
add    $0xa,%r15d
mov    %r15d,%ebx
and    $0xfffffc,%ebx
movsd  0x186a10(%rsp,%r12,8),%xmm0
movsd  0xc3510(%rsp,%r12,8),%xmm1
movsd  %xmm0,0x8(%rsp)
xchg   %ax,%ax
movsd  %xmm1,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd  (%rsp),%xmm1
add    $0xfffffffc,%ebx
jne    12e0 <main+0x1c0>
test   $0x2,%r15b
je     1280 <main+0x160>
nop
movsd  %xmm1,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
movsd  (%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm1
add    $0xffffffff,%ebp
jne    1360 <main+0x240>
jmp    1280 <main+0x160>
xor    %ebx,%ebx
mov    $0xd1b71759,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
imul   %r14,%rax
shr    $0x2d,%rax
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,1),%ebp
add    $0xa,%ebp
movsd  0x186a10(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp,%rbx,8),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
addsd  0xc3510(%rsp,%rbx,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
addsd  0xc3510(%rsp,%rbx,8),%xmm0
add    $0xfffffffe,%ebp
jne    13d0 <main+0x2b0>
movsd  %xmm0,0x10(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0x186a0,%rbx
jne    13a0 <main+0x280>
xorpd  %xmm0,%xmm0
mov    $0x7,%eax
nopl   0x0(%rax,%rax,1)
addsd  -0x28(%rsp,%rax,8),%xmm0
addsd  -0x20(%rsp,%rax,8),%xmm0
addsd  -0x18(%rsp,%rax,8),%xmm0
addsd  -0x10(%rsp,%rax,8),%xmm0
addsd  -0x8(%rsp,%rax,8),%xmm0
addsd  (%rsp,%rax,8),%xmm0
addsd  0x8(%rsp,%rax,8),%xmm0
addsd  0x10(%rsp,%rax,8),%xmm0
add    $0x8,%rax
cmp    $0x186a7,%rax
jne    1470 <main+0x350>
lea    0xb4e(%rip),%rdi
call   1030 <debug@plt>
xor    %eax,%eax
add    $0x249f10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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