#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 */
int /*<<< orphan*/ lapack_inv_(int, double *);
int /*<<< orphan*/ scalars_nonewald_poly(int, double, double, double, double *);
void scalars_minv_ft_poly(double r, double aa, double ab, double *scalar_ft) {
  double mat[16];
  double scalar[11];
  scalars_nonewald_poly(1, r, aa, ab, scalar);
  double xa12, ya12;
  double yb12;
  double xc12, yc12;
  double aa2 = aa * aa;
  double aa3 = aa2 * aa;
  xa12 = scalar[0];
  ya12 = scalar[1];
  yb12 = scalar[2];
  xc12 = scalar[3];
  yc12 = scalar[4];
  double xa21, ya21;
  double yb21;
  double xc21, yc21;
  double ab2 = ab * ab;
  double ab3 = ab2 * ab;
  xa21 = xa12;
  ya21 = ya12;
  yb21 = yb12;
  xc21 = xc12;
  yc21 = yc12;
  double xa11, ya11;
  xa11 = 1.0 / aa;
  ya11 = 1.0 / aa;
  double xa22, ya22;
  xa22 = 1.0 / ab;
  ya22 = 1.0 / ab;
  double xc11, yc11;
  xc11 = 0.75 / aa3;
  yc11 = 0.75 / aa3;
  double xc22, yc22;
  xc22 = 0.75 / ab3;
  yc22 = 0.75 / ab3;
  double det;
  double XA11, XA12, XA21, XA22;
  det = xa11 * xa22 - xa12 * xa21;
  XA11 = xa22 / det;
  XA12 = -xa12 / det;
  XA21 = -xa21 / det;
  XA22 = xa11 / det;
  double XC11, XC12, XC21, XC22;
  det = xc11 * xc22 - xc12 * xc21;
  XC11 = xc22 / det;
  XC12 = -xc12 / det;
  XC21 = -xc21 / det;
  XC22 = xc11 / det;
  double YA11, YA12, YA21, YA22;
  double YB11, YB12, YB21, YB22;
  double YC11, YC12, YC21, YC22;
  mat[0] = ya11;
  mat[1] = ya12;
  mat[2] = 0.0;
  mat[3] = yb21;
  mat[4] = ya21;
  mat[5] = ya22;
  mat[6] = -yb12;
  mat[7] = 0.0;
  mat[8] = 0.0;
  mat[9] = -yb12;
  mat[10] = yc11;
  mat[11] = yc12;
  mat[12] = yb21;
  mat[13] = 0.0;
  mat[14] = yc21;
  mat[15] = yc22;
  lapack_inv_(4, mat);
  YA11 = mat[0];
  YA12 = mat[1];
  YA21 = mat[4];
  YA22 = mat[5];
  YB11 = -mat[8];
  YB12 = -mat[9];
  YB21 = mat[12];
  YB22 = mat[13];
  YC11 = mat[10];
  YC12 = mat[11];
  YC21 = mat[14];
  YC22 = mat[15];
  scalar_ft[0] = XA11;
  scalar_ft[1] = XA12;
  scalar_ft[2] = XA21;
  scalar_ft[3] = XA22;
  scalar_ft[4] = YA11;
  scalar_ft[5] = YA12;
  scalar_ft[6] = YA21;
  scalar_ft[7] = YA22;
  scalar_ft[8] = YB11;
  scalar_ft[9] = YB12;
  scalar_ft[10] = YB21;
  scalar_ft[11] = YB22;
  scalar_ft[12] = XC11;
  scalar_ft[13] = XC12;
  scalar_ft[14] = XC21;
  scalar_ft[15] = XC22;
  scalar_ft[16] = YC11;
  scalar_ft[17] = YC12;
  scalar_ft[18] = YC21;
  scalar_ft[19] = YC22;
}


x86 assembly (clang, -O0):
<scalars_minv_ft_poly>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
mov    %rdi,-0x20(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
lea    -0x100(%rbp),%rsi
mov    $0x1,%edi
call   1030 <scalars_nonewald_poly@plt>
movsd  -0x10(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0xdb4(%rip),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0xd9f(%rip),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  0xd8a(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  0xd75(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  0xd58(%rip),%xmm0
divsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0xd40(%rip),%xmm0
divsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  0xd28(%rip),%xmm0
divsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  0xd10(%rip),%xmm0
divsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x140(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x158(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x30(%rbp)
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x28(%rbp)
lea    -0xa0(%rbp),%rsi
mov    $0x4,%edi
call   1040 <lapack_inv_@plt>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x1d0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x200(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x208(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x210(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x218(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x220(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x228(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x230(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x238(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x1e8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x1f8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movsd  -0x240(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x80(%rax)
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x88(%rax)
movsd  -0x250(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x90(%rax)
movsd  -0x258(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x98(%rax)
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scalars_minv_ft_poly>:
push   %rbx
sub    $0x120,%rsp
mov    %rdi,%rbx
movsd  %xmm2,0x8(%rsp)
movsd  %xmm1,0x10(%rsp)
lea    0xc0(%rsp),%rsi
mov    $0x1,%edi
call   1030 <scalars_nonewald_poly@plt>
movsd  0x10(%rsp),%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm0,%xmm6
movsd  0xc0(%rsp),%xmm5
movsd  0xc8(%rsp),%xmm9
movsd  0xd0(%rsp),%xmm10
movsd  0xd8(%rsp),%xmm2
movsd  0xe0(%rsp),%xmm8
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
movsd  0xe53(%rip),%xmm7
movapd %xmm7,%xmm1
divsd  %xmm6,%xmm1
divsd  %xmm3,%xmm7
movsd  0xe47(%rip),%xmm3
movapd %xmm3,%xmm6
divsd  %xmm4,%xmm6
divsd  %xmm0,%xmm3
movapd 0xe3a(%rip),%xmm11
movapd %xmm5,%xmm4
xorpd  %xmm11,%xmm4
mulsd  %xmm5,%xmm5
movapd %xmm1,%xmm0
movsd  %xmm1,0x30(%rsp)
mulsd  %xmm7,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm9,0x38(%rsp)
movq   $0x0,0x40(%rsp)
movsd  %xmm10,0x48(%rsp)
movsd  %xmm9,0x50(%rsp)
movsd  %xmm7,0x58(%rsp)
unpcklpd %xmm4,%xmm7
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm7
movapd %xmm7,0x10(%rsp)
movapd %xmm2,%xmm0
xorpd  %xmm11,%xmm0
mulsd  %xmm2,%xmm2
movapd %xmm6,%xmm5
movapd %xmm10,%xmm1
xorpd  %xmm11,%xmm1
movlpd %xmm1,0x60(%rsp)
xorpd  %xmm4,%xmm4
movupd %xmm4,0x68(%rsp)
movlpd %xmm1,0x78(%rsp)
movsd  %xmm6,0x80(%rsp)
mulsd  %xmm3,%xmm6
subsd  %xmm2,%xmm6
movsd  %xmm8,0x88(%rsp)
movsd  %xmm10,0x90(%rsp)
movq   $0x0,0x98(%rsp)
movsd  %xmm8,0xa0(%rsp)
movsd  %xmm3,0xa8(%rsp)
unpcklpd %xmm0,%xmm3
divsd  %xmm6,%xmm5
movsd  %xmm5,0x28(%rsp)
unpcklpd %xmm6,%xmm6
divpd  %xmm6,%xmm3
movapd %xmm3,0xb0(%rsp)
lea    0x30(%rsp),%rsi
mov    $0x4,%edi
call   1040 <lapack_inv_@plt>
movaps 0xd31(%rip),%xmm6
xorps  0x70(%rsp),%xmm6
movaps 0x30(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
movaps 0x80(%rsp),%xmm2
movaps 0x90(%rsp),%xmm3
movaps 0xa0(%rsp),%xmm4
movaps 0x10(%rsp),%xmm5
movups %xmm5,(%rbx)
movhps %xmm5,0x10(%rbx)
movsd  0x8(%rsp),%xmm5
movsd  %xmm5,0x18(%rbx)
movups %xmm0,0x20(%rbx)
movups %xmm1,0x30(%rbx)
movups %xmm6,0x40(%rbx)
movups %xmm3,0x50(%rbx)
movaps 0xb0(%rsp),%xmm0
movups %xmm0,0x60(%rbx)
movhps %xmm0,0x70(%rbx)
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x78(%rbx)
movups %xmm2,0x80(%rbx)
movups %xmm4,0x90(%rbx)
add    $0x120,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @scalars_minv_ft_poly(double %0, double %1, double %2, double* nocapture writeonly %3) {
%5 = alloca [16 x double]
%6 = alloca [11 x double]
%7 = bitcast [16 x double]* %5 to i8*
%8 = bitcast [11 x double]* %6 to i8*
%9 = getelementptr inbounds [11 x double], [11 x double]* %6, i64 0, i64 0
%10 = call i32 @scalars_nonewald_poly(i32 1, double %0, double %1, double %2, double* %9)
%11 = fmul double %1, %1
%12 = fmul double %11, %1
%13 = load double, double* %9
%14 = getelementptr inbounds [11 x double], [11 x double]* %6, i64 0, i64 1
%15 = load double, double* %14
%16 = getelementptr inbounds [11 x double], [11 x double]* %6, i64 0, i64 2
%17 = load double, double* %16
%18 = getelementptr inbounds [11 x double], [11 x double]* %6, i64 0, i64 3
%19 = load double, double* %18
%20 = getelementptr inbounds [11 x double], [11 x double]* %6, i64 0, i64 4
%21 = load double, double* %20
%22 = fmul double %2, %2
%23 = fmul double %22, %2
%24 = fdiv double 1.000000e+00, %1
%25 = fdiv double 1.000000e+00, %2
%26 = fdiv double 7.500000e-01, %12
%27 = fdiv double 7.500000e-01, %23
%28 = fneg double %13
%29 = fmul double %13, %28
%30 = call double @llvm.fmuladd.f64(double %24, double %25, double %29)
%31 = insertelement <2 x double> poison, double %25, i64 0
%32 = insertelement <2 x double> %31, double %28, i64 1
%33 = insertelement <2 x double> poison, double %30, i64 0
%34 = shufflevector <2 x double> %33, <2 x double> poison, <2 x i32> zeroinitializer
%35 = fdiv <2 x double> %32, %34
%36 = fdiv double %24, %30
%37 = fneg double %19
%38 = fmul double %19, %37
%39 = call double @llvm.fmuladd.f64(double %26, double %27, double %38)
%40 = insertelement <2 x double> poison, double %27, i64 0
%41 = insertelement <2 x double> %40, double %37, i64 1
%42 = insertelement <2 x double> poison, double %39, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = fdiv <2 x double> %41, %43
%45 = fdiv double %26, %39
%46 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 0
store double %24, double* %46
%47 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 1
store double %15, double* %47
%48 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 2
store double 0.000000e+00, double* %48
%49 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 3
store double %17, double* %49
%50 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 4
store double %15, double* %50
%51 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 5
store double %25, double* %51
%52 = fneg double %17
%53 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 6
store double %52, double* %53
%54 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 7
%55 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 8
%56 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 9
%57 = bitcast double* %54 to i8*
store double %52, double* %56
%58 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 10
store double %26, double* %58
%59 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 11
store double %21, double* %59
%60 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 12
store double %17, double* %60
%61 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 13
store double 0.000000e+00, double* %61
%62 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 14
store double %21, double* %62
%63 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 15
store double %27, double* %63
%64 = call i32 @lapack_inv_(i32 4, double* %46)
%65 = bitcast [16 x double]* %5 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = bitcast double* %50 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = bitcast double* %55 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = fneg <2 x double> %70
%72 = bitcast double* %60 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = bitcast double* %58 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = bitcast double* %62 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = bitcast double* %3 to <2 x double>*
store <2 x double> %35, <2 x double>* %78
%79 = getelementptr inbounds double, double* %3, i64 2
%80 = extractelement <2 x double> %35, i64 1
store double %80, double* %79
%81 = getelementptr inbounds double, double* %3, i64 3
store double %36, double* %81
%82 = getelementptr inbounds double, double* %3, i64 4
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> %66, <2 x double>* %83
%84 = getelementptr inbounds double, double* %3, i64 6
%85 = bitcast double* %84 to <2 x double>*
store <2 x double> %68, <2 x double>* %85
%86 = getelementptr inbounds double, double* %3, i64 8
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %71, <2 x double>* %87
%88 = getelementptr inbounds double, double* %3, i64 10
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %73, <2 x double>* %89
%90 = getelementptr inbounds double, double* %3, i64 12
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> %44, <2 x double>* %91
%92 = getelementptr inbounds double, double* %3, i64 14
%93 = extractelement <2 x double> %44, i64 1
store double %93, double* %92
%94 = getelementptr inbounds double, double* %3, i64 15
store double %45, double* %94
%95 = getelementptr inbounds double, double* %3, i64 16
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %75, <2 x double>* %96
%97 = getelementptr inbounds double, double* %3, i64 18
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %77, <2 x double>* %98
ret void
}