#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 */
double fabs(float);
int /*<<< orphan*/ free_vector(float *, int /*<<< orphan*/, int);
int /*<<< orphan*/ nrerror(char *);
float *vector(int /*<<< orphan*/, int);
void qroot(float p[], int n, float *b, float *c, float eps) {
  void poldiv(float u[], int n, float v[], int nv, float q[], float r[]);
  int iter;
  float sc, sb, s, rc, rb, r, dv, delc, delb;
  float *q, *qq, *rem;
  float d[3];
  q = vector(0, n);
  qq = vector(0, n);
  rem = vector(0, n);
  d[2] = 1.0;
  for (iter = 1; iter <= 20; iter++) {
    d[1] = (*b);
    d[0] = (*c);
    poldiv(p, n, d, 2, q, rem);
    s = rem[0];
    r = rem[1];
    poldiv(q, (n - 1), d, 2, qq, rem);
    sb = -(*c) * (rc = -rem[1]);
    rb = -(*b) * rc + (sc = -rem[0]);
    dv = 1.0 / (sb * rc - sc * rb);
    delb = (r * sc - s * rc) * dv;
    delc = (-r * sb + s * rb) * dv;
    *b += (delb = (r * sc - s * rc) * dv);
    *c += (delc = (-r * sb + s * rb) * dv);
    if ((fabs(delb) <= eps * fabs(*b) || fabs(*b) < 1.0e-6) &&
        (fabs(delc) <= eps * fabs(*c) || fabs(*c) < 1.0e-6)) {
      free_vector(rem, 0, n);
      free_vector(qq, 0, n);
      free_vector(q, 0, n);
      return;
    }
  }
  nrerror("Too many iterations in routine qroot");
}


x86 assembly (clang, -O0):
<qroot>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    -0xc(%rbp),%esi
xor    %edi,%edi
call   1070 <vector@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%esi
xor    %edi,%edi
call   1070 <vector@plt>
mov    %rax,-0x60(%rbp)
mov    -0xc(%rbp),%esi
xor    %edi,%edi
call   1070 <vector@plt>
mov    %rax,-0x68(%rbp)
movss  0xe5f(%rip),%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x1,-0x28(%rbp)
cmpl   $0x14,-0x28(%rbp)
jg     14eb <qroot+0x39b>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
lea    -0x74(%rbp),%rdx
mov    -0x58(%rbp),%r8
mov    -0x68(%rbp),%r9
mov    $0x2,%ecx
call   1030 <poldiv@plt>
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x68(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
lea    -0x74(%rbp),%rdx
mov    -0x60(%rbp),%r8
mov    -0x68(%rbp),%r9
mov    $0x2,%ecx
call   1030 <poldiv@plt>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x68(%rbp),%rax
movss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  %xmm1,-0x38(%rbp)
mulss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x38(%rbp),%xmm2
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  %xmm1,-0x2c(%rbp)
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd30(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
call   1060 <fabs@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <fabs@plt>
movsd  -0x88(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x80(%rbp),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jae    1436 <qroot+0x2e6>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xbe4(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    14d8 <qroot+0x388>
movss  -0x48(%rbp),%xmm0
call   1060 <fabs@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <fabs@plt>
movsd  -0x98(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jae    14a9 <qroot+0x359>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xb71(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    14d8 <qroot+0x388>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1050 <free_vector@plt>
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1050 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1050 <free_vector@plt>
jmp    14f7 <qroot+0x3a7>
jmp    14dd <qroot+0x38d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ad <qroot+0x5d>
lea    0xb26(%rip),%rdi
call   1040 <nrerror@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qroot>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movss  %xmm0,0x8(%rsp)
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %esi,%ebp
mov    %rdi,0x40(%rsp)
xor    %edi,%edi
call   1070 <vector@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %ebp,%esi
call   1070 <vector@plt>
mov    %rax,0x20(%rsp)
xor    %edi,%edi
mov    %ebp,%esi
call   1070 <vector@plt>
mov    %rax,%r13
movl   $0x3f800000,0x3c(%rsp)
3f
mov    %rbp,0x18(%rsp)
lea    -0x1(%rbp),%eax
mov    %eax,0x14(%rsp)
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    $0x14,%ebp
jmp    11c9 <qroot+0x79>
add    $0xffffffff,%ebp
je     136e <qroot+0x21e>
movss  (%r12),%xmm0
movss  %xmm0,0x38(%rsp)
movss  (%rbx),%xmm0
movss  %xmm0,0x34(%rsp)
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%rsi
lea    0x34(%rsp),%r14
mov    %r14,%rdx
mov    $0x2,%ecx
mov    %r15,%r8
mov    %r13,%r9
call   1030 <poldiv@plt>
movss  0x0(%r13),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x4(%r13),%xmm0
movss  %xmm0,0x10(%rsp)
mov    %r15,%rdi
mov    0x14(%rsp),%esi
mov    %r14,%rdx
mov    $0x2,%ecx
mov    0x20(%rsp),%r8
mov    %r13,%r9
call   1030 <poldiv@plt>
movss  0x0(%r13),%xmm1
movss  0x4(%r13),%xmm0
movss  (%rbx),%xmm2
mulss  %xmm0,%xmm2
movss  (%r12),%xmm3
movaps %xmm3,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm1,%xmm5
movss  0x10(%rsp),%xmm6
movaps %xmm6,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm5,%xmm1
mulss  %xmm2,%xmm6
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  0xd81(%rip),%xmm2
divss  %xmm1,%xmm2
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm0
subss  %xmm4,%xmm0
mulss  %xmm1,%xmm5
subss  %xmm6,%xmm5
mulss  %xmm2,%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,(%r12)
mulss  %xmm2,%xmm5
movss  (%rbx),%xmm1
movss  %xmm5,0x10(%rsp)
addss  %xmm5,%xmm1
movss  %xmm1,(%rbx)
call   1060 <fabs@plt>
movsd  %xmm0,0x8(%rsp)
movss  (%r12),%xmm0
call   1060 <fabs@plt>
mulsd  0x28(%rsp),%xmm0
ucomisd 0x8(%rsp),%xmm0
jae    12fe <qroot+0x1ae>
movss  (%r12),%xmm0
call   1060 <fabs@plt>
movsd  0xd14(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    11c0 <qroot+0x70>
movss  0x10(%rsp),%xmm0
call   1060 <fabs@plt>
movsd  %xmm0,0x8(%rsp)
movss  (%rbx),%xmm0
call   1060 <fabs@plt>
mulsd  0x28(%rsp),%xmm0
ucomisd 0x8(%rsp),%xmm0
jae    1341 <qroot+0x1f1>
movss  (%rbx),%xmm0
call   1060 <fabs@plt>
movsd  0xcd1(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    11c0 <qroot+0x70>
mov    %r13,%rdi
xor    %esi,%esi
mov    0x18(%rsp),%rbx
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    %r15,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
jmp    137a <qroot+0x22a>
lea    0xc9b(%rip),%rdi
call   1040 <nrerror@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [37 x i8] c"Too many iterations in routine qroot\00"
define void @qroot(float* %0, i32 %1, float* nocapture %2, float* nocapture %3, float %4) {
%6 = alloca [3 x float]
%7 = bitcast [3 x float]* %6 to i8*
%8 = tail call float* @vector(i32 0, i32 %1)
%9 = tail call float* @vector(i32 0, i32 %1)
%10 = tail call float* @vector(i32 0, i32 %1)
%11 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 2
store float 1.000000e+00, float* %11
%12 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 1
%13 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 0
%14 = getelementptr inbounds float, float* %10, i64 1
%15 = add nsw i32 %1, -1
%16 = fpext float %4 to double
br label %17
17: ; preds = %5, %67
%18 = phi i32 [ 1, %5 ], [ %68, %67 ]
%19 = load float, float* %2
store float %19, float* %12
%20 = load float, float* %3
store float %20, float* %13
%21 = load float, float* %10
%22 = load float, float* %14
%23 = load float, float* %3
%24 = load float, float* %14
%25 = fneg float %24
%26 = fmul float %23, %24
%27 = load float, float* %2
%28 = load float, float* %10
%29 = fneg float %28
%30 = call float @llvm.fmuladd.f32(float %27, float %24, float %29)
%31 = fmul float %28, %30
%32 = call float @llvm.fmuladd.f32(float %26, float %25, float %31)
%33 = fdiv float 1.000000e+00, %32
%34 = fmul float %21, %24
%35 = call float @llvm.fmuladd.f32(float %22, float %29, float %34)
%36 = fneg float %22
%37 = fmul float %21, %30
%38 = call float @llvm.fmuladd.f32(float %36, float %26, float %37)
%39 = fmul float %35, %33
%40 = fadd float %27, %39
store float %40, float* %2
%41 = fmul float %38, %33
%42 = load float, float* %3
%43 = fadd float %42, %41
store float %43, float* %3
%44 = call double @fabs(float %39)
%45 = load float, float* %2
%46 = call double @fabs(float %45)
%47 = fmul double %46, %16
%48 = fcmp ugt double %44, %47
br i1 %48, label %49, label %53
49: ; preds = %17
%50 = load float, float* %2
%51 = call double @fabs(float %50)
%52 = fcmp olt double %51, 0x3EB0C6F7A0B5ED8D
br i1 %52, label %53, label %67
53: ; preds = %49, %17
%54 = call double @fabs(float %41)
%55 = load float, float* %3
%56 = call double @fabs(float %55)
%57 = fmul double %56, %16
%58 = fcmp ugt double %54, %57
br i1 %58, label %59, label %63
59: ; preds = %53
%60 = load float, float* %3
%61 = call double @fabs(float %60)
%62 = fcmp olt double %61, 0x3EB0C6F7A0B5ED8D
br i1 %62, label %63, label %67
63: ; preds = %59, %53
%64 = call i32 @free_vector(float* %10, i32 0, i32 %1)
%65 = call i32 @free_vector(float* %9, i32 0, i32 %1)
%66 = call i32 @free_vector(float* %8, i32 0, i32 %1)
br label %72
67: ; preds = %49, %59
%68 = add nuw nsw i32 %18, 1
%69 = icmp eq i32 %68, 21
br i1 %69, label %70, label %17
70: ; preds = %67
%71 = call i32 @nrerror(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0))
br label %72
72: ; preds = %70, %63
ret void
}