#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ ichol(double *, int);
double l2norm(double *, int);
int /*<<< orphan*/ linsolve_lower(double *, int, double *, double *);
int /*<<< orphan*/ madd(double *, double *, double *, int, int);
scalar_t__ malloc(int);
int /*<<< orphan*/ mdisplay(double *, int, int);
int /*<<< orphan*/ mmult(double *, double *, double *, int, int, int);
int /*<<< orphan*/ msub(double *, double *, double *, int, int);
int /*<<< orphan*/ mtranspose(double *, int, int, double *);
double pow(double, double);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scale(double *, int, int, double);
double sqrt(double);
int cgpc(double *xi, int N, double *A, double *b, double *xf) {
  int i, j, t, rcode;
  int iter, siter;
  double *temp, *rk, *pk, *dx, *jac, *apk, *U, *y, *AB;
  double stol, gtol, bn;
  temp = (double *)malloc(sizeof(double) * 8);
  rk = (double *)malloc(sizeof(double) * N);
  pk = (double *)malloc(sizeof(double) * N);
  apk = (double *)malloc(sizeof(double) * N);
  dx = (double *)malloc(sizeof(double) * N);
  jac = (double *)malloc(sizeof(double) * N);
  U = (double *)malloc(sizeof(double) * N * N);
  AB = (double *)malloc(sizeof(double) * N * N);
  y = (double *)malloc(sizeof(double) * N);
  iter = 0;
  rcode = 0;
  siter = (int)1000;
  gtol = pow((double)1e-15, 1.0 / 3.0);
  stol = gtol * gtol;
  mmult(A, xi, rk, N, N, 1);
  msub(rk, b, rk, N, 1);
  for (i = 0; i < N; ++i) {
    t = i * N;
    for (j = 0; j < N; ++j) {
      AB[t + j] = A[t + j];
    }
  }
  ichol(AB, N);
  mdisplay(AB, N, N);
  mtranspose(AB, N, N, U);
  linsolve_lower(U, N, rk, y);
  for (i = 0; i < N; ++i) {
    pk[i] = -y[i];
    xf[i] = xi[i];
  }
  bn = l2norm(b, N);
  while (rcode == 0 && iter < siter) {
    iter++;
    mmult(rk, y, temp, 1, N, 1);
    mmult(A, pk, apk, N, N, 1);
    mmult(pk, apk, temp + 1, 1, N, 1);
    temp[2] = temp[0] / temp[1];
    for (i = 0; i < N; ++i) {
      xf[i] = xi[i] + temp[2] * pk[i];
      apk[i] *= temp[2];
    }
    madd(rk, apk, rk, 1, N);
    linsolve_lower(U, N, rk, y);
    mmult(rk, y, temp + 3, 1, N, 1);
    if (sqrt(temp[3]) <= stol * bn) {
      rcode = 1;
    }
    temp[4] = temp[3] / temp[0];
    scale(pk, N, 1, temp[4]);
    mdisplay(xf, 1, N);
    msub(pk, y, pk, N, 1);
    printf("%d \n", iter);
    for (i = 0; i < N; ++i) {
      xi[i] = xf[i];
    }
  }
  free(temp);
  free(rk);
  free(pk);
  free(dx);
  free(jac);
  free(apk);
  free(U);
  free(y);
  free(AB);
  return rcode;
}


x86 assembly (clang, -O0):
<cgpc>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    $0x40,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x3e8,-0x40(%rbp)
movsd  0xd2c(%rip),%xmm0
movsd  0xd2c(%rip),%xmm1
call   10f0 <pow@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    -0x50(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    $0x1,%r8d
call   1060 <msub@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13b1 <cgpc+0x1d1>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    139e <cgpc+0x1be>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    135d <cgpc+0x17d>
jmp    13a3 <cgpc+0x1c3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1340 <cgpc+0x160>
mov    -0x88(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   10a0 <ichol@plt>
mov    -0x88(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0xc(%rbp),%edx
call   1080 <mdisplay@plt>
mov    -0x88(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x78(%rbp),%rcx
call   10b0 <mtranspose@plt>
mov    -0x78(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x80(%rbp),%rcx
call   1090 <linsolve_lower@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1468 <cgpc+0x288>
mov    -0x80(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1403 <cgpc+0x223>
mov    -0x20(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1040 <l2norm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0xa1(%rbp)
jne    149d <cgpc+0x2bd>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
setl   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    14b0 <cgpc+0x2d0>
jmp    16d5 <cgpc+0x4f5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
mov    %r9d,%ecx
call   1050 <mmult@plt>
mov    -0x18(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    -0x58(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x8,%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
mov    %r9d,%ecx
call   1050 <mmult@plt>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
divsd  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a5 <cgpc+0x3c5>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1538 <cgpc+0x358>
mov    -0x50(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%ecx
call   10e0 <madd@plt>
mov    -0x78(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x80(%rbp),%rcx
call   1090 <linsolve_lower@plt>
mov    -0x50(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x18,%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
mov    %r9d,%ecx
call   1050 <mmult@plt>
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
call   1100 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1627 <cgpc+0x447>
movl   $0x1,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x48(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x48(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    $0x1,%edx
call   10d0 <scale@plt>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1080 <mdisplay@plt>
mov    -0x58(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    $0x1,%r8d
call   1060 <msub@plt>
mov    -0x3c(%rbp),%esi
lea    0x980(%rip),%rdi
call   1070 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16d0 <cgpc+0x4f0>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    169c <cgpc+0x4bc>
jmp    147c <cgpc+0x29c>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%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>
mov    -0x38(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r8,%rbx
mov    %rcx,0x28(%rsp)
mov    %rdx,%rbp
mov    %esi,%r15d
mov    %r15,(%rsp)
mov    %rdi,%r14
mov    $0x40,%edi
call   10c0 <malloc@plt>
mov    %rax,0x60(%rsp)
lea    0x0(,%r15,8),%r12d
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,%r15
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    %r12d,%r13d
imul   (%rsp),%r13d
mov    %r13d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %r13d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x68(%rsp)
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbp,%rdi
mov    %r14,%rsi
mov    0x58(%rsp),%r12
mov    %r12,%rdx
mov    (%rsp),%r13
mov    %r13d,%ecx
mov    %r13d,%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    %r12,%rdi
mov    0x28(%rsp),%rsi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    $0x1,%r8d
call   1060 <msub@plt>
mov    %r13,%rsi
mov    0x68(%rsp),%r13
mov    %esi,%r9d
test   %esi,%esi
mov    %rbp,0xa0(%rsp)
mov    %r9,0x8(%rsp)
mov    %r15,0x30(%rsp)
jle    1684 <cgpc+0x4b4>
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
mov    %rax,0x70(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rax
mov    %rax,0x48(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x38(%rsp)
lea    0x70(%r13),%rdi
lea    0x0(,%r9,8),%rax
mov    %rax,0x40(%rsp)
lea    0x70(%rbp),%rcx
lea    0x10(%r13),%rax
lea    0x10(%rbp),%rdx
mov    %rdx,0x20(%rsp)
mov    %r8,0x90(%rsp)
shl    $0x5,%r8
mov    %r8,0x78(%rsp)
xor    %r12d,%r12d
mov    %rbp,%r8
mov    %r13,%r10
mov    0x80(%rsp),%r13
jmp    13aa <cgpc+0x1da>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x40(%rsp),%rdx
add    %rdx,%rdi
add    %rdx,%rcx
add    %rdx,%rax
add    %rdx,0x20(%rsp)
add    %rdx,%r10
add    %rdx,%r8
cmp    %r9,%r12
mov    (%rsp),%rsi
je     1584 <cgpc+0x3b4>
cmp    $0x4,%esi
jae    13c0 <cgpc+0x1f0>
xor    %r11d,%r11d
jmp    1500 <cgpc+0x330>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdx
imul   %r9,%rdx
lea    (%rdx,%r9,1),%rsi
lea    0x0(,%rsi,8),%r11
add    %rbp,%r11
mov    0x68(%rsp),%r9
lea    (%r9,%rdx,8),%rbp
cmp    %r11,%rbp
mov    0xa0(%rsp),%rbp
jae    1410 <cgpc+0x240>
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
lea    (%r9,%rsi,8),%rsi
cmp    %rsi,%rdx
jae    1410 <cgpc+0x240>
xor    %r11d,%r11d
mov    0x8(%rsp),%r9
jmp    1500 <cgpc+0x330>
nopl   (%rax)
cmpq   $0xc,0x50(%rsp)
jae    1426 <cgpc+0x256>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x78(%rsp),%r11
jmp    149c <cgpc+0x2cc>
mov    0x48(%rsp),%rsi
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x78(%rsp),%r11
nopw   0x0(%rax,%rax,1)
movups -0x70(%rcx,%rdx,8),%xmm0
movups -0x60(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x70(%rdi,%rdx,8)
movups %xmm1,-0x60(%rdi,%rdx,8)
movups -0x50(%rcx,%rdx,8),%xmm0
movups -0x40(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x50(%rdi,%rdx,8)
movups %xmm1,-0x40(%rdi,%rdx,8)
movups -0x30(%rcx,%rdx,8),%xmm0
movups -0x20(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x30(%rdi,%rdx,8)
movups %xmm1,-0x20(%rdi,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd %xmm0,-0x10(%rdi,%rdx,8)
movupd %xmm1,(%rdi,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1440 <cgpc+0x270>
cmpq   $0x0,0x90(%rsp)
je     14df <cgpc+0x30f>
lea    (%rax,%rdx,8),%rsi
mov    0x20(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
nopl   (%rax)
movupd -0x10(%rdx,%rbp,1),%xmm0
movupd (%rdx,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    14c0 <cgpc+0x2f0>
mov    0x98(%rsp),%rdx
mov    %rdx,%r11
cmp    %r9,%rdx
mov    0xa0(%rsp),%rbp
je     1380 <cgpc+0x1b0>
nopl   0x0(%rax,%rax,1)
mov    %r11,%rdx
not    %rdx
add    %r9,%rdx
mov    0x38(%rsp),%rsi
test   %rsi,%rsi
je     1536 <cgpc+0x366>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r8,%r11,8),%xmm0
movsd  %xmm0,(%r10,%r11,8)
add    $0x1,%r11
add    $0xffffffffffffffff,%rsi
jne    1520 <cgpc+0x350>
cmp    $0x3,%rdx
jb     1380 <cgpc+0x1b0>
movsd  (%r8,%r11,8),%xmm0
movsd  %xmm0,-0x10(%rax,%r11,8)
movsd  0x8(%r8,%r11,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r11,8)
movsd  0x10(%r8,%r11,8),%xmm0
movsd  %xmm0,(%rax,%r11,8)
movsd  0x18(%r8,%r11,8),%xmm0
movsd  %xmm0,0x8(%rax,%r11,8)
add    $0x4,%r11
cmp    %r11,%r9
jne    1540 <cgpc+0x370>
jmp    1380 <cgpc+0x1b0>
mov    0x68(%rsp),%rbp
mov    %rbp,%rdi
call   10a0 <ichol@plt>
mov    %rbp,%rdi
mov    (%rsp),%rsi
mov    (%rsp),%rdx
call   1080 <mdisplay@plt>
mov    %rbp,%rdi
mov    (%rsp),%rsi
mov    (%rsp),%rdx
mov    0x88(%rsp),%r12
mov    %r12,%rcx
call   10b0 <mtranspose@plt>
mov    %r12,%rdi
mov    (%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x18(%rsp),%rcx
call   1090 <linsolve_lower@plt>
mov    0x8(%rsp),%rbp
mov    (%rsp),%rsi
test   %esi,%esi
jle    16d7 <cgpc+0x507>
cmp    $0x4,%esi
jae    1dce <cgpc+0xbfe>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1620 <cgpc+0x450>
mov    0x18(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
xorps  0x9f5(%rip),%xmm0
movlps %xmm0,0x0(%r13,%rax,8)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
mov    0x18(%rsp),%rcx
je     16d7 <cgpc+0x507>
movapd 0x9ca(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x0(%r13,%rax,8)
movsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%r13,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1640 <cgpc+0x470>
jmp    16d7 <cgpc+0x507>
mov    %r13,%rdi
call   10a0 <ichol@plt>
mov    %r13,%rdi
mov    (%rsp),%rsi
mov    (%rsp),%rdx
call   1080 <mdisplay@plt>
mov    %r13,%rdi
mov    (%rsp),%rsi
mov    (%rsp),%rdx
mov    0x88(%rsp),%rbp
mov    %rbp,%rcx
call   10b0 <mtranspose@plt>
mov    %rbp,%rdi
mov    (%rsp),%rsi
mov    %r12,%rdx
mov    0x18(%rsp),%rcx
call   1090 <linsolve_lower@plt>
mov    (%rsp),%rsi
mov    0x80(%rsp),%r13
mov    0x28(%rsp),%rdi
call   1040 <l2norm@plt>
mov    0x60(%rsp),%r8
lea    0x10(%r8),%r12
add    $0x18,%r8
mov    0x8(%rsp),%rax
lea    (%r14,%rax,8),%r10
mov    %r10,0x28(%rsp)
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,8),%r11
lea    0x8(%rbx),%rax
mov    0x8(%rsp),%rcx
lea    (%r15,%rcx,8),%rdx
mov    %rdx,0x40(%rsp)
mov    %r15,%rsi
add    $0x8,%rsi
lea    0x8(%r14),%rcx
mov    %rcx,0x38(%rsp)
mov    %r13,%rbp
add    $0x8,%rbp
mov    0x8(%rsp),%rcx
and    $0xfffffffc,%ecx
mov    %rcx,0x100(%rsp)
lea    -0x4(%rcx),%r9
mov    %r9,0xf8(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
cmp    %rdx,%rax
setb   %dl
cmp    %r11,%rsi
setb   %cl
and    %dl,%cl
cmp    %r8,%rax
setb   %dil
cmp    %r11,%r12
mov    %r11,0x20(%rsp)
setb   %dl
and    %dil,%dl
or     %cl,%dl
cmp    %r10,%rax
setb   %dil
mov    0x38(%rsp),%r10
cmp    %r11,%r10
setb   %cl
and    %dil,%cl
mov    0x8(%rsp),%rdi
lea    0x0(,%rdi,8),%rdi
add    %r13,%rdi
mov    %rdi,0x48(%rsp)
cmp    %rdi,%rax
setb   %dil
cmp    %r11,%rbp
setb   %al
and    %dil,%al
or     %cl,%al
or     %dl,%al
mov    %r8,0x98(%rsp)
cmp    %r8,%rsi
setb   %dil
mov    %r12,0x90(%rsp)
mov    0x40(%rsp),%rcx
cmp    %rcx,%r12
setb   %dl
and    %dil,%dl
mov    0x28(%rsp),%r12
cmp    %r12,%rsi
setb   %dil
cmp    %rcx,%r10
mov    %rcx,%r10
mov    0x60(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0x78(%rsp)
mulsd  0x80e(%rip),%xmm0
movsd  %xmm0,0x50(%rsp)
setb   %cl
and    %dil,%cl
or     %dl,%cl
mov    0x8(%rsp),%rdx
lea    -0x1(%rdx),%rdi
cmp    0x48(%rsp),%rsi
mov    (%rsp),%r8
setb   %r11b
cmp    %r10,%rbp
mov    0x8(%rsp),%rsi
setb   %dl
and    %r11b,%dl
or     %cl,%dl
or     %al,%dl
mov    %dl,0x17(%rsp)
mov    %rdi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xc8(%rsp)
mov    %rdi,0xa8(%rsp)
or     $0x1,%rdi
mov    %rdi,0xc0(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
cmp    %r14,0x20(%rsp)
seta   %al
cmp    %rbx,%r12
seta   %cl
and    %al,%cl
mov    %cl,0x70(%rsp)
mov    %r9d,%ecx
and    $0x3,%ecx
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%r9
mov    %r9,0xd0(%rsp)
mov    %esi,%r12d
and    $0x3,%r12d
lea    0x10(%r14),%rax
mov    %rax,0xe0(%rsp)
mov    %rcx,0xf0(%rsp)
mov    %rcx,%rdi
shl    $0x5,%rdi
lea    0x10(%rbx),%rax
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    0x18(%rsp),%rbp
mov    %r12,0x28(%rsp)
mov    %rdi,0x48(%rsp)
mov    0x58(%rsp),%rdi
mov    %rbp,%rsi
mov    0x60(%rsp),%rbp
mov    %rbp,%rdx
mov    $0x1,%ecx
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    0xa0(%rsp),%rdi
mov    %r13,%rsi
mov    %r15,%rdx
mov    (%rsp),%rcx
mov    (%rsp),%r8
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    0x78(%rsp),%rdx
mov    $0x1,%ecx
mov    (%rsp),%r8
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    0x8(%rsp),%rdx
mov    (%rsp),%r8
movsd  0x0(%rbp),%xmm0
divsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x10(%rbp)
test   %r8d,%r8d
mov    0x90(%rsp),%rsi
jle    1ab0 <cgpc+0x8e0>
mulsd  0x0(%r13),%xmm0
addsd  (%r14),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%rsi),%xmm0
mulsd  (%r15),%xmm0
movsd  %xmm0,(%r15)
cmp    $0x1,%r8d
je     1ab0 <cgpc+0x8e0>
cmpq   $0x2,0xa8(%rsp)
setb   %al
or     0x17(%rsp),%al
mov    $0x1,%ecx
test   $0x1,%al
jne    1a0d <cgpc+0x83d>
movsd  (%rsi),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
mov    0xc8(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r14,%rax,8),%xmm1
movupd 0x8(%r13,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rbx,%rax,8)
movupd 0x8(%r15,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    19c0 <cgpc+0x7f0>
mov    0xc0(%rsp),%rcx
cmp    %rdi,0xa8(%rsp)
je     1ab0 <cgpc+0x8e0>
mov    %rcx,%rax
test   $0x1,%dl
jne    1a3f <cgpc+0x86f>
movsd  (%rsi),%xmm0
mulsd  0x0(%r13,%rcx,8),%xmm0
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  (%rsi),%xmm0
mulsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0xe8(%rsp),%rcx
je     1ab0 <cgpc+0x8e0>
nopl   0x0(%rax)
movsd  (%rsi),%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rsi),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  (%rsi),%xmm0
mulsd  0x8(%r13,%rax,8),%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  (%rsi),%xmm0
mulsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1a50 <cgpc+0x880>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x40(%rsp)
mov    0x58(%rsp),%r13
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r13,%rdx
mov    $0x1,%ecx
mov    %r8,%r12
call   10e0 <madd@plt>
mov    0x88(%rsp),%rdi
mov    %r12d,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%r15
mov    %r15,%rcx
call   1090 <linsolve_lower@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    0x98(%rsp),%rbp
mov    %rbp,%rdx
mov    $0x1,%ecx
mov    %r12d,%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
movsd  0x0(%rbp),%xmm0
ucomisd 0x4f5(%rip),%xmm0
jb     1b30 <cgpc+0x960>
sqrtsd %xmm0,%xmm0
jmp    1b35 <cgpc+0x965>
nopl   0x0(%rax,%rax,1)
call   10f0 <sqrt@plt>
movsd  %xmm0,0x38(%rsp)
mov    (%rsp),%rsi
mov    0x80(%rsp),%r13
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r15
mov    0x28(%rsp),%r12
mov    0x60(%rsp),%rax
movsd  0x18(%rax),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,0x20(%rax)
mov    %r13,%rdi
mov    $0x1,%edx
call   10d0 <scale@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    (%rsp),%rdx
call   1080 <mdisplay@plt>
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    (%rsp),%rcx
mov    $0x1,%r8d
call   1060 <msub@plt>
lea    0x47a(%rip),%rdi
mov    0x40(%rsp),%esi
call   1070 <printf@plt>
mov    (%rsp),%r8
test   %r8d,%r8d
mov    0x8(%rsp),%rsi
mov    0x48(%rsp),%rdi
movsd  0x38(%rsp),%xmm2
jle    1d2b <cgpc+0xb5b>
cmp    $0x4,%r8d
setb   %al
or     0x70(%rsp),%al
je     1be0 <cgpc+0xa10>
xor    %eax,%eax
jmp    1cbf <cgpc+0xaef>
cmpq   $0xc,0xf8(%rsp)
jae    1bef <cgpc+0xa1f>
xor    %eax,%eax
jmp    1c64 <cgpc+0xa94>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movups %xmm0,0x20(%r14,%rax,8)
movups %xmm1,0x30(%r14,%rax,8)
movups 0x40(%rbx,%rax,8),%xmm0
movups 0x50(%rbx,%rax,8),%xmm1
movups %xmm0,0x40(%r14,%rax,8)
movups %xmm1,0x50(%r14,%rax,8)
movupd 0x60(%rbx,%rax,8),%xmm0
movupd 0x70(%rbx,%rax,8),%xmm1
movupd %xmm0,0x60(%r14,%rax,8)
movupd %xmm1,0x70(%r14,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1c00 <cgpc+0xa30>
cmpq   $0x0,0xf0(%rsp)
je     1caf <cgpc+0xadf>
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1c90 <cgpc+0xac0>
mov    0x100(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     1d2b <cgpc+0xb5b>
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
test   %r12,%r12
je     1ce5 <cgpc+0xb15>
mov    %r12,%rdx
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1cd0 <cgpc+0xb00>
cmp    $0x3,%rcx
jb     1d2b <cgpc+0xb5b>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1cf0 <cgpc+0xb20>
movsd  0x50(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jae    1d4e <cgpc+0xb7e>
cmpl   $0x3e6,0x20(%rsp)
mov    0x40(%rsp),%eax
mov    %rax,0x20(%rsp)
jbe    18e0 <cgpc+0x710>
xor    %ebx,%ebx
movsd  0x50(%rsp),%xmm0
ucomisd %xmm2,%xmm0
setae  %bl
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
lea    (%rbx,%rbp,8),%r12
mov    0x18(%rsp),%rdx
lea    (%rdx,%rbp,8),%rsi
lea    (%r14,%rbp,8),%rdi
cmp    %r12,%r13
setb   %bpl
cmp    %rbx,%rax
seta   %r11b
cmp    %rsi,%r13
setb   %cl
cmp    %rax,%rdx
setb   %r8b
cmp    %rdi,%r13
setb   %r15b
cmp    %r14,%rax
seta   %r9b
cmp    %rbx,%rsi
seta   %r10b
cmp    %r12,%rdx
setb   %dl
cmp    %rbx,%rdi
seta   %dil
cmp    %r14,%r12
seta   %r12b
xor    %eax,%eax
test   %r11b,%bpl
jne    1f94 <cgpc+0xdc4>
and    %r8b,%cl
mov    (%rsp),%rsi
jne    1f98 <cgpc+0xdc8>
and    %r9b,%r15b
jne    1f98 <cgpc+0xdc8>
and    %dl,%r10b
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%rbp
jne    15ee <cgpc+0x41e>
and    %r12b,%dil
jne    15ee <cgpc+0x41e>
mov    %ebp,%eax
and    $0xfffffffc,%eax
cmpq   $0x0,0x50(%rsp)
je     1f85 <cgpc+0xdb5>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
lea    0x2(%rcx),%rdx
mov    0x70(%rsp),%r8
and    %r8,%rdx
xor    %ecx,%ecx
movapd 0x164(%rip),%xmm0
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rcx,8),%xmm1
movupd 0x10(%rdi,%rcx,8),%xmm2
xorpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm2
movupd %xmm1,0x0(%r13,%rcx,8)
movupd %xmm2,0x10(%r13,%rcx,8)
movups (%r14,%rcx,8),%xmm1
movups 0x10(%r14,%rcx,8),%xmm2
movups %xmm1,(%rbx,%rcx,8)
movups %xmm2,0x10(%rbx,%rcx,8)
movupd 0x20(%rdi,%rcx,8),%xmm1
movupd 0x30(%rdi,%rcx,8),%xmm2
xorpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm2
movupd %xmm1,0x20(%r13,%rcx,8)
movupd %xmm2,0x30(%r13,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm2
movupd %xmm1,0x20(%rbx,%rcx,8)
movupd %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1eb0 <cgpc+0xce0>
test   $0x1,%r8b
je     1f77 <cgpc+0xda7>
mov    0x18(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
movapd 0xb7(%rip),%xmm2
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,0x0(%r13,%rcx,8)
movupd %xmm1,0x10(%r13,%rcx,8)
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd %xmm0,(%rbx,%rcx,8)
movupd %xmm1,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
jne    15ee <cgpc+0x41e>
jmp    16d7 <cgpc+0x507>
xor    %ecx,%ecx
mov    0x70(%rsp),%r8
test   $0x1,%r8b
jne    1f31 <cgpc+0xd61>
jmp    1f77 <cgpc+0xda7>
mov    (%rsp),%rsi
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%rbp
jmp    15ee <cgpc+0x41e>

LLVM IR (-O0):
@.str = [5 x i8] c"%d \0A\00"
define i32 @cgpc(double* %0, i32 %1, double* %2, double* %3, double* %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double*
%18 = alloca double*
%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
store double* %0, double** %6
store i32 %1, i32* %7
store double* %2, double** %8
store double* %3, double** %9
store double* %4, double** %10
%29 = call i64 @malloc(i32 64)
%30 = inttoptr i64 %29 to double*
store double* %30, double** %17
%31 = load i32, i32* %7
%32 = sext i32 %31 to i64
%33 = mul i64 8, %32
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to double*
store double* %36, double** %18
%37 = load i32, i32* %7
%38 = sext i32 %37 to i64
%39 = mul i64 8, %38
%40 = trunc i64 %39 to i32
%41 = call i64 @malloc(i32 %40)
%42 = inttoptr i64 %41 to double*
store double* %42, double** %19
%43 = load i32, i32* %7
%44 = sext i32 %43 to i64
%45 = mul i64 8, %44
%46 = trunc i64 %45 to i32
%47 = call i64 @malloc(i32 %46)
%48 = inttoptr i64 %47 to double*
store double* %48, double** %22
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = mul i64 8, %50
%52 = trunc i64 %51 to i32
%53 = call i64 @malloc(i32 %52)
%54 = inttoptr i64 %53 to double*
store double* %54, double** %20
%55 = load i32, i32* %7
%56 = sext i32 %55 to i64
%57 = mul i64 8, %56
%58 = trunc i64 %57 to i32
%59 = call i64 @malloc(i32 %58)
%60 = inttoptr i64 %59 to double*
store double* %60, double** %21
%61 = load i32, i32* %7
%62 = sext i32 %61 to i64
%63 = mul i64 8, %62
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = mul i64 %63, %65
%67 = trunc i64 %66 to i32
%68 = call i64 @malloc(i32 %67)
%69 = inttoptr i64 %68 to double*
store double* %69, double** %23
%70 = load i32, i32* %7
%71 = sext i32 %70 to i64
%72 = mul i64 8, %71
%73 = load i32, i32* %7
%74 = sext i32 %73 to i64
%75 = mul i64 %72, %74
%76 = trunc i64 %75 to i32
%77 = call i64 @malloc(i32 %76)
%78 = inttoptr i64 %77 to double*
store double* %78, double** %25
%79 = load i32, i32* %7
%80 = sext i32 %79 to i64
%81 = mul i64 8, %80
%82 = trunc i64 %81 to i32
%83 = call i64 @malloc(i32 %82)
%84 = inttoptr i64 %83 to double*
store double* %84, double** %24
store i32 0, i32* %15
store i32 0, i32* %14
store i32 1000, i32* %16
%85 = call double @pow(double 1.000000e-15, double 0x3FD5555555555555)
store double %85, double* %27
%86 = load double, double* %27
%87 = load double, double* %27
%88 = fmul double %86, %87
store double %88, double* %26
%89 = load double*, double** %8
%90 = load double*, double** %6
%91 = load double*, double** %18
%92 = load i32, i32* %7
%93 = load i32, i32* %7
%94 = call i32 @mmult(double* %89, double* %90, double* %91, i32 %92, i32 %93, i32 1)
%95 = load double*, double** %18
%96 = load double*, double** %9
%97 = load double*, double** %18
%98 = load i32, i32* %7
%99 = call i32 @msub(double* %95, double* %96, double* %97, i32 %98, i32 1)
store i32 0, i32* %11
br label %100
100: ; preds = %130, %5
%101 = load i32, i32* %11
%102 = load i32, i32* %7
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %133
104: ; preds = %100
%105 = load i32, i32* %11
%106 = load i32, i32* %7
%107 = mul nsw i32 %105, %106
store i32 %107, i32* %13
store i32 0, i32* %12
br label %108
108: ; preds = %126, %104
%109 = load i32, i32* %12
%110 = load i32, i32* %7
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %129
112: ; preds = %108
%113 = load double*, double** %8
%114 = load i32, i32* %13
%115 = load i32, i32* %12
%116 = add nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %113, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %25
%121 = load i32, i32* %13
%122 = load i32, i32* %12
%123 = add nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double, double* %120, i64 %124
store double %119, double* %125
br label %126
126: ; preds = %112
%127 = load i32, i32* %12
%128 = add nsw i32 %127, 1
store i32 %128, i32* %12
br label %108
129: ; preds = %108
br label %130
130: ; preds = %129
%131 = load i32, i32* %11
%132 = add nsw i32 %131, 1
store i32 %132, i32* %11
br label %100
133: ; preds = %100
%134 = load double*, double** %25
%135 = load i32, i32* %7
%136 = call i32 @ichol(double* %134, i32 %135)
%137 = load double*, double** %25
%138 = load i32, i32* %7
%139 = load i32, i32* %7
%140 = call i32 @mdisplay(double* %137, i32 %138, i32 %139)
%141 = load double*, double** %25
%142 = load i32, i32* %7
%143 = load i32, i32* %7
%144 = load double*, double** %23
%145 = call i32 @mtranspose(double* %141, i32 %142, i32 %143, double* %144)
%146 = load double*, double** %23
%147 = load i32, i32* %7
%148 = load double*, double** %18
%149 = load double*, double** %24
%150 = call i32 @linsolve_lower(double* %146, i32 %147, double* %148, double* %149)
store i32 0, i32* %11
br label %151
151: ; preds = %175, %133
%152 = load i32, i32* %11
%153 = load i32, i32* %7
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %178
155: ; preds = %151
%156 = load double*, double** %24
%157 = load i32, i32* %11
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = fneg double %160
%162 = load double*, double** %19
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
store double %161, double* %165
%166 = load double*, double** %6
%167 = load i32, i32* %11
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %166, i64 %168
%170 = load double, double* %169
%171 = load double*, double** %10
%172 = load i32, i32* %11
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %171, i64 %173
store double %170, double* %174
br label %175
175: ; preds = %155
%176 = load i32, i32* %11
%177 = add nsw i32 %176, 1
store i32 %177, i32* %11
br label %151
178: ; preds = %151
%179 = load double*, double** %9
%180 = load i32, i32* %7
%181 = call double @l2norm(double* %179, i32 %180)
store double %181, double* %28
br label %182
182: ; preds = %324, %178
%183 = load i32, i32* %14
%184 = icmp eq i32 %183, 0
br i1 %184, label %185, label %189
185: ; preds = %182
%186 = load i32, i32* %15
%187 = load i32, i32* %16
%188 = icmp slt i32 %186, %187
br label %189
189: ; preds = %185, %182
%190 = phi i1 [ false, %182 ], [ %188, %185 ]
br i1 %190, label %191, label %325
191: ; preds = %189
%192 = load i32, i32* %15
%193 = add nsw i32 %192, 1
store i32 %193, i32* %15
%194 = load double*, double** %18
%195 = load double*, double** %24
%196 = load double*, double** %17
%197 = load i32, i32* %7
%198 = call i32 @mmult(double* %194, double* %195, double* %196, i32 1, i32 %197, i32 1)
%199 = load double*, double** %8
%200 = load double*, double** %19
%201 = load double*, double** %22
%202 = load i32, i32* %7
%203 = load i32, i32* %7
%204 = call i32 @mmult(double* %199, double* %200, double* %201, i32 %202, i32 %203, i32 1)
%205 = load double*, double** %19
%206 = load double*, double** %22
%207 = load double*, double** %17
%208 = getelementptr inbounds double, double* %207, i64 1
%209 = load i32, i32* %7
%210 = call i32 @mmult(double* %205, double* %206, double* %208, i32 1, i32 %209, i32 1)
%211 = load double*, double** %17
%212 = getelementptr inbounds double, double* %211, i64 0
%213 = load double, double* %212
%214 = load double*, double** %17
%215 = getelementptr inbounds double, double* %214, i64 1
%216 = load double, double* %215
%217 = fdiv double %213, %216
%218 = load double*, double** %17
%219 = getelementptr inbounds double, double* %218, i64 2
store double %217, double* %219
store i32 0, i32* %11
br label %220
220: ; preds = %252, %191
%221 = load i32, i32* %11
%222 = load i32, i32* %7
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %255
224: ; preds = %220
%225 = load double*, double** %6
%226 = load i32, i32* %11
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
%229 = load double, double* %228
%230 = load double*, double** %17
%231 = getelementptr inbounds double, double* %230, i64 2
%232 = load double, double* %231
%233 = load double*, double** %19
%234 = load i32, i32* %11
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = call double @llvm.fmuladd.f64(double %232, double %237, double %229)
%239 = load double*, double** %10
%240 = load i32, i32* %11
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %239, i64 %241
store double %238, double* %242
%243 = load double*, double** %17
%244 = getelementptr inbounds double, double* %243, i64 2
%245 = load double, double* %244
%246 = load double*, double** %22
%247 = load i32, i32* %11
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %246, i64 %248
%250 = load double, double* %249
%251 = fmul double %250, %245
store double %251, double* %249
br label %252
252: ; preds = %224
%253 = load i32, i32* %11
%254 = add nsw i32 %253, 1
store i32 %254, i32* %11
br label %220
255: ; preds = %220
%256 = load double*, double** %18
%257 = load double*, double** %22
%258 = load double*, double** %18
%259 = load i32, i32* %7
%260 = call i32 @madd(double* %256, double* %257, double* %258, i32 1, i32 %259)
%261 = load double*, double** %23
%262 = load i32, i32* %7
%263 = load double*, double** %18
%264 = load double*, double** %24
%265 = call i32 @linsolve_lower(double* %261, i32 %262, double* %263, double* %264)
%266 = load double*, double** %18
%267 = load double*, double** %24
%268 = load double*, double** %17
%269 = getelementptr inbounds double, double* %268, i64 3
%270 = load i32, i32* %7
%271 = call i32 @mmult(double* %266, double* %267, double* %269, i32 1, i32 %270, i32 1)
%272 = load double*, double** %17
%273 = getelementptr inbounds double, double* %272, i64 3
%274 = load double, double* %273
%275 = call double @sqrt(double %274)
%276 = load double, double* %26
%277 = load double, double* %28
%278 = fmul double %276, %277
%279 = fcmp ole double %275, %278
br i1 %279, label %280, label %281
280: ; preds = %255
store i32 1, i32* %14
br label %281
281: ; preds = %280, %255
%282 = load double*, double** %17
%283 = getelementptr inbounds double, double* %282, i64 3
%284 = load double, double* %283
%285 = load double*, double** %17
%286 = getelementptr inbounds double, double* %285, i64 0
%287 = load double, double* %286
%288 = fdiv double %284, %287
%289 = load double*, double** %17
%290 = getelementptr inbounds double, double* %289, i64 4
store double %288, double* %290
%291 = load double*, double** %19
%292 = load i32, i32* %7
%293 = load double*, double** %17
%294 = getelementptr inbounds double, double* %293, i64 4
%295 = load double, double* %294
%296 = call i32 @scale(double* %291, i32 %292, i32 1, double %295)
%297 = load double*, double** %10
%298 = load i32, i32* %7
%299 = call i32 @mdisplay(double* %297, i32 1, i32 %298)
%300 = load double*, double** %19
%301 = load double*, double** %24
%302 = load double*, double** %19
%303 = load i32, i32* %7
%304 = call i32 @msub(double* %300, double* %301, double* %302, i32 %303, i32 1)
%305 = load i32, i32* %15
%306 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %305)
store i32 0, i32* %11
br label %307
307: ; preds = %321, %281
%308 = load i32, i32* %11
%309 = load i32, i32* %7
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %324
311: ; preds = %307
%312 = load double*, double** %10
%313 = load i32, i32* %11
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %312, i64 %314
%316 = load double, double* %315
%317 = load double*, double** %6
%318 = load i32, i32* %11
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
store double %316, double* %320
br label %321
321: ; preds = %311
%322 = load i32, i32* %11
%323 = add nsw i32 %322, 1
store i32 %323, i32* %11
br label %307
324: ; preds = %307
br label %182
325: ; preds = %189
%326 = load double*, double** %17
%327 = call i32 @free(double* %326)
%328 = load double*, double** %18
%329 = call i32 @free(double* %328)
%330 = load double*, double** %19
%331 = call i32 @free(double* %330)
%332 = load double*, double** %20
%333 = call i32 @free(double* %332)
%334 = load double*, double** %21
%335 = call i32 @free(double* %334)
%336 = load double*, double** %22
%337 = call i32 @free(double* %336)
%338 = load double*, double** %23
%339 = call i32 @free(double* %338)
%340 = load double*, double** %24
%341 = call i32 @free(double* %340)
%342 = load double*, double** %25
%343 = call i32 @free(double* %342)
%344 = load i32, i32* %14
ret i32 %344
}

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