#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 */
unsigned int cholesky(double *, double *, unsigned int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ inv_chol(double *, double *, unsigned int);
scalar_t__ malloc(unsigned int);
int /*<<< orphan*/ matrix_matrix_transpose_self_product(double *, double *,
                                                        unsigned int,
                                                        unsigned int);
int /*<<< orphan*/ matrix_transpose_matrix_self_product(double *, double *,
                                                        unsigned int,
                                                        unsigned int);
int /*<<< orphan*/ matrix_transpose_matrix_self_product_in_out_stride(
    double *, double *, unsigned int, unsigned int, unsigned int, unsigned int);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, unsigned int);
void geninv(double *G, unsigned int m1, unsigned int n1, double *Y,
            unsigned int size[2]) {
  unsigned int i, j, k;
  char tp;
  unsigned int n = (((m1) < (n1)) ? (m1) : (n1));
  double *A = (double *)malloc(n * n * sizeof(double));
  if (m1 < n1) {
    tp = 1;
    matrix_matrix_transpose_self_product(G, A, m1, n1);
  } else {
    tp = 0;
    matrix_transpose_matrix_self_product(G, A, m1, n1);
  }
  double *L = (double *)malloc(n * n * sizeof(double));
  memset(L, 0, n * n * sizeof(double));
  unsigned int r = cholesky(A, L, n);
  double *Ltmp = (double *)malloc(r * r * sizeof(double));
  matrix_transpose_matrix_self_product_in_out_stride(L, Ltmp, n, r, n, r);
  double *L2 = (double *)malloc(r * r * sizeof(double));
  memset(L2, 0, r * r * sizeof(double));
  cholesky(Ltmp, L2, r);
  double *M = (double *)malloc(r * r * sizeof(double));
  inv_chol(L2, M, r);
  double *tmpRes1 = (double *)malloc(r * sizeof(double));
  double *tmpRes2 = (double *)malloc(r * sizeof(double));
  double *tmpRes3;
  double *tmpRes4 = (double *)malloc(n1 * m1 * sizeof(double));
  if (tp) {
    tmpRes3 = (double *)malloc(r * sizeof(double));
    for (i = 0; i < n1; ++i) {
      for (j = 0; j < r; ++j) {
        double res = 0.0;
        for (k = 0; k < m1; ++k)
          res += G[k * n1 + i] * L[k * n + j];
        tmpRes1[j] = res;
      }
      for (j = 0; j < r; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += tmpRes1[k] * M[k * r + j];
        tmpRes2[j] = res;
      }
      for (j = 0; j < r; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += tmpRes2[k] * M[k * r + j];
        tmpRes3[j] = res;
      }
      for (j = 0; j < m1; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += tmpRes3[k] * L[j * n + k];
        Y[i * m1 + j] = res;
      }
    }
  } else {
    tmpRes3 = (double *)malloc(n1 * sizeof(double));
    for (i = 0; i < n1; ++i) {
      for (j = 0; j < r; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += L[i * n + k] * M[k * r + j];
        tmpRes1[j] = res;
      }
      for (j = 0; j < r; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += tmpRes1[k] * M[k * r + j];
        tmpRes2[j] = res;
      }
      for (j = 0; j < n1; ++j) {
        double res = 0.0;
        for (k = 0; k < r; ++k)
          res += tmpRes2[k] * L[j * n1 + k];
        tmpRes3[j] = res;
      }
      for (j = 0; j < m1; ++j) {
        double res = 0.0;
        for (k = 0; k < n1; ++k)
          res += tmpRes3[k] * G[j * n1 + k];
        Y[i * m1 + j] = res;
      }
    }
  }
  size[0] = n1;
  size[1] = m1;
  free(A);
  free(L);
  free(Ltmp);
  free(L2);
  free(M);
  free(tmpRes1);
  free(tmpRes2);
  free(tmpRes3);
  free(tmpRes4);
}


x86 assembly (clang, -O0):
<geninv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    11b7 <geninv+0x37>
mov    -0xc(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    11c0 <geninv+0x40>
mov    -0x10(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    1209 <geninv+0x89>
movb   $0x1,-0x2d(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1070 <matrix_matrix_transpose_self_product@plt>
jmp    1220 <geninv+0xa0>
movb   $0x0,-0x2d(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1050 <matrix_transpose_matrix_self_product@plt>
mov    -0x34(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x34(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1090 <cholesky@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    -0x4c(%rbp),%ecx
mov    -0x34(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
call   1060 <matrix_transpose_matrix_self_product_in_out_stride@plt>
mov    -0x4c(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x4c(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1090 <cholesky@plt>
mov    -0x4c(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1040 <inv_chol@plt>
mov    -0x4c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmpb   $0x0,-0x2d(%rbp)
je     1602 <geninv+0x482>
mov    -0x4c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    15fd <geninv+0x47d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1413 <geninv+0x293>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    13f1 <geninv+0x271>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1395 <geninv+0x215>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1377 <geninv+0x1f7>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    14ad <geninv+0x32d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    148b <geninv+0x30b>
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1438 <geninv+0x2b8>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    141a <geninv+0x29a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1547 <geninv+0x3c7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1525 <geninv+0x3a5>
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d2 <geninv+0x352>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14b4 <geninv+0x334>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    15ea <geninv+0x46a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    15bf <geninv+0x43f>
mov    -0x80(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    156c <geninv+0x3ec>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    154e <geninv+0x3ce>
jmp    15ef <geninv+0x46f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1364 <geninv+0x1e4>
jmp    18b9 <geninv+0x739>
mov    -0x10(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    18b4 <geninv+0x734>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    16ca <geninv+0x54a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    16a8 <geninv+0x528>
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164c <geninv+0x4cc>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    162e <geninv+0x4ae>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1764 <geninv+0x5e4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1742 <geninv+0x5c2>
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16ef <geninv+0x56f>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16d1 <geninv+0x551>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    17fe <geninv+0x67e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    17dc <geninv+0x65c>
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1789 <geninv+0x609>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176b <geninv+0x5eb>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    18a1 <geninv+0x721>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    1876 <geninv+0x6f6>
mov    -0x80(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1823 <geninv+0x6a3>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1805 <geninv+0x685>
jmp    18a6 <geninv+0x726>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    161b <geninv+0x49b>
jmp    18b9 <geninv+0x739>
mov    -0x10(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<geninv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r8,0xb0(%rsp)
mov    %rcx,0x88(%rsp)
mov    %edx,%r15d
mov    %esi,%r14d
mov    %rdi,%rbp
cmp    %edx,%esi
mov    %edx,%eax
cmovb  %esi,%eax
mov    %rax,0x38(%rsp)
mov    %eax,%ebx
imul   %eax,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   10a0 <malloc@plt>
mov    %r14d,%edx
mov    %rax,%r14
cmp    %r15d,%edx
mov    %edx,0x4(%rsp)
mov    %r15,0x28(%rsp)
mov    %rbp,%rdi
mov    %rax,%rsi
mov    %r15d,%ecx
jae    11e9 <geninv+0x69>
call   1070 <matrix_matrix_transpose_self_product@plt>
jmp    11ee <geninv+0x6e>
call   1050 <matrix_transpose_matrix_self_product@plt>
mov    %ebx,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1080 <memset@plt>
mov    %r14,0xa8(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
mov    0x38(%rsp),%r14
mov    %r14d,%edx
call   1090 <cholesky@plt>
mov    %eax,%ebx
lea    0x0(,%rbx,8),%r13d
mov    %r13d,0x10(%rsp)
imul   %eax,%r13d
mov    %r13d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r12
mov    %r15,%rdi
mov    %rax,%rsi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %r14d,%r8d
mov    %ebx,%r9d
call   1060 <matrix_transpose_matrix_self_product_in_out_stride@plt>
mov    %r13d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   1080 <memset@plt>
mov    %r12,0xa0(%rsp)
mov    %r12,%rdi
mov    %r14,%rsi
mov    %rbx,0x8(%rsp)
mov    %ebx,%edx
call   1090 <cholesky@plt>
mov    %r13d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r13
mov    %r14,0x98(%rsp)
mov    %r14,%rdi
mov    %rax,%rsi
mov    %ebx,%edx
call   1040 <inv_chol@plt>
mov    0x10(%rsp),%r14d
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r12
mov    0x4(%rsp),%edi
mov    0x28(%rsp),%r14
imul   %r14d,%edi
shl    $0x3,%edi
call   10a0 <malloc@plt>
mov    %rax,0x90(%rsp)
cmp    %r14d,0x4(%rsp)
mov    %rbx,0x60(%rsp)
jae    1750 <geninv+0x5d0>
mov    0x10(%rsp),%edi
call   10a0 <malloc@plt>
mov    0x28(%rsp),%r9
mov    %rax,%r14
mov    0x8(%rsp),%rsi
mov    %esi,%eax
mov    0x4(%rsp),%edi
mov    %edi,%ecx
lea    -0x1(%rax),%rdx
mov    %rdx,0x20(%rsp)
mov    %rcx,0x48(%rsp)
and    $0xfffffffe,%ecx
mov    %rcx,0x50(%rsp)
mov    %eax,%r10d
and    $0xfffffffe,%r10d
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x58(%rsp)
lea    (%r9,%r9,1),%r8d
mov    0x38(%rsp),%rbx
lea    (%rbx,%rbx,1),%ecx
mov    %ecx,0x68(%rsp)
lea    (%rsi,%rsi,1),%r11d
mov    %rax,0x40(%rsp)
mov    %eax,%esi
and    $0xfffffffc,%esi
neg    %rsi
mov    %r10,0x78(%rsp)
mov    %r11d,0x70(%rsp)
mov    %rsi,0x10(%rsp)
mov    %r8d,0x30(%rsp)
jmp    1399 <geninv+0x219>
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    0x28(%rsp),%r9
mov    %rax,0x18(%rsp)
cmp    %r9d,%eax
mov    0x4(%rsp),%ecx
mov    0x38(%rsp),%rbx
mov    0x30(%rsp),%r8d
je     1c20 <geninv+0xaa0>
cmpl   $0x0,0x8(%rsp)
je     1630 <geninv+0x4b0>
xor    %eax,%eax
mov    0x4(%rsp),%edx
jmp    13c9 <geninv+0x249>
nopl   0x0(%rax)
mov    0x60(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    0x40(%rsp),%rax
je     1490 <geninv+0x310>
xorpd  %xmm0,%xmm0
test   %edx,%edx
je     13b0 <geninv+0x230>
cmp    $0x1,%edx
jne    13e0 <geninv+0x260>
xor    %ecx,%ecx
mov    %r8d,%r10d
jmp    143a <geninv+0x2ba>
nopl   (%rax)
mov    %eax,%edx
mov    0x18(%rsp),%rdi
xor    %ecx,%ecx
mov    %r8d,%r10d
mov    0x50(%rsp),%r8
mov    0x68(%rsp),%r11d
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%esi
movsd  0x0(%rbp,%rsi,8),%xmm1
mov    %edx,%esi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
lea    (%r9,%rdi,1),%esi
movsd  0x0(%rbp,%rsi,8),%xmm0
lea    (%rbx,%rdx,1),%esi
mulsd  (%r15,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rcx
add    %r10d,%edi
add    %r11d,%edx
cmp    %rcx,%r8
jne    1400 <geninv+0x280>
testb  $0x1,0x48(%rsp)
mov    %r10d,%r8d
mov    0x78(%rsp),%r10
mov    0x70(%rsp),%r11d
mov    0x10(%rsp),%rsi
mov    0x4(%rsp),%edx
je     13b0 <geninv+0x230>
mov    %ebx,%edx
imul   %ecx,%edx
imul   %r9d,%ecx
add    0x18(%rsp),%ecx
movsd  0x0(%rbp,%rcx,8),%xmm1
add    %eax,%edx
mulsd  (%r15,%rdx,8),%xmm1
mov    0x4(%rsp),%edx
addsd  %xmm1,%xmm0
jmp    13b0 <geninv+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,0x8(%rsp)
je     1630 <geninv+0x4b0>
xor    %edx,%edx
mov    0x8(%rsp),%rdi
mov    0x60(%rsp),%rbx
mov    0x40(%rsp),%r9
jmp    14c3 <geninv+0x343>
xchg   %ax,%ax
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%rdx
cmp    %r9,%rdx
je     1550 <geninv+0x3d0>
cmpq   $0x0,0x20(%rsp)
je     1520 <geninv+0x3a0>
xorpd  %xmm1,%xmm1
mov    %edx,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%esi
movsd  (%rbx,%rcx,8),%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm0
mulsd  0x0(%r13,%rsi,8),%xmm2
addsd  %xmm1,%xmm2
lea    (%rdi,%rax,1),%esi
mulsd  0x0(%r13,%rsi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rcx
add    %r11d,%eax
movapd %xmm0,%xmm1
cmp    %rcx,%r10
jne    14e0 <geninv+0x360>
test   $0x1,%r9b
je     14b0 <geninv+0x330>
jmp    152c <geninv+0x3ac>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
test   $0x1,%r9b
je     14b0 <geninv+0x330>
movsd  (%rbx,%rcx,8),%xmm1
imul   %edi,%ecx
add    %edx,%ecx
mulsd  0x0(%r13,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    14b0 <geninv+0x330>
cs nopw 0x0(%rax,%rax,1)
test   %edi,%edi
mov    0x10(%rsp),%rsi
je     1630 <geninv+0x4b0>
xor    %edx,%edx
jmp    1588 <geninv+0x408>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%r14,%rdx,8)
add    $0x1,%rdx
cmp    %rbx,%rdx
mov    0x10(%rsp),%rsi
je     1630 <geninv+0x4b0>
cmpq   $0x0,0x20(%rsp)
je     15f0 <geninv+0x470>
xorpd  %xmm1,%xmm1
mov    %edx,%eax
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    0x40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,%esi
movsd  (%r12,%rcx,8),%xmm2
movsd  0x8(%r12,%rcx,8),%xmm0
mulsd  0x0(%r13,%rsi,8),%xmm2
addsd  %xmm1,%xmm2
lea    (%rdi,%rax,1),%esi
mulsd  0x0(%r13,%rsi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rcx
add    %r11d,%eax
movapd %xmm0,%xmm1
cmp    %rcx,%r10
jne    15b0 <geninv+0x430>
test   $0x1,%bl
je     1570 <geninv+0x3f0>
jmp    1609 <geninv+0x489>
nop
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    0x40(%rsp),%rbx
test   $0x1,%bl
je     1570 <geninv+0x3f0>
movsd  (%r12,%rcx,8),%xmm1
imul   %edi,%ecx
add    %edx,%ecx
mulsd  0x0(%r13,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1570 <geninv+0x3f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x4(%rsp)
je     1370 <geninv+0x1f0>
mov    0x18(%rsp),%rax
mov    %eax,%ebx
imul   0x4(%rsp),%ebx
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    167e <geninv+0x4fe>
nop
xorpd  %xmm0,%xmm0
lea    (%rbx,%r9,1),%eax
mov    0x88(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%r9
add    0x38(%rsp),%r8d
cmp    0x48(%rsp),%r9
mov    0x10(%rsp),%rsi
je     1370 <geninv+0x1f0>
cmpl   $0x0,0x8(%rsp)
je     1650 <geninv+0x4d0>
cmpq   $0x3,0x20(%rsp)
jae    16a0 <geninv+0x520>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    1717 <geninv+0x597>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    $0x3,%edx
mov    %r8d,%ecx
nopl   0x0(%rax)
mov    %ecx,%eax
movsd  -0x18(%r14,%rdx,8),%xmm1
mulsd  (%r15,%rax,8),%xmm1
movsd  -0x10(%r14,%rdx,8),%xmm2
lea    0x1(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm2
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
movsd  -0x8(%r14,%rdx,8),%xmm1
lea    0x2(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%r14,%rdx,8),%xmm0
lea    0x3(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%ecx
lea    (%rsi,%rdx,1),%rax
add    $0x4,%rax
add    $0x4,%rdx
cmp    $0x3,%rax
jne    16b0 <geninv+0x530>
add    $0xfffffffffffffffd,%rdx
mov    0x58(%rsp),%rdi
test   %rdi,%rdi
je     1654 <geninv+0x4d4>
lea    (%r8,%rdx,1),%eax
lea    (%r14,%rdx,8),%rcx
xor    %edx,%edx
nop
movsd  (%rcx,%rdx,8),%xmm1
lea    (%rax,%rdx,1),%esi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1730 <geninv+0x5b0>
jmp    1654 <geninv+0x4d4>
lea    0x0(,%r14,8),%edi
call   10a0 <malloc@plt>
mov    0x28(%rsp),%r9
mov    %rax,%r14
test   %r9d,%r9d
je     1c27 <geninv+0xaa7>
mov    0x8(%rsp),%rax
mov    %eax,%edi
mov    %r9d,%ecx
mov    0x4(%rsp),%edx
mov    %rdx,0x70(%rsp)
lea    -0x1(%rdi),%rdx
mov    %rdx,0x48(%rsp)
lea    -0x1(%rcx),%rdx
mov    %rdx,0x58(%rsp)
mov    %edi,%r8d
and    $0xfffffffe,%r8d
mov    %edi,%esi
and    $0x3,%esi
mov    %ecx,%edx
and    $0x3,%edx
mov    %rdx,0x50(%rsp)
lea    (%rax,%rax,1),%r10d
mov    %rdi,0x18(%rsp)
mov    %edi,%edx
and    $0xfffffffc,%edx
neg    %rdx
mov    %rcx,0x40(%rsp)
and    $0xfffffffc,%ecx
neg    %rcx
mov    %rcx,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0x1,%r11d
mov    0x38(%rsp),%rax
mov    %rdx,0x20(%rsp)
mov    %rsi,0x10(%rsp)
jmp    181b <geninv+0x69b>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rcx
add    $0x1,%ecx
mov    0x38(%rsp),%rax
mov    0x84(%rsp),%r11d
add    %eax,%r11d
mov    0x28(%rsp),%r9
mov    %rcx,0x30(%rsp)
cmp    %r9d,%ecx
je     1c27 <geninv+0xaa7>
cmpl   $0x0,0x8(%rsp)
je     19c0 <geninv+0x840>
mov    0x30(%rsp),%r9
imul   %eax,%r9d
xor    %edi,%edi
jmp    185c <geninv+0x6dc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x60(%rsp),%rbx
movsd  %xmm0,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rcx,%rdi
mov    0x20(%rsp),%rdx
je     1900 <geninv+0x780>
cmpq   $0x0,0x48(%rsp)
je     18c0 <geninv+0x740>
xorpd  %xmm0,%xmm0
mov    %edi,%ecx
mov    %r11d,%eax
xor    %edx,%edx
mov    0x8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rax),%esi
movsd  (%r15,%rsi,8),%xmm1
mov    %ecx,%esi
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
mov    %eax,%esi
movsd  (%r15,%rsi,8),%xmm0
lea    (%rbx,%rcx,1),%esi
mulsd  0x0(%r13,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdx
add    $0x2,%eax
add    %r10d,%ecx
cmp    %rdx,%r8
jne    1880 <geninv+0x700>
jmp    18c6 <geninv+0x746>
nopl   (%rax)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x18(%rsp),%rcx
test   $0x1,%cl
je     1840 <geninv+0x6c0>
lea    (%r9,%rdx,1),%eax
movsd  (%r15,%rax,8),%xmm1
imul   0x8(%rsp),%edx
add    %edi,%edx
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1840 <geninv+0x6c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rsi
test   %esi,%esi
mov    0x18(%rsp),%r9
je     19c0 <geninv+0x840>
xor    %edi,%edi
jmp    1938 <geninv+0x7b8>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,(%r12,%rdi,8)
add    $0x1,%rdi
cmp    %r9,%rdi
mov    0x20(%rsp),%rdx
je     19c0 <geninv+0x840>
cmpq   $0x0,0x48(%rsp)
je     1990 <geninv+0x810>
xorpd  %xmm1,%xmm1
mov    %edi,%eax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
movsd  (%rbx,%rdx,8),%xmm2
movsd  0x8(%rbx,%rdx,8),%xmm0
mulsd  0x0(%r13,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
lea    (%rsi,%rax,1),%ecx
mulsd  0x0(%r13,%rcx,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    %r10d,%eax
movapd %xmm0,%xmm1
cmp    %rdx,%r8
jne    1950 <geninv+0x7d0>
test   $0x1,%r9b
je     1920 <geninv+0x7a0>
jmp    199c <geninv+0x81c>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xor    %edx,%edx
test   $0x1,%r9b
je     1920 <geninv+0x7a0>
movsd  (%rbx,%rdx,8),%xmm1
imul   %esi,%edx
add    %edi,%edx
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1920 <geninv+0x7a0>
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,0x84(%rsp)
xor    %r9d,%r9d
xor    %edi,%edi
mov    0x10(%rsp),%rsi
jmp    1a03 <geninv+0x883>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
add    0x28(%rsp),%r9d
cmp    0x40(%rsp),%rdi
mov    0x20(%rsp),%rdx
je     1af0 <geninv+0x970>
cmpl   $0x0,0x8(%rsp)
je     19e0 <geninv+0x860>
cmpq   $0x3,0x48(%rsp)
jae    1a30 <geninv+0x8b0>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
test   %rsi,%rsi
jne    1ab0 <geninv+0x930>
jmp    19e4 <geninv+0x864>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm0
mov    %rdx,%r11
mov    $0x3,%edx
mov    %r9d,%ecx
nop
mov    %ecx,%eax
movsd  -0x18(%r12,%rdx,8),%xmm1
mulsd  (%r15,%rax,8),%xmm1
movsd  -0x10(%r12,%rdx,8),%xmm2
lea    0x1(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm2
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
movsd  -0x8(%r12,%rdx,8),%xmm1
lea    0x2(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%r12,%rdx,8),%xmm0
lea    0x3(%rcx),%eax
mulsd  (%r15,%rax,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%ecx
lea    (%r11,%rdx,1),%rax
add    $0x4,%rax
add    $0x4,%rdx
cmp    $0x3,%rax
jne    1a40 <geninv+0x8c0>
add    $0xfffffffffffffffd,%rdx
test   %rsi,%rsi
je     19e4 <geninv+0x864>
lea    (%r9,%rdx,1),%eax
lea    (%r12,%rdx,8),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm1
lea    (%rax,%rdx,1),%esi
mulsd  (%r15,%rsi,8),%xmm1
mov    0x10(%rsp),%rsi
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1ac0 <geninv+0x940>
jmp    19e4 <geninv+0x864>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x4(%rsp)
je     17f0 <geninv+0x670>
mov    0x30(%rsp),%rax
imul   0x4(%rsp),%eax
mov    %rax,0x78(%rsp)
xor    %r11d,%r11d
xor    %edi,%edi
jmp    1b4d <geninv+0x9cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rax
add    %edi,%eax
mov    0x88(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rdi
add    0x28(%rsp),%r11d
cmp    0x70(%rsp),%rdi
mov    0x20(%rsp),%rdx
je     17f0 <geninv+0x670>
cmpq   $0x3,0x58(%rsp)
jae    1b60 <geninv+0x9e0>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    1be7 <geninv+0xa67>
xorpd  %xmm0,%xmm0
mov    $0x3,%edx
mov    %r11d,%ecx
mov    0x68(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
movsd  -0x18(%r14,%rdx,8),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
movsd  -0x10(%r14,%rdx,8),%xmm2
lea    0x1(%rcx),%eax
mulsd  0x0(%rbp,%rax,8),%xmm2
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
movsd  -0x8(%r14,%rdx,8),%xmm1
lea    0x2(%rcx),%eax
mulsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%r14,%rdx,8),%xmm0
lea    0x3(%rcx),%eax
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%ecx
lea    (%rsi,%rdx,1),%rax
add    $0x4,%rax
add    $0x4,%rdx
cmp    $0x3,%rax
jne    1b80 <geninv+0xa00>
add    $0xfffffffffffffffd,%rdx
mov    0x50(%rsp),%r9
test   %r9,%r9
je     1b20 <geninv+0x9a0>
lea    (%r11,%rdx,1),%eax
lea    (%r14,%rdx,8),%rcx
xor    %edx,%edx
nop
movsd  (%rcx,%rdx,8),%xmm1
lea    (%rax,%rdx,1),%esi
mulsd  0x0(%rbp,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r9
jne    1c00 <geninv+0xa80>
jmp    1b20 <geninv+0x9a0>
mov    0x60(%rsp),%rbx
jmp    1c2b <geninv+0xaab>
mov    0x4(%rsp),%ecx
mov    0xb0(%rsp),%rax
mov    %r9d,(%rax)
mov    %ecx,0x4(%rax)
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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