#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*/ exit(int);
int /*<<< orphan*/ printf(char *);
double lu(double **A, int n) {
  int i = 0;
  int j = 0;
  int k = 0;
  double detA = 1;
  double mult = 0;
  for (k = 0; k < n; k++) {
    detA *= A[k][k];
    if (detA == 0) {
      printf("La matriu A és singular.\n");
      exit(1);
    }
    for (i = k + 1; i < n; i++) {
      mult = A[i][k] / A[k][k];
      for (j = k + 1; j < n; j++) {
        A[i][j] -= mult * A[k][j];
      }
      A[i][k] = mult;
    }
  }
  return detA;
}


x86 assembly (clang, -O0):
<lu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movsd  0xeb4(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ae <lu+0x18e>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11b9 <lu+0x99>
jp     11b9 <lu+0x99>
lea    0xe5e(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    129b <lu+0x17b>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1273 <lu+0x153>
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%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    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1206 <lu+0xe6>
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c2 <lu+0xa2>
jmp    12a0 <lu+0x180>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1160 <lu+0x40>
movsd  -0x20(%rbp),%xmm0
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
test   %esi,%esi
jle    13f3 <lu+0x2d3>
mov    %esi,%r11d
mov    %r11,%r9
neg    %r9
lea    -0x5(%r11),%rax
mov    %rax,0x8(%rsp)
movsd  0xeb0(%rip),%xmm0
mov    $0x1,%r8d
mov    $0x7,%eax
mov    %rax,(%rsp)
xor    %edx,%edx
xorpd  %xmm8,%xmm8
movapd 0xea1(%rip),%xmm9
jmp    119d <lu+0x7d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
addq   $0x1,(%rsp)
addq   $0xffffffffffffffff,0x8(%rsp)
mov    0x10(%rsp),%rdx
cmp    %r11,%rdx
je     13fb <lu+0x2db>
mov    (%rdi,%rdx,8),%rcx
movsd  (%rcx,%rdx,8),%xmm4
mulsd  %xmm4,%xmm0
ucomisd %xmm8,%xmm0
jne    11b7 <lu+0x97>
jnp    140a <lu+0x2ea>
lea    0x1(%rdx),%rax
mov    %rax,0x10(%rsp)
cmp    %r11,%rax
jae    1180 <lu+0x60>
mov    0x8(%rsp),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x18(%rsp)
mov    %rdx,%r10
not    %r10
lea    (%r10,%r11,1),%rax
add    $0xfffffffffffffffc,%rax
add    %r11,%r10
mov    %rax,0x38(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x30(%rsp)
lea    (%rcx,%r8,8),%rax
mov    %rax,0x40(%rsp)
lea    (%rcx,%r11,8),%r12
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
add    %r8,%rax
mov    %rax,0x20(%rsp)
mov    (%rsp),%rax
lea    (%rcx,%rax,8),%r15
mov    %r8,%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rsi,8),%r14
movsd  (%r14,%rdx,8),%xmm10
divsd  %xmm4,%xmm10
movapd %xmm10,%xmm4
xorpd  %xmm9,%xmm4
mov    %r8,%rbx
cmp    $0x4,%r10
jb     1370 <lu+0x250>
lea    (%r14,%r8,8),%rbp
cmp    %r12,%rbp
jae    1271 <lu+0x151>
lea    (%r14,%r11,8),%rbp
mov    %r8,%rbx
cmp    %rbp,0x40(%rsp)
jb     1370 <lu+0x250>
mov    %r12,%rbx
mov    %r9,%rax
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0x4,0x38(%rsp)
jae    128f <lu+0x16f>
xor    %r9d,%r9d
jmp    131b <lu+0x1fb>
mov    (%rsp),%rbp
lea    (%r14,%rbp,8),%r12
mov    0x18(%rsp),%r13
xor    %r9d,%r9d
nop
movupd -0x30(%r15,%r9,8),%xmm6
movupd -0x20(%r15,%r9,8),%xmm7
mulpd  %xmm5,%xmm6
movupd -0x30(%r12,%r9,8),%xmm1
addpd  %xmm6,%xmm1
movupd -0x20(%r12,%r9,8),%xmm6
movupd -0x10(%r12,%r9,8),%xmm2
movupd (%r12,%r9,8),%xmm3
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm1,-0x30(%r12,%r9,8)
movupd %xmm7,-0x20(%r12,%r9,8)
movupd -0x10(%r15,%r9,8),%xmm1
movupd (%r15,%r9,8),%xmm6
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm1,-0x10(%r12,%r9,8)
movupd %xmm6,(%r12,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%r13
jne    12a0 <lu+0x180>
testb  $0x1,0x30(%rsp)
mov    %rbx,%r12
je     135f <lu+0x23f>
add    %r8,%r9
movupd (%rcx,%r9,8),%xmm1
movupd 0x10(%rcx,%r9,8),%xmm2
movupd (%r14,%r9,8),%xmm3
movupd 0x10(%r14,%r9,8),%xmm6
mulpd  %xmm5,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm5,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm1,(%r14,%r9,8)
movupd %xmm2,0x10(%r14,%r9,8)
mov    0x20(%rsp),%rbx
cmp    0x28(%rsp),%r10
mov    %rax,%r9
je     13d6 <lu+0x2b6>
xchg   %ax,%ax
mov    %r11d,%eax
sub    %ebx,%eax
mov    %rbx,%rbp
test   $0x1,%al
je     1395 <lu+0x275>
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r14,%rbx,8),%xmm1
movsd  %xmm1,(%r14,%rbx,8)
lea    0x1(%rbx),%rbp
not    %rbx
cmp    %r9,%rbx
je     13d6 <lu+0x2b6>
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r14,%rbp,8),%xmm1
movsd  %xmm1,(%r14,%rbp,8)
movsd  0x8(%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x8(%r14,%rbp,8),%xmm1
movsd  %xmm1,0x8(%r14,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r11
jne    13a0 <lu+0x280>
movsd  %xmm10,(%r14,%rdx,8)
add    $0x1,%rsi
cmp    %r11,%rsi
je     1180 <lu+0x60>
movsd  (%rcx,%rdx,8),%xmm4
jmp    1230 <lu+0x110>
movsd  0xc05(%rip),%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc0f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@.str = [27 x i8] c"La matriu A \C3\A9s singular.\0A\00"
define double @lu(double** %0, i32 %1) {
%3 = alloca double**
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
%9 = alloca double
store double** %0, double*** %3
store i32 %1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store double 1.000000e+00, double* %8
store double 0.000000e+00, double* %9
store i32 0, i32* %7
br label %10
10: ; preds = %103, %2
%11 = load i32, i32* %7
%12 = load i32, i32* %4
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %106
14: ; preds = %10
%15 = load double**, double*** %3
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds double*, double** %15, i64 %17
%19 = load double*, double** %18
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %19, i64 %21
%23 = load double, double* %22
%24 = load double, double* %8
%25 = fmul double %24, %23
store double %25, double* %8
%26 = load double, double* %8
%27 = fcmp oeq double %26, 0.000000e+00
br i1 %27, label %28, label %31
28: ; preds = %14
%29 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
%30 = call i32 @exit(i32 1)
unreachable
31: ; preds = %14
%32 = load i32, i32* %7
%33 = add nsw i32 %32, 1
store i32 %33, i32* %5
br label %34
34: ; preds = %99, %31
%35 = load i32, i32* %5
%36 = load i32, i32* %4
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %102
38: ; preds = %34
%39 = load double**, double*** %3
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double*, double** %39, i64 %41
%43 = load double*, double** %42
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
%47 = load double, double* %46
%48 = load double**, double*** %3
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double*, double** %48, i64 %50
%52 = load double*, double** %51
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fdiv double %47, %56
store double %57, double* %9
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
store i32 %59, i32* %6
br label %60
60: ; preds = %86, %38
%61 = load i32, i32* %6
%62 = load i32, i32* %4
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %89
64: ; preds = %60
%65 = load double, double* %9
%66 = load double**, double*** %3
%67 = load i32, i32* %7
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double*, double** %66, i64 %68
%70 = load double*, double** %69
%71 = load i32, i32* %6
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
%75 = load double**, double*** %3
%76 = load i32, i32* %5
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double*, double** %75, i64 %77
%79 = load double*, double** %78
%80 = load i32, i32* %6
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
%83 = load double, double* %82
%84 = fneg double %65
%85 = call double @llvm.fmuladd.f64(double %84, double %74, double %83)
store double %85, double* %82
br label %86
86: ; preds = %64
%87 = load i32, i32* %6
%88 = add nsw i32 %87, 1
store i32 %88, i32* %6
br label %60
89: ; preds = %60
%90 = load double, double* %9
%91 = load double**, double*** %3
%92 = load i32, i32* %5
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double*, double** %91, i64 %93
%95 = load double*, double** %94
%96 = load i32, i32* %7
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
store double %90, double* %98
br label %99
99: ; preds = %89
%100 = load i32, i32* %5
%101 = add nsw i32 %100, 1
store i32 %101, i32* %5
br label %34
102: ; preds = %34
br label %103
103: ; preds = %102
%104 = load i32, i32* %7
%105 = add nsw i32 %104, 1
store i32 %105, i32* %7
br label %10
106: ; preds = %10
%107 = load double, double* %8
ret double %107
}

LLVM IR (-O2):
@str = [26 x i8] c"La matriu A \C3\A9s singular.\00"
define double @lu(double** nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %163
4: ; preds = %2
%5 = zext i32 %1 to i64
%6 = zext i32 %1 to i64
%7 = sub nsw i64 0, %6
br label %11
8: ; preds = %158, %31
%9 = add nuw nsw i64 %13, 1
%10 = icmp eq i64 %32, %6
br i1 %10, label %163, label %11
11: ; preds = %4, %8
%12 = phi i64 [ 0, %4 ], [ %32, %8 ]
%13 = phi i64 [ 1, %4 ], [ %9, %8 ]
%14 = phi double [ 1.000000e+00, %4 ], [ %26, %8 ]
%15 = xor i64 %12, -1
%16 = add nsw i64 %15, %6
%17 = add i64 %16, -4
%18 = lshr i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = xor i64 %12, -1
%21 = add nsw i64 %20, %6
%22 = getelementptr inbounds double*, double** %0, i64 %12
%23 = load double*, double** %22
%24 = getelementptr inbounds double, double* %23, i64 %12
%25 = load double, double* %24
%26 = fmul double %14, %25
%27 = fcmp oeq double %26, 0.000000e+00
br i1 %27, label %28, label %31
28: ; preds = %11
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str, i64 0, i64 0))
%30 = tail call i32 @exit(i32 1)
unreachable
31: ; preds = %11
%32 = add nuw nsw i64 %12, 1
%33 = icmp ult i64 %32, %5
br i1 %33, label %34, label %8
34: ; preds = %31
%35 = getelementptr double, double* %23, i64 %13
%36 = getelementptr double, double* %23, i64 %6
%37 = icmp ult i64 %21, 4
%38 = and i64 %21, -4
%39 = add i64 %13, %38
%40 = and i64 %19, 1
%41 = icmp ult i64 %17, 4
%42 = and i64 %19, 9223372036854775806
%43 = icmp eq i64 %40, 0
%44 = icmp eq i64 %21, %38
br label %45
45: ; preds = %34, %161
%46 = phi double [ %162, %161 ], [ %25, %34 ]
%47 = phi i64 [ %159, %161 ], [ %13, %34 ]
%48 = getelementptr inbounds double*, double** %0, i64 %47
%49 = load double*, double** %48
%50 = getelementptr inbounds double, double* %49, i64 %12
%51 = load double, double* %50
%52 = fdiv double %51, %46
%53 = fneg double %52
br i1 %37, label %127, label %54
54: ; preds = %45
%55 = getelementptr double, double* %49, i64 %13
%56 = getelementptr double, double* %49, i64 %6
%57 = icmp ult double* %55, %36
%58 = icmp ult double* %35, %56
%59 = and i1 %57, %58
br i1 %59, label %127, label %60
60: ; preds = %54
%61 = insertelement <2 x double> poison, double %53, i64 0
%62 = shufflevector <2 x double> %61, <2 x double> poison, <2 x i32> zeroinitializer
%63 = insertelement <2 x double> poison, double %53, i64 0
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %41, label %106, label %65
65: ; preds = %60, %65
%66 = phi i64 [ %103, %65 ], [ 0, %60 ]
%67 = phi i64 [ %104, %65 ], [ 0, %60 ]
%68 = add i64 %13, %66
%69 = getelementptr inbounds double, double* %23, i64 %68
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %69, i64 2
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = getelementptr inbounds double, double* %49, i64 %68
%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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %62, <2 x double> %71, <2 x double> %77)
%82 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %64, <2 x double> %74, <2 x double> %80)
%83 = bitcast double* %75 to <2 x double>*
store <2 x double> %81, <2 x double>* %83
%84 = bitcast double* %78 to <2 x double>*
store <2 x double> %82, <2 x double>* %84
%85 = or i64 %66, 4
%86 = add i64 %13, %85
%87 = getelementptr inbounds double, double* %23, 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* %49, i64 %86
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %93, i64 2
%97 = bitcast double* %96 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %62, <2 x double> %89, <2 x double> %95)
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %64, <2 x double> %92, <2 x double> %98)
%101 = bitcast double* %93 to <2 x double>*
store <2 x double> %99, <2 x double>* %101
%102 = bitcast double* %96 to <2 x double>*
store <2 x double> %100, <2 x double>* %102
%103 = add nuw i64 %66, 8
%104 = add i64 %67, 2
%105 = icmp eq i64 %104, %42
br i1 %105, label %106, label %65
106: ; preds = %65, %60
%107 = phi i64 [ 0, %60 ], [ %103, %65 ]
br i1 %43, label %126, label %108
108: ; preds = %106
%109 = add i64 %13, %107
%110 = getelementptr inbounds double, double* %23, i64 %109
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = getelementptr inbounds double, double* %110, i64 2
%114 = bitcast double* %113 to <2 x double>*
%115 = load <2 x double>, <2 x double>* %114
%116 = getelementptr inbounds double, double* %49, i64 %109
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr inbounds double, double* %116, i64 2
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %62, <2 x double> %112, <2 x double> %118)
%123 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %64, <2 x double> %115, <2 x double> %121)
%124 = bitcast double* %116 to <2 x double>*
store <2 x double> %122, <2 x double>* %124
%125 = bitcast double* %119 to <2 x double>*
store <2 x double> %123, <2 x double>* %125
br label %126
126: ; preds = %106, %108
br i1 %44, label %158, label %127
127: ; preds = %54, %45, %126
%128 = phi i64 [ %13, %54 ], [ %13, %45 ], [ %39, %126 ]
%129 = sub i64 %6, %128
%130 = xor i64 %128, -1
%131 = and i64 %129, 1
%132 = icmp eq i64 %131, 0
br i1 %132, label %140, label %133
133: ; preds = %127
%134 = getelementptr inbounds double, double* %23, i64 %128
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %49, i64 %128
%137 = load double, double* %136
%138 = tail call double @llvm.fmuladd.f64(double %53, double %135, double %137)
store double %138, double* %136
%139 = add nuw nsw i64 %128, 1
br label %140
140: ; preds = %133, %127
%141 = phi i64 [ %128, %127 ], [ %139, %133 ]
%142 = icmp eq i64 %130, %7
br i1 %142, label %158, label %143
143: ; preds = %140, %143
%144 = phi i64 [ %156, %143 ], [ %141, %140 ]
%145 = getelementptr inbounds double, double* %23, i64 %144
%146 = load double, double* %145
%147 = getelementptr inbounds double, double* %49, i64 %144
%148 = load double, double* %147
%149 = tail call double @llvm.fmuladd.f64(double %53, double %146, double %148)
store double %149, double* %147
%150 = add nuw nsw i64 %144, 1
%151 = getelementptr inbounds double, double* %23, i64 %150
%152 = load double, double* %151
%153 = getelementptr inbounds double, double* %49, i64 %150
%154 = load double, double* %153
%155 = tail call double @llvm.fmuladd.f64(double %53, double %152, double %154)
store double %155, double* %153
%156 = add nuw nsw i64 %144, 2
%157 = icmp eq i64 %156, %6
br i1 %157, label %158, label %143
158: ; preds = %140, %143, %126
store double %52, double* %50
%159 = add nuw nsw i64 %47, 1
%160 = icmp eq i64 %159, %6
br i1 %160, label %8, label %161
161: ; preds = %158
%162 = load double, double* %24
br label %45
163: ; preds = %8, %2
%164 = phi double [ 1.000000e+00, %2 ], [ %26, %8 ]
ret double %164
}