#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 */
typedef int /*<<< orphan*/ coeffs_sp_avx2;

/* Variables and functions */
int /*<<< orphan*/ horner_fma_dp(double *, double *, int, double *);
int /*<<< orphan*/ horner_fma_sp(float *, float *, int, float *);
int /*<<< orphan*/ horner_fma_sp_avx2(float *, float *, int, float *);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  printf("Single precision:\n");
  float coeffs[] = {1.0f, 2.0f, 3.0f};
  float x[] = {.2f, .4f, .6f, .8f};
  float results[4];
  printf("%gx^2 + %gx + %g evaluated at\n%f, %f, %f, %f = \n", coeffs[2],
         coeffs[1], coeffs[0], x[0], x[1], x[2], x[3]);
  horner_fma_sp(x, coeffs, 3, results);
  printf("%f, %f, %f, %f\n", results[0], results[1], results[2], results[3]);
  printf("\nDouble precision:\n");
  double coeffs_dp[] = {1.0, 2.0, 3.0};
  double x_dp[] = {1.0 / 3.0, 2.0 / 3.0};
  double results_dp[2];
  printf("%gx^2 + %gx + %g evaluated at\n%f, %f = \n", coeffs_dp[2],
         coeffs_dp[1], coeffs_dp[0], x_dp[0], x_dp[1]);
  horner_fma_dp(x_dp, coeffs_dp, 3, results_dp);
  printf("%f, %f\n", results_dp[0], results_dp[1]);
  float coeffs_sp_avx2[] = {0.0f, 1.0f,
                            0.0f, -1.0 / (3 * 2),
                            0.0f, 1.0 / (5 * 4 * 3 * 2),
                            0.0f, -1.0 / (7 * 6 * 5 * 4 * 3 * 2),
                            0.0f, 1.0 / (9 * 8 * 7 * 6 * 5 * 4 * 3 * 2)};
  float x_sp_avx2[] = {
      -(2.0 * 3.14159265359) * (3. / 8.0), -(2.0 * 3.14159265359) * (2. / 8.0),
      -(2.0 * 3.14159265359) * (1. / 8.0), (2.0 * 3.14159265359) * (0. / 8.0),
      (2.0 * 3.14159265359) * (1. / 8.0),  (2.0 * 3.14159265359) * (2. / 8.0),
      (2.0 * 3.14159265359) * (3. / 8.0),  (2.0 * 3.14159265359) * (4. / 8.0),
  };
  float results_sp_avx2[8];
  horner_fma_sp_avx2(x_sp_avx2, coeffs_sp_avx2,
                     sizeof(coeffs_sp_avx2) / sizeof(coeffs_sp_avx2[0]),
                     results_sp_avx2);
  float *p = results_sp_avx2;
  printf("\n%f %f %f %f %f %f %f %f\n", p[0], p[1], p[2], p[3], p[4], p[5],
         p[6], p[7]);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
lea    0xeb2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0xf50(%rip),%rax
mov    %rax,-0xc(%rbp)
mov    0xf4e(%rip),%eax
mov    %eax,-0x4(%rbp)
mov    0xf6c(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xf69(%rip),%rax
mov    %rax,-0x18(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0xc(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x20(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x1c(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  -0x18(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  -0x14(%rbp),%xmm6
cvtss2sd %xmm6,%xmm6
lea    0xe4e(%rip),%rdi
mov    $0x7,%al
call   1030 <printf@plt>
lea    -0x20(%rbp),%rdi
lea    -0xc(%rbp),%rsi
lea    -0x30(%rbp),%rcx
mov    $0x3,%edx
call   1070 <horner_fma_sp@plt>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x24(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xe37(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xe39(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0xe93(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xe90(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    0xe8d(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xea2(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xe9f(%rip),%rax
mov    %rax,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm4
lea    0xdef(%rip),%rdi
mov    $0x5,%al
call   1030 <printf@plt>
lea    -0x60(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x70(%rbp),%rcx
mov    $0x3,%edx
call   1050 <horner_fma_dp@plt>
movsd  -0x70(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
lea    0xda5(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1040 <memset@plt>
movss  0xd33(%rip),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  0xd1f(%rip),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  0xd0b(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  0xcf7(%rip),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  0xce3(%rip),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    0xde7(%rip),%rax
mov    %rax,-0xc0(%rbp)
mov    0xde1(%rip),%rax
mov    %rax,-0xb8(%rbp)
mov    0xddb(%rip),%rax
mov    %rax,-0xb0(%rbp)
mov    0xdd5(%rip),%rax
mov    %rax,-0xa8(%rbp)
lea    -0xc0(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
lea    -0xe0(%rbp),%rcx
mov    $0xa,%edx
call   1060 <horner_fma_sp_avx2@plt>
lea    -0xe0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0xe8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0xe8(%rbp),%rax
movss  0x8(%rax),%xmm2
cvtss2sd %xmm2,%xmm2
mov    -0xe8(%rbp),%rax
movss  0xc(%rax),%xmm3
cvtss2sd %xmm3,%xmm3
mov    -0xe8(%rbp),%rax
movss  0x10(%rax),%xmm4
cvtss2sd %xmm4,%xmm4
mov    -0xe8(%rbp),%rax
movss  0x14(%rax),%xmm5
cvtss2sd %xmm5,%xmm5
mov    -0xe8(%rbp),%rax
movss  0x18(%rax),%xmm6
cvtss2sd %xmm6,%xmm6
mov    -0xe8(%rbp),%rax
movss  0x1c(%rax),%xmm7
cvtss2sd %xmm7,%xmm7
lea    0xc98(%rip),%rdi
mov    $0x8,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0xe8,%rsp
lea    0xfc6(%rip),%rdi
call   1030 <puts@plt>
mov    0xeef(%rip),%eax
mov    %eax,0x38(%rsp)
mov    0xedc(%rip),%rax
mov    %rax,0x30(%rsp)
movaps 0xf00(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
lea    0xf11(%rip),%rdi
movsd  0xe69(%rip),%xmm0
movsd  0xe69(%rip),%xmm1
movsd  0xe69(%rip),%xmm2
movsd  0xe69(%rip),%xmm3
movsd  0xe69(%rip),%xmm4
movsd  0xe69(%rip),%xmm5
movsd  0xe69(%rip),%xmm6
mov    $0x7,%al
call   1040 <printf@plt>
lea    0xb0(%rsp),%rdi
lea    0x30(%rsp),%rsi
mov    %rsp,%rcx
mov    $0x3,%edx
call   1070 <horner_fma_sp@plt>
movss  (%rsp),%xmm0
movss  0x4(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
movss  0x8(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0xc(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xebb(%rip),%rdi
mov    $0x4,%al
call   1040 <printf@plt>
lea    0xf12(%rip),%rdi
call   1030 <puts@plt>
mov    0xe40(%rip),%rax
mov    %rax,0xa0(%rsp)
movaps 0xe21(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xe42(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
lea    0xe84(%rip),%rdi
movsd  0xdd3(%rip),%xmm3
movsd  0xdd3(%rip),%xmm4
movsd  0xd8b(%rip),%xmm0
movsd  0xd8b(%rip),%xmm1
movsd  0xd8b(%rip),%xmm2
mov    $0x5,%al
call   1040 <printf@plt>
lea    0x80(%rsp),%rdi
lea    0x90(%rsp),%rsi
lea    0x70(%rsp),%rcx
mov    $0x3,%edx
call   1050 <horner_fma_dp@plt>
movsd  0x70(%rsp),%xmm0
movsd  0x78(%rsp),%xmm1
lea    0xe1b(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movq   $0x0,0x60(%rsp)
movl   $0x3f800000,0x44(%rsp)
3f
movl   $0xbe2aaaab,0x4c(%rsp)
be
movl   $0x3c088889,0x54(%rsp)
3c
movl   $0xb9500d01,0x5c(%rsp)
b9
movl   $0x3638ef1d,0x64(%rsp)
36
movaps 0xe56(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xe37(%rip),%xmm0
movaps %xmm0,0xc0(%rsp)
lea    0xc0(%rsp),%rdi
lea    0x40(%rsp),%rsi
lea    0x10(%rsp),%rcx
mov    $0xa,%edx
call   1060 <horner_fma_sp_avx2@plt>
movss  0x10(%rsp),%xmm0
movss  0x14(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
movss  0x18(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x1c(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x20(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0x24(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  0x28(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
movss  0x2c(%rsp),%xmm7
cvtss2sd %xmm7,%xmm7
lea    0xd76(%rip),%rdi
mov    $0x8,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xe8,%rsp
ret

LLVM IR (-O0):
@.str = [19 x i8] c"Single precision:\0A\00"
@__const.main.coeffs = [3 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+00]
@__const.main.x = [4 x float] [float 0x3FC99999A0000000, float 0x3FD99999A0000000, float 0x3FE3333340000000, float 0x3FE99999A0000000]
@.str.1 = [49 x i8] c"%gx^2 + %gx + %g evaluated at\0A%f, %f, %f, %f = \0A\00"
@.str.2 = [16 x i8] c"%f, %f, %f, %f\0A\00"
@.str.3 = [20 x i8] c"\0ADouble precision:\0A\00"
@__const.main.coeffs_dp = [3 x double] [double 1.000000e+00, double 2.000000e+00, double 3.000000e+00]
@__const.main.x_dp = [2 x double] [double 0x3FD5555555555555, double 0x3FE5555555555555]
@.str.4 = [41 x i8] c"%gx^2 + %gx + %g evaluated at\0A%f, %f = \0A\00"
@.str.5 = [8 x i8] c"%f, %f\0A\00"
@__const.main.x_sp_avx2 = [8 x float] [float 0xC002D97C80000000, float 0xBFF921FB60000000, float 0xBFE921FB60000000, float 0.000000e+00, float 0x3FE921FB60000000, float 0x3FF921FB60000000, float 0x4002D97C80000000, float 0x400921FB60000000]
@.str.6 = [26 x i8] c"\0A%f %f %f %f %f %f %f %f\0A\00"
define i32 @main() {
%1 = alloca [3 x float]
%2 = alloca [4 x float]
%3 = alloca [4 x float]
%4 = alloca [3 x double]
%5 = alloca [2 x double]
%6 = alloca [2 x double]
%7 = alloca [10 x float]
%8 = alloca [8 x float]
%9 = alloca [8 x float]
%10 = alloca float*
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%12 = bitcast [3 x float]* %1 to i8*
%13 = bitcast [4 x float]* %2 to i8*
%14 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 2
%15 = load float, float* %14
%16 = fpext float %15 to double
%17 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 1
%18 = load float, float* %17
%19 = fpext float %18 to double
%20 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 0
%21 = load float, float* %20
%22 = fpext float %21 to double
%23 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 0
%24 = load float, float* %23
%25 = fpext float %24 to double
%26 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 1
%27 = load float, float* %26
%28 = fpext float %27 to double
%29 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 2
%30 = load float, float* %29
%31 = fpext float %30 to double
%32 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 3
%33 = load float, float* %32
%34 = fpext float %33 to double
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i64 0, i64 0), double %16, double %19, double %22, double %25, double %28, double %31, double %34)
%36 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 0
%37 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 0
%38 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%39 = call i32 @horner_fma_sp(float* %36, float* %37, i32 3, float* %38)
%40 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 1
%44 = load float, float* %43
%45 = fpext float %44 to double
%46 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 2
%47 = load float, float* %46
%48 = fpext float %47 to double
%49 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 3
%50 = load float, float* %49
%51 = fpext float %50 to double
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), double %42, double %45, double %48, double %51)
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0))
%54 = bitcast [3 x double]* %4 to i8*
%55 = bitcast [2 x double]* %5 to i8*
%56 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%57 = load double, double* %56
%58 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%59 = load double, double* %58
%60 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%61 = load double, double* %60
%62 = getelementptr inbounds [2 x double], [2 x double]* %5, i64 0, i64 0
%63 = load double, double* %62
%64 = getelementptr inbounds [2 x double], [2 x double]* %5, i64 0, i64 1
%65 = load double, double* %64
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.4, i64 0, i64 0), double %57, double %59, double %61, double %63, double %65)
%67 = getelementptr inbounds [2 x double], [2 x double]* %5, i64 0, i64 0
%68 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%69 = getelementptr inbounds [2 x double], [2 x double]* %6, i64 0, i64 0
%70 = call i32 @horner_fma_dp(double* %67, double* %68, i32 3, double* %69)
%71 = getelementptr inbounds [2 x double], [2 x double]* %6, i64 0, i64 0
%72 = load double, double* %71
%73 = getelementptr inbounds [2 x double], [2 x double]* %6, i64 0, i64 1
%74 = load double, double* %73
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), double %72, double %74)
%76 = bitcast [10 x float]* %7 to i8*
%77 = bitcast i8* %76 to [10 x float]*
%78 = getelementptr inbounds [10 x float], [10 x float]* %77, i32 0, i32 1
store float 1.000000e+00, float* %78
%79 = getelementptr inbounds [10 x float], [10 x float]* %77, i32 0, i32 3
store float 0xBFC5555560000000, float* %79
%80 = getelementptr inbounds [10 x float], [10 x float]* %77, i32 0, i32 5
store float 0x3F81111120000000, float* %80
%81 = getelementptr inbounds [10 x float], [10 x float]* %77, i32 0, i32 7
store float 0xBF2A01A020000000, float* %81
%82 = getelementptr inbounds [10 x float], [10 x float]* %77, i32 0, i32 9
store float 0x3EC71DE3A0000000, float* %82
%83 = bitcast [8 x float]* %8 to i8*
%84 = getelementptr inbounds [8 x float], [8 x float]* %8, i64 0, i64 0
%85 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 0
%86 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 0
%87 = call i32 @horner_fma_sp_avx2(float* %84, float* %85, i32 10, float* %86)
%88 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 0
store float* %88, float** %10
%89 = load float*, float** %10
%90 = getelementptr inbounds float, float* %89, i64 0
%91 = load float, float* %90
%92 = fpext float %91 to double
%93 = load float*, float** %10
%94 = getelementptr inbounds float, float* %93, i64 1
%95 = load float, float* %94
%96 = fpext float %95 to double
%97 = load float*, float** %10
%98 = getelementptr inbounds float, float* %97, i64 2
%99 = load float, float* %98
%100 = fpext float %99 to double
%101 = load float*, float** %10
%102 = getelementptr inbounds float, float* %101, i64 3
%103 = load float, float* %102
%104 = fpext float %103 to double
%105 = load float*, float** %10
%106 = getelementptr inbounds float, float* %105, i64 4
%107 = load float, float* %106
%108 = fpext float %107 to double
%109 = load float*, float** %10
%110 = getelementptr inbounds float, float* %109, i64 5
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = load float*, float** %10
%114 = getelementptr inbounds float, float* %113, i64 6
%115 = load float, float* %114
%116 = fpext float %115 to double
%117 = load float*, float** %10
%118 = getelementptr inbounds float, float* %117, i64 7
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %92, double %96, double %100, double %104, double %108, double %112, double %116, double %120)
ret i32 0
}

LLVM IR (-O2):
@__const.main.coeffs = [3 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+00]
@__const.main.x = [4 x float] [float 0x3FC99999A0000000, float 0x3FD99999A0000000, float 0x3FE3333340000000, float 0x3FE99999A0000000]
@.str.1 = [49 x i8] c"%gx^2 + %gx + %g evaluated at\0A%f, %f, %f, %f = \0A\00"
@.str.2 = [16 x i8] c"%f, %f, %f, %f\0A\00"
@__const.main.coeffs_dp = [3 x double] [double 1.000000e+00, double 2.000000e+00, double 3.000000e+00]
@__const.main.x_dp = [2 x double] [double 0x3FD5555555555555, double 0x3FE5555555555555]
@.str.4 = [41 x i8] c"%gx^2 + %gx + %g evaluated at\0A%f, %f = \0A\00"
@.str.5 = [8 x i8] c"%f, %f\0A\00"
@__const.main.x_sp_avx2 = [8 x float] [float 0xC002D97C80000000, float 0xBFF921FB60000000, float 0xBFE921FB60000000, float 0.000000e+00, float 0x3FE921FB60000000, float 0x3FF921FB60000000, float 0x4002D97C80000000, float 0x400921FB60000000]
@.str.6 = [26 x i8] c"\0A%f %f %f %f %f %f %f %f\0A\00"
@str = [18 x i8] c"Single precision:\00"
@str.7 = [19 x i8] c"\0ADouble precision:\00"
define i32 @main() {
%1 = alloca [3 x float]
%2 = alloca [4 x float]
%3 = alloca [4 x float]
%4 = alloca [3 x double]
%5 = alloca [2 x double]
%6 = alloca [2 x double]
%7 = alloca [10 x float]
%8 = alloca [8 x float]
%9 = alloca [8 x float]
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%11 = bitcast [3 x float]* %1 to i8*
%12 = bitcast [4 x float]* %2 to i8*
%13 = bitcast [4 x float]* %3 to i8*
%14 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 0
%15 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 0
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i64 0, i64 0), double 3.000000e+00, double 2.000000e+00, double 1.000000e+00, double 0x3FC99999A0000000, double 0x3FD99999A0000000, double 0x3FE3333340000000, double 0x3FE99999A0000000)
%17 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%18 = call i32 @horner_fma_sp(float* %15, float* %14, i32 3, float* %17)
%19 = load float, float* %17
%20 = fpext float %19 to double
%21 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 1
%22 = load float, float* %21
%23 = fpext float %22 to double
%24 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 2
%25 = load float, float* %24
%26 = fpext float %25 to double
%27 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 3
%28 = load float, float* %27
%29 = fpext float %28 to double
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), double %20, double %23, double %26, double %29)
%31 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.7, i64 0, i64 0))
%32 = bitcast [3 x double]* %4 to i8*
%33 = bitcast [2 x double]* %5 to i8*
%34 = bitcast [2 x double]* %6 to i8*
%35 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%36 = getelementptr inbounds [2 x double], [2 x double]* %5, i64 0, i64 0
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.4, i64 0, i64 0), double 3.000000e+00, double 2.000000e+00, double 1.000000e+00, double 0x3FD5555555555555, double 0x3FE5555555555555)
%38 = getelementptr inbounds [2 x double], [2 x double]* %6, i64 0, i64 0
%39 = call i32 @horner_fma_dp(double* %36, double* %35, i32 3, double* %38)
%40 = load double, double* %38
%41 = getelementptr inbounds [2 x double], [2 x double]* %6, i64 0, i64 1
%42 = load double, double* %41
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), double %40, double %42)
%44 = bitcast [10 x float]* %7 to i8*
%45 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 1
store float 1.000000e+00, float* %45
%46 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 3
store float 0xBFC5555560000000, float* %46
%47 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 5
store float 0x3F81111120000000, float* %47
%48 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 7
store float 0xBF2A01A020000000, float* %48
%49 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 9
store float 0x3EC71DE3A0000000, float* %49
%50 = bitcast [8 x float]* %8 to i8*
%51 = bitcast [8 x float]* %9 to i8*
%52 = getelementptr inbounds [8 x float], [8 x float]* %8, i64 0, i64 0
%53 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 0
%54 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 0
%55 = call i32 @horner_fma_sp_avx2(float* %52, float* %53, i32 10, float* %54)
%56 = load float, float* %54
%57 = fpext float %56 to double
%58 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 1
%59 = load float, float* %58
%60 = fpext float %59 to double
%61 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 2
%62 = load float, float* %61
%63 = fpext float %62 to double
%64 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 3
%65 = load float, float* %64
%66 = fpext float %65 to double
%67 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 4
%68 = load float, float* %67
%69 = fpext float %68 to double
%70 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 5
%71 = load float, float* %70
%72 = fpext float %71 to double
%73 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 6
%74 = load float, float* %73
%75 = fpext float %74 to double
%76 = getelementptr inbounds [8 x float], [8 x float]* %9, i64 0, i64 7
%77 = load float, float* %76
%78 = fpext float %77 to double
%79 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %57, double %60, double %63, double %66, double %69, double %72, double %75, double %78)
ret i32 0
}