#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*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, float *);
main() {
  float a, b, x;
  int i = 1;
  printf("enter the interval of root:\n");
  printf("a:");
  scanf("%f", &a);
  printf("b:");
  scanf("%f", &b);
  x = b -
      ((b - a) / (((b * b * b) - (4 * b) - 9) - ((a * a * a) - (4 * a) - 9)) *
       ((b * b * b) - (4 * b) - 9));
  printf("%d approximation of the root:%f", i, x);
  printf("\tf(x)=%f", ((x * x * x) - (4 * x) - 9));
  i++;
  printf("\n");
  while ((x - b) > 0.00001 || (x - b) < -0.00001) {
    a = b;
    b = x;
    x = b -
        ((b - a) / (((b * b * b) - (4 * b) - 9) - ((a * a * a) - (4 * a) - 9)) *
         ((b * b * b) - (4 * b) - 9));
    printf("%d approximation of the root:%f", i, x);
    printf("\tf(x)=%f", ((x * x * x) - (4 * x) - 9));
    i++;
    printf("\n");
  }
  printf("real root of the equation :%f", x);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x14(%rbp)
lea    0xedb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf26(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
lea    0xecf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf08(%rip),%rdi
lea    -0xc(%rbp),%rsi
call   1040 <scanf@plt>
movss  -0xc(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
mulss  -0xc(%rbp),%xmm2
movss  -0xc(%rbp),%xmm4
movss  0xe5e(%rip),%xmm3
mulss  -0xc(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0xe38(%rip),%xmm3
subss  %xmm3,%xmm2
movss  -0x8(%rbp),%xmm3
mulss  -0x8(%rbp),%xmm3
movss  -0x8(%rbp),%xmm5
movss  0xe21(%rip),%xmm4
mulss  -0x8(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  0xdfb(%rip),%xmm4
subss  %xmm4,%xmm3
subss  %xmm3,%xmm2
divss  %xmm2,%xmm0
movss  -0xc(%rbp),%xmm2
mulss  -0xc(%rbp),%xmm2
movss  -0xc(%rbp),%xmm4
movss  0xddc(%rip),%xmm3
mulss  -0xc(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0xdb6(%rip),%xmm3
subss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x14(%rbp),%esi
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdc0(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movss  -0x10(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  0xd6b(%rip),%xmm1
mulss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xd45(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd91(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
lea    0xd52(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x10(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
movsd  0xd08(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x15(%rbp)
ja     132d <main+0x20d>
movss  -0x10(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xced(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
test   $0x1,%al
jne    133d <main+0x21d>
jmp    14be <main+0x39e>
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0xc(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
mulss  -0xc(%rbp),%xmm2
movss  -0xc(%rbp),%xmm4
movss  0xc8d(%rip),%xmm3
mulss  -0xc(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0xc67(%rip),%xmm3
subss  %xmm3,%xmm2
movss  -0x8(%rbp),%xmm3
mulss  -0x8(%rbp),%xmm3
movss  -0x8(%rbp),%xmm5
movss  0xc50(%rip),%xmm4
mulss  -0x8(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  0xc2a(%rip),%xmm4
subss  %xmm4,%xmm3
subss  %xmm3,%xmm2
divss  %xmm2,%xmm0
movss  -0xc(%rbp),%xmm2
mulss  -0xc(%rbp),%xmm2
movss  -0xc(%rbp),%xmm4
movss  0xc0b(%rip),%xmm3
mulss  -0xc(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0xbe5(%rip),%xmm3
subss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x14(%rbp),%esi
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbef(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movss  -0x10(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  0xb9a(%rip),%xmm1
mulss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xb74(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbc0(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
lea    0xb81(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12e8 <main+0x1c8>
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb96(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0x30,%rsp
lea    0xf35(%rip),%rdi
call   1040 <puts@plt>
lea    0xedc(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf18(%rip),%rbx
lea    0xc(%rsp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
lea    0xebd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
movss  0x8(%rsp),%xmm4
movss  0xc(%rsp),%xmm0
movaps %xmm4,%xmm1
subss  %xmm0,%xmm1
movaps %xmm4,%xmm2
unpcklps %xmm0,%xmm2
movaps %xmm2,%xmm0
mulps  %xmm2,%xmm0
mulps  %xmm2,%xmm0
mulps  0xe45(%rip),%xmm2
addps  %xmm0,%xmm2
addps  0xe4b(%rip),%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm3
subss  %xmm0,%xmm3
divss  %xmm3,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm4
movaps %xmm4,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
lea    0xe4c(%rip),%rdi
mov    $0x1,%esi
movsd  %xmm0,0x28(%rsp)
mov    $0x1,%al
call   1050 <printf@plt>
movaps 0x10(%rsp),%xmm2
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
movss  0xe08(%rip),%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  0xdf8(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe27(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movaps 0x10(%rsp),%xmm4
movss  0x8(%rsp),%xmm1
movaps %xmm4,%xmm0
subss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
ucomisd 0xdbf(%rip),%xmm2
ja     127d <main+0x13d>
movsd  0xdbd(%rip),%xmm3
ucomisd %xmm2,%xmm3
jbe    1387 <main+0x247>
unpcklps %xmm1,%xmm4
mov    $0x2,%ebx
lea    0xdb2(%rip),%r14
lea    0xdcb(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movss  %xmm1,0xc(%rsp)
movss  %xmm4,0x8(%rsp)
movaps %xmm4,%xmm1
mulps  %xmm4,%xmm1
movaps %xmm4,%xmm2
mulps  0xd3d(%rip),%xmm2
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
addps  0xd40(%rip),%xmm1
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
divss  %xmm3,%xmm0
mulss  %xmm1,%xmm0
subss  %xmm0,%xmm4
movaps %xmm4,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
mov    %r14,%rdi
mov    %ebx,%esi
movsd  %xmm0,0x28(%rsp)
mov    $0x1,%al
call   1050 <printf@plt>
movaps 0x10(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps 0x10(%rsp),%xmm1
mulss  0xd02(%rip),%xmm1
mulss  0x10(%rsp),%xmm0
addss  %xmm1,%xmm0
addss  0xcf4(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%ebx
mov    $0xa,%edi
call   1030 <putchar@plt>
movaps 0x10(%rsp),%xmm4
movss  0x8(%rsp),%xmm2
movaps %xmm4,%xmm0
subss  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd 0xcbc(%rip),%xmm1
unpcklps %xmm2,%xmm4
ja     12a0 <main+0x160>
movsd  0xcb3(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     12a0 <main+0x160>
lea    0xcd9(%rip),%rdi
movsd  0x28(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@.str.1 = [3 x i8] c"a:\00"
@.str.2 = [3 x i8] c"%f\00"
@.str.3 = [3 x i8] c"b:\00"
@.str.4 = [32 x i8] c"%d approximation of the root:%f\00"
@.str.5 = [9 x i8] c"\09f(x)=%f\00"
@.str.7 = [30 x i8] c"real root of the equation :%f\00"
@str = [28 x i8] c"enter the interval of root:\00"
define i32 @main() {
%1 = alloca float
%2 = alloca float
%3 = bitcast float* %1 to i8*
%4 = bitcast float* %2 to i8*
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), float* %1)
%8 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%9 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), float* %2)
%10 = load float, float* %2
%11 = load float, float* %1
%12 = fsub float %10, %11
%13 = insertelement <2 x float> poison, float %10, i64 0
%14 = insertelement <2 x float> %13, float %11, i64 1
%15 = fmul <2 x float> %14, %14
%16 = fmul <2 x float> %14, <float -4.000000e+00, float -4.000000e+00>
%17 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %15, <2 x float> %14, <2 x float> %16)
%18 = fadd <2 x float> %17, <float -9.000000e+00, float -9.000000e+00>
%19 = extractelement <2 x float> %18, i64 0
%20 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%21 = fsub <2 x float> %18, %20
%22 = extractelement <2 x float> %21, i64 0
%23 = fneg float %12
%24 = fdiv float %23, %22
%25 = call float @llvm.fmuladd.f32(float %24, float %19, float %10)
%26 = fpext float %25 to double
%27 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i32 1, double %26)
%28 = fmul float %25, %25
%29 = fmul float %25, -4.000000e+00
%30 = call float @llvm.fmuladd.f32(float %28, float %25, float %29)
%31 = fadd float %30, -9.000000e+00
%32 = fpext float %31 to double
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), double %32)
%34 = call i32 @putchar(i32 10)
%35 = load float, float* %2
%36 = fsub float %25, %35
%37 = fpext float %36 to double
%38 = fcmp ogt double %37, 1.000000e-05
%39 = fcmp olt double %37, -1.000000e-05
%40 = or i1 %38, %39
br i1 %40, label %41, label %79
41: ; preds = %0
%42 = insertelement <2 x float> poison, float %25, i64 0
%43 = insertelement <2 x float> %42, float %35, i64 1
br label %44
44: ; preds = %41, %44
%45 = phi float [ %72, %44 ], [ %36, %41 ]
%46 = phi i32 [ %69, %44 ], [ 2, %41 ]
%47 = phi <2 x float> [ %78, %44 ], [ %43, %41 ]
%48 = extractelement <2 x float> %47, i64 1
store float %48, float* %1
%49 = extractelement <2 x float> %47, i64 0
store float %49, float* %2
%50 = fmul <2 x float> %47, %47
%51 = fmul <2 x float> %47, <float -4.000000e+00, float -4.000000e+00>
%52 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %50, <2 x float> %47, <2 x float> %51)
%53 = fadd <2 x float> %52, <float -9.000000e+00, float -9.000000e+00>
%54 = extractelement <2 x float> %53, i64 0
%55 = shufflevector <2 x float> %53, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%56 = fsub <2 x float> %53, %55
%57 = extractelement <2 x float> %56, i64 0
%58 = fneg float %45
%59 = fdiv float %58, %57
%60 = call float @llvm.fmuladd.f32(float %59, float %54, float %49)
%61 = fpext float %60 to double
%62 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i32 %46, double %61)
%63 = fmul float %60, %60
%64 = fmul float %60, -4.000000e+00
%65 = call float @llvm.fmuladd.f32(float %63, float %60, float %64)
%66 = fadd float %65, -9.000000e+00
%67 = fpext float %66 to double
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), double %67)
%69 = add nuw nsw i32 %46, 1
%70 = call i32 @putchar(i32 10)
%71 = load float, float* %2
%72 = fsub float %60, %71
%73 = fpext float %72 to double
%74 = fcmp ogt double %73, 1.000000e-05
%75 = fcmp olt double %73, -1.000000e-05
%76 = or i1 %74, %75
%77 = insertelement <2 x float> poison, float %60, i64 0
%78 = insertelement <2 x float> %77, float %71, i64 1
br i1 %76, label %44, label %79
79: ; preds = %44, %0
%80 = phi double [ %26, %0 ], [ %61, %44 ]
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.7, i64 0, i64 0), double %80)
ret i32 0
}