#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*/ display(double **);
double solve(double coef[3][4]) {
  display(coef);
  double t = coef[1][0] / coef[0][0];
  double t2 = coef[2][0] / coef[0][0];
  for (int i = 0; i < 4; i++) {
    coef[1][i] = coef[1][i] - (t * coef[0][i]);
    coef[2][i] = coef[2][i] - (t2 * coef[0][i]);
    display(coef);
  }
  t = coef[2][1] / coef[1][1];
  for (int i = 0; i < 4; i++) {
    coef[2][i] -= (t * coef[1][i]);
    display(coef);
  }
  for (int j = 2; j >= 1; j--) {
    for (int i = 0; i < 4; i++) {
      coef[j][i] /= coef[2][j];
    }
    for (int i = 0; i < 4; i++) {
      coef[1][i] = coef[1][i] - (coef[2][i]);
      display(coef);
    }
  }
}


x86 assembly (clang, -O0):
<solve>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1213 <solve+0x103>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x20(%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x40(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,0x40(%rax,%rcx,8)
mov    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1158 <solve+0x48>
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    1298 <solve+0x188>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  0x20(%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  0x40(%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rax,%rcx,8)
mov    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1231 <solve+0x121>
movl   $0x2,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     135c <solve+0x24c>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    12f7 <solve+0x1e7>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x40(%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12b0 <solve+0x1a0>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1349 <solve+0x239>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  0x40(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
mov    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12fe <solve+0x1ee>
jmp    134e <solve+0x23e>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    129f <solve+0x18f>
movsd  -0x8(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve>:
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%rbx
call   1030 <display@plt>
movsd  (%rbx),%xmm0
movsd  0x20(%rbx),%xmm1
movsd  0x40(%rbx),%xmm2
movapd 0xecd(%rip),%xmm3
movapd %xmm1,%xmm4
xorpd  %xmm3,%xmm4
divsd  %xmm0,%xmm4
movapd %xmm4,(%rsp)
movapd %xmm2,%xmm5
xorpd  %xmm3,%xmm5
divsd  %xmm0,%xmm5
movapd %xmm5,0x10(%rsp)
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x20(%rbx)
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x8(%rbx),%xmm0
movapd (%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x28(%rbx),%xmm1
movsd  %xmm1,0x28(%rbx)
mulsd  0x10(%rsp),%xmm0
addsd  0x48(%rbx),%xmm0
movsd  %xmm0,0x48(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x10(%rbx),%xmm0
movapd (%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x30(%rbx),%xmm1
movsd  %xmm1,0x30(%rbx)
mulsd  0x10(%rsp),%xmm0
addsd  0x50(%rbx),%xmm0
movsd  %xmm0,0x50(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x18(%rbx),%xmm0
movapd (%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x38(%rbx),%xmm1
movsd  %xmm1,0x38(%rbx)
movapd 0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x58(%rbx),%xmm1
movsd  %xmm1,0x58(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x48(%rbx),%xmm1
xorpd  0xde3(%rip),%xmm1
divsd  0x28(%rbx),%xmm1
movapd %xmm1,(%rsp)
movsd  0x20(%rbx),%xmm0
mulsd  %xmm1,%xmm0
addsd  0x40(%rbx),%xmm0
movsd  %xmm0,0x40(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x28(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x48(%rbx),%xmm0
movsd  %xmm0,0x48(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x30(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x50(%rbx),%xmm0
movsd  %xmm0,0x50(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movapd (%rsp),%xmm0
mulsd  0x38(%rbx),%xmm0
addsd  0x58(%rbx),%xmm0
movsd  %xmm0,0x58(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x50(%rbx),%xmm0
movupd 0x40(%rbx),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x40(%rbx)
divsd  %xmm0,%xmm0
movsd  %xmm0,0x50(%rbx)
movsd  0x58(%rbx),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x58(%rbx)
movsd  0x20(%rbx),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x28(%rbx),%xmm0
subsd  0x48(%rbx),%xmm0
movsd  %xmm0,0x28(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x30(%rbx),%xmm0
subsd  0x50(%rbx),%xmm0
movsd  %xmm0,0x30(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x38(%rbx),%xmm0
subsd  0x58(%rbx),%xmm0
movsd  %xmm0,0x38(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x48(%rbx),%xmm0
movsd  0x20(%rbx),%xmm1
divsd  %xmm0,%xmm1
movupd 0x28(%rbx),%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,0x28(%rbx)
movsd  0x38(%rbx),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x38(%rbx)
subsd  0x40(%rbx),%xmm1
movsd  %xmm1,0x20(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x28(%rbx),%xmm0
subsd  0x48(%rbx),%xmm0
movsd  %xmm0,0x28(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x30(%rbx),%xmm0
subsd  0x50(%rbx),%xmm0
movsd  %xmm0,0x30(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x38(%rbx),%xmm0
subsd  0x58(%rbx),%xmm0
movsd  %xmm0,0x38(%rbx)
mov    %rbx,%rdi
add    $0x20,%rsp
pop    %rbx
jmp    1030 <display@plt>

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

LLVM IR (-O2):
define double @solve([4 x double]* %0) {
%2 = bitcast [4 x double]* %0 to double**
%3 = tail call i32 @display(double** %2)
%4 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 0
%5 = load double, double* %4
%6 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 0
%7 = load double, double* %6
%8 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 0
%9 = load double, double* %8
%10 = fneg double %5
%11 = fdiv double %10, %7
%12 = fneg double %9
%13 = fdiv double %12, %7
%14 = tail call double @llvm.fmuladd.f64(double %11, double %7, double %5)
store double %14, double* %4
%15 = tail call double @llvm.fmuladd.f64(double %13, double %7, double %9)
store double %15, double* %8
%16 = tail call i32 @display(double** %2)
%17 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 1
%18 = load double, double* %17
%19 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 1
%20 = load double, double* %19
%21 = tail call double @llvm.fmuladd.f64(double %11, double %20, double %18)
store double %21, double* %17
%22 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 1
%23 = load double, double* %22
%24 = tail call double @llvm.fmuladd.f64(double %13, double %20, double %23)
store double %24, double* %22
%25 = tail call i32 @display(double** %2)
%26 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 2
%27 = load double, double* %26
%28 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 2
%29 = load double, double* %28
%30 = tail call double @llvm.fmuladd.f64(double %11, double %29, double %27)
store double %30, double* %26
%31 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 2
%32 = load double, double* %31
%33 = tail call double @llvm.fmuladd.f64(double %13, double %29, double %32)
store double %33, double* %31
%34 = tail call i32 @display(double** %2)
%35 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 3
%36 = load double, double* %35
%37 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 3
%38 = load double, double* %37
%39 = tail call double @llvm.fmuladd.f64(double %11, double %38, double %36)
store double %39, double* %35
%40 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 3
%41 = load double, double* %40
%42 = tail call double @llvm.fmuladd.f64(double %13, double %38, double %41)
store double %42, double* %40
%43 = tail call i32 @display(double** %2)
%44 = load double, double* %22
%45 = load double, double* %17
%46 = fneg double %44
%47 = fdiv double %46, %45
%48 = load double, double* %4
%49 = load double, double* %8
%50 = tail call double @llvm.fmuladd.f64(double %47, double %48, double %49)
store double %50, double* %8
%51 = tail call i32 @display(double** %2)
%52 = load double, double* %17
%53 = load double, double* %22
%54 = tail call double @llvm.fmuladd.f64(double %47, double %52, double %53)
store double %54, double* %22
%55 = tail call i32 @display(double** %2)
%56 = load double, double* %26
%57 = load double, double* %31
%58 = tail call double @llvm.fmuladd.f64(double %47, double %56, double %57)
store double %58, double* %31
%59 = tail call i32 @display(double** %2)
%60 = load double, double* %35
%61 = load double, double* %40
%62 = tail call double @llvm.fmuladd.f64(double %47, double %60, double %61)
store double %62, double* %40
%63 = tail call i32 @display(double** %2)
%64 = load double, double* %31
%65 = bitcast double* %8 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = insertelement <2 x double> poison, double %64, i64 0
%68 = shufflevector <2 x double> %67, <2 x double> poison, <2 x i32> zeroinitializer
%69 = fdiv <2 x double> %66, %68
%70 = bitcast double* %8 to <2 x double>*
store <2 x double> %69, <2 x double>* %70
%71 = fdiv double %64, %64
store double %71, double* %31
%72 = load double, double* %40
%73 = fdiv double %72, %71
store double %73, double* %40
%74 = load double, double* %4
%75 = extractelement <2 x double> %69, i64 0
%76 = fsub double %74, %75
store double %76, double* %4
%77 = tail call i32 @display(double** %2)
%78 = load double, double* %17
%79 = load double, double* %22
%80 = fsub double %78, %79
store double %80, double* %17
%81 = tail call i32 @display(double** %2)
%82 = load double, double* %26
%83 = load double, double* %31
%84 = fsub double %82, %83
store double %84, double* %26
%85 = tail call i32 @display(double** %2)
%86 = load double, double* %35
%87 = load double, double* %40
%88 = fsub double %86, %87
store double %88, double* %35
%89 = tail call i32 @display(double** %2)
%90 = load double, double* %22
%91 = load double, double* %4
%92 = fdiv double %91, %90
%93 = bitcast double* %17 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = insertelement <2 x double> poison, double %90, i64 0
%96 = shufflevector <2 x double> %95, <2 x double> poison, <2 x i32> zeroinitializer
%97 = fdiv <2 x double> %94, %96
%98 = bitcast double* %17 to <2 x double>*
store <2 x double> %97, <2 x double>* %98
%99 = load double, double* %35
%100 = fdiv double %99, %90
store double %100, double* %35
%101 = load double, double* %8
%102 = fsub double %92, %101
store double %102, double* %4
%103 = tail call i32 @display(double** %2)
%104 = load double, double* %17
%105 = load double, double* %22
%106 = fsub double %104, %105
store double %106, double* %17
%107 = tail call i32 @display(double** %2)
%108 = load double, double* %26
%109 = load double, double* %31
%110 = fsub double %108, %109
store double %110, double* %26
%111 = tail call i32 @display(double** %2)
%112 = load double, double* %35
%113 = load double, double* %40
%114 = fsub double %112, %113
store double %114, double* %35
%115 = tail call i32 @display(double** %2)
ret double undef
}