#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 */
typedef int rowa;
typedef scalar_t__ *mmax;
typedef scalar_t__ *k;
typedef scalar_t__ *i;

/* Variables and functions */
scalar_t__ fabs(double);
double mdet(double *ap, int dimen, int rowa) {
  double det = 1.0;
  double work;
  int is = 0;
  int mmax;
  int i, j, k;
  for (k = 0; k < dimen - 1; k++) {
    mmax = k;
    for (i = k + 1; i < dimen; i++)
      if (fabs((*(ap + (rowa) * (i) + (k)))) >
          fabs((*(ap + (rowa) * (mmax) + (k)))))
        mmax = i;
    if (mmax != k) {
      for (j = k; j < dimen; j++) {
        work = (*(ap + (rowa) * (k) + (j)));
        (*(ap + (rowa) * (k) + (j))) = (*(ap + (rowa) * (mmax) + (j)));
        (*(ap + (rowa) * (mmax) + (j))) = work;
      }
      is++;
    }
    for (i = k + 1; i < dimen; i++) {
      work = (*(ap + (rowa) * (i) + (k))) / (*(ap + (rowa) * (k) + (k)));
      for (j = k + 1; j < dimen; j++)
        (*(ap + (rowa) * (i) + (j))) -= work * (*(ap + (rowa) * (k) + (j)));
    }
  }
  for (i = 0; i < dimen; i++)
    det *= (*(ap + (rowa) * (i) + (i)));
  for (i = 0; i < is; i++)
    det *= -1.0;
  return (det);
}


x86 assembly (clang, -O0):
<mdet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  0xed6(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1397 <mdet+0x287>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11dc <mdet+0xcc>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
jle    11c9 <mdet+0xb9>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    11ce <mdet+0xbe>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    115d <mdet+0x4d>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1293 <mdet+0x183>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128a <mdet+0x17a>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ee <mdet+0xde>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1384 <mdet+0x274>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1371 <mdet+0x261>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f2 <mdet+0x1e2>
jmp    1376 <mdet+0x266>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    129c <mdet+0x18c>
jmp    1389 <mdet+0x279>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    113d <mdet+0x2d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13e0 <mdet+0x2d0>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    139e <mdet+0x28e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1413 <mdet+0x303>
movsd  0xc0d(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e7 <mdet+0x2d7>
movsd  -0x18(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mdet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %edx,0x2c(%rsp)
movslq %edx,%r13
mov    %esi,%edx
mov    %rsi,0x68(%rsp)
cmp    $0x2,%esi
jl     188b <mdet+0x77b>
mov    0x68(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0xd8(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x108(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0x60(%rsp)
lea    0x8(,%r13,8),%rax
mov    %rax,0xa8(%rsp)
lea    0x0(%r13,%rdx,1),%rax
mov    %rax,0xd0(%rsp)
lea    0x8(%rdi),%rax
lea    (%rdi,%rdx,8),%rcx
mov    %rcx,0xc8(%rsp)
lea    -0x1(%rdx),%rcx
mov    %rcx,0x78(%rsp)
mov    %rdx,%rcx
neg    %rcx
mov    %rcx,0x110(%rsp)
lea    (%rdi,%r13,8),%r12
lea    -0x4(%rdx),%rcx
mov    %rcx,0x88(%rsp)
lea    0x30(%rdi),%rsi
lea    0x38(%rdi,%r13,8),%rcx
mov    %rcx,0xa0(%rsp)
lea    0x38(%rdi),%r15
lea    -0x5(%rdx),%rcx
mov    %rcx,0x98(%rsp)
lea    (%rdi,%r13,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x90(%rsp)
xor    %r8d,%r8d
mov    $0x1,%ecx
mov    %rcx,0x18(%rsp)
mov    %rdi,%rbx
mov    %rax,0x70(%rsp)
mov    %rax,%rbp
mov    %rdi,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rdi,0xc0(%rsp)
mov    %r13,0x50(%rsp)
jmp    12a8 <mdet+0x198>
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x18(%rsp)
mov    0xa8(%rsp),%rcx
mov    0xe0(%rsp),%r12
add    %rcx,%r12
addq   $0xffffffffffffffff,0x88(%rsp)
addq   $0x8,0x80(%rsp)
mov    0xb0(%rsp),%rsi
add    %rcx,%rsi
mov    0x60(%rsp),%rax
mov    0x48(%rsp),%rbp
add    %rax,%rbp
add    %rcx,0xa0(%rsp)
add    %rcx,%r15
addq   $0xffffffffffffffff,0x98(%rsp)
add    %rax,0x90(%rsp)
add    %rax,%rbx
mov    0xb8(%rsp),%r8
cmp    0xd8(%rsp),%r8
je     188b <mdet+0x77b>
mov    %rbp,0x48(%rsp)
mov    %rsi,0xb0(%rsp)
mov    %r8,%rax
imul   %r13,%rax
mov    %rax,%rcx
mov    %rax,0x30(%rsp)
add    %rdx,%rax
mov    %rax,0x38(%rsp)
lea    (%rdi,%r8,8),%rax
mov    %rax,0x40(%rsp)
lea    0x1(%r8),%rax
mov    %rax,0xb8(%rsp)
cmp    %rdx,%rax
mov    %r8,0x8(%rsp)
mov    %r12,0xe0(%rsp)
jae    1350 <mdet+0x240>
mov    0x18(%rsp),%r13
mov    %r8d,%r14d
jmp    1316 <mdet+0x206>
nopl   (%rax)
add    $0x1,%r13
add    0x60(%rsp),%r12
mov    %ecx,%r14d
mov    0x20(%rsp),%rdx
cmp    %r13,%rdx
je     1353 <mdet+0x243>
movsd  (%r12),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbp
mov    %r14d,%eax
imul   0x2c(%rsp),%eax
cltq
mov    0x40(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
call   1030 <fabs@plt>
mov    %r13d,%ecx
cmp    %rax,%rbp
jg     1300 <mdet+0x1f0>
mov    %r14d,%ecx
jmp    1300 <mdet+0x1f0>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%ecx
mov    0xa8(%rsp),%rax
mov    0x8(%rsp),%rsi
imul   %rsi,%rax
mov    %rax,0x58(%rsp)
mov    0xc0(%rsp),%rdi
mov    0x38(%rsp),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x38(%rsp)
mov    %ecx,%eax
cmp    %rax,%rsi
jne    13b0 <mdet+0x2a0>
mov    0x50(%rsp),%r13
movapd 0xc6d(%rip),%xmm7
cmp    %rdx,0xb8(%rsp)
jae    1230 <mdet+0x120>
jmp    15d7 <mdet+0x4c7>
cs nopw 0x0(%rax,%rax,1)
cmp    %rdx,%rsi
mov    0x50(%rsp),%r13
movapd 0xc40(%rip),%xmm7
mov    0x48(%rsp),%rbp
jae    15b7 <mdet+0x4a7>
mov    %rdx,%r14
mov    0x8(%rsp),%rsi
sub    %rsi,%r14
mov    0x30(%rsp),%rax
lea    (%rdi,%rax,8),%r8
imul   0x2c(%rsp),%ecx
movslq %ecx,%r11
lea    (%rdi,%r11,8),%r9
cmp    $0x4,%r14
jb     1540 <mdet+0x430>
mov    0x58(%rsp),%rax
lea    (%rdi,%rax,1),%rcx
mov    0xc8(%rsp),%rdx
lea    (%rdx,%r11,8),%rdx
cmp    %rdx,%rcx
mov    0x20(%rsp),%rdx
jae    142d <mdet+0x31d>
mov    0x40(%rsp),%rax
lea    (%rax,%r11,8),%rcx
mov    0x8(%rsp),%rsi
cmp    0x38(%rsp),%rcx
jb     1540 <mdet+0x430>
lea    -0x4(%r14),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
cmp    $0x4,%rcx
mov    0xb0(%rsp),%rax
jae    1451 <mdet+0x341>
xor    %ecx,%ecx
jmp    14de <mdet+0x3ce>
mov    0x88(%rsp),%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x80(%rsp),%rcx
lea    (%rcx,%r11,8),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rax,%rcx,8),%xmm0
movups -0x20(%rax,%rcx,8),%xmm1
movups (%rdx,%rcx,8),%xmm2
movups 0x10(%rdx,%rcx,8),%xmm3
movups %xmm2,-0x30(%rax,%rcx,8)
movups %xmm3,-0x20(%rax,%rcx,8)
movups %xmm0,(%rdx,%rcx,8)
movups %xmm1,0x10(%rdx,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
movupd 0x20(%rdx,%rcx,8),%xmm2
movupd 0x30(%rdx,%rcx,8),%xmm3
movupd %xmm2,-0x10(%rax,%rcx,8)
movupd %xmm3,(%rax,%rcx,8)
movupd %xmm0,0x20(%rdx,%rcx,8)
movupd %xmm1,0x30(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1480 <mdet+0x370>
mov    %r14,%rsi
and    $0xfffffffffffffffc,%rsi
test   $0x1,%r10b
mov    0x20(%rsp),%rdx
je     1529 <mdet+0x419>
add    0x8(%rsp),%rcx
movupd (%r8,%rcx,8),%xmm0
movupd 0x10(%r8,%rcx,8),%xmm1
movupd (%r9,%rcx,8),%xmm2
movupd 0x10(%r9,%rcx,8),%xmm3
movupd %xmm2,(%r8,%rcx,8)
movupd %xmm3,0x10(%r8,%rcx,8)
movupd %xmm0,(%r9,%rcx,8)
movupd %xmm1,0x10(%r9,%rcx,8)
cmp    %rsi,%r14
mov    0x48(%rsp),%rbp
je     15b7 <mdet+0x4a7>
add    0x8(%rsp),%rsi
nopl   0x0(%rax)
sub    %esi,%edx
mov    %rsi,%rcx
test   $0x1,%dl
je     1566 <mdet+0x456>
movsd  (%r8,%rsi,8),%xmm0
movsd  (%r9,%rsi,8),%xmm1
movsd  %xmm1,(%r8,%rsi,8)
movsd  %xmm0,(%r9,%rsi,8)
lea    0x1(%rsi),%rcx
cmp    %rsi,0x78(%rsp)
mov    0x20(%rsp),%rdx
je     15b7 <mdet+0x4a7>
mov    0x70(%rsp),%rsi
lea    (%rsi,%r11,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rcx,8),%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rcx,8)
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1580 <mdet+0x470>
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rsi
cmp    %rdx,0xb8(%rsp)
jae    1230 <mdet+0x120>
mov    0x78(%rsp),%r14
sub    %rsi,%r14
mov    0x98(%rsp),%rax
shr    $0x2,%rax
add    $0xfffffffffffffffc,%r14
add    $0x1,%rax
mov    %r14,%rcx
shr    $0x2,%rcx
and    $0xfffffffffffffffe,%rax
mov    %rax,0xe8(%rsp)
add    $0x1,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rsi,%rbp
not    %rbp
add    %rdx,%rbp
mov    0xd0(%rsp),%rax
mov    0x30(%rsp),%r8
add    %r8,%rax
mov    %rax,0x40(%rsp)
mov    0x70(%rsp),%rax
mov    0x58(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x100(%rsp)
lea    (%rdi,%r8,8),%r12
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    0x18(%rsp),%r10
mov    %rax,0x30(%rsp)
add    %r10,%rax
mov    %rax,0xf0(%rsp)
mov    0x90(%rsp),%r8
mov    0xa0(%rsp),%r9
xor    %r11d,%r11d
jmp    16a1 <mdet+0x591>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x1,%r11
mov    0x60(%rsp),%rax
add    %rax,%r9
add    %rax,%r8
cmp    %rdx,%r10
mov    0x8(%rsp),%rsi
je     1230 <mdet+0x120>
mov    %r10,%rax
imul   %r13,%rax
lea    (%rdi,%rax,8),%rax
movsd  (%rax,%rsi,8),%xmm0
xorpd  %xmm7,%xmm0
divsd  (%r12,%rsi,8),%xmm0
mov    0x18(%rsp),%rsi
cmp    $0x4,%rbp
jb     1810 <mdet+0x700>
mov    %r11,%rcx
imul   %r13,%rcx
mov    0x108(%rsp),%rsi
add    %rcx,%rsi
lea    (%rdi,%rsi,8),%rsi
add    0x58(%rsp),%rsi
cmp    0x38(%rsp),%rsi
jae    1708 <mdet+0x5f8>
add    0x40(%rsp),%rcx
lea    (%rdi,%rcx,8),%rcx
mov    0x18(%rsp),%rsi
cmp    %rcx,0x100(%rsp)
jb     1810 <mdet+0x700>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%r14
jae    171d <mdet+0x60d>
xor    %ecx,%ecx
jmp    17ab <mdet+0x69b>
mov    0xe8(%rsp),%r13
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%r15,%rcx,8),%xmm2
movupd -0x20(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r9,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r9,%rcx,8),%xmm2
movupd -0x10(%r9,%rcx,8),%xmm5
movupd (%r9,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r9,%rcx,8)
movupd %xmm3,-0x20(%r9,%rcx,8)
movupd -0x10(%r15,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r9,%rcx,8)
movupd %xmm3,(%r9,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r13
jne    1730 <mdet+0x620>
testb  $0x1,0xf8(%rsp)
01
mov    0xc0(%rsp),%rdi
mov    0x50(%rsp),%r13
je     17fa <mdet+0x6ea>
add    0x18(%rsp),%rcx
movupd (%r12,%rcx,8),%xmm2
movupd 0x10(%r12,%rcx,8),%xmm3
movupd (%rax,%rcx,8),%xmm4
movupd 0x10(%rax,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%rcx,8)
movupd %xmm3,0x10(%rax,%rcx,8)
mov    0xf0(%rsp),%rsi
cmp    0x30(%rsp),%rbp
je     1680 <mdet+0x570>
nopl   (%rax)
sub    %esi,%edx
mov    %rsi,%rcx
test   $0x1,%dl
je     1832 <mdet+0x722>
movsd  (%r12,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rax,%rsi,8)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0x110(%rsp),%rsi
mov    0x20(%rsp),%rdx
je     1680 <mdet+0x570>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r8,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%r8,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r8,%rcx,8),%xmm1
movsd  %xmm1,(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1850 <mdet+0x740>
jmp    1680 <mdet+0x570>
cmpl   $0x0,0x68(%rsp)
jle    18b0 <mdet+0x7a0>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    18c2 <mdet+0x7b2>
movsd  0x767(%rip),%xmm0
xor    %ecx,%ecx
jmp    1933 <mdet+0x823>
movsd  0x758(%rip),%xmm0
mov    0x10(%rsp),%rsi
jmp    195d <mdet+0x84d>
mov    %r13,%r8
shl    $0x4,%r8
mov    %r13,%rsi
shl    $0x5,%rsi
add    $0x20,%rsi
lea    0x0(,%r13,8),%rcx
lea    (%rcx,%rcx,2),%r9
and    $0xfffffffc,%edx
neg    %rdx
movsd  0x722(%rip),%xmm0
mov    $0x1,%ecx
mov    %rdi,%rbp
cs nopw 0x0(%rax,%rax,1)
mulsd  0x0(%rbp),%xmm0
mulsd  0x8(%rbp,%r13,8),%xmm0
mulsd  0x10(%rbp,%r8,1),%xmm0
mulsd  0x18(%rbp,%r9,1),%xmm0
add    %rsi,%rbp
lea    (%rdx,%rcx,1),%rbx
add    $0x4,%rbx
add    $0x4,%rcx
cmp    $0x1,%rbx
jne    1900 <mdet+0x7f0>
add    $0xffffffffffffffff,%rcx
mov    0x10(%rsp),%rsi
test   %rax,%rax
je     195d <mdet+0x84d>
lea    0x8(,%r13,8),%rdx
imul   %rdx,%rcx
add    %rcx,%rdi
nopl   0x0(%rax)
mulsd  (%rdi),%xmm0
add    %rdx,%rdi
add    $0xffffffffffffffff,%rax
jne    1950 <mdet+0x840>
test   %esi,%esi
jle    19a9 <mdet+0x899>
lea    -0x1(%rsi),%ecx
mov    %esi,%eax
and    $0x7,%eax
cmp    $0x7,%ecx
jb     1985 <mdet+0x875>
and    $0xfffffff8,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffff8,%esi
jne    1980 <mdet+0x870>
test   %eax,%eax
je     19a9 <mdet+0x899>
movapd 0x66f(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm0
add    $0xffffffff,%eax
jne    19a0 <mdet+0x890>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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