#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(double);
float fabsf(float);
int /*<<< orphan*/ printf(char *, ...);
double sqrt(double);
float sqrtf(float);
int main() {
  float sc = 0.0, sa = -2.0, sb = 3.0;
  double dc = 0.0, da = -2.0, db = 3.0;
  double relerr;
  printf("--- float data type(single precsion floating-point number) ---\n");
  sc = sa + sb;
  printf("%25.17e := %25.17e + %25.17e\n", sc, sa, sb);
  sc = sa - sb;
  printf("%25.17e := %25.17e - %25.17e\n", sc, sa, sb);
  sc = sa * sb;
  printf("%25.17e := %25.17e * %25.17e\n", sc, sa, sb);
  sc = sa / sb;
  printf("%25.17e := %25.17e / %25.17e\n", sc, sa, sb);
  sc = fabsf(sa);
  printf("%25.17e := |%25.17e|\n", sc, sa);
  sc = sqrtf(sb);
  printf("%25.17e := sqrt(%25.17e)\n", sc, sb);
  printf("--- double data type(double precsion floating-point number) ---\n");
  dc = da + db;
  printf("%25.17e := %25.17e + %25.17e\n", dc, da, db);
  dc = da - db;
  printf("%25.17e := %25.17e - %25.17e\n", dc, da, db);
  dc = da * db;
  printf("%25.17e := %25.17e * %25.17e\n", dc, da, db);
  dc = da / db;
  printf("%25.17e := %25.17e / %25.17e\n", dc, da, db);
  dc = fabs(da);
  printf("%25.17e := |%25.17e|\n", dc, da);
  dc = sqrt(db);
  printf("%25.17e := sqrt(%25.17e)\n", dc, db);
  relerr = fabs(sc - dc);
  if (fabs(dc) > 0.0)
    relerr /= fabs(dc);
  printf("Single Prec.  : %25.17e\n", sc);
  printf("Double Prec.  : %25.17e\n", dc);
  printf("Relative Error: %10.3e\n", relerr);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8(%rbp)
movss  0xee5(%rip),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  0xed4(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xeb7(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xea2(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    0xeae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0xc(%rbp),%xmm0
addss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x10(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xeb6(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movss  -0xc(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x10(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe9c(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movss  -0xc(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x10(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe82(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movss  -0xc(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x10(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe68(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movss  -0xc(%rbp),%xmm0
movaps 0xd93(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xe51(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x10(%rbp),%xmm0
call   1040 <sqrtf@plt>
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xe38(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    0xe44(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
lea    0xd70(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
lea    0xd62(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
lea    0xd54(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
lea    0xd46(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
movaps 0xc61(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
lea    0xd37(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x28(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
lea    0xd26(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x18(%rbp),%xmm0
movaps 0xc04(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x18(%rbp),%xmm0
movaps 0xbef(%rip),%xmm1
pand   %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1440 <main+0x310>
movsd  -0x18(%rbp),%xmm1
movaps 0xbd2(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd11(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x18(%rbp),%xmm0
lea    0xd17(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x30(%rbp),%xmm0
lea    0xd1d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0x1018(%rip),%rdi
call   1030 <puts@plt>
lea    0xf1a(%rip),%r14
movsd  0xeba(%rip),%xmm0
movsd  0xeba(%rip),%xmm1
movsd  0xeba(%rip),%xmm2
mov    %r14,%rdi
mov    $0x3,%al
call   1040 <printf@plt>
lea    0xf0f(%rip),%r15
movsd  0xea9(%rip),%xmm0
mov    %r15,%rdi
movsd  0xe8e(%rip),%xmm1
movsd  0xe8e(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
lea    0xf04(%rip),%r12
movsd  0xe88(%rip),%xmm0
mov    %r12,%rdi
movsd  0xe65(%rip),%xmm1
movsd  0xe65(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
lea    0xef9(%rip),%r13
movsd  0xe67(%rip),%xmm0
mov    %r13,%rdi
movsd  0xe3c(%rip),%xmm1
movsd  0xe3c(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
lea    0xeee(%rip),%rbx
movsd  0xe46(%rip),%xmm0
mov    %rbx,%rdi
movsd  0xe13(%rip),%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xee3(%rip),%rbp
movsd  0xe2d(%rip),%xmm0
mov    %rbp,%rdi
movsd  0xdfa(%rip),%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xf65(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%rdi
movsd  0xdcc(%rip),%xmm0
movsd  0xdcc(%rip),%xmm1
movsd  0xdcc(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
mov    %r15,%rdi
movsd  0xdc2(%rip),%xmm0
movsd  0xdaa(%rip),%xmm1
movsd  0xdaa(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
mov    %r12,%rdi
movsd  0xda8(%rip),%xmm0
movsd  0xd88(%rip),%xmm1
movsd  0xd88(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
movsd  0xda9(%rip),%xmm0
mov    %r13,%rdi
movsd  0xd66(%rip),%xmm1
movsd  0xd66(%rip),%xmm2
mov    $0x3,%al
call   1040 <printf@plt>
mov    %rbx,%rdi
movsd  0xd74(%rip),%xmm0
movsd  0xd44(%rip),%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xd75(%rip),%xmm0
mov    %rbp,%rdi
movsd  0xd32(%rip),%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xe14(%rip),%rdi
movsd  0xd44(%rip),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xe17(%rip),%rdi
movsd  0xd3e(%rip),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xe1a(%rip),%rdi
movsd  0xd30(%rip),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [64 x i8] c"--- float data type(single precsion floating-point number) ---\0A\00"
@.str.1 = [30 x i8] c"%25.17e := %25.17e + %25.17e\0A\00"
@.str.2 = [30 x i8] c"%25.17e := %25.17e - %25.17e\0A\00"
@.str.3 = [30 x i8] c"%25.17e := %25.17e * %25.17e\0A\00"
@.str.4 = [30 x i8] c"%25.17e := %25.17e / %25.17e\0A\00"
@.str.5 = [22 x i8] c"%25.17e := |%25.17e|\0A\00"
@.str.6 = [26 x i8] c"%25.17e := sqrt(%25.17e)\0A\00"
@.str.7 = [65 x i8] c"--- double data type(double precsion floating-point number) ---\0A\00"
@.str.8 = [25 x i8] c"Single Prec. : %25.17e\0A\00"
@.str.9 = [25 x i8] c"Double Prec. : %25.17e\0A\00"
@.str.10 = [24 x i8] c"Relative Error: %10.3e\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
store i32 0, i32* %1
store float 0.000000e+00, float* %2
store float -2.000000e+00, float* %3
store float 3.000000e+00, float* %4
store double 0.000000e+00, double* %5
store double -2.000000e+00, double* %6
store double 3.000000e+00, double* %7
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str, i64 0, i64 0))
%10 = load float, float* %3
%11 = load float, float* %4
%12 = fadd float %10, %11
store float %12, float* %2
%13 = load float, float* %2
%14 = fpext float %13 to double
%15 = load float, float* %3
%16 = fpext float %15 to double
%17 = load float, float* %4
%18 = fpext float %17 to double
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), double %14, double %16, double %18)
%20 = load float, float* %3
%21 = load float, float* %4
%22 = fsub float %20, %21
store float %22, float* %2
%23 = load float, float* %2
%24 = fpext float %23 to double
%25 = load float, float* %3
%26 = fpext float %25 to double
%27 = load float, float* %4
%28 = fpext float %27 to double
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double %24, double %26, double %28)
%30 = load float, float* %3
%31 = load float, float* %4
%32 = fmul float %30, %31
store float %32, float* %2
%33 = load float, float* %2
%34 = fpext float %33 to double
%35 = load float, float* %3
%36 = fpext float %35 to double
%37 = load float, float* %4
%38 = fpext float %37 to double
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), double %34, double %36, double %38)
%40 = load float, float* %3
%41 = load float, float* %4
%42 = fdiv float %40, %41
store float %42, float* %2
%43 = load float, float* %2
%44 = fpext float %43 to double
%45 = load float, float* %3
%46 = fpext float %45 to double
%47 = load float, float* %4
%48 = fpext float %47 to double
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), double %44, double %46, double %48)
%50 = load float, float* %3
%51 = call float @llvm.fabs.f32(float %50)
store float %51, float* %2
%52 = load float, float* %2
%53 = fpext float %52 to double
%54 = load float, float* %3
%55 = fpext float %54 to double
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), double %53, double %55)
%57 = load float, float* %4
%58 = call float @sqrtf(float %57)
store float %58, float* %2
%59 = load float, float* %2
%60 = fpext float %59 to double
%61 = load float, float* %4
%62 = fpext float %61 to double
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %60, double %62)
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.7, i64 0, i64 0))
%65 = load double, double* %6
%66 = load double, double* %7
%67 = fadd double %65, %66
store double %67, double* %5
%68 = load double, double* %5
%69 = load double, double* %6
%70 = load double, double* %7
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), double %68, double %69, double %70)
%72 = load double, double* %6
%73 = load double, double* %7
%74 = fsub double %72, %73
store double %74, double* %5
%75 = load double, double* %5
%76 = load double, double* %6
%77 = load double, double* %7
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double %75, double %76, double %77)
%79 = load double, double* %6
%80 = load double, double* %7
%81 = fmul double %79, %80
store double %81, double* %5
%82 = load double, double* %5
%83 = load double, double* %6
%84 = load double, double* %7
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), double %82, double %83, double %84)
%86 = load double, double* %6
%87 = load double, double* %7
%88 = fdiv double %86, %87
store double %88, double* %5
%89 = load double, double* %5
%90 = load double, double* %6
%91 = load double, double* %7
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), double %89, double %90, double %91)
%93 = load double, double* %6
%94 = call double @llvm.fabs.f64(double %93)
store double %94, double* %5
%95 = load double, double* %5
%96 = load double, double* %6
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), double %95, double %96)
%98 = load double, double* %7
%99 = call double @sqrt(double %98)
store double %99, double* %5
%100 = load double, double* %5
%101 = load double, double* %7
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %100, double %101)
%103 = load float, float* %2
%104 = fpext float %103 to double
%105 = load double, double* %5
%106 = fsub double %104, %105
%107 = call double @llvm.fabs.f64(double %106)
store double %107, double* %8
%108 = load double, double* %5
%109 = call double @llvm.fabs.f64(double %108)
%110 = fcmp ogt double %109, 0.000000e+00
br i1 %110, label %111, label %116
111: ; preds = %0
%112 = load double, double* %5
%113 = call double @llvm.fabs.f64(double %112)
%114 = load double, double* %8
%115 = fdiv double %114, %113
store double %115, double* %8
br label %116
116: ; preds = %111, %0
%117 = load float, float* %2
%118 = fpext float %117 to double
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), double %118)
%120 = load double, double* %5
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), double %120)
%122 = load double, double* %8
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.10, i64 0, i64 0), double %122)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [30 x i8] c"%25.17e := %25.17e + %25.17e\0A\00"
@.str.2 = [30 x i8] c"%25.17e := %25.17e - %25.17e\0A\00"
@.str.3 = [30 x i8] c"%25.17e := %25.17e * %25.17e\0A\00"
@.str.4 = [30 x i8] c"%25.17e := %25.17e / %25.17e\0A\00"
@.str.5 = [22 x i8] c"%25.17e := |%25.17e|\0A\00"
@.str.6 = [26 x i8] c"%25.17e := sqrt(%25.17e)\0A\00"
@.str.8 = [25 x i8] c"Single Prec. : %25.17e\0A\00"
@.str.9 = [25 x i8] c"Double Prec. : %25.17e\0A\00"
@.str.10 = [24 x i8] c"Relative Error: %10.3e\0A\00"
@str = [63 x i8] c"--- float data type(single precsion floating-point number) ---\00"
@str.11 = [64 x i8] c"--- double data type(double precsion floating-point number) ---\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), double 1.000000e+00, double -2.000000e+00, double 3.000000e+00)
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double -5.000000e+00, double -2.000000e+00, double 3.000000e+00)
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), double -6.000000e+00, double -2.000000e+00, double 3.000000e+00)
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), double 0xBFE5555560000000, double -2.000000e+00, double 3.000000e+00)
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), double 2.000000e+00, double -2.000000e+00)
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double 0x3FFBB67AE0000000, double 3.000000e+00)
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.11, i64 0, i64 0))
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), double 1.000000e+00, double -2.000000e+00, double 3.000000e+00)
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double -5.000000e+00, double -2.000000e+00, double 3.000000e+00)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), double -6.000000e+00, double -2.000000e+00, double 3.000000e+00)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), double 0xBFE5555555555555, double -2.000000e+00, double 3.000000e+00)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), double 2.000000e+00, double -2.000000e+00)
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double 0x3FFBB67AE8584CAA, double 3.000000e+00)
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), double 0x3FFBB67AE0000000)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), double 0x3FFBB67AE8584CAA)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.10, i64 0, i64 0), double 0x3E53459281DB9CAF)
ret i32 0
}