void summaryInterpolate(double *souVal, int *souNNTarID, int nSou,
                        double *tarVal, int *nSouPixels, int nTar) {
  for (int i = 0; i < nTar; i++) {
    tarVal[i] = 0;
    nSouPixels[i] = 0;
  }
  int nnTarID;
  for (int i = 0; i < nSou; i++) {
    nnTarID = souNNTarID[i];
    if (nnTarID > 0 && souVal[i] >= 0) {
      tarVal[nnTarID] += souVal[i];
      nSouPixels[nnTarID]++;
    }
  }
  for (int i = 0; i < nTar; i++) {
    if (nSouPixels[i] > 0) {
      tarVal[i] = tarVal[i] / nSouPixels[i];
    } else {
      tarVal[i] = -999;
    }
  }
}


x86 assembly (clang, -O0):
<summaryInterpolate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    115b <summaryInterpolate+0x5b>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1122 <summaryInterpolate+0x22>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e3 <summaryInterpolate+0xe3>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    11d0 <summaryInterpolate+0xd0>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11d0 <summaryInterpolate+0xd0>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    11d5 <summaryInterpolate+0xd5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1162 <summaryInterpolate+0x62>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1260 <summaryInterpolate+0x160>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1238 <summaryInterpolate+0x138>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    124d <summaryInterpolate+0x14d>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xdb8(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1252 <summaryInterpolate+0x152>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ea <summaryInterpolate+0xea>
pop    %rbp
ret

x86 assembly (clang, -O2):
<summaryInterpolate>:
push   %r15
push   %r14
push   %rbx
mov    %r9d,%r10d
test   %r9d,%r9d
jle    1219 <summaryInterpolate+0x119>
cmp    $0x4,%r9d
jae    111e <summaryInterpolate+0x1e>
xor    %eax,%eax
jmp    1200 <summaryInterpolate+0x100>
mov    %r10d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rbx
mov    %rbx,%r14
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14d,%r11d
and    $0x3,%r11d
cmp    $0xc,%rbx
jae    1144 <summaryInterpolate+0x44>
xor    %ebx,%ebx
jmp    11a4 <summaryInterpolate+0xa4>
and    $0xfffffffffffffffc,%r14
xor    %ebx,%ebx
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
movupd %xmm0,(%rcx,%rbx,8)
movupd %xmm0,0x10(%rcx,%rbx,8)
movupd %xmm0,(%r8,%rbx,4)
movupd %xmm0,0x20(%rcx,%rbx,8)
movupd %xmm0,0x30(%rcx,%rbx,8)
movupd %xmm0,0x10(%r8,%rbx,4)
movupd %xmm0,0x40(%rcx,%rbx,8)
movupd %xmm0,0x50(%rcx,%rbx,8)
movupd %xmm0,0x20(%r8,%rbx,4)
movupd %xmm0,0x60(%rcx,%rbx,8)
movupd %xmm0,0x70(%rcx,%rbx,8)
movupd %xmm0,0x30(%r8,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%r14
jne    1150 <summaryInterpolate+0x50>
test   %r11,%r11
je     11ed <summaryInterpolate+0xed>
lea    (%r8,%rbx,4),%r14
add    $0x8,%r14
lea    (%rcx,%rbx,8),%r15
add    $0x10,%r15
shl    $0x4,%r11
xor    %ebx,%ebx
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm0,-0x10(%r15,%rbx,2)
movupd %xmm0,(%r15,%rbx,2)
movupd %xmm0,-0x8(%r14,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%r11
jne    11d0 <summaryInterpolate+0xd0>
cmp    %r10,%rax
je     1219 <summaryInterpolate+0x119>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,(%rcx,%rax,8)
movl   $0x0,(%r8,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    1200 <summaryInterpolate+0x100>
test   %edx,%edx
jle    125c <summaryInterpolate+0x15c>
mov    %edx,%eax
xor    %edx,%edx
xorpd  %xmm0,%xmm0
jmp    1239 <summaryInterpolate+0x139>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %rdx,%rax
je     125c <summaryInterpolate+0x15c>
mov    (%rsi,%rdx,4),%ebx
test   %ebx,%ebx
jle    1230 <summaryInterpolate+0x130>
movsd  (%rdi,%rdx,8),%xmm1
ucomisd %xmm0,%xmm1
jb     1230 <summaryInterpolate+0x130>
addsd  (%rcx,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
addl   $0x1,(%r8,%rbx,4)
jmp    1230 <summaryInterpolate+0x130>
test   %r9d,%r9d
jle    130d <summaryInterpolate+0x20d>
cmp    $0x1,%r9d
jne    1295 <summaryInterpolate+0x195>
xor    %eax,%eax
test   $0x1,%r10b
je     130d <summaryInterpolate+0x20d>
mov    (%r8,%rax,4),%edx
test   %edx,%edx
jle    1300 <summaryInterpolate+0x200>
movsd  (%rcx,%rax,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
divsd  %xmm1,%xmm0
jmp    1308 <summaryInterpolate+0x208>
mov    %r10d,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
movsd  0xd5b(%rip),%xmm0
jmp    12bf <summaryInterpolate+0x1bf>
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
je     126d <summaryInterpolate+0x16d>
mov    (%r8,%rax,4),%esi
movapd %xmm0,%xmm1
test   %esi,%esi
jle    12db <summaryInterpolate+0x1db>
movsd  (%rcx,%rax,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
mov    0x4(%r8,%rax,4),%esi
movapd %xmm0,%xmm1
test   %esi,%esi
jle    12b0 <summaryInterpolate+0x1b0>
movsd  0x8(%rcx,%rax,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
divsd  %xmm2,%xmm1
jmp    12b0 <summaryInterpolate+0x1b0>
movsd  0xcf8(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @summaryInterpolate(double* %0, i32* %1, i32 %2, double* %3, i32* %4, i32 %5) {
%7 = alloca double*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store double* %0, double** %7
store i32* %1, i32** %8
store i32 %2, i32* %9
store double* %3, double** %10
store i32* %4, i32** %11
store i32 %5, i32* %12
store i32 0, i32* %13
br label %17
17: ; preds = %30, %6
%18 = load i32, i32* %13
%19 = load i32, i32* %12
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %33
21: ; preds = %17
%22 = load double*, double** %10
%23 = load i32, i32* %13
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds double, double* %22, i64 %24
store double 0.000000e+00, double* %25
%26 = load i32*, i32** %11
%27 = load i32, i32* %13
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i32, i32* %26, i64 %28
store i32 0, i32* %29
br label %30
30: ; preds = %21
%31 = load i32, i32* %13
%32 = add nsw i32 %31, 1
store i32 %32, i32* %13
br label %17
33: ; preds = %17
store i32 0, i32* %15
br label %34
34: ; preds = %72, %33
%35 = load i32, i32* %15
%36 = load i32, i32* %9
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %75
38: ; preds = %34
%39 = load i32*, i32** %8
%40 = load i32, i32* %15
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %39, i64 %41
%43 = load i32, i32* %42
store i32 %43, i32* %14
%44 = load i32, i32* %14
%45 = icmp sgt i32 %44, 0
br i1 %45, label %46, label %71
46: ; preds = %38
%47 = load double*, double** %7
%48 = load i32, i32* %15
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = fcmp oge double %51, 0.000000e+00
br i1 %52, label %53, label %71
53: ; preds = %46
%54 = load double*, double** %7
%55 = load i32, i32* %15
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = load double, double* %57
%59 = load double*, double** %10
%60 = load i32, i32* %14
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = fadd double %63, %58
store double %64, double* %62
%65 = load i32*, i32** %11
%66 = load i32, i32* %14
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
%69 = load i32, i32* %68
%70 = add nsw i32 %69, 1
store i32 %70, i32* %68
br label %71
71: ; preds = %53, %46, %38
br label %72
72: ; preds = %71
%73 = load i32, i32* %15
%74 = add nsw i32 %73, 1
store i32 %74, i32* %15
br label %34
75: ; preds = %34
store i32 0, i32* %16
br label %76
76: ; preds = %110, %75
%77 = load i32, i32* %16
%78 = load i32, i32* %12
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %113
80: ; preds = %76
%81 = load i32*, i32** %11
%82 = load i32, i32* %16
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %81, i64 %83
%85 = load i32, i32* %84
%86 = icmp sgt i32 %85, 0
br i1 %86, label %87, label %104
87: ; preds = %80
%88 = load double*, double** %10
%89 = load i32, i32* %16
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
%92 = load double, double* %91
%93 = load i32*, i32** %11
%94 = load i32, i32* %16
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = sitofp i32 %97 to double
%99 = fdiv double %92, %98
%100 = load double*, double** %10
%101 = load i32, i32* %16
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
store double %99, double* %103
br label %109
104: ; preds = %80
%105 = load double*, double** %10
%106 = load i32, i32* %16
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
store double -9.990000e+02, double* %108
br label %109
109: ; preds = %104, %87
br label %110
110: ; preds = %109
%111 = load i32, i32* %16
%112 = add nsw i32 %111, 1
store i32 %112, i32* %16
br label %76
113: ; preds = %76
ret void
}

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