#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*/ crossp(double *, double *, double *);
int /*<<< orphan*/ fillu3(double *, unsigned char *, double *, double *);
scalar_t__ isinf(double);
scalar_t__ isnan(double);
int /*<<< orphan*/ mattr(double *, double *, int, int);
int /*<<< orphan*/ memcpy(double *, double *, int);
unsigned char minv(double *, int);
int /*<<< orphan*/ mmul(double *, double *, double *, int);
int /*<<< orphan*/ rmmult(double *, double *, double *, int, int, int);
int /*<<< orphan*/ skew_sym(double *, double *);
int /*<<< orphan*/ svduv(double *, double *, double *, int, double *, int);
void Hdetect(double *F, double *u7, unsigned char *IDXS, double *H) {
  double D[3], U[3 * 3], V[3 * 3], ec[3], Ex[3 * 3], A[3 * 3], u3a[3 * 3],
      u3b[3 * 3], u3aT[3 * 3], u3bT[3 * 3], Au3b[3 * 3], Ft[3 * 3], F1[3 * 3],
      p1[3 * 3], p1T[3 * 3], p2[3 * 3], b[3];
  unsigned char i, j, sing;
  mattr(Ft, F, 3, 3);
  memcpy(F1, F, 3 * 3 * sizeof(double));
  svduv(D, F1, U, 3, V, 3);
  ec[0] = V[2];
  ec[1] = V[5];
  ec[2] = V[8];
  skew_sym(ec, Ex);
  mmul(A, Ex, Ft, 3);
  fillu3(u7, IDXS, u3a, u3b);
  mmul(Au3b, A, u3b, 3);
  mattr(u3aT, u3a, 3, 3);
  mattr(u3bT, Au3b, 3, 3);
  crossp(p1T, u3aT, u3bT);
  crossp(p1T + 3, u3aT + 3, u3bT + 3);
  crossp(p1T + 6, u3aT + 6, u3bT + 6);
  mattr(p1, p1T, 3, 3);
  for (i = 0; i < 9; ++i) {
    Ex[i] *= -1;
  }
  mmul(p2, Ex, u3a, 3);
  b[0] = (p1[0] * p2[0] + p1[3] * p2[3] + p1[6] * p2[6]) /
         (p2[0] * p2[0] + p2[3] * p2[3] + p2[6] * p2[6]);
  b[1] = (p1[1] * p2[1] + p1[4] * p2[4] + p1[7] * p2[7]) /
         (p2[1] * p2[1] + p2[4] * p2[4] + p2[7] * p2[7]);
  b[2] = (p1[2] * p2[2] + p1[5] * p2[5] + p1[8] * p2[8]) /
         (p2[2] * p2[2] + p2[5] * p2[5] + p2[8] * p2[8]);
  mattr(u3bT, u3b, 3, 3);
  sing = minv(u3bT, 3);
  rmmult(u3b, u3bT, b, 3, 3, 1);
  mattr(u3bT, u3b, 3, 1);
  rmmult(u3b, ec, u3bT, 3, 1, 3);
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < 3; ++j) {
      H[i + j * 3] = A[i * 3 + j] - u3b[i * 3 + j];
    }
  }
  if (isnan(*H) || isinf(*H) || sing) {
    H[1] = H[2] = H[3] = H[5] = H[6] = H[7] = 0;
    H[0] = H[4] = H[8] = 1;
  }
}


x86 assembly (clang, -O0):
<Hdetect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
lea    -0x380(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1080 <mattr@plt>
lea    -0x3d0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x48,%edx
call   1040 <memcpy@plt>
lea    -0x40(%rbp),%rdi
lea    -0x3d0(%rbp),%rsi
lea    -0x90(%rbp),%rdx
lea    -0xe0(%rbp),%r8
mov    $0x3,%r9d
mov    %r9d,%ecx
call   1050 <svduv@plt>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
lea    -0x100(%rbp),%rdi
lea    -0x150(%rbp),%rsi
call   10b0 <skew_sym@plt>
lea    -0x1a0(%rbp),%rdi
lea    -0x150(%rbp),%rsi
lea    -0x380(%rbp),%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x240(%rbp),%rcx
call   1030 <fillu3@plt>
lea    -0x330(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
lea    -0x240(%rbp),%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
lea    -0x290(%rbp),%rdi
lea    -0x1f0(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1080 <mattr@plt>
lea    -0x2e0(%rbp),%rdi
lea    -0x330(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1080 <mattr@plt>
lea    -0x470(%rbp),%rdi
lea    -0x290(%rbp),%rsi
lea    -0x2e0(%rbp),%rdx
call   1090 <crossp@plt>
lea    -0x470(%rbp),%rdi
add    $0x18,%rdi
lea    -0x290(%rbp),%rsi
add    $0x18,%rsi
lea    -0x2e0(%rbp),%rdx
add    $0x18,%rdx
call   1090 <crossp@plt>
lea    -0x470(%rbp),%rdi
add    $0x30,%rdi
lea    -0x290(%rbp),%rsi
add    $0x30,%rsi
lea    -0x2e0(%rbp),%rdx
add    $0x30,%rdx
call   1090 <crossp@plt>
lea    -0x420(%rbp),%rdi
lea    -0x470(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1080 <mattr@plt>
movb   $0x0,-0x4e1(%rbp)
movzbl -0x4e1(%rbp),%eax
cmp    $0x9,%eax
jge    13b9 <Hdetect+0x209>
movzbl -0x4e1(%rbp),%eax
movsd  0xc74(%rip),%xmm0
mulsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x4e1(%rbp),%al
add    $0x1,%al
mov    %al,-0x4e1(%rbp)
jmp    1375 <Hdetect+0x1c5>
lea    -0x4c0(%rbp),%rdi
lea    -0x150(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
movsd  -0x420(%rbp),%xmm1
ff
movsd  -0x4c0(%rbp),%xmm2
ff
movsd  -0x408(%rbp),%xmm0
ff
mulsd  -0x4a8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x3f0(%rbp),%xmm0
ff
movsd  -0x490(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x4c0(%rbp),%xmm2
ff
movsd  -0x4c0(%rbp),%xmm3
ff
movsd  -0x4a8(%rbp),%xmm1
ff
mulsd  -0x4a8(%rbp),%xmm1
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x490(%rbp),%xmm1
ff
movsd  -0x490(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4e0(%rbp)
ff
movsd  -0x418(%rbp),%xmm1
ff
movsd  -0x4b8(%rbp),%xmm2
ff
movsd  -0x400(%rbp),%xmm0
ff
mulsd  -0x4a0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x3e8(%rbp),%xmm0
ff
movsd  -0x488(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x4b8(%rbp),%xmm2
ff
movsd  -0x4b8(%rbp),%xmm3
ff
movsd  -0x4a0(%rbp),%xmm1
ff
mulsd  -0x4a0(%rbp),%xmm1
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x488(%rbp),%xmm1
ff
movsd  -0x488(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4d8(%rbp)
ff
movsd  -0x410(%rbp),%xmm1
ff
movsd  -0x4b0(%rbp),%xmm2
ff
movsd  -0x3f8(%rbp),%xmm0
ff
mulsd  -0x498(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x3e0(%rbp),%xmm0
ff
movsd  -0x480(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x4b0(%rbp),%xmm2
ff
movsd  -0x4b0(%rbp),%xmm3
ff
movsd  -0x498(%rbp),%xmm1
ff
mulsd  -0x498(%rbp),%xmm1
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x480(%rbp),%xmm1
ff
movsd  -0x480(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4d0(%rbp)
ff
lea    -0x2e0(%rbp),%rdi
lea    -0x240(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1080 <mattr@plt>
lea    -0x2e0(%rbp),%rdi
mov    $0x3,%esi
call   10c0 <minv@plt>
mov    %al,-0x4e3(%rbp)
lea    -0x240(%rbp),%rdi
lea    -0x2e0(%rbp),%rsi
lea    -0x4e0(%rbp),%rdx
mov    $0x3,%r8d
mov    $0x1,%r9d
mov    %r8d,%ecx
call   1070 <rmmult@plt>
lea    -0x2e0(%rbp),%rdi
lea    -0x240(%rbp),%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1080 <mattr@plt>
lea    -0x240(%rbp),%rdi
lea    -0x100(%rbp),%rsi
lea    -0x2e0(%rbp),%rdx
mov    $0x3,%r9d
mov    $0x1,%r8d
mov    %r9d,%ecx
call   1070 <rmmult@plt>
movb   $0x0,-0x4e1(%rbp)
movzbl -0x4e1(%rbp),%eax
cmp    $0x3,%eax
jge    16d0 <Hdetect+0x520>
movb   $0x0,-0x4e2(%rbp)
movzbl -0x4e2(%rbp),%eax
cmp    $0x3,%eax
jge    16b8 <Hdetect+0x508>
movzbl -0x4e1(%rbp),%eax
imul   $0x3,%eax,%eax
movzbl -0x4e2(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movzbl -0x4e1(%rbp),%eax
imul   $0x3,%eax,%eax
movzbl -0x4e2(%rbp),%ecx
add    %ecx,%eax
cltq
subsd  -0x240(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movzbl -0x4e1(%rbp),%ecx
movzbl -0x4e2(%rbp),%edx
imul   $0x3,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4e2(%rbp),%al
add    $0x1,%al
mov    %al,-0x4e2(%rbp)
jmp    163a <Hdetect+0x48a>
jmp    16bd <Hdetect+0x50d>
mov    -0x4e1(%rbp),%al
add    $0x1,%al
mov    %al,-0x4e1(%rbp)
jmp    1623 <Hdetect+0x473>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
call   10a0 <isnan@plt>
cmp    $0x0,%rax
jne    170e <Hdetect+0x55e>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
call   10d0 <isinf@plt>
cmp    $0x0,%rax
jne    170e <Hdetect+0x55e>
movzbl -0x4e3(%rbp),%eax
cmp    $0x0,%eax
je     1788 <Hdetect+0x5d8>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x89e(%rip),%xmm0
movsd  %xmm0,0x40(%rax)
mov    -0x20(%rbp),%rax
movsd  0x88d(%rip),%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x20(%rbp),%rax
movsd  0x87c(%rip),%xmm0
movsd  %xmm0,(%rax)
add    $0x4f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Hdetect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4b8,%rsp
mov    %rcx,%r15
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbp
lea    0x380(%rsp),%r14
mov    %r14,%rdi
mov    %rbp,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1080 <mattr@plt>
lea    0x330(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x48,%edx
call   1040 <memcpy@plt>
lea    0x310(%rsp),%rdi
lea    0x470(%rsp),%rdx
lea    0x1d0(%rsp),%r8
mov    %rbx,%rsi
mov    $0x3,%ecx
mov    $0x3,%r9d
call   1050 <svduv@plt>
movsd  0x1e0(%rsp),%xmm0
movsd  0x1f8(%rsp),%xmm1
movsd  %xmm0,(%rsp)
movsd  %xmm1,0x8(%rsp)
movsd  0x210(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rsp,%rdi
lea    0x20(%rsp),%rbx
mov    %rbx,%rsi
call   10b0 <skew_sym@plt>
lea    0xc0(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
lea    0x420(%rsp),%r14
lea    0x70(%rsp),%rcx
mov    %r13,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    %rcx,%r13
call   1030 <fillu3@plt>
lea    0x3d0(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
lea    0x2c0(%rsp),%rbp
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1080 <mattr@plt>
lea    0x270(%rsp),%r12
mov    %r12,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1080 <mattr@plt>
lea    0x220(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
call   1090 <crossp@plt>
lea    0x238(%rsp),%rdi
lea    0x2d8(%rsp),%rsi
lea    0x288(%rsp),%rdx
call   1090 <crossp@plt>
lea    0x250(%rsp),%rdi
lea    0x2f0(%rsp),%rsi
lea    0x2a0(%rsp),%rdx
call   1090 <crossp@plt>
lea    0x180(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1080 <mattr@plt>
movaps 0xc98(%rip),%xmm0
movaps 0x20(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x20(%rsp)
movaps 0x30(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x30(%rsp)
movaps 0x40(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x40(%rsp)
movaps 0x50(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
movsd  0x60(%rsp),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x60(%rsp)
lea    0x130(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    %r14,%rdx
mov    $0x3,%ecx
call   1060 <mmul@plt>
movapd 0x130(%rsp),%xmm0
movupd 0x198(%rsp),%xmm1
movupd 0x148(%rsp),%xmm2
mulpd  %xmm2,%xmm1
movapd 0x180(%rsp),%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
movapd 0x160(%rsp),%xmm1
movapd 0x1b0(%rsp),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm2
mulpd  %xmm0,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm1,%xmm1
addpd  %xmm0,%xmm1
divpd  %xmm1,%xmm4
movapd %xmm4,0x110(%rsp)
movsd  0x140(%rsp),%xmm0
movsd  0x158(%rsp),%xmm1
movsd  0x1a8(%rsp),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x190(%rsp),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  0x170(%rsp),%xmm2
movsd  0x1c0(%rsp),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm4
movsd  %xmm4,0x120(%rsp)
mov    %r12,%rdi
mov    %r13,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1080 <mattr@plt>
mov    %r12,%rdi
mov    $0x3,%esi
call   10c0 <minv@plt>
mov    %eax,%ebp
lea    0x110(%rsp),%rdx
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x3,%ecx
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1070 <rmmult@plt>
mov    %r12,%rdi
mov    %r13,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1080 <mattr@plt>
mov    %r13,%rdi
mov    %rsp,%rsi
mov    %r12,%rdx
mov    $0x3,%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1070 <rmmult@plt>
movapd 0xc0(%rsp),%xmm0
movapd 0x70(%rsp),%xmm1
movapd 0xd0(%rsp),%xmm2
movapd 0x80(%rsp),%xmm3
movhpd 0xd8(%rsp),%xmm0
movhpd 0x88(%rsp),%xmm1
subpd  %xmm1,%xmm0
movsd  0xc8(%rsp),%xmm1
movsd  0x78(%rsp),%xmm4
movupd %xmm0,(%r15)
movapd 0xe0(%rsp),%xmm5
movapd 0x90(%rsp),%xmm6
movhpd 0xe8(%rsp),%xmm2
movhpd 0x98(%rsp),%xmm3
subpd  %xmm3,%xmm2
movupd %xmm2,0x30(%r15)
movapd 0xf0(%rsp),%xmm2
unpcklpd %xmm1,%xmm2
movapd 0xa0(%rsp),%xmm1
unpcklpd %xmm4,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r15)
movhpd 0xf8(%rsp),%xmm5
movhpd 0xa8(%rsp),%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x20(%r15)
movsd  0x100(%rsp),%xmm1
subsd  0xb0(%rsp),%xmm1
movsd  %xmm1,0x40(%r15)
call   10a0 <isnan@plt>
test   %rax,%rax
je     163c <Hdetect+0x48c>
lea    0x8(%r15),%rax
lea    0x28(%r15),%rcx
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rax)
movq   $0x0,0x10(%rax)
movupd %xmm0,(%rcx)
movq   $0x0,0x10(%rcx)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x40(%r15)
mov    %rax,0x20(%r15)
mov    %rax,(%r15)
add    $0x4b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  (%r15),%xmm0
call   10d0 <isinf@plt>
test   %rax,%rax
jne    15f1 <Hdetect+0x441>
test   %bpl,%bpl
je     162a <Hdetect+0x47a>
jmp    15f1 <Hdetect+0x441>

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

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