#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*/ free_matrix(float **, int, int, int, int);
float **matrix(int, int, int, int);
int /*<<< orphan*/ nrerror(char *);
void bcuint(float y[], float y1[], float y2[], float y12[], float x1l,
            float x1u, float x2l, float x2u, float x1, float x2, float *ansy,
            float *ansy1, float *ansy2) {
  void bcucof(float y[], float y1[], float y2[], float y12[], float d1,
              float d2, float **c);
  int i;
  float t, u, d1, d2, **c;
  c = matrix(1, 4, 1, 4);
  d1 = x1u - x1l;
  d2 = x2u - x2l;
  bcucof(y, y1, y2, y12, d1, d2, c);
  if (x1u == x1l || x2u == x2l)
    nrerror("Bad input in routine bcuint");
  t = (x1 - x1l) / d1;
  u = (x2 - x2l) / d2;
  *ansy = (*ansy2) = (*ansy1) = 0.0;
  for (i = 4; i >= 1; i--) {
    *ansy = t * (*ansy) + ((c[i][4] * u + c[i][3]) * u + c[i][2]) * u + c[i][1];
    *ansy2 = t * (*ansy2) + (3.0 * c[i][4] * u + 2.0 * c[i][3]) * u + c[i][2];
    *ansy1 = u * (*ansy1) + (3.0 * c[4][i] * t + 2.0 * c[3][i]) * t + c[2][i];
  }
  *ansy1 /= d1;
  *ansy2 /= d2;
  free_matrix(c, 1, 4, 1, 4);
}


x86 assembly (clang, -O0):
<bcuint>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
movss  %xmm3,-0x30(%rbp)
movss  %xmm4,-0x34(%rbp)
movss  %xmm5,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    $0x1,%edx
mov    $0x4,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1050 <matrix@plt>
mov    %rax,-0x68(%rbp)
movss  -0x28(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
movss  -0x58(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
mov    -0x68(%rbp),%r8
call   1060 <bcucof@plt>
movss  -0x28(%rbp),%xmm0
ucomiss -0x24(%rbp),%xmm0
jne    11f4 <bcuint+0xb4>
jp     11f4 <bcuint+0xb4>
jmp    1209 <bcuint+0xc9>
movss  -0x30(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jne    1215 <bcuint+0xd5>
jp     1215 <bcuint+0xd5>
lea    0xe00(%rip),%rdi
call   1040 <nrerror@plt>
movss  -0x34(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
divss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
divss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x4,-0x4c(%rbp)
cmpl   $0x1,-0x4c(%rbp)
jl     1431 <bcuint+0x2f1>
movss  -0x50(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x10(%rax),%xmm1
movss  -0x54(%rbp),%xmm4
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0xc(%rax),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x54(%rbp),%xmm4
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xceb(%rip),%xmm0
mulsd  %xmm2,%xmm0
movss  -0x54(%rbp),%xmm2
cvtss2sd %xmm2,%xmm3
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0xc(%rax),%xmm2
cvtss2sd %xmm2,%xmm4
movsd  0xcb9(%rip),%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movss  -0x54(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x68(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xc51(%rip),%xmm0
mulsd  %xmm2,%xmm0
movss  -0x50(%rbp),%xmm2
cvtss2sd %xmm2,%xmm3
mov    -0x68(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm4
movsd  0xc1f(%rip),%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movss  -0x50(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1265 <bcuint+0x125>
movss  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x4,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bcuint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%rbx
mov    %r8,%r14
movss  %xmm5,0x24(%rsp)
movss  %xmm4,0x20(%rsp)
movss  %xmm3,0x8(%rsp)
movss  %xmm2,(%rsp)
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x4(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rsi,%rbp
mov    %rdi,%r12
mov    0x60(%rsp),%r13
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
mov    $0x4,%ecx
call   1050 <matrix@plt>
mov    %rax,%r15
movss  0xc(%rsp),%xmm0
subss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
subss  (%rsp),%xmm1
mov    %r12,%rdi
mov    %rbp,%rsi
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rcx
movss  %xmm0,0x10(%rsp)
movss  %xmm1,0x18(%rsp)
mov    %rax,%r8
call   1060 <bcucof@plt>
movss  (%rsp),%xmm0
movss  0xc(%rsp),%xmm1
ucomiss 0x4(%rsp),%xmm1
jne    11f7 <bcuint+0xb7>
jnp    1204 <bcuint+0xc4>
movss  0x8(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1215 <bcuint+0xd5>
jp     1215 <bcuint+0xd5>
lea    0xdfd(%rip),%rdi
call   1040 <nrerror@plt>
movss  (%rsp),%xmm0
movss  0x20(%rsp),%xmm2
subss  0x4(%rsp),%xmm2
movss  0x10(%rsp),%xmm10
divss  %xmm10,%xmm2
movss  0x24(%rsp),%xmm7
subss  %xmm0,%xmm7
movss  0x18(%rsp),%xmm9
divss  %xmm9,%xmm7
movl   $0x0,(%rbx)
movl   $0x0,0x0(%r13)
movl   $0x0,(%r14)
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
mov    0x20(%r15),%rax
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mov    0x10(%r15),%rcx
mov    0x18(%r15),%rdx
mov    $0x4,%esi
xorps  %xmm3,%xmm3
movsd  0xd7d(%rip),%xmm8
mov    %rax,%rdi
cs nopw 0x0(%rax,%rax,1)
movss  0x10(%rdi),%xmm4
mulss  %xmm7,%xmm4
addss  0xc(%rdi),%xmm4
mulss  %xmm7,%xmm4
addss  0x8(%rdi),%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
addss  0x4(%rdi),%xmm3
movss  %xmm3,(%r14)
movss  0x0(%r13),%xmm3
mulss  %xmm2,%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x10(%rdi),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm8,%xmm4
movss  0x8(%rdi),%xmm5
movss  0xc(%rdi),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm6,%xmm6
mulsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0x0(%r13)
movss  (%rbx),%xmm3
mulss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%rax,%rsi,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm8,%xmm4
movss  (%rdx,%rsi,4),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm5,%xmm5
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movss  (%rcx,%rsi,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,(%rbx)
cmp    $0x2,%rsi
jb     1375 <bcuint+0x235>
movss  (%r14),%xmm3
mov    -0x8(%r15,%rsi,8),%rdi
add    $0xffffffffffffffff,%rsi
jmp    1290 <bcuint+0x150>
divss  %xmm10,%xmm3
movss  %xmm3,(%rbx)
movss  0x0(%r13),%xmm0
divss  %xmm9,%xmm0
movss  %xmm0,0x0(%r13)
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x4,%edx
mov    $0x1,%ecx
mov    $0x4,%r8d
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_matrix@plt>

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

LLVM IR (-O2):
@.str = [28 x i8] c"Bad input in routine bcuint\00"
define void @bcuint(float* %0, float* %1, float* %2, float* %3, float %4, float %5, float %6, float %7, float %8, float %9, float* nocapture %10, float* nocapture %11, float* nocapture %12) {
%14 = tail call float** @matrix(i32 1, i32 4, i32 1, i32 4)
%15 = fsub float %5, %4
%16 = fsub float %7, %6
tail call void @bcucof(float* %0, float* %1, float* %2, float* %3, float %15, float %16, float** %14)
%17 = fcmp oeq float %5, %4
%18 = fcmp oeq float %7, %6
%19 = or i1 %17, %18
br i1 %19, label %20, label %22
20: ; preds = %13
%21 = tail call i32 @nrerror(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
br label %22
22: ; preds = %13, %20
%23 = fsub float %8, %4
%24 = fdiv float %23, %15
%25 = fsub float %9, %6
%26 = fdiv float %25, %16
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %10
%27 = fpext float %26 to double
%28 = getelementptr inbounds float*, float** %14, i64 4
%29 = load float*, float** %28
%30 = fpext float %24 to double
%31 = getelementptr inbounds float*, float** %14, i64 3
%32 = load float*, float** %31
%33 = getelementptr inbounds float*, float** %14, i64 2
%34 = load float*, float** %33
br label %35
35: ; preds = %87, %22
%36 = phi float* [ %29, %22 ], [ %90, %87 ]
%37 = phi float [ 0.000000e+00, %22 ], [ %88, %87 ]
%38 = phi i64 [ 4, %22 ], [ %85, %87 ]
%39 = getelementptr inbounds float, float* %36, i64 4
%40 = load float, float* %39
%41 = getelementptr inbounds float, float* %36, i64 3
%42 = load float, float* %41
%43 = tail call float @llvm.fmuladd.f32(float %40, float %26, float %42)
%44 = getelementptr inbounds float, float* %36, i64 2
%45 = load float, float* %44
%46 = tail call float @llvm.fmuladd.f32(float %43, float %26, float %45)
%47 = fmul float %26, %46
%48 = tail call float @llvm.fmuladd.f32(float %24, float %37, float %47)
%49 = getelementptr inbounds float, float* %36, i64 1
%50 = load float, float* %49
%51 = fadd float %50, %48
store float %51, float* %10
%52 = load float, float* %12
%53 = fmul float %24, %52
%54 = fpext float %53 to double
%55 = load float, float* %39
%56 = fpext float %55 to double
%57 = fmul double %56, 3.000000e+00
%58 = load float, float* %41
%59 = fpext float %58 to double
%60 = fmul double %59, 2.000000e+00
%61 = tail call double @llvm.fmuladd.f64(double %57, double %27, double %60)
%62 = tail call double @llvm.fmuladd.f64(double %61, double %27, double %54)
%63 = load float, float* %44
%64 = fpext float %63 to double
%65 = fadd double %62, %64
%66 = fptrunc double %65 to float
store float %66, float* %12
%67 = load float, float* %11
%68 = fmul float %26, %67
%69 = fpext float %68 to double
%70 = getelementptr inbounds float, float* %29, i64 %38
%71 = load float, float* %70
%72 = fpext float %71 to double
%73 = fmul double %72, 3.000000e+00
%74 = getelementptr inbounds float, float* %32, i64 %38
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = fmul double %76, 2.000000e+00
%78 = tail call double @llvm.fmuladd.f64(double %73, double %30, double %77)
%79 = tail call double @llvm.fmuladd.f64(double %78, double %30, double %69)
%80 = getelementptr inbounds float, float* %34, i64 %38
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = fadd double %79, %82
%84 = fptrunc double %83 to float
store float %84, float* %11
%85 = add nsw i64 %38, -1
%86 = icmp ugt i64 %38, 1
br i1 %86, label %87, label %91
87: ; preds = %35
%88 = load float, float* %10
%89 = getelementptr inbounds float*, float** %14, i64 %85
%90 = load float*, float** %89
br label %35
91: ; preds = %35
%92 = fdiv float %84, %15
store float %92, float* %11
%93 = load float, float* %12
%94 = fdiv float %93, %16
store float %94, float* %12
%95 = tail call i32 @free_matrix(float** %14, i32 1, i32 4, i32 1, i32 4)
ret void
}