#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 sqrt(double);
void cholesky(long N, double *A, double *diag) {
  long i, j, k;
  for (j = 0; j < N; j++)
    diag[j] = A[N * j + j];
  for (j = 0; j < N; j++) {
    for (k = 0; k < j; k++)
      diag[j] -= A[N * k + j] * A[N * k + j];
    diag[j] = sqrt(diag[j]);
    for (i = j + 1; i < N; i++) {
      for (k = 0; k < j; k++)
        A[N * j + i] -= A[N * k + i] * A[N * k + j];
      A[N * j + i] /= diag[j];
    }
  }
}


x86 assembly (clang, -O0):
<cholesky>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    116e <cholesky+0x5e>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    112c <cholesky+0x1c>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1321 <cholesky+0x211>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1208 <cholesky+0xf8>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x30(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x30(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    118c <cholesky+0x7c>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    130b <cholesky+0x1fb>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    12ce <cholesky+0x1be>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x30(%rbp),%rcx
add    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x30(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1249 <cholesky+0x139>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1233 <cholesky+0x123>
jmp    1310 <cholesky+0x200>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1176 <cholesky+0x66>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cholesky>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %rdi,%rdi
jle    1411 <cholesky+0x301>
mov    %rsi,%r14
lea    -0x1(%rdi),%rax
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    114b <cholesky+0x3b>
xor    %ecx,%ecx
test   %r8,%r8
jne    11cd <cholesky+0xbd>
jmp    1206 <cholesky+0xf6>
mov    %rdi,%r9
shl    $0x4,%r9
mov    %rdi,%rsi
shl    $0x5,%rsi
add    $0x20,%rsi
lea    0x0(,%rdi,8),%rax
lea    (%rax,%rax,2),%r10
mov    %rdi,%rbp
and    $0xfffffffffffffffc,%rbp
neg    %rbp
mov    $0x1,%ecx
mov    %r14,%rax
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x10(%rax,%r9,1),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movsd  0x18(%rax,%r10,1),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
add    %rsi,%rax
lea    (%rcx,%rbp,1),%rbx
add    $0x4,%rbx
add    $0x4,%rcx
cmp    $0x1,%rbx
jne    1180 <cholesky+0x70>
add    $0xffffffffffffffff,%rcx
test   %r8,%r8
je     1206 <cholesky+0xf6>
lea    (%rdx,%rcx,8),%rbp
lea    0x1(%rdi),%rax
imul   %rcx,%rax
lea    (%r14,%rax,8),%rax
lea    0x8(,%rdi,8),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
add    %rcx,%rax
cmp    %rsi,%r8
jne    11f0 <cholesky+0xe0>
test   %rdi,%rdi
jle    1411 <cholesky+0x301>
mov    %rdi,%r12
shl    $0x4,%r12
lea    (%r14,%rdi,8),%r11
lea    (%r14,%rdi,8),%rax
add    $0x8,%rax
mov    %rax,0x18(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x10(%rsp)
xor    %r8d,%r8d
xorpd  %xmm2,%xmm2
mov    %r14,%r13
jmp    125d <cholesky+0x14d>
nopl   0x0(%rax)
add    $0x8,%r13
add    $0x8,%r11
addq   $0x8,0x18(%rsp)
addq   $0x8,0x10(%rsp)
cmp    %rdi,%r8
je     1411 <cholesky+0x301>
mov    %r8,%rbp
mov    %r8,%r15
and    $0xfffffffffffffffe,%r15
test   %r8,%r8
je     1280 <cholesky+0x170>
movsd  (%rdx,%rbp,8),%xmm0
cmp    $0x1,%rbp
jne    1290 <cholesky+0x180>
xor    %eax,%eax
jmp    12cf <cholesky+0x1bf>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm0
jmp    12ef <cholesky+0x1df>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x2,%rax
add    %r12,%rcx
cmp    %rax,%r15
jne    12a0 <cholesky+0x190>
test   $0x1,%bpl
je     12ef <cholesky+0x1df>
imul   %rdi,%rax
add    %rbp,%rax
movsd  (%r14,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
ucomisd %xmm2,%xmm0
mov    %rbp,0x8(%rsp)
jb     1300 <cholesky+0x1f0>
sqrtsd %xmm0,%xmm0
jmp    1324 <cholesky+0x214>
mov    %rdx,%rbx
mov    %rdi,%rbp
mov    %r11,0x20(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm2,%xmm2
mov    0x20(%rsp),%r11
mov    %rbp,%rdi
mov    0x8(%rsp),%rbp
mov    %rbx,%rdx
movsd  %xmm0,(%rdx,%rbp,8)
lea    0x1(%rbp),%r8
cmp    %rdi,%r8
jge    1240 <cholesky+0x130>
mov    %rbp,%r9
imul   %rdi,%r9
mov    0x10(%rsp),%rbx
mov    0x18(%rsp),%rsi
mov    %r8,%r10
jmp    1376 <cholesky+0x266>
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
divsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%r10
add    $0x8,%rsi
add    $0x8,%rbx
cmp    %rdi,%r10
jge    1240 <cholesky+0x130>
lea    (%r10,%r9,1),%rax
test   %rbp,%rbp
je     1350 <cholesky+0x240>
movsd  (%r14,%rax,8),%xmm0
cmp    $0x1,%rbp
jne    1390 <cholesky+0x280>
xor    %ecx,%ecx
jmp    13d7 <cholesky+0x2c7>
nop
xor    %ebp,%ebp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rbp,1),%xmm1
mulsd  0x0(%r13,%rbp,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  (%rsi,%rbp,1),%xmm1
mulsd  (%r11,%rbp,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x2,%rcx
add    %r12,%rbp
cmp    %rcx,%r15
jne    13a0 <cholesky+0x290>
mov    0x8(%rsp),%rbp
test   $0x1,%bpl
je     1350 <cholesky+0x240>
imul   %rdi,%rcx
lea    (%rcx,%r10,1),%rbp
movsd  (%r14,%rbp,8),%xmm1
mov    0x8(%rsp),%rbp
add    %rbp,%rcx
mulsd  (%r14,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
jmp    1350 <cholesky+0x240>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cholesky(i64 %0, double* %1, double* %2) {
%4 = alloca i64
%5 = alloca double*
%6 = alloca double*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
store i64 %0, i64* %4
store double* %1, double** %5
store double* %2, double** %6
store i64 0, i64* %8
br label %10
10: ; preds = %26, %3
%11 = load i64, i64* %8
%12 = load i64, i64* %4
%13 = icmp slt i64 %11, %12
br i1 %13, label %14, label %29
14: ; preds = %10
%15 = load double*, double** %5
%16 = load i64, i64* %4
%17 = load i64, i64* %8
%18 = mul nsw i64 %16, %17
%19 = load i64, i64* %8
%20 = add nsw i64 %18, %19
%21 = getelementptr inbounds double, double* %15, i64 %20
%22 = load double, double* %21
%23 = load double*, double** %6
%24 = load i64, i64* %8
%25 = getelementptr inbounds double, double* %23, i64 %24
store double %22, double* %25
br label %26
26: ; preds = %14
%27 = load i64, i64* %8
%28 = add nsw i64 %27, 1
store i64 %28, i64* %8
br label %10
29: ; preds = %10
store i64 0, i64* %8
br label %30
30: ; preds = %133, %29
%31 = load i64, i64* %8
%32 = load i64, i64* %4
%33 = icmp slt i64 %31, %32
br i1 %33, label %34, label %136
34: ; preds = %30
store i64 0, i64* %9
br label %35
35: ; preds = %62, %34
%36 = load i64, i64* %9
%37 = load i64, i64* %8
%38 = icmp slt i64 %36, %37
br i1 %38, label %39, label %65
39: ; preds = %35
%40 = load double*, double** %5
%41 = load i64, i64* %4
%42 = load i64, i64* %9
%43 = mul nsw i64 %41, %42
%44 = load i64, i64* %8
%45 = add nsw i64 %43, %44
%46 = getelementptr inbounds double, double* %40, i64 %45
%47 = load double, double* %46
%48 = load double*, double** %5
%49 = load i64, i64* %4
%50 = load i64, i64* %9
%51 = mul nsw i64 %49, %50
%52 = load i64, i64* %8
%53 = add nsw i64 %51, %52
%54 = getelementptr inbounds double, double* %48, i64 %53
%55 = load double, double* %54
%56 = load double*, double** %6
%57 = load i64, i64* %8
%58 = getelementptr inbounds double, double* %56, i64 %57
%59 = load double, double* %58
%60 = fneg double %47
%61 = call double @llvm.fmuladd.f64(double %60, double %55, double %59)
store double %61, double* %58
br label %62
62: ; preds = %39
%63 = load i64, i64* %9
%64 = add nsw i64 %63, 1
store i64 %64, i64* %9
br label %35
65: ; preds = %35
%66 = load double*, double** %6
%67 = load i64, i64* %8
%68 = getelementptr inbounds double, double* %66, i64 %67
%69 = load double, double* %68
%70 = call double @sqrt(double %69)
%71 = load double*, double** %6
%72 = load i64, i64* %8
%73 = getelementptr inbounds double, double* %71, i64 %72
store double %70, double* %73
%74 = load i64, i64* %8
%75 = add nsw i64 %74, 1
store i64 %75, i64* %7
br label %76
76: ; preds = %129, %65
%77 = load i64, i64* %7
%78 = load i64, i64* %4
%79 = icmp slt i64 %77, %78
br i1 %79, label %80, label %132
80: ; preds = %76
store i64 0, i64* %9
br label %81
81: ; preds = %112, %80
%82 = load i64, i64* %9
%83 = load i64, i64* %8
%84 = icmp slt i64 %82, %83
br i1 %84, label %85, label %115
85: ; preds = %81
%86 = load double*, double** %5
%87 = load i64, i64* %4
%88 = load i64, i64* %9
%89 = mul nsw i64 %87, %88
%90 = load i64, i64* %7
%91 = add nsw i64 %89, %90
%92 = getelementptr inbounds double, double* %86, i64 %91
%93 = load double, double* %92
%94 = load double*, double** %5
%95 = load i64, i64* %4
%96 = load i64, i64* %9
%97 = mul nsw i64 %95, %96
%98 = load i64, i64* %8
%99 = add nsw i64 %97, %98
%100 = getelementptr inbounds double, double* %94, i64 %99
%101 = load double, double* %100
%102 = load double*, double** %5
%103 = load i64, i64* %4
%104 = load i64, i64* %8
%105 = mul nsw i64 %103, %104
%106 = load i64, i64* %7
%107 = add nsw i64 %105, %106
%108 = getelementptr inbounds double, double* %102, i64 %107
%109 = load double, double* %108
%110 = fneg double %93
%111 = call double @llvm.fmuladd.f64(double %110, double %101, double %109)
store double %111, double* %108
br label %112
112: ; preds = %85
%113 = load i64, i64* %9
%114 = add nsw i64 %113, 1
store i64 %114, i64* %9
br label %81
115: ; preds = %81
%116 = load double*, double** %6
%117 = load i64, i64* %8
%118 = getelementptr inbounds double, double* %116, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %5
%121 = load i64, i64* %4
%122 = load i64, i64* %8
%123 = mul nsw i64 %121, %122
%124 = load i64, i64* %7
%125 = add nsw i64 %123, %124
%126 = getelementptr inbounds double, double* %120, i64 %125
%127 = load double, double* %126
%128 = fdiv double %127, %119
store double %128, double* %126
br label %129
129: ; preds = %115
%130 = load i64, i64* %7
%131 = add nsw i64 %130, 1
store i64 %131, i64* %7
br label %76
132: ; preds = %76
br label %133
133: ; preds = %132
%134 = load i64, i64* %8
%135 = add nsw i64 %134, 1
store i64 %135, i64* %8
br label %30
136: ; preds = %30
ret void
}

LLVM IR (-O2):
define void @cholesky(i64 %0, double* nocapture %1, double* nocapture %2) {
%4 = icmp sgt i64 %0, 0
br i1 %4, label %5, label %165
5: ; preds = %3
%6 = add i64 %0, -1
%7 = and i64 %0, 3
%8 = icmp ult i64 %6, 3
br i1 %8, label %11, label %9
9: ; preds = %5
%10 = and i64 %0, -4
br label %26
11: ; preds = %26, %5
%12 = phi i64 [ 0, %5 ], [ %52, %26 ]
%13 = icmp eq i64 %7, 0
br i1 %13, label %25, label %14
14: ; preds = %11, %14
%15 = phi i64 [ %22, %14 ], [ %12, %11 ]
%16 = phi i64 [ %23, %14 ], [ 0, %11 ]
%17 = mul nsw i64 %15, %0
%18 = add nsw i64 %17, %15
%19 = getelementptr inbounds double, double* %1, i64 %18
%20 = load double, double* %19
%21 = getelementptr inbounds double, double* %2, i64 %15
store double %20, double* %21
%22 = add nuw nsw i64 %15, 1
%23 = add i64 %16, 1
%24 = icmp eq i64 %23, %7
br i1 %24, label %25, label %14
25: ; preds = %14, %11
br i1 %4, label %57, label %165
26: ; preds = %26, %9
%27 = phi i64 [ 0, %9 ], [ %52, %26 ]
%28 = phi i64 [ 0, %9 ], [ %53, %26 ]
%29 = mul nsw i64 %27, %0
%30 = add nsw i64 %29, %27
%31 = getelementptr inbounds double, double* %1, i64 %30
%32 = load double, double* %31
%33 = getelementptr inbounds double, double* %2, i64 %27
store double %32, double* %33
%34 = or i64 %27, 1
%35 = mul nsw i64 %34, %0
%36 = add nsw i64 %35, %34
%37 = getelementptr inbounds double, double* %1, i64 %36
%38 = load double, double* %37
%39 = getelementptr inbounds double, double* %2, i64 %34
store double %38, double* %39
%40 = or i64 %27, 2
%41 = mul nsw i64 %40, %0
%42 = add nsw i64 %41, %40
%43 = getelementptr inbounds double, double* %1, i64 %42
%44 = load double, double* %43
%45 = getelementptr inbounds double, double* %2, i64 %40
store double %44, double* %45
%46 = or i64 %27, 3
%47 = mul nsw i64 %46, %0
%48 = add nsw i64 %47, %46
%49 = getelementptr inbounds double, double* %1, i64 %48
%50 = load double, double* %49
%51 = getelementptr inbounds double, double* %2, i64 %46
store double %50, double* %51
%52 = add nuw nsw i64 %27, 4
%53 = add i64 %28, 4
%54 = icmp eq i64 %53, %10
br i1 %54, label %11, label %26
55: ; preds = %158, %101
%56 = icmp eq i64 %105, %0
br i1 %56, label %165, label %57
57: ; preds = %25, %55
%58 = phi i64 [ %105, %55 ], [ 0, %25 ]
%59 = icmp eq i64 %58, 0
br i1 %59, label %60, label %62
60: ; preds = %57
%61 = load double, double* %2
br label %101
62: ; preds = %57
%63 = getelementptr inbounds double, double* %2, i64 %58
%64 = load double, double* %63
%65 = and i64 %58, 1
%66 = icmp eq i64 %58, 1
br i1 %66, label %89, label %67
67: ; preds = %62
%68 = and i64 %58, 9223372036854775806
br label %69
69: ; preds = %69, %67
%70 = phi double [ %64, %67 ], [ %85, %69 ]
%71 = phi i64 [ 0, %67 ], [ %86, %69 ]
%72 = phi i64 [ 0, %67 ], [ %87, %69 ]
%73 = mul nsw i64 %71, %0
%74 = add nsw i64 %73, %58
%75 = getelementptr inbounds double, double* %1, i64 %74
%76 = load double, double* %75
%77 = fneg double %76
%78 = tail call double @llvm.fmuladd.f64(double %77, double %76, double %70)
store double %78, double* %63
%79 = or i64 %71, 1
%80 = mul nsw i64 %79, %0
%81 = add nsw i64 %80, %58
%82 = getelementptr inbounds double, double* %1, i64 %81
%83 = load double, double* %82
%84 = fneg double %83
%85 = tail call double @llvm.fmuladd.f64(double %84, double %83, double %78)
store double %85, double* %63
%86 = add nuw nsw i64 %71, 2
%87 = add i64 %72, 2
%88 = icmp eq i64 %87, %68
br i1 %88, label %89, label %69
89: ; preds = %69, %62
%90 = phi double [ undef, %62 ], [ %85, %69 ]
%91 = phi double [ %64, %62 ], [ %85, %69 ]
%92 = phi i64 [ 0, %62 ], [ %86, %69 ]
%93 = icmp eq i64 %65, 0
br i1 %93, label %101, label %94
94: ; preds = %89
%95 = mul nsw i64 %92, %0
%96 = add nsw i64 %95, %58
%97 = getelementptr inbounds double, double* %1, i64 %96
%98 = load double, double* %97
%99 = fneg double %98
%100 = tail call double @llvm.fmuladd.f64(double %99, double %98, double %91)
store double %100, double* %63
br label %101
101: ; preds = %94, %89, %60
%102 = phi double [ %61, %60 ], [ %90, %89 ], [ %100, %94 ]
%103 = getelementptr inbounds double, double* %2, i64 %58
%104 = tail call double @sqrt(double %102)
store double %104, double* %103
%105 = add nuw nsw i64 %58, 1
%106 = icmp slt i64 %105, %0
br i1 %106, label %107, label %55
107: ; preds = %101
%108 = mul nsw i64 %58, %0
%109 = and i64 %58, 1
%110 = icmp eq i64 %58, 1
%111 = and i64 %58, 9223372036854775806
%112 = icmp eq i64 %109, 0
br label %113
113: ; preds = %107, %158
%114 = phi i64 [ %105, %107 ], [ %163, %158 ]
%115 = add nsw i64 %114, %108
br i1 %59, label %158, label %116
116: ; preds = %113
%117 = getelementptr inbounds double, double* %1, i64 %115
%118 = load double, double* %117
br i1 %110, label %145, label %119
119: ; preds = %116, %119
%120 = phi double [ %141, %119 ], [ %118, %116 ]
%121 = phi i64 [ %142, %119 ], [ 0, %116 ]
%122 = phi i64 [ %143, %119 ], [ 0, %116 ]
%123 = mul nsw i64 %121, %0
%124 = add nsw i64 %123, %114
%125 = getelementptr inbounds double, double* %1, i64 %124
%126 = load double, double* %125
%127 = add nsw i64 %123, %58
%128 = getelementptr inbounds double, double* %1, i64 %127
%129 = load double, double* %128
%130 = fneg double %126
%131 = tail call double @llvm.fmuladd.f64(double %130, double %129, double %120)
store double %131, double* %117
%132 = or i64 %121, 1
%133 = mul nsw i64 %132, %0
%134 = add nsw i64 %133, %114
%135 = getelementptr inbounds double, double* %1, i64 %134
%136 = load double, double* %135
%137 = add nsw i64 %133, %58
%138 = getelementptr inbounds double, double* %1, i64 %137
%139 = load double, double* %138
%140 = fneg double %136
%141 = tail call double @llvm.fmuladd.f64(double %140, double %139, double %131)
store double %141, double* %117
%142 = add nuw nsw i64 %121, 2
%143 = add i64 %122, 2
%144 = icmp eq i64 %143, %111
br i1 %144, label %145, label %119
145: ; preds = %119, %116
%146 = phi double [ %118, %116 ], [ %141, %119 ]
%147 = phi i64 [ 0, %116 ], [ %142, %119 ]
br i1 %112, label %158, label %148
148: ; preds = %145
%149 = mul nsw i64 %147, %0
%150 = add nsw i64 %149, %114
%151 = getelementptr inbounds double, double* %1, i64 %150
%152 = load double, double* %151
%153 = add nsw i64 %149, %58
%154 = getelementptr inbounds double, double* %1, i64 %153
%155 = load double, double* %154
%156 = fneg double %152
%157 = tail call double @llvm.fmuladd.f64(double %156, double %155, double %146)
store double %157, double* %117
br label %158
158: ; preds = %148, %145, %113
%159 = load double, double* %103
%160 = getelementptr inbounds double, double* %1, i64 %115
%161 = load double, double* %160
%162 = fdiv double %161, %159
store double %162, double* %160
%163 = add nuw nsw i64 %114, 1
%164 = icmp slt i64 %163, %0
br i1 %164, label %113, label %55
165: ; preds = %55, %3, %25
ret void
}