#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 */
typedef int /*<<< orphan*/ c;
typedef int /*<<< orphan*/ b;
typedef int /*<<< orphan*/ a;

/* Variables and functions */
int /*<<< orphan*/ memset(long double *, int, int const);
void coulomb_pole_reduction(int n_parameters, const double *amplitude,
                            const double *screening, long double *a,
                            long double *b, long double *c) {
  const int n = n_parameters - 1;
  memset(a, 0x0, n * sizeof(a[0]));
  memset(b, 0x0, n * sizeof(b[0]));
  memset(c, 0x0, 4 * sizeof(c[0]));
  int i, j;
  for (i = 0; i < n; i++) {
    const long double Ai = amplitude[i];
    const long double Bi = screening[i];
    b[i] = Ai * Ai;
    for (j = i + 1; j < n; j++) {
      const long double Aj = amplitude[j];
      const long double Bj = screening[j];
      const long double d = 2 * Ai * Aj / (Bj - Bi);
      a[i] += d;
      a[j] -= d;
    }
  }
  const long double N = screening[n];
  long double Sa[4] = {0, 0, 0, 0}, Sb[4] = {0, 0, 0, 0};
  for (i = 0; i < n; i++) {
    const long double Bi = screening[i];
    const long double x = 1. - Bi / N;
    long double r = x;
    for (j = 0; j < 4; j++) {
      Sa[j] += a[i] / r;
      r *= x;
      Sb[j] += b[i] / r;
    }
  }
  long double tmp = 1;
  for (i = 0; i < 4; i++) {
    c[i] = ((4 - i) * Sb[3 - i] / N - Sa[3 - i]) * tmp;
    tmp *= N;
  }
  for (i = 0; i < n; i++) {
    const long double Bi = screening[i];
    long double d = 1. - Bi / N;
    d *= d;
    d *= d;
    a[i] = (a[i] - 4 * b[i] / (N - Bi)) / d;
    b[i] /= d;
  }
}


x86 assembly (clang, -O0):
<coulomb_pole_reduction>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x4,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x28(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x4,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1030 <memset@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1258 <coulomb_pole_reduction+0x148>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x50(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x60(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(0)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fstpt  (%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1245 <coulomb_pole_reduction+0x135>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x80(%rbp)
fldt   -0x50(%rbp)
fadd   %st,%st(0)
fldt   -0x70(%rbp)
fmulp  %st,%st(1)
fldt   -0x80(%rbp)
fldt   -0x60(%rbp)
fsubrp %st,%st(1)
fdivrp %st,%st(1)
fstpt  -0x90(%rbp)
fldt   -0x90(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
faddp  %st,%st(1)
fstpt  (%rax,%rcx,1)
fldt   -0x90(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fsubp  %st,%st(1)
fstpt  (%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c1 <coulomb_pole_reduction+0xb1>
jmp    124a <coulomb_pole_reduction+0x13a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117c <coulomb_pole_reduction+0x6c>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0xa0(%rbp)
lea    -0xe0(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1030 <memset@plt>
lea    -0x120(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1030 <memset@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    137b <coulomb_pole_reduction+0x26b>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x130(%rbp)
fldt   -0x130(%rbp)
fldt   -0xa0(%rbp)
fdivrp %st,%st(1)
fld1
fsubp  %st,%st(1)
fstpt  -0x140(%rbp)
fldt   -0x140(%rbp)
fstpt  -0x150(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1368 <coulomb_pole_reduction+0x258>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fldt   -0x150(%rbp)
fdivrp %st,%st(1)
movslq -0x3c(%rbp),%rax
shl    $0x4,%rax
fldt   -0xe0(%rbp,%rax,1)
faddp  %st,%st(1)
fstpt  -0xe0(%rbp,%rax,1)
fldt   -0x140(%rbp)
fldt   -0x150(%rbp)
fmulp  %st,%st(1)
fstpt  -0x150(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fldt   -0x150(%rbp)
fdivrp %st,%st(1)
movslq -0x3c(%rbp),%rax
shl    $0x4,%rax
fldt   -0x120(%rbp,%rax,1)
faddp  %st,%st(1)
fstpt  -0x120(%rbp,%rax,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12de <coulomb_pole_reduction+0x1ce>
jmp    136d <coulomb_pole_reduction+0x25d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1296 <coulomb_pole_reduction+0x186>
fld1
fstpt  -0x160(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    1409 <coulomb_pole_reduction+0x2f9>
movslq -0x38(%rbp),%rcx
mov    %ecx,%edx
mov    $0x4,%eax
sub    %edx,%eax
mov    %eax,-0x184(%rbp)
fildl  -0x184(%rbp)
mov    $0x3,%eax
sub    %edx,%eax
cltq
shl    $0x4,%rax
fldt   -0x120(%rbp,%rax,1)
fmulp  %st,%st(1)
fldt   -0xa0(%rbp)
fdivrp %st,%st(1)
fldt   -0xe0(%rbp,%rax,1)
fsubrp %st,%st(1)
fldt   -0x160(%rbp)
fmulp  %st,%st(1)
mov    -0x30(%rbp),%rax
shl    $0x4,%rcx
fstpt  (%rax,%rcx,1)
fldt   -0xa0(%rbp)
fldt   -0x160(%rbp)
fmulp  %st,%st(1)
fstpt  -0x160(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    138a <coulomb_pole_reduction+0x27a>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    14c4 <coulomb_pole_reduction+0x3b4>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
fldl   (%rax,%rcx,8)
fstpt  -0x170(%rbp)
fldt   -0x170(%rbp)
fldt   -0xa0(%rbp)
fdivrp %st,%st(1)
fld1
fsubp  %st,%st(1)
fstpt  -0x180(%rbp)
fldt   -0x180(%rbp)
fmul   %st,%st(0)
fstpt  -0x180(%rbp)
fldt   -0x180(%rbp)
fmul   %st,%st(0)
fstpt  -0x180(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
mov    -0x28(%rbp),%rdx
fldt   (%rdx,%rcx,1)
flds   0xb83(%rip)
fmulp  %st,%st(1)
fldt   -0xa0(%rbp)
fldt   -0x170(%rbp)
fsubrp %st,%st(1)
fdivrp %st,%st(1)
faddp  %st,%st(1)
fldt   -0x180(%rbp)
fdivrp %st,%st(1)
fstpt  (%rax,%rcx,1)
fldt   -0x180(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x4,%rcx
fldt   (%rax,%rcx,1)
fdivp  %st,%st(1)
fstpt  (%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1410 <coulomb_pole_reduction+0x300>
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coulomb_pole_reduction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x50(%rsp)
mov    %r8,%r13
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,(%rsp)
mov    %edi,%ebx
lea    -0x1(%rbx),%eax
mov    %eax,0x1c(%rsp)
movslq %eax,%r12
mov    %r12d,%ebp
shl    $0x4,%ebp
mov    %rcx,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
mov    0x50(%rsp),%rbp
call   1030 <memset@plt>
mov    %rbp,%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1030 <memset@plt>
cmp    $0x1,%ebx
jle    122b <coulomb_pole_reduction+0x11b>
mov    %rbx,0x58(%rsp)
mov    0x1c(%rsp),%r10d
mov    %r10d,%r8d
lea    0x10(%r14),%r9
xor    %eax,%eax
mov    %r8,%rsi
mov    (%rsp),%rcx
mov    %rcx,%rdi
mov    %r15,%rbp
jmp    11c0 <coulomb_pole_reduction+0xb0>
nopl   0x0(%rax)
fstp   %st(0)
fstp   %st(0)
add    $0x10,%r9
add    $0x8,%rbp
add    $0x8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    %r8,%rax
mov    %r11,%rcx
je     1254 <coulomb_pole_reduction+0x144>
mov    %rcx,%r11
fldl   (%rcx,%rax,8)
fldl   (%r15,%rax,8)
fld    %st(1)
fmul   %st(2),%st
mov    %rax,%rdx
shl    $0x4,%rdx
fstpt  0x0(%r13,%rdx,1)
add    $0x1,%rax
cmp    %r12,%rax
jge    11a0 <coulomb_pole_reduction+0x90>
fxch   %st(1)
fadd   %st,%st(0)
add    %r14,%rdx
mov    $0x1,%ebx
mov    %r9,%rcx
fxch   %st(1)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
fld    %st(1)
fmull  (%rdi,%rbx,8)
fld    %st(1)
fsubrl 0x0(%rbp,%rbx,8)
fdivrp %st,%st(1)
fldt   (%rdx)
fadd   %st(1),%st
fstpt  (%rdx)
fldt   (%rcx)
fsubp  %st,%st(1)
fstpt  (%rcx)
add    $0x10,%rcx
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1200 <coulomb_pole_reduction+0xf0>
jmp    11a0 <coulomb_pole_reduction+0x90>
fldl   (%r15,%r12,8)
fldz
fld    %st(0)
fld    %st(1)
fstpt  (%rsp)
fld    %st(1)
fstpt  0x20(%rsp)
fld    %st(1)
fld    %st(2)
fstpt  0x10(%rsp)
fld    %st(2)
fld    %st(3)
mov    0x1c(%rsp),%r10d
jmp    1389 <coulomb_pole_reduction+0x279>
fldl   (%r15,%r12,8)
fldz
mov    0x58(%rsp),%rbx
cmp    $0x2,%ebx
mov    0x50(%rsp),%rbp
jl     1370 <coulomb_pole_reduction+0x260>
fstp   %st(0)
shl    $0x3,%r8
fldz
xor    %ecx,%ecx
fld1
fstpt  0x64(%rsp)
fld    %st(0)
fstpt  0x44(%rsp)
fld    %st(0)
fstpt  (%rsp)
fld    %st(0)
fstpt  0x20(%rsp)
fld    %st(0)
fstpt  0x38(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fld    %st(0)
fstpt  0x2c(%rsp)
fld    %st(0)
fld    %st(2)
fstpt  0x70(%rsp)
nopl   0x0(%rax,%rax,1)
fxch   %st(2)
fdivrl (%r15,%rcx,1)
fldt   0x64(%rsp)
fsubp  %st,%st(1)
fldt   (%r14,%rcx,2)
fldt   0x0(%r13,%rcx,2)
fld    %st(1)
fdiv   %st(3),%st
faddp  %st,%st(4)
fxch   %st(3)
fstpt  0x7c(%rsp)
fld    %st(1)
fmul   %st(2),%st
fld    %st(3)
fdiv   %st(1),%st
fldt   0x38(%rsp)
faddp  %st,%st(1)
fstpt  0x38(%rsp)
fld    %st(1)
fdiv   %st(1),%st
fldt   0x44(%rsp)
faddp  %st,%st(1)
fstpt  0x44(%rsp)
fmul   %st(2),%st
fld    %st(3)
fdiv   %st(1),%st
fldt   0x10(%rsp)
faddp  %st,%st(1)
fstpt  0x10(%rsp)
fld    %st(1)
fdiv   %st(1),%st
fldt   (%rsp)
faddp  %st,%st(1)
fstpt  (%rsp)
fmul   %st(2),%st
fld    %st(3)
fdiv   %st(1),%st
fldt   0x2c(%rsp)
faddp  %st,%st(1)
fstpt  0x2c(%rsp)
fldt   0x70(%rsp)
fxch   %st(2)
fdiv   %st(1),%st
fldt   0x20(%rsp)
faddp  %st,%st(1)
fstpt  0x20(%rsp)
fmulp  %st,%st(2)
fxch   %st(2)
fdivp  %st,%st(1)
faddp  %st,%st(2)
fldt   0x7c(%rsp)
add    $0x8,%rcx
cmp    %rcx,%r8
fxch   %st(1)
fxch   %st(2)
jne    12b0 <coulomb_pole_reduction+0x1a0>
fmuls  0xcae(%rip)
fldt   0x2c(%rsp)
fmuls  0xca8(%rip)
fldt   0x10(%rsp)
fadd   %st,%st(0)
fstpt  0x10(%rsp)
fldt   0x44(%rsp)
fldt   0x38(%rsp)
jmp    138f <coulomb_pole_reduction+0x27f>
fld    %st(0)
fld    %st(1)
fstpt  (%rsp)
fld    %st(1)
fstpt  0x20(%rsp)
fld    %st(1)
fld    %st(2)
fstpt  0x10(%rsp)
fld    %st(2)
fld    %st(3)
fxch   %st(3)
fxch   %st(1)
fxch   %st(2)
fxch   %st(3)
fdiv   %st(5),%st
fldt   0x20(%rsp)
fsubrp %st,%st(1)
fstpt  0x0(%rbp)
fxch   %st(1)
fdiv   %st(4),%st
fldt   (%rsp)
fsubrp %st,%st(1)
fmul   %st(4),%st
fstpt  0x10(%rbp)
fldt   0x10(%rsp)
fdiv   %st(4),%st
fsubp  %st,%st(1)
fld    %st(3)
fmul   %st(4),%st
fmul   %st,%st(1)
fxch   %st(1)
fstpt  0x20(%rbp)
fxch   %st(1)
fdiv   %st(3),%st
fsubp  %st,%st(2)
fmul   %st(2),%st
fmulp  %st,%st(1)
fstpt  0x30(%rbp)
cmp    $0x1,%ebx
fldz
jle    1422 <coulomb_pole_reduction+0x312>
fstp   %st(0)
mov    %r10d,%eax
shl    $0x3,%rax
xor    %ecx,%ecx
fld1
xchg   %ax,%ax
fldl   (%r15,%rcx,1)
fld    %st(0)
fdiv   %st(3),%st
fsubr  %st(2),%st
fmul   %st,%st(0)
fmul   %st,%st(0)
fldt   (%r14,%rcx,2)
fldt   0x0(%r13,%rcx,2)
fmuls  0xc0b(%rip)
fxch   %st(3)
fsubr  %st(5),%st
fdivrp %st,%st(3)
faddp  %st,%st(2)
fdivr  %st,%st(1)
fxch   %st(1)
fstpt  (%r14,%rcx,2)
fldt   0x0(%r13,%rcx,2)
fdivp  %st,%st(1)
fstpt  0x0(%r13,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    13e0 <coulomb_pole_reduction+0x2d0>
fstp   %st(0)
fstp   %st(0)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @coulomb_pole_reduction(i32 %0, double* %1, double* %2, x86_fp80* %3, x86_fp80* %4, x86_fp80* %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca x86_fp80*
%11 = alloca x86_fp80*
%12 = alloca x86_fp80*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca x86_fp80
%17 = alloca x86_fp80
%18 = alloca x86_fp80
%19 = alloca x86_fp80
%20 = alloca x86_fp80
%21 = alloca x86_fp80
%22 = alloca [4 x x86_fp80]
%23 = alloca [4 x 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
store i32 %0, i32* %7
store double* %1, double** %8
store double* %2, double** %9
store x86_fp80* %3, x86_fp80** %10
store x86_fp80* %4, x86_fp80** %11
store x86_fp80* %5, x86_fp80** %12
%30 = load i32, i32* %7
%31 = sub nsw i32 %30, 1
store i32 %31, i32* %13
%32 = load x86_fp80*, x86_fp80** %10
%33 = load i32, i32* %13
%34 = sext i32 %33 to i64
%35 = mul i64 %34, 16
%36 = trunc i64 %35 to i32
%37 = call i32 @memset(x86_fp80* %32, i32 0, i32 %36)
%38 = load x86_fp80*, x86_fp80** %11
%39 = load i32, i32* %13
%40 = sext i32 %39 to i64
%41 = mul i64 %40, 16
%42 = trunc i64 %41 to i32
%43 = call i32 @memset(x86_fp80* %38, i32 0, i32 %42)
%44 = load x86_fp80*, x86_fp80** %12
%45 = call i32 @memset(x86_fp80* %44, i32 0, i32 64)
store i32 0, i32* %14
br label %46
46: ; preds = %115, %6
%47 = load i32, i32* %14
%48 = load i32, i32* %13
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %118
50: ; preds = %46
%51 = load double*, double** %8
%52 = load i32, i32* %14
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %51, i64 %53
%55 = load double, double* %54
%56 = fpext double %55 to x86_fp80
store x86_fp80 %56, x86_fp80* %16
%57 = load double*, double** %9
%58 = load i32, i32* %14
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = fpext double %61 to x86_fp80
store x86_fp80 %62, x86_fp80* %17
%63 = load x86_fp80, x86_fp80* %16
%64 = load x86_fp80, x86_fp80* %16
%65 = fmul x86_fp80 %63, %64
%66 = load x86_fp80*, x86_fp80** %11
%67 = load i32, i32* %14
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds x86_fp80, x86_fp80* %66, i64 %68
store x86_fp80 %65, x86_fp80* %69
%70 = load i32, i32* %14
%71 = add nsw i32 %70, 1
store i32 %71, i32* %15
br label %72
72: ; preds = %111, %50
%73 = load i32, i32* %15
%74 = load i32, i32* %13
%75 = icmp slt i32 %73, %74
br i1 %75, label %76, label %114
76: ; preds = %72
%77 = load double*, double** %8
%78 = load i32, i32* %15
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = fpext double %81 to x86_fp80
store x86_fp80 %82, x86_fp80* %18
%83 = load double*, double** %9
%84 = load i32, i32* %15
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
%87 = load double, double* %86
%88 = fpext double %87 to x86_fp80
store x86_fp80 %88, x86_fp80* %19
%89 = load x86_fp80, x86_fp80* %16
%90 = fmul x86_fp80 0xK40008000000000000000, %89
%91 = load x86_fp80, x86_fp80* %18
%92 = fmul x86_fp80 %90, %91
%93 = load x86_fp80, x86_fp80* %19
%94 = load x86_fp80, x86_fp80* %17
%95 = fsub x86_fp80 %93, %94
%96 = fdiv x86_fp80 %92, %95
store x86_fp80 %96, x86_fp80* %20
%97 = load x86_fp80, x86_fp80* %20
%98 = load x86_fp80*, x86_fp80** %10
%99 = load i32, i32* %14
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds x86_fp80, x86_fp80* %98, i64 %100
%102 = load x86_fp80, x86_fp80* %101
%103 = fadd x86_fp80 %102, %97
store x86_fp80 %103, x86_fp80* %101
%104 = load x86_fp80, x86_fp80* %20
%105 = load x86_fp80*, x86_fp80** %10
%106 = load i32, i32* %15
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds x86_fp80, x86_fp80* %105, i64 %107
%109 = load x86_fp80, x86_fp80* %108
%110 = fsub x86_fp80 %109, %104
store x86_fp80 %110, x86_fp80* %108
br label %111
111: ; preds = %76
%112 = load i32, i32* %15
%113 = add nsw i32 %112, 1
store i32 %113, i32* %15
br label %72
114: ; preds = %72
br label %115
115: ; preds = %114
%116 = load i32, i32* %14
%117 = add nsw i32 %116, 1
store i32 %117, i32* %14
br label %46
118: ; preds = %46
%119 = load double*, double** %9
%120 = load i32, i32* %13
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %119, i64 %121
%123 = load double, double* %122
%124 = fpext double %123 to x86_fp80
store x86_fp80 %124, x86_fp80* %21
%125 = bitcast [4 x x86_fp80]* %22 to i8*
%126 = bitcast [4 x x86_fp80]* %23 to i8*
store i32 0, i32* %14
br label %127
127: ; preds = %178, %118
%128 = load i32, i32* %14
%129 = load i32, i32* %13
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %181
131: ; preds = %127
%132 = load double*, double** %9
%133 = load i32, i32* %14
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %132, i64 %134
%136 = load double, double* %135
%137 = fpext double %136 to x86_fp80
store x86_fp80 %137, x86_fp80* %24
%138 = load x86_fp80, x86_fp80* %24
%139 = load x86_fp80, x86_fp80* %21
%140 = fdiv x86_fp80 %138, %139
%141 = fsub x86_fp80 0xK3FFF8000000000000000, %140
store x86_fp80 %141, x86_fp80* %25
%142 = load x86_fp80, x86_fp80* %25
store x86_fp80 %142, x86_fp80* %26
store i32 0, i32* %15
br label %143
143: ; preds = %174, %131
%144 = load i32, i32* %15
%145 = icmp slt i32 %144, 4
br i1 %145, label %146, label %177
146: ; preds = %143
%147 = load x86_fp80*, x86_fp80** %10
%148 = load i32, i32* %14
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds x86_fp80, x86_fp80* %147, i64 %149
%151 = load x86_fp80, x86_fp80* %150
%152 = load x86_fp80, x86_fp80* %26
%153 = fdiv x86_fp80 %151, %152
%154 = load i32, i32* %15
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [4 x x86_fp80], [4 x x86_fp80]* %22, i64 0, i64 %155
%157 = load x86_fp80, x86_fp80* %156
%158 = fadd x86_fp80 %157, %153
store x86_fp80 %158, x86_fp80* %156
%159 = load x86_fp80, x86_fp80* %25
%160 = load x86_fp80, x86_fp80* %26
%161 = fmul x86_fp80 %160, %159
store x86_fp80 %161, x86_fp80* %26
%162 = load x86_fp80*, x86_fp80** %11
%163 = load i32, i32* %14
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds x86_fp80, x86_fp80* %162, i64 %164
%166 = load x86_fp80, x86_fp80* %165
%167 = load x86_fp80, x86_fp80* %26
%168 = fdiv x86_fp80 %166, %167
%169 = load i32, i32* %15
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [4 x x86_fp80], [4 x x86_fp80]* %23, i64 0, i64 %170
%172 = load x86_fp80, x86_fp80* %171
%173 = fadd x86_fp80 %172, %168
store x86_fp80 %173, x86_fp80* %171
br label %174
174: ; preds = %146
%175 = load i32, i32* %15
%176 = add nsw i32 %175, 1
store i32 %176, i32* %15
br label %143
177: ; preds = %143
br label %178
178: ; preds = %177
%179 = load i32, i32* %14
%180 = add nsw i32 %179, 1
store i32 %180, i32* %14
br label %127
181: ; preds = %127
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %27
store i32 0, i32* %14
br label %182
182: ; preds = %212, %181
%183 = load i32, i32* %14
%184 = icmp slt i32 %183, 4
br i1 %184, label %185, label %215
185: ; preds = %182
%186 = load i32, i32* %14
%187 = sub nsw i32 4, %186
%188 = sitofp i32 %187 to x86_fp80
%189 = load i32, i32* %14
%190 = sub nsw i32 3, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [4 x x86_fp80], [4 x x86_fp80]* %23, i64 0, i64 %191
%193 = load x86_fp80, x86_fp80* %192
%194 = fmul x86_fp80 %188, %193
%195 = load x86_fp80, x86_fp80* %21
%196 = fdiv x86_fp80 %194, %195
%197 = load i32, i32* %14
%198 = sub nsw i32 3, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [4 x x86_fp80], [4 x x86_fp80]* %22, i64 0, i64 %199
%201 = load x86_fp80, x86_fp80* %200
%202 = fsub x86_fp80 %196, %201
%203 = load x86_fp80, x86_fp80* %27
%204 = fmul x86_fp80 %202, %203
%205 = load x86_fp80*, x86_fp80** %12
%206 = load i32, i32* %14
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds x86_fp80, x86_fp80* %205, i64 %207
store x86_fp80 %204, x86_fp80* %208
%209 = load x86_fp80, x86_fp80* %21
%210 = load x86_fp80, x86_fp80* %27
%211 = fmul x86_fp80 %210, %209
store x86_fp80 %211, x86_fp80* %27
br label %212
212: ; preds = %185
%213 = load i32, i32* %14
%214 = add nsw i32 %213, 1
store i32 %214, i32* %14
br label %182
215: ; preds = %182
store i32 0, i32* %14
br label %216
216: ; preds = %266, %215
%217 = load i32, i32* %14
%218 = load i32, i32* %13
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %269
220: ; preds = %216
%221 = load double*, double** %9
%222 = load i32, i32* %14
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %221, i64 %223
%225 = load double, double* %224
%226 = fpext double %225 to x86_fp80
store x86_fp80 %226, x86_fp80* %28
%227 = load x86_fp80, x86_fp80* %28
%228 = load x86_fp80, x86_fp80* %21
%229 = fdiv x86_fp80 %227, %228
%230 = fsub x86_fp80 0xK3FFF8000000000000000, %229
store x86_fp80 %230, x86_fp80* %29
%231 = load x86_fp80, x86_fp80* %29
%232 = load x86_fp80, x86_fp80* %29
%233 = fmul x86_fp80 %232, %231
store x86_fp80 %233, x86_fp80* %29
%234 = load x86_fp80, x86_fp80* %29
%235 = load x86_fp80, x86_fp80* %29
%236 = fmul x86_fp80 %235, %234
store x86_fp80 %236, x86_fp80* %29
%237 = load x86_fp80*, x86_fp80** %10
%238 = load i32, i32* %14
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds x86_fp80, x86_fp80* %237, i64 %239
%241 = load x86_fp80, x86_fp80* %240
%242 = load x86_fp80*, x86_fp80** %11
%243 = load i32, i32* %14
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds x86_fp80, x86_fp80* %242, i64 %244
%246 = load x86_fp80, x86_fp80* %245
%247 = fmul x86_fp80 0xK40018000000000000000, %246
%248 = load x86_fp80, x86_fp80* %21
%249 = load x86_fp80, x86_fp80* %28
%250 = fsub x86_fp80 %248, %249
%251 = fdiv x86_fp80 %247, %250
%252 = fsub x86_fp80 %241, %251
%253 = load x86_fp80, x86_fp80* %29
%254 = fdiv x86_fp80 %252, %253
%255 = load x86_fp80*, x86_fp80** %10
%256 = load i32, i32* %14
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds x86_fp80, x86_fp80* %255, i64 %257
store x86_fp80 %254, x86_fp80* %258
%259 = load x86_fp80, x86_fp80* %29
%260 = load x86_fp80*, x86_fp80** %11
%261 = load i32, i32* %14
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds x86_fp80, x86_fp80* %260, i64 %262
%264 = load x86_fp80, x86_fp80* %263
%265 = fdiv x86_fp80 %264, %259
store x86_fp80 %265, x86_fp80* %263
br label %266
266: ; preds = %220
%267 = load i32, i32* %14
%268 = add nsw i32 %267, 1
store i32 %268, i32* %14
br label %216
269: ; preds = %216
ret void
}

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