#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 */
double **dmatrix(int, int, int, int);
double *dvector(int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int /*<<< orphan*/ free_dvector(double *, int, int);
int /*<<< orphan*/ ldl_dcmp(double **, int, double *, double *, double *, int,
                            int, int *);
int /*<<< orphan*/ ldl_mprove(double **, int, double *, double *, double *,
                              double *, int *);
int /*<<< orphan*/ stdout;
void invAXinvA(double **A, double **X, int n, int verbose) {
  double *diag, *b, *x, **Ai, **XAi, Aij, error;
  int i, j, k, ok;
  diag = dvector(1, n);
  x = dvector(1, n);
  b = dvector(1, n);
  Ai = dmatrix(1, n, 1, n);
  XAi = dmatrix(1, n, 1, n);
  for (i = 1; i <= n; i++) {
    diag[i] = x[i] = b[i] = 0.0;
    for (j = 1; j <= n; j++)
      XAi[i][j] = Ai[i][j] = 0.0;
  }
  ldl_dcmp(A, n, diag, b, x, 1, 0, &ok);
  for (j = 1; j <= n; j++) {
    for (k = 1; k <= n; k++)
      b[k] = 0.0;
    b[j] = 1.0;
    ldl_dcmp(A, n, diag, b, x, 0, 1, &ok);
    if (verbose)
      fprintf(stdout, "    LDL' RMS matrix precision:");
    error = ok = 1;
    do {
      ldl_mprove(A, n, diag, b, x, &error, &ok);
      if (verbose)
        fprintf(stdout, "%9.2e", error);
    } while (ok);
    if (verbose)
      fprintf(stdout, "\n");
    for (k = 1; k <= n; k++)
      Ai[j][k] = x[k];
  }
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      Ai[i][j] = Ai[j][i] = 0.5 * (Ai[i][j] + Ai[j][i]);
  for (i = 1; i <= n; i++) {
    for (j = 1; j <= n; j++) {
      Aij = 0.0;
      for (k = 1; k <= n; k++)
        Aij += X[i][k] * Ai[k][j];
      XAi[i][j] = Aij;
    }
  }
  for (i = 1; i <= n; i++) {
    for (j = 1; j <= n; j++) {
      Aij = 0.0;
      for (k = 1; k <= n; k++)
        Aij += Ai[i][k] * XAi[k][j];
      X[i][j] = Aij;
    }
  }
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      X[i][j] = X[j][i] = 0.5 * (X[i][j] + X[j][i]);
  free_dvector(diag, 1, n);
  free_dvector(x, 1, n);
  free_dvector(b, 1, n);
  free_dmatrix(Ai, 1, n, 1, n);
  free_dmatrix(XAi, 1, n, 1, n);
}


x86 assembly (clang, -O0):
<invAXinvA>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1040 <dmatrix@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1040 <dmatrix@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     128c <invAXinvA+0x11c>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1279 <invAXinvA+0x109>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    122f <invAXinvA+0xbf>
jmp    127e <invAXinvA+0x10e>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11ec <invAXinvA+0x7c>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    $0x1,%r9d
xor    %eax,%eax
lea    -0x60(%rbp),%rax
movl   $0x0,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <ldl_dcmp@plt>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1445 <invAXinvA+0x2d5>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1300 <invAXinvA+0x190>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12d6 <invAXinvA+0x166>
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  0xcf8(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
xor    %r9d,%r9d
lea    -0x60(%rbp),%rax
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <ldl_dcmp@plt>
cmpl   $0x0,-0x18(%rbp)
je     1361 <invAXinvA+0x1f1>
mov    0x2c8f(%rip),%rax
mov    (%rax),%edi
lea    0xcb6(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x1,-0x60(%rbp)
movsd  0xc98(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
lea    -0x50(%rbp),%r9
lea    -0x60(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <ldl_mprove@plt>
cmpl   $0x0,-0x18(%rbp)
je     13bf <invAXinvA+0x24f>
mov    0x2c36(%rip),%rax
mov    (%rax),%edi
movsd  -0x50(%rbp),%xmm0
lea    0xc77(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
jmp    13c4 <invAXinvA+0x254>
cmpl   $0x0,-0x60(%rbp)
jne    1375 <invAXinvA+0x205>
cmpl   $0x0,-0x18(%rbp)
je     13ef <invAXinvA+0x27f>
mov    0x2c01(%rip),%rax
mov    (%rax),%edi
lea    0xc4d(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1432 <invAXinvA+0x2c2>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13f6 <invAXinvA+0x286>
jmp    1437 <invAXinvA+0x2c7>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12c3 <invAXinvA+0x153>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14eb <invAXinvA+0x37b>
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14d8 <invAXinvA+0x368>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xb64(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    145e <invAXinvA+0x2ee>
jmp    14dd <invAXinvA+0x36d>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    144c <invAXinvA+0x2dc>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     15b1 <invAXinvA+0x441>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     159e <invAXinvA+0x42e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1576 <invAXinvA+0x406>
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1520 <invAXinvA+0x3b0>
movsd  -0x48(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1505 <invAXinvA+0x395>
jmp    15a3 <invAXinvA+0x433>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14f2 <invAXinvA+0x382>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1677 <invAXinvA+0x507>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1664 <invAXinvA+0x4f4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     163c <invAXinvA+0x4cc>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15e6 <invAXinvA+0x476>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15cb <invAXinvA+0x45b>
jmp    1669 <invAXinvA+0x4f9>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15b8 <invAXinvA+0x448>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     171d <invAXinvA+0x5ad>
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     170a <invAXinvA+0x59a>
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x932(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1690 <invAXinvA+0x520>
jmp    170f <invAXinvA+0x59f>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    167e <invAXinvA+0x50e>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1090 <free_dmatrix@plt>
mov    -0x40(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1090 <free_dmatrix@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invAXinvA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %ecx,0x34(%rsp)
mov    %edx,%r15d
mov    %rsi,0x38(%rsp)
mov    %rdi,0x48(%rsp)
mov    $0x1,%edi
mov    %edx,%esi
call   1080 <dvector@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %r15d,%esi
call   1080 <dvector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %r15d,%esi
call   1080 <dvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r15d,%esi
mov    $0x1,%edx
mov    %r15d,%ecx
call   1050 <dmatrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %r15d,%esi
mov    $0x1,%edx
mov    %r15d,%ecx
call   1050 <dmatrix@plt>
mov    %rax,%r14
test   %r15d,%r15d
mov    %rbp,0x58(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r15,0x20(%rsp)
jle    18e9 <invAXinvA+0x769>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
mov    %rax,0x60(%rsp)
mov    %r15d,%r10d
lea    0x1(%r10),%rdx
lea    -0x4(%r10),%rax
mov    %rax,0x70(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r10,0x28(%rsp)
and    $0xfffffffc,%r10d
lea    0x1(%r10),%r9
mov    %eax,%r11d
and    $0x3,%r11d
mov    %rax,0x50(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
xorpd  %xmm0,%xmm0
mov    %rdx,%rax
mov    %rdx,0x10(%rsp)
jmp    128d <invAXinvA+0x10d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rdx,%rdi
je     1474 <invAXinvA+0x2f4>
mov    0x40(%rsp),%rax
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,0x0(%r13,%rdi,8)
movq   $0x0,0x0(%rbp,%rdi,8)
mov    (%r12,%rdi,8),%rsi
mov    (%r14,%rdi,8),%rcx
mov    $0x1,%eax
cmpl   $0x4,0x28(%rsp)
jb     13d0 <invAXinvA+0x250>
lea    0x8(%rsi),%rax
mov    0x10(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
cmp    %rdx,%rax
jae    12f6 <invAXinvA+0x176>
mov    0x10(%rsp),%rax
lea    (%rsi,%rax,8),%rdx
lea    0x8(%rcx),%rbx
mov    $0x1,%eax
cmp    %rdx,%rbx
mov    0x10(%rsp),%rdx
jb     13d0 <invAXinvA+0x250>
cmpq   $0xc,0x70(%rsp)
jae    1302 <invAXinvA+0x182>
xor    %eax,%eax
jmp    137a <invAXinvA+0x1fa>
mov    0x18(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movupd %xmm0,0x8(%rsi,%rax,8)
movupd %xmm0,0x18(%rsi,%rax,8)
movupd %xmm0,0x8(%rcx,%rax,8)
movupd %xmm0,0x18(%rcx,%rax,8)
movupd %xmm0,0x28(%rsi,%rax,8)
movupd %xmm0,0x38(%rsi,%rax,8)
movupd %xmm0,0x28(%rcx,%rax,8)
movupd %xmm0,0x38(%rcx,%rax,8)
movupd %xmm0,0x48(%rsi,%rax,8)
movupd %xmm0,0x58(%rsi,%rax,8)
movupd %xmm0,0x48(%rcx,%rax,8)
movupd %xmm0,0x58(%rcx,%rax,8)
movupd %xmm0,0x68(%rsi,%rax,8)
movupd %xmm0,0x78(%rsi,%rax,8)
movupd %xmm0,0x68(%rcx,%rax,8)
movupd %xmm0,0x78(%rcx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdx
jne    1310 <invAXinvA+0x190>
test   %r11,%r11
je     13bc <invAXinvA+0x23c>
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rax,8),%rbx
or     $0x8,%rbx
movupd %xmm0,(%rsi,%rbx,1)
movupd %xmm0,0x10(%rsi,%rbx,1)
movupd %xmm0,(%rcx,%rbx,1)
movupd %xmm0,0x10(%rcx,%rbx,1)
add    $0x4,%rax
add    $0xffffffffffffffff,%rdx
jne    1390 <invAXinvA+0x210>
mov    %r9,%rax
cmp    %r10,0x28(%rsp)
mov    0x10(%rsp),%rdx
je     1280 <invAXinvA+0x100>
nop
mov    %r15,%rbx
mov    %edx,%r15d
sub    %eax,%r15d
mov    %rdx,%r8
mov    %rax,%rdx
not    %rdx
add    %r8,%rdx
and    $0x3,%r15
je     140a <invAXinvA+0x28a>
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rax,8)
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%r15
jne    13f0 <invAXinvA+0x270>
cmp    $0x3,%rdx
mov    %rbx,%r15
mov    0x10(%rsp),%rdx
jb     1280 <invAXinvA+0x100>
nopl   0x0(%rax)
movq   $0x0,(%rsi,%rax,8)
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,0x8(%rsi,%rax,8)
movq   $0x0,0x8(%rcx,%rax,8)
movq   $0x0,0x10(%rsi,%rax,8)
movq   $0x0,0x10(%rcx,%rax,8)
movq   $0x0,0x18(%rsi,%rax,8)
movq   $0x0,0x18(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1420 <invAXinvA+0x2a0>
jmp    1280 <invAXinvA+0x100>
lea    0xc(%rsp),%rax
mov    0x48(%rsp),%rdi
mov    %r15d,%esi
mov    %rbp,%rdx
mov    0x40(%rsp),%rcx
mov    %r13,%r8
mov    $0x1,%r9d
push   %rax
push   $0x0
call   1070 <ldl_dcmp@plt>
mov    0x20(%rsp),%rcx
add    $0x10,%rsp
test   %r15d,%r15d
mov    0x28(%rsp),%rax
jle    1911 <invAXinvA+0x791>
mov    0x40(%rsp),%r15
mov    %r15,%rdx
add    $0x8,%rdx
mov    %rdx,0xb0(%rsp)
shl    $0x3,%rax
mov    %rax,0xa8(%rsp)
mov    0x20(%rsp),%rax
lea    0x1(%rax),%r9d
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
mov    %rax,0xa0(%rsp)
mov    %r13,%rax
add    $0x8,%rax
mov    %rax,0x98(%rsp)
lea    -0x1(%rcx),%rax
mov    %rax,0x78(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
add    $0x1,%rax
mov    %rax,0x88(%rsp)
mov    0x50(%rsp),%rcx
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x68(%rsp)
and    %rcx,0x60(%rsp)
mov    $0x1,%r8d
lea    0x80(%rsp),%rbp
mov    %r9,0x18(%rsp)
jmp    155d <invAXinvA+0x3dd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
cmp    %r9,%r8
je     1851 <invAXinvA+0x6d1>
mov    0xb0(%rsp),%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rdx
mov    %r15,%rbx
mov    %r8,%r15
call   1040 <memset@plt>
mov    %r15,0x50(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rbx,%r15,8)
mov    0x48(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    %rbx,%r15
mov    %rbx,%rcx
mov    %r13,%r8
xor    %r9d,%r9d
lea    0xc(%rsp),%rax
push   %rax
push   $0x1
call   1070 <ldl_dcmp@plt>
add    $0x10,%rsp
cmpl   $0x0,0x34(%rsp)
je     15d7 <invAXinvA+0x457>
mov    0x2a19(%rip),%rax
mov    (%rax),%edi
lea    0xa38(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movl   $0x1,0xc(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x80(%rsp)
mov    0x29e8(%rip),%rbx
jmp    1607 <invAXinvA+0x487>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0xc(%rsp)
je     1669 <invAXinvA+0x4e9>
sub    $0x8,%rsp
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x60(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    %rbp,%r9
lea    0x14(%rsp),%rax
push   %rax
call   1030 <ldl_mprove@plt>
add    $0x10,%rsp
cmpl   $0x0,0x34(%rsp)
je     1600 <invAXinvA+0x480>
mov    (%rbx),%edi
movsd  0x80(%rsp),%xmm0
lea    0x9dc(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jne    1607 <invAXinvA+0x487>
mov    (%rbx),%edi
lea    0x9cb(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    0x50(%rsp),%r8
mov    (%r12,%r8,8),%rax
mov    $0x1,%ecx
cmpq   $0x4,0x78(%rsp)
jae    16a0 <invAXinvA+0x520>
mov    0x28(%rsp),%r11
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%r9
jmp    17c0 <invAXinvA+0x640>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x8(%rax),%rdx
cmp    0xa0(%rsp),%rdx
mov    0x28(%rsp),%r11
mov    0x18(%rsp),%r9
jae    16d4 <invAXinvA+0x554>
mov    0x10(%rsp),%rdx
lea    (%rax,%rdx,8),%rdx
cmp    %rdx,0x98(%rsp)
mov    0x10(%rsp),%rdx
jb     17c0 <invAXinvA+0x640>
cmpq   $0xc,0x70(%rsp)
jae    16e0 <invAXinvA+0x560>
xor    %ecx,%ecx
jmp    1756 <invAXinvA+0x5d6>
mov    0x60(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups 0x8(%r13,%rcx,8),%xmm0
movups 0x18(%r13,%rcx,8),%xmm1
movups %xmm0,0x8(%rax,%rcx,8)
movups %xmm1,0x18(%rax,%rcx,8)
movups 0x28(%r13,%rcx,8),%xmm0
movups 0x38(%r13,%rcx,8),%xmm1
movups %xmm0,0x28(%rax,%rcx,8)
movups %xmm1,0x38(%rax,%rcx,8)
movups 0x48(%r13,%rcx,8),%xmm0
movups 0x58(%r13,%rcx,8),%xmm1
movups %xmm0,0x48(%rax,%rcx,8)
movups %xmm1,0x58(%rax,%rcx,8)
movupd 0x68(%r13,%rcx,8),%xmm0
movupd 0x78(%r13,%rcx,8),%xmm1
movupd %xmm0,0x68(%rax,%rcx,8)
movupd %xmm1,0x78(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    16f0 <invAXinvA+0x570>
cmpq   $0x0,0x68(%rsp)
je     179f <invAXinvA+0x61f>
mov    0x68(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rcx,8),%rsi
or     $0x8,%rsi
movupd 0x0(%r13,%rsi,1),%xmm0
movupd 0x10(%r13,%rsi,1),%xmm1
movupd %xmm0,(%rax,%rsi,1)
movupd %xmm1,0x10(%rax,%rsi,1)
add    $0x4,%rcx
add    $0xffffffffffffffff,%rdx
jne    1770 <invAXinvA+0x5f0>
mov    0x88(%rsp),%rcx
mov    0x90(%rsp),%rdx
cmp    %rdx,0x78(%rsp)
mov    0x10(%rsp),%rdx
je     1550 <invAXinvA+0x3d0>
nop
mov    %edx,%esi
sub    %ecx,%esi
mov    %rdx,%rdi
mov    %rcx,%rdx
not    %rdx
add    %rdi,%rdx
and    $0x3,%rsi
je     17f6 <invAXinvA+0x676>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    17e0 <invAXinvA+0x660>
cmp    $0x3,%rdx
mov    0x10(%rsp),%rdx
jb     1550 <invAXinvA+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1810 <invAXinvA+0x690>
jmp    1550 <invAXinvA+0x3d0>
cmpl   $0x0,0x20(%rsp)
jle    1911 <invAXinvA+0x791>
mov    $0x1,%esi
xor    %eax,%eax
movsd  0x795(%rip),%xmm0
mov    %r12,%rcx
mov    0x20(%rsp),%r10
jmp    1898 <invAXinvA+0x718>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffffffffffff,%rdx
add    $0x1,%rax
add    $0x8,%rcx
mov    %r8,%rsi
cmp    %r9,%r8
je     1987 <invAXinvA+0x807>
mov    (%r12,%rsi,8),%rdi
movsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
lea    0x1(%rsi),%r8
cmp    %r9,%r8
je     1880 <invAXinvA+0x700>
lea    (%rdi,%rax,8),%rbp
mov    $0x2,%edi
mov    (%rcx,%rdi,8),%rbx
movsd  0x0(%rbp,%rdi,8),%xmm1
addsd  (%rbx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
movsd  %xmm1,0x0(%rbp,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    18c0 <invAXinvA+0x740>
jmp    1880 <invAXinvA+0x700>
lea    0xc(%rsp),%rax
mov    0x48(%rsp),%rdi
mov    %r15d,%esi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    %r13,%r8
mov    $0x1,%r9d
push   %rax
push   $0x0
call   1070 <ldl_dcmp@plt>
add    $0x10,%rsp
mov    0x58(%rsp),%rdi
mov    $0x1,%esi
mov    0x20(%rsp),%rbx
mov    %ebx,%edx
call   1090 <free_dvector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1090 <free_dvector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1090 <free_dvector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    $0x1,%ecx
mov    %ebx,%r8d
call   10a0 <free_dmatrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    $0x1,%ecx
mov    %ebx,%r8d
call   10a0 <free_dmatrix@plt>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r10d,%r10d
mov    0x10(%rsp),%r8
jle    1911 <invAXinvA+0x791>
add    $0xfffffffffffffffe,%r8
mov    %r11d,%eax
and    $0x3,%eax
mov    %r11d,%r10d
and    $0xfffffffc,%r10d
mov    $0x1,%edx
jmp    19c2 <invAXinvA+0x842>
nopl   0x0(%rax)
mov    %r15,%rdx
add    $0x1,%rdx
cmp    0x18(%rsp),%rdx
je     1ac1 <invAXinvA+0x941>
mov    (%r14,%rdx,8),%r9
mov    0x38(%rsp),%rcx
mov    %rdx,%r15
mov    (%rcx,%rdx,8),%rdi
mov    $0x1,%edx
jmp    19f1 <invAXinvA+0x871>
nopl   0x0(%rax)
movsd  %xmm1,(%r9,%rdx,8)
add    $0x1,%rdx
cmp    0x18(%rsp),%rdx
je     19b0 <invAXinvA+0x830>
xorpd  %xmm1,%xmm1
cmp    $0x3,%r8
jae    1a10 <invAXinvA+0x890>
mov    $0x1,%esi
test   %rax,%rax
jne    1a89 <invAXinvA+0x909>
jmp    19e0 <invAXinvA+0x860>
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rdi,%rsi,8),%xmm2
movsd  0x10(%rdi,%rsi,8),%xmm3
mov    0x8(%r12,%rsi,8),%rbp
mov    0x10(%r12,%rsi,8),%rbx
mulsd  0x0(%rbp,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rbx,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x18(%rdi,%rsi,8),%xmm2
mov    0x18(%r12,%rsi,8),%rbp
mulsd  0x0(%rbp,%rdx,8),%xmm2
movsd  0x20(%rdi,%rsi,8),%xmm1
mov    0x20(%r12,%rsi,8),%rbp
mulsd  0x0(%rbp,%rdx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1a20 <invAXinvA+0x8a0>
add    $0x1,%rsi
test   %rax,%rax
je     19e0 <invAXinvA+0x860>
lea    (%r12,%rsi,8),%rbp
lea    (%rdi,%rsi,8),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rbx,8),%xmm2
mov    0x0(%rbp,%rbx,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1aa0 <invAXinvA+0x920>
jmp    19e0 <invAXinvA+0x860>
cmpl   $0x0,0x20(%rsp)
jle    1911 <invAXinvA+0x791>
mov    %r8,%rdx
mov    %r11d,%eax
and    $0x3,%eax
and    $0xfffffffc,%r11d
mov    $0x1,%r10d
mov    0x20(%rsp),%r15
jmp    1b02 <invAXinvA+0x982>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x18(%rsp),%r9
cmp    %r9,%r10
je     1c01 <invAXinvA+0xa81>
mov    0x38(%rsp),%rcx
mov    (%rcx,%r10,8),%r9
mov    (%r12,%r10,8),%rsi
mov    $0x1,%edi
jmp    1b34 <invAXinvA+0x9b4>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm1,(%r9,%rdi,8)
add    $0x1,%rdi
cmp    0x18(%rsp),%rdi
mov    %r8,%rdx
je     1af0 <invAXinvA+0x970>
xorpd  %xmm1,%xmm1
cmp    $0x3,%rdx
jae    1b50 <invAXinvA+0x9d0>
mov    $0x1,%ecx
test   %rax,%rax
jne    1bc9 <invAXinvA+0xa49>
jmp    1b20 <invAXinvA+0x9a0>
xchg   %ax,%ax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rsi,%rcx,8),%xmm2
movsd  0x10(%rsi,%rcx,8),%xmm3
mov    0x8(%r14,%rcx,8),%rbp
mov    0x10(%r14,%rcx,8),%rbx
mulsd  0x0(%rbp,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rbx,%rdi,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x18(%rsi,%rcx,8),%xmm2
mov    0x18(%r14,%rcx,8),%rbp
mulsd  0x0(%rbp,%rdi,8),%xmm2
movsd  0x20(%rsi,%rcx,8),%xmm1
mov    0x20(%r14,%rcx,8),%rbp
mulsd  0x0(%rbp,%rdi,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1b60 <invAXinvA+0x9e0>
add    $0x1,%rcx
test   %rax,%rax
je     1b20 <invAXinvA+0x9a0>
lea    (%r14,%rcx,8),%rbp
lea    (%rsi,%rcx,8),%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rbx,8),%xmm2
mov    0x0(%rbp,%rbx,8),%rdx
mulsd  (%rdx,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1be0 <invAXinvA+0xa60>
jmp    1b20 <invAXinvA+0x9a0>
test   %r15d,%r15d
jle    1911 <invAXinvA+0x791>
mov    $0x1,%esi
xor    %eax,%eax
mov    0x38(%rsp),%rcx
mov    %r9,%rdx
jmp    1c38 <invAXinvA+0xab8>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdx
add    $0x1,%rax
add    $0x8,%rcx
mov    %r8,%rsi
cmp    %r9,%r8
je     1911 <invAXinvA+0x791>
mov    0x38(%rsp),%rdi
mov    (%rdi,%rsi,8),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
lea    0x1(%rsi),%r8
cmp    %r9,%r8
je     1c20 <invAXinvA+0xaa0>
lea    0x0(%rbp,%rax,8),%rbp
mov    $0x2,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rbx,8),%rdi
movsd  0x0(%rbp,%rbx,8),%xmm1
addsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1c70 <invAXinvA+0xaf0>
jmp    1c20 <invAXinvA+0xaa0>

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

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