#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*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, float *, float *);
int main(void) {
  float a = 0, b = 0, mid = 0;
  printf("\nf(x) = (x*x - x - 6)");
  do {
    printf("\nEnter values of lower limit and upper limit respectively.\n");
    scanf("%f %f", &a, &b);
    if ((a * a - a - 6) * (b * b - b - 6) > 0) {
      printf("f(%f) = %f;\nf(%f) = %f\n", a, (a * a - a - 6), b,
             (b * b - b - 6));
      printf("There is no root possible within the two points provided. Please "
             "try again.\n");
    }
  } while ((a * a - a - 6) * (b * b - b - 6) > 0);
  printf("       a\t|       b\t|   m=(a+b)/2\t|     f(m)\t|\n");
  printf("----------------------------------------------------------------\n");
  do {
    mid = (a + b) * 0.5;
    printf("%11f\t|%11f\t|%11f\t|%12f\t|\n", a, b, mid, (mid * mid - mid - 6));
    if ((mid * mid - mid - 6) < 0.0000005 && (mid * mid - mid - 6) > -0.0000005)
      break;
    else if ((mid * mid - mid - 6) * (a * a - a - 6) > 0)
      a = mid;
    else
      b = mid;
  } while (fabs(a - b) > 0.0000005);
  mid = (a + b) * 0.5;
  printf("\n\tThe root is: %f\n", mid);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
lea    0xec2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xef8(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
call   1050 <scanf@plt>
movss  -0x8(%rbp),%xmm0
movss  -0x8(%rbp),%xmm2
movss  -0x8(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xe4d(%rip),%xmm1
subss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
movss  -0xc(%rbp),%xmm3
movss  -0xc(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0xe1d(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    128d <main+0x15d>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
movss  -0x8(%rbp),%xmm3
movss  -0x8(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0xdd4(%rip),%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0xc(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0xc(%rbp),%xmm3
movss  -0xc(%rbp),%xmm5
movss  -0xc(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  0xd97(%rip),%xmm4
subss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xe00(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xe0a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1292 <main+0x162>
movss  -0x8(%rbp),%xmm0
movss  -0x8(%rbp),%xmm2
movss  -0x8(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xd42(%rip),%xmm1
subss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
movss  -0xc(%rbp),%xmm3
movss  -0xc(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0xd12(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1165 <main+0x35>
lea    0xdd4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdf5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x8(%rbp),%xmm0
addss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcdc(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x10(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x10(%rbp),%xmm3
movss  -0x10(%rbp),%xmm5
movss  -0x10(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  0xc78(%rip),%xmm4
subss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xdb7(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
movss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xc36(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc2e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    142f <main+0x2ff>
movss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xbf0(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbf8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    142f <main+0x2ff>
jmp    14e3 <main+0x3b3>
movss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xba5(%rip),%xmm1
subss  %xmm1,%xmm0
movss  -0x8(%rbp),%xmm1
movss  -0x8(%rbp),%xmm3
movss  -0x8(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0xb75(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14ae <main+0x37e>
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
jmp    14b8 <main+0x388>
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
jmp    14bd <main+0x38d>
jmp    14c2 <main+0x392>
movss  -0x8(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
call   1040 <fabs@plt>
movsd  0xb2f(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     131e <main+0x1ee>
movss  -0x8(%rbp),%xmm0
addss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb17(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc52(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movl   $0x0,0x4(%rsp)
movl   $0x0,(%rsp)
lea    0xecc(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf1f(%rip),%r14
lea    0xecd(%rip),%r15
lea    0x4(%rsp),%r12
mov    %rsp,%rbx
lea    0xec4(%rip),%r13
lea    0xfac(%rip),%rbp
jmp    11a9 <main+0x69>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomiss %xmm5,%xmm4
jbe    1249 <main+0x109>
mov    %r14,%rdi
call   1030 <puts@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %rbx,%rdx
call   1060 <scanf@plt>
xorps  %xmm5,%xmm5
movss  0x4(%rsp),%xmm0
movss  (%rsp),%xmm2
movaps %xmm0,%xmm3
unpcklps %xmm2,%xmm3
movaps %xmm3,%xmm1
mulps  %xmm3,%xmm1
subps  %xmm3,%xmm1
addps  0xe1d(%rip),%xmm1
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
movaps %xmm1,%xmm4
mulss  %xmm3,%xmm4
ucomiss %xmm5,%xmm4
jbe    11a0 <main+0x60>
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
mov    %r13,%rdi
mov    $0x4,%al
call   1040 <printf@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
xorps  %xmm5,%xmm5
movss  (%rsp),%xmm0
movss  0x4(%rsp),%xmm1
unpcklps %xmm0,%xmm1
movaps %xmm1,%xmm0
mulps  %xmm1,%xmm0
subps  %xmm1,%xmm0
addps  0xdc7(%rip),%xmm0
movaps %xmm0,%xmm4
shufps $0x55,%xmm0,%xmm4
mulss  %xmm0,%xmm4
jmp    11a0 <main+0x60>
lea    0xe7c(%rip),%rdi
call   1030 <puts@plt>
lea    0xe9e(%rip),%rdi
call   1030 <puts@plt>
lea    0xdfc(%rip),%rbx
jmp    1292 <main+0x152>
nopw   0x0(%rax,%rax,1)
movss  0x8(%rsp),%xmm1
movss  %xmm1,(%rsp)
subss  %xmm1,%xmm0
call   1050 <fabs@plt>
ucomisd 0xd94(%rip),%xmm0
jbe    1355 <main+0x215>
movss  0x4(%rsp),%xmm3
movss  (%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
addss  %xmm1,%xmm3
mulss  0xd60(%rip),%xmm3
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
movaps %xmm3,%xmm4
mulss  %xmm3,%xmm4
movss  %xmm3,0x8(%rsp)
subss  %xmm3,%xmm4
addss  0xd40(%rip),%xmm4
movss  %xmm4,0xc(%rsp)
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movsd  %xmm3,0x10(%rsp)
mov    %rbx,%rdi
mov    $0x4,%al
call   1040 <printf@plt>
movsd  0x10(%rsp),%xmm1
movsd  0xd21(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    130f <main+0x1cf>
ucomisd 0xd1b(%rip),%xmm1
ja     1355 <main+0x215>
movss  0x4(%rsp),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm0,%xmm1
addss  0xcec(%rip),%xmm1
movss  0xc(%rsp),%xmm2
mulss  %xmm1,%xmm2
ucomiss 0xcdf(%rip),%xmm2
jbe    1270 <main+0x130>
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  (%rsp),%xmm1
jmp    127b <main+0x13b>
movss  0x4(%rsp),%xmm0
addss  (%rsp),%xmm0
mulss  0xca8(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd0b(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [22 x i8] c"\0Af(x) = (x*x - x - 6)\00"
@.str.1 = [60 x i8] c"\0AEnter values of lower limit and upper limit respectively.\0A\00"
@.str.2 = [6 x i8] c"%f %f\00"
@.str.3 = [24 x i8] c"f(%f) = %f;\0Af(%f) = %f\0A\00"
@.str.4 = [77 x i8] c"There is no root possible within the two points provided. Please try again.\0A\00"
@.str.5 = [47 x i8] c" a\09| b\09| m=(a+b)/2\09| f(m)\09|\0A\00"
@.str.6 = [66 x i8] c"----------------------------------------------------------------\0A\00"
@.str.7 = [26 x i8] c"%11f\09|%11f\09|%11f\09|%12f\09|\0A\00"
@.str.8 = [19 x i8] c"\0A\09The root is: %f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca float
%4 = alloca float
store i32 0, i32* %1
store float 0.000000e+00, float* %2
store float 0.000000e+00, float* %3
store float 0.000000e+00, float* %4
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
br label %6
6: ; preds = %45, %0
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.1, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), float* %2, float* %3)
%9 = load float, float* %2
%10 = load float, float* %2
%11 = load float, float* %2
%12 = fneg float %11
%13 = call float @llvm.fmuladd.f32(float %9, float %10, float %12)
%14 = fsub float %13, 6.000000e+00
%15 = load float, float* %3
%16 = load float, float* %3
%17 = load float, float* %3
%18 = fneg float %17
%19 = call float @llvm.fmuladd.f32(float %15, float %16, float %18)
%20 = fsub float %19, 6.000000e+00
%21 = fmul float %14, %20
%22 = fcmp ogt float %21, 0.000000e+00
br i1 %22, label %23, label %44
23: ; preds = %6
%24 = load float, float* %2
%25 = fpext float %24 to double
%26 = load float, float* %2
%27 = load float, float* %2
%28 = load float, float* %2
%29 = fneg float %28
%30 = call float @llvm.fmuladd.f32(float %26, float %27, float %29)
%31 = fsub float %30, 6.000000e+00
%32 = fpext float %31 to double
%33 = load float, float* %3
%34 = fpext float %33 to double
%35 = load float, float* %3
%36 = load float, float* %3
%37 = load float, float* %3
%38 = fneg float %37
%39 = call float @llvm.fmuladd.f32(float %35, float %36, float %38)
%40 = fsub float %39, 6.000000e+00
%41 = fpext float %40 to double
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), double %25, double %32, double %34, double %41)
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.4, i64 0, i64 0))
br label %44
44: ; preds = %23, %6
br label %45
45: ; preds = %44
%46 = load float, float* %2
%47 = load float, float* %2
%48 = load float, float* %2
%49 = fneg float %48
%50 = call float @llvm.fmuladd.f32(float %46, float %47, float %49)
%51 = fsub float %50, 6.000000e+00
%52 = load float, float* %3
%53 = load float, float* %3
%54 = load float, float* %3
%55 = fneg float %54
%56 = call float @llvm.fmuladd.f32(float %52, float %53, float %55)
%57 = fsub float %56, 6.000000e+00
%58 = fmul float %51, %57
%59 = fcmp ogt float %58, 0.000000e+00
br i1 %59, label %6, label %60
60: ; preds = %45
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.5, i64 0, i64 0))
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.6, i64 0, i64 0))
br label %63
63: ; preds = %123, %60
%64 = load float, float* %2
%65 = load float, float* %3
%66 = fadd float %64, %65
%67 = fpext float %66 to double
%68 = fmul double %67, 5.000000e-01
%69 = fptrunc double %68 to float
store float %69, float* %4
%70 = load float, float* %2
%71 = fpext float %70 to double
%72 = load float, float* %3
%73 = fpext float %72 to double
%74 = load float, float* %4
%75 = fpext float %74 to double
%76 = load float, float* %4
%77 = load float, float* %4
%78 = load float, float* %4
%79 = fneg float %78
%80 = call float @llvm.fmuladd.f32(float %76, float %77, float %79)
%81 = fsub float %80, 6.000000e+00
%82 = fpext float %81 to double
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), double %71, double %73, double %75, double %82)
%84 = load float, float* %4
%85 = load float, float* %4
%86 = load float, float* %4
%87 = fneg float %86
%88 = call float @llvm.fmuladd.f32(float %84, float %85, float %87)
%89 = fsub float %88, 6.000000e+00
%90 = fpext float %89 to double
%91 = fcmp olt double %90, 5.000000e-07
br i1 %91, label %92, label %102
92: ; preds = %63
%93 = load float, float* %4
%94 = load float, float* %4
%95 = load float, float* %4
%96 = fneg float %95
%97 = call float @llvm.fmuladd.f32(float %93, float %94, float %96)
%98 = fsub float %97, 6.000000e+00
%99 = fpext float %98 to double
%100 = fcmp ogt double %99, -5.000000e-07
br i1 %100, label %101, label %102
101: ; preds = %92
br label %129
102: ; preds = %92, %63
%103 = load float, float* %4
%104 = load float, float* %4
%105 = load float, float* %4
%106 = fneg float %105
%107 = call float @llvm.fmuladd.f32(float %103, float %104, float %106)
%108 = fsub float %107, 6.000000e+00
%109 = load float, float* %2
%110 = load float, float* %2
%111 = load float, float* %2
%112 = fneg float %111
%113 = call float @llvm.fmuladd.f32(float %109, float %110, float %112)
%114 = fsub float %113, 6.000000e+00
%115 = fmul float %108, %114
%116 = fcmp ogt float %115, 0.000000e+00
br i1 %116, label %117, label %119
117: ; preds = %102
%118 = load float, float* %4
store float %118, float* %2
br label %121
119: ; preds = %102
%120 = load float, float* %4
store float %120, float* %3
br label %121
121: ; preds = %119, %117
br label %122
122: ; preds = %121
br label %123
123: ; preds = %122
%124 = load float, float* %2
%125 = load float, float* %3
%126 = fsub float %124, %125
%127 = call double @fabs(float %126)
%128 = fcmp ogt double %127, 5.000000e-07
br i1 %128, label %63, label %129
129: ; preds = %123, %101
%130 = load float, float* %2
%131 = load float, float* %3
%132 = fadd float %130, %131
%133 = fpext float %132 to double
%134 = fmul double %133, 5.000000e-01
%135 = fptrunc double %134 to float
store float %135, float* %4
%136 = load float, float* %4
%137 = fpext float %136 to double
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.8, i64 0, i64 0), double %137)
ret i32 0
}

LLVM IR (-O2):
@.str = [22 x i8] c"\0Af(x) = (x*x - x - 6)\00"
@.str.2 = [6 x i8] c"%f %f\00"
@.str.3 = [24 x i8] c"f(%f) = %f;\0Af(%f) = %f\0A\00"
@.str.7 = [26 x i8] c"%11f\09|%11f\09|%11f\09|%12f\09|\0A\00"
@.str.8 = [19 x i8] c"\0A\09The root is: %f\0A\00"
@str = [59 x i8] c"\0AEnter values of lower limit and upper limit respectively.\00"
@str.9 = [46 x i8] c" a\09| b\09| m=(a+b)/2\09| f(m)\09|\00"
@str.10 = [65 x i8] c"----------------------------------------------------------------\00"
@str.11 = [76 x i8] c"There is no root possible within the two points provided. Please try again.\00"
define i32 @main() {
%1 = alloca float
%2 = alloca float
%3 = bitcast float* %1 to i8*
store float 0.000000e+00, float* %1
%4 = bitcast float* %2 to i8*
store float 0.000000e+00, float* %2
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
br label %6
6: ; preds = %37, %0
%7 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), float* %1, float* %2)
%9 = load float, float* %1
%10 = load float, float* %2
%11 = insertelement <2 x float> poison, float %9, i64 0
%12 = insertelement <2 x float> %11, float %10, i64 1
%13 = fneg <2 x float> %12
%14 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %12, <2 x float> %12, <2 x float> %13)
%15 = fadd <2 x float> %14, <float -6.000000e+00, float -6.000000e+00>
%16 = extractelement <2 x float> %15, i64 0
%17 = extractelement <2 x float> %15, i64 1
%18 = fmul float %16, %17
%19 = fcmp ogt float %18, 0.000000e+00
br i1 %19, label %20, label %37
20: ; preds = %6
%21 = fpext float %9 to double
%22 = fpext float %16 to double
%23 = fpext float %10 to double
%24 = fpext float %17 to double
%25 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), double %21, double %22, double %23, double %24)
%26 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.11, i64 0, i64 0))
%27 = load float, float* %1
%28 = load float, float* %2
%29 = insertelement <2 x float> poison, float %27, i64 0
%30 = insertelement <2 x float> %29, float %28, i64 1
%31 = fneg <2 x float> %30
%32 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %30, <2 x float> %30, <2 x float> %31)
%33 = fadd <2 x float> %32, <float -6.000000e+00, float -6.000000e+00>
%34 = shufflevector <2 x float> %33, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%35 = fmul <2 x float> %33, %34
%36 = extractelement <2 x float> %35, i64 0
br label %37
37: ; preds = %6, %20
%38 = phi float [ %18, %6 ], [ %36, %20 ]
%39 = fcmp ogt float %38, 0.000000e+00
br i1 %39, label %6, label %40
40: ; preds = %37
%41 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.9, i64 0, i64 0))
%42 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.10, i64 0, i64 0))
br label %43
43: ; preds = %69, %40
%44 = load float, float* %1
%45 = load float, float* %2
%46 = fadd float %44, %45
%47 = fmul float %46, 5.000000e-01
%48 = fpext float %44 to double
%49 = fpext float %45 to double
%50 = fpext float %47 to double
%51 = fneg float %47
%52 = call float @llvm.fmuladd.f32(float %47, float %47, float %51)
%53 = fadd float %52, -6.000000e+00
%54 = fpext float %53 to double
%55 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), double %48, double %49, double %50, double %54)
%56 = fcmp olt double %54, 5.000000e-07
%57 = fcmp ogt double %54, -5.000000e-07
%58 = and i1 %56, %57
br i1 %58, label %75, label %59
59: ; preds = %43
%60 = load float, float* %1
%61 = fneg float %60
%62 = call float @llvm.fmuladd.f32(float %60, float %60, float %61)
%63 = fadd float %62, -6.000000e+00
%64 = fmul float %53, %63
%65 = fcmp ogt float %64, 0.000000e+00
br i1 %65, label %66, label %68
66: ; preds = %59
store float %47, float* %1
%67 = load float, float* %2
br label %69
68: ; preds = %59
store float %47, float* %2
br label %69
69: ; preds = %68, %66
%70 = phi float [ %47, %68 ], [ %67, %66 ]
%71 = phi float [ %60, %68 ], [ %47, %66 ]
%72 = fsub float %71, %70
%73 = call double @fabs(float %72)
%74 = fcmp ogt double %73, 5.000000e-07
br i1 %74, label %43, label %75
75: ; preds = %43, %69
%76 = load float, float* %1
%77 = load float, float* %2
%78 = fadd float %76, %77
%79 = fmul float %78, 5.000000e-01
%80 = fpext float %79 to double
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.8, i64 0, i64 0), double %80)
ret i32 0
}