#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 */
long double logl(int);
void coulomb_transport_coefficients(double mu_, double fspin, int n_parameters,
                                    const double *screening,
                                    const long double *a, const long double *b,
                                    const long double *c, double *coefficient) {
  const long double S = fspin;
  const long double mu = mu_;
  const int n = n_parameters - 1;
  double cs0 = 0., cs1 = 0.;
  int i;
  for (i = 0; i < n; i++) {
    const long double alp = screening[i];
    const long double r = mu / (mu + alp);
    const long double L = logl(1. + mu / alp);
    const long double I0 = r / alp;
    const long double J0 = L;
    const long double I1 = L - r;
    const long double J1 = -alp * L;
    const long double I2 = mu + alp * (r - 2. * L);
    const long double J2 = alp * (alp * L - mu);
    cs0 += a[i] * (J0 - S * J1) + b[i] * (I0 - S * I1);
    cs1 += a[i] * (J1 - S * J2) + b[i] * (I1 - S * I2);
  }
  const long double N = screening[n];
  const long double r = mu / (mu + N);
  const long double L = logl(1. + mu / N);
  const long double I0 = r / N;
  const long double J0 = L;
  const long double I1 = L - r;
  const long double J1 = -N * L;
  const long double I2 = mu + N * (r - 2. * L);
  const long double J2 = N * (N * L - mu);
  const long double rn = 1. / (1. + mu / N);
  const long double K0 = (1. - rn) * (1. + rn) / (2 * N * N);
  const long double L0 =
      (1. - rn) * ((1. + rn) * (1. + rn) - rn) / (3 * N * N * N);
  const long double K1 = I0 - N * K0;
  const long double L1 = K0 - N * L0;
  const long double K2 = I1 - N * K1;
  const long double L2 = K1 - N * L1;
  cs0 += c[0] * (J0 - S * J1) + c[1] * (I0 - S * I1) + c[2] * (K0 - S * K1) +
         c[3] * (L0 - S * L1);
  cs1 += c[0] * (J1 - S * J2) + c[1] * (I1 - S * I2) + c[2] * (K1 - S * K2) +
         c[3] * (L1 - S * L2);
  coefficient[0] = cs0;
  coefficient[1] = 2 * cs1;
}


x86 assembly (clang, -O0):
<coulomb_transport_coefficients>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
fldl   -0x10(%rbp)
fstpt  -0x50(%rbp)
fldl   -0x8(%rbp)
fstpt  -0x60(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    131d <coulomb_transport_coefficients+0x20d>
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x90(%rbp)
fldt   -0x60(%rbp)
fldt   -0x90(%rbp)
fadd   %st(1),%st
fdivrp %st,%st(1)
fstpt  -0xa0(%rbp)
fldt   -0x60(%rbp)
fldt   -0x90(%rbp)
fdivrp %st,%st(1)
fld1
faddp  %st,%st(1)
fnstcw -0x232(%rbp)
movzwl -0x232(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x234(%rbp)
fldcw  -0x234(%rbp)
fistpl -0x224(%rbp)
fldcw  -0x232(%rbp)
mov    -0x224(%rbp),%edi
call   1030 <logl@plt>
fstpt  -0xb0(%rbp)
fldt   -0xa0(%rbp)
fldt   -0x90(%rbp)
fdivrp %st,%st(1)
fstpt  -0xc0(%rbp)
fldt   -0xb0(%rbp)
fstpt  -0xd0(%rbp)
fldt   -0xb0(%rbp)
fldt   -0xa0(%rbp)
fsubrp %st,%st(1)
fstpt  -0xe0(%rbp)
fldt   -0x90(%rbp)
fchs
fldt   -0xb0(%rbp)
fmulp  %st,%st(1)
fstpt  -0xf0(%rbp)
fldt   -0x60(%rbp)
fldt   -0x90(%rbp)
fldt   -0xa0(%rbp)
fldt   -0xb0(%rbp)
fadd   %st,%st(0)
fsubrp %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x100(%rbp)
fldt   -0x90(%rbp)
fldt   -0xb0(%rbp)
fldt   -0x60(%rbp)
fxch   %st(1)
fmul   %st(2),%st
fsubp  %st,%st(1)
fmulp  %st,%st(1)
fstpt  -0x110(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fldt   -0xd0(%rbp)
fldt   -0x50(%rbp)
fldt   -0xf0(%rbp)
fmul   %st(1),%st
fsubrp %st,%st(2)
mov    -0x30(%rbp),%rax
fldt   (%rax,%rcx,1)
fldt   -0xc0(%rbp)
fldt   -0xe0(%rbp)
fmulp  %st,%st(3)
fsubp  %st,%st(2)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldl   -0x70(%rbp)
faddp  %st,%st(1)
fstpl  -0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fldt   -0xf0(%rbp)
fldt   -0x50(%rbp)
fldt   -0x110(%rbp)
fmul   %st(1),%st
fsubrp %st,%st(2)
mov    -0x30(%rbp),%rax
fldt   (%rax,%rcx,1)
fldt   -0xe0(%rbp)
fldt   -0x100(%rbp)
fmulp  %st,%st(3)
fsubp  %st,%st(2)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldl   -0x78(%rbp)
faddp  %st,%st(1)
fstpl  -0x230(%rbp)
movsd  -0x230(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1168 <coulomb_transport_coefficients+0x58>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x120(%rbp)
fldt   -0x60(%rbp)
fldt   -0x120(%rbp)
fadd   %st(1),%st
fdivrp %st,%st(1)
fstpt  -0x130(%rbp)
fldt   -0x60(%rbp)
fldt   -0x120(%rbp)
fdivrp %st,%st(1)
fld1
fld    %st(0)
fstpt  -0x244(%rbp)
faddp  %st,%st(1)
fnstcw -0x236(%rbp)
movzwl -0x236(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x238(%rbp)
fldcw  -0x238(%rbp)
fistpl -0x214(%rbp)
fldcw  -0x236(%rbp)
mov    -0x214(%rbp),%edi
call   1030 <logl@plt>
fldt   -0x244(%rbp)
fxch   %st(1)
fstpt  -0x140(%rbp)
fldt   -0x130(%rbp)
fldt   -0x120(%rbp)
fdivrp %st,%st(1)
fstpt  -0x150(%rbp)
fldt   -0x140(%rbp)
fstpt  -0x160(%rbp)
fldt   -0x140(%rbp)
fldt   -0x130(%rbp)
fsubrp %st,%st(1)
fstpt  -0x170(%rbp)
fldt   -0x120(%rbp)
fchs
fldt   -0x140(%rbp)
fmulp  %st,%st(1)
fstpt  -0x180(%rbp)
fldt   -0x60(%rbp)
fldt   -0x120(%rbp)
fldt   -0x130(%rbp)
fldt   -0x140(%rbp)
fadd   %st,%st(0)
fsubrp %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x190(%rbp)
fldt   -0x120(%rbp)
fldt   -0x140(%rbp)
fldt   -0x60(%rbp)
fxch   %st(1)
fmul   %st(2),%st
fsubp  %st,%st(1)
fmulp  %st,%st(1)
fstpt  -0x1a0(%rbp)
fldt   -0x60(%rbp)
fldt   -0x120(%rbp)
fdivrp %st,%st(1)
fadd   %st(1),%st
fdivr  %st(1),%st
fstpt  -0x1b0(%rbp)
fldt   -0x1b0(%rbp)
fld    %st(1)
fsub   %st(1),%st
fxch   %st(1)
fadd   %st(2),%st
fmulp  %st,%st(1)
fldt   -0x120(%rbp)
fld    %st(0)
fadd   %st(1),%st
fmulp  %st,%st(1)
fdivrp %st,%st(1)
fstpt  -0x1c0(%rbp)
fldt   -0x1b0(%rbp)
fld    %st(1)
fsub   %st(1),%st
fxch   %st(2)
fadd   %st(1),%st
fmul   %st,%st(0)
fsubp  %st,%st(1)
fmulp  %st,%st(1)
fldt   -0x120(%rbp)
flds   0xb89(%rip)
fmul   %st(1),%st
fmul   %st(1),%st
fmulp  %st,%st(1)
fdivrp %st,%st(1)
fstpt  -0x1d0(%rbp)
fldt   -0x150(%rbp)
fldt   -0x120(%rbp)
fldt   -0x1c0(%rbp)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0x1e0(%rbp)
fldt   -0x1c0(%rbp)
fldt   -0x120(%rbp)
fldt   -0x1d0(%rbp)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0x1f0(%rbp)
fldt   -0x170(%rbp)
fldt   -0x120(%rbp)
fldt   -0x1e0(%rbp)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0x200(%rbp)
fldt   -0x1e0(%rbp)
fldt   -0x120(%rbp)
fldt   -0x1f0(%rbp)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0x210(%rbp)
mov    -0x38(%rbp),%rax
fldt   (%rax)
fldt   -0x160(%rbp)
fldt   -0x50(%rbp)
fldt   -0x180(%rbp)
fmul   %st(1),%st
fsubrp %st,%st(2)
fldt   0x10(%rax)
fldt   -0x150(%rbp)
fldt   -0x170(%rbp)
fmul   %st(3),%st
fsubrp %st,%st(1)
fmulp  %st,%st(1)
fxch   %st(3)
fmulp  %st,%st(2)
fxch   %st(1)
faddp  %st,%st(2)
fldt   0x20(%rax)
fldt   -0x1c0(%rbp)
fldt   -0x1e0(%rbp)
fmul   %st(3),%st
fsubrp %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(2)
fldt   0x30(%rax)
fldt   -0x1d0(%rbp)
fldt   -0x1f0(%rbp)
fmulp  %st,%st(3)
fsubp  %st,%st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldl   -0x70(%rbp)
faddp  %st,%st(1)
fstpl  -0x70(%rbp)
mov    -0x38(%rbp),%rax
fldt   (%rax)
fldt   -0x180(%rbp)
fldt   -0x50(%rbp)
fldt   -0x1a0(%rbp)
fmul   %st(1),%st
fsubrp %st,%st(2)
fldt   0x10(%rax)
fldt   -0x170(%rbp)
fldt   -0x190(%rbp)
fmul   %st(3),%st
fsubrp %st,%st(1)
fmulp  %st,%st(1)
fxch   %st(3)
fmulp  %st,%st(2)
fxch   %st(1)
faddp  %st,%st(2)
fldt   0x20(%rax)
fldt   -0x1e0(%rbp)
fldt   -0x200(%rbp)
fmul   %st(3),%st
fsubrp %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(2)
fldt   0x30(%rax)
fldt   -0x1f0(%rbp)
fldt   -0x210(%rbp)
fmulp  %st,%st(3)
fsubp  %st,%st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldl   -0x78(%rbp)
faddp  %st,%st(1)
fstpl  -0x220(%rbp)
movsd  -0x220(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0xa06(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,0x8(%rax)
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coulomb_transport_coefficients>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0xa8(%rsp)
mov    %r8,%r15
mov    %rsi,%rbx
movsd  %xmm1,0xd8(%rsp)
fldl   0xd8(%rsp)
movsd  %xmm0,0xe0(%rsp)
fldl   0xe0(%rsp)
lea    -0x1(%rdi),%eax
mov    %eax,0x4c(%rsp)
fld    %st(0)
fchs
fstpt  0x58(%rsp)
fxch   %st(1)
fchs
fstpt  0x9c(%rsp)
fldz
fld    %st(0)
cmp    $0x2,%edi
fld    %st(2)
fstpt  0x28(%rsp)
jl     12d2 <coulomb_transport_coefficients+0x1c2>
mov    %rcx,%r12
mov    %rdx,%r13
fstp   %st(1)
fstp   %st(0)
mov    0x4c(%rsp),%r14d
shl    $0x3,%r14
fldz
xor    %ebp,%ebp
fld    %st(0)
fxch   %st(1)
nopw   0x0(%rax,%rax,1)
fstpt  0x40(%rsp)
fstpt  0x90(%rsp)
fldl   (%rbx,%rbp,1)
fld    %st(0)
fstpt  0x84(%rsp)
fld    %st(1)
fadd   %st(1),%st
fdivr  %st(2),%st
fstpt  0x10(%rsp)
fdivrp %st,%st(1)
fld1
faddp  %st,%st(1)
fnstcw 0xa(%rsp)
movzwl 0xa(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0xe(%rsp)
fldcw  0xe(%rsp)
fistpl 0x68(%rsp)
fldcw  0xa(%rsp)
mov    0x68(%rsp),%edi
call   1030 <logl@plt>
fldt   0x84(%rsp)
fldt   0x10(%rsp)
fld    %st(0)
fdiv   %st(2),%st
fstpt  0x34(%rsp)
fld    %st(2)
fadd   %st(3),%st
fsubr  %st(1),%st
fxch   %st(1)
fsubr  %st(3),%st
fld    %st(0)
fstpt  0x1c(%rsp)
fxch   %st(1)
fmul   %st(2),%st
fstpt  0x10(%rsp)
fld    %st(1)
fmul   %st(3),%st
fldt   0x58(%rsp)
faddp  %st,%st(1)
fmul   %st(2),%st
fxch   %st(2)
fchs
fmul   %st(3),%st
fldt   0x9c(%rsp)
fld    %st(0)
fmul   %st(2),%st
faddp  %st,%st(5)
fmul   %st,%st(2)
fldt   0x34(%rsp)
faddp  %st,%st(3)
fldt   (%r12,%rbp,2)
fmul   %st,%st(3)
fldt   0x0(%r13,%rbp,2)
fmul   %st,%st(6)
fxch   %st(6)
faddp  %st,%st(4)
fldt   0x40(%rsp)
faddp  %st,%st(4)
fxch   %st(3)
fstpl  0xd0(%rsp)
fmul   %st,%st(3)
fldt   0x28(%rsp)
fxch   %st(4)
faddp  %st,%st(2)
fldt   0x10(%rsp)
fadd   %st(4),%st
fmulp  %st,%st(1)
fldt   0x1c(%rsp)
faddp  %st,%st(1)
fmulp  %st,%st(2)
fmulp  %st,%st(3)
faddp  %st,%st(2)
movsd  0xd0(%rsp),%xmm0
fldt   0x90(%rsp)
faddp  %st,%st(2)
fxch   %st(1)
fstpl  0xc0(%rsp)
movsd  0xc0(%rsp),%xmm1
movsd  %xmm0,0xc8(%rsp)
fldl   0xc8(%rsp)
movsd  %xmm1,0xb8(%rsp)
fldl   0xb8(%rsp)
add    $0x8,%rbp
cmp    %rbp,%r14
fxch   %st(1)
jne    11a0 <coulomb_transport_coefficients+0x90>
fstpt  0x40(%rsp)
fstpt  0x90(%rsp)
movslq 0x4c(%rsp),%rax
fldl   (%rbx,%rax,8)
fld    %st(0)
fstpt  0x4c(%rsp)
fld    %st(1)
fadd   %st(1),%st
fdivr  %st(2),%st
fstpt  0x10(%rsp)
fdivrp %st,%st(1)
fld1
fld    %st(0)
fstpt  0x1c(%rsp)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x78(%rsp)
fnstcw 0x8(%rsp)
movzwl 0x8(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0xc(%rsp)
fldcw  0xc(%rsp)
fistpl 0x64(%rsp)
fldcw  0x8(%rsp)
mov    0x64(%rsp),%edi
call   1030 <logl@plt>
fld    %st(0)
fadd   %st(1),%st
fldt   0x10(%rsp)
fsubp  %st,%st(1)
fldt   0x4c(%rsp)
fmul   %st,%st(1)
fldt   0x28(%rsp)
faddp  %st,%st(2)
fxch   %st(1)
fstpt  0x84(%rsp)
fld    %st(0)
fmul   %st(2),%st
fldt   0x58(%rsp)
faddp  %st,%st(1)
fstpt  0x34(%rsp)
fldt   0x1c(%rsp)
fldt   0x78(%rsp)
fdivr  %st(1),%st
fld    %st(1)
fsub   %st(1),%st
fxch   %st(2)
fadd   %st(1),%st
fld    %st(3)
fadd   %st(4),%st
fmul   %st(4),%st
fld    %st(3)
fmul   %st(2),%st
fdivp  %st,%st(1)
fld    %st(0)
fstpt  0x6c(%rsp)
fxch   %st(1)
fmul   %st,%st(0)
fsubp  %st,%st(2)
fxch   %st(2)
fmulp  %st,%st(1)
fld    %st(2)
fmuls  0xc6e(%rip)
fmul   %st(3),%st
fmul   %st(3),%st
fdivrp %st,%st(1)
fstpt  0x28(%rsp)
fld    %st(1)
fchs
fmul   %st(3),%st
fld    %st(0)
fstpt  0x1c(%rsp)
fldt   0x9c(%rsp)
fmul   %st,%st(1)
fxch   %st(1)
fadd   %st(4),%st
fldt   0x10(%rsp)
fsubr  %st,%st(5)
fld    %st(5)
fstpt  0x78(%rsp)
fdiv   %st(4),%st
fxch   %st(3)
fmul   %st(4),%st
fsubr  %st(3),%st
fxch   %st(5)
fmul   %st(2),%st
faddp  %st,%st(3)
fldt   0x10(%r15)
fld    %st(0)
fstpt  0x10(%rsp)
fmulp  %st,%st(3)
fldt   (%r15)
fld    %st(0)
fstpt  0x58(%rsp)
fmulp  %st,%st(1)
faddp  %st,%st(2)
fxch   %st(1)
fstpt  0xec(%rsp)
fldt   0x28(%rsp)
fld    %st(2)
fmul   %st(1),%st
fldt   0x6c(%rsp)
fsub   %st,%st(1)
fld    %st(3)
fmul   %st(6),%st
faddp  %st,%st(1)
fldt   0x20(%r15)
fld    %st(0)
fstpt  0x6c(%rsp)
fmulp  %st,%st(1)
fldt   0xec(%rsp)
faddp  %st,%st(1)
fld    %st(3)
fmul   %st(2),%st
faddp  %st,%st(3)
fldt   0x30(%r15)
fld    %st(0)
fstpt  0x28(%rsp)
fmulp  %st,%st(3)
faddp  %st,%st(2)
fldt   0x40(%rsp)
faddp  %st,%st(2)
fxch   %st(1)
fstpt  0x40(%rsp)
fldt   0x34(%rsp)
fmul   %st(3),%st
fmul   %st(2),%st
fldt   0x1c(%rsp)
faddp  %st,%st(1)
fstpt  0x34(%rsp)
fld    %st(2)
fmul   %st(4),%st
fldt   0x78(%rsp)
fsub   %st,%st(1)
fxch   %st(1)
fstpt  0x1c(%rsp)
fldt   0x84(%rsp)
fmul   %st(3),%st
faddp  %st,%st(1)
fldt   0x10(%rsp)
fmulp  %st,%st(1)
fldt   0x58(%rsp)
fldt   0x34(%rsp)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fxch   %st(3)
fmul   %st(1),%st
fsubr  %st(4),%st
fldt   0x1c(%rsp)
fmul   %st(3),%st
faddp  %st,%st(5)
fldt   0x6c(%rsp)
fmulp  %st,%st(5)
fxch   %st(4)
faddp  %st,%st(3)
fxch   %st(1)
fmulp  %st,%st(3)
faddp  %st,%st(2)
fldt   0x28(%rsp)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fldt   0x90(%rsp)
faddp  %st,%st(1)
fstpl  0xb0(%rsp)
movsd  0xb0(%rsp),%xmm0
mov    0xa8(%rsp),%rax
fldt   0x40(%rsp)
fstpl  (%rax)
addsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @coulomb_transport_coefficients(double %0, double %1, i32 %2, double* %3, x86_fp80* %4, x86_fp80* %5, x86_fp80* %6, double* %7) {
%9 = alloca double
%10 = alloca double
%11 = alloca i32
%12 = alloca double*
%13 = alloca x86_fp80*
%14 = alloca x86_fp80*
%15 = alloca x86_fp80*
%16 = alloca double*
%17 = alloca x86_fp80
%18 = alloca x86_fp80
%19 = alloca i32
%20 = alloca double
%21 = alloca double
%22 = alloca i32
%23 = alloca x86_fp80
%24 = alloca x86_fp80
%25 = alloca x86_fp80
%26 = alloca x86_fp80
%27 = alloca x86_fp80
%28 = alloca x86_fp80
%29 = alloca x86_fp80
%30 = alloca x86_fp80
%31 = alloca x86_fp80
%32 = alloca x86_fp80
%33 = alloca x86_fp80
%34 = alloca x86_fp80
%35 = alloca x86_fp80
%36 = alloca x86_fp80
%37 = alloca x86_fp80
%38 = alloca x86_fp80
%39 = alloca x86_fp80
%40 = alloca x86_fp80
%41 = alloca x86_fp80
%42 = alloca x86_fp80
%43 = alloca x86_fp80
%44 = alloca x86_fp80
%45 = alloca x86_fp80
%46 = alloca x86_fp80
%47 = alloca x86_fp80
store double %0, double* %9
store double %1, double* %10
store i32 %2, i32* %11
store double* %3, double** %12
store x86_fp80* %4, x86_fp80** %13
store x86_fp80* %5, x86_fp80** %14
store x86_fp80* %6, x86_fp80** %15
store double* %7, double** %16
%48 = load double, double* %10
%49 = fpext double %48 to x86_fp80
store x86_fp80 %49, x86_fp80* %17
%50 = load double, double* %9
%51 = fpext double %50 to x86_fp80
store x86_fp80 %51, x86_fp80* %18
%52 = load i32, i32* %11
%53 = sub nsw i32 %52, 1
store i32 %53, i32* %19
store double 0.000000e+00, double* %20
store double 0.000000e+00, double* %21
store i32 0, i32* %22
br label %54
54: ; preds = %152, %8
%55 = load i32, i32* %22
%56 = load i32, i32* %19
%57 = icmp slt i32 %55, %56
br i1 %57, label %58, label %155
58: ; preds = %54
%59 = load double*, double** %12
%60 = load i32, i32* %22
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = fpext double %63 to x86_fp80
store x86_fp80 %64, x86_fp80* %23
%65 = load x86_fp80, x86_fp80* %18
%66 = load x86_fp80, x86_fp80* %18
%67 = load x86_fp80, x86_fp80* %23
%68 = fadd x86_fp80 %66, %67
%69 = fdiv x86_fp80 %65, %68
store x86_fp80 %69, x86_fp80* %24
%70 = load x86_fp80, x86_fp80* %18
%71 = load x86_fp80, x86_fp80* %23
%72 = fdiv x86_fp80 %70, %71
%73 = fadd x86_fp80 0xK3FFF8000000000000000, %72
%74 = fptosi x86_fp80 %73 to i32
%75 = call x86_fp80 @logl(i32 %74)
store x86_fp80 %75, x86_fp80* %25
%76 = load x86_fp80, x86_fp80* %24
%77 = load x86_fp80, x86_fp80* %23
%78 = fdiv x86_fp80 %76, %77
store x86_fp80 %78, x86_fp80* %26
%79 = load x86_fp80, x86_fp80* %25
store x86_fp80 %79, x86_fp80* %27
%80 = load x86_fp80, x86_fp80* %25
%81 = load x86_fp80, x86_fp80* %24
%82 = fsub x86_fp80 %80, %81
store x86_fp80 %82, x86_fp80* %28
%83 = load x86_fp80, x86_fp80* %23
%84 = fneg x86_fp80 %83
%85 = load x86_fp80, x86_fp80* %25
%86 = fmul x86_fp80 %84, %85
store x86_fp80 %86, x86_fp80* %29
%87 = load x86_fp80, x86_fp80* %18
%88 = load x86_fp80, x86_fp80* %23
%89 = load x86_fp80, x86_fp80* %24
%90 = load x86_fp80, x86_fp80* %25
%91 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xKC0008000000000000000, x86_fp80 %90, x86_fp80 %89)
%92 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %88, x86_fp80 %91, x86_fp80 %87)
store x86_fp80 %92, x86_fp80* %30
%93 = load x86_fp80, x86_fp80* %23
%94 = load x86_fp80, x86_fp80* %23
%95 = load x86_fp80, x86_fp80* %25
%96 = load x86_fp80, x86_fp80* %18
%97 = fneg x86_fp80 %96
%98 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %94, x86_fp80 %95, x86_fp80 %97)
%99 = fmul x86_fp80 %93, %98
store x86_fp80 %99, x86_fp80* %31
%100 = load x86_fp80*, x86_fp80** %13
%101 = load i32, i32* %22
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds x86_fp80, x86_fp80* %100, i64 %102
%104 = load x86_fp80, x86_fp80* %103
%105 = load x86_fp80, x86_fp80* %27
%106 = load x86_fp80, x86_fp80* %17
%107 = load x86_fp80, x86_fp80* %29
%108 = fneg x86_fp80 %106
%109 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %108, x86_fp80 %107, x86_fp80 %105)
%110 = load x86_fp80*, x86_fp80** %14
%111 = load i32, i32* %22
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds x86_fp80, x86_fp80* %110, i64 %112
%114 = load x86_fp80, x86_fp80* %113
%115 = load x86_fp80, x86_fp80* %26
%116 = load x86_fp80, x86_fp80* %17
%117 = load x86_fp80, x86_fp80* %28
%118 = fneg x86_fp80 %116
%119 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %118, x86_fp80 %117, x86_fp80 %115)
%120 = fmul x86_fp80 %114, %119
%121 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %104, x86_fp80 %109, x86_fp80 %120)
%122 = load double, double* %20
%123 = fpext double %122 to x86_fp80
%124 = fadd x86_fp80 %123, %121
%125 = fptrunc x86_fp80 %124 to double
store double %125, double* %20
%126 = load x86_fp80*, x86_fp80** %13
%127 = load i32, i32* %22
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds x86_fp80, x86_fp80* %126, i64 %128
%130 = load x86_fp80, x86_fp80* %129
%131 = load x86_fp80, x86_fp80* %29
%132 = load x86_fp80, x86_fp80* %17
%133 = load x86_fp80, x86_fp80* %31
%134 = fneg x86_fp80 %132
%135 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %134, x86_fp80 %133, x86_fp80 %131)
%136 = load x86_fp80*, x86_fp80** %14
%137 = load i32, i32* %22
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds x86_fp80, x86_fp80* %136, i64 %138
%140 = load x86_fp80, x86_fp80* %139
%141 = load x86_fp80, x86_fp80* %28
%142 = load x86_fp80, x86_fp80* %17
%143 = load x86_fp80, x86_fp80* %30
%144 = fneg x86_fp80 %142
%145 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %144, x86_fp80 %143, x86_fp80 %141)
%146 = fmul x86_fp80 %140, %145
%147 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %130, x86_fp80 %135, x86_fp80 %146)
%148 = load double, double* %21
%149 = fpext double %148 to x86_fp80
%150 = fadd x86_fp80 %149, %147
%151 = fptrunc x86_fp80 %150 to double
store double %151, double* %21
br label %152
152: ; preds = %58
%153 = load i32, i32* %22
%154 = add nsw i32 %153, 1
store i32 %154, i32* %22
br label %54
155: ; preds = %54
%156 = load double*, double** %12
%157 = load i32, i32* %19
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = fpext double %160 to x86_fp80
store x86_fp80 %161, x86_fp80* %32
%162 = load x86_fp80, x86_fp80* %18
%163 = load x86_fp80, x86_fp80* %18
%164 = load x86_fp80, x86_fp80* %32
%165 = fadd x86_fp80 %163, %164
%166 = fdiv x86_fp80 %162, %165
store x86_fp80 %166, x86_fp80* %33
%167 = load x86_fp80, x86_fp80* %18
%168 = load x86_fp80, x86_fp80* %32
%169 = fdiv x86_fp80 %167, %168
%170 = fadd x86_fp80 0xK3FFF8000000000000000, %169
%171 = fptosi x86_fp80 %170 to i32
%172 = call x86_fp80 @logl(i32 %171)
store x86_fp80 %172, x86_fp80* %34
%173 = load x86_fp80, x86_fp80* %33
%174 = load x86_fp80, x86_fp80* %32
%175 = fdiv x86_fp80 %173, %174
store x86_fp80 %175, x86_fp80* %35
%176 = load x86_fp80, x86_fp80* %34
store x86_fp80 %176, x86_fp80* %36
%177 = load x86_fp80, x86_fp80* %34
%178 = load x86_fp80, x86_fp80* %33
%179 = fsub x86_fp80 %177, %178
store x86_fp80 %179, x86_fp80* %37
%180 = load x86_fp80, x86_fp80* %32
%181 = fneg x86_fp80 %180
%182 = load x86_fp80, x86_fp80* %34
%183 = fmul x86_fp80 %181, %182
store x86_fp80 %183, x86_fp80* %38
%184 = load x86_fp80, x86_fp80* %18
%185 = load x86_fp80, x86_fp80* %32
%186 = load x86_fp80, x86_fp80* %33
%187 = load x86_fp80, x86_fp80* %34
%188 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xKC0008000000000000000, x86_fp80 %187, x86_fp80 %186)
%189 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %185, x86_fp80 %188, x86_fp80 %184)
store x86_fp80 %189, x86_fp80* %39
%190 = load x86_fp80, x86_fp80* %32
%191 = load x86_fp80, x86_fp80* %32
%192 = load x86_fp80, x86_fp80* %34
%193 = load x86_fp80, x86_fp80* %18
%194 = fneg x86_fp80 %193
%195 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %191, x86_fp80 %192, x86_fp80 %194)
%196 = fmul x86_fp80 %190, %195
store x86_fp80 %196, x86_fp80* %40
%197 = load x86_fp80, x86_fp80* %18
%198 = load x86_fp80, x86_fp80* %32
%199 = fdiv x86_fp80 %197, %198
%200 = fadd x86_fp80 0xK3FFF8000000000000000, %199
%201 = fdiv x86_fp80 0xK3FFF8000000000000000, %200
store x86_fp80 %201, x86_fp80* %41
%202 = load x86_fp80, x86_fp80* %41
%203 = fsub x86_fp80 0xK3FFF8000000000000000, %202
%204 = load x86_fp80, x86_fp80* %41
%205 = fadd x86_fp80 0xK3FFF8000000000000000, %204
%206 = fmul x86_fp80 %203, %205
%207 = load x86_fp80, x86_fp80* %32
%208 = fmul x86_fp80 0xK40008000000000000000, %207
%209 = load x86_fp80, x86_fp80* %32
%210 = fmul x86_fp80 %208, %209
%211 = fdiv x86_fp80 %206, %210
store x86_fp80 %211, x86_fp80* %42
%212 = load x86_fp80, x86_fp80* %41
%213 = fsub x86_fp80 0xK3FFF8000000000000000, %212
%214 = load x86_fp80, x86_fp80* %41
%215 = fadd x86_fp80 0xK3FFF8000000000000000, %214
%216 = load x86_fp80, x86_fp80* %41
%217 = fadd x86_fp80 0xK3FFF8000000000000000, %216
%218 = load x86_fp80, x86_fp80* %41
%219 = fneg x86_fp80 %218
%220 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %215, x86_fp80 %217, x86_fp80 %219)
%221 = fmul x86_fp80 %213, %220
%222 = load x86_fp80, x86_fp80* %32
%223 = fmul x86_fp80 0xK4000C000000000000000, %222
%224 = load x86_fp80, x86_fp80* %32
%225 = fmul x86_fp80 %223, %224
%226 = load x86_fp80, x86_fp80* %32
%227 = fmul x86_fp80 %225, %226
%228 = fdiv x86_fp80 %221, %227
store x86_fp80 %228, x86_fp80* %43
%229 = load x86_fp80, x86_fp80* %35
%230 = load x86_fp80, x86_fp80* %32
%231 = load x86_fp80, x86_fp80* %42
%232 = fneg x86_fp80 %230
%233 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %232, x86_fp80 %231, x86_fp80 %229)
store x86_fp80 %233, x86_fp80* %44
%234 = load x86_fp80, x86_fp80* %42
%235 = load x86_fp80, x86_fp80* %32
%236 = load x86_fp80, x86_fp80* %43
%237 = fneg x86_fp80 %235
%238 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %237, x86_fp80 %236, x86_fp80 %234)
store x86_fp80 %238, x86_fp80* %45
%239 = load x86_fp80, x86_fp80* %37
%240 = load x86_fp80, x86_fp80* %32
%241 = load x86_fp80, x86_fp80* %44
%242 = fneg x86_fp80 %240
%243 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %242, x86_fp80 %241, x86_fp80 %239)
store x86_fp80 %243, x86_fp80* %46
%244 = load x86_fp80, x86_fp80* %44
%245 = load x86_fp80, x86_fp80* %32
%246 = load x86_fp80, x86_fp80* %45
%247 = fneg x86_fp80 %245
%248 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %247, x86_fp80 %246, x86_fp80 %244)
store x86_fp80 %248, x86_fp80* %47
%249 = load x86_fp80*, x86_fp80** %15
%250 = getelementptr inbounds x86_fp80, x86_fp80* %249, i64 0
%251 = load x86_fp80, x86_fp80* %250
%252 = load x86_fp80, x86_fp80* %36
%253 = load x86_fp80, x86_fp80* %17
%254 = load x86_fp80, x86_fp80* %38
%255 = fneg x86_fp80 %253
%256 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %255, x86_fp80 %254, x86_fp80 %252)
%257 = load x86_fp80*, x86_fp80** %15
%258 = getelementptr inbounds x86_fp80, x86_fp80* %257, i64 1
%259 = load x86_fp80, x86_fp80* %258
%260 = load x86_fp80, x86_fp80* %35
%261 = load x86_fp80, x86_fp80* %17
%262 = load x86_fp80, x86_fp80* %37
%263 = fneg x86_fp80 %261
%264 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %263, x86_fp80 %262, x86_fp80 %260)
%265 = fmul x86_fp80 %259, %264
%266 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %251, x86_fp80 %256, x86_fp80 %265)
%267 = load x86_fp80*, x86_fp80** %15
%268 = getelementptr inbounds x86_fp80, x86_fp80* %267, i64 2
%269 = load x86_fp80, x86_fp80* %268
%270 = load x86_fp80, x86_fp80* %42
%271 = load x86_fp80, x86_fp80* %17
%272 = load x86_fp80, x86_fp80* %44
%273 = fneg x86_fp80 %271
%274 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %273, x86_fp80 %272, x86_fp80 %270)
%275 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %269, x86_fp80 %274, x86_fp80 %266)
%276 = load x86_fp80*, x86_fp80** %15
%277 = getelementptr inbounds x86_fp80, x86_fp80* %276, i64 3
%278 = load x86_fp80, x86_fp80* %277
%279 = load x86_fp80, x86_fp80* %43
%280 = load x86_fp80, x86_fp80* %17
%281 = load x86_fp80, x86_fp80* %45
%282 = fneg x86_fp80 %280
%283 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %282, x86_fp80 %281, x86_fp80 %279)
%284 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %278, x86_fp80 %283, x86_fp80 %275)
%285 = load double, double* %20
%286 = fpext double %285 to x86_fp80
%287 = fadd x86_fp80 %286, %284
%288 = fptrunc x86_fp80 %287 to double
store double %288, double* %20
%289 = load x86_fp80*, x86_fp80** %15
%290 = getelementptr inbounds x86_fp80, x86_fp80* %289, i64 0
%291 = load x86_fp80, x86_fp80* %290
%292 = load x86_fp80, x86_fp80* %38
%293 = load x86_fp80, x86_fp80* %17
%294 = load x86_fp80, x86_fp80* %40
%295 = fneg x86_fp80 %293
%296 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %295, x86_fp80 %294, x86_fp80 %292)
%297 = load x86_fp80*, x86_fp80** %15
%298 = getelementptr inbounds x86_fp80, x86_fp80* %297, i64 1
%299 = load x86_fp80, x86_fp80* %298
%300 = load x86_fp80, x86_fp80* %37
%301 = load x86_fp80, x86_fp80* %17
%302 = load x86_fp80, x86_fp80* %39
%303 = fneg x86_fp80 %301
%304 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %303, x86_fp80 %302, x86_fp80 %300)
%305 = fmul x86_fp80 %299, %304
%306 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %291, x86_fp80 %296, x86_fp80 %305)
%307 = load x86_fp80*, x86_fp80** %15
%308 = getelementptr inbounds x86_fp80, x86_fp80* %307, i64 2
%309 = load x86_fp80, x86_fp80* %308
%310 = load x86_fp80, x86_fp80* %44
%311 = load x86_fp80, x86_fp80* %17
%312 = load x86_fp80, x86_fp80* %46
%313 = fneg x86_fp80 %311
%314 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %313, x86_fp80 %312, x86_fp80 %310)
%315 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %309, x86_fp80 %314, x86_fp80 %306)
%316 = load x86_fp80*, x86_fp80** %15
%317 = getelementptr inbounds x86_fp80, x86_fp80* %316, i64 3
%318 = load x86_fp80, x86_fp80* %317
%319 = load x86_fp80, x86_fp80* %45
%320 = load x86_fp80, x86_fp80* %17
%321 = load x86_fp80, x86_fp80* %47
%322 = fneg x86_fp80 %320
%323 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %322, x86_fp80 %321, x86_fp80 %319)
%324 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %318, x86_fp80 %323, x86_fp80 %315)
%325 = load double, double* %21
%326 = fpext double %325 to x86_fp80
%327 = fadd x86_fp80 %326, %324
%328 = fptrunc x86_fp80 %327 to double
store double %328, double* %21
%329 = load double, double* %20
%330 = load double*, double** %16
%331 = getelementptr inbounds double, double* %330, i64 0
store double %329, double* %331
%332 = load double, double* %21
%333 = fmul double 2.000000e+00, %332
%334 = load double*, double** %16
%335 = getelementptr inbounds double, double* %334, i64 1
store double %333, double* %335
ret void
}

LLVM IR (-O2):
define void @coulomb_transport_coefficients(double %0, double %1, i32 %2, double* nocapture %3, x86_fp80* nocapture %4, x86_fp80* nocapture %5, x86_fp80* nocapture %6, double* nocapture writeonly %7) {
%9 = fpext double %1 to x86_fp80
%10 = fpext double %0 to x86_fp80
%11 = add i32 %2, -1
%12 = icmp sgt i32 %2, 1
%13 = fneg x86_fp80 %10
%14 = fneg x86_fp80 %9
br i1 %12, label %15, label %58
15: ; preds = %8
%16 = zext i32 %11 to i64
br label %17
17: ; preds = %15, %17
%18 = phi i64 [ 0, %15 ], [ %54, %17 ]
%19 = phi x86_fp80 [ 0xK00000000000000000000, %15 ], [ %55, %17 ]
%20 = phi x86_fp80 [ 0xK00000000000000000000, %15 ], [ %56, %17 ]
%21 = getelementptr inbounds double, double* %3, i64 %18
%22 = load double, double* %21
%23 = fpext double %22 to x86_fp80
%24 = fadd x86_fp80 %10, %23
%25 = fdiv x86_fp80 %10, %24
%26 = fdiv x86_fp80 %10, %23
%27 = fadd x86_fp80 %26, 0xK3FFF8000000000000000
%28 = fptosi x86_fp80 %27 to i32
%29 = tail call x86_fp80 @logl(i32 %28)
%30 = fdiv x86_fp80 %25, %23
%31 = fsub x86_fp80 %29, %25
%32 = fneg x86_fp80 %23
%33 = fmul x86_fp80 %29, %32
%34 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %29, x86_fp80 0xKC0008000000000000000, x86_fp80 %25)
%35 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %23, x86_fp80 %34, x86_fp80 %10)
%36 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %23, x86_fp80 %29, x86_fp80 %13)
%37 = fmul x86_fp80 %36, %23
%38 = getelementptr inbounds x86_fp80, x86_fp80* %4, i64 %18
%39 = load x86_fp80, x86_fp80* %38
%40 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %33, x86_fp80 %29)
%41 = getelementptr inbounds x86_fp80, x86_fp80* %5, i64 %18
%42 = load x86_fp80, x86_fp80* %41
%43 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %31, x86_fp80 %30)
%44 = fmul x86_fp80 %42, %43
%45 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %39, x86_fp80 %40, x86_fp80 %44)
%46 = fadd x86_fp80 %19, %45
%47 = fptrunc x86_fp80 %46 to double
%48 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %37, x86_fp80 %33)
%49 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %35, x86_fp80 %31)
%50 = fmul x86_fp80 %42, %49
%51 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %39, x86_fp80 %48, x86_fp80 %50)
%52 = fadd x86_fp80 %20, %51
%53 = fptrunc x86_fp80 %52 to double
%54 = add nuw nsw i64 %18, 1
%55 = fpext double %47 to x86_fp80
%56 = fpext double %53 to x86_fp80
%57 = icmp eq i64 %54, %16
br i1 %57, label %58, label %17
58: ; preds = %17, %8
%59 = phi x86_fp80 [ 0xK00000000000000000000, %8 ], [ %56, %17 ]
%60 = phi x86_fp80 [ 0xK00000000000000000000, %8 ], [ %55, %17 ]
%61 = sext i32 %11 to i64
%62 = getelementptr inbounds double, double* %3, i64 %61
%63 = load double, double* %62
%64 = fpext double %63 to x86_fp80
%65 = fadd x86_fp80 %10, %64
%66 = fdiv x86_fp80 %10, %65
%67 = fdiv x86_fp80 %10, %64
%68 = fadd x86_fp80 %67, 0xK3FFF8000000000000000
%69 = fptosi x86_fp80 %68 to i32
%70 = tail call x86_fp80 @logl(i32 %69)
%71 = fdiv x86_fp80 %66, %64
%72 = fsub x86_fp80 %70, %66
%73 = fneg x86_fp80 %64
%74 = fmul x86_fp80 %70, %73
%75 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %70, x86_fp80 0xKC0008000000000000000, x86_fp80 %66)
%76 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 %75, x86_fp80 %10)
%77 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 %70, x86_fp80 %13)
%78 = fmul x86_fp80 %77, %64
%79 = fdiv x86_fp80 0xK3FFF8000000000000000, %68
%80 = fsub x86_fp80 0xK3FFF8000000000000000, %79
%81 = fadd x86_fp80 %79, 0xK3FFF8000000000000000
%82 = fmul x86_fp80 %80, %81
%83 = fmul x86_fp80 %64, 0xK40008000000000000000
%84 = fmul x86_fp80 %83, %64
%85 = fdiv x86_fp80 %82, %84
%86 = fneg x86_fp80 %79
%87 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %81, x86_fp80 %81, x86_fp80 %86)
%88 = fmul x86_fp80 %80, %87
%89 = fmul x86_fp80 %64, 0xK4000C000000000000000
%90 = fmul x86_fp80 %89, %64
%91 = fmul x86_fp80 %90, %64
%92 = fdiv x86_fp80 %88, %91
%93 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %73, x86_fp80 %85, x86_fp80 %71)
%94 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %73, x86_fp80 %92, x86_fp80 %85)
%95 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %73, x86_fp80 %93, x86_fp80 %72)
%96 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %73, x86_fp80 %94, x86_fp80 %93)
%97 = load x86_fp80, x86_fp80* %6
%98 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %74, x86_fp80 %70)
%99 = getelementptr inbounds x86_fp80, x86_fp80* %6, i64 1
%100 = load x86_fp80, x86_fp80* %99
%101 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %72, x86_fp80 %71)
%102 = fmul x86_fp80 %100, %101
%103 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %97, x86_fp80 %98, x86_fp80 %102)
%104 = getelementptr inbounds x86_fp80, x86_fp80* %6, i64 2
%105 = load x86_fp80, x86_fp80* %104
%106 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %93, x86_fp80 %85)
%107 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %105, x86_fp80 %106, x86_fp80 %103)
%108 = getelementptr inbounds x86_fp80, x86_fp80* %6, i64 3
%109 = load x86_fp80, x86_fp80* %108
%110 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %94, x86_fp80 %92)
%111 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %109, x86_fp80 %110, x86_fp80 %107)
%112 = fadd x86_fp80 %60, %111
%113 = fptrunc x86_fp80 %112 to double
%114 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %78, x86_fp80 %74)
%115 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %76, x86_fp80 %72)
%116 = fmul x86_fp80 %100, %115
%117 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %97, x86_fp80 %114, x86_fp80 %116)
%118 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %95, x86_fp80 %93)
%119 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %105, x86_fp80 %118, x86_fp80 %117)
%120 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %96, x86_fp80 %94)
%121 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %109, x86_fp80 %120, x86_fp80 %119)
%122 = fadd x86_fp80 %59, %121
%123 = fptrunc x86_fp80 %122 to double
store double %113, double* %7
%124 = fmul double %123, 2.000000e+00
%125 = getelementptr inbounds double, double* %7, i64 1
store double %124, double* %125
ret void
}