void compute_mean_and_vari_from_hist(int slots, const unsigned long counts[],
                                     double *pmean, double *pvari) {
  unsigned long long sum0 = 0;
  unsigned long long sum1 = 0;
  for (int i = 0; i < slots; ++i) {
    unsigned long long tmp = counts[i];
    sum0 += tmp;
    sum1 += tmp * i;
  }
  *pmean = (double)sum1 / (double)sum0;
  double sum2 = 0;
  for (int i = 0; i < slots; ++i) {
    unsigned long tmp = counts[i];
    double delta = i - *pmean;
    sum2 += tmp * delta * delta;
  }
  *pvari = sum2 / (sum0 - 1);
}


x86 assembly (clang, -O0):
<compute_mean_and_vari_from_hist>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1174 <compute_mean_and_vari_from_hist+0x74>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    112a <compute_mean_and_vari_from_hist+0x2a>
movq   -0x30(%rbp),%xmm0
movaps 0xe80(%rip),%xmm3
punpckldq %xmm3,%xmm0
movapd 0xe84(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movq   -0x28(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1251 <compute_mean_and_vari_from_hist+0x151>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movaps 0xdf9(%rip),%xmm1
movq   -0x58(%rbp),%xmm0
punpckldq %xmm1,%xmm0
movapd 0xdf8(%rip),%xmm1
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11ce <compute_mean_and_vari_from_hist+0xce>
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
movq   %rax,%xmm1
movaps 0xd96(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xd9a(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_mean_and_vari_from_hist>:
test   %edi,%edi
jle    111a <compute_mean_and_vari_from_hist+0x1a>
mov    %edi,%r8d
cmp    $0x4,%edi
jae    1133 <compute_mean_and_vari_from_hist+0x33>
xor    %r9d,%r9d
xor    %r10d,%r10d
xor    %r11d,%r11d
jmp    1380 <compute_mean_and_vari_from_hist+0x280>
movabs $0x7ff8000000000000,%rax
mov    %rax,(%rdx)
xorpd  %xmm0,%xmm0
xor    %r10d,%r10d
jmp    14ba <compute_mean_and_vari_from_hist+0x3ba>
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     14e8 <compute_mean_and_vari_from_hist+0x3e8>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
pxor   %xmm12,%xmm12
movdqa 0xe99(%rip),%xmm15
xor    %eax,%eax
movdqa 0xe9e(%rip),%xmm8
movdqa 0xea5(%rip),%xmm9
movdqa 0xeac(%rip),%xmm10
movdqa 0xeb3(%rip),%xmm11
pxor   %xmm14,%xmm14
pxor   %xmm4,%xmm4
pxor   %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
movdqa %xmm15,%xmm3
paddq  %xmm8,%xmm3
movdqu (%rsi,%rax,8),%xmm1
movdqu 0x10(%rsi,%rax,8),%xmm7
movdqu 0x20(%rsi,%rax,8),%xmm0
movdqu 0x30(%rsi,%rax,8),%xmm13
paddq  %xmm1,%xmm12
paddq  %xmm7,%xmm14
movdqa %xmm15,%xmm6
psrlq  $0x20,%xmm6
pmuludq %xmm1,%xmm6
movdqa %xmm1,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm15,%xmm5
paddq  %xmm6,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm15,%xmm1
paddq  %xmm4,%xmm1
paddq  %xmm5,%xmm1
movdqa %xmm7,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm3,%xmm4
movdqa %xmm3,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm7,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm7,%xmm3
paddq  %xmm2,%xmm3
paddq  %xmm5,%xmm3
movdqa %xmm15,%xmm4
paddq  %xmm9,%xmm4
movdqa %xmm15,%xmm2
paddq  %xmm10,%xmm2
paddq  %xmm0,%xmm12
paddq  %xmm13,%xmm14
movdqa %xmm0,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm4,%xmm5
movdqa %xmm4,%xmm6
psrlq  $0x20,%xmm6
pmuludq %xmm0,%xmm6
paddq  %xmm5,%xmm6
psllq  $0x20,%xmm6
pmuludq %xmm0,%xmm4
paddq  %xmm6,%xmm4
paddq  %xmm1,%xmm4
movdqa %xmm13,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm2,%xmm0
movdqa %xmm2,%xmm1
psrlq  $0x20,%xmm1
pmuludq %xmm13,%xmm1
paddq  %xmm0,%xmm1
psllq  $0x20,%xmm1
pmuludq %xmm13,%xmm2
paddq  %xmm1,%xmm2
paddq  %xmm3,%xmm2
add    $0x8,%rax
paddq  %xmm11,%xmm15
add    $0xfffffffffffffffe,%r11
jne    11a0 <compute_mean_and_vari_from_hist+0xa0>
test   $0x1,%r10b
je     134c <compute_mean_and_vari_from_hist+0x24c>
movdqa 0xd3f(%rip),%xmm0
paddq  %xmm15,%xmm0
movdqu (%rsi,%rax,8),%xmm1
movdqu 0x10(%rsi,%rax,8),%xmm3
paddq  %xmm1,%xmm12
paddq  %xmm3,%xmm14
movdqa %xmm15,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm1,%xmm5
movdqa %xmm1,%xmm6
psrlq  $0x20,%xmm6
pmuludq %xmm15,%xmm6
paddq  %xmm5,%xmm6
psllq  $0x20,%xmm6
pmuludq %xmm15,%xmm1
paddq  %xmm6,%xmm1
paddq  %xmm1,%xmm4
movdqa %xmm3,%xmm1
psrlq  $0x20,%xmm1
pmuludq %xmm0,%xmm1
movdqa %xmm0,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm3,%xmm5
paddq  %xmm1,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm3,%xmm0
paddq  %xmm5,%xmm0
paddq  %xmm0,%xmm2
paddq  %xmm14,%xmm12
paddq  %xmm2,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddq  %xmm4,%xmm0
movq   %xmm0,%r11
pshufd $0xee,%xmm12,%xmm0
paddq  %xmm12,%xmm0
movq   %xmm0,%r10
cmp    %r8,%r9
je     1397 <compute_mean_and_vari_from_hist+0x297>
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%r9,8),%rax
add    %rax,%r10
imul   %r9,%rax
add    %rax,%r11
add    $0x1,%r9
cmp    %r9,%r8
jne    1380 <compute_mean_and_vari_from_hist+0x280>
movq   %r11,%xmm0
movdqa 0xcac(%rip),%xmm2
punpckldq %xmm2,%xmm0
movapd 0xcb0(%rip),%xmm3
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movq   %r10,%xmm0
punpckldq %xmm2,%xmm0
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
addsd  %xmm0,%xmm4
divsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx)
test   %edi,%edi
jle    13f5 <compute_mean_and_vari_from_hist+0x2f5>
cmp    $0x1,%edi
jne    13fe <compute_mean_and_vari_from_hist+0x2fe>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    147d <compute_mean_and_vari_from_hist+0x37d>
xorpd  %xmm0,%xmm0
jmp    14ba <compute_mean_and_vari_from_hist+0x3ba>
mov    %r8d,%edi
and    $0xfffffffe,%edi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
xorps  %xmm4,%xmm4
cvtsi2sd %edx,%xmm4
subsd  %xmm1,%xmm4
movq   (%rsi,%rdx,8),%xmm5
punpckldq %xmm2,%xmm5
subpd  %xmm3,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
lea    0x1(%rdx),%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
addsd  %xmm0,%xmm6
subsd  %xmm1,%xmm4
movq   0x8(%rsi,%rdx,8),%xmm5
punpckldq %xmm2,%xmm5
subpd  %xmm3,%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
addsd  %xmm5,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm6,%xmm0
add    $0x2,%rdx
cmp    %rdi,%rdx
jne    1410 <compute_mean_and_vari_from_hist+0x310>
test   $0x1,%r8b
je     14ba <compute_mean_and_vari_from_hist+0x3ba>
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
movsd  (%rsi,%rdx,8),%xmm3
unpcklps 0xbba(%rip),%xmm3
subsd  %xmm1,%xmm2
subpd  0xbbe(%rip),%xmm3
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0xffffffffffffffff,%r10
movq   %r10,%xmm1
punpckldq 0xb85(%rip),%xmm1
subpd  0xb8d(%rip),%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx)
ret
pxor   %xmm12,%xmm12
movdqa 0xb0a(%rip),%xmm15
xor    %eax,%eax
pxor   %xmm14,%xmm14
pxor   %xmm4,%xmm4
pxor   %xmm2,%xmm2
test   $0x1,%r10b
jne    12c9 <compute_mean_and_vari_from_hist+0x1c9>
jmp    134c <compute_mean_and_vari_from_hist+0x24c>

LLVM IR (-O0):
define void @compute_mean_and_vari_from_hist(i32 %0, i64* %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca i64*
%7 = alloca double*
%8 = alloca double*
%9 = alloca i64
%10 = alloca i64
%11 = alloca i32
%12 = alloca i64
%13 = alloca double
%14 = alloca i32
%15 = alloca i64
%16 = alloca double
store i32 %0, i32* %5
store i64* %1, i64** %6
store double* %2, double** %7
store double* %3, double** %8
store i64 0, i64* %9
store i64 0, i64* %10
store i32 0, i32* %11
br label %17
17: ; preds = %36, %4
%18 = load i32, i32* %11
%19 = load i32, i32* %5
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %39
21: ; preds = %17
%22 = load i64*, i64** %6
%23 = load i32, i32* %11
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i64, i64* %22, i64 %24
%26 = load i64, i64* %25
store i64 %26, i64* %12
%27 = load i64, i64* %12
%28 = load i64, i64* %9
%29 = add i64 %28, %27
store i64 %29, i64* %9
%30 = load i64, i64* %12
%31 = load i32, i32* %11
%32 = sext i32 %31 to i64
%33 = mul i64 %30, %32
%34 = load i64, i64* %10
%35 = add i64 %34, %33
store i64 %35, i64* %10
br label %36
36: ; preds = %21
%37 = load i32, i32* %11
%38 = add nsw i32 %37, 1
store i32 %38, i32* %11
br label %17
39: ; preds = %17
%40 = load i64, i64* %10
%41 = uitofp i64 %40 to double
%42 = load i64, i64* %9
%43 = uitofp i64 %42 to double
%44 = fdiv double %41, %43
%45 = load double*, double** %7
store double %44, double* %45
store double 0.000000e+00, double* %13
store i32 0, i32* %14
br label %46
46: ; preds = %68, %39
%47 = load i32, i32* %14
%48 = load i32, i32* %5
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %71
50: ; preds = %46
%51 = load i64*, i64** %6
%52 = load i32, i32* %14
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i64, i64* %51, i64 %53
%55 = load i64, i64* %54
store i64 %55, i64* %15
%56 = load i32, i32* %14
%57 = sitofp i32 %56 to double
%58 = load double*, double** %7
%59 = load double, double* %58
%60 = fsub double %57, %59
store double %60, double* %16
%61 = load i64, i64* %15
%62 = uitofp i64 %61 to double
%63 = load double, double* %16
%64 = fmul double %62, %63
%65 = load double, double* %16
%66 = load double, double* %13
%67 = call double @llvm.fmuladd.f64(double %64, double %65, double %66)
store double %67, double* %13
br label %68
68: ; preds = %50
%69 = load i32, i32* %14
%70 = add nsw i32 %69, 1
store i32 %70, i32* %14
br label %46
71: ; preds = %46
%72 = load double, double* %13
%73 = load i64, i64* %9
%74 = sub i64 %73, 1
%75 = uitofp i64 %74 to double
%76 = fdiv double %72, %75
%77 = load double*, double** %8
store double %76, double* %77
ret void
}

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