#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 *malloc(unsigned int const);
void poly2(const double *r, const double *s, const double *t,
           const unsigned int Nn, double **f, double **f_r, double **f_s,
           double **f_t) {
  unsigned int i;
  double *f_rst, *f_r_rst, *f_s_rst, *f_t_rst;
  double r_i, s_i, t_i;
  f_rst = malloc(Nn * sizeof *f_rst);
  f_r_rst = malloc(Nn * sizeof *f_r_rst);
  f_s_rst = malloc(Nn * sizeof *f_s_rst);
  f_t_rst = malloc(Nn * sizeof *f_t_rst);
  for (i = 0; i < Nn; i++) {
    r_i = r[i];
    s_i = s[i];
    t_i = t[i];
    f_rst[i] = 1.0 + 2.0 * r_i + 3.0 * s_i + 4.0 * t_i + 5.0 * r_i * r_i +
               6.0 * r_i * s_i + 7.0 * r_i * t_i + 8.0 * s_i * s_i +
               9.0 * s_i * t_i + 10.0 * t_i * t_i;
    f_r_rst[i] = 2.0 + 10.0 * r_i + 6.0 * s_i + 7.0 * t_i;
    f_s_rst[i] = 3.0 + 6.0 * r_i + 16.0 * s_i + 9.0 * t_i;
    f_t_rst[i] = 4.0 + 7.0 * r_i + 9.0 * s_i + 20.0 * t_i;
  }
  *f = f_rst;
  *f_r = f_r_rst;
  *f_s = f_s_rst;
  *f_t = f_t_rst;
}


x86 assembly (clang, -O0):
<poly2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    13b3 <poly2+0x2a3>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  0xe82(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  0xe49(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xe1c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe44(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe02(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xdd0(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdee(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd94(%rip),%xmm1
mulsd  -0x68(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdaa(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  0xd7f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd7b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  0xd52(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xd25(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  0xd1c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd18(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  0xcf7(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xcca(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  0xcb1(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xcad(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  0xc8c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xc6f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1186 <poly2+0x76>
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x50(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x58(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<poly2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,0x18(%rsp)
mov    %ecx,%r12d
mov    %rdx,%rbp
mov    %rsi,%r14
mov    %rdi,%r15
lea    0x0(,%r12,8),%r13d
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,%rbx
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r13d,%edi
mov    %rbx,%r13
call   1030 <malloc@plt>
test   %r12d,%r12d
je     14c5 <poly2+0x3b5>
mov    %r12d,%r8d
cmp    $0x1,%r12d
jne    1186 <poly2+0x76>
xor    %r9d,%r9d
jmp    1320 <poly2+0x210>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ecx,%ecx
movapd 0xe78(%rip),%xmm14
movapd 0xe7f(%rip),%xmm15
movapd 0xe96(%rip),%xmm11
movapd 0xe9d(%rip),%xmm12
movapd 0xeb5(%rip),%xmm7
movapd 0xebd(%rip),%xmm0
movapd 0xee4(%rip),%xmm13
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm9
movupd 0x0(%rbp,%rcx,8),%xmm6
movapd %xmm1,%xmm2
addpd  %xmm1,%xmm2
addpd  0xdfe(%rip),%xmm2
movapd %xmm9,%xmm3
mulpd  %xmm14,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm6,%xmm2
mulpd  %xmm15,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm1,%xmm3
mulpd  0xe07(%rip),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm1,%xmm2
mulpd  %xmm11,%xmm2
movapd %xmm2,%xmm4
mulpd  %xmm9,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm1,%xmm8
mulpd  %xmm12,%xmm8
movapd %xmm8,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm9,%xmm3
mulpd  0xdf5(%rip),%xmm3
mulpd  %xmm9,%xmm3
addpd  %xmm5,%xmm3
movapd %xmm9,%xmm10
mulpd  %xmm7,%xmm10
addpd  %xmm15,%xmm8
addpd  %xmm10,%xmm8
mulpd  %xmm6,%xmm10
addpd  %xmm3,%xmm10
movapd %xmm6,%xmm3
mulpd  %xmm0,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm10,%xmm3
movupd %xmm3,0x0(%r13,%rcx,8)
mulpd  %xmm0,%xmm1
addpd  0xdda(%rip),%xmm1
movapd %xmm9,%xmm3
mulpd  %xmm11,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm6,%xmm1
mulpd  %xmm12,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rdx,%rcx,8)
addpd  %xmm14,%xmm2
mulpd  0xdbc(%rip),%xmm9
addpd  %xmm2,%xmm9
movapd %xmm6,%xmm1
mulpd  %xmm7,%xmm1
addpd  %xmm9,%xmm1
movupd %xmm1,(%rsi,%rcx,8)
mulpd  %xmm13,%xmm6
addpd  %xmm8,%xmm6
movupd %xmm6,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    11e0 <poly2+0xd0>
cmp    %r8,%r9
je     14c5 <poly2+0x3b5>
lea    (%r15,%r9,8),%r10
lea    (%r14,%r9,8),%r11
lea    0x0(%rbp,%r9,8),%rbp
lea    0x0(,%r9,8),%rbx
add    %r13,%rbx
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
mov    0x8(%rsp),%rdx
lea    (%rdx,%r9,8),%rdx
lea    (%rax,%r9,8),%rsi
sub    %r9,%r8
xor    %edi,%edi
movsd  0xd6c(%rip),%xmm14
movsd  0xd6b(%rip),%xmm15
movsd  0xd72(%rip),%xmm11
movsd  0xd71(%rip),%xmm12
movsd  0xd79(%rip),%xmm7
movsd  0xd79(%rip),%xmm0
movsd  0xd88(%rip),%xmm13
movsd  (%r10,%rdi,8),%xmm1
movsd  (%r11,%rdi,8),%xmm9
movsd  0x0(%rbp,%rdi,8),%xmm6
movapd %xmm1,%xmm2
addsd  %xmm1,%xmm2
addsd  0xd0e(%rip),%xmm2
movapd %xmm9,%xmm3
mulsd  %xmm14,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm6,%xmm2
mulsd  %xmm15,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm1,%xmm3
mulsd  0xcff(%rip),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm1,%xmm2
mulsd  %xmm11,%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm1,%xmm8
mulsd  %xmm12,%xmm8
movapd %xmm8,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm9,%xmm3
mulsd  0xcd5(%rip),%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm9,%xmm10
mulsd  %xmm7,%xmm10
addsd  %xmm15,%xmm8
addsd  %xmm10,%xmm8
mulsd  %xmm6,%xmm10
addsd  %xmm3,%xmm10
movapd %xmm6,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm10,%xmm3
movsd  %xmm3,(%rbx,%rdi,8)
mulsd  %xmm0,%xmm1
addsd  0xca4(%rip),%xmm1
movapd %xmm9,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm6,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
addsd  %xmm14,%xmm2
mulsd  0xc7e(%rip),%xmm9
addsd  %xmm2,%xmm9
movapd %xmm6,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm9,%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
mulsd  %xmm13,%xmm6
addsd  %xmm8,%xmm6
movsd  %xmm6,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r8
jne    1390 <poly2+0x280>
mov    0x18(%rsp),%rcx
mov    %r13,(%rcx)
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    %rdx,(%rcx)
mov    0x60(%rsp),%rcx
mov    0x8(%rsp),%rdx
mov    %rdx,(%rcx)
mov    0x68(%rsp),%rcx
mov    %rax,(%rcx)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @poly2(double* %0, double* %1, double* %2, i32 %3, double** %4, double** %5, double** %6, double** %7) {
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca double**
%14 = alloca double**
%15 = alloca double**
%16 = alloca double**
%17 = alloca i32
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double
%23 = alloca double
%24 = alloca double
store double* %0, double** %9
store double* %1, double** %10
store double* %2, double** %11
store i32 %3, i32* %12
store double** %4, double*** %13
store double** %5, double*** %14
store double** %6, double*** %15
store double** %7, double*** %16
%25 = load i32, i32* %12
%26 = zext i32 %25 to i64
%27 = mul i64 %26, 8
%28 = trunc i64 %27 to i32
%29 = call double* @malloc(i32 %28)
store double* %29, double** %18
%30 = load i32, i32* %12
%31 = zext i32 %30 to i64
%32 = mul i64 %31, 8
%33 = trunc i64 %32 to i32
%34 = call double* @malloc(i32 %33)
store double* %34, double** %19
%35 = load i32, i32* %12
%36 = zext i32 %35 to i64
%37 = mul i64 %36, 8
%38 = trunc i64 %37 to i32
%39 = call double* @malloc(i32 %38)
store double* %39, double** %20
%40 = load i32, i32* %12
%41 = zext i32 %40 to i64
%42 = mul i64 %41, 8
%43 = trunc i64 %42 to i32
%44 = call double* @malloc(i32 %43)
store double* %44, double** %21
store i32 0, i32* %17
br label %45
45: ; preds = %129, %8
%46 = load i32, i32* %17
%47 = load i32, i32* %12
%48 = icmp ult i32 %46, %47
br i1 %48, label %49, label %132
49: ; preds = %45
%50 = load double*, double** %9
%51 = load i32, i32* %17
%52 = zext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
%54 = load double, double* %53
store double %54, double* %22
%55 = load double*, double** %10
%56 = load i32, i32* %17
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
store double %59, double* %23
%60 = load double*, double** %11
%61 = load i32, i32* %17
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
store double %64, double* %24
%65 = load double, double* %22
%66 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %65, double 1.000000e+00)
%67 = load double, double* %23
%68 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %67, double %66)
%69 = load double, double* %24
%70 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %69, double %68)
%71 = load double, double* %22
%72 = fmul double 5.000000e+00, %71
%73 = load double, double* %22
%74 = call double @llvm.fmuladd.f64(double %72, double %73, double %70)
%75 = load double, double* %22
%76 = fmul double 6.000000e+00, %75
%77 = load double, double* %23
%78 = call double @llvm.fmuladd.f64(double %76, double %77, double %74)
%79 = load double, double* %22
%80 = fmul double 7.000000e+00, %79
%81 = load double, double* %24
%82 = call double @llvm.fmuladd.f64(double %80, double %81, double %78)
%83 = load double, double* %23
%84 = fmul double 8.000000e+00, %83
%85 = load double, double* %23
%86 = call double @llvm.fmuladd.f64(double %84, double %85, double %82)
%87 = load double, double* %23
%88 = fmul double 9.000000e+00, %87
%89 = load double, double* %24
%90 = call double @llvm.fmuladd.f64(double %88, double %89, double %86)
%91 = load double, double* %24
%92 = fmul double 1.000000e+01, %91
%93 = load double, double* %24
%94 = call double @llvm.fmuladd.f64(double %92, double %93, double %90)
%95 = load double*, double** %18
%96 = load i32, i32* %17
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
store double %94, double* %98
%99 = load double, double* %22
%100 = call double @llvm.fmuladd.f64(double 1.000000e+01, double %99, double 2.000000e+00)
%101 = load double, double* %23
%102 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %101, double %100)
%103 = load double, double* %24
%104 = call double @llvm.fmuladd.f64(double 7.000000e+00, double %103, double %102)
%105 = load double*, double** %19
%106 = load i32, i32* %17
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
store double %104, double* %108
%109 = load double, double* %22
%110 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %109, double 3.000000e+00)
%111 = load double, double* %23
%112 = call double @llvm.fmuladd.f64(double 1.600000e+01, double %111, double %110)
%113 = load double, double* %24
%114 = call double @llvm.fmuladd.f64(double 9.000000e+00, double %113, double %112)
%115 = load double*, double** %20
%116 = load i32, i32* %17
%117 = zext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
store double %114, double* %118
%119 = load double, double* %22
%120 = call double @llvm.fmuladd.f64(double 7.000000e+00, double %119, double 4.000000e+00)
%121 = load double, double* %23
%122 = call double @llvm.fmuladd.f64(double 9.000000e+00, double %121, double %120)
%123 = load double, double* %24
%124 = call double @llvm.fmuladd.f64(double 2.000000e+01, double %123, double %122)
%125 = load double*, double** %21
%126 = load i32, i32* %17
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
store double %124, double* %128
br label %129
129: ; preds = %49
%130 = load i32, i32* %17
%131 = add i32 %130, 1
store i32 %131, i32* %17
br label %45
132: ; preds = %45
%133 = load double*, double** %18
%134 = load double**, double*** %13
store double* %133, double** %134
%135 = load double*, double** %19
%136 = load double**, double*** %14
store double* %135, double** %136
%137 = load double*, double** %20
%138 = load double**, double*** %15
store double* %137, double** %138
%139 = load double*, double** %21
%140 = load double**, double*** %16
store double* %139, double** %140
ret void
}

LLVM IR (-O2):
define void @poly2(double* nocapture %0, double* nocapture %1, double* nocapture %2, i32 %3, double** nocapture writeonly %4, double** nocapture writeonly %5, double** nocapture writeonly %6, double** nocapture writeonly %7) {
%9 = shl i32 %3, 3
%10 = tail call double* @malloc(i32 %9)
%11 = tail call double* @malloc(i32 %9)
%12 = tail call double* @malloc(i32 %9)
%13 = tail call double* @malloc(i32 %9)
%14 = icmp eq i32 %3, 0
br i1 %14, label %107, label %15
15: ; preds = %8
%16 = zext i32 %3 to i64
%17 = icmp eq i32 %3, 1
br i1 %17, label %67, label %18
18: ; preds = %15
%19 = and i64 %16, 4294967294
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ 0, %18 ], [ %63, %20 ]
%22 = getelementptr inbounds double, double* %0, i64 %21
%23 = bitcast double* %22 to <2 x double>*
%24 = load <2 x double>, <2 x double>* %23
%25 = getelementptr inbounds double, double* %1, i64 %21
%26 = bitcast double* %25 to <2 x double>*
%27 = load <2 x double>, <2 x double>* %26
%28 = getelementptr inbounds double, double* %2, i64 %21
%29 = bitcast double* %28 to <2 x double>*
%30 = load <2 x double>, <2 x double>* %29
%31 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %24, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%32 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %31)
%33 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %30, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %32)
%34 = fmul <2 x double> %24, <double 5.000000e+00, double 5.000000e+00>
%35 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %34, <2 x double> %24, <2 x double> %33)
%36 = fmul <2 x double> %24, <double 6.000000e+00, double 6.000000e+00>
%37 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %36, <2 x double> %27, <2 x double> %35)
%38 = fmul <2 x double> %24, <double 7.000000e+00, double 7.000000e+00>
%39 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %30, <2 x double> %37)
%40 = fmul <2 x double> %27, <double 8.000000e+00, double 8.000000e+00>
%41 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %27, <2 x double> %39)
%42 = fmul <2 x double> %27, <double 9.000000e+00, double 9.000000e+00>
%43 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %42, <2 x double> %30, <2 x double> %41)
%44 = fmul <2 x double> %30, <double 1.000000e+01, double 1.000000e+01>
%45 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> %30, <2 x double> %43)
%46 = getelementptr inbounds double, double* %10, i64 %21
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> %45, <2 x double>* %47
%48 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %24, <2 x double> <double 1.000000e+01, double 1.000000e+01>, <2 x double> <double 2.000000e+00, double 2.000000e+00>)
%49 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %48)
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %30, <2 x double> <double 7.000000e+00, double 7.000000e+00>, <2 x double> %49)
%51 = getelementptr inbounds double, double* %11, i64 %21
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> %50, <2 x double>* %52
%53 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %24, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> <double 3.000000e+00, double 3.000000e+00>)
%54 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> <double 1.600000e+01, double 1.600000e+01>, <2 x double> %53)
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %30, <2 x double> <double 9.000000e+00, double 9.000000e+00>, <2 x double> %54)
%56 = getelementptr inbounds double, double* %12, i64 %21
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %55, <2 x double>* %57
%58 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %24, <2 x double> <double 7.000000e+00, double 7.000000e+00>, <2 x double> <double 4.000000e+00, double 4.000000e+00>)
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> <double 9.000000e+00, double 9.000000e+00>, <2 x double> %58)
%60 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %30, <2 x double> <double 2.000000e+01, double 2.000000e+01>, <2 x double> %59)
%61 = getelementptr inbounds double, double* %13, i64 %21
%62 = bitcast double* %61 to <2 x double>*
store <2 x double> %60, <2 x double>* %62
%63 = add nuw i64 %21, 2
%64 = icmp eq i64 %63, %19
br i1 %64, label %65, label %20
65: ; preds = %20
%66 = icmp eq i64 %19, %16
br i1 %66, label %107, label %67
67: ; preds = %15, %65
%68 = phi i64 [ 0, %15 ], [ %19, %65 ]
br label %69
69: ; preds = %67, %69
%70 = phi i64 [ %105, %69 ], [ %68, %67 ]
%71 = getelementptr inbounds double, double* %0, i64 %70
%72 = load double, double* %71
%73 = getelementptr inbounds double, double* %1, i64 %70
%74 = load double, double* %73
%75 = getelementptr inbounds double, double* %2, i64 %70
%76 = load double, double* %75
%77 = tail call double @llvm.fmuladd.f64(double %72, double 2.000000e+00, double 1.000000e+00)
%78 = tail call double @llvm.fmuladd.f64(double %74, double 3.000000e+00, double %77)
%79 = tail call double @llvm.fmuladd.f64(double %76, double 4.000000e+00, double %78)
%80 = fmul double %72, 5.000000e+00
%81 = tail call double @llvm.fmuladd.f64(double %80, double %72, double %79)
%82 = fmul double %72, 6.000000e+00
%83 = tail call double @llvm.fmuladd.f64(double %82, double %74, double %81)
%84 = fmul double %72, 7.000000e+00
%85 = tail call double @llvm.fmuladd.f64(double %84, double %76, double %83)
%86 = fmul double %74, 8.000000e+00
%87 = tail call double @llvm.fmuladd.f64(double %86, double %74, double %85)
%88 = fmul double %74, 9.000000e+00
%89 = tail call double @llvm.fmuladd.f64(double %88, double %76, double %87)
%90 = fmul double %76, 1.000000e+01
%91 = tail call double @llvm.fmuladd.f64(double %90, double %76, double %89)
%92 = getelementptr inbounds double, double* %10, i64 %70
store double %91, double* %92
%93 = tail call double @llvm.fmuladd.f64(double %72, double 1.000000e+01, double 2.000000e+00)
%94 = tail call double @llvm.fmuladd.f64(double %74, double 6.000000e+00, double %93)
%95 = tail call double @llvm.fmuladd.f64(double %76, double 7.000000e+00, double %94)
%96 = getelementptr inbounds double, double* %11, i64 %70
store double %95, double* %96
%97 = tail call double @llvm.fmuladd.f64(double %72, double 6.000000e+00, double 3.000000e+00)
%98 = tail call double @llvm.fmuladd.f64(double %74, double 1.600000e+01, double %97)
%99 = tail call double @llvm.fmuladd.f64(double %76, double 9.000000e+00, double %98)
%100 = getelementptr inbounds double, double* %12, i64 %70
store double %99, double* %100
%101 = tail call double @llvm.fmuladd.f64(double %72, double 7.000000e+00, double 4.000000e+00)
%102 = tail call double @llvm.fmuladd.f64(double %74, double 9.000000e+00, double %101)
%103 = tail call double @llvm.fmuladd.f64(double %76, double 2.000000e+01, double %102)
%104 = getelementptr inbounds double, double* %13, i64 %70
store double %103, double* %104
%105 = add nuw nsw i64 %70, 1
%106 = icmp eq i64 %105, %16
br i1 %106, label %107, label %69
107: ; preds = %69, %65, %8
store double* %10, double** %4
store double* %11, double** %5
store double* %12, double** %6
store double* %13, double** %7
ret void
}