#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);
  }
  for (int j = 1; j < 3; j++) {
    t = coef[3 - j][j] / coef[j][j];
    for (int i = 0; i < 4; i++) {
      coef[3 - j][i] -= (t * coef[j][i]);
      display(coef);
    }
  }
  for (int i = 2; i > 0; i--) {
    t = coef[0][i] / coef[i][i];
    for (int j = 0; j < 4; j++) {
      coef[0][j] -= (t * coef[i][j]);
      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>
movl   $0x1,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    12fb <solve+0x1eb>
mov    -0x10(%rbp),%rax
mov    $0x3,%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    12e8 <solve+0x1d8>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    $0x3,%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x2c(%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    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1267 <solve+0x157>
jmp    12ed <solve+0x1dd>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    121a <solve+0x10a>
movl   $0x2,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    13bf <solve+0x2af>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    13ac <solve+0x29c>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x34(%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    -0x10(%rbp),%rdi
call   1030 <display@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133d <solve+0x22d>
jmp    13b1 <solve+0x2a1>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1302 <solve+0x1f2>
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  0x30(%rbx),%xmm1
xorpd  0xd5d(%rip),%xmm1
divsd  0x50(%rbx),%xmm1
movapd %xmm1,(%rsp)
movsd  0x40(%rbx),%xmm0
mulsd  %xmm1,%xmm0
addsd  0x20(%rbx),%xmm0
movsd  %xmm0,0x20(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x48(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x28(%rbx),%xmm0
movsd  %xmm0,0x28(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x50(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x30(%rbx),%xmm0
movsd  %xmm0,0x30(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movapd (%rsp),%xmm0
mulsd  0x58(%rbx),%xmm0
addsd  0x38(%rbx),%xmm0
movsd  %xmm0,0x38(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x10(%rbx),%xmm1
xorpd  0xcd7(%rip),%xmm1
divsd  0x50(%rbx),%xmm1
movapd %xmm1,(%rsp)
movsd  0x40(%rbx),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x48(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x8(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x50(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movapd (%rsp),%xmm0
mulsd  0x58(%rbx),%xmm0
addsd  0x18(%rbx),%xmm0
movsd  %xmm0,0x18(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x8(%rbx),%xmm1
xorpd  0xc53(%rip),%xmm1
divsd  0x28(%rbx),%xmm1
movapd %xmm1,(%rsp)
movsd  0x20(%rbx),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x28(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x8(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movsd  0x30(%rbx),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rbx)
mov    %rbx,%rdi
call   1030 <display@plt>
movapd (%rsp),%xmm0
mulsd  0x38(%rbx),%xmm0
addsd  0x18(%rbx),%xmm0
movsd  %xmm0,0x18(%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
store i32 1, i32* %7
br label %83
83: ; preds = %136, %82
%84 = load i32, i32* %7
%85 = icmp slt i32 %84, 3
br i1 %85, label %86, label %139
86: ; preds = %83
%87 = load [4 x double]*, [4 x double]** %3
%88 = load i32, i32* %7
%89 = sub nsw i32 3, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [4 x double], [4 x double]* %87, i64 %90
%92 = load i32, i32* %7
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [4 x double], [4 x double]* %91, i64 0, i64 %93
%95 = load double, double* %94
%96 = load [4 x double]*, [4 x double]** %3
%97 = load i32, i32* %7
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [4 x double], [4 x double]* %96, i64 %98
%100 = load i32, i32* %7
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [4 x double], [4 x double]* %99, i64 0, i64 %101
%103 = load double, double* %102
%104 = fdiv double %95, %103
store double %104, double* %4
store i32 0, i32* %8
br label %105
105: ; preds = %132, %86
%106 = load i32, i32* %8
%107 = icmp slt i32 %106, 4
br i1 %107, label %108, label %135
108: ; preds = %105
%109 = load double, double* %4
%110 = load [4 x double]*, [4 x double]** %3
%111 = load i32, i32* %7
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [4 x double], [4 x double]* %110, i64 %112
%114 = load i32, i32* %8
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [4 x double], [4 x double]* %113, i64 0, i64 %115
%117 = load double, double* %116
%118 = load [4 x double]*, [4 x double]** %3
%119 = load i32, i32* %7
%120 = sub nsw i32 3, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [4 x double], [4 x double]* %118, i64 %121
%123 = load i32, i32* %8
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [4 x double], [4 x double]* %122, i64 0, i64 %124
%126 = load double, double* %125
%127 = fneg double %109
%128 = call double @llvm.fmuladd.f64(double %127, double %117, double %126)
store double %128, double* %125
%129 = load [4 x double]*, [4 x double]** %3
%130 = bitcast [4 x double]* %129 to double**
%131 = call i32 @display(double** %130)
br label %132
132: ; preds = %108
%133 = load i32, i32* %8
%134 = add nsw i32 %133, 1
store i32 %134, i32* %8
br label %105
135: ; preds = %105
br label %136
136: ; preds = %135
%137 = load i32, i32* %7
%138 = add nsw i32 %137, 1
store i32 %138, i32* %7
br label %83
139: ; preds = %83
store i32 2, i32* %9
br label %140
140: ; preds = %187, %139
%141 = load i32, i32* %9
%142 = icmp sgt i32 %141, 0
br i1 %142, label %143, label %190
143: ; preds = %140
%144 = load [4 x double]*, [4 x double]** %3
%145 = getelementptr inbounds [4 x double], [4 x double]* %144, i64 0
%146 = load i32, i32* %9
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [4 x double], [4 x double]* %145, i64 0, i64 %147
%149 = load double, double* %148
%150 = load [4 x double]*, [4 x double]** %3
%151 = load i32, i32* %9
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [4 x double], [4 x double]* %150, i64 %152
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [4 x double], [4 x double]* %153, i64 0, i64 %155
%157 = load double, double* %156
%158 = fdiv double %149, %157
store double %158, double* %4
store i32 0, i32* %10
br label %159
159: ; preds = %183, %143
%160 = load i32, i32* %10
%161 = icmp slt i32 %160, 4
br i1 %161, label %162, label %186
162: ; preds = %159
%163 = load double, double* %4
%164 = load [4 x double]*, [4 x double]** %3
%165 = load i32, i32* %9
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [4 x double], [4 x double]* %164, i64 %166
%168 = load i32, i32* %10
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [4 x double], [4 x double]* %167, i64 0, i64 %169
%171 = load double, double* %170
%172 = load [4 x double]*, [4 x double]** %3
%173 = getelementptr inbounds [4 x double], [4 x double]* %172, i64 0
%174 = load i32, i32* %10
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [4 x double], [4 x double]* %173, i64 0, i64 %175
%177 = load double, double* %176
%178 = fneg double %163
%179 = call double @llvm.fmuladd.f64(double %178, double %171, double %177)
store double %179, double* %176
%180 = load [4 x double]*, [4 x double]** %3
%181 = bitcast [4 x double]* %180 to double**
%182 = call i32 @display(double** %181)
br label %183
183: ; preds = %162
%184 = load i32, i32* %10
%185 = add nsw i32 %184, 1
store i32 %185, i32* %10
br label %159
186: ; preds = %159
br label %187
187: ; preds = %186
%188 = load i32, i32* %9
%189 = add nsw i32 %188, -1
store i32 %189, i32* %9
br label %140
190: ; preds = %140
%191 = load double, double* %2
ret double %191
}

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* %26
%65 = load double, double* %31
%66 = fneg double %64
%67 = fdiv double %66, %65
%68 = load double, double* %8
%69 = load double, double* %4
%70 = tail call double @llvm.fmuladd.f64(double %67, double %68, double %69)
store double %70, double* %4
%71 = tail call i32 @display(double** %2)
%72 = load double, double* %22
%73 = load double, double* %17
%74 = tail call double @llvm.fmuladd.f64(double %67, double %72, double %73)
store double %74, double* %17
%75 = tail call i32 @display(double** %2)
%76 = load double, double* %31
%77 = load double, double* %26
%78 = tail call double @llvm.fmuladd.f64(double %67, double %76, double %77)
store double %78, double* %26
%79 = tail call i32 @display(double** %2)
%80 = load double, double* %40
%81 = load double, double* %35
%82 = tail call double @llvm.fmuladd.f64(double %67, double %80, double %81)
store double %82, double* %35
%83 = tail call i32 @display(double** %2)
%84 = load double, double* %28
%85 = load double, double* %31
%86 = fneg double %84
%87 = fdiv double %86, %85
%88 = load double, double* %8
%89 = load double, double* %6
%90 = tail call double @llvm.fmuladd.f64(double %87, double %88, double %89)
store double %90, double* %6
%91 = tail call i32 @display(double** %2)
%92 = load double, double* %22
%93 = load double, double* %19
%94 = tail call double @llvm.fmuladd.f64(double %87, double %92, double %93)
store double %94, double* %19
%95 = tail call i32 @display(double** %2)
%96 = load double, double* %31
%97 = load double, double* %28
%98 = tail call double @llvm.fmuladd.f64(double %87, double %96, double %97)
store double %98, double* %28
%99 = tail call i32 @display(double** %2)
%100 = load double, double* %40
%101 = load double, double* %37
%102 = tail call double @llvm.fmuladd.f64(double %87, double %100, double %101)
store double %102, double* %37
%103 = tail call i32 @display(double** %2)
%104 = load double, double* %19
%105 = load double, double* %17
%106 = fneg double %104
%107 = fdiv double %106, %105
%108 = load double, double* %4
%109 = load double, double* %6
%110 = tail call double @llvm.fmuladd.f64(double %107, double %108, double %109)
store double %110, double* %6
%111 = tail call i32 @display(double** %2)
%112 = load double, double* %17
%113 = load double, double* %19
%114 = tail call double @llvm.fmuladd.f64(double %107, double %112, double %113)
store double %114, double* %19
%115 = tail call i32 @display(double** %2)
%116 = load double, double* %26
%117 = load double, double* %28
%118 = tail call double @llvm.fmuladd.f64(double %107, double %116, double %117)
store double %118, double* %28
%119 = tail call i32 @display(double** %2)
%120 = load double, double* %35
%121 = load double, double* %37
%122 = tail call double @llvm.fmuladd.f64(double %107, double %120, double %121)
store double %122, double* %37
%123 = tail call i32 @display(double** %2)
ret double undef
}