void estimate_rincf_drone(double x_est[7], const double omega[3],
                          const double acc[3], const double mag[3],
                          const double K_ss[36], const double g_e[3],
                          const double b_e[3], double dt) {
  double b_x_est[7];
  double c_x_est[7];
  double x[7];
  int i;
  double qnorm;
  double b_x[7];
  double b_g_e[6];
  double inn[6];
  int i0;
  double b_inn[7];
  double c_x[7];
  b_x_est[0] = x_est[0];
  b_x_est[1] = x_est[1];
  b_x_est[2] = x_est[2];
  b_x_est[3] = x_est[3];
  b_x_est[4] = x_est[4];
  b_x_est[5] = x_est[5];
  b_x_est[6] = x_est[6];
  c_x_est[0] = (x_est[1] * (x_est[4] - omega[0]) / 2.0 +
                x_est[2] * (x_est[5] - omega[1]) / 2.0) +
               x_est[3] * (x_est[6] - omega[2]) / 2.0;
  c_x_est[1] = (x_est[3] * (x_est[5] - omega[1]) / 2.0 -
                x_est[0] * (x_est[4] - omega[0]) / 2.0) -
               x_est[2] * (x_est[6] - omega[2]) / 2.0;
  c_x_est[2] = (x_est[1] * (x_est[6] - omega[2]) / 2.0 -
                x_est[0] * (x_est[5] - omega[1]) / 2.0) -
               x_est[3] * (x_est[4] - omega[0]) / 2.0;
  c_x_est[3] = (x_est[2] * (x_est[4] - omega[0]) / 2.0 -
                x_est[1] * (x_est[5] - omega[1]) / 2.0) -
               x_est[0] * (x_est[6] - omega[2]) / 2.0;
  c_x_est[4] = 0.0;
  c_x_est[5] = 0.0;
  c_x_est[6] = 0.0;
  for (i = 0; i < 7; i++) {
    x[i] = b_x_est[i] + c_x_est[i] * dt;
  }
  qnorm = sqrt(((x[0] * x[0] + x[1] * x[1]) + x[2] * x[2]) + x[3] * x[3]);
  b_x[0] = x[0] / qnorm;
  b_x[1] = x[1] / qnorm;
  b_x[2] = x[2] / qnorm;
  b_x[3] = x[3] / qnorm;
  b_x[4] = x[4];
  b_x[5] = x[5];
  b_x[6] = x[6];
  for (i = 0; i < 7; i++) {
    x[i] = b_x[i];
  }
  b_g_e[0] = g_e[1] * ((acc[2] * (((x[0] * x[0] - x[1] * x[1]) - x[2] * x[2]) +
                                  x[3] * x[3]) -
                        acc[0] * (2.0 * x[0] * x[2] - 2.0 * x[1] * x[3])) +
                       acc[1] * (2.0 * x[0] * x[1] + 2.0 * x[2] * x[3])) -
             g_e[2] * ((acc[1] * (((x[0] * x[0] - x[1] * x[1]) + x[2] * x[2]) -
                                  x[3] * x[3]) +
                        acc[0] * (2.0 * x[0] * x[3] + 2.0 * x[1] * x[2])) -
                       acc[2] * (2.0 * x[0] * x[1] - 2.0 * x[2] * x[3]));
  b_g_e[1] = g_e[2] * ((acc[0] * (((x[0] * x[0] + x[1] * x[1]) - x[2] * x[2]) -
                                  x[3] * x[3]) -
                        acc[1] * (2.0 * x[0] * x[3] - 2.0 * x[1] * x[2])) +
                       acc[2] * (2.0 * x[0] * x[2] + 2.0 * x[1] * x[3])) -
             g_e[0] * ((acc[2] * (((x[0] * x[0] - x[1] * x[1]) - x[2] * x[2]) +
                                  x[3] * x[3]) -
                        acc[0] * (2.0 * x[0] * x[2] - 2.0 * x[1] * x[3])) +
                       acc[1] * (2.0 * x[0] * x[1] + 2.0 * x[2] * x[3]));
  b_g_e[2] = g_e[0] * ((acc[1] * (((x[0] * x[0] - x[1] * x[1]) + x[2] * x[2]) -
                                  x[3] * x[3]) +
                        acc[0] * (2.0 * x[0] * x[3] + 2.0 * x[1] * x[2])) -
                       acc[2] * (2.0 * x[0] * x[1] - 2.0 * x[2] * x[3])) -
             g_e[1] * ((acc[0] * (((x[0] * x[0] + x[1] * x[1]) - x[2] * x[2]) -
                                  x[3] * x[3]) -
                        acc[1] * (2.0 * x[0] * x[3] - 2.0 * x[1] * x[2])) +
                       acc[2] * (2.0 * x[0] * x[2] + 2.0 * x[1] * x[3]));
  b_g_e[3] = b_e[2] * ((mag[1] * (((x[0] * x[0] - x[1] * x[1]) + x[2] * x[2]) -
                                  x[3] * x[3]) +
                        mag[0] * (2.0 * x[0] * x[3] + 2.0 * x[1] * x[2])) -
                       mag[2] * (2.0 * x[0] * x[1] - 2.0 * x[2] * x[3])) -
             b_e[1] * ((mag[2] * (((x[0] * x[0] - x[1] * x[1]) - x[2] * x[2]) +
                                  x[3] * x[3]) -
                        mag[0] * (2.0 * x[0] * x[2] - 2.0 * x[1] * x[3])) +
                       mag[1] * (2.0 * x[0] * x[1] + 2.0 * x[2] * x[3]));
  b_g_e[4] = b_e[0] * ((mag[2] * (((x[0] * x[0] - x[1] * x[1]) - x[2] * x[2]) +
                                  x[3] * x[3]) -
                        mag[0] * (2.0 * x[0] * x[2] - 2.0 * x[1] * x[3])) +
                       mag[1] * (2.0 * x[0] * x[1] + 2.0 * x[2] * x[3])) -
             b_e[2] * ((mag[0] * (((x[0] * x[0] + x[1] * x[1]) - x[2] * x[2]) -
                                  x[3] * x[3]) -
                        mag[1] * (2.0 * x[0] * x[3] - 2.0 * x[1] * x[2])) +
                       mag[2] * (2.0 * x[0] * x[2] + 2.0 * x[1] * x[3]));
  b_g_e[5] = b_e[1] * ((mag[0] * (((x[0] * x[0] + x[1] * x[1]) - x[2] * x[2]) -
                                  x[3] * x[3]) -
                        mag[1] * (2.0 * x[0] * x[3] - 2.0 * x[1] * x[2])) +
                       mag[2] * (2.0 * x[0] * x[2] + 2.0 * x[1] * x[3])) -
             b_e[0] * ((mag[1] * (((x[0] * x[0] - x[1] * x[1]) + x[2] * x[2]) -
                                  x[3] * x[3]) +
                        mag[0] * (2.0 * x[0] * x[3] + 2.0 * x[1] * x[2])) -
                       mag[2] * (2.0 * x[0] * x[1] - 2.0 * x[2] * x[3]));
  for (i = 0; i < 6; i++) {
    inn[i] = 0.0;
    for (i0 = 0; i0 < 6; i0++) {
      inn[i] += K_ss[i + 6 * i0] * b_g_e[i0];
    }
  }
  b_inn[0] = (-inn[0] * x[1] - inn[1] * x[2]) - inn[2] * x[3];
  b_inn[1] = (inn[0] * x[0] + inn[1] * x[3]) - inn[2] * x[2];
  b_inn[2] = (inn[1] * x[0] - inn[0] * x[3]) + inn[2] * x[1];
  b_inn[3] = (inn[0] * x[2] - inn[1] * x[1]) + inn[2] * x[0];
  b_inn[4] =
      (inn[3] * (((x[0] * x[0] + x[1] * x[1]) - x[2] * x[2]) - x[3] * x[3]) +
       inn[4] * (2.0 * x[0] * x[3] + 2.0 * x[1] * x[2])) -
      inn[5] * (2.0 * x[0] * x[2] - 2.0 * x[1] * x[3]);
  b_inn[5] =
      (inn[4] * (((x[0] * x[0] - x[1] * x[1]) + x[2] * x[2]) - x[3] * x[3]) -
       inn[3] * (2.0 * x[0] * x[3] - 2.0 * x[1] * x[2])) +
      inn[5] * (2.0 * x[0] * x[1] + 2.0 * x[2] * x[3]);
  b_inn[6] =
      (inn[5] * (((x[0] * x[0] - x[1] * x[1]) - x[2] * x[2]) + x[3] * x[3]) +
       inn[3] * (2.0 * x[0] * x[2] + 2.0 * x[1] * x[3])) -
      inn[4] * (2.0 * x[0] * x[1] - 2.0 * x[2] * x[3]);
  for (i = 0; i < 7; i++) {
    x[i] += b_inn[i];
  }
  qnorm = sqrt(((x[0] * x[0] + x[1] * x[1]) + x[2] * x[2]) + x[3] * x[3]);
  c_x[0] = x[0] / qnorm;
  c_x[1] = x[1] / qnorm;
  c_x[2] = x[2] / qnorm;
  c_x[3] = x[3] / qnorm;
  c_x[4] = x[4];
  c_x[5] = x[5];
  c_x[6] = x[6];
  for (i = 0; i < 7; i++) {
    x[i] = c_x[i];
  }
  for (i = 0; i < 7; i++) {
    x_est[i] = x[i];
  }
}


x86 assembly (clang, -O0):
<estimate_rincf_drone>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1e3d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1e12(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1de3(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1dac(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1d83(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1d54(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1d1d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1cf3(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1cc5(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1c8f(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1c64(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1c36(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0xf4(%rbp)
cmpl   $0x7,-0xf4(%rbp)
jge    145d <estimate_rincf_drone+0x34d>
movslq -0xf4(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0xf4(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xf4(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1402 <estimate_rincf_drone+0x2f2>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
cmpl   $0x7,-0xf4(%rbp)
jge    159d <estimate_rincf_drone+0x48d>
movslq -0xf4(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movslq -0xf4(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    155c <estimate_rincf_drone+0x44c>
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  0x19bb(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe0(%rbp),%xmm6
ff
movsd  0x19a3(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xd8(%rbp),%xmm5
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0x1940(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm5
ff
movsd  0x1928(%rip),%xmm4
mulsd  -0xe0(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm3
movsd  0x1860(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xd8(%rbp),%xmm8
ff ff
movsd  0x1847(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xe0(%rbp),%xmm7
ff
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm3
movsd  0x1811(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm7
ff
movsd  0x17f9(%rip),%xmm6
mulsd  -0xe0(%rbp),%xmm6
ff
mulsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm6,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm6
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0x16d8(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xd8(%rbp),%xmm6
ff
movsd  0x16c0(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xe0(%rbp),%xmm5
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  0x165d(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm5
ff
movsd  0x1645(%rip),%xmm4
mulsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm3
movsd  0x157e(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe0(%rbp),%xmm8
ff ff
movsd  0x1565(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xd8(%rbp),%xmm7
ff
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm3
movsd  0x1501(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm7
ff
movsd  0x14e9(%rip),%xmm6
mulsd  -0xe0(%rbp),%xmm6
ff
mulsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  0x13f7(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xd8(%rbp),%xmm6
ff
movsd  0x13df(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xe0(%rbp),%xmm5
ff
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  0x13aa(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm5
ff
movsd  0x1392(%rip),%xmm4
mulsd  -0xe0(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm3
movsd  0x129c(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xd8(%rbp),%xmm8
ff ff
movsd  0x1283(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xe0(%rbp),%xmm7
ff
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm3
movsd  0x121f(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe0(%rbp),%xmm7
ff
movsd  0x1207(%rip),%xmm6
mulsd  -0xe8(%rbp),%xmm6
mulsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
movsd  0x1114(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xd8(%rbp),%xmm6
ff
movsd  0x10fc(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xe0(%rbp),%xmm5
ff
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  0x10c7(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm5
ff
movsd  0x10af(%rip),%xmm4
mulsd  -0xe0(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm3
movsd  0xfb9(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe0(%rbp),%xmm8
ff ff
movsd  0xfa0(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xd8(%rbp),%xmm7
ff
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm3
movsd  0xf3c(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm7
ff
movsd  0xf24(%rip),%xmm6
mulsd  -0xe0(%rbp),%xmm6
ff
mulsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
movsd  0xe32(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe0(%rbp),%xmm6
ff
movsd  0xe1a(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xd8(%rbp),%xmm5
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0xdb7(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm5
ff
movsd  0xd9f(%rip),%xmm4
mulsd  -0xe0(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm3
movsd  0xcd7(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xd8(%rbp),%xmm8
ff ff
movsd  0xcbe(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xe0(%rbp),%xmm7
ff
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm3
movsd  0xc5a(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe0(%rbp),%xmm7
ff
movsd  0xc42(%rip),%xmm6
mulsd  -0xe8(%rbp),%xmm6
ff
mulsd  -0xd8(%rbp),%xmm6
ff
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0xd8(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0xb4f(%rip),%xmm4
mulsd  -0xf0(%rbp),%xmm4
ff
movsd  -0xd8(%rbp),%xmm6
ff
movsd  0xb37(%rip),%xmm5
mulsd  -0xe8(%rbp),%xmm5
ff
mulsd  -0xe0(%rbp),%xmm5
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  0xad4(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm5
ff
movsd  0xabc(%rip),%xmm4
mulsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm4
movsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movsd  -0xe0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm6
ff
mulsd  %xmm6,%xmm3
addsd  %xmm5,%xmm3
movsd  -0xd8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm3
movsd  0x9f5(%rip),%xmm6
mulsd  -0xf0(%rbp),%xmm6
ff
movsd  -0xd8(%rbp),%xmm8
ff ff
movsd  0x9dc(%rip),%xmm7
mulsd  -0xe8(%rbp),%xmm7
ff
mulsd  -0xe0(%rbp),%xmm7
ff
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm3
movsd  0x9a6(%rip),%xmm5
mulsd  -0xf0(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm7
ff
movsd  0x98e(%rip),%xmm6
mulsd  -0xe0(%rbp),%xmm6
ff
mulsd  -0xd8(%rbp),%xmm6
ff
movq   %xmm6,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm6
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
cmpl   $0x6,-0xf4(%rbp)
jge    27a5 <estimate_rincf_drone+0x1695>
movslq -0xf4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
movl   $0x0,-0x1a4(%rbp)
cmpl   $0x6,-0x1a4(%rbp)
jge    278c <estimate_rincf_drone+0x167c>
mov    -0x28(%rbp),%rax
mov    -0xf4(%rbp),%ecx
imul   $0x6,-0x1a4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1a4(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm2
ff ff
movslq -0xf4(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    271f <estimate_rincf_drone+0x160f>
jmp    2791 <estimate_rincf_drone+0x1681>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    26f5 <estimate_rincf_drone+0x15e5>
movsd  -0x1a0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x198(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x198(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x198(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x1a0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x198(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x188(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm3
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x180(%rbp),%xmm0
ff
movsd  0x613(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm5
ff
movsd  0x5fb(%rip),%xmm4
mulsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xe0(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x5c7(%rip),%xmm2
mulsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movsd  0x5af(%rip),%xmm3
mulsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x188(%rbp),%xmm0
ff
movsd  0x4bb(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xd8(%rbp),%xmm5
ff
movsd  0x4a3(%rip),%xmm4
mulsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xe0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x441(%rip),%xmm2
mulsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  0x429(%rip),%xmm3
mulsd  -0xe0(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm3
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x188(%rbp),%xmm0
ff
movsd  0x363(%rip),%xmm3
mulsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm5
ff
movsd  0x34b(%rip),%xmm4
mulsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
movsd  0x317(%rip),%xmm2
mulsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  0x2ff(%rip),%xmm3
mulsd  -0xe0(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
cmpl   $0x7,-0xf4(%rbp)
jge    2dab <estimate_rincf_drone+0x1c9b>
movslq -0xf4(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0xf4(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    2d61 <estimate_rincf_drone+0x1c51>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
cmpl   $0x7,-0xf4(%rbp)
jge    2eeb <estimate_rincf_drone+0x1ddb>
movslq -0xf4(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movslq -0xf4(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    2eaa <estimate_rincf_drone+0x1d9a>
movl   $0x0,-0xf4(%rbp)
cmpl   $0x7,-0xf4(%rbp)
jge    2f36 <estimate_rincf_drone+0x1e26>
movslq -0xf4(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0xf4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    2ef5 <estimate_rincf_drone+0x1de5>
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<estimate_rincf_drone>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,%r12
mov    %r8,%rbx
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rdi,%r14
movupd 0x8(%rdi),%xmm9
movapd %xmm9,%xmm10
shufpd $0x1,%xmm9,%xmm10
movupd 0x20(%rdi),%xmm4
movsd  0x30(%rdi),%xmm8
movapd %xmm4,%xmm2
movapd %xmm0,%xmm14
xorpd  %xmm13,%xmm13
mulsd  %xmm13,%xmm0
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm1,0xf0(%rsp)
unpckhpd %xmm4,%xmm4
subsd  0x8(%rsi),%xmm4
unpcklpd %xmm8,%xmm2
movsd  (%rsi),%xmm5
movhpd 0x10(%rsi),%xmm5
subpd  %xmm5,%xmm2
movsd  0x18(%rdi),%xmm11
movapd %xmm9,%xmm6
unpcklpd %xmm11,%xmm6
movapd %xmm9,%xmm12
movsd  %xmm11,%xmm12
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm12,%xmm1
mulpd  %xmm3,%xmm1
mulpd  %xmm2,%xmm10
unpcklpd %xmm2,%xmm3
unpcklpd %xmm4,%xmm2
mulpd  %xmm2,%xmm6
movsd  (%rdi),%xmm15
movapd %xmm9,%xmm7
movsd  %xmm15,%xmm7
mulpd  %xmm2,%xmm7
movapd 0xe1a(%rip),%xmm2
mulpd  %xmm2,%xmm6
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm2,%xmm7
movapd %xmm6,%xmm5
subpd  %xmm7,%xmm5
addpd  %xmm6,%xmm7
mulpd  %xmm2,%xmm1
shufpd $0x1,%xmm1,%xmm1
subpd  %xmm1,%xmm5
addpd  %xmm7,%xmm1
mov    0x150(%rsp),%rbp
movsd  %xmm5,%xmm1
mulpd  %xmm2,%xmm10
unpcklpd %xmm15,%xmm9
unpcklpd %xmm4,%xmm4
mulpd  %xmm9,%xmm4
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm10
unpcklpd %xmm11,%xmm15
mulpd  %xmm15,%xmm3
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm10
unpcklpd %xmm14,%xmm14
mulpd  %xmm14,%xmm1
addpd  %xmm9,%xmm1
mulpd  %xmm10,%xmm14
addpd  %xmm12,%xmm14
addsd  %xmm8,%xmm0
movapd %xmm0,0x100(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,0x30(%rsp)
unpckhpd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm14,%xmm2
unpckhpd %xmm14,%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm14,0x10(%rsp)
movapd %xmm14,%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm13,%xmm0
jb     12c0 <estimate_rincf_drone+0x1b0>
sqrtsd %xmm0,%xmm0
jmp    12c5 <estimate_rincf_drone+0x1b5>
call   1030 <sqrt@plt>
unpcklpd %xmm0,%xmm0
movapd 0x30(%rsp),%xmm1
divpd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm6
divpd  %xmm0,%xmm6
movapd 0xd2b(%rip),%xmm4
movapd %xmm1,%xmm0
xorpd  %xmm4,%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm2,%xmm3
movapd %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
movapd %xmm5,%xmm2
xorpd  %xmm4,%xmm2
movapd %xmm4,%xmm9
movapd %xmm2,%xmm8
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
movapd %xmm1,%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm4,%xmm7
movapd %xmm1,%xmm10
movapd %xmm1,%xmm4
mulpd  %xmm1,%xmm10
unpckhpd %xmm10,%xmm10
addpd  %xmm2,%xmm10
movapd %xmm3,%xmm12
movapd %xmm3,%xmm13
movapd %xmm3,0x60(%rsp)
addsd  %xmm3,%xmm12
mulpd  0xcc0(%rip),%xmm7
movapd %xmm7,%xmm1
movapd %xmm7,%xmm14
xorpd  %xmm9,%xmm1
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
unpcklpd %xmm0,%xmm1
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm12,%xmm1
unpcklpd %xmm12,%xmm1
movapd %xmm6,%xmm7
shufpd $0x1,%xmm4,%xmm7
movapd %xmm4,%xmm15
movapd %xmm4,0x30(%rsp)
mulpd  %xmm1,%xmm7
movapd %xmm8,%xmm4
movapd %xmm8,%xmm1
shufpd $0x2,%xmm6,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm10,%xmm4
movapd %xmm4,%xmm8
unpckhpd %xmm10,%xmm10
mulsd  %xmm5,%xmm1
addsd  %xmm1,%xmm10
movapd %xmm1,%xmm3
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm1,%xmm10
movapd %xmm10,0xc0(%rsp)
movapd %xmm7,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm4,0x20(%rsp)
movsd  0x0(%r13),%xmm7
movsd  %xmm7,0x40(%rsp)
mulsd  %xmm7,%xmm4
movsd  0x10(%r13),%xmm11
movsd  %xmm11,0x48(%rsp)
mulsd  %xmm10,%xmm11
subsd  %xmm4,%xmm11
movapd %xmm13,%xmm4
mulsd  %xmm13,%xmm4
subsd  %xmm2,%xmm4
addsd  %xmm4,%xmm3
movapd %xmm5,%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm4,%xmm2
addsd  %xmm1,%xmm3
movapd %xmm3,0x80(%rsp)
subsd  %xmm1,%xmm2
unpcklpd %xmm1,%xmm1
movapd %xmm8,%xmm3
subpd  %xmm1,%xmm3
unpckhpd %xmm0,%xmm0
movapd %xmm12,0x50(%rsp)
movapd %xmm12,%xmm7
mulsd  %xmm15,%xmm7
movsd  0xbc4(%rip),%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm6,0x10(%rsp)
mulsd  %xmm6,%xmm1
addsd  %xmm7,%xmm1
movsd  %xmm1,0x8(%rsp)
subsd  %xmm0,%xmm7
movapd %xmm14,%xmm9
movapd %xmm14,%xmm13
mulpd  %xmm5,%xmm13
movapd %xmm5,%xmm10
mulsd  %xmm6,%xmm12
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
addpd  %xmm13,%xmm0
movapd %xmm0,0xb0(%rsp)
movsd  0x40(%rsp),%xmm5
movapd %xmm5,%xmm8
mulsd  %xmm0,%xmm8
movapd %xmm3,%xmm15
movapd %xmm3,%xmm14
movapd %xmm3,0x90(%rsp)
unpckhpd %xmm3,%xmm15
movsd  0x8(%r13),%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm8,%xmm1
movsd  0x48(%rsp),%xmm4
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm1
movapd 0x20(%rsp),%xmm4
unpckhpd %xmm4,%xmm4
movapd %xmm6,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm0,%xmm11
movsd  0x10(%r12),%xmm3
movsd  %xmm3,0x70(%rsp)
mulsd  %xmm3,%xmm1
movsd  0x8(%r12),%xmm3
movsd  %xmm3,0x78(%rsp)
mulsd  %xmm3,%xmm11
subsd  %xmm1,%xmm11
movapd %xmm11,0xd0(%rsp)
movapd %xmm10,%xmm1
movapd %xmm10,%xmm11
movapd %xmm10,0xe0(%rsp)
movapd %xmm9,%xmm3
mulsd  %xmm9,%xmm1
movapd %xmm12,%xmm9
subsd  %xmm1,%xmm9
movapd %xmm9,%xmm10
mulsd  %xmm6,%xmm10
movapd %xmm5,%xmm1
mulsd  %xmm14,%xmm1
movapd %xmm1,%xmm14
subsd  %xmm10,%xmm14
mulsd  0x10(%rsp),%xmm3
movapd 0x50(%rsp),%xmm5
mulsd  %xmm11,%xmm5
movapd %xmm5,%xmm11
addsd  %xmm3,%xmm11
movapd %xmm11,0xa0(%rsp)
subsd  %xmm3,%xmm5
movapd %xmm5,0x50(%rsp)
movsd  0x40(%rsp),%xmm3
mulsd  %xmm5,%xmm3
movsd  0x48(%rsp),%xmm5
movapd %xmm5,%xmm10
mulsd  0x80(%rsp),%xmm10
subsd  %xmm3,%xmm10
addsd  %xmm0,%xmm10
movapd %xmm5,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm0,%xmm14
mulsd  0x70(%rsp),%xmm14
movsd  (%r12),%xmm3
mulsd  %xmm3,%xmm10
subsd  %xmm10,%xmm14
movapd %xmm6,%xmm11
mulsd  %xmm2,%xmm11
addsd  %xmm8,%xmm11
mulsd  0x8(%rsp),%xmm5
subsd  %xmm5,%xmm11
subsd  %xmm13,%xmm12
mulsd  %xmm12,%xmm6
subsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mulsd  0x78(%rsp),%xmm1
mulsd  %xmm3,%xmm11
subsd  %xmm1,%xmm11
movsd  (%r15),%xmm10
movapd 0xb0(%rsp),%xmm6
mulsd  %xmm10,%xmm6
movsd  0x8(%r15),%xmm0
mulsd  %xmm0,%xmm15
addsd  %xmm6,%xmm15
movsd  0x10(%r15),%xmm8
mulsd  %xmm8,%xmm7
subsd  %xmm7,%xmm15
movapd 0x20(%rsp),%xmm1
mulsd  %xmm10,%xmm1
movapd %xmm8,%xmm5
mulsd  0xc0(%rsp),%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm5
movsd  0x8(%rbp),%xmm7
mulsd  %xmm7,%xmm5
movsd  0x10(%rbp),%xmm1
mulsd  %xmm1,%xmm15
subsd  %xmm5,%xmm15
movapd 0x50(%rsp),%xmm3
mulsd  %xmm10,%xmm3
movapd 0x80(%rsp),%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm9
mulsd  0x90(%rsp),%xmm10
movapd %xmm10,%xmm4
subsd  %xmm9,%xmm4
movapd %xmm8,%xmm3
mulsd  0xa0(%rsp),%xmm3
addsd  %xmm3,%xmm4
mulsd  %xmm1,%xmm4
movsd  0x0(%rbp),%xmm1
mulsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm12
subsd  %xmm12,%xmm10
addsd  %xmm3,%xmm10
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
mulsd  0x8(%rsp),%xmm8
subsd  %xmm8,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm7,%xmm10
subsd  %xmm2,%xmm10
movapd 0xd0(%rsp),%xmm13
movapd %xmm13,%xmm12
unpcklpd %xmm13,%xmm12
movupd (%rbx),%xmm0
mulpd  %xmm12,%xmm0
xorpd  %xmm1,%xmm1
addpd  %xmm1,%xmm0
movapd %xmm14,%xmm7
unpcklpd %xmm14,%xmm7
movupd 0x30(%rbx),%xmm1
mulpd  %xmm7,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm11,%xmm6
unpcklpd %xmm11,%xmm6
movupd 0x60(%rbx),%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm15,%xmm9
unpcklpd %xmm15,%xmm9
movupd 0x90(%rbx),%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm5,%xmm8
unpcklpd %xmm5,%xmm8
movupd 0xc0(%rbx),%xmm0
mulpd  %xmm8,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm10,%xmm4
unpcklpd %xmm10,%xmm4
movupd 0xf0(%rbx),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
movsd  0x10(%rbx),%xmm0
mulsd  %xmm13,%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  0x40(%rbx),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
movsd  0x70(%rbx),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  0xa0(%rbx),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd0(%rbx),%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  0x100(%rbx),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm0,%xmm2
movupd 0x18(%rbx),%xmm0
mulpd  %xmm12,%xmm0
addpd  0x7c3(%rip),%xmm0
movupd 0x48(%rbx),%xmm1
mulpd  %xmm1,%xmm7
addpd  %xmm0,%xmm7
movupd 0x78(%rbx),%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm7,%xmm0
movupd 0xa8(%rbx),%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm0,%xmm1
movupd 0xd8(%rbx),%xmm0
mulpd  %xmm8,%xmm0
addpd  %xmm1,%xmm0
movupd 0x108(%rbx),%xmm8
mulpd  %xmm4,%xmm8
addpd  %xmm0,%xmm8
mulsd  0x28(%rbx),%xmm13
mulsd  0x58(%rbx),%xmm14
xorpd  %xmm12,%xmm12
addsd  %xmm12,%xmm13
addsd  %xmm13,%xmm14
mulsd  0x88(%rbx),%xmm11
addsd  %xmm14,%xmm11
mulsd  0xb8(%rbx),%xmm15
addsd  %xmm11,%xmm15
mulsd  0xe8(%rbx),%xmm5
mulsd  0x118(%rbx),%xmm10
addsd  %xmm15,%xmm5
addsd  %xmm5,%xmm10
movapd %xmm3,%xmm0
shufpd $0x1,%xmm3,%xmm0
movapd 0x30(%rsp),%xmm1
movapd %xmm1,%xmm11
movapd 0x10(%rsp),%xmm6
unpcklpd %xmm6,%xmm11
mulpd  %xmm0,%xmm11
movapd 0x6d5(%rip),%xmm9
xorpd  %xmm9,%xmm0
movapd 0xe0(%rsp),%xmm7
unpcklpd %xmm6,%xmm7
movapd %xmm3,%xmm4
movsd  %xmm0,%xmm4
mulpd  %xmm7,%xmm4
shufpd $0x1,%xmm3,%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm4,%xmm0
unpcklpd %xmm2,%xmm2
movapd %xmm1,%xmm5
shufpd $0x1,%xmm1,%xmm5
mulpd  %xmm2,%xmm5
mulpd  %xmm6,%xmm2
subpd  %xmm2,%xmm0
movapd %xmm6,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm1,%xmm4
mulpd  %xmm3,%xmm2
subpd  %xmm11,%xmm2
addpd  %xmm2,%xmm5
movapd %xmm10,%xmm3
movapd %xmm9,%xmm1
xorpd  %xmm9,%xmm3
xorpd  %xmm8,%xmm1
movapd %xmm1,%xmm2
movapd %xmm8,%xmm1
shufpd $0x1,%xmm2,%xmm1
mulpd  0xb0(%rsp),%xmm1
movapd 0x90(%rsp),%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm10,%xmm3
mulpd  0x20(%rsp),%xmm3
addpd  %xmm2,%xmm3
addpd  0xf0(%rsp),%xmm3
movapd %xmm8,%xmm1
mulsd  0xa0(%rsp),%xmm8
mulsd  0xc0(%rsp),%xmm10
addsd  %xmm8,%xmm10
unpckhpd %xmm1,%xmm1
mulsd  0x8(%rsp),%xmm1
subsd  %xmm1,%xmm10
addsd  0x100(%rsp),%xmm10
movapd %xmm10,0x20(%rsp)
movapd 0x60(%rsp),%xmm1
unpcklpd %xmm4,%xmm1
addpd  %xmm0,%xmm1
addpd  %xmm6,%xmm5
movapd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm1,0x60(%rsp)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm5,%xmm2
unpckhpd %xmm5,%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm12,%xmm0
jb     1a80 <estimate_rincf_drone+0x970>
sqrtsd %xmm0,%xmm0
jmp    1a9d <estimate_rincf_drone+0x98d>
movapd %xmm5,0x10(%rsp)
movapd %xmm3,0x30(%rsp)
call   1030 <sqrt@plt>
movapd 0x30(%rsp),%xmm3
movapd 0x10(%rsp),%xmm5
unpcklpd %xmm0,%xmm0
movapd 0x60(%rsp),%xmm1
divpd  %xmm0,%xmm1
divpd  %xmm0,%xmm5
movupd %xmm1,(%r14)
shufpd $0x1,%xmm5,%xmm5
movupd %xmm5,0x10(%r14)
movupd %xmm3,0x20(%r14)
movaps 0x20(%rsp),%xmm0
movsd  %xmm0,0x30(%r14)
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @estimate_rincf_drone(double* %0, double* %1, double* %2, double* %3, double* %4, double* %5, double* %6, double %7) {
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double
%17 = alloca [7 x double]
%18 = alloca [7 x double]
%19 = alloca [7 x double]
%20 = alloca i32
%21 = alloca double
%22 = alloca [7 x double]
%23 = alloca [6 x double]
%24 = alloca [6 x double]
%25 = alloca i32
%26 = alloca [7 x double]
%27 = alloca [7 x double]
store double* %0, double** %9
store double* %1, double** %10
store double* %2, double** %11
store double* %3, double** %12
store double* %4, double** %13
store double* %5, double** %14
store double* %6, double** %15
store double %7, double* %16
%28 = load double*, double** %9
%29 = getelementptr inbounds double, double* %28, i64 0
%30 = load double, double* %29
%31 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 0
store double %30, double* %31
%32 = load double*, double** %9
%33 = getelementptr inbounds double, double* %32, i64 1
%34 = load double, double* %33
%35 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 1
store double %34, double* %35
%36 = load double*, double** %9
%37 = getelementptr inbounds double, double* %36, i64 2
%38 = load double, double* %37
%39 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 2
store double %38, double* %39
%40 = load double*, double** %9
%41 = getelementptr inbounds double, double* %40, i64 3
%42 = load double, double* %41
%43 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 3
store double %42, double* %43
%44 = load double*, double** %9
%45 = getelementptr inbounds double, double* %44, i64 4
%46 = load double, double* %45
%47 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 4
store double %46, double* %47
%48 = load double*, double** %9
%49 = getelementptr inbounds double, double* %48, i64 5
%50 = load double, double* %49
%51 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 5
store double %50, double* %51
%52 = load double*, double** %9
%53 = getelementptr inbounds double, double* %52, i64 6
%54 = load double, double* %53
%55 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 6
store double %54, double* %55
%56 = load double*, double** %9
%57 = getelementptr inbounds double, double* %56, i64 1
%58 = load double, double* %57
%59 = load double*, double** %9
%60 = getelementptr inbounds double, double* %59, i64 4
%61 = load double, double* %60
%62 = load double*, double** %10
%63 = getelementptr inbounds double, double* %62, i64 0
%64 = load double, double* %63
%65 = fsub double %61, %64
%66 = fmul double %58, %65
%67 = fdiv double %66, 2.000000e+00
%68 = load double*, double** %9
%69 = getelementptr inbounds double, double* %68, i64 2
%70 = load double, double* %69
%71 = load double*, double** %9
%72 = getelementptr inbounds double, double* %71, i64 5
%73 = load double, double* %72
%74 = load double*, double** %10
%75 = getelementptr inbounds double, double* %74, i64 1
%76 = load double, double* %75
%77 = fsub double %73, %76
%78 = fmul double %70, %77
%79 = fdiv double %78, 2.000000e+00
%80 = fadd double %67, %79
%81 = load double*, double** %9
%82 = getelementptr inbounds double, double* %81, i64 3
%83 = load double, double* %82
%84 = load double*, double** %9
%85 = getelementptr inbounds double, double* %84, i64 6
%86 = load double, double* %85
%87 = load double*, double** %10
%88 = getelementptr inbounds double, double* %87, i64 2
%89 = load double, double* %88
%90 = fsub double %86, %89
%91 = fmul double %83, %90
%92 = fdiv double %91, 2.000000e+00
%93 = fadd double %80, %92
%94 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 0
store double %93, double* %94
%95 = load double*, double** %9
%96 = getelementptr inbounds double, double* %95, i64 3
%97 = load double, double* %96
%98 = load double*, double** %9
%99 = getelementptr inbounds double, double* %98, i64 5
%100 = load double, double* %99
%101 = load double*, double** %10
%102 = getelementptr inbounds double, double* %101, i64 1
%103 = load double, double* %102
%104 = fsub double %100, %103
%105 = fmul double %97, %104
%106 = fdiv double %105, 2.000000e+00
%107 = load double*, double** %9
%108 = getelementptr inbounds double, double* %107, i64 0
%109 = load double, double* %108
%110 = load double*, double** %9
%111 = getelementptr inbounds double, double* %110, i64 4
%112 = load double, double* %111
%113 = load double*, double** %10
%114 = getelementptr inbounds double, double* %113, i64 0
%115 = load double, double* %114
%116 = fsub double %112, %115
%117 = fmul double %109, %116
%118 = fdiv double %117, 2.000000e+00
%119 = fsub double %106, %118
%120 = load double*, double** %9
%121 = getelementptr inbounds double, double* %120, i64 2
%122 = load double, double* %121
%123 = load double*, double** %9
%124 = getelementptr inbounds double, double* %123, i64 6
%125 = load double, double* %124
%126 = load double*, double** %10
%127 = getelementptr inbounds double, double* %126, i64 2
%128 = load double, double* %127
%129 = fsub double %125, %128
%130 = fmul double %122, %129
%131 = fdiv double %130, 2.000000e+00
%132 = fsub double %119, %131
%133 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 1
store double %132, double* %133
%134 = load double*, double** %9
%135 = getelementptr inbounds double, double* %134, i64 1
%136 = load double, double* %135
%137 = load double*, double** %9
%138 = getelementptr inbounds double, double* %137, i64 6
%139 = load double, double* %138
%140 = load double*, double** %10
%141 = getelementptr inbounds double, double* %140, i64 2
%142 = load double, double* %141
%143 = fsub double %139, %142
%144 = fmul double %136, %143
%145 = fdiv double %144, 2.000000e+00
%146 = load double*, double** %9
%147 = getelementptr inbounds double, double* %146, i64 0
%148 = load double, double* %147
%149 = load double*, double** %9
%150 = getelementptr inbounds double, double* %149, i64 5
%151 = load double, double* %150
%152 = load double*, double** %10
%153 = getelementptr inbounds double, double* %152, i64 1
%154 = load double, double* %153
%155 = fsub double %151, %154
%156 = fmul double %148, %155
%157 = fdiv double %156, 2.000000e+00
%158 = fsub double %145, %157
%159 = load double*, double** %9
%160 = getelementptr inbounds double, double* %159, i64 3
%161 = load double, double* %160
%162 = load double*, double** %9
%163 = getelementptr inbounds double, double* %162, i64 4
%164 = load double, double* %163
%165 = load double*, double** %10
%166 = getelementptr inbounds double, double* %165, i64 0
%167 = load double, double* %166
%168 = fsub double %164, %167
%169 = fmul double %161, %168
%170 = fdiv double %169, 2.000000e+00
%171 = fsub double %158, %170
%172 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 2
store double %171, double* %172
%173 = load double*, double** %9
%174 = getelementptr inbounds double, double* %173, i64 2
%175 = load double, double* %174
%176 = load double*, double** %9
%177 = getelementptr inbounds double, double* %176, i64 4
%178 = load double, double* %177
%179 = load double*, double** %10
%180 = getelementptr inbounds double, double* %179, i64 0
%181 = load double, double* %180
%182 = fsub double %178, %181
%183 = fmul double %175, %182
%184 = fdiv double %183, 2.000000e+00
%185 = load double*, double** %9
%186 = getelementptr inbounds double, double* %185, i64 1
%187 = load double, double* %186
%188 = load double*, double** %9
%189 = getelementptr inbounds double, double* %188, i64 5
%190 = load double, double* %189
%191 = load double*, double** %10
%192 = getelementptr inbounds double, double* %191, i64 1
%193 = load double, double* %192
%194 = fsub double %190, %193
%195 = fmul double %187, %194
%196 = fdiv double %195, 2.000000e+00
%197 = fsub double %184, %196
%198 = load double*, double** %9
%199 = getelementptr inbounds double, double* %198, i64 0
%200 = load double, double* %199
%201 = load double*, double** %9
%202 = getelementptr inbounds double, double* %201, i64 6
%203 = load double, double* %202
%204 = load double*, double** %10
%205 = getelementptr inbounds double, double* %204, i64 2
%206 = load double, double* %205
%207 = fsub double %203, %206
%208 = fmul double %200, %207
%209 = fdiv double %208, 2.000000e+00
%210 = fsub double %197, %209
%211 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 3
store double %210, double* %211
%212 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 4
store double 0.000000e+00, double* %212
%213 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 5
store double 0.000000e+00, double* %213
%214 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 6
store double 0.000000e+00, double* %214
store i32 0, i32* %20
br label %215
215: ; preds = %232, %8
%216 = load i32, i32* %20
%217 = icmp slt i32 %216, 7
br i1 %217, label %218, label %235
218: ; preds = %215
%219 = load i32, i32* %20
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 %220
%222 = load double, double* %221
%223 = load i32, i32* %20
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [7 x double], [7 x double]* %18, i64 0, i64 %224
%226 = load double, double* %225
%227 = load double, double* %16
%228 = call double @llvm.fmuladd.f64(double %226, double %227, double %222)
%229 = load i32, i32* %20
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 %230
store double %228, double* %231
br label %232
232: ; preds = %218
%233 = load i32, i32* %20
%234 = add nsw i32 %233, 1
store i32 %234, i32* %20
br label %215
235: ; preds = %215
%236 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%237 = load double, double* %236
%238 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%239 = load double, double* %238
%240 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%241 = load double, double* %240
%242 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%243 = load double, double* %242
%244 = fmul double %241, %243
%245 = call double @llvm.fmuladd.f64(double %237, double %239, double %244)
%246 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%247 = load double, double* %246
%248 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%249 = load double, double* %248
%250 = call double @llvm.fmuladd.f64(double %247, double %249, double %245)
%251 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%252 = load double, double* %251
%253 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%254 = load double, double* %253
%255 = call double @llvm.fmuladd.f64(double %252, double %254, double %250)
%256 = call double @sqrt(double %255)
store double %256, double* %21
%257 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%258 = load double, double* %257
%259 = load double, double* %21
%260 = fdiv double %258, %259
%261 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 0
store double %260, double* %261
%262 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%263 = load double, double* %262
%264 = load double, double* %21
%265 = fdiv double %263, %264
%266 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 1
store double %265, double* %266
%267 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%268 = load double, double* %267
%269 = load double, double* %21
%270 = fdiv double %268, %269
%271 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 2
store double %270, double* %271
%272 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%273 = load double, double* %272
%274 = load double, double* %21
%275 = fdiv double %273, %274
%276 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 3
store double %275, double* %276
%277 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 4
%278 = load double, double* %277
%279 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 4
store double %278, double* %279
%280 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 5
%281 = load double, double* %280
%282 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 5
store double %281, double* %282
%283 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 6
%284 = load double, double* %283
%285 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 6
store double %284, double* %285
store i32 0, i32* %20
br label %286
286: ; preds = %297, %235
%287 = load i32, i32* %20
%288 = icmp slt i32 %287, 7
br i1 %288, label %289, label %300
289: ; preds = %286
%290 = load i32, i32* %20
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 %291
%293 = load double, double* %292
%294 = load i32, i32* %20
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 %295
store double %293, double* %296
br label %297
297: ; preds = %289
%298 = load i32, i32* %20
%299 = add nsw i32 %298, 1
store i32 %299, i32* %20
br label %286
300: ; preds = %286
%301 = load double*, double** %14
%302 = getelementptr inbounds double, double* %301, i64 1
%303 = load double, double* %302
%304 = load double*, double** %11
%305 = getelementptr inbounds double, double* %304, i64 2
%306 = load double, double* %305
%307 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%308 = load double, double* %307
%309 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%310 = load double, double* %309
%311 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%312 = load double, double* %311
%313 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%314 = load double, double* %313
%315 = fmul double %312, %314
%316 = fneg double %315
%317 = call double @llvm.fmuladd.f64(double %308, double %310, double %316)
%318 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%319 = load double, double* %318
%320 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%321 = load double, double* %320
%322 = fneg double %319
%323 = call double @llvm.fmuladd.f64(double %322, double %321, double %317)
%324 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%325 = load double, double* %324
%326 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%327 = load double, double* %326
%328 = call double @llvm.fmuladd.f64(double %325, double %327, double %323)
%329 = load double*, double** %11
%330 = getelementptr inbounds double, double* %329, i64 0
%331 = load double, double* %330
%332 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%333 = load double, double* %332
%334 = fmul double 2.000000e+00, %333
%335 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%336 = load double, double* %335
%337 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%338 = load double, double* %337
%339 = fmul double 2.000000e+00, %338
%340 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%341 = load double, double* %340
%342 = fmul double %339, %341
%343 = fneg double %342
%344 = call double @llvm.fmuladd.f64(double %334, double %336, double %343)
%345 = fmul double %331, %344
%346 = fneg double %345
%347 = call double @llvm.fmuladd.f64(double %306, double %328, double %346)
%348 = load double*, double** %11
%349 = getelementptr inbounds double, double* %348, i64 1
%350 = load double, double* %349
%351 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%352 = load double, double* %351
%353 = fmul double 2.000000e+00, %352
%354 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%355 = load double, double* %354
%356 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%357 = load double, double* %356
%358 = fmul double 2.000000e+00, %357
%359 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%360 = load double, double* %359
%361 = fmul double %358, %360
%362 = call double @llvm.fmuladd.f64(double %353, double %355, double %361)
%363 = call double @llvm.fmuladd.f64(double %350, double %362, double %347)
%364 = load double*, double** %14
%365 = getelementptr inbounds double, double* %364, i64 2
%366 = load double, double* %365
%367 = load double*, double** %11
%368 = getelementptr inbounds double, double* %367, i64 1
%369 = load double, double* %368
%370 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%371 = load double, double* %370
%372 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%373 = load double, double* %372
%374 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%375 = load double, double* %374
%376 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%377 = load double, double* %376
%378 = fmul double %375, %377
%379 = fneg double %378
%380 = call double @llvm.fmuladd.f64(double %371, double %373, double %379)
%381 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%382 = load double, double* %381
%383 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%384 = load double, double* %383
%385 = call double @llvm.fmuladd.f64(double %382, double %384, double %380)
%386 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%387 = load double, double* %386
%388 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%389 = load double, double* %388
%390 = fneg double %387
%391 = call double @llvm.fmuladd.f64(double %390, double %389, double %385)
%392 = load double*, double** %11
%393 = getelementptr inbounds double, double* %392, i64 0
%394 = load double, double* %393
%395 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%396 = load double, double* %395
%397 = fmul double 2.000000e+00, %396
%398 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%399 = load double, double* %398
%400 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%401 = load double, double* %400
%402 = fmul double 2.000000e+00, %401
%403 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%404 = load double, double* %403
%405 = fmul double %402, %404
%406 = call double @llvm.fmuladd.f64(double %397, double %399, double %405)
%407 = fmul double %394, %406
%408 = call double @llvm.fmuladd.f64(double %369, double %391, double %407)
%409 = load double*, double** %11
%410 = getelementptr inbounds double, double* %409, i64 2
%411 = load double, double* %410
%412 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%413 = load double, double* %412
%414 = fmul double 2.000000e+00, %413
%415 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%416 = load double, double* %415
%417 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%418 = load double, double* %417
%419 = fmul double 2.000000e+00, %418
%420 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%421 = load double, double* %420
%422 = fmul double %419, %421
%423 = fneg double %422
%424 = call double @llvm.fmuladd.f64(double %414, double %416, double %423)
%425 = fneg double %411
%426 = call double @llvm.fmuladd.f64(double %425, double %424, double %408)
%427 = fmul double %366, %426
%428 = fneg double %427
%429 = call double @llvm.fmuladd.f64(double %303, double %363, double %428)
%430 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 0
store double %429, double* %430
%431 = load double*, double** %14
%432 = getelementptr inbounds double, double* %431, i64 2
%433 = load double, double* %432
%434 = load double*, double** %11
%435 = getelementptr inbounds double, double* %434, i64 0
%436 = load double, double* %435
%437 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%438 = load double, double* %437
%439 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%440 = load double, double* %439
%441 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%442 = load double, double* %441
%443 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%444 = load double, double* %443
%445 = fmul double %442, %444
%446 = call double @llvm.fmuladd.f64(double %438, double %440, double %445)
%447 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%448 = load double, double* %447
%449 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%450 = load double, double* %449
%451 = fneg double %448
%452 = call double @llvm.fmuladd.f64(double %451, double %450, double %446)
%453 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%454 = load double, double* %453
%455 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%456 = load double, double* %455
%457 = fneg double %454
%458 = call double @llvm.fmuladd.f64(double %457, double %456, double %452)
%459 = load double*, double** %11
%460 = getelementptr inbounds double, double* %459, i64 1
%461 = load double, double* %460
%462 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%463 = load double, double* %462
%464 = fmul double 2.000000e+00, %463
%465 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%466 = load double, double* %465
%467 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%468 = load double, double* %467
%469 = fmul double 2.000000e+00, %468
%470 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%471 = load double, double* %470
%472 = fmul double %469, %471
%473 = fneg double %472
%474 = call double @llvm.fmuladd.f64(double %464, double %466, double %473)
%475 = fmul double %461, %474
%476 = fneg double %475
%477 = call double @llvm.fmuladd.f64(double %436, double %458, double %476)
%478 = load double*, double** %11
%479 = getelementptr inbounds double, double* %478, i64 2
%480 = load double, double* %479
%481 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%482 = load double, double* %481
%483 = fmul double 2.000000e+00, %482
%484 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%485 = load double, double* %484
%486 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%487 = load double, double* %486
%488 = fmul double 2.000000e+00, %487
%489 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%490 = load double, double* %489
%491 = fmul double %488, %490
%492 = call double @llvm.fmuladd.f64(double %483, double %485, double %491)
%493 = call double @llvm.fmuladd.f64(double %480, double %492, double %477)
%494 = load double*, double** %14
%495 = getelementptr inbounds double, double* %494, i64 0
%496 = load double, double* %495
%497 = load double*, double** %11
%498 = getelementptr inbounds double, double* %497, i64 2
%499 = load double, double* %498
%500 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%501 = load double, double* %500
%502 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%503 = load double, double* %502
%504 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%505 = load double, double* %504
%506 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%507 = load double, double* %506
%508 = fmul double %505, %507
%509 = fneg double %508
%510 = call double @llvm.fmuladd.f64(double %501, double %503, double %509)
%511 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%512 = load double, double* %511
%513 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%514 = load double, double* %513
%515 = fneg double %512
%516 = call double @llvm.fmuladd.f64(double %515, double %514, double %510)
%517 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%518 = load double, double* %517
%519 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%520 = load double, double* %519
%521 = call double @llvm.fmuladd.f64(double %518, double %520, double %516)
%522 = load double*, double** %11
%523 = getelementptr inbounds double, double* %522, i64 0
%524 = load double, double* %523
%525 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%526 = load double, double* %525
%527 = fmul double 2.000000e+00, %526
%528 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%529 = load double, double* %528
%530 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%531 = load double, double* %530
%532 = fmul double 2.000000e+00, %531
%533 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%534 = load double, double* %533
%535 = fmul double %532, %534
%536 = fneg double %535
%537 = call double @llvm.fmuladd.f64(double %527, double %529, double %536)
%538 = fmul double %524, %537
%539 = fneg double %538
%540 = call double @llvm.fmuladd.f64(double %499, double %521, double %539)
%541 = load double*, double** %11
%542 = getelementptr inbounds double, double* %541, i64 1
%543 = load double, double* %542
%544 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%545 = load double, double* %544
%546 = fmul double 2.000000e+00, %545
%547 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%548 = load double, double* %547
%549 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%550 = load double, double* %549
%551 = fmul double 2.000000e+00, %550
%552 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%553 = load double, double* %552
%554 = fmul double %551, %553
%555 = call double @llvm.fmuladd.f64(double %546, double %548, double %554)
%556 = call double @llvm.fmuladd.f64(double %543, double %555, double %540)
%557 = fmul double %496, %556
%558 = fneg double %557
%559 = call double @llvm.fmuladd.f64(double %433, double %493, double %558)
%560 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 1
store double %559, double* %560
%561 = load double*, double** %14
%562 = getelementptr inbounds double, double* %561, i64 0
%563 = load double, double* %562
%564 = load double*, double** %11
%565 = getelementptr inbounds double, double* %564, i64 1
%566 = load double, double* %565
%567 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%568 = load double, double* %567
%569 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%570 = load double, double* %569
%571 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%572 = load double, double* %571
%573 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%574 = load double, double* %573
%575 = fmul double %572, %574
%576 = fneg double %575
%577 = call double @llvm.fmuladd.f64(double %568, double %570, double %576)
%578 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%579 = load double, double* %578
%580 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%581 = load double, double* %580
%582 = call double @llvm.fmuladd.f64(double %579, double %581, double %577)
%583 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%584 = load double, double* %583
%585 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%586 = load double, double* %585
%587 = fneg double %584
%588 = call double @llvm.fmuladd.f64(double %587, double %586, double %582)
%589 = load double*, double** %11
%590 = getelementptr inbounds double, double* %589, i64 0
%591 = load double, double* %590
%592 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%593 = load double, double* %592
%594 = fmul double 2.000000e+00, %593
%595 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%596 = load double, double* %595
%597 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%598 = load double, double* %597
%599 = fmul double 2.000000e+00, %598
%600 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%601 = load double, double* %600
%602 = fmul double %599, %601
%603 = call double @llvm.fmuladd.f64(double %594, double %596, double %602)
%604 = fmul double %591, %603
%605 = call double @llvm.fmuladd.f64(double %566, double %588, double %604)
%606 = load double*, double** %11
%607 = getelementptr inbounds double, double* %606, i64 2
%608 = load double, double* %607
%609 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%610 = load double, double* %609
%611 = fmul double 2.000000e+00, %610
%612 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%613 = load double, double* %612
%614 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%615 = load double, double* %614
%616 = fmul double 2.000000e+00, %615
%617 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%618 = load double, double* %617
%619 = fmul double %616, %618
%620 = fneg double %619
%621 = call double @llvm.fmuladd.f64(double %611, double %613, double %620)
%622 = fneg double %608
%623 = call double @llvm.fmuladd.f64(double %622, double %621, double %605)
%624 = load double*, double** %14
%625 = getelementptr inbounds double, double* %624, i64 1
%626 = load double, double* %625
%627 = load double*, double** %11
%628 = getelementptr inbounds double, double* %627, i64 0
%629 = load double, double* %628
%630 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%631 = load double, double* %630
%632 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%633 = load double, double* %632
%634 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%635 = load double, double* %634
%636 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%637 = load double, double* %636
%638 = fmul double %635, %637
%639 = call double @llvm.fmuladd.f64(double %631, double %633, double %638)
%640 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%641 = load double, double* %640
%642 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%643 = load double, double* %642
%644 = fneg double %641
%645 = call double @llvm.fmuladd.f64(double %644, double %643, double %639)
%646 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%647 = load double, double* %646
%648 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%649 = load double, double* %648
%650 = fneg double %647
%651 = call double @llvm.fmuladd.f64(double %650, double %649, double %645)
%652 = load double*, double** %11
%653 = getelementptr inbounds double, double* %652, i64 1
%654 = load double, double* %653
%655 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%656 = load double, double* %655
%657 = fmul double 2.000000e+00, %656
%658 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%659 = load double, double* %658
%660 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%661 = load double, double* %660
%662 = fmul double 2.000000e+00, %661
%663 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%664 = load double, double* %663
%665 = fmul double %662, %664
%666 = fneg double %665
%667 = call double @llvm.fmuladd.f64(double %657, double %659, double %666)
%668 = fmul double %654, %667
%669 = fneg double %668
%670 = call double @llvm.fmuladd.f64(double %629, double %651, double %669)
%671 = load double*, double** %11
%672 = getelementptr inbounds double, double* %671, i64 2
%673 = load double, double* %672
%674 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%675 = load double, double* %674
%676 = fmul double 2.000000e+00, %675
%677 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%678 = load double, double* %677
%679 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%680 = load double, double* %679
%681 = fmul double 2.000000e+00, %680
%682 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%683 = load double, double* %682
%684 = fmul double %681, %683
%685 = call double @llvm.fmuladd.f64(double %676, double %678, double %684)
%686 = call double @llvm.fmuladd.f64(double %673, double %685, double %670)
%687 = fmul double %626, %686
%688 = fneg double %687
%689 = call double @llvm.fmuladd.f64(double %563, double %623, double %688)
%690 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 2
store double %689, double* %690
%691 = load double*, double** %15
%692 = getelementptr inbounds double, double* %691, i64 2
%693 = load double, double* %692
%694 = load double*, double** %12
%695 = getelementptr inbounds double, double* %694, i64 1
%696 = load double, double* %695
%697 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%698 = load double, double* %697
%699 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%700 = load double, double* %699
%701 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%702 = load double, double* %701
%703 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%704 = load double, double* %703
%705 = fmul double %702, %704
%706 = fneg double %705
%707 = call double @llvm.fmuladd.f64(double %698, double %700, double %706)
%708 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%709 = load double, double* %708
%710 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%711 = load double, double* %710
%712 = call double @llvm.fmuladd.f64(double %709, double %711, double %707)
%713 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%714 = load double, double* %713
%715 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%716 = load double, double* %715
%717 = fneg double %714
%718 = call double @llvm.fmuladd.f64(double %717, double %716, double %712)
%719 = load double*, double** %12
%720 = getelementptr inbounds double, double* %719, i64 0
%721 = load double, double* %720
%722 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%723 = load double, double* %722
%724 = fmul double 2.000000e+00, %723
%725 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%726 = load double, double* %725
%727 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%728 = load double, double* %727
%729 = fmul double 2.000000e+00, %728
%730 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%731 = load double, double* %730
%732 = fmul double %729, %731
%733 = call double @llvm.fmuladd.f64(double %724, double %726, double %732)
%734 = fmul double %721, %733
%735 = call double @llvm.fmuladd.f64(double %696, double %718, double %734)
%736 = load double*, double** %12
%737 = getelementptr inbounds double, double* %736, i64 2
%738 = load double, double* %737
%739 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%740 = load double, double* %739
%741 = fmul double 2.000000e+00, %740
%742 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%743 = load double, double* %742
%744 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%745 = load double, double* %744
%746 = fmul double 2.000000e+00, %745
%747 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%748 = load double, double* %747
%749 = fmul double %746, %748
%750 = fneg double %749
%751 = call double @llvm.fmuladd.f64(double %741, double %743, double %750)
%752 = fneg double %738
%753 = call double @llvm.fmuladd.f64(double %752, double %751, double %735)
%754 = load double*, double** %15
%755 = getelementptr inbounds double, double* %754, i64 1
%756 = load double, double* %755
%757 = load double*, double** %12
%758 = getelementptr inbounds double, double* %757, i64 2
%759 = load double, double* %758
%760 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%761 = load double, double* %760
%762 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%763 = load double, double* %762
%764 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%765 = load double, double* %764
%766 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%767 = load double, double* %766
%768 = fmul double %765, %767
%769 = fneg double %768
%770 = call double @llvm.fmuladd.f64(double %761, double %763, double %769)
%771 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%772 = load double, double* %771
%773 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%774 = load double, double* %773
%775 = fneg double %772
%776 = call double @llvm.fmuladd.f64(double %775, double %774, double %770)
%777 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%778 = load double, double* %777
%779 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%780 = load double, double* %779
%781 = call double @llvm.fmuladd.f64(double %778, double %780, double %776)
%782 = load double*, double** %12
%783 = getelementptr inbounds double, double* %782, i64 0
%784 = load double, double* %783
%785 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%786 = load double, double* %785
%787 = fmul double 2.000000e+00, %786
%788 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%789 = load double, double* %788
%790 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%791 = load double, double* %790
%792 = fmul double 2.000000e+00, %791
%793 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%794 = load double, double* %793
%795 = fmul double %792, %794
%796 = fneg double %795
%797 = call double @llvm.fmuladd.f64(double %787, double %789, double %796)
%798 = fmul double %784, %797
%799 = fneg double %798
%800 = call double @llvm.fmuladd.f64(double %759, double %781, double %799)
%801 = load double*, double** %12
%802 = getelementptr inbounds double, double* %801, i64 1
%803 = load double, double* %802
%804 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%805 = load double, double* %804
%806 = fmul double 2.000000e+00, %805
%807 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%808 = load double, double* %807
%809 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%810 = load double, double* %809
%811 = fmul double 2.000000e+00, %810
%812 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%813 = load double, double* %812
%814 = fmul double %811, %813
%815 = call double @llvm.fmuladd.f64(double %806, double %808, double %814)
%816 = call double @llvm.fmuladd.f64(double %803, double %815, double %800)
%817 = fmul double %756, %816
%818 = fneg double %817
%819 = call double @llvm.fmuladd.f64(double %693, double %753, double %818)
%820 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 3
store double %819, double* %820
%821 = load double*, double** %15
%822 = getelementptr inbounds double, double* %821, i64 0
%823 = load double, double* %822
%824 = load double*, double** %12
%825 = getelementptr inbounds double, double* %824, i64 2
%826 = load double, double* %825
%827 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%828 = load double, double* %827
%829 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%830 = load double, double* %829
%831 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%832 = load double, double* %831
%833 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%834 = load double, double* %833
%835 = fmul double %832, %834
%836 = fneg double %835
%837 = call double @llvm.fmuladd.f64(double %828, double %830, double %836)
%838 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%839 = load double, double* %838
%840 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%841 = load double, double* %840
%842 = fneg double %839
%843 = call double @llvm.fmuladd.f64(double %842, double %841, double %837)
%844 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%845 = load double, double* %844
%846 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%847 = load double, double* %846
%848 = call double @llvm.fmuladd.f64(double %845, double %847, double %843)
%849 = load double*, double** %12
%850 = getelementptr inbounds double, double* %849, i64 0
%851 = load double, double* %850
%852 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%853 = load double, double* %852
%854 = fmul double 2.000000e+00, %853
%855 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%856 = load double, double* %855
%857 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%858 = load double, double* %857
%859 = fmul double 2.000000e+00, %858
%860 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%861 = load double, double* %860
%862 = fmul double %859, %861
%863 = fneg double %862
%864 = call double @llvm.fmuladd.f64(double %854, double %856, double %863)
%865 = fmul double %851, %864
%866 = fneg double %865
%867 = call double @llvm.fmuladd.f64(double %826, double %848, double %866)
%868 = load double*, double** %12
%869 = getelementptr inbounds double, double* %868, i64 1
%870 = load double, double* %869
%871 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%872 = load double, double* %871
%873 = fmul double 2.000000e+00, %872
%874 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%875 = load double, double* %874
%876 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%877 = load double, double* %876
%878 = fmul double 2.000000e+00, %877
%879 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%880 = load double, double* %879
%881 = fmul double %878, %880
%882 = call double @llvm.fmuladd.f64(double %873, double %875, double %881)
%883 = call double @llvm.fmuladd.f64(double %870, double %882, double %867)
%884 = load double*, double** %15
%885 = getelementptr inbounds double, double* %884, i64 2
%886 = load double, double* %885
%887 = load double*, double** %12
%888 = getelementptr inbounds double, double* %887, i64 0
%889 = load double, double* %888
%890 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%891 = load double, double* %890
%892 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%893 = load double, double* %892
%894 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%895 = load double, double* %894
%896 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%897 = load double, double* %896
%898 = fmul double %895, %897
%899 = call double @llvm.fmuladd.f64(double %891, double %893, double %898)
%900 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%901 = load double, double* %900
%902 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%903 = load double, double* %902
%904 = fneg double %901
%905 = call double @llvm.fmuladd.f64(double %904, double %903, double %899)
%906 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%907 = load double, double* %906
%908 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%909 = load double, double* %908
%910 = fneg double %907
%911 = call double @llvm.fmuladd.f64(double %910, double %909, double %905)
%912 = load double*, double** %12
%913 = getelementptr inbounds double, double* %912, i64 1
%914 = load double, double* %913
%915 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%916 = load double, double* %915
%917 = fmul double 2.000000e+00, %916
%918 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%919 = load double, double* %918
%920 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%921 = load double, double* %920
%922 = fmul double 2.000000e+00, %921
%923 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%924 = load double, double* %923
%925 = fmul double %922, %924
%926 = fneg double %925
%927 = call double @llvm.fmuladd.f64(double %917, double %919, double %926)
%928 = fmul double %914, %927
%929 = fneg double %928
%930 = call double @llvm.fmuladd.f64(double %889, double %911, double %929)
%931 = load double*, double** %12
%932 = getelementptr inbounds double, double* %931, i64 2
%933 = load double, double* %932
%934 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%935 = load double, double* %934
%936 = fmul double 2.000000e+00, %935
%937 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%938 = load double, double* %937
%939 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%940 = load double, double* %939
%941 = fmul double 2.000000e+00, %940
%942 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%943 = load double, double* %942
%944 = fmul double %941, %943
%945 = call double @llvm.fmuladd.f64(double %936, double %938, double %944)
%946 = call double @llvm.fmuladd.f64(double %933, double %945, double %930)
%947 = fmul double %886, %946
%948 = fneg double %947
%949 = call double @llvm.fmuladd.f64(double %823, double %883, double %948)
%950 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 4
store double %949, double* %950
%951 = load double*, double** %15
%952 = getelementptr inbounds double, double* %951, i64 1
%953 = load double, double* %952
%954 = load double*, double** %12
%955 = getelementptr inbounds double, double* %954, i64 0
%956 = load double, double* %955
%957 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%958 = load double, double* %957
%959 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%960 = load double, double* %959
%961 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%962 = load double, double* %961
%963 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%964 = load double, double* %963
%965 = fmul double %962, %964
%966 = call double @llvm.fmuladd.f64(double %958, double %960, double %965)
%967 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%968 = load double, double* %967
%969 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%970 = load double, double* %969
%971 = fneg double %968
%972 = call double @llvm.fmuladd.f64(double %971, double %970, double %966)
%973 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%974 = load double, double* %973
%975 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%976 = load double, double* %975
%977 = fneg double %974
%978 = call double @llvm.fmuladd.f64(double %977, double %976, double %972)
%979 = load double*, double** %12
%980 = getelementptr inbounds double, double* %979, i64 1
%981 = load double, double* %980
%982 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%983 = load double, double* %982
%984 = fmul double 2.000000e+00, %983
%985 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%986 = load double, double* %985
%987 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%988 = load double, double* %987
%989 = fmul double 2.000000e+00, %988
%990 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%991 = load double, double* %990
%992 = fmul double %989, %991
%993 = fneg double %992
%994 = call double @llvm.fmuladd.f64(double %984, double %986, double %993)
%995 = fmul double %981, %994
%996 = fneg double %995
%997 = call double @llvm.fmuladd.f64(double %956, double %978, double %996)
%998 = load double*, double** %12
%999 = getelementptr inbounds double, double* %998, i64 2
%1000 = load double, double* %999
%1001 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1002 = load double, double* %1001
%1003 = fmul double 2.000000e+00, %1002
%1004 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1005 = load double, double* %1004
%1006 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1007 = load double, double* %1006
%1008 = fmul double 2.000000e+00, %1007
%1009 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1010 = load double, double* %1009
%1011 = fmul double %1008, %1010
%1012 = call double @llvm.fmuladd.f64(double %1003, double %1005, double %1011)
%1013 = call double @llvm.fmuladd.f64(double %1000, double %1012, double %997)
%1014 = load double*, double** %15
%1015 = getelementptr inbounds double, double* %1014, i64 0
%1016 = load double, double* %1015
%1017 = load double*, double** %12
%1018 = getelementptr inbounds double, double* %1017, i64 1
%1019 = load double, double* %1018
%1020 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1021 = load double, double* %1020
%1022 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1023 = load double, double* %1022
%1024 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1025 = load double, double* %1024
%1026 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1027 = load double, double* %1026
%1028 = fmul double %1025, %1027
%1029 = fneg double %1028
%1030 = call double @llvm.fmuladd.f64(double %1021, double %1023, double %1029)
%1031 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1032 = load double, double* %1031
%1033 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1034 = load double, double* %1033
%1035 = call double @llvm.fmuladd.f64(double %1032, double %1034, double %1030)
%1036 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1037 = load double, double* %1036
%1038 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1039 = load double, double* %1038
%1040 = fneg double %1037
%1041 = call double @llvm.fmuladd.f64(double %1040, double %1039, double %1035)
%1042 = load double*, double** %12
%1043 = getelementptr inbounds double, double* %1042, i64 0
%1044 = load double, double* %1043
%1045 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1046 = load double, double* %1045
%1047 = fmul double 2.000000e+00, %1046
%1048 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1049 = load double, double* %1048
%1050 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1051 = load double, double* %1050
%1052 = fmul double 2.000000e+00, %1051
%1053 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1054 = load double, double* %1053
%1055 = fmul double %1052, %1054
%1056 = call double @llvm.fmuladd.f64(double %1047, double %1049, double %1055)
%1057 = fmul double %1044, %1056
%1058 = call double @llvm.fmuladd.f64(double %1019, double %1041, double %1057)
%1059 = load double*, double** %12
%1060 = getelementptr inbounds double, double* %1059, i64 2
%1061 = load double, double* %1060
%1062 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1063 = load double, double* %1062
%1064 = fmul double 2.000000e+00, %1063
%1065 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1066 = load double, double* %1065
%1067 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1068 = load double, double* %1067
%1069 = fmul double 2.000000e+00, %1068
%1070 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1071 = load double, double* %1070
%1072 = fmul double %1069, %1071
%1073 = fneg double %1072
%1074 = call double @llvm.fmuladd.f64(double %1064, double %1066, double %1073)
%1075 = fneg double %1061
%1076 = call double @llvm.fmuladd.f64(double %1075, double %1074, double %1058)
%1077 = fmul double %1016, %1076
%1078 = fneg double %1077
%1079 = call double @llvm.fmuladd.f64(double %953, double %1013, double %1078)
%1080 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 5
store double %1079, double* %1080
store i32 0, i32* %20
br label %1081
1081: ; preds = %1113, %300
%1082 = load i32, i32* %20
%1083 = icmp slt i32 %1082, 6
br i1 %1083, label %1084, label %1116
1084: ; preds = %1081
%1085 = load i32, i32* %20
%1086 = sext i32 %1085 to i64
%1087 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 %1086
store double 0.000000e+00, double* %1087
store i32 0, i32* %25
br label %1088
1088: ; preds = %1109, %1084
%1089 = load i32, i32* %25
%1090 = icmp slt i32 %1089, 6
br i1 %1090, label %1091, label %1112
1091: ; preds = %1088
%1092 = load double*, double** %13
%1093 = load i32, i32* %20
%1094 = load i32, i32* %25
%1095 = mul nsw i32 6, %1094
%1096 = add nsw i32 %1093, %1095
%1097 = sext i32 %1096 to i64
%1098 = getelementptr inbounds double, double* %1092, i64 %1097
%1099 = load double, double* %1098
%1100 = load i32, i32* %25
%1101 = sext i32 %1100 to i64
%1102 = getelementptr inbounds [6 x double], [6 x double]* %23, i64 0, i64 %1101
%1103 = load double, double* %1102
%1104 = load i32, i32* %20
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 %1105
%1107 = load double, double* %1106
%1108 = call double @llvm.fmuladd.f64(double %1099, double %1103, double %1107)
store double %1108, double* %1106
br label %1109
1109: ; preds = %1091
%1110 = load i32, i32* %25
%1111 = add nsw i32 %1110, 1
store i32 %1111, i32* %25
br label %1088
1112: ; preds = %1088
br label %1113
1113: ; preds = %1112
%1114 = load i32, i32* %20
%1115 = add nsw i32 %1114, 1
store i32 %1115, i32* %20
br label %1081
1116: ; preds = %1081
%1117 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 0
%1118 = load double, double* %1117
%1119 = fneg double %1118
%1120 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1121 = load double, double* %1120
%1122 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 1
%1123 = load double, double* %1122
%1124 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1125 = load double, double* %1124
%1126 = fmul double %1123, %1125
%1127 = fneg double %1126
%1128 = call double @llvm.fmuladd.f64(double %1119, double %1121, double %1127)
%1129 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 2
%1130 = load double, double* %1129
%1131 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1132 = load double, double* %1131
%1133 = fneg double %1130
%1134 = call double @llvm.fmuladd.f64(double %1133, double %1132, double %1128)
%1135 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 0
store double %1134, double* %1135
%1136 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 0
%1137 = load double, double* %1136
%1138 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1139 = load double, double* %1138
%1140 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 1
%1141 = load double, double* %1140
%1142 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1143 = load double, double* %1142
%1144 = fmul double %1141, %1143
%1145 = call double @llvm.fmuladd.f64(double %1137, double %1139, double %1144)
%1146 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 2
%1147 = load double, double* %1146
%1148 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1149 = load double, double* %1148
%1150 = fneg double %1147
%1151 = call double @llvm.fmuladd.f64(double %1150, double %1149, double %1145)
%1152 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 1
store double %1151, double* %1152
%1153 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 1
%1154 = load double, double* %1153
%1155 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1156 = load double, double* %1155
%1157 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 0
%1158 = load double, double* %1157
%1159 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1160 = load double, double* %1159
%1161 = fmul double %1158, %1160
%1162 = fneg double %1161
%1163 = call double @llvm.fmuladd.f64(double %1154, double %1156, double %1162)
%1164 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 2
%1165 = load double, double* %1164
%1166 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1167 = load double, double* %1166
%1168 = call double @llvm.fmuladd.f64(double %1165, double %1167, double %1163)
%1169 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 2
store double %1168, double* %1169
%1170 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 0
%1171 = load double, double* %1170
%1172 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1173 = load double, double* %1172
%1174 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 1
%1175 = load double, double* %1174
%1176 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1177 = load double, double* %1176
%1178 = fmul double %1175, %1177
%1179 = fneg double %1178
%1180 = call double @llvm.fmuladd.f64(double %1171, double %1173, double %1179)
%1181 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 2
%1182 = load double, double* %1181
%1183 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1184 = load double, double* %1183
%1185 = call double @llvm.fmuladd.f64(double %1182, double %1184, double %1180)
%1186 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 3
store double %1185, double* %1186
%1187 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 3
%1188 = load double, double* %1187
%1189 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1190 = load double, double* %1189
%1191 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1192 = load double, double* %1191
%1193 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1194 = load double, double* %1193
%1195 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1196 = load double, double* %1195
%1197 = fmul double %1194, %1196
%1198 = call double @llvm.fmuladd.f64(double %1190, double %1192, double %1197)
%1199 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1200 = load double, double* %1199
%1201 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1202 = load double, double* %1201
%1203 = fneg double %1200
%1204 = call double @llvm.fmuladd.f64(double %1203, double %1202, double %1198)
%1205 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1206 = load double, double* %1205
%1207 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1208 = load double, double* %1207
%1209 = fneg double %1206
%1210 = call double @llvm.fmuladd.f64(double %1209, double %1208, double %1204)
%1211 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 4
%1212 = load double, double* %1211
%1213 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1214 = load double, double* %1213
%1215 = fmul double 2.000000e+00, %1214
%1216 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1217 = load double, double* %1216
%1218 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1219 = load double, double* %1218
%1220 = fmul double 2.000000e+00, %1219
%1221 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1222 = load double, double* %1221
%1223 = fmul double %1220, %1222
%1224 = call double @llvm.fmuladd.f64(double %1215, double %1217, double %1223)
%1225 = fmul double %1212, %1224
%1226 = call double @llvm.fmuladd.f64(double %1188, double %1210, double %1225)
%1227 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 5
%1228 = load double, double* %1227
%1229 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1230 = load double, double* %1229
%1231 = fmul double 2.000000e+00, %1230
%1232 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1233 = load double, double* %1232
%1234 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1235 = load double, double* %1234
%1236 = fmul double 2.000000e+00, %1235
%1237 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1238 = load double, double* %1237
%1239 = fmul double %1236, %1238
%1240 = fneg double %1239
%1241 = call double @llvm.fmuladd.f64(double %1231, double %1233, double %1240)
%1242 = fneg double %1228
%1243 = call double @llvm.fmuladd.f64(double %1242, double %1241, double %1226)
%1244 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 4
store double %1243, double* %1244
%1245 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 4
%1246 = load double, double* %1245
%1247 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1248 = load double, double* %1247
%1249 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1250 = load double, double* %1249
%1251 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1252 = load double, double* %1251
%1253 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1254 = load double, double* %1253
%1255 = fmul double %1252, %1254
%1256 = fneg double %1255
%1257 = call double @llvm.fmuladd.f64(double %1248, double %1250, double %1256)
%1258 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1259 = load double, double* %1258
%1260 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1261 = load double, double* %1260
%1262 = call double @llvm.fmuladd.f64(double %1259, double %1261, double %1257)
%1263 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1264 = load double, double* %1263
%1265 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1266 = load double, double* %1265
%1267 = fneg double %1264
%1268 = call double @llvm.fmuladd.f64(double %1267, double %1266, double %1262)
%1269 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 3
%1270 = load double, double* %1269
%1271 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1272 = load double, double* %1271
%1273 = fmul double 2.000000e+00, %1272
%1274 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1275 = load double, double* %1274
%1276 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1277 = load double, double* %1276
%1278 = fmul double 2.000000e+00, %1277
%1279 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1280 = load double, double* %1279
%1281 = fmul double %1278, %1280
%1282 = fneg double %1281
%1283 = call double @llvm.fmuladd.f64(double %1273, double %1275, double %1282)
%1284 = fmul double %1270, %1283
%1285 = fneg double %1284
%1286 = call double @llvm.fmuladd.f64(double %1246, double %1268, double %1285)
%1287 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 5
%1288 = load double, double* %1287
%1289 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1290 = load double, double* %1289
%1291 = fmul double 2.000000e+00, %1290
%1292 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1293 = load double, double* %1292
%1294 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1295 = load double, double* %1294
%1296 = fmul double 2.000000e+00, %1295
%1297 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1298 = load double, double* %1297
%1299 = fmul double %1296, %1298
%1300 = call double @llvm.fmuladd.f64(double %1291, double %1293, double %1299)
%1301 = call double @llvm.fmuladd.f64(double %1288, double %1300, double %1286)
%1302 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 5
store double %1301, double* %1302
%1303 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 5
%1304 = load double, double* %1303
%1305 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1306 = load double, double* %1305
%1307 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1308 = load double, double* %1307
%1309 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1310 = load double, double* %1309
%1311 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1312 = load double, double* %1311
%1313 = fmul double %1310, %1312
%1314 = fneg double %1313
%1315 = call double @llvm.fmuladd.f64(double %1306, double %1308, double %1314)
%1316 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1317 = load double, double* %1316
%1318 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1319 = load double, double* %1318
%1320 = fneg double %1317
%1321 = call double @llvm.fmuladd.f64(double %1320, double %1319, double %1315)
%1322 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1323 = load double, double* %1322
%1324 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1325 = load double, double* %1324
%1326 = call double @llvm.fmuladd.f64(double %1323, double %1325, double %1321)
%1327 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 3
%1328 = load double, double* %1327
%1329 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1330 = load double, double* %1329
%1331 = fmul double 2.000000e+00, %1330
%1332 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1333 = load double, double* %1332
%1334 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1335 = load double, double* %1334
%1336 = fmul double 2.000000e+00, %1335
%1337 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1338 = load double, double* %1337
%1339 = fmul double %1336, %1338
%1340 = call double @llvm.fmuladd.f64(double %1331, double %1333, double %1339)
%1341 = fmul double %1328, %1340
%1342 = call double @llvm.fmuladd.f64(double %1304, double %1326, double %1341)
%1343 = getelementptr inbounds [6 x double], [6 x double]* %24, i64 0, i64 4
%1344 = load double, double* %1343
%1345 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1346 = load double, double* %1345
%1347 = fmul double 2.000000e+00, %1346
%1348 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1349 = load double, double* %1348
%1350 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1351 = load double, double* %1350
%1352 = fmul double 2.000000e+00, %1351
%1353 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1354 = load double, double* %1353
%1355 = fmul double %1352, %1354
%1356 = fneg double %1355
%1357 = call double @llvm.fmuladd.f64(double %1347, double %1349, double %1356)
%1358 = fneg double %1344
%1359 = call double @llvm.fmuladd.f64(double %1358, double %1357, double %1342)
%1360 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 6
store double %1359, double* %1360
store i32 0, i32* %20
br label %1361
1361: ; preds = %1374, %1116
%1362 = load i32, i32* %20
%1363 = icmp slt i32 %1362, 7
br i1 %1363, label %1364, label %1377
1364: ; preds = %1361
%1365 = load i32, i32* %20
%1366 = sext i32 %1365 to i64
%1367 = getelementptr inbounds [7 x double], [7 x double]* %26, i64 0, i64 %1366
%1368 = load double, double* %1367
%1369 = load i32, i32* %20
%1370 = sext i32 %1369 to i64
%1371 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 %1370
%1372 = load double, double* %1371
%1373 = fadd double %1372, %1368
store double %1373, double* %1371
br label %1374
1374: ; preds = %1364
%1375 = load i32, i32* %20
%1376 = add nsw i32 %1375, 1
store i32 %1376, i32* %20
br label %1361
1377: ; preds = %1361
%1378 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1379 = load double, double* %1378
%1380 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1381 = load double, double* %1380
%1382 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1383 = load double, double* %1382
%1384 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1385 = load double, double* %1384
%1386 = fmul double %1383, %1385
%1387 = call double @llvm.fmuladd.f64(double %1379, double %1381, double %1386)
%1388 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1389 = load double, double* %1388
%1390 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1391 = load double, double* %1390
%1392 = call double @llvm.fmuladd.f64(double %1389, double %1391, double %1387)
%1393 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1394 = load double, double* %1393
%1395 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1396 = load double, double* %1395
%1397 = call double @llvm.fmuladd.f64(double %1394, double %1396, double %1392)
%1398 = call double @sqrt(double %1397)
store double %1398, double* %21
%1399 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 0
%1400 = load double, double* %1399
%1401 = load double, double* %21
%1402 = fdiv double %1400, %1401
%1403 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 0
store double %1402, double* %1403
%1404 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 1
%1405 = load double, double* %1404
%1406 = load double, double* %21
%1407 = fdiv double %1405, %1406
%1408 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 1
store double %1407, double* %1408
%1409 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 2
%1410 = load double, double* %1409
%1411 = load double, double* %21
%1412 = fdiv double %1410, %1411
%1413 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 2
store double %1412, double* %1413
%1414 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 3
%1415 = load double, double* %1414
%1416 = load double, double* %21
%1417 = fdiv double %1415, %1416
%1418 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 3
store double %1417, double* %1418
%1419 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 4
%1420 = load double, double* %1419
%1421 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 4
store double %1420, double* %1421
%1422 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 5
%1423 = load double, double* %1422
%1424 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 5
store double %1423, double* %1424
%1425 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 6
%1426 = load double, double* %1425
%1427 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 6
store double %1426, double* %1427
store i32 0, i32* %20
br label %1428
1428: ; preds = %1439, %1377
%1429 = load i32, i32* %20
%1430 = icmp slt i32 %1429, 7
br i1 %1430, label %1431, label %1442
1431: ; preds = %1428
%1432 = load i32, i32* %20
%1433 = sext i32 %1432 to i64
%1434 = getelementptr inbounds [7 x double], [7 x double]* %27, i64 0, i64 %1433
%1435 = load double, double* %1434
%1436 = load i32, i32* %20
%1437 = sext i32 %1436 to i64
%1438 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 %1437
store double %1435, double* %1438
br label %1439
1439: ; preds = %1431
%1440 = load i32, i32* %20
%1441 = add nsw i32 %1440, 1
store i32 %1441, i32* %20
br label %1428
1442: ; preds = %1428
store i32 0, i32* %20
br label %1443
1443: ; preds = %1455, %1442
%1444 = load i32, i32* %20
%1445 = icmp slt i32 %1444, 7
br i1 %1445, label %1446, label %1458
1446: ; preds = %1443
%1447 = load i32, i32* %20
%1448 = sext i32 %1447 to i64
%1449 = getelementptr inbounds [7 x double], [7 x double]* %19, i64 0, i64 %1448
%1450 = load double, double* %1449
%1451 = load double*, double** %9
%1452 = load i32, i32* %20
%1453 = sext i32 %1452 to i64
%1454 = getelementptr inbounds double, double* %1451, i64 %1453
store double %1450, double* %1454
br label %1455
1455: ; preds = %1446
%1456 = load i32, i32* %20
%1457 = add nsw i32 %1456, 1
store i32 %1457, i32* %20
br label %1443
1458: ; preds = %1443
ret void
}

LLVM IR (-O2):
define void @estimate_rincf_drone(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double %7) {
%9 = load double, double* %0
%10 = getelementptr inbounds double, double* %0, i64 1
%11 = getelementptr inbounds double, double* %0, i64 2
%12 = bitcast double* %10 to <2 x double>*
%13 = load <2 x double>, <2 x double>* %12
%14 = shufflevector <2 x double> %13, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%15 = getelementptr inbounds double, double* %0, i64 3
%16 = load double, double* %15
%17 = getelementptr inbounds double, double* %0, i64 4
%18 = bitcast double* %17 to <2 x double>*
%19 = load <2 x double>, <2 x double>* %18
%20 = getelementptr inbounds double, double* %0, i64 6
%21 = load double, double* %20
%22 = load double, double* %1
%23 = getelementptr inbounds double, double* %1, i64 1
%24 = load double, double* %23
%25 = extractelement <2 x double> %19, i64 1
%26 = fsub double %25, %24
%27 = getelementptr inbounds double, double* %1, i64 2
%28 = load double, double* %27
%29 = insertelement <2 x double> %19, double %21, i64 1
%30 = insertelement <2 x double> poison, double %22, i64 0
%31 = insertelement <2 x double> %30, double %28, i64 1
%32 = fsub <2 x double> %29, %31
%33 = shufflevector <2 x double> %13, <2 x double> undef, <2 x i32> <i32 0, i32 undef>
%34 = insertelement <2 x double> %33, double %16, i64 1
%35 = insertelement <2 x double> %32, double %26, i64 1
%36 = fmul <2 x double> %34, %35
%37 = fmul <2 x double> %36, <double 5.000000e-01, double 5.000000e-01>
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%39 = insertelement <2 x double> poison, double %9, i64 0
%40 = insertelement <2 x double> %13, double %9, i64 0
%41 = fmul <2 x double> %40, %35
%42 = fmul <2 x double> %41, <double 5.000000e-01, double 5.000000e-01>
%43 = fsub <2 x double> %38, %42
%44 = fadd <2 x double> %38, %42
%45 = shufflevector <2 x double> %43, <2 x double> %44, <2 x i32> <i32 0, i32 3>
%46 = insertelement <2 x double> %13, double %16, i64 0
%47 = shufflevector <2 x double> %32, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%48 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> <i32 1, i32 1>
%49 = fmul <2 x double> %46, %48
%50 = fmul <2 x double> %49, <double 5.000000e-01, double 5.000000e-01>
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%52 = fsub <2 x double> %45, %51
%53 = fadd <2 x double> %45, %51
%54 = shufflevector <2 x double> %52, <2 x double> %53, <2 x i32> <i32 0, i32 3>
%55 = fmul <2 x double> %14, %32
%56 = fmul <2 x double> %55, <double 5.000000e-01, double 5.000000e-01>
%57 = insertelement <2 x double> %33, double %9, i64 1
%58 = insertelement <2 x double> poison, double %26, i64 0
%59 = shufflevector <2 x double> %58, <2 x double> poison, <2 x i32> zeroinitializer
%60 = fmul <2 x double> %57, %59
%61 = fmul <2 x double> %60, <double 5.000000e-01, double 5.000000e-01>
%62 = fsub <2 x double> %56, %61
%63 = insertelement <2 x double> %39, double %16, i64 1
%64 = shufflevector <2 x double> %47, <2 x double> %32, <2 x i32> <i32 0, i32 2>
%65 = fmul <2 x double> %63, %64
%66 = fmul <2 x double> %65, <double 5.000000e-01, double 5.000000e-01>
%67 = fsub <2 x double> %62, %66
%68 = insertelement <2 x double> poison, double %7, i64 0
%69 = shufflevector <2 x double> %68, <2 x double> poison, <2 x i32> zeroinitializer
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %54, <2 x double> %69, <2 x double> %57)
%71 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %69, <2 x double> %46)
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %69, <2 x double> zeroinitializer, <2 x double> %19)
%73 = tail call double @llvm.fmuladd.f64(double %7, double 0.000000e+00, double %21)
%74 = fmul <2 x double> %70, %70
%75 = extractelement <2 x double> %74, i64 0
%76 = extractelement <2 x double> %70, i64 1
%77 = tail call double @llvm.fmuladd.f64(double %76, double %76, double %75)
%78 = extractelement <2 x double> %71, i64 1
%79 = tail call double @llvm.fmuladd.f64(double %78, double %78, double %77)
%80 = extractelement <2 x double> %71, i64 0
%81 = tail call double @llvm.fmuladd.f64(double %80, double %80, double %79)
%82 = tail call double @sqrt(double %81)
%83 = insertelement <2 x double> poison, double %82, i64 0
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> zeroinitializer
%85 = fdiv <2 x double> %70, %84
%86 = fdiv <2 x double> %71, %84
%87 = getelementptr inbounds double, double* %5, i64 1
%88 = load double, double* %87
%89 = getelementptr inbounds double, double* %2, i64 2
%90 = load double, double* %89
%91 = extractelement <2 x double> %85, i64 0
%92 = fneg double %91
%93 = extractelement <2 x double> %85, i64 1
%94 = extractelement <2 x double> %86, i64 1
%95 = fneg double %94
%96 = shufflevector <2 x double> %85, <2 x double> poison, <2 x i32> zeroinitializer
%97 = insertelement <2 x double> %85, double %92, i64 1
%98 = fmul <2 x double> %96, %97
%99 = shufflevector <2 x double> %85, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%100 = shufflevector <2 x double> %85, <2 x double> poison, <2 x i32> <i32 1, i32 1>
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %100, <2 x double> %100, <2 x double> %98)
%102 = extractelement <2 x double> %101, i64 1
%103 = tail call double @llvm.fmuladd.f64(double %95, double %94, double %102)
%104 = extractelement <2 x double> %86, i64 0
%105 = tail call double @llvm.fmuladd.f64(double %104, double %104, double %103)
%106 = load double, double* %2
%107 = fmul double %93, 2.000000e+00
%108 = fmul <2 x double> %96, <double 2.000000e+00, double -2.000000e+00>
%109 = extractelement <2 x double> %108, i64 0
%110 = fneg double %109
%111 = fneg double %106
%112 = fmul double %94, 2.000000e+00
%113 = shufflevector <2 x double> %86, <2 x double> undef, <2 x i32> zeroinitializer
%114 = insertelement <2 x double> poison, double %110, i64 0
%115 = insertelement <2 x double> %114, double %112, i64 1
%116 = fmul <2 x double> %113, %115
%117 = insertelement <2 x double> poison, double %107, i64 0
%118 = shufflevector <2 x double> %117, <2 x double> poison, <2 x i32> zeroinitializer
%119 = shufflevector <2 x double> %86, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%120 = shufflevector <2 x double> %119, <2 x double> %85, <2 x i32> <i32 0, i32 2>
%121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %118, <2 x double> %120, <2 x double> %116)
%122 = extractelement <2 x double> %121, i64 0
%123 = fmul double %122, %111
%124 = tail call double @llvm.fmuladd.f64(double %90, double %105, double %123)
%125 = getelementptr inbounds double, double* %2, i64 1
%126 = load double, double* %125
%127 = extractelement <2 x double> %121, i64 1
%128 = tail call double @llvm.fmuladd.f64(double %126, double %127, double %124)
%129 = getelementptr inbounds double, double* %5, i64 2
%130 = load double, double* %129
%131 = fneg double %104
%132 = shufflevector <2 x double> %86, <2 x double> poison, <2 x i32> <i32 1, i32 1>
%133 = fmul <2 x double> %108, %132
%134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %118, <2 x double> %113, <2 x double> %133)
%135 = extractelement <2 x double> %134, i64 0
%136 = fmul double %106, %135
%137 = insertelement <2 x double> %86, double %95, i64 0
%138 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %137, <2 x double> %132, <2 x double> %101)
%139 = insertelement <2 x double> poison, double %131, i64 0
%140 = shufflevector <2 x double> %139, <2 x double> poison, <2 x i32> zeroinitializer
%141 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %113, <2 x double> %138)
%142 = extractelement <2 x double> %141, i64 1
%143 = tail call double @llvm.fmuladd.f64(double %126, double %142, double %136)
%144 = extractelement <2 x double> %116, i64 1
%145 = fneg double %144
%146 = tail call double @llvm.fmuladd.f64(double %107, double %91, double %145)
%147 = fneg double %90
%148 = tail call double @llvm.fmuladd.f64(double %147, double %146, double %143)
%149 = fneg double %130
%150 = fmul double %148, %149
%151 = tail call double @llvm.fmuladd.f64(double %88, double %128, double %150)
%152 = fmul double %94, %110
%153 = tail call double @llvm.fmuladd.f64(double %107, double %104, double %152)
%154 = fneg double %126
%155 = fmul double %153, %154
%156 = extractelement <2 x double> %141, i64 0
%157 = tail call double @llvm.fmuladd.f64(double %106, double %156, double %155)
%158 = fmul <2 x double> %108, %86
%159 = extractelement <2 x double> %158, i64 0
%160 = tail call double @llvm.fmuladd.f64(double %107, double %94, double %159)
%161 = tail call double @llvm.fmuladd.f64(double %90, double %160, double %157)
%162 = load double, double* %5
%163 = extractelement <2 x double> %98, i64 0
%164 = fneg double %163
%165 = tail call double @llvm.fmuladd.f64(double %93, double %93, double %164)
%166 = tail call double @llvm.fmuladd.f64(double %95, double %94, double %165)
%167 = tail call double @llvm.fmuladd.f64(double %104, double %104, double %166)
%168 = fneg double %159
%169 = tail call double @llvm.fmuladd.f64(double %107, double %94, double %168)
%170 = fmul double %169, %111
%171 = tail call double @llvm.fmuladd.f64(double %90, double %167, double %170)
%172 = tail call double @llvm.fmuladd.f64(double %126, double %127, double %171)
%173 = fneg double %162
%174 = fmul double %172, %173
%175 = tail call double @llvm.fmuladd.f64(double %130, double %161, double %174)
%176 = tail call double @llvm.fmuladd.f64(double %94, double %94, double %165)
%177 = tail call double @llvm.fmuladd.f64(double %131, double %104, double %176)
%178 = tail call double @llvm.fmuladd.f64(double %126, double %177, double %136)
%179 = fmul double %94, -2.000000e+00
%180 = fmul double %179, %104
%181 = tail call double @llvm.fmuladd.f64(double %107, double %91, double %180)
%182 = tail call double @llvm.fmuladd.f64(double %147, double %181, double %178)
%183 = extractelement <2 x double> %133, i64 0
%184 = fneg double %183
%185 = tail call double @llvm.fmuladd.f64(double %107, double %104, double %184)
%186 = fmul double %185, %154
%187 = tail call double @llvm.fmuladd.f64(double %106, double %156, double %186)
%188 = tail call double @llvm.fmuladd.f64(double %90, double %160, double %187)
%189 = fneg double %88
%190 = fmul double %188, %189
%191 = tail call double @llvm.fmuladd.f64(double %162, double %182, double %190)
%192 = getelementptr inbounds double, double* %6, i64 2
%193 = load double, double* %192
%194 = getelementptr inbounds double, double* %3, i64 1
%195 = load double, double* %194
%196 = load double, double* %3
%197 = fmul double %135, %196
%198 = tail call double @llvm.fmuladd.f64(double %195, double %142, double %197)
%199 = getelementptr inbounds double, double* %3, i64 2
%200 = load double, double* %199
%201 = fneg double %200
%202 = tail call double @llvm.fmuladd.f64(double %201, double %146, double %198)
%203 = getelementptr inbounds double, double* %6, i64 1
%204 = load double, double* %203
%205 = fneg double %196
%206 = fmul double %122, %205
%207 = tail call double @llvm.fmuladd.f64(double %200, double %105, double %206)
%208 = tail call double @llvm.fmuladd.f64(double %195, double %127, double %207)
%209 = fneg double %204
%210 = fmul double %208, %209
%211 = tail call double @llvm.fmuladd.f64(double %193, double %202, double %210)
%212 = load double, double* %6
%213 = fmul double %169, %205
%214 = tail call double @llvm.fmuladd.f64(double %200, double %167, double %213)
%215 = tail call double @llvm.fmuladd.f64(double %195, double %127, double %214)
%216 = fneg double %195
%217 = fmul double %153, %216
%218 = tail call double @llvm.fmuladd.f64(double %196, double %156, double %217)
%219 = tail call double @llvm.fmuladd.f64(double %200, double %160, double %218)
%220 = fneg double %193
%221 = fmul double %219, %220
%222 = tail call double @llvm.fmuladd.f64(double %212, double %215, double %221)
%223 = fmul double %185, %216
%224 = tail call double @llvm.fmuladd.f64(double %196, double %156, double %223)
%225 = tail call double @llvm.fmuladd.f64(double %200, double %160, double %224)
%226 = tail call double @llvm.fmuladd.f64(double %195, double %177, double %197)
%227 = tail call double @llvm.fmuladd.f64(double %201, double %181, double %226)
%228 = fneg double %212
%229 = fmul double %227, %228
%230 = tail call double @llvm.fmuladd.f64(double %204, double %225, double %229)
%231 = getelementptr inbounds double, double* %4, i64 6
%232 = getelementptr inbounds double, double* %4, i64 12
%233 = getelementptr inbounds double, double* %4, i64 18
%234 = getelementptr inbounds double, double* %4, i64 24
%235 = getelementptr inbounds double, double* %4, i64 30
%236 = bitcast double* %4 to <2 x double>*
%237 = load <2 x double>, <2 x double>* %236
%238 = insertelement <2 x double> poison, double %151, i64 0
%239 = shufflevector <2 x double> %238, <2 x double> poison, <2 x i32> zeroinitializer
%240 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %237, <2 x double> %239, <2 x double> zeroinitializer)
%241 = bitcast double* %231 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = insertelement <2 x double> poison, double %175, i64 0
%244 = shufflevector <2 x double> %243, <2 x double> poison, <2 x i32> zeroinitializer
%245 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %242, <2 x double> %244, <2 x double> %240)
%246 = bitcast double* %232 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = insertelement <2 x double> poison, double %191, i64 0
%249 = shufflevector <2 x double> %248, <2 x double> poison, <2 x i32> zeroinitializer
%250 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %247, <2 x double> %249, <2 x double> %245)
%251 = bitcast double* %233 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = insertelement <2 x double> poison, double %211, i64 0
%254 = shufflevector <2 x double> %253, <2 x double> poison, <2 x i32> zeroinitializer
%255 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %252, <2 x double> %254, <2 x double> %250)
%256 = bitcast double* %234 to <2 x double>*
%257 = load <2 x double>, <2 x double>* %256
%258 = insertelement <2 x double> poison, double %222, i64 0
%259 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> zeroinitializer
%260 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %257, <2 x double> %259, <2 x double> %255)
%261 = bitcast double* %235 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = insertelement <2 x double> poison, double %230, i64 0
%264 = shufflevector <2 x double> %263, <2 x double> poison, <2 x i32> zeroinitializer
%265 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %262, <2 x double> %264, <2 x double> %260)
%266 = getelementptr inbounds double, double* %4, i64 2
%267 = load double, double* %266
%268 = tail call double @llvm.fmuladd.f64(double %267, double %151, double 0.000000e+00)
%269 = getelementptr inbounds double, double* %4, i64 8
%270 = load double, double* %269
%271 = tail call double @llvm.fmuladd.f64(double %270, double %175, double %268)
%272 = getelementptr inbounds double, double* %4, i64 14
%273 = load double, double* %272
%274 = tail call double @llvm.fmuladd.f64(double %273, double %191, double %271)
%275 = getelementptr inbounds double, double* %4, i64 20
%276 = load double, double* %275
%277 = tail call double @llvm.fmuladd.f64(double %276, double %211, double %274)
%278 = getelementptr inbounds double, double* %4, i64 26
%279 = load double, double* %278
%280 = tail call double @llvm.fmuladd.f64(double %279, double %222, double %277)
%281 = getelementptr inbounds double, double* %4, i64 32
%282 = load double, double* %281
%283 = tail call double @llvm.fmuladd.f64(double %282, double %230, double %280)
%284 = getelementptr inbounds double, double* %4, i64 3
%285 = getelementptr inbounds double, double* %4, i64 9
%286 = getelementptr inbounds double, double* %4, i64 15
%287 = getelementptr inbounds double, double* %4, i64 21
%288 = getelementptr inbounds double, double* %4, i64 27
%289 = getelementptr inbounds double, double* %4, i64 33
%290 = bitcast double* %284 to <2 x double>*
%291 = load <2 x double>, <2 x double>* %290
%292 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %291, <2 x double> %239, <2 x double> zeroinitializer)
%293 = bitcast double* %285 to <2 x double>*
%294 = load <2 x double>, <2 x double>* %293
%295 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %294, <2 x double> %244, <2 x double> %292)
%296 = bitcast double* %286 to <2 x double>*
%297 = load <2 x double>, <2 x double>* %296
%298 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %297, <2 x double> %249, <2 x double> %295)
%299 = bitcast double* %287 to <2 x double>*
%300 = load <2 x double>, <2 x double>* %299
%301 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %300, <2 x double> %254, <2 x double> %298)
%302 = bitcast double* %288 to <2 x double>*
%303 = load <2 x double>, <2 x double>* %302
%304 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %303, <2 x double> %259, <2 x double> %301)
%305 = bitcast double* %289 to <2 x double>*
%306 = load <2 x double>, <2 x double>* %305
%307 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %306, <2 x double> %264, <2 x double> %304)
%308 = getelementptr inbounds double, double* %4, i64 5
%309 = load double, double* %308
%310 = tail call double @llvm.fmuladd.f64(double %309, double %151, double 0.000000e+00)
%311 = getelementptr inbounds double, double* %4, i64 11
%312 = load double, double* %311
%313 = tail call double @llvm.fmuladd.f64(double %312, double %175, double %310)
%314 = getelementptr inbounds double, double* %4, i64 17
%315 = load double, double* %314
%316 = tail call double @llvm.fmuladd.f64(double %315, double %191, double %313)
%317 = getelementptr inbounds double, double* %4, i64 23
%318 = load double, double* %317
%319 = tail call double @llvm.fmuladd.f64(double %318, double %211, double %316)
%320 = getelementptr inbounds double, double* %4, i64 29
%321 = load double, double* %320
%322 = tail call double @llvm.fmuladd.f64(double %321, double %222, double %319)
%323 = getelementptr inbounds double, double* %4, i64 35
%324 = load double, double* %323
%325 = tail call double @llvm.fmuladd.f64(double %324, double %230, double %322)
%326 = shufflevector <2 x double> %265, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%327 = fneg <2 x double> %326
%328 = fneg double %283
%329 = shufflevector <2 x double> %119, <2 x double> %86, <2 x i32> <i32 0, i32 2>
%330 = shufflevector <2 x double> %327, <2 x double> %265, <2 x i32> <i32 0, i32 3>
%331 = fmul <2 x double> %329, %330
%332 = shufflevector <2 x double> %327, <2 x double> %265, <2 x i32> <i32 1, i32 2>
%333 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %332, <2 x double> %85, <2 x double> %331)
%334 = insertelement <2 x double> poison, double %328, i64 0
%335 = shufflevector <2 x double> %334, <2 x double> poison, <2 x i32> zeroinitializer
%336 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %335, <2 x double> %86, <2 x double> %333)
%337 = shufflevector <2 x double> %85, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%338 = shufflevector <2 x double> %85, <2 x double> %86, <2 x i32> <i32 0, i32 2>
%339 = fmul <2 x double> %338, %327
%340 = shufflevector <2 x double> %119, <2 x double> %85, <2 x i32> <i32 0, i32 3>
%341 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %265, <2 x double> %340, <2 x double> %339)
%342 = insertelement <2 x double> poison, double %283, i64 0
%343 = shufflevector <2 x double> %342, <2 x double> poison, <2 x i32> zeroinitializer
%344 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %343, <2 x double> %337, <2 x double> %341)
%345 = fneg double %325
%346 = extractelement <2 x double> %307, i64 0
%347 = fneg double %346
%348 = extractelement <2 x double> %307, i64 1
%349 = insertelement <2 x double> poison, double %348, i64 0
%350 = insertelement <2 x double> %349, double %347, i64 1
%351 = fmul <2 x double> %134, %350
%352 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %307, <2 x double> %141, <2 x double> %351)
%353 = insertelement <2 x double> poison, double %345, i64 0
%354 = insertelement <2 x double> %353, double %325, i64 1
%355 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %354, <2 x double> %121, <2 x double> %352)
%356 = fmul double %160, %346
%357 = tail call double @llvm.fmuladd.f64(double %325, double %105, double %356)
%358 = fneg double %348
%359 = tail call double @llvm.fmuladd.f64(double %358, double %181, double %357)
%360 = shufflevector <2 x double> %99, <2 x double> %85, <2 x i32> <i32 0, i32 2>
%361 = fadd <2 x double> %336, %360
%362 = fadd <2 x double> %344, %86
%363 = fadd <2 x double> %355, %72
%364 = fadd double %359, %73
%365 = fmul <2 x double> %361, %361
%366 = extractelement <2 x double> %365, i64 1
%367 = extractelement <2 x double> %361, i64 0
%368 = tail call double @llvm.fmuladd.f64(double %367, double %367, double %366)
%369 = extractelement <2 x double> %362, i64 1
%370 = tail call double @llvm.fmuladd.f64(double %369, double %369, double %368)
%371 = extractelement <2 x double> %362, i64 0
%372 = tail call double @llvm.fmuladd.f64(double %371, double %371, double %370)
%373 = tail call double @sqrt(double %372)
%374 = insertelement <2 x double> poison, double %373, i64 0
%375 = shufflevector <2 x double> %374, <2 x double> poison, <2 x i32> zeroinitializer
%376 = fdiv <2 x double> %361, %375
%377 = fdiv <2 x double> %362, %375
%378 = bitcast double* %0 to <2 x double>*
store <2 x double> %376, <2 x double>* %378
%379 = shufflevector <2 x double> %377, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%380 = bitcast double* %11 to <2 x double>*
store <2 x double> %379, <2 x double>* %380
%381 = bitcast double* %17 to <2 x double>*
store <2 x double> %363, <2 x double>* %381
store double %364, double* %20
ret void
}