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