void updateSolutionEconomic_CFP64(float _Complex *mat, double _Complex *x,
                                  double _Complex *r, int n, long long *Idxs) {
  int i, j, offset1, offset2;
  double _Complex t = r[n - 1];
  for (i = 0; i < n - 1; ++i) {
    t -= mat[i] * r[i];
  }
  t *= mat[n - 1];
  offset1 = n;
  offset2 = 2 * n - 1;
  x[Idxs[n - 1] - 1] += t;
  for (i = 0; i < n - 1; ++i) {
    x[Idxs[i] - 1] += mat[i + offset1] * (r[i] - mat[i + offset2] * t);
  }
}


x86 assembly (clang, -O0):
<updateSolutionEconomic_CFP64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movsd  0x8(%rax),%xmm0
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    125b <updateSolutionEconomic_CFP64+0x15b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x88(%rbp)
ff
cvtss2sd %xmm0,%xmm2
movsd  %xmm2,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm4
movsd  %xmm4,-0x78(%rbp)
movsd  0x8(%rax),%xmm5
movsd  %xmm5,-0x70(%rbp)
movaps %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movaps %xmm2,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm2
subsd  %xmm3,%xmm0
movsd  %xmm0,-0x68(%rbp)
addsd  %xmm2,%xmm1
movsd  %xmm1,-0x60(%rbp)
ucomisd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  %xmm1,-0x50(%rbp)
jnp    1227 <updateSolutionEconomic_CFP64+0x127>
movsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm1
movsd  %xmm0,-0x58(%rbp)
movsd  %xmm1,-0x50(%rbp)
jnp    1227 <updateSolutionEconomic_CFP64+0x127>
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
call   1670 <__muldc3>
movsd  %xmm0,-0x58(%rbp)
movsd  %xmm1,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
subsd  %xmm3,%xmm1
subsd  %xmm2,%xmm0
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114c <updateSolutionEconomic_CFP64+0x4c>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm1,%xmm4
movsd  %xmm4,-0xc8(%rbp)
ff
cvtss2sd %xmm0,%xmm5
movsd  %xmm5,-0xc0(%rbp)
ff
movsd  -0x48(%rbp),%xmm1
movsd  %xmm1,-0xb8(%rbp)
ff
movsd  -0x40(%rbp),%xmm2
movsd  %xmm2,-0xb0(%rbp)
ff
movaps %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movaps %xmm2,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm2
subsd  %xmm3,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
addsd  %xmm2,%xmm1
movsd  %xmm1,-0xa0(%rbp)
ff
ucomisd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  %xmm1,-0x90(%rbp)
ff
jnp    134c <updateSolutionEconomic_CFP64+0x24c>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm1
movsd  %xmm0,-0x98(%rbp)
ff
movsd  %xmm1,-0x90(%rbp)
ff
jnp    134c <updateSolutionEconomic_CFP64+0x24c>
movsd  -0xc0(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1670 <__muldc3>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  %xmm1,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm0,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movsd  0x8(%rax),%xmm0
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm0
movsd  %xmm1,(%rax)
movsd  %xmm0,0x8(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    165f <updateSolutionEconomic_CFP64+0x55f>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x128(%rbp)
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x108(%rbp)
ff
cvtss2sd %xmm0,%xmm2
movsd  %xmm2,-0x100(%rbp)
ff
movsd  -0x48(%rbp),%xmm4
movsd  %xmm4,-0xf8(%rbp)
ff
movsd  -0x40(%rbp),%xmm5
movsd  %xmm5,-0xf0(%rbp)
ff
movaps %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movaps %xmm2,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm2
subsd  %xmm3,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
addsd  %xmm2,%xmm1
movsd  %xmm1,-0xe0(%rbp)
ff
ucomisd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  %xmm1,-0xd0(%rbp)
ff
jnp    151d <updateSolutionEconomic_CFP64+0x41d>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm1
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  %xmm1,-0xd0(%rbp)
ff
jnp    151d <updateSolutionEconomic_CFP64+0x41d>
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
call   1670 <__muldc3>
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  %xmm1,-0xd0(%rbp)
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm5
ff
movsd  -0x118(%rbp),%xmm4
ff
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  %xmm3,%xmm4
movsd  %xmm4,-0x158(%rbp)
ff
subsd  %xmm0,%xmm5
movsd  %xmm5,-0x150(%rbp)
ff
movaps %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movaps %xmm2,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm2
subsd  %xmm3,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
addsd  %xmm2,%xmm1
movsd  %xmm1,-0x140(%rbp)
ff
ucomisd %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  %xmm1,-0x130(%rbp)
ff
jnp    160c <updateSolutionEconomic_CFP64+0x50c>
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm1
movsd  %xmm0,-0x138(%rbp)
ff
movsd  %xmm1,-0x130(%rbp)
ff
jnp    160c <updateSolutionEconomic_CFP64+0x50c>
movsd  -0x150(%rbp),%xmm3
ff
movsd  -0x158(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x128(%rbp),%xmm0
ff
call   1670 <__muldc3>
movsd  %xmm0,-0x138(%rbp)
ff
movsd  %xmm1,-0x130(%rbp)
ff
movsd  -0x138(%rbp),%xmm3
ff
movsd  -0x130(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movsd  0x8(%rax),%xmm0
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm0
movsd  %xmm1,(%rax)
movsd  %xmm0,0x8(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13c3 <updateSolutionEconomic_CFP64+0x2c3>
add    $0x160,%rsp
pop    %rbp
ret
nopl   0x0(%rax,%rax,1)

x86 assembly (clang, -O2):
<updateSolutionEconomic_CFP64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdx,%r12
mov    %rsi,%r15
mov    %rdi,%rbx
movslq %ecx,%rax
lea    -0x1(%rax),%r14
mov    %r14,%rdx
shl    $0x4,%rdx
movupd (%r12,%rdx,1),%xmm6
cmp    $0x2,%eax
jl     11de <updateSolutionEconomic_CFP64+0xde>
mov    %r14d,%ebp
shl    $0x3,%rbp
xor    %r13d,%r13d
xchg   %ax,%ax
movss  (%rbx,%r13,1),%xmm0
movss  0x4(%rbx,%r13,1),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
movupd (%r12,%r13,2),%xmm2
movaps %xmm0,%xmm3
movlhps %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movaps %xmm1,%xmm5
movlhps %xmm1,%xmm5
movapd %xmm2,%xmm4
shufpd $0x1,%xmm2,%xmm4
mulpd  %xmm5,%xmm4
movapd %xmm3,%xmm5
subpd  %xmm4,%xmm5
addpd  %xmm3,%xmm4
movapd %xmm4,%xmm3
movsd  %xmm5,%xmm3
ucomisd %xmm5,%xmm5
jp     11a1 <updateSolutionEconomic_CFP64+0xa1>
subpd  %xmm3,%xmm6
add    $0x8,%r13
cmp    %r13,%rbp
jne    1140 <updateSolutionEconomic_CFP64+0x40>
jmp    11de <updateSolutionEconomic_CFP64+0xde>
unpckhpd %xmm4,%xmm4
ucomisd %xmm4,%xmm4
jnp    1192 <updateSolutionEconomic_CFP64+0x92>
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
mov    %r8,0x8(%rsp)
mov    %ecx,0x20(%rsp)
movapd %xmm6,0x10(%rsp)
call   1470 <__muldc3>
movapd 0x10(%rsp),%xmm6
mov    0x20(%rsp),%ecx
mov    0x8(%rsp),%r8
movaps %xmm0,%xmm3
movlhps %xmm1,%xmm3
jmp    1192 <updateSolutionEconomic_CFP64+0x92>
movss  (%rbx,%r14,8),%xmm0
movss  0x4(%rbx,%r14,8),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm1,%xmm3
movapd %xmm6,%xmm0
shufpd $0x1,%xmm6,%xmm0
movaps %xmm3,%xmm1
movlhps %xmm3,%xmm1
mulpd  %xmm0,%xmm1
movaps %xmm2,%xmm0
movlhps %xmm2,%xmm0
mulpd  %xmm6,%xmm0
movapd %xmm0,%xmm4
subpd  %xmm1,%xmm4
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm8
movsd  %xmm4,%xmm8
ucomisd %xmm4,%xmm4
jp     1433 <updateSolutionEconomic_CFP64+0x333>
mov    (%r8,%r14,8),%rax
shl    $0x4,%rax
movupd -0x10(%rax,%r15,1),%xmm0
addpd  %xmm8,%xmm0
movupd %xmm0,-0x10(%rax,%r15,1)
cmp    $0x2,%ecx
jl     1424 <updateSolutionEconomic_CFP64+0x324>
mov    %ecx,%eax
add    %ecx,%ecx
movslq %ecx,%rcx
mov    %r14d,%r13d
movapd %xmm8,%xmm9
unpckhpd %xmm8,%xmm9
lea    (%rbx,%rcx,8),%rbp
add    $0xfffffffffffffffc,%rbp
lea    (%rbx,%rax,8),%rbx
shl    $0x3,%r13
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtps2pd (%rbx,%r14,1),%xmm6
movsd  (%r12,%r14,2),%xmm7
movsd  0x8(%r12,%r14,2),%xmm5
movss  -0x4(%rbp,%r14,1),%xmm0
movss  0x0(%rbp,%r14,1),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm1,%xmm3
movapd %xmm8,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm9,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm0
movapd %xmm9,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm8,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm0,%xmm0
jp     1363 <updateSolutionEconomic_CFP64+0x263>
subsd  %xmm0,%xmm7
subsd  %xmm1,%xmm5
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm6,%xmm2
shufpd $0x1,%xmm6,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
mulpd  %xmm6,%xmm1
movapd %xmm1,%xmm3
subpd  %xmm2,%xmm3
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm3,%xmm0
ucomisd %xmm3,%xmm3
jp     13ce <updateSolutionEconomic_CFP64+0x2ce>
mov    (%r8,%r14,1),%rax
shl    $0x4,%rax
movupd -0x10(%rax,%r15,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%r15,1)
add    $0x8,%r14
cmp    %r14,%r13
jne    1290 <updateSolutionEconomic_CFP64+0x190>
jmp    1424 <updateSolutionEconomic_CFP64+0x324>
ucomisd %xmm1,%xmm1
jnp    12f0 <updateSolutionEconomic_CFP64+0x1f0>
movapd %xmm2,%xmm0
movapd %xmm3,%xmm1
movapd %xmm8,%xmm2
movapd %xmm9,%xmm3
mov    %r8,0x8(%rsp)
movapd %xmm8,0x20(%rsp)
movapd %xmm9,0x10(%rsp)
movapd %xmm7,0x50(%rsp)
movapd %xmm5,0x40(%rsp)
movaps %xmm6,0x30(%rsp)
call   1470 <__muldc3>
movapd 0x30(%rsp),%xmm6
movapd 0x40(%rsp),%xmm5
movapd 0x50(%rsp),%xmm7
movapd 0x10(%rsp),%xmm9
movapd 0x20(%rsp),%xmm8
mov    0x8(%rsp),%r8
jmp    12f0 <updateSolutionEconomic_CFP64+0x1f0>
unpckhpd %xmm1,%xmm1
ucomisd %xmm1,%xmm1
jnp    1337 <updateSolutionEconomic_CFP64+0x237>
movapd %xmm5,%xmm3
movapd %xmm7,%xmm2
movapd %xmm6,%xmm0
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
mov    %r8,0x8(%rsp)
movapd %xmm8,0x20(%rsp)
movapd %xmm9,0x10(%rsp)
call   1470 <__muldc3>
movapd 0x10(%rsp),%xmm9
movapd 0x20(%rsp),%xmm8
mov    0x8(%rsp),%r8
unpcklpd %xmm1,%xmm0
jmp    1337 <updateSolutionEconomic_CFP64+0x237>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
unpckhpd %xmm0,%xmm0
ucomisd %xmm0,%xmm0
jnp    1236 <updateSolutionEconomic_CFP64+0x136>
movapd %xmm6,%xmm0
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
mov    %r8,%r13
mov    %ecx,%ebp
call   1470 <__muldc3>
mov    %ebp,%ecx
mov    %r13,%r8
movapd %xmm0,%xmm8
unpcklpd %xmm1,%xmm8
jmp    1236 <updateSolutionEconomic_CFP64+0x136>
nopl   0x0(%rax,%rax,1)

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

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