void updateSolutionEconomic_CFP32(float _Complex *mat, float _Complex *x,
                                  float _Complex *r, int n, long long *Idxs) {
  int i, j, offset1, offset2;
  float _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_CFP32>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%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
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1250 <updateSolutionEconomic_CFP32+0x150>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  0x4(%rax,%rcx,8),%xmm2
movss  %xmm2,-0x7c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm4
movss  %xmm4,-0x78(%rbp)
movss  0x4(%rax,%rcx,8),%xmm5
movss  %xmm5,-0x74(%rbp)
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x70(%rbp)
addss  %xmm2,%xmm0
movss  %xmm0,-0x6c(%rbp)
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x68(%rbp)
movss  %xmm0,-0x64(%rbp)
jnp    121c <updateSolutionEconomic_CFP32+0x11c>
movss  -0x6c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm1
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x68(%rbp)
movss  %xmm0,-0x64(%rbp)
jnp    121c <updateSolutionEconomic_CFP32+0x11c>
movss  -0x74(%rbp),%xmm3
movss  -0x78(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x80(%rbp),%xmm0
call   1670 <__mulsc3>
movlpd %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
movss  %xmm1,-0x68(%rbp)
movss  %xmm0,-0x64(%rbp)
movss  -0x68(%rbp),%xmm3
movss  -0x64(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
subss  %xmm3,%xmm1
subss  %xmm2,%xmm0
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1147 <updateSolutionEconomic_CFP32+0x47>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm4
movss  %xmm4,-0xa0(%rbp)
ff
movss  0x4(%rax,%rcx,8),%xmm5
movss  %xmm5,-0x9c(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x3c(%rbp),%xmm2
movss  %xmm2,-0x94(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x90(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x88(%rbp)
ff
movss  %xmm0,-0x84(%rbp)
ff
jnp    1346 <updateSolutionEconomic_CFP32+0x246>
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x88(%rbp)
ff
movss  %xmm0,-0x84(%rbp)
ff
jnp    1346 <updateSolutionEconomic_CFP32+0x246>
movss  -0x9c(%rbp),%xmm3
ff
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x94(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm0
ff
call   1670 <__mulsc3>
movlpd %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  %xmm1,-0x88(%rbp)
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
movss  -0x40(%rbp),%xmm3
movss  -0x3c(%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
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
addss  %xmm3,%xmm1
addss  %xmm2,%xmm0
movss  %xmm1,(%rax,%rcx,8)
movss  %xmm0,0x4(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1658 <updateSolutionEconomic_CFP32+0x558>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  0x4(%rax,%rcx,8),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  0x4(%rax,%rcx,8),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,8),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  0x4(%rax,%rcx,8),%xmm2
movss  %xmm2,-0xbc(%rbp)
ff
movss  -0x40(%rbp),%xmm4
movss  %xmm4,-0xb8(%rbp)
ff
movss  -0x3c(%rbp),%xmm5
movss  %xmm5,-0xb4(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0xb0(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0xa8(%rbp)
ff
movss  %xmm0,-0xa4(%rbp)
ff
jnp    150c <updateSolutionEconomic_CFP32+0x40c>
movss  -0xac(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0xa8(%rbp)
ff
movss  %xmm0,-0xa4(%rbp)
ff
jnp    150c <updateSolutionEconomic_CFP32+0x40c>
movss  -0xb4(%rbp),%xmm3
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xbc(%rbp),%xmm1
ff
movss  -0xc0(%rbp),%xmm0
ff
call   1670 <__mulsc3>
movlpd %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  %xmm1,-0xa8(%rbp)
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xcc(%rbp),%xmm2
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm5
ff
movss  -0xc8(%rbp),%xmm4
ff
movss  -0xa8(%rbp),%xmm3
ff
movss  -0xa4(%rbp),%xmm1
ff
subss  %xmm3,%xmm4
movss  %xmm4,-0xe8(%rbp)
ff
subss  %xmm1,%xmm5
movss  %xmm5,-0xe4(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0xe0(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
jnp    1608 <updateSolutionEconomic_CFP32+0x508>
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
jnp    1608 <updateSolutionEconomic_CFP32+0x508>
movss  -0xe4(%rbp),%xmm3
ff
movss  -0xe8(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm1
ff
movss  -0xd0(%rbp),%xmm0
ff
call   1670 <__mulsc3>
movlpd %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm3
ff
movss  -0xd4(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,8),%xmm1
movss  0x4(%rax,%rcx,8),%xmm0
addss  %xmm3,%xmm1
addss  %xmm2,%xmm0
movss  %xmm1,(%rax,%rcx,8)
movss  %xmm0,0x4(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ba <updateSolutionEconomic_CFP32+0x2ba>
add    $0xf0,%rsp
pop    %rbp
ret
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)

x86 assembly (clang, -O2):
<updateSolutionEconomic_CFP32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %ecx,%r14d
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r12
movslq %ecx,%rax
lea    -0x1(%rax),%rdx
movsd  -0x8(%r15,%rax,8),%xmm7
cmp    $0x2,%eax
jl     11cd <updateSolutionEconomic_CFP32+0xcd>
mov    %edx,%ebp
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r13,8),%xmm0
movss  (%r15,%r13,8),%xmm2
movss  0x4(%r15,%r13,8),%xmm3
movaps %xmm3,%xmm1
shufps $0x0,%xmm3,%xmm1
movaps %xmm0,%xmm5
shufps $0xe1,%xmm0,%xmm5
mulps  %xmm1,%xmm5
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
mulps  %xmm0,%xmm4
movaps %xmm4,%xmm6
subps  %xmm5,%xmm6
addps  %xmm5,%xmm4
movaps %xmm4,%xmm1
shufps $0x1,%xmm6,%xmm1
shufps $0xe2,%xmm6,%xmm1
ucomiss %xmm6,%xmm6
jp     1195 <updateSolutionEconomic_CFP32+0x95>
subps  %xmm1,%xmm7
add    $0x1,%r13
cmp    %r13,%rbp
jne    1140 <updateSolutionEconomic_CFP32+0x40>
jmp    11cd <updateSolutionEconomic_CFP32+0xcd>
shufps $0x55,%xmm4,%xmm4
ucomiss %xmm4,%xmm4
jnp    1187 <updateSolutionEconomic_CFP32+0x87>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
mov    %r8,0x8(%rsp)
mov    %rdx,0x20(%rsp)
movaps %xmm7,0x10(%rsp)
call   1430 <__mulsc3>
movaps 0x10(%rsp),%xmm7
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%r8
movaps %xmm0,%xmm1
jmp    1187 <updateSolutionEconomic_CFP32+0x87>
movsd  (%r12,%rdx,8),%xmm2
movaps %xmm7,%xmm9
mulps  %xmm2,%xmm9
movaps %xmm7,%xmm0
shufps $0xe1,%xmm7,%xmm0
mulps  %xmm2,%xmm0
movaps %xmm9,%xmm1
shufps $0x55,%xmm9,%xmm1
subss  %xmm1,%xmm9
movaps %xmm0,%xmm8
shufps $0x55,%xmm0,%xmm8
addss  %xmm0,%xmm8
ucomiss %xmm9,%xmm9
jp     13ed <updateSolutionEconomic_CFP32+0x2ed>
mov    (%r8,%rdx,8),%rax
movss  -0x8(%rbx,%rax,8),%xmm0
addss  %xmm9,%xmm0
movss  -0x4(%rbx,%rax,8),%xmm1
addss  %xmm8,%xmm1
movss  %xmm0,-0x8(%rbx,%rax,8)
movss  %xmm1,-0x4(%rbx,%rax,8)
cmp    $0x2,%r14d
jl     13de <updateSolutionEconomic_CFP32+0x2de>
mov    %r14d,%eax
add    %r14d,%r14d
movslq %r14d,%rcx
mov    %edx,%r13d
movaps %xmm9,%xmm6
shufps $0x0,%xmm9,%xmm6
movaps %xmm8,%xmm7
shufps $0x0,%xmm8,%xmm7
lea    (%r12,%rcx,8),%r14
add    $0xfffffffffffffff8,%r14
lea    (%r12,%rax,8),%r12
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rbp,8),%xmm4
movsd  (%r15,%rbp,8),%xmm5
movsd  (%r14,%rbp,8),%xmm0
movaps %xmm7,%xmm1
mulps  %xmm0,%xmm1
shufps $0xe1,%xmm1,%xmm1
movaps %xmm6,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm2,%xmm3
subps  %xmm1,%xmm3
addps  %xmm1,%xmm2
movaps %xmm2,%xmm1
shufps $0x1,%xmm3,%xmm1
shufps $0xe2,%xmm3,%xmm1
ucomiss %xmm3,%xmm3
jp     130b <updateSolutionEconomic_CFP32+0x20b>
subps  %xmm1,%xmm5
movaps %xmm4,%xmm0
mulps  %xmm5,%xmm0
movaps %xmm4,%xmm2
shufps $0xe1,%xmm4,%xmm2
mulps  %xmm5,%xmm2
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
subss  %xmm1,%xmm0
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
addss  %xmm2,%xmm1
ucomiss %xmm0,%xmm0
jp     137a <updateSolutionEconomic_CFP32+0x27a>
mov    (%r8,%rbp,8),%rax
addss  -0x8(%rbx,%rax,8),%xmm0
addss  -0x4(%rbx,%rax,8),%xmm1
movss  %xmm0,-0x8(%rbx,%rax,8)
movss  %xmm1,-0x4(%rbx,%rax,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1270 <updateSolutionEconomic_CFP32+0x170>
jmp    13de <updateSolutionEconomic_CFP32+0x2de>
shufps $0x55,%xmm2,%xmm2
ucomiss %xmm2,%xmm2
jnp    12ab <updateSolutionEconomic_CFP32+0x1ab>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm9,%xmm2
movaps %xmm8,%xmm3
mov    %r8,0x8(%rsp)
movaps %xmm9,0x20(%rsp)
movaps %xmm8,0x10(%rsp)
movaps %xmm6,0x40(%rsp)
movaps %xmm7,0x30(%rsp)
movaps %xmm5,0x60(%rsp)
movaps %xmm4,0x50(%rsp)
call   1430 <__mulsc3>
movaps 0x50(%rsp),%xmm4
movaps 0x60(%rsp),%xmm5
movaps 0x30(%rsp),%xmm7
movaps 0x40(%rsp),%xmm6
movaps 0x10(%rsp),%xmm8
movaps 0x20(%rsp),%xmm9
mov    0x8(%rsp),%r8
movaps %xmm0,%xmm1
jmp    12ab <updateSolutionEconomic_CFP32+0x1ab>
ucomiss %xmm1,%xmm1
jnp    12dd <updateSolutionEconomic_CFP32+0x1dd>
movaps %xmm4,%xmm0
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movaps %xmm5,%xmm2
movaps %xmm5,%xmm3
shufps $0x55,%xmm5,%xmm3
mov    %r8,0x8(%rsp)
movaps %xmm9,0x20(%rsp)
movaps %xmm8,0x10(%rsp)
movaps %xmm6,0x40(%rsp)
movaps %xmm7,0x30(%rsp)
call   1430 <__mulsc3>
movaps 0x30(%rsp),%xmm7
movaps 0x40(%rsp),%xmm6
movaps 0x10(%rsp),%xmm8
movaps 0x20(%rsp),%xmm9
mov    0x8(%rsp),%r8
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
jmp    12dd <updateSolutionEconomic_CFP32+0x1dd>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
ucomiss %xmm8,%xmm8
jnp    120b <updateSolutionEconomic_CFP32+0x10b>
movaps %xmm7,%xmm0
movaps %xmm7,%xmm1
shufps $0x55,%xmm7,%xmm1
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
mov    %r8,%r13
mov    %rdx,%rbp
call   1430 <__mulsc3>
mov    %rbp,%rdx
mov    %r13,%r8
movaps %xmm0,%xmm9
movaps %xmm0,%xmm8
shufps $0x55,%xmm0,%xmm8
jmp    120b <updateSolutionEconomic_CFP32+0x10b>
nopl   0x0(%rax,%rax,1)

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

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