#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 */
double fabs(double);
double sqrt(double);
void Roe_Goundov_solver(double *F, double gamma, double P_L, double RHO_L,
                        double U_L, double P_R, double RHO_R, double U_R,
                        double *lambda_max, double delta) {
  double C_L, C_R;
  C_L = sqrt(gamma * P_L / RHO_L);
  C_R = sqrt(gamma * P_R / RHO_R);
  double z = 0.5 * (gamma - 1.0) / gamma;
  double H_L, H_R;
  H_L = gamma / (gamma - 1.0) * P_L / RHO_L + 0.5 * (U_L * U_L);
  H_R = gamma / (gamma - 1.0) * P_R / RHO_R + 0.5 * (U_R * U_R);
  double E_L, E_R;
  E_L = 1.0 / (gamma - 1.0) * P_L / RHO_L + 0.5 * (U_L * U_L);
  E_R = 1.0 / (gamma - 1.0) * P_R / RHO_R + 0.5 * (U_R * U_R);
  double U[3];
  U[0] = RHO_L;
  U[1] = RHO_L * U_L;
  U[2] = RHO_L * E_L;
  double RHO_S, U_S, H_S, C_S;
  RHO_S = sqrt(RHO_L * RHO_R);
  U_S = (U_L * sqrt(RHO_L) + U_R * sqrt(RHO_R)) / (sqrt(RHO_L) + sqrt(RHO_R));
  H_S = (H_L * sqrt(RHO_L) + H_R * sqrt(RHO_R)) / (sqrt(RHO_L) + sqrt(RHO_R));
  C_S = sqrt((gamma - 1.0) * (H_S - 0.5 * U_S * U_S));
  double R[3][3];
  double lambda[3], W[3];
  R[0][0] = 1.0;
  R[0][1] = 1.0;
  R[0][2] = 1.0;
  R[1][0] = U_S - C_S;
  R[1][1] = U_S;
  R[1][2] = U_S + C_S;
  R[2][0] = H_S - U_S * C_S;
  R[2][1] = 0.5 * (U_S * U_S);
  R[2][2] = H_S + U_S * C_S;
  int i, j;
  W[0] = 0.5 * ((P_R - P_L) - RHO_S * C_S * (U_R - U_L)) / (C_S * C_S);
  W[1] = (RHO_R - RHO_L) - (P_R - P_L) / (C_S * C_S);
  W[2] = 0.5 * ((P_R - P_L) + RHO_S * C_S * (U_R - U_L)) / (C_S * C_S);
  lambda[0] = U_S - C_S;
  lambda[1] = U_S;
  lambda[2] = U_S + C_S;
  *lambda_max = fabs(U_S) + C_S;
  for (j = 0; j < 3; j++) {
    if (lambda[j] <= 0) {
      for (i = 0; i < 3; i++) {
        U[i] += W[j] * R[i][j];
      }
    }
  }
  F[0] = U[0];
  F[1] = U[1] / U[0];
  F[2] = (U[2] / U[0] - 0.5 * F[1] * F[1]) * (gamma - 1.0) * F[0];
}


x86 assembly (clang, -O0):
<Roe_Goundov_solver>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
mov    %rsi,-0x48(%rbp)
movsd  %xmm7,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x10(%rbp),%xmm1
movsd  0xe8e(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xe7a(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
movsd  0xe62(%rip),%xmm2
subsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mulsd  -0x18(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  0xe36(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
movsd  0xe1f(%rip),%xmm2
subsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xdf3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xde1(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xdd5(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x18(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  0xdad(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xd9b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xd8f(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xd67(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  -0x1a8(%rbp),%xmm1
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x198(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  -0x190(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x188(%rbp),%xmm0
ff
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x170(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  -0x168(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x160(%rbp),%xmm0
ff
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0xbc2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  0xba6(%rip),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xb66(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0xb56(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0xb46(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  0xa9f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xa20(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
mulsd  -0xc0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x998(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movaps 0x919(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x158(%rbp)
cmpl   $0x3,-0x158(%rbp)
jge    17c6 <Roe_Goundov_solver+0x6b6>
movslq -0x158(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd -0x130(%rbp,%rax,8),%xmm0
ff ff
jb     17ad <Roe_Goundov_solver+0x69d>
movl   $0x0,-0x154(%rbp)
cmpl   $0x3,-0x154(%rbp)
jge    17a8 <Roe_Goundov_solver+0x698>
movslq -0x158(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movslq -0x154(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x154(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1735 <Roe_Goundov_solver+0x625>
jmp    17ad <Roe_Goundov_solver+0x69d>
jmp    17b2 <Roe_Goundov_solver+0x6a2>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1705 <Roe_Goundov_solver+0x5f5>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm1
ff
divsd  -0xa0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
movsd  0x805(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  0x7d3(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Roe_Goundov_solver>:
push   %r14
push   %rbx
sub    $0xd8,%rsp
mov    %rsi,%r14
movaps %xmm6,0xa0(%rsp)
movaps %xmm3,0xc0(%rsp)
movapd %xmm0,%xmm3
mov    %rdi,%rbx
movsd  %xmm1,0x98(%rsp)
mulsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movsd  %xmm4,0x58(%rsp)
movapd %xmm5,0x40(%rsp)
movapd %xmm2,0x30(%rsp)
movsd  %xmm3,0x10(%rsp)
ja     1731 <Roe_Goundov_solver+0x621>
mulsd  %xmm4,%xmm3
divsd  %xmm5,%xmm3
ucomisd %xmm3,%xmm1
ja     1761 <Roe_Goundov_solver+0x651>
movapd %xmm2,%xmm0
mulsd  %xmm5,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1195 <Roe_Goundov_solver+0x85>
sqrtsd %xmm0,%xmm0
jmp    11a4 <Roe_Goundov_solver+0x94>
call   1030 <sqrt@plt>
xorpd  %xmm1,%xmm1
movapd 0x30(%rsp),%xmm2
movsd  %xmm0,0xb8(%rsp)
ucomisd %xmm1,%xmm2
jb     11b9 <Roe_Goundov_solver+0xa9>
sqrtsd %xmm2,%xmm2
jmp    11c6 <Roe_Goundov_solver+0xb6>
movapd %xmm2,%xmm0
call   1030 <sqrt@plt>
movapd %xmm0,%xmm2
movapd 0x40(%rsp),%xmm0
movsd  0x10(%rsp),%xmm5
movsd  0xe26(%rip),%xmm1
addsd  %xmm5,%xmm1
movsd  %xmm1,0x90(%rsp)
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
movapd %xmm2,0x70(%rsp)
jb     1200 <Roe_Goundov_solver+0xf0>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1213 <Roe_Goundov_solver+0x103>
call   1030 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x10(%rsp),%xmm5
movapd %xmm0,%xmm1
movapd 0x30(%rsp),%xmm0
divsd  0x90(%rsp),%xmm5
ucomisd %xmm3,%xmm0
movsd  %xmm1,0x80(%rsp)
jb     1237 <Roe_Goundov_solver+0x127>
sqrtsd %xmm0,%xmm0
jmp    1248 <Roe_Goundov_solver+0x138>
movsd  %xmm5,0x10(%rsp)
call   1030 <sqrt@plt>
movsd  0x10(%rsp),%xmm5
movsd  %xmm0,0x88(%rsp)
movapd 0xa0(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
movapd 0x40(%rsp),%xmm2
movsd  0xda2(%rip),%xmm7
movapd 0xc0(%rsp),%xmm6
mulsd  %xmm6,%xmm6
movsd  0xd85(%rip),%xmm3
movapd %xmm5,%xmm14
mulsd  0x98(%rsp),%xmm14
mulsd  %xmm1,%xmm5
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm2
jb     12b1 <Roe_Goundov_solver+0x1a1>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    1306 <Roe_Goundov_solver+0x1f6>
movapd %xmm2,%xmm0
movsd  %xmm14,0x8(%rsp)
movsd  %xmm5,0x10(%rsp)
movapd %xmm6,0x60(%rsp)
movsd  %xmm1,0x28(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x28(%rsp),%xmm1
movsd  0xd2b(%rip),%xmm7
movapd 0x60(%rsp),%xmm6
movsd  0x10(%rsp),%xmm5
movsd  0xd0f(%rip),%xmm3
movsd  0x8(%rsp),%xmm14
movapd 0x40(%rsp),%xmm2
movsd  %xmm0,0xb0(%rsp)
movapd 0x30(%rsp),%xmm0
divsd  0x90(%rsp),%xmm7
mulsd  %xmm3,%xmm6
divsd  %xmm0,%xmm14
divsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm1
ucomisd %xmm4,%xmm0
movapd %xmm6,0x60(%rsp)
jb     1342 <Roe_Goundov_solver+0x232>
sqrtsd %xmm0,%xmm8
jmp    138a <Roe_Goundov_solver+0x27a>
movsd  %xmm14,0x8(%rsp)
movsd  %xmm5,0x10(%rsp)
movsd  %xmm7,0x50(%rsp)
movsd  %xmm1,0x28(%rsp)
call   1030 <sqrt@plt>
movsd  0x28(%rsp),%xmm1
movsd  0x50(%rsp),%xmm7
movapd 0x60(%rsp),%xmm6
movsd  0x10(%rsp),%xmm5
movsd  0x8(%rsp),%xmm14
movapd 0x40(%rsp),%xmm2
movapd %xmm0,%xmm8
movapd 0xa0(%rsp),%xmm0
movapd 0x70(%rsp),%xmm4
movsd  0x80(%rsp),%xmm3
mulsd  0x98(%rsp),%xmm7
mulsd  %xmm0,%xmm3
mulsd  0xc0(%rsp),%xmm4
addsd  %xmm6,%xmm14
addsd  %xmm5,%xmm1
xorpd  %xmm6,%xmm6
ucomisd %xmm6,%xmm2
jb     13d4 <Roe_Goundov_solver+0x2c4>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    1433 <Roe_Goundov_solver+0x323>
movapd %xmm2,%xmm0
movapd %xmm4,0x70(%rsp)
movsd  %xmm14,0x8(%rsp)
movsd  %xmm3,0x80(%rsp)
movsd  %xmm7,0x50(%rsp)
movsd  %xmm1,0x28(%rsp)
movsd  %xmm8,0x10(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm6,%xmm6
movsd  0x10(%rsp),%xmm8
movsd  0x28(%rsp),%xmm1
movsd  0x50(%rsp),%xmm7
movsd  0x80(%rsp),%xmm3
movsd  0x8(%rsp),%xmm14
movapd 0x70(%rsp),%xmm4
movapd 0x30(%rsp),%xmm5
mulsd  %xmm0,%xmm1
divsd  %xmm5,%xmm7
addsd  %xmm3,%xmm4
movsd  0x88(%rsp),%xmm2
addsd  0xb0(%rsp),%xmm2
mulsd  %xmm8,%xmm14
ucomisd %xmm6,%xmm5
jb     146b <Roe_Goundov_solver+0x35b>
xorps  %xmm3,%xmm3
sqrtsd %xmm5,%xmm3
jmp    14bc <Roe_Goundov_solver+0x3ac>
movapd %xmm5,%xmm0
movapd %xmm4,0x70(%rsp)
movsd  %xmm14,0x8(%rsp)
movsd  %xmm2,0x88(%rsp)
movsd  %xmm7,0x50(%rsp)
movsd  %xmm1,0x28(%rsp)
call   1030 <sqrt@plt>
movsd  0x28(%rsp),%xmm1
movsd  0x50(%rsp),%xmm7
movsd  0x88(%rsp),%xmm2
movsd  0x8(%rsp),%xmm14
movapd 0x70(%rsp),%xmm4
movapd %xmm0,%xmm3
movapd 0x40(%rsp),%xmm0
movapd 0x60(%rsp),%xmm5
addsd  %xmm7,%xmm5
divsd  %xmm2,%xmm4
addsd  %xmm1,%xmm14
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm4,0x70(%rsp)
jb     14eb <Roe_Goundov_solver+0x3db>
sqrtsd %xmm0,%xmm0
jmp    1520 <Roe_Goundov_solver+0x410>
movsd  %xmm14,0x8(%rsp)
movapd %xmm5,0x60(%rsp)
movsd  %xmm3,0x10(%rsp)
call   1030 <sqrt@plt>
movsd  0x10(%rsp),%xmm3
xorpd  %xmm1,%xmm1
movapd 0x60(%rsp),%xmm5
movsd  0x8(%rsp),%xmm14
movapd 0x70(%rsp),%xmm4
movapd 0x30(%rsp),%xmm11
addsd  %xmm0,%xmm3
divsd  %xmm3,%xmm14
movapd %xmm11,%xmm3
unpcklpd %xmm11,%xmm3
movapd 0xc0(%rsp),%xmm6
unpcklpd %xmm5,%xmm6
movsd  0xac9(%rip),%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm14,%xmm0
mulsd  0x90(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jb     1571 <Roe_Goundov_solver+0x461>
sqrtsd %xmm0,%xmm0
jmp    15a9 <Roe_Goundov_solver+0x499>
movsd  %xmm14,0x8(%rsp)
movapd %xmm3,0x10(%rsp)
movapd %xmm6,0x60(%rsp)
call   1030 <sqrt@plt>
movapd 0x60(%rsp),%xmm6
movapd 0x10(%rsp),%xmm3
movsd  0x8(%rsp),%xmm14
movapd 0x70(%rsp),%xmm4
movapd 0x30(%rsp),%xmm11
movapd 0xa0(%rsp),%xmm2
movsd  0x58(%rsp),%xmm9
movsd  0xa46(%rip),%xmm13
mulpd  %xmm6,%xmm3
movapd %xmm4,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm4,%xmm8
mulsd  %xmm0,%xmm8
subsd  0x98(%rsp),%xmm9
movsd  0xb8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
subsd  0xc0(%rsp),%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm0,%xmm12
mulsd  %xmm0,%xmm12
movapd 0xa12(%rip),%xmm1
andpd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
xorpd  %xmm10,%xmm10
ucomisd %xmm5,%xmm10
jae    162e <Roe_Goundov_solver+0x51e>
movapd %xmm11,%xmm15
jmp    1665 <Roe_Goundov_solver+0x555>
movapd %xmm9,%xmm6
subsd  %xmm2,%xmm6
mulsd  %xmm13,%xmm6
divsd  %xmm12,%xmm6
movapd %xmm14,%xmm1
subsd  %xmm8,%xmm1
movapd %xmm6,%xmm15
addsd  %xmm11,%xmm15
unpcklpd %xmm6,%xmm6
unpcklpd %xmm1,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm5,%xmm3
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm10
jb     16ab <Roe_Goundov_solver+0x59b>
movapd %xmm4,%xmm1
mulsd  %xmm4,%xmm1
movapd 0x40(%rsp),%xmm6
subsd  %xmm11,%xmm6
movapd %xmm9,%xmm5
divsd  %xmm12,%xmm5
mulsd  %xmm13,%xmm1
subsd  %xmm5,%xmm6
addsd  %xmm6,%xmm15
unpcklpd %xmm6,%xmm6
unpcklpd %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm4,%xmm3
xorpd  %xmm4,%xmm4
ucomisd %xmm0,%xmm4
jb     16df <Roe_Goundov_solver+0x5cf>
addsd  %xmm9,%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm14,%xmm8
divsd  %xmm12,%xmm2
addsd  %xmm2,%xmm15
unpcklpd %xmm2,%xmm2
unpcklpd %xmm8,%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm0,%xmm3
movsd  %xmm15,(%rbx)
movapd %xmm3,%xmm0
divsd  %xmm15,%xmm0
movsd  %xmm0,0x8(%rbx)
unpckhpd %xmm3,%xmm3
divsd  %xmm15,%xmm3
movsd  0x915(%rip),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movsd  0x90(%rsp),%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm15,%xmm0
movsd  %xmm0,0x10(%rbx)
add    $0xd8,%rsp
pop    %rbx
pop    %r14
ret
ucomisd %xmm1,%xmm0
jae    116b <Roe_Goundov_solver+0x5b>
call   1030 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  0x10(%rsp),%xmm3
movapd 0x30(%rsp),%xmm2
movapd 0x40(%rsp),%xmm5
movsd  0x58(%rsp),%xmm4
jmp    116b <Roe_Goundov_solver+0x5b>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm3
jae    117d <Roe_Goundov_solver+0x6d>
movapd %xmm3,%xmm0
call   1030 <sqrt@plt>
movapd 0x30(%rsp),%xmm2
movapd 0x40(%rsp),%xmm5
jmp    117d <Roe_Goundov_solver+0x6d>

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

LLVM IR (-O2):
define void @Roe_Goundov_solver(double* nocapture %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double* nocapture writeonly %8, double %9) {
%11 = fmul double %1, %2
%12 = fdiv double %11, %3
%13 = fcmp olt double %12, 0.000000e+00
br i1 %13, label %14, label %16
14: ; preds = %10
%15 = tail call double @sqrt(double %12)
br label %16
16: ; preds = %10, %14
%17 = fmul double %1, %5
%18 = fdiv double %17, %6
%19 = fcmp olt double %18, 0.000000e+00
br i1 %19, label %20, label %22
20: ; preds = %16
%21 = tail call double @sqrt(double %18)
br label %22
22: ; preds = %16, %20
%23 = fadd double %1, -1.000000e+00
%24 = fdiv double %1, %23
%25 = fmul double %24, %2
%26 = fdiv double %25, %3
%27 = fmul double %4, %4
%28 = tail call double @llvm.fmuladd.f64(double %27, double 5.000000e-01, double %26)
%29 = fmul double %24, %5
%30 = fdiv double %29, %6
%31 = fmul double %7, %7
%32 = tail call double @llvm.fmuladd.f64(double %31, double 5.000000e-01, double %30)
%33 = fdiv double 1.000000e+00, %23
%34 = fmul double %33, %2
%35 = fdiv double %34, %3
%36 = tail call double @llvm.fmuladd.f64(double %27, double 5.000000e-01, double %35)
%37 = insertelement <2 x double> poison, double %3, i64 0
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> zeroinitializer
%39 = insertelement <2 x double> poison, double %4, i64 0
%40 = insertelement <2 x double> %39, double %36, i64 1
%41 = fmul <2 x double> %38, %40
%42 = fmul double %3, %6
%43 = tail call double @sqrt(double %42)
%44 = tail call double @sqrt(double %3)
%45 = tail call double @sqrt(double %6)
%46 = fmul double %45, %7
%47 = tail call double @llvm.fmuladd.f64(double %4, double %44, double %46)
%48 = tail call double @sqrt(double %3)
%49 = tail call double @sqrt(double %6)
%50 = fadd double %48, %49
%51 = fdiv double %47, %50
%52 = tail call double @sqrt(double %3)
%53 = tail call double @sqrt(double %6)
%54 = fmul double %32, %53
%55 = tail call double @llvm.fmuladd.f64(double %28, double %52, double %54)
%56 = tail call double @sqrt(double %3)
%57 = tail call double @sqrt(double %6)
%58 = fadd double %56, %57
%59 = fdiv double %55, %58
%60 = fmul double %51, -5.000000e-01
%61 = tail call double @llvm.fmuladd.f64(double %60, double %51, double %59)
%62 = fmul double %23, %61
%63 = tail call double @sqrt(double %62)
%64 = fsub double %51, %63
%65 = fadd double %51, %63
%66 = fmul double %51, %51
%67 = fmul double %66, 5.000000e-01
%68 = tail call double @llvm.fmuladd.f64(double %51, double %63, double %59)
%69 = fsub double %5, %2
%70 = fmul double %43, %63
%71 = fsub double %7, %4
%72 = fneg double %70
%73 = tail call double @llvm.fmuladd.f64(double %72, double %71, double %69)
%74 = fmul double %73, 5.000000e-01
%75 = fmul double %63, %63
%76 = fdiv double %74, %75
%77 = fsub double %6, %3
%78 = fdiv double %69, %75
%79 = fsub double %77, %78
%80 = tail call double @llvm.fmuladd.f64(double %70, double %71, double %69)
%81 = fmul double %80, 5.000000e-01
%82 = fdiv double %81, %75
%83 = tail call double @llvm.fabs.f64(double %51)
%84 = fadd double %83, %63
store double %84, double* %8
%85 = fcmp ugt double %64, 0.000000e+00
br i1 %85, label %95, label %86
86: ; preds = %22
%87 = fneg double %51
%88 = tail call double @llvm.fmuladd.f64(double %87, double %63, double %59)
%89 = fadd double %76, %3
%90 = insertelement <2 x double> poison, double %76, i64 0
%91 = shufflevector <2 x double> %90, <2 x double> poison, <2 x i32> zeroinitializer
%92 = insertelement <2 x double> poison, double %64, i64 0
%93 = insertelement <2 x double> %92, double %88, i64 1
%94 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %93, <2 x double> %41)
br label %95
95: ; preds = %86, %22
%96 = phi double [ %3, %22 ], [ %89, %86 ]
%97 = phi <2 x double> [ %41, %22 ], [ %94, %86 ]
%98 = fcmp ugt double %51, 0.000000e+00
br i1 %98, label %106, label %99
99: ; preds = %95
%100 = fadd double %79, %96
%101 = insertelement <2 x double> poison, double %79, i64 0
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> zeroinitializer
%103 = insertelement <2 x double> poison, double %51, i64 0
%104 = insertelement <2 x double> %103, double %67, i64 1
%105 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %102, <2 x double> %104, <2 x double> %97)
br label %106
106: ; preds = %99, %95
%107 = phi double [ %96, %95 ], [ %100, %99 ]
%108 = phi <2 x double> [ %97, %95 ], [ %105, %99 ]
%109 = fcmp ugt double %65, 0.000000e+00
br i1 %109, label %117, label %110
110: ; preds = %106
%111 = fadd double %82, %107
%112 = insertelement <2 x double> poison, double %82, i64 0
%113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> zeroinitializer
%114 = insertelement <2 x double> poison, double %65, i64 0
%115 = insertelement <2 x double> %114, double %68, i64 1
%116 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %113, <2 x double> %115, <2 x double> %108)
br label %117
117: ; preds = %110, %106
%118 = phi double [ %107, %106 ], [ %111, %110 ]
%119 = phi <2 x double> [ %108, %106 ], [ %116, %110 ]
store double %118, double* %0
%120 = extractelement <2 x double> %119, i64 0
%121 = fdiv double %120, %118
%122 = getelementptr inbounds double, double* %0, i64 1
store double %121, double* %122
%123 = extractelement <2 x double> %119, i64 1
%124 = fdiv double %123, %118
%125 = fmul double %121, -5.000000e-01
%126 = tail call double @llvm.fmuladd.f64(double %125, double %121, double %124)
%127 = fmul double %23, %126
%128 = fmul double %118, %127
%129 = getelementptr inbounds double, double* %0, i64 2
store double %128, double* %129
ret void
}