#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ epipole(double *, double const *);
void FDso(const double *u, const double *F, double *p, double *sgn, int len) {
  double rx, ry, rwc, ryc, rxc, r;
  int i;
  double ec[3];
  double sx, sy;
  epipole(ec, F);
  for (i = 1; i <= len; i++) {
    rxc = (*F) * (*(u + 3)) + (*(F + 3)) * (*(u + 4)) + (*(F + 6)) * (*(u + 5));
    ryc = (*(F + 1)) * (*(u + 3)) + (*(F + 4)) * (*(u + 4)) +
          (*(F + 7)) * (*(u + 5));
    rwc = (*(F + 2)) * (*(u + 3)) + (*(F + 5)) * (*(u + 4)) +
          (*(F + 8)) * (*(u + 5));
    r = ((*(u)) * rxc + (*(u + 1)) * ryc + (*(u + 2)) * rwc);
    rx = (*F) * (*(u)) + (*(F + 1)) * (*(u + 1)) + (*(F + 2)) * (*(u + 2));
    ry =
        (*(F + 3)) * (*(u)) + (*(F + 4)) * (*(u + 1)) + (*(F + 5)) * (*(u + 2));
    *p = r * r / (rxc * rxc + ryc * ryc + rx * rx + ry * ry);
    sx = ec[1] * u[2] - ec[2] * u[1];
    sy = ec[2] * u[0] - ec[0] * u[2];
    *sgn = sx * rxc + sy * ryc;
    sgn++;
    p++;
    u += 6;
  }
}


x86 assembly (clang, -O0):
<FDso>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <epipole@plt>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1437 <FDso+0x327>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x50(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x48(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x30(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x38(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x8(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1143 <FDso+0x33>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FDso>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r8d,%r14d
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0x20(%rsp),%rdi
call   1030 <epipole@plt>
test   %r14d,%r14d
jle    1676 <FDso+0x566>
movsd  0x28(%rsp),%xmm13
movsd  0x30(%rsp),%xmm14
movapd 0xea7(%rip),%xmm0
movapd %xmm14,%xmm15
xorpd  %xmm0,%xmm15
movsd  0x20(%rsp),%xmm10
xorpd  %xmm0,%xmm10
lea    -0x1(%r14),%ecx
mov    $0x1,%edi
cmp    $0x2,%ecx
jb     14e9 <FDso+0x3d9>
lea    0x8(,%rcx,8),%rbp
add    %r13,%rbp
lea    (%rcx,%rcx,2),%rax
shl    $0x4,%rax
cmp    %r15,%rbp
seta   0x10(%rsp)
lea    (%r15,%rcx,8),%rsi
add    $0x8,%rsi
cmp    %r13,%rsi
seta   %r11b
lea    0x48(%r12),%rdx
cmp    %r15,%rdx
seta   %dil
cmp    %r12,%rsi
seta   %r9b
add    %rbx,%rax
add    $0x30,%rax
cmp    %r15,%rax
seta   %r10b
cmp    %rbx,%rsi
seta   (%rsp)
cmp    %r13,%rdx
seta   %sil
cmp    %r12,%rbp
seta   %dl
cmp    %r13,%rax
seta   %r8b
cmp    %rbx,%rbp
seta   %bpl
test   %r11b,0x10(%rsp)
jne    14e4 <FDso+0x3d4>
and    %r9b,%dil
jne    14e4 <FDso+0x3d4>
and    (%rsp),%r10b
jne    14e4 <FDso+0x3d4>
and    %dl,%sil
jne    14e4 <FDso+0x3d4>
and    %bpl,%r8b
jne    14e4 <FDso+0x3d4>
add    $0x1,%rcx
mov    %ecx,%eax
and    $0x1,%eax
test   %rax,%rax
mov    $0x2,%edx
cmovne %rax,%rdx
sub    %rdx,%rcx
lea    (%rcx,%rcx,2),%rdx
shl    $0x4,%rdx
add    %rbx,%rdx
lea    (%r15,%rcx,8),%r8
lea    0x1(%rcx),%edi
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
movapd %xmm0,0x10(%rsp)
movapd %xmm13,0x50(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm13,(%rsp)
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm0
movapd %xmm0,0xa0(%rsp)
movapd %xmm14,0x40(%rsp)
unpcklpd %xmm14,%xmm14
movapd %xmm14,0x90(%rsp)
movsd  (%r12),%xmm9
movsd  0x8(%r12),%xmm5
movsd  0x10(%r12),%xmm6
movsd  0x18(%r12),%xmm13
unpcklpd %xmm9,%xmm9
unpcklpd %xmm13,%xmm13
movsd  0x30(%r12),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x80(%rsp)
unpcklpd %xmm5,%xmm5
movsd  0x20(%r12),%xmm0
unpcklpd %xmm0,%xmm0
movsd  0x38(%r12),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x70(%rsp)
unpcklpd %xmm6,%xmm6
movsd  0x28(%r12),%xmm1
unpcklpd %xmm1,%xmm1
movsd  0x40(%r12),%xmm2
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x60(%rsp)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x18(%rbx),%xmm2
movhpd 0x48(%rbx),%xmm2
movsd  0x20(%rbx),%xmm3
movhpd 0x50(%rbx),%xmm3
movapd %xmm13,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm9,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movsd  0x28(%rbx),%xmm11
movhpd 0x58(%rbx),%xmm11
movapd 0x80(%rsp),%xmm12
mulpd  %xmm11,%xmm12
addpd  %xmm4,%xmm12
movapd %xmm3,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm5,%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm4,%xmm7
movapd 0x70(%rsp),%xmm14
mulpd  %xmm11,%xmm14
addpd  %xmm7,%xmm14
mulpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm3,%xmm2
mulpd  0x60(%rsp),%xmm11
addpd  %xmm2,%xmm11
movupd 0x30(%rbx),%xmm4
movupd (%rbx),%xmm8
movupd 0x10(%rbx),%xmm2
movapd %xmm8,%xmm3
unpcklpd %xmm4,%xmm3
unpckhpd %xmm4,%xmm8
movhpd 0x40(%rbx),%xmm2
movapd %xmm14,%xmm4
mulpd  %xmm8,%xmm4
movapd %xmm3,%xmm7
mulpd  %xmm12,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm2,%xmm11
addpd  %xmm7,%xmm11
movapd %xmm5,%xmm4
mulpd  %xmm8,%xmm4
movapd %xmm9,%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm6,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm0,%xmm8
mulpd  %xmm13,%xmm3
addpd  %xmm8,%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm14,%xmm3
mulpd  %xmm14,%xmm3
movapd %xmm12,%xmm7
mulpd  %xmm12,%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm11,%xmm11
mulpd  %xmm4,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm2,%xmm2
addpd  %xmm4,%xmm2
divpd  %xmm2,%xmm11
movupd %xmm11,(%r15,%rsi,8)
movsd  0x10(%rbx),%xmm2
movhpd 0x40(%rbx),%xmm2
movupd (%rbx),%xmm3
movsd  0x38(%rbx),%xmm4
movapd %xmm3,%xmm7
shufpd $0x1,%xmm4,%xmm7
mulpd  0x10(%rsp),%xmm7
movapd (%rsp),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movhpd 0x30(%rbx),%xmm3
mulpd  0x90(%rsp),%xmm3
mulpd  0xa0(%rsp),%xmm2
addpd  %xmm3,%xmm2
mulpd  %xmm14,%xmm2
mulpd  %xmm12,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0x0(%r13,%rsi,8)
add    $0x2,%rsi
add    $0x60,%rbx
cmp    %rsi,%rcx
jne    1320 <FDso+0x210>
mov    %rdx,%rbx
mov    %r8,%r15
mov    %rax,%r13
movapd 0x50(%rsp),%xmm13
movapd 0x40(%rsp),%xmm14
jmp    14e9 <FDso+0x3d9>
mov    $0x1,%edi
sub    %edi,%r14d
add    $0x1,%r14d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x18(%rbx),%xmm7
movsd  0x18(%r12),%xmm9
movsd  0x20(%rbx),%xmm0
movapd %xmm9,%xmm1
mulsd  %xmm0,%xmm1
movsd  (%r12),%xmm6
movsd  0x8(%r12),%xmm8
movapd %xmm6,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
movsd  0x28(%rbx),%xmm4
movsd  0x30(%r12),%xmm12
mulsd  %xmm4,%xmm12
addsd  %xmm2,%xmm12
movsd  0x20(%r12),%xmm11
movapd %xmm0,%xmm1
mulsd  %xmm11,%xmm1
movapd %xmm8,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
movsd  0x38(%r12),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm2,%xmm5
movsd  0x10(%r12),%xmm3
movsd  0x28(%r12),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm7
addsd  %xmm0,%xmm7
mulsd  0x40(%r12),%xmm4
addsd  %xmm7,%xmm4
movsd  (%rbx),%xmm0
movsd  0x8(%rbx),%xmm7
movapd %xmm5,%xmm1
mulsd  %xmm7,%xmm1
mulsd  %xmm0,%xmm6
mulsd  %xmm0,%xmm9
mulsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
movsd  0x10(%rbx),%xmm1
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
mulsd  %xmm7,%xmm8
addsd  %xmm8,%xmm6
mulsd  %xmm1,%xmm3
addsd  %xmm6,%xmm3
mulsd  %xmm7,%xmm11
addsd  %xmm11,%xmm9
mulsd  %xmm1,%xmm2
addsd  %xmm9,%xmm2
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm12,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm4,%xmm4
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm4
movsd  %xmm4,(%r15,%rax,8)
movsd  0x10(%rbx),%xmm0
movsd  0x8(%rbx),%xmm1
mulsd  %xmm15,%xmm1
movapd %xmm13,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm10,%xmm0
movsd  (%rbx),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm12,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
add    $0x30,%rbx
add    $0x1,%rax
cmp    %eax,%r14d
jne    1500 <FDso+0x3f0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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