void DiscreteGammaMean(double rates[], const double alpha, const double beta,
                       const unsigned n_cat) {
  double lnga1;
  unsigned last_cat, i;
  double current;
  const double inv_two_beta = .5 / beta;
  const double d_n_cat = (double)n_cat;
  const double cat_freq = 1.0 / d_n_cat;
  double prop = cat_freq;
  double rate_sum = 0.0;
  double prev = 0.0;
  const double factor = (alpha * n_cat) / beta;
  assert(n_cat > 0);
  assert(rates != 0L);
  assert(alpha > 0.0);
  assert(beta > 0.0);
  if (n_cat < 2) {
    rates[0] = 1.0;
    return;
  }
  last_cat = n_cat - 1;
  lnga1 = LnGamma(alpha + 1.0);
  for (i = 0; i < last_cat; i++) {
    current = inv_two_beta * PointChi2(prop, 2.0 * alpha);
    current = IncompleteGamma(current * beta, alpha + 1, lnga1);
    rates[i] = (current - prev) * factor;
    rate_sum += rates[i];
    prev = current;
    prop += cat_freq;
  }
  rates[last_cat] = (1.0 - prev) * factor;
  rate_sum += rates[last_cat];
  rate_sum /= d_n_cat;
  for (i = 0; i < n_cat; ++i)
    rates[i] /= rate_sum;
}


x86 assembly (clang, -O0):
<DiscreteGammaMean>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xe97(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  0xe7c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x1c(%rbp),%eax
cvtsi2sd %rax,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,-0x1c(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpq   $0x0,-0x8(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpl   $0x2,-0x1c(%rbp)
jae    1246 <DiscreteGammaMean+0x106>
mov    -0x8(%rbp),%rax
movsd  0xdcb(%rip),%xmm0
movsd  %xmm0,(%rax)
jmp    13ba <DiscreteGammaMean+0x27a>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movsd  0xdb1(%rip),%xmm0
addsd  -0x10(%rbp),%xmm0
mov    $0x1,%al
call   1060 <LnGamma@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1338 <DiscreteGammaMean+0x1f8>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xd7a(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mov    $0x2,%al
call   1050 <PointChi2@plt>
movsd  -0x78(%rbp),%xmm0
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  0xd42(%rip),%xmm1
addsd  -0x10(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
mov    $0x3,%al
call   1030 <IncompleteGamma@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1273 <DiscreteGammaMean+0x133>
movsd  0xcc8(%rip),%xmm0
subsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    13ba <DiscreteGammaMean+0x27a>
movsd  -0x60(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1386 <DiscreteGammaMean+0x246>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DiscreteGammaMean>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %esi,%r14d
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,(%rsp)
mov    %rdi,%r12
xor    %edi,%edi
test   %esi,%esi
setne  %dil
xor    %eax,%eax
call   1040 <assert@plt>
xor    %edi,%edi
test   %r12,%r12
setne  %dil
xor    %eax,%eax
call   1040 <assert@plt>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
movsd  (%rsp),%xmm0
ucomisd %xmm1,%xmm0
seta   %dil
xor    %eax,%eax
call   1040 <assert@plt>
xor    %edi,%edi
movsd  0x8(%rsp),%xmm0
ucomisd 0xe6b(%rip),%xmm0
seta   %dil
xor    %eax,%eax
call   1040 <assert@plt>
cmp    $0x1,%r14d
ja     11c9 <DiscreteGammaMean+0x89>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12)
jmp    13c9 <DiscreteGammaMean+0x289>
movsd  0xe2f(%rip),%xmm2
mov    %r14d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x40(%rsp)
movsd  0xe14(%rip),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  %xmm1,0x28(%rsp)
movsd  (%rsp),%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
lea    -0x1(%r14),%r15d
movsd  0xde5(%rip),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x38(%rsp)
mov    $0x1,%al
call   1060 <LnGamma@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  (%rsp),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
movsd  0x10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
nop
movsd  %xmm0,0x20(%rsp)
movapd %xmm3,0x50(%rsp)
movsd  %xmm1,0x48(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  (%rsp),%xmm1
mov    $0x2,%al
call   1050 <PointChi2@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x40(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
mov    $0x3,%al
call   1030 <IncompleteGamma@plt>
movapd 0x50(%rsp),%xmm3
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm1,%xmm0
subsd  0x48(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
addsd  %xmm0,%xmm3
movsd  0x20(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1260 <DiscreteGammaMean+0x120>
movsd  0xd16(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r15,8)
addsd  %xmm1,%xmm3
divsd  0x28(%rsp),%xmm3
cmp    $0x2,%r14d
mov    $0x1,%eax
cmovae %r14d,%eax
cmp    $0x2,%eax
jae    1329 <DiscreteGammaMean+0x1e9>
xor    %ecx,%ecx
jmp    13b0 <DiscreteGammaMean+0x270>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     13d5 <DiscreteGammaMean+0x295>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd (%r12,%rsi,8),%xmm1
movupd 0x10(%r12,%rsi,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rsi,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%r12,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1360 <DiscreteGammaMean+0x220>
test   $0x1,%dl
je     13a1 <DiscreteGammaMean+0x261>
movupd (%r12,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rsi,8)
cmp    %rax,%rcx
je     13c9 <DiscreteGammaMean+0x289>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13b0 <DiscreteGammaMean+0x270>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %esi,%esi
test   $0x1,%dl
jne    1391 <DiscreteGammaMean+0x251>
jmp    13a1 <DiscreteGammaMean+0x261>

LLVM IR (-O0):
define void @DiscreteGammaMean(double* %0, double %1, double %2, i32 %3) {
%5 = alloca double*
%6 = alloca double
%7 = alloca double
%8 = alloca i32
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
store double* %0, double** %5
store double %1, double* %6
store double %2, double* %7
store i32 %3, i32* %8
%20 = load double, double* %7
%21 = fdiv double 5.000000e-01, %20
store double %21, double* %13
%22 = load i32, i32* %8
%23 = uitofp i32 %22 to double
store double %23, double* %14
%24 = load double, double* %14
%25 = fdiv double 1.000000e+00, %24
store double %25, double* %15
%26 = load double, double* %15
store double %26, double* %16
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %18
%27 = load double, double* %6
%28 = load i32, i32* %8
%29 = uitofp i32 %28 to double
%30 = fmul double %27, %29
%31 = load double, double* %7
%32 = fdiv double %30, %31
store double %32, double* %19
%33 = load i32, i32* %8
%34 = icmp ugt i32 %33, 0
%35 = zext i1 %34 to i32
%36 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %35)
%37 = load double*, double** %5
%38 = icmp ne double* %37, null
%39 = zext i1 %38 to i32
%40 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %39)
%41 = load double, double* %6
%42 = fcmp ogt double %41, 0.000000e+00
%43 = zext i1 %42 to i32
%44 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %43)
%45 = load double, double* %7
%46 = fcmp ogt double %45, 0.000000e+00
%47 = zext i1 %46 to i32
%48 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %47)
%49 = load i32, i32* %8
%50 = icmp ult i32 %49, 2
br i1 %50, label %51, label %54
51: ; preds = %4
%52 = load double*, double** %5
%53 = getelementptr inbounds double, double* %52, i64 0
store double 1.000000e+00, double* %53
br label %138
54: ; preds = %4
%55 = load i32, i32* %8
%56 = sub i32 %55, 1
store i32 %56, i32* %10
%57 = load double, double* %6
%58 = fadd double %57, 1.000000e+00
%59 = call i32 (double, ...) bitcast (i32 (...)* @LnGamma to i32 (double, ...)*)(double %58)
%60 = sitofp i32 %59 to double
store double %60, double* %9
store i32 0, i32* %11
br label %61
61: ; preds = %101, %54
%62 = load i32, i32* %11
%63 = load i32, i32* %10
%64 = icmp ult i32 %62, %63
br i1 %64, label %65, label %104
65: ; preds = %61
%66 = load double, double* %13
%67 = load double, double* %16
%68 = load double, double* %6
%69 = fmul double 2.000000e+00, %68
%70 = call i32 (double, double, ...) bitcast (i32 (...)* @PointChi2 to i32 (double, double, ...)*)(double %67, double %69)
%71 = sitofp i32 %70 to double
%72 = fmul double %66, %71
store double %72, double* %12
%73 = load double, double* %12
%74 = load double, double* %7
%75 = fmul double %73, %74
%76 = load double, double* %6
%77 = fadd double %76, 1.000000e+00
%78 = load double, double* %9
%79 = call i32 (double, double, double, ...) bitcast (i32 (...)* @IncompleteGamma to i32 (double, double, double, ...)*)(double %75, double %77, double %78)
%80 = sitofp i32 %79 to double
store double %80, double* %12
%81 = load double, double* %12
%82 = load double, double* %18
%83 = fsub double %81, %82
%84 = load double, double* %19
%85 = fmul double %83, %84
%86 = load double*, double** %5
%87 = load i32, i32* %11
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
store double %85, double* %89
%90 = load double*, double** %5
%91 = load i32, i32* %11
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
%94 = load double, double* %93
%95 = load double, double* %17
%96 = fadd double %95, %94
store double %96, double* %17
%97 = load double, double* %12
store double %97, double* %18
%98 = load double, double* %15
%99 = load double, double* %16
%100 = fadd double %99, %98
store double %100, double* %16
br label %101
101: ; preds = %65
%102 = load i32, i32* %11
%103 = add i32 %102, 1
store i32 %103, i32* %11
br label %61
104: ; preds = %61
%105 = load double, double* %18
%106 = fsub double 1.000000e+00, %105
%107 = load double, double* %19
%108 = fmul double %106, %107
%109 = load double*, double** %5
%110 = load i32, i32* %10
%111 = zext i32 %110 to i64
%112 = getelementptr inbounds double, double* %109, i64 %111
store double %108, double* %112
%113 = load double*, double** %5
%114 = load i32, i32* %10
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
%117 = load double, double* %116
%118 = load double, double* %17
%119 = fadd double %118, %117
store double %119, double* %17
%120 = load double, double* %14
%121 = load double, double* %17
%122 = fdiv double %121, %120
store double %122, double* %17
store i32 0, i32* %11
br label %123
123: ; preds = %135, %104
%124 = load i32, i32* %11
%125 = load i32, i32* %8
%126 = icmp ult i32 %124, %125
br i1 %126, label %127, label %138
127: ; preds = %123
%128 = load double, double* %17
%129 = load double*, double** %5
%130 = load i32, i32* %11
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = fdiv double %133, %128
store double %134, double* %132
br label %135
135: ; preds = %127
%136 = load i32, i32* %11
%137 = add i32 %136, 1
store i32 %137, i32* %11
br label %123
138: ; preds = %51, %123
ret void
}

LLVM IR (-O2):
define void @DiscreteGammaMean(double* %0, double %1, double %2, i32 %3) {
%5 = fdiv double 5.000000e-01, %2
%6 = uitofp i32 %3 to double
%7 = fdiv double 1.000000e+00, %6
%8 = fmul double %6, %1
%9 = fdiv double %8, %2
%10 = icmp ne i32 %3, 0
%11 = zext i1 %10 to i32
%12 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %11)
%13 = icmp ne double* %0, null
%14 = zext i1 %13 to i32
%15 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %14)
%16 = fcmp ogt double %1, 0.000000e+00
%17 = zext i1 %16 to i32
%18 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %17)
%19 = fcmp ogt double %2, 0.000000e+00
%20 = zext i1 %19 to i32
%21 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %20)
%22 = icmp ult i32 %3, 2
br i1 %22, label %23, label %24
23: ; preds = %4
store double 1.000000e+00, double* %0
br label %106
24: ; preds = %4
%25 = add i32 %3, -1
%26 = fadd double %1, 1.000000e+00
%27 = tail call i32 (double, ...) bitcast (i32 (...)* @LnGamma to i32 (double, ...)*)(double %26)
%28 = sitofp i32 %27 to double
%29 = fmul double %1, 2.000000e+00
%30 = zext i32 %25 to i64
br label %31
31: ; preds = %24, %31
%32 = phi i64 [ 0, %24 ], [ %47, %31 ]
%33 = phi double [ 0.000000e+00, %24 ], [ %41, %31 ]
%34 = phi double [ 0.000000e+00, %24 ], [ %45, %31 ]
%35 = phi double [ %7, %24 ], [ %46, %31 ]
%36 = tail call i32 (double, double, ...) bitcast (i32 (...)* @PointChi2 to i32 (double, double, ...)*)(double %35, double %29)
%37 = sitofp i32 %36 to double
%38 = fmul double %5, %37
%39 = fmul double %38, %2
%40 = tail call i32 (double, double, double, ...) bitcast (i32 (...)* @IncompleteGamma to i32 (double, double, double, ...)*)(double %39, double %26, double %28)
%41 = sitofp i32 %40 to double
%42 = fsub double %41, %33
%43 = fmul double %9, %42
%44 = getelementptr inbounds double, double* %0, i64 %32
store double %43, double* %44
%45 = fadd double %34, %43
%46 = fadd double %7, %35
%47 = add nuw nsw i64 %32, 1
%48 = icmp eq i64 %47, %30
br i1 %48, label %49, label %31
49: ; preds = %31
%50 = fsub double 1.000000e+00, %41
%51 = fmul double %9, %50
%52 = getelementptr inbounds double, double* %0, i64 %30
store double %51, double* %52
%53 = fadd double %45, %51
%54 = fdiv double %53, %6
%55 = call i32 @llvm.umax.i32(i32 %3, i32 1)
%56 = zext i32 %55 to i64
%57 = icmp ult i32 %55, 2
br i1 %57, label %97, label %58
58: ; preds = %49
%59 = and i64 %56, 4294967294
%60 = insertelement <2 x double> poison, double %54, i64 0
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> zeroinitializer
%62 = add nsw i64 %59, -2
%63 = lshr exact i64 %62, 1
%64 = add nuw i64 %63, 1
%65 = and i64 %64, 1
%66 = icmp eq i64 %62, 0
br i1 %66, label %86, label %67
67: ; preds = %58
%68 = and i64 %64, -2
br label %69
69: ; preds = %69, %67
%70 = phi i64 [ 0, %67 ], [ %83, %69 ]
%71 = phi i64 [ 0, %67 ], [ %84, %69 ]
%72 = getelementptr inbounds double, double* %0, i64 %70
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = fdiv <2 x double> %74, %61
%76 = bitcast double* %72 to <2 x double>*
store <2 x double> %75, <2 x double>* %76
%77 = or i64 %70, 2
%78 = getelementptr inbounds double, double* %0, i64 %77
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = fdiv <2 x double> %80, %61
%82 = bitcast double* %78 to <2 x double>*
store <2 x double> %81, <2 x double>* %82
%83 = add nuw i64 %70, 4
%84 = add nuw i64 %71, 2
%85 = icmp eq i64 %84, %68
br i1 %85, label %86, label %69
86: ; preds = %69, %58
%87 = phi i64 [ 0, %58 ], [ %83, %69 ]
%88 = icmp eq i64 %65, 0
br i1 %88, label %95, label %89
89: ; preds = %86
%90 = getelementptr inbounds double, double* %0, i64 %87
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = fdiv <2 x double> %92, %61
%94 = bitcast double* %90 to <2 x double>*
store <2 x double> %93, <2 x double>* %94
br label %95
95: ; preds = %86, %89
%96 = icmp eq i64 %59, %56
br i1 %96, label %106, label %97
97: ; preds = %49, %95
%98 = phi i64 [ 0, %49 ], [ %59, %95 ]
br label %99
99: ; preds = %97, %99
%100 = phi i64 [ %104, %99 ], [ %98, %97 ]
%101 = getelementptr inbounds double, double* %0, i64 %100
%102 = load double, double* %101
%103 = fdiv double %102, %54
store double %103, double* %101
%104 = add nuw nsw i64 %100, 1
%105 = icmp eq i64 %104, %56
br i1 %105, label %106, label %99
106: ; preds = %99, %95, %23
ret void
}