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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double asum(double *, int);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ choldc(double *, int, double *);
int /*<<< orphan*/ copyarr(double *, double *, int);
int /*<<< orphan*/ fatalx(char *, int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ vlog(double *, double *, int);
double pdinv(double *cinv, double *coeff, int n) {
  double *tt;
  double *p;
  double t, sum, y;
  int i, j, k;
  if ((tt = (double *)calloc((n * n), sizeof(double))) == NULL)
    fatalx("Unable to allocate %d unit(s) for item \n", n * n);
  if ((p = (double *)calloc((n), sizeof(double))) == NULL)
    fatalx("Unable to allocate %d unit(s) for item \n", n);
  copyarr(coeff, tt, n * n);
  choldc(tt, n, p);
  for (i = 0; i < n; i++) {
    tt[i * n + i] = 1.0 / p[i];
    for (j = i + 1; j < n; j++) {
      sum = 0.0;
      for (k = i; k < j; k++) {
        sum -= tt[j * n + k] * tt[k * n + i];
      }
      tt[j * n + i] = sum / p[j];
    }
  }
  for (i = 0; i < n; i++)
    for (j = i; j < n; j++) {
      sum = 0.0;
      if (cinv == NULL)
        break;
      for (k = j; k < n; k++) {
        sum += tt[k * n + j] * tt[k * n + i];
      }
      cinv[i * n + j] = cinv[j * n + i] = sum;
    }
  vlog(p, p, n);
  y = 2.0 * asum(p, n);
  free(tt);
  free(p);
  return y;
}


x86 assembly (clang, -O0):
<pdinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%edi
imul   -0x14(%rbp),%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    11b5 <pdinv+0x45>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
lea    0xe60(%rip),%rdi
call   1050 <fatalx@plt>
mov    -0x14(%rbp),%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    11df <pdinv+0x6f>
mov    -0x14(%rbp),%esi
lea    0xe36(%rip),%rdi
call   1050 <fatalx@plt>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
call   1090 <copyarr@plt>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x28(%rbp),%rdx
call   1040 <choldc@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    131c <pdinv+0x1ac>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xde2(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1309 <pdinv+0x199>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    12d3 <pdinv+0x163>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1264 <pdinv+0xf4>
movsd  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    124a <pdinv+0xda>
jmp    130e <pdinv+0x19e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    120a <pdinv+0x9a>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1409 <pdinv+0x299>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f6 <pdinv+0x286>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpq   $0x0,-0x8(%rbp)
jne    1359 <pdinv+0x1e9>
jmp    13f6 <pdinv+0x286>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13b7 <pdinv+0x247>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    135f <pdinv+0x1ef>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1335 <pdinv+0x1c5>
jmp    13fb <pdinv+0x28b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1323 <pdinv+0x1b3>
mov    -0x28(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1060 <vlog@plt>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1080 <asum@plt>
movaps %xmm0,%xmm1
movsd  0xbd0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pdinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,%r14d
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    %edx,%r12d
imul   %edx,%r12d
mov    %r12d,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,%r15
test   %rax,%rax
jne    11b2 <pdinv+0x42>
lea    0xe5e(%rip),%rdi
mov    %r12d,%esi
call   1050 <fatalx@plt>
mov    %r14d,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,%r13
test   %rax,%rax
jne    11d6 <pdinv+0x66>
lea    0xe3a(%rip),%rdi
mov    %r14d,%esi
call   1050 <fatalx@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
call   1090 <copyarr@plt>
mov    %r15,%rdi
mov    %r14d,%esi
mov    %r13,%rdx
call   1040 <choldc@plt>
test   %r14d,%r14d
jle    1438 <pdinv+0x2c8>
mov    %rbp,0x20(%rsp)
mov    %r14d,%eax
mov    %rax,%rcx
shl    $0x4,%rcx
lea    (%r15,%rax,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x18(%rsp)
lea    0x0(,%rax,8),%rsi
mov    $0x1,%edx
mov    %rdx,0x10(%rsp)
xor    %ebx,%ebx
movsd  0xdcd(%rip),%xmm0
xor    %r11d,%r11d
mov    %r14d,0xc(%rsp)
jmp    1262 <pdinv+0xf2>
nopl   (%rax)
addq   $0x1,0x10(%rsp)
add    %rsi,0x18(%rsp)
add    $0x8,%rbx
mov    0x28(%rsp),%r11
cmp    %rax,%r11
mov    0xc(%rsp),%r14d
je     1382 <pdinv+0x212>
movapd %xmm0,%xmm1
divsd  0x0(%r13,%r11,8),%xmm1
mov    %r11d,%edx
imul   %r14d,%edx
movslq %edx,%rdx
add    %r11,%rdx
movsd  %xmm1,(%r15,%rdx,8)
lea    0x1(%r11),%rdx
mov    %rdx,0x28(%rsp)
cmp    %rax,%rdx
jae    1240 <pdinv+0xd0>
mov    %r11,%rdx
imul   %rax,%rdx
add    %r11,%rdx
mov    %rdx,(%rsp)
lea    0x1(%r11),%rdx
mov    %rdx,0x30(%rsp)
mov    0x18(%rsp),%rdx
xor    %r14d,%r14d
mov    0x10(%rsp),%r10
jmp    12e6 <pdinv+0x176>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r8,%r13
divsd  (%r8,%r10,8),%xmm1
add    %r11,%r12
movsd  %xmm1,(%r15,%r12,8)
add    $0x1,%r10
add    $0x1,%r14
add    %rsi,%rdx
cmp    %rax,%r10
je     1240 <pdinv+0xd0>
mov    %r13,%r8
mov    %r10,%r12
imul   %rax,%r12
xorpd  %xmm1,%xmm1
cmp    %r10,%r11
jae    12c0 <pdinv+0x150>
xorpd  %xmm1,%xmm1
mov    %r11,%rdi
test   $0x1,%r14b
jne    1327 <pdinv+0x1b7>
lea    (%r11,%r12,1),%rdi
movsd  (%r15,%rdi,8),%xmm2
mov    (%rsp),%rdi
mulsd  (%r15,%rdi,8),%xmm2
xorpd  %xmm1,%xmm1
subsd  %xmm2,%xmm1
mov    0x30(%rsp),%rdi
test   %r14,%r14
je     12c0 <pdinv+0x150>
mov    %rax,%rbp
imul   %rdi,%rbp
add    %r11,%rbp
lea    0x1(%rdi),%r9
imul   %rsi,%r9
add    %rbx,%r9
mov    %r15,%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rdx,%rdi,8),%xmm2
mulsd  0x0(%r13,%rbp,8),%xmm2
movsd  (%rdx,%rdi,8),%xmm3
subsd  %xmm2,%xmm1
mulsd  0x0(%r13,%r9,1),%xmm3
subsd  %xmm3,%xmm1
add    $0x2,%rdi
add    %rcx,%r13
cmp    %rdi,%r10
jne    1350 <pdinv+0x1e0>
jmp    12c0 <pdinv+0x150>
test   %r14d,%r14d
mov    0x20(%rsp),%r12
jle    1438 <pdinv+0x2c8>
lea    0x0(,%rax,8),%rcx
lea    0x8(,%rax,8),%r9
xor    %r8d,%r8d
xor    %r11d,%r11d
jmp    13bc <pdinv+0x24c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r9,%r8
cmp    %rax,%r11
je     1438 <pdinv+0x2c8>
test   %r12,%r12
je     13b0 <pdinv+0x240>
mov    %r11,%r10
imul   %rax,%r10
mov    %r8,%rbp
mov    %r8,%rdx
mov    %r11,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    %r15,%rbx
mov    %rsi,%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,1),%xmm1
mulsd  (%rbx,%rdx,1),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
add    %rcx,%rbx
cmp    %rax,%rdi
jb     13f0 <pdinv+0x280>
mov    %rsi,%rdi
imul   %rax,%rdi
add    %r11,%rdi
movsd  %xmm0,(%r12,%rdi,8)
lea    (%rsi,%r10,1),%rdi
movsd  %xmm0,(%r12,%rdi,8)
add    $0x1,%rsi
add    %rcx,%rdx
add    %r9,%rbp
cmp    %rax,%rsi
jb     13e0 <pdinv+0x270>
jmp    13b0 <pdinv+0x240>
mov    %r13,%rdi
mov    %r13,%rsi
mov    %r14d,%edx
call   1060 <vlog@plt>
mov    %r13,%rdi
mov    %r14d,%esi
call   1080 <asum@plt>
addsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [41 x i8] c"Unable to allocate %d unit(s) for item \0A\00"
define double @pdinv(double* writeonly %0, double* %1, i32 %2) {
%4 = mul nsw i32 %2, %2
%5 = tail call i64 @calloc(i32 %4, i32 8)
%6 = inttoptr i64 %5 to double*
%7 = icmp eq i64 %5, 0
br i1 %7, label %8, label %10
8: ; preds = %3
%9 = tail call i32 @fatalx(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 %4)
br label %10
10: ; preds = %8, %3
%11 = tail call i64 @calloc(i32 %2, i32 8)
%12 = inttoptr i64 %11 to double*
%13 = icmp eq i64 %11, 0
br i1 %13, label %14, label %16
14: ; preds = %10
%15 = tail call i32 @fatalx(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 %2)
br label %16
16: ; preds = %14, %10
%17 = tail call i32 @copyarr(double* %1, double* %6, i32 %4)
%18 = tail call i32 @choldc(double* %6, i32 %2, double* %12)
%19 = icmp sgt i32 %2, 0
br i1 %19, label %20, label %133
20: ; preds = %16
%21 = zext i32 %2 to i64
%22 = zext i32 %2 to i64
br label %31
23: ; preds = %93, %31
%24 = add nuw nsw i64 %32, 1
%25 = icmp eq i64 %42, %22
br i1 %25, label %26, label %31
26: ; preds = %23
br i1 %19, label %27, label %133
27: ; preds = %26
%28 = icmp eq double* %0, null
%29 = zext i32 %2 to i64
%30 = zext i32 %2 to i64
br label %103
31: ; preds = %20, %23
%32 = phi i64 [ 1, %20 ], [ %24, %23 ]
%33 = phi i64 [ 0, %20 ], [ %42, %23 ]
%34 = trunc i64 %33 to i32
%35 = getelementptr inbounds double, double* %12, i64 %33
%36 = load double, double* %35
%37 = fdiv double 1.000000e+00, %36
%38 = mul nsw i32 %34, %2
%39 = sext i32 %38 to i64
%40 = add nsw i64 %33, %39
%41 = getelementptr inbounds double, double* %6, i64 %40
store double %37, double* %41
%42 = add nuw nsw i64 %33, 1
%43 = icmp ult i64 %42, %21
br i1 %43, label %44, label %23
44: ; preds = %31
%45 = mul nsw i64 %33, %21
%46 = add nuw nsw i64 %45, %33
%47 = getelementptr inbounds double, double* %6, i64 %46
%48 = add nuw nsw i64 %33, 1
br label %49
49: ; preds = %44, %93
%50 = phi i64 [ 0, %44 ], [ %102, %93 ]
%51 = phi i64 [ %32, %44 ], [ %100, %93 ]
%52 = icmp ult i64 %33, %51
%53 = mul nsw i64 %51, %21
br i1 %52, label %54, label %93
54: ; preds = %49
%55 = and i64 %50, 1
%56 = icmp eq i64 %55, 0
br i1 %56, label %57, label %64
57: ; preds = %54
%58 = add nuw nsw i64 %33, %53
%59 = getelementptr inbounds double, double* %6, i64 %58
%60 = load double, double* %59
%61 = load double, double* %47
%62 = fneg double %60
%63 = tail call double @llvm.fmuladd.f64(double %62, double %61, double 0.000000e+00)
br label %64
64: ; preds = %57, %54
%65 = phi double [ undef, %54 ], [ %63, %57 ]
%66 = phi i64 [ %33, %54 ], [ %48, %57 ]
%67 = phi double [ 0.000000e+00, %54 ], [ %63, %57 ]
%68 = icmp eq i64 %50, 0
br i1 %68, label %93, label %69
69: ; preds = %64, %69
%70 = phi i64 [ %91, %69 ], [ %66, %64 ]
%71 = phi double [ %90, %69 ], [ %67, %64 ]
%72 = add nuw nsw i64 %70, %53
%73 = getelementptr inbounds double, double* %6, i64 %72
%74 = load double, double* %73
%75 = mul nsw i64 %70, %21
%76 = add nuw nsw i64 %75, %33
%77 = getelementptr inbounds double, double* %6, i64 %76
%78 = load double, double* %77
%79 = fneg double %74
%80 = tail call double @llvm.fmuladd.f64(double %79, double %78, double %71)
%81 = add nuw nsw i64 %70, 1
%82 = add nuw nsw i64 %81, %53
%83 = getelementptr inbounds double, double* %6, i64 %82
%84 = load double, double* %83
%85 = mul nsw i64 %81, %21
%86 = add nuw nsw i64 %85, %33
%87 = getelementptr inbounds double, double* %6, i64 %86
%88 = load double, double* %87
%89 = fneg double %84
%90 = tail call double @llvm.fmuladd.f64(double %89, double %88, double %80)
%91 = add nuw nsw i64 %70, 2
%92 = icmp eq i64 %91, %51
br i1 %92, label %93, label %69
93: ; preds = %64, %69, %49
%94 = phi double [ 0.000000e+00, %49 ], [ %65, %64 ], [ %90, %69 ]
%95 = getelementptr inbounds double, double* %12, i64 %51
%96 = load double, double* %95
%97 = fdiv double %94, %96
%98 = add nuw nsw i64 %53, %33
%99 = getelementptr inbounds double, double* %6, i64 %98
store double %97, double* %99
%100 = add nuw nsw i64 %51, 1
%101 = icmp eq i64 %100, %22
%102 = add i64 %50, 1
br i1 %101, label %23, label %49
103: ; preds = %27, %130
%104 = phi i64 [ 0, %27 ], [ %131, %130 ]
br i1 %28, label %130, label %105
105: ; preds = %103
%106 = mul nsw i64 %104, %29
br label %107
107: ; preds = %122, %105
%108 = phi i64 [ %104, %105 ], [ %128, %122 ]
br label %109
109: ; preds = %107, %109
%110 = phi i64 [ %108, %107 ], [ %120, %109 ]
%111 = phi double [ 0.000000e+00, %107 ], [ %119, %109 ]
%112 = mul nsw i64 %110, %29
%113 = add nuw nsw i64 %112, %108
%114 = getelementptr inbounds double, double* %6, i64 %113
%115 = load double, double* %114
%116 = add nuw nsw i64 %112, %104
%117 = getelementptr inbounds double, double* %6, i64 %116
%118 = load double, double* %117
%119 = tail call double @llvm.fmuladd.f64(double %115, double %118, double %111)
%120 = add nuw nsw i64 %110, 1
%121 = icmp ult i64 %120, %29
br i1 %121, label %109, label %122
122: ; preds = %109
%123 = mul nsw i64 %108, %29
%124 = add nuw nsw i64 %123, %104
%125 = getelementptr inbounds double, double* %0, i64 %124
store double %119, double* %125
%126 = add nuw nsw i64 %108, %106
%127 = getelementptr inbounds double, double* %0, i64 %126
store double %119, double* %127
%128 = add nuw nsw i64 %108, 1
%129 = icmp ult i64 %128, %29
br i1 %129, label %107, label %130
130: ; preds = %122, %103
%131 = add nuw nsw i64 %104, 1
%132 = icmp eq i64 %131, %30
br i1 %132, label %133, label %103
133: ; preds = %130, %16, %26
%134 = tail call i32 @vlog(double* %12, double* %12, i32 %2)
%135 = tail call double @asum(double* %12, i32 %2)
%136 = fmul double %135, 2.000000e+00
%137 = tail call i32 @free(double* %6)
%138 = tail call i32 @free(double* %12)
ret double %136
}