#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*/ abyx(int, double *, int);
scalar_t__ eigen(int, double *, int, double *, double *, double *, double *,
                 double *);
int /*<<< orphan*/ error2(char *);
double log(double);
int /*<<< orphan*/ matby(double *, double *, double *, int, int, int);
int /*<<< orphan*/ matinv(double *, int, int, double *);
int pow(double, int);
int /*<<< orphan*/ printf(char *, int, double);
int /*<<< orphan*/ puts(char *);
int sum(double *, int);
int /*<<< orphan*/ xtoy(double *, double *, int);
int /*<<< orphan*/ zero(double *, int);
double DistanceREV(double Ft[], int n, double alpha, double Root[], double U[],
                   double V[], double pi[], double space[], int *cond) {
  int i, j;
  double *Q = Ft, *T1 = space, *T2 = space + n * n, t, small = 1e-6;
  *cond = 0;
  for (i = 0, t = 0; i < n; i++)
    for (j = 0; j < n; j++)
      if (i - j)
        t += Q[i * n + j];
  if (t < small) {
    *cond = 1;
    zero(Q, n * n);
    return (0);
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < i; j++)
      Q[i * n + j] = Q[j * n + i] = (Q[i * n + j] + Q[j * n + i]) / 2;
  abyx(1. / sum(Q, n * n), Q, n * n);
  for (i = 0; i < n; i++) {
    pi[i] = sum(Q + i * n, n);
    if (Q[i * n + i] <= small) {
      Q[i * n + i] = 1 - pi[i] + Q[i * n + i];
      *cond = -1;
    } else
      abyx(1 / pi[i], Q + i * n, n);
  }
  if (eigen(1, Q, n, Root, T1, U, V, T2))
    error2("eigen jgl");
  xtoy(U, V, n * n);
  matinv(V, n, n, T1);
  for (i = 0; i < n; i++) {
    if (Root[i] <= 0) {
      printf("  Root %d:%10.4f", i + 1, Root[i]);
    }
    Root[i] =
        (alpha <= 0 ? log(Root[i]) : (alpha * (1 - pow(Root[i], -1 / alpha))));
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      T1[i * n + j] = U[i * n + j] * Root[j];
  matby(T1, V, Q, n, n, n);
  for (i = 0, t = 0; i < n; i++)
    t -= pi[i] * Q[i * n + i];
  if (t <= 0)
    puts("err: DistanceREV");
  for (i = 0; i < n; i++)
    Root[i] /= t;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      Q[i * n + j] /= t;
      if (i - j)
        Q[i * n + j] = ((0) > (Q[i * n + j]) ? (0) : (Q[i * n + j]));
    }
  return (t);
}


x86 assembly (clang, -O0):
<DistanceREV>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movsd  0xde0(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b2 <DistanceREV+0xf2>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    129f <DistanceREV+0xdf>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
je     128c <DistanceREV+0xcc>
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1291 <DistanceREV+0xd1>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1251 <DistanceREV+0x91>
jmp    12a4 <DistanceREV+0xe4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    123e <DistanceREV+0x7e>
movsd  -0x68(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12ed <DistanceREV+0x12d>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
call   10a0 <zero@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1869 <DistanceREV+0x6a9>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1398 <DistanceREV+0x1d8>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1385 <DistanceREV+0x1c5>
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xcd1(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1307 <DistanceREV+0x147>
jmp    138a <DistanceREV+0x1ca>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12f4 <DistanceREV+0x134>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
call   1090 <sum@plt>
cvtsi2sd %eax,%xmm1
movsd  0xc54(%rip),%xmm0
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
mov    -0x50(%rbp),%rsi
mov    -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
call   10e0 <abyx@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14c9 <DistanceREV+0x309>
mov    -0x50(%rbp),%rdi
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x14(%rbp),%esi
call   1090 <sum@plt>
cvtsi2sd %eax,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1481 <DistanceREV+0x2c1>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xbc7(%rip),%xmm0
subsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    14b6 <DistanceREV+0x2f6>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xb77(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%edi
mov    -0x50(%rbp),%rsi
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x14(%rbp),%edx
call   10e0 <abyx@plt>
jmp    14bb <DistanceREV+0x2fb>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13d3 <DistanceREV+0x213>
mov    -0x50(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x58(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    -0x38(%rbp),%r10
mov    -0x60(%rbp),%rax
mov    $0x1,%edi
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <eigen@plt>
cmp    $0x0,%rax
je     150d <DistanceREV+0x34d>
lea    0xb18(%rip),%rdi
call   1070 <error2@plt>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
call   10d0 <xtoy@plt>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x58(%rbp),%rcx
call   1080 <matinv@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    160e <DistanceREV+0x44e>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     157c <DistanceREV+0x3bc>
mov    -0x44(%rbp),%esi
add    $0x1,%esi
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xab3(%rip),%rdi
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
ucomisd -0x20(%rbp),%xmm0
jb     15a6 <DistanceREV+0x3e6>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10b0 <log@plt>
movsd  %xmm0,-0x78(%rbp)
jmp    15ee <DistanceREV+0x42e>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa4b(%rip),%xmm1
divsd  -0x20(%rbp),%xmm1
cvttsd2si %xmm1,%edi
call   10c0 <pow@plt>
movsd  -0x80(%rbp),%xmm0
mov    %eax,%ecx
mov    $0x1,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    153b <DistanceREV+0x37b>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    168e <DistanceREV+0x4ce>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    167b <DistanceREV+0x4bb>
mov    -0x30(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1628 <DistanceREV+0x468>
jmp    1680 <DistanceREV+0x4c0>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1615 <DistanceREV+0x455>
mov    -0x58(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x14(%rbp),%r9d
call   1030 <matby@plt>
movl   $0x0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    171f <DistanceREV+0x55f>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16b9 <DistanceREV+0x4f9>
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     1739 <DistanceREV+0x579>
lea    0x907(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1775 <DistanceREV+0x5b5>
movsd  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1740 <DistanceREV+0x580>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    185f <DistanceREV+0x69f>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    184c <DistanceREV+0x68c>
movsd  -0x68(%rbp),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
je     1839 <DistanceREV+0x679>
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    17fd <DistanceREV+0x63d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    181b <DistanceREV+0x65b>
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    183e <DistanceREV+0x67e>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    178f <DistanceREV+0x5cf>
jmp    1851 <DistanceREV+0x691>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    177c <DistanceREV+0x5bc>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DistanceREV>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x58(%rsp)
mov    %esi,%r12d
mov    %rdi,%r15
mov    0xb8(%rsp),%rax
imul   %esi,%esi
movl   $0x0,(%rax)
test   %r12d,%r12d
jle    12bd <DistanceREV+0xfd>
mov    %rdx,%r14
mov    0xb0(%rsp),%rax
lea    (%rax,%rsi,8),%r11
mov    %r12d,%r9d
lea    -0x1(%r9),%r10
mov    %r9d,%eax
and    $0xfffffffe,%eax
lea    0x8(%r15),%rbp
lea    0x0(,%r9,8),%r13
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    123c <DistanceREV+0x7c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    %r13,%rbp
cmp    %r9,%rdx
je     12af <DistanceREV+0xef>
test   %r10,%r10
je     1290 <DistanceREV+0xd0>
xor    %edi,%edi
jmp    1259 <DistanceREV+0x99>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rax,%rdi
je     1280 <DistanceREV+0xc0>
mov    %rdi,%rbx
cmp    %rdi,%rdx
je     1267 <DistanceREV+0xa7>
addsd  -0x8(%rbp,%rbx,8),%xmm1
lea    0x1(%rbx),%rdi
cmp    %rdi,%rdx
je     1250 <DistanceREV+0x90>
addsd  0x0(%rbp,%rbx,8),%xmm1
jmp    1250 <DistanceREV+0x90>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
test   $0x1,%r9b
jne    1298 <DistanceREV+0xd8>
jmp    1230 <DistanceREV+0x70>
nopl   0x0(%rax)
xor    %ebx,%ebx
test   $0x1,%r9b
je     1230 <DistanceREV+0x70>
cmp    %rbx,%rdx
je     1230 <DistanceREV+0x70>
mov    %rdx,%rdi
imul   %r9,%rdi
add    %rdi,%rbx
addsd  (%r15,%rbx,8),%xmm1
jmp    1230 <DistanceREV+0x70>
movsd  0xd49(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    12e6 <DistanceREV+0x126>
mov    0xb8(%rsp),%rax
movl   $0x1,(%rax)
mov    %r15,%rdi
call   10a0 <zero@plt>
xorpd  %xmm0,%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r12d,%r12d
mov    %r15,0x10(%rsp)
mov    %r12,0x18(%rsp)
mov    %r9,0x8(%rsp)
movsd  %xmm0,0x20(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,0x40(%rsp)
mov    %r10,0x60(%rsp)
mov    %rsi,0x50(%rsp)
mov    %r11,0x48(%rsp)
jle    14db <DistanceREV+0x31b>
lea    0x8(%r15),%rax
mov    %r9,%rcx
shl    $0x4,%rcx
xor    %ebp,%ebp
movsd  0xcde(%rip),%xmm0
mov    %r15,%r8
jmp    1354 <DistanceREV+0x194>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    %r13,%rax
add    $0x8,%r8
cmp    %r9,%rbp
je     13fa <DistanceREV+0x23a>
test   %rbp,%rbp
je     1340 <DistanceREV+0x180>
cmp    $0x1,%rbp
jne    1370 <DistanceREV+0x1b0>
xor    %edi,%edi
jmp    13be <DistanceREV+0x1fe>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r8,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdi,8),%xmm1
addsd  (%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movsd  %xmm1,-0x8(%rax,%rdi,8)
movsd  (%rax,%rdi,8),%xmm1
addsd  (%rbx,%r13,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r13,1)
movsd  %xmm1,(%rax,%rdi,8)
add    $0x2,%rdi
add    %rcx,%rbx
cmp    %rdi,%rdx
jne    1380 <DistanceREV+0x1c0>
test   $0x1,%bpl
je     1340 <DistanceREV+0x180>
mov    %rbp,%rdx
imul   %r9,%rdx
add    %rdi,%rdx
movsd  (%r15,%rdx,8),%xmm1
imul   %r9,%rdi
add    %rbp,%rdi
addsd  (%r15,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdi,8)
movsd  %xmm1,(%r15,%rdx,8)
jmp    1340 <DistanceREV+0x180>
mov    %r15,%rdi
mov    %rsi,%rbx
call   1090 <sum@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xbf4(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
mov    %r15,%rsi
mov    %ebx,%edx
call   10e0 <abyx@plt>
mov    0x8(%rsp),%rsi
test   %r12d,%r12d
jle    1504 <DistanceREV+0x344>
xor    %r15d,%r15d
mov    0x10(%rsp),%rbp
xor    %ebx,%ebx
jmp    1478 <DistanceREV+0x2b8>
movsd  0xbc0(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
mov    %rbp,%rsi
mov    0x18(%rsp),%r12
mov    %r12d,%edx
call   10e0 <abyx@plt>
add    $0x1,%rbx
add    %r12d,%r15d
add    %r13,%rbp
mov    0x8(%rsp),%rsi
cmp    %rbx,%rsi
je     1504 <DistanceREV+0x344>
movslq %r15d,%r12
add    %rbx,%r12
mov    %rbp,%rdi
call   1090 <sum@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    0x10(%rsp),%rax
movsd  (%rax,%r12,8),%xmm1
movsd  0xb56(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1440 <DistanceREV+0x280>
movsd  0xb50(%rip),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%r12,8)
mov    0xb8(%rsp),%rax
movl   $0xffffffff,(%rax)
mov    0x18(%rsp),%r12
jmp    1460 <DistanceREV+0x2a0>
mov    %r15,%rdi
mov    %rsi,%rbx
call   1090 <sum@plt>
cvtsi2sd %eax,%xmm0
movsd  0xb16(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
mov    %r15,%rsi
mov    %ebx,%edx
call   10e0 <abyx@plt>
mov    $0x1,%edi
mov    0x10(%rsp),%rsi
mov    %r12d,%edx
mov    %r14,%rcx
mov    0xb0(%rsp),%r15
mov    %r15,%r8
mov    0x40(%rsp),%r9
push   0x48(%rsp)
mov    0x40(%rsp),%rbx
push   %rbx
call   1040 <eigen@plt>
add    $0x10,%rsp
test   %rax,%rax
je     1548 <DistanceREV+0x388>
lea    0xb0d(%rip),%rdi
call   1070 <error2@plt>
mov    0x40(%rsp),%rdi
mov    %rbx,%rsi
mov    0x50(%rsp),%rdx
call   10d0 <xtoy@plt>
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %r15,%rcx
call   1080 <matinv@plt>
test   %r12d,%r12d
jle    188a <DistanceREV+0x6ca>
movsd  0xa9c(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ebx
xor    %r15d,%r15d
xorpd  %xmm2,%xmm2
jmp    15d7 <DistanceREV+0x417>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%edi
call   10c0 <pow@plt>
xorpd  %xmm2,%xmm2
movsd  0x20(%rsp),%xmm1
mov    0x8(%rsp),%rbp
mov    $0x1,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%r15,8)
add    $0x1,%r15
cmp    %r15,%rbp
je     161f <DistanceREV+0x45f>
movsd  (%r14,%r15,8),%xmm0
ucomisd %xmm0,%xmm2
jb     15fd <DistanceREV+0x43d>
lea    0x1(%r15),%esi
lea    0xa6c(%rip),%rdi
call   1060 <printf@plt>
xorpd  %xmm2,%xmm2
movsd  0x20(%rsp),%xmm1
ucomisd %xmm1,%xmm2
movsd  (%r14,%r15,8),%xmm0
jb     15a0 <DistanceREV+0x3e0>
call   10b0 <log@plt>
xorpd  %xmm2,%xmm2
movsd  0x20(%rsp),%xmm1
mov    0x8(%rsp),%rbp
jmp    15c8 <DistanceREV+0x408>
test   %r12d,%r12d
mov    0xb0(%rsp),%r15
jle    188a <DistanceREV+0x6ca>
lea    (%r14,%rbp,8),%rax
mov    %rax,0x20(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x70(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x68(%rsp)
mov    %rbp,%r10
neg    %r10
lea    0x30(%r15),%rdi
mov    0x40(%rsp),%r11
lea    0x30(%r11),%rdx
lea    0x8(%r11),%rsi
lea    0x8(%r15),%rax
xor    %r8d,%r8d
jmp    16a9 <DistanceREV+0x4e9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r13,%rdi
add    %r13,%rdx
add    %r13,%rsi
add    %r13,%rax
cmp    %rbp,%r8
je     18e3 <DistanceREV+0x723>
mov    %r8,%r9
imul   %rbp,%r9
cmp    $0x4,%ebp
jae    1730 <DistanceREV+0x570>
xor    %ebx,%ebx
mov    %rbx,%rcx
test   $0x1,%bpl
je     16dc <DistanceREV+0x51c>
add    %rbx,%r9
movsd  (%r11,%r9,8),%xmm0
mulsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%r9,8)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    %r10,%rbx
je     1690 <DistanceREV+0x4d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rsi,%rcx,8),%xmm0
mulsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
mulsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    16f0 <DistanceREV+0x530>
jmp    1690 <DistanceREV+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8,%rcx
imul   %rbp,%rcx
lea    (%rcx,%rbp,1),%rbx
lea    (%r15,%rcx,8),%rbp
lea    (%r15,%rbx,8),%r12
lea    (%r11,%rbx,8),%rbx
mov    %r11,%r15
lea    (%r11,%rcx,8),%rcx
cmp    %rbx,%rbp
setb   %bl
cmp    %r12,%rcx
setb   %r11b
cmp    0x20(%rsp),%rbp
setb   %cl
cmp    %r14,%r12
seta   %r12b
test   %r11b,%bl
jne    1863 <DistanceREV+0x6a3>
mov    $0x0,%ebx
and    %r12b,%cl
mov    0x18(%rsp),%r12
mov    0x8(%rsp),%rbp
mov    %r15,%r11
mov    0xb0(%rsp),%r15
jne    16b7 <DistanceREV+0x4f7>
cmpq   $0x0,0x48(%rsp)
je     187f <DistanceREV+0x6bf>
mov    0x68(%rsp),%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x30(%rdx,%rbx,8),%xmm0
movupd -0x20(%rdx,%rbx,8),%xmm1
movupd (%r14,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rdi,%rbx,8)
movupd %xmm0,-0x20(%rdi,%rbx,8)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
movupd 0x20(%r14,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rdi,%rbx,8)
movupd %xmm0,(%rdi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    17b0 <DistanceREV+0x5f0>
testb  $0x1,0x70(%rsp)
je     184d <DistanceREV+0x68d>
lea    (%rbx,%r9,1),%rcx
movupd (%r11,%rcx,8),%xmm0
movupd 0x10(%r11,%rcx,8),%xmm1
movupd (%r14,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%rcx,8)
movupd %xmm0,0x10(%r15,%rcx,8)
mov    0x50(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rbp,%rcx
je     1690 <DistanceREV+0x4d0>
jmp    16b7 <DistanceREV+0x4f7>
xor    %ebx,%ebx
mov    0x18(%rsp),%r12
mov    0x8(%rsp),%rbp
mov    %r15,%r11
mov    0xb0(%rsp),%r15
jmp    16b7 <DistanceREV+0x4f7>
xor    %ebx,%ebx
testb  $0x1,0x70(%rsp)
jne    181a <DistanceREV+0x65a>
jmp    184d <DistanceREV+0x68d>
mov    %r15,%rdi
mov    0x38(%rsp),%rsi
mov    0x10(%rsp),%r15
mov    %r15,%rdx
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %r12d,%r9d
call   1030 <matby@plt>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x20(%rsp)
lea    0x7b2(%rip),%rdi
call   1050 <puts@plt>
movapd 0x20(%rsp),%xmm0
test   %r12d,%r12d
jle    12d7 <DistanceREV+0x117>
cmp    $0x1,%r12d
jne    19c4 <DistanceREV+0x804>
xor    %eax,%eax
mov    0x8(%rsp),%rbp
jmp    1a50 <DistanceREV+0x890>
mov    %r15,%rdi
mov    0x38(%rsp),%rsi
mov    0x10(%rsp),%r15
mov    %r15,%rdx
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %r12d,%r9d
call   1030 <matby@plt>
test   %r12d,%r12d
jle    18a8 <DistanceREV+0x6e8>
xor    %eax,%eax
cmpq   $0x0,0x60(%rsp)
je     1c31 <DistanceREV+0xa71>
lea    (%r12,%r12,1),%r9d
mov    0x58(%rsp),%rcx
lea    0x8(%rcx),%rdx
mov    0x8(%rsp),%r11
mov    %r11d,%r8d
and    $0xfffffffe,%r8d
neg    %r8
xorpd  %xmm0,%xmm0
mov    $0x1,%ebp
xor    %edi,%edi
mov    %r12d,%ebx
xor    %esi,%esi
movslq %ebx,%rbx
lea    (%rbx,%rbp,1),%r10
cltq
lea    (%rsi,%rax,1),%rcx
movsd  -0x8(%rdx),%xmm2
mulsd  (%r15,%rcx,8),%xmm2
movsd  (%rdx),%xmm1
subsd  %xmm2,%xmm0
mulsd  (%r15,%r10,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x2,%rsi
add    %r9d,%eax
add    $0x10,%rdx
add    $0x2,%rbp
add    %r9d,%ebx
add    $0xfffffffffffffffe,%rdi
cmp    %rdi,%r8
jne    1940 <DistanceREV+0x780>
neg    %rdi
mov    %rdi,%rax
test   $0x1,%r11b
je     19b1 <DistanceREV+0x7f1>
mov    0x58(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mov    %eax,%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
add    %rax,%rcx
mulsd  (%r15,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    18ac <DistanceREV+0x6ec>
jmp    18c4 <DistanceREV+0x704>
mov    0x8(%rsp),%rbp
mov    %ebp,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1c21 <DistanceREV+0xa61>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd (%r14,%rdx,8),%xmm1
movupd 0x10(%r14,%rdx,8),%xmm2
divpd  %xmm3,%xmm1
movupd %xmm1,(%r14,%rdx,8)
divpd  %xmm3,%xmm2
movupd %xmm2,0x10(%r14,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1a00 <DistanceREV+0x840>
test   $0x1,%cl
je     1a41 <DistanceREV+0x881>
movupd (%r14,%rdx,8),%xmm1
divpd  %xmm3,%xmm1
movupd %xmm1,(%r14,%rdx,8)
cmp    %rbp,%rax
je     1a69 <DistanceREV+0x8a9>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1a50 <DistanceREV+0x890>
test   %r12d,%r12d
jle    12d7 <DistanceREV+0x117>
mov    %ebp,%r11d
and    $0xfffffffe,%r11d
lea    -0x2(%r11),%r9
mov    %r9,%r10
shr    %r10
add    $0x1,%r10
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
lea    0x10(%r15),%rdi
lea    0x0(,%rbp,8),%rax
xor    %ebx,%ebx
movdqa 0x573(%rip),%xmm8
movdqa 0x57a(%rip),%xmm9
movdqa 0x581(%rip),%xmm10
mov    %r15,%rsi
jmp    1ae3 <DistanceREV+0x923>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
add    %rax,%rdi
add    %rax,%rsi
cmp    %rbp,%rbx
je     12d7 <DistanceREV+0x117>
cmp    $0x2,%r12d
jae    1af0 <DistanceREV+0x930>
xor    %ecx,%ecx
jmp    1bf2 <DistanceREV+0xa32>
movq   %rbx,%xmm4
pshufd $0x44,%xmm4,%xmm1
test   %r9,%r9
je     1c0e <DistanceREV+0xa4e>
mov    %r8,%rdx
xor    %ecx,%ecx
movdqa %xmm8,%xmm5
nopl   (%rax)
movupd -0x10(%rdi,%rcx,8),%xmm7
movupd (%rdi,%rcx,8),%xmm6
divpd  %xmm3,%xmm7
movdqa %xmm1,%xmm4
pcmpeqd %xmm5,%xmm4
pshufd $0xb1,%xmm4,%xmm2
pand   %xmm4,%xmm2
pxor   %xmm4,%xmm4
maxpd  %xmm7,%xmm4
andpd  %xmm2,%xmm7
andnpd %xmm4,%xmm2
orpd   %xmm7,%xmm2
movupd %xmm2,-0x10(%rdi,%rcx,8)
movdqa %xmm5,%xmm2
paddq  %xmm9,%xmm2
divpd  %xmm3,%xmm6
pcmpeqd %xmm1,%xmm2
pshufd $0xb1,%xmm2,%xmm4
pand   %xmm2,%xmm4
pxor   %xmm2,%xmm2
maxpd  %xmm6,%xmm2
andpd  %xmm4,%xmm6
andnpd %xmm2,%xmm4
orpd   %xmm6,%xmm4
movupd %xmm4,(%rdi,%rcx,8)
add    $0x4,%rcx
paddq  %xmm10,%xmm5
add    $0xfffffffffffffffe,%rdx
jne    1b10 <DistanceREV+0x950>
test   $0x1,%r10b
je     1bcd <DistanceREV+0xa0d>
mov    %rbx,%rdx
imul   %rbp,%rdx
add    %rdx,%rcx
movupd (%r15,%rcx,8),%xmm2
divpd  %xmm3,%xmm2
pcmpeqd %xmm5,%xmm1
pshufd $0xb1,%xmm1,%xmm4
pand   %xmm1,%xmm4
pxor   %xmm1,%xmm1
maxpd  %xmm2,%xmm1
andpd  %xmm4,%xmm2
andnpd %xmm1,%xmm4
orpd   %xmm2,%xmm4
movupd %xmm4,(%r15,%rcx,8)
mov    %r11,%rcx
cmp    %rbp,%r11
jne    1bf2 <DistanceREV+0xa32>
jmp    1ad0 <DistanceREV+0x910>
nopw   0x0(%rax,%rax,1)
movsd  %xmm4,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
je     1ad0 <DistanceREV+0x910>
movsd  (%rsi,%rcx,8),%xmm4
divsd  %xmm0,%xmm4
cmp    %rcx,%rbx
je     1be0 <DistanceREV+0xa20>
xorpd  %xmm1,%xmm1
maxsd  %xmm4,%xmm1
movapd %xmm1,%xmm4
jmp    1be0 <DistanceREV+0xa20>
xor    %ecx,%ecx
movdqa %xmm8,%xmm5
test   $0x1,%r10b
jne    1b92 <DistanceREV+0x9d2>
jmp    1bcd <DistanceREV+0xa0d>
xor    %edx,%edx
test   $0x1,%cl
jne    1a31 <DistanceREV+0x871>
jmp    1a41 <DistanceREV+0x881>
xorpd  %xmm0,%xmm0
mov    0x8(%rsp),%r11
test   $0x1,%r11b
jne    1991 <DistanceREV+0x7d1>
jmp    19b1 <DistanceREV+0x7f1>

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

LLVM IR (-O2):
@.str = [10 x i8] c"eigen jgl\00"
@.str.1 = [17 x i8] c" Root %d:%10.4f\00"
@.str.2 = [17 x i8] c"err: DistanceREV\00"
define double @DistanceREV(double* %0, i32 %1, double %2, double* %3, double* %4, double* %5, double* nocapture %6, double* %7, i32* nocapture writeonly %8) {
%10 = mul nsw i32 %1, %1
%11 = zext i32 %10 to i64
%12 = getelementptr inbounds double, double* %7, i64 %11
store i32 0, i32* %8
%13 = icmp sgt i32 %1, 0
br i1 %13, label %14, label %71
14: ; preds = %9
%15 = zext i32 %1 to i64
%16 = zext i32 %1 to i64
%17 = add nsw i64 %16, -1
%18 = and i64 %16, 1
%19 = icmp eq i64 %17, 0
%20 = and i64 %16, 4294967294
%21 = icmp eq i64 %18, 0
br label %22
22: ; preds = %61, %14
%23 = phi i64 [ 0, %14 ], [ %63, %61 ]
%24 = phi double [ 0.000000e+00, %14 ], [ %62, %61 ]
%25 = mul nsw i64 %23, %15
br i1 %19, label %50, label %26
26: ; preds = %22, %45
%27 = phi i64 [ %47, %45 ], [ 0, %22 ]
%28 = phi double [ %46, %45 ], [ %24, %22 ]
%29 = phi i64 [ %48, %45 ], [ 0, %22 ]
%30 = icmp eq i64 %23, %27
br i1 %30, label %36, label %31
31: ; preds = %26
%32 = add nuw nsw i64 %27, %25
%33 = getelementptr inbounds double, double* %0, i64 %32
%34 = load double, double* %33
%35 = fadd double %28, %34
br label %36
36: ; preds = %26, %31
%37 = phi double [ %35, %31 ], [ %28, %26 ]
%38 = or i64 %27, 1
%39 = icmp eq i64 %23, %38
br i1 %39, label %45, label %40
40: ; preds = %36
%41 = add nuw nsw i64 %38, %25
%42 = getelementptr inbounds double, double* %0, i64 %41
%43 = load double, double* %42
%44 = fadd double %37, %43
br label %45
45: ; preds = %40, %36
%46 = phi double [ %44, %40 ], [ %37, %36 ]
%47 = add nuw nsw i64 %27, 2
%48 = add i64 %29, 2
%49 = icmp eq i64 %48, %20
br i1 %49, label %50, label %26
50: ; preds = %45, %22
%51 = phi double [ undef, %22 ], [ %46, %45 ]
%52 = phi i64 [ 0, %22 ], [ %47, %45 ]
%53 = phi double [ %24, %22 ], [ %46, %45 ]
br i1 %21, label %61, label %54
54: ; preds = %50
%55 = icmp eq i64 %23, %52
br i1 %55, label %61, label %56
56: ; preds = %54
%57 = add nuw nsw i64 %52, %25
%58 = getelementptr inbounds double, double* %0, i64 %57
%59 = load double, double* %58
%60 = fadd double %53, %59
br label %61
61: ; preds = %54, %56, %50
%62 = phi double [ %51, %50 ], [ %60, %56 ], [ %53, %54 ]
%63 = add nuw nsw i64 %23, 1
%64 = icmp eq i64 %63, %16
br i1 %64, label %65, label %22
65: ; preds = %61
%66 = fcmp olt double %62, 0x3EB0C6F7A0B5ED8D
br i1 %66, label %71, label %67
67: ; preds = %65
br i1 %13, label %68, label %156
68: ; preds = %67
%69 = zext i32 %1 to i64
%70 = zext i32 %1 to i64
br label %73
71: ; preds = %9, %65
store i32 1, i32* %8
%72 = tail call i32 @zero(double* %0, i32 %10)
br label %536
73: ; preds = %68, %120
%74 = phi i64 [ 0, %68 ], [ %121, %120 ]
%75 = icmp eq i64 %74, 0
br i1 %75, label %120, label %76
76: ; preds = %73
%77 = mul nsw i64 %74, %69
%78 = and i64 %74, 1
%79 = icmp eq i64 %74, 1
br i1 %79, label %107, label %80
80: ; preds = %76
%81 = and i64 %74, 9223372036854775806
br label %82
82: ; preds = %82, %80
%83 = phi i64 [ 0, %80 ], [ %104, %82 ]
%84 = phi i64 [ 0, %80 ], [ %105, %82 ]
%85 = add nuw nsw i64 %83, %77
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = load double, double* %86
%88 = mul nsw i64 %83, %69
%89 = add nuw nsw i64 %88, %74
%90 = getelementptr inbounds double, double* %0, i64 %89
%91 = load double, double* %90
%92 = fadd double %87, %91
%93 = fmul double %92, 5.000000e-01
store double %93, double* %90
store double %93, double* %86
%94 = or i64 %83, 1
%95 = add nuw nsw i64 %94, %77
%96 = getelementptr inbounds double, double* %0, i64 %95
%97 = load double, double* %96
%98 = mul nsw i64 %94, %69
%99 = add nuw nsw i64 %98, %74
%100 = getelementptr inbounds double, double* %0, i64 %99
%101 = load double, double* %100
%102 = fadd double %97, %101
%103 = fmul double %102, 5.000000e-01
store double %103, double* %100
store double %103, double* %96
%104 = add nuw nsw i64 %83, 2
%105 = add i64 %84, 2
%106 = icmp eq i64 %105, %81
br i1 %106, label %107, label %82
107: ; preds = %82, %76
%108 = phi i64 [ 0, %76 ], [ %104, %82 ]
%109 = icmp eq i64 %78, 0
br i1 %109, label %120, label %110
110: ; preds = %107
%111 = add nuw nsw i64 %108, %77
%112 = getelementptr inbounds double, double* %0, i64 %111
%113 = load double, double* %112
%114 = mul nsw i64 %108, %69
%115 = add nuw nsw i64 %114, %74
%116 = getelementptr inbounds double, double* %0, i64 %115
%117 = load double, double* %116
%118 = fadd double %113, %117
%119 = fmul double %118, 5.000000e-01
store double %119, double* %116
store double %119, double* %112
br label %120
120: ; preds = %110, %107, %73
%121 = add nuw nsw i64 %74, 1
%122 = icmp eq i64 %121, %70
br i1 %122, label %123, label %73
123: ; preds = %120
%124 = tail call i32 @sum(double* %0, i32 %10)
%125 = sitofp i32 %124 to double
%126 = fdiv double 1.000000e+00, %125
%127 = fptosi double %126 to i32
%128 = tail call i32 @abyx(i32 %127, double* %0, i32 %10)
br i1 %13, label %129, label %162
129: ; preds = %123
%130 = zext i32 %1 to i64
%131 = zext i32 %1 to i64
br label %132
132: ; preds = %129, %153
%133 = phi i64 [ 0, %129 ], [ %154, %153 ]
%134 = trunc i64 %133 to i32
%135 = mul nsw i64 %133, %130
%136 = mul nsw i32 %134, %1
%137 = getelementptr inbounds double, double* %0, i64 %135
%138 = tail call i32 @sum(double* %137, i32 %1)
%139 = sitofp i32 %138 to double
%140 = getelementptr inbounds double, double* %6, i64 %133
store double %139, double* %140
%141 = sext i32 %136 to i64
%142 = add nsw i64 %133, %141
%143 = getelementptr inbounds double, double* %0, i64 %142
%144 = load double, double* %143
%145 = fcmp ugt double %144, 0x3EB0C6F7A0B5ED8D
br i1 %145, label %149, label %146
146: ; preds = %132
%147 = fsub double 1.000000e+00, %139
%148 = fadd double %147, %144
store double %148, double* %143
store i32 -1, i32* %8
br label %153
149: ; preds = %132
%150 = fdiv double 1.000000e+00, %139
%151 = fptosi double %150 to i32
%152 = tail call i32 @abyx(i32 %151, double* %137, i32 %1)
br label %153
153: ; preds = %146, %149
%154 = add nuw nsw i64 %133, 1
%155 = icmp eq i64 %154, %131
br i1 %155, label %162, label %132
156: ; preds = %67
%157 = tail call i32 @sum(double* %0, i32 %10)
%158 = sitofp i32 %157 to double
%159 = fdiv double 1.000000e+00, %158
%160 = fptosi double %159 to i32
%161 = tail call i32 @abyx(i32 %160, double* %0, i32 %10)
br label %162
162: ; preds = %153, %156, %123
%163 = tail call i64 @eigen(i32 1, double* %0, i32 %1, double* %3, double* %7, double* %4, double* %5, double* %12)
%164 = icmp eq i64 %163, 0
br i1 %164, label %167, label %165
165: ; preds = %162
%166 = tail call i32 @error2(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %167
167: ; preds = %165, %162
%168 = tail call i32 @xtoy(double* %4, double* %5, i32 %10)
%169 = tail call i32 @matinv(double* %5, i32 %1, i32 %1, double* %7)
br i1 %13, label %170, label %339
170: ; preds = %167
%171 = fcmp ugt double %2, 0.000000e+00
%172 = fdiv double -1.000000e+00, %2
%173 = fptosi double %172 to i32
%174 = zext i32 %1 to i64
br label %194
175: ; preds = %212
br i1 %13, label %176, label %339
176: ; preds = %175
%177 = zext i32 %1 to i64
%178 = zext i32 %1 to i64
%179 = getelementptr double, double* %3, i64 %16
%180 = and i64 %16, 4294967292
%181 = add nsw i64 %180, -4
%182 = lshr exact i64 %181, 2
%183 = add nuw nsw i64 %182, 1
%184 = icmp ult i32 %1, 4
%185 = and i64 %16, 4294967292
%186 = and i64 %183, 1
%187 = icmp eq i64 %181, 0
%188 = and i64 %183, 9223372036854775806
%189 = icmp eq i64 %186, 0
%190 = icmp eq i64 %185, %16
%191 = and i64 %16, 1
%192 = icmp eq i64 %191, 0
%193 = sub nsw i64 0, %16
br label %216
194: ; preds = %170, %212
%195 = phi i64 [ 0, %170 ], [ %214, %212 ]
%196 = getelementptr inbounds double, double* %3, i64 %195
%197 = load double, double* %196
%198 = fcmp ugt double %197, 0.000000e+00
br i1 %198, label %203, label %199
199: ; preds = %194
%200 = trunc i64 %195 to i32
%201 = add i32 %200, 1
%202 = tail call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), i32 %201, double %197)
br label %203
203: ; preds = %199, %194
%204 = load double, double* %196
br i1 %171, label %207, label %205
205: ; preds = %203
%206 = tail call double @log(double %204)
br label %212
207: ; preds = %203
%208 = tail call i32 @pow(double %204, i32 %173)
%209 = sub nsw i32 1, %208
%210 = sitofp i32 %209 to double
%211 = fmul double %210, %2
br label %212
212: ; preds = %207, %205
%213 = phi double [ %206, %205 ], [ %211, %207 ]
store double %213, double* %196
%214 = add nuw nsw i64 %195, 1
%215 = icmp eq i64 %214, %174
br i1 %215, label %175, label %194
216: ; preds = %336, %176
%217 = phi i64 [ 0, %176 ], [ %337, %336 ]
%218 = mul i64 %217, %16
%219 = getelementptr double, double* %7, i64 %218
%220 = add i64 %218, %16
%221 = getelementptr double, double* %7, i64 %220
%222 = mul nsw i64 %217, %177
br i1 %184, label %302, label %223
223: ; preds = %216
%224 = getelementptr double, double* %4, i64 %220
%225 = getelementptr double, double* %4, i64 %218
%226 = icmp ult double* %219, %224
%227 = icmp ult double* %225, %221
%228 = and i1 %226, %227
%229 = icmp ult double* %219, %179
%230 = icmp ugt double* %221, %3
%231 = and i1 %229, %230
%232 = or i1 %228, %231
br i1 %232, label %302, label %233
233: ; preds = %223
br i1 %187, label %279, label %234
234: ; preds = %233, %234
%235 = phi i64 [ %276, %234 ], [ 0, %233 ]
%236 = phi i64 [ %277, %234 ], [ 0, %233 ]
%237 = add nuw nsw i64 %235, %222
%238 = getelementptr inbounds double, double* %4, i64 %237
%239 = bitcast double* %238 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = getelementptr inbounds double, double* %238, i64 2
%242 = bitcast double* %241 to <2 x double>*
%243 = load <2 x double>, <2 x double>* %242
%244 = getelementptr inbounds double, double* %3, i64 %235
%245 = bitcast double* %244 to <2 x double>*
%246 = load <2 x double>, <2 x double>* %245
%247 = getelementptr inbounds double, double* %244, i64 2
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = fmul <2 x double> %240, %246
%251 = fmul <2 x double> %243, %249
%252 = getelementptr inbounds double, double* %7, i64 %237
%253 = bitcast double* %252 to <2 x double>*
store <2 x double> %250, <2 x double>* %253
%254 = getelementptr inbounds double, double* %252, i64 2
%255 = bitcast double* %254 to <2 x double>*
store <2 x double> %251, <2 x double>* %255
%256 = or i64 %235, 4
%257 = add nuw nsw i64 %256, %222
%258 = getelementptr inbounds double, double* %4, i64 %257
%259 = bitcast double* %258 to <2 x double>*
%260 = load <2 x double>, <2 x double>* %259
%261 = getelementptr inbounds double, double* %258, i64 2
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = getelementptr inbounds double, double* %3, i64 %256
%265 = bitcast double* %264 to <2 x double>*
%266 = load <2 x double>, <2 x double>* %265
%267 = getelementptr inbounds double, double* %264, i64 2
%268 = bitcast double* %267 to <2 x double>*
%269 = load <2 x double>, <2 x double>* %268
%270 = fmul <2 x double> %260, %266
%271 = fmul <2 x double> %263, %269
%272 = getelementptr inbounds double, double* %7, i64 %257
%273 = bitcast double* %272 to <2 x double>*
store <2 x double> %270, <2 x double>* %273
%274 = getelementptr inbounds double, double* %272, i64 2
%275 = bitcast double* %274 to <2 x double>*
store <2 x double> %271, <2 x double>* %275
%276 = add nuw i64 %235, 8
%277 = add i64 %236, 2
%278 = icmp eq i64 %277, %188
br i1 %278, label %279, label %234
279: ; preds = %234, %233
%280 = phi i64 [ 0, %233 ], [ %276, %234 ]
br i1 %189, label %301, label %281
281: ; preds = %279
%282 = add nuw nsw i64 %280, %222
%283 = getelementptr inbounds double, double* %4, i64 %282
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %283, i64 2
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = getelementptr inbounds double, double* %3, i64 %280
%290 = bitcast double* %289 to <2 x double>*
%291 = load <2 x double>, <2 x double>* %290
%292 = getelementptr inbounds double, double* %289, i64 2
%293 = bitcast double* %292 to <2 x double>*
%294 = load <2 x double>, <2 x double>* %293
%295 = fmul <2 x double> %285, %291
%296 = fmul <2 x double> %288, %294
%297 = getelementptr inbounds double, double* %7, i64 %282
%298 = bitcast double* %297 to <2 x double>*
store <2 x double> %295, <2 x double>* %298
%299 = getelementptr inbounds double, double* %297, i64 2
%300 = bitcast double* %299 to <2 x double>*
store <2 x double> %296, <2 x double>* %300
br label %301
301: ; preds = %279, %281
br i1 %190, label %336, label %302
302: ; preds = %223, %216, %301
%303 = phi i64 [ 0, %223 ], [ 0, %216 ], [ %185, %301 ]
%304 = xor i64 %303, -1
br i1 %192, label %314, label %305
305: ; preds = %302
%306 = add nuw nsw i64 %303, %222
%307 = getelementptr inbounds double, double* %4, i64 %306
%308 = load double, double* %307
%309 = getelementptr inbounds double, double* %3, i64 %303
%310 = load double, double* %309
%311 = fmul double %308, %310
%312 = getelementptr inbounds double, double* %7, i64 %306
store double %311, double* %312
%313 = or i64 %303, 1
br label %314
314: ; preds = %305, %302
%315 = phi i64 [ %303, %302 ], [ %313, %305 ]
%316 = icmp eq i64 %304, %193
br i1 %316, label %336, label %317
317: ; preds = %314, %317
%318 = phi i64 [ %334, %317 ], [ %315, %314 ]
%319 = add nuw nsw i64 %318, %222
%320 = getelementptr inbounds double, double* %4, i64 %319
%321 = load double, double* %320
%322 = getelementptr inbounds double, double* %3, i64 %318
%323 = load double, double* %322
%324 = fmul double %321, %323
%325 = getelementptr inbounds double, double* %7, i64 %319
store double %324, double* %325
%326 = add nuw nsw i64 %318, 1
%327 = add nuw nsw i64 %326, %222
%328 = getelementptr inbounds double, double* %4, i64 %327
%329 = load double, double* %328
%330 = getelementptr inbounds double, double* %3, i64 %326
%331 = load double, double* %330
%332 = fmul double %329, %331
%333 = getelementptr inbounds double, double* %7, i64 %327
store double %332, double* %333
%334 = add nuw nsw i64 %318, 2
%335 = icmp eq i64 %334, %178
br i1 %335, label %336, label %317
336: ; preds = %314, %317, %301
%337 = add nuw nsw i64 %217, 1
%338 = icmp eq i64 %337, %178
br i1 %338, label %341, label %216
339: ; preds = %175, %167
%340 = tail call i32 @matby(double* %7, double* %5, double* %0, i32 %1, i32 %1, i32 %1)
br label %395
341: ; preds = %336
%342 = tail call i32 @matby(double* %7, double* %5, double* %0, i32 %1, i32 %1, i32 %1)
br i1 %13, label %343, label %395
343: ; preds = %341
%344 = and i64 %16, 1
%345 = icmp eq i64 %17, 0
br i1 %345, label %376, label %346
346: ; preds = %343
%347 = and i64 %16, 4294967294
br label %348
348: ; preds = %348, %346
%349 = phi i64 [ 0, %346 ], [ %373, %348 ]
%350 = phi double [ 0.000000e+00, %346 ], [ %372, %348 ]
%351 = phi i64 [ 0, %346 ], [ %374, %348 ]
%352 = trunc i64 %349 to i32
%353 = getelementptr inbounds double, double* %6, i64 %349
%354 = load double, double* %353
%355 = mul nsw i32 %352, %1
%356 = sext i32 %355 to i64
%357 = add nsw i64 %349, %356
%358 = getelementptr inbounds double, double* %0, i64 %357
%359 = load double, double* %358
%360 = fneg double %354
%361 = tail call double @llvm.fmuladd.f64(double %360, double %359, double %350)
%362 = or i64 %349, 1
%363 = trunc i64 %362 to i32
%364 = getelementptr inbounds double, double* %6, i64 %362
%365 = load double, double* %364
%366 = mul nsw i32 %363, %1
%367 = sext i32 %366 to i64
%368 = add nsw i64 %362, %367
%369 = getelementptr inbounds double, double* %0, i64 %368
%370 = load double, double* %369
%371 = fneg double %365
%372 = tail call double @llvm.fmuladd.f64(double %371, double %370, double %361)
%373 = add nuw nsw i64 %349, 2
%374 = add i64 %351, 2
%375 = icmp eq i64 %374, %347
br i1 %375, label %376, label %348
376: ; preds = %348, %343
%377 = phi double [ undef, %343 ], [ %372, %348 ]
%378 = phi i64 [ 0, %343 ], [ %373, %348 ]
%379 = phi double [ 0.000000e+00, %343 ], [ %372, %348 ]
%380 = icmp eq i64 %344, 0
br i1 %380, label %392, label %381
381: ; preds = %376
%382 = trunc i64 %378 to i32
%383 = getelementptr inbounds double, double* %6, i64 %378
%384 = load double, double* %383
%385 = mul nsw i32 %382, %1
%386 = sext i32 %385 to i64
%387 = add nsw i64 %378, %386
%388 = getelementptr inbounds double, double* %0, i64 %387
%389 = load double, double* %388
%390 = fneg double %384
%391 = tail call double @llvm.fmuladd.f64(double %390, double %389, double %379)
br label %392
392: ; preds = %376, %381
%393 = phi double [ %377, %376 ], [ %391, %381 ]
%394 = fcmp ugt double %393, 0.000000e+00
br i1 %394, label %398, label %395
395: ; preds = %339, %341, %392
%396 = phi double [ %393, %392 ], [ 0.000000e+00, %341 ], [ 0.000000e+00, %339 ]
%397 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
br label %398
398: ; preds = %395, %392
%399 = phi double [ %396, %395 ], [ %393, %392 ]
br i1 %13, label %400, label %536
400: ; preds = %398
%401 = zext i32 %1 to i64
%402 = icmp eq i32 %1, 1
br i1 %402, label %442, label %403
403: ; preds = %400
%404 = and i64 %16, 4294967294
%405 = insertelement <2 x double> poison, double %399, i64 0
%406 = shufflevector <2 x double> %405, <2 x double> poison, <2 x i32> zeroinitializer
%407 = add nsw i64 %404, -2
%408 = lshr exact i64 %407, 1
%409 = add nuw i64 %408, 1
%410 = and i64 %409, 1
%411 = icmp eq i64 %407, 0
br i1 %411, label %431, label %412
412: ; preds = %403
%413 = and i64 %409, -2
br label %414
414: ; preds = %414, %412
%415 = phi i64 [ 0, %412 ], [ %428, %414 ]
%416 = phi i64 [ 0, %412 ], [ %429, %414 ]
%417 = getelementptr inbounds double, double* %3, i64 %415
%418 = bitcast double* %417 to <2 x double>*
%419 = load <2 x double>, <2 x double>* %418
%420 = fdiv <2 x double> %419, %406
%421 = bitcast double* %417 to <2 x double>*
store <2 x double> %420, <2 x double>* %421
%422 = or i64 %415, 2
%423 = getelementptr inbounds double, double* %3, i64 %422
%424 = bitcast double* %423 to <2 x double>*
%425 = load <2 x double>, <2 x double>* %424
%426 = fdiv <2 x double> %425, %406
%427 = bitcast double* %423 to <2 x double>*
store <2 x double> %426, <2 x double>* %427
%428 = add nuw i64 %415, 4
%429 = add nuw i64 %416, 2
%430 = icmp eq i64 %429, %413
br i1 %430, label %431, label %414
431: ; preds = %414, %403
%432 = phi i64 [ 0, %403 ], [ %428, %414 ]
%433 = icmp eq i64 %410, 0
br i1 %433, label %440, label %434
434: ; preds = %431
%435 = getelementptr inbounds double, double* %3, i64 %432
%436 = bitcast double* %435 to <2 x double>*
%437 = load <2 x double>, <2 x double>* %436
%438 = fdiv <2 x double> %437, %406
%439 = bitcast double* %435 to <2 x double>*
store <2 x double> %438, <2 x double>* %439
br label %440
440: ; preds = %431, %434
%441 = icmp eq i64 %404, %16
br i1 %441, label %444, label %442
442: ; preds = %400, %440
%443 = phi i64 [ 0, %400 ], [ %404, %440 ]
br label %461
444: ; preds = %461, %440
br i1 %13, label %445, label %536
445: ; preds = %444
%446 = zext i32 %1 to i64
%447 = zext i32 %1 to i64
%448 = and i64 %16, 4294967294
%449 = add nsw i64 %448, -2
%450 = lshr exact i64 %449, 1
%451 = add nuw i64 %450, 1
%452 = icmp ult i32 %1, 2
%453 = and i64 %16, 4294967294
%454 = insertelement <2 x double> poison, double %399, i64 0
%455 = shufflevector <2 x double> %454, <2 x double> poison, <2 x i32> zeroinitializer
%456 = and i64 %451, 1
%457 = icmp eq i64 %449, 0
%458 = and i64 %451, -2
%459 = icmp eq i64 %456, 0
%460 = icmp eq i64 %453, %16
br label %468
461: ; preds = %442, %461
%462 = phi i64 [ %466, %461 ], [ %443, %442 ]
%463 = getelementptr inbounds double, double* %3, i64 %462
%464 = load double, double* %463
%465 = fdiv double %464, %399
store double %465, double* %463
%466 = add nuw nsw i64 %462, 1
%467 = icmp eq i64 %466, %401
br i1 %467, label %444, label %461
468: ; preds = %533, %445
%469 = phi i64 [ 0, %445 ], [ %534, %533 ]
%470 = mul nsw i64 %469, %446
br i1 %452, label %519, label %471
471: ; preds = %468
%472 = insertelement <2 x i64> poison, i64 %469, i64 0
%473 = shufflevector <2 x i64> %472, <2 x i64> poison, <2 x i32> zeroinitializer
br i1 %457, label %504, label %474
474: ; preds = %471, %474
%475 = phi i64 [ %500, %474 ], [ 0, %471 ]
%476 = phi <2 x i64> [ %501, %474 ], [ <i64 0, i64 1>, %471 ]
%477 = phi i64 [ %502, %474 ], [ 0, %471 ]
%478 = add nuw nsw i64 %475, %470
%479 = getelementptr inbounds double, double* %0, i64 %478
%480 = bitcast double* %479 to <2 x double>*
%481 = load <2 x double>, <2 x double>* %480
%482 = fdiv <2 x double> %481, %455
%483 = icmp eq <2 x i64> %473, %476
%484 = fcmp olt <2 x double> %482, zeroinitializer
%485 = select <2 x i1> %484, <2 x double> zeroinitializer, <2 x double> %482
%486 = select <2 x i1> %483, <2 x double> %482, <2 x double> %485
%487 = bitcast double* %479 to <2 x double>*
store <2 x double> %486, <2 x double>* %487
%488 = or i64 %475, 2
%489 = add <2 x i64> %476, <i64 2, i64 2>
%490 = add nuw nsw i64 %488, %470
%491 = getelementptr inbounds double, double* %0, i64 %490
%492 = bitcast double* %491 to <2 x double>*
%493 = load <2 x double>, <2 x double>* %492
%494 = fdiv <2 x double> %493, %455
%495 = icmp eq <2 x i64> %473, %489
%496 = fcmp olt <2 x double> %494, zeroinitializer
%497 = select <2 x i1> %496, <2 x double> zeroinitializer, <2 x double> %494
%498 = select <2 x i1> %495, <2 x double> %494, <2 x double> %497
%499 = bitcast double* %491 to <2 x double>*
store <2 x double> %498, <2 x double>* %499
%500 = add nuw i64 %475, 4
%501 = add <2 x i64> %476, <i64 4, i64 4>
%502 = add nuw i64 %477, 2
%503 = icmp eq i64 %502, %458
br i1 %503, label %504, label %474
504: ; preds = %474, %471
%505 = phi i64 [ 0, %471 ], [ %500, %474 ]
%506 = phi <2 x i64> [ <i64 0, i64 1>, %471 ], [ %501, %474 ]
br i1 %459, label %518, label %507
507: ; preds = %504
%508 = add nuw nsw i64 %505, %470
%509 = getelementptr inbounds double, double* %0, i64 %508
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = fdiv <2 x double> %511, %455
%513 = icmp eq <2 x i64> %473, %506
%514 = fcmp olt <2 x double> %512, zeroinitializer
%515 = select <2 x i1> %514, <2 x double> zeroinitializer, <2 x double> %512
%516 = select <2 x i1> %513, <2 x double> %512, <2 x double> %515
%517 = bitcast double* %509 to <2 x double>*
store <2 x double> %516, <2 x double>* %517
br label %518
518: ; preds = %504, %507
br i1 %460, label %533, label %519
519: ; preds = %468, %518
%520 = phi i64 [ 0, %468 ], [ %453, %518 ]
br label %521
521: ; preds = %519, %521
%522 = phi i64 [ %531, %521 ], [ %520, %519 ]
%523 = add nuw nsw i64 %522, %470
%524 = getelementptr inbounds double, double* %0, i64 %523
%525 = load double, double* %524
%526 = fdiv double %525, %399
%527 = icmp eq i64 %469, %522
%528 = fcmp olt double %526, 0.000000e+00
%529 = select i1 %528, double 0.000000e+00, double %526
%530 = select i1 %527, double %526, double %529
store double %530, double* %524
%531 = add nuw nsw i64 %522, 1
%532 = icmp eq i64 %531, %447
br i1 %532, label %533, label %521
533: ; preds = %521, %518
%534 = add nuw nsw i64 %469, 1
%535 = icmp eq i64 %534, %447
br i1 %535, label %536, label %468
536: ; preds = %533, %398, %444, %71
%537 = phi double [ 0.000000e+00, %71 ], [ %399, %444 ], [ %399, %398 ], [ %399, %533 ]
ret double %537
}