#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 pow(double, int);
int simpson(double *data, int n_point, int col, int off, double *integral) {
  int i;
  double val = 0;
  double x0, x1, x2, fx0, fx1, fx2;
  double dd_x0x1;
  double dd_x1x2;
  double dd_x0x1x2;
  int beg = 0;
  if ((n_point % 2) != 1) {
    beg = 1;
    x0 = data[0 + 0 * col];
    x1 = data[0 + 1 * col];
    fx0 = data[off + 0 * col];
    fx1 = data[off + 1 * col];
    val += (fx0 + fx1) * (x1 - x0) / 2;
  }
  for (i = beg; i < n_point - 2; i += 2) {
    x0 = data[0 + (i + 0) * col];
    x1 = data[0 + (i + 1) * col];
    x2 = data[0 + (i + 2) * col];
    fx0 = data[off + (i + 0) * col];
    fx1 = data[off + (i + 1) * col];
    fx2 = data[off + (i + 2) * col];
    dd_x0x1 = (fx1 - fx0) / (x1 - x0);
    dd_x1x2 = (fx2 - fx1) / (x2 - x1);
    dd_x0x1x2 = (dd_x1x2 - dd_x0x1) / (x2 - x0);
    val += (fx0 - dd_x0x1 * x0 + dd_x0x1x2 * x0 * x1) * (x2 - x0) +
           (dd_x0x1 - dd_x0x1x2 * (x0 + x1)) * (pow(x2, 2) - pow(x0, 2)) / 2 +
           dd_x0x1x2 * (pow(x2, 3) - pow(x0, 3)) / 3;
  }
  *integral = val;
  return 0;
}


x86 assembly (clang, -O0):
<simpson>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
je     11ec <simpson+0xdc>
movl   $0x1,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x0,-0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
shl    $0x0,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   $0x0,-0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe22(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1499 <simpson+0x389>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   -0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   -0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    $0x0,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x68(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
addsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0xb8(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
movaps %xmm0,%xmm4
movsd  -0xa0(%rbp),%xmm0
ff
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movsd  0xbf9(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mov    $0x3,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x3,%edi
call   1030 <pow@plt>
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xb8f(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    11f2 <simpson+0xe2>
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simpson>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r8,0x28(%rsp)
mov    %rdi,%rbx
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
and    $0xfffffffe,%eax
mov    %esi,%edi
sub    %eax,%edi
movslq %edx,%rax
movslq %ecx,%r15
cmp    $0x1,%edi
jne    114a <simpson+0x3a>
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
jmp    117e <simpson+0x6e>
movsd  (%rbx,%rax,8),%xmm0
movsd  (%rbx,%r15,8),%xmm1
lea    (%r15,%rax,1),%ecx
movslq %ecx,%rcx
addsd  (%rbx,%rcx,8),%xmm1
subsd  (%rbx),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0xe8f(%rip),%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    $0x1,%ecx
add    $0xfffffffe,%esi
cmp    %esi,%ecx
jge    1354 <simpson+0x244>
mov    %ecx,%r12d
movslq %esi,%rcx
mov    %rcx,0x48(%rsp)
lea    0x1(%r12),%rbp
imul   %rax,%rbp
lea    0x0(,%r15,8),%rcx
lea    (%rcx,%rbp,8),%rsi
mov    %rsi,0x40(%rsp)
shl    $0x3,%rbp
mov    %rax,%rsi
shl    $0x4,%rsi
mov    %rsi,0x38(%rsp)
mov    %rax,%r13
imul   %r12,%r13
add    %r13,%r15
lea    0x2(%r12),%r14
imul   %rax,%r14
lea    (%rcx,%r14,8),%rax
mov    %rax,0x30(%rsp)
shl    $0x3,%r14
xchg   %ax,%ax
movsd  %xmm1,0x58(%rsp)
movsd  (%rbx,%r13,8),%xmm6
movsd  (%rbx,%rbp,1),%xmm0
movsd  (%rbx,%r14,1),%xmm7
movsd  (%rbx,%r15,8),%xmm1
mov    0x30(%rsp),%rax
movsd  (%rbx,%rax,1),%xmm5
mov    0x40(%rsp),%rax
movsd  (%rbx,%rax,1),%xmm2
unpcklpd %xmm2,%xmm5
unpcklpd %xmm1,%xmm2
movapd %xmm7,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm5
unpcklpd %xmm6,%xmm4
subpd  %xmm4,%xmm3
divpd  %xmm3,%xmm5
movapd %xmm5,%xmm3
unpckhpd %xmm5,%xmm3
subsd  %xmm3,%xmm5
movapd %xmm7,%xmm2
movapd %xmm7,0x80(%rsp)
movapd %xmm6,0x60(%rsp)
subsd  %xmm6,%xmm2
movapd %xmm2,(%rsp)
divsd  %xmm2,%xmm5
movapd %xmm3,%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm2,%xmm1
movapd %xmm6,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm5,0x90(%rsp)
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,0x10(%rsp)
addsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm3
movapd %xmm3,0x70(%rsp)
add    $0x2,%r12
movapd %xmm7,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x50(%rsp)
movapd 0x60(%rsp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x70(%rsp),%xmm1
mulsd  0xd22(%rip),%xmm1
movapd 0x10(%rsp),%xmm0
mulsd  (%rsp),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,0x10(%rsp)
movaps 0x80(%rsp),%xmm0
mov    $0x3,%edi
call   1030 <pow@plt>
movsd  %xmm0,(%rsp)
movapd 0x60(%rsp),%xmm0
mov    $0x3,%edi
call   1030 <pow@plt>
movsd  0x58(%rsp),%xmm1
movsd  (%rsp),%xmm2
subsd  %xmm0,%xmm2
mulsd  0x90(%rsp),%xmm2
divsd  0xcce(%rip),%xmm2
addsd  0x10(%rsp),%xmm2
addsd  %xmm2,%xmm1
add    0x38(%rsp),%rbx
cmp    0x48(%rsp),%r12
jl     11e0 <simpson+0xd0>
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax)
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @simpson(double* %0, i32 %1, i32 %2, i32 %3, double* %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca i32
store double* %0, double** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store double* %4, double** %10
store double 0.000000e+00, double* %12
store i32 0, i32* %22
%23 = load i32, i32* %7
%24 = srem i32 %23, 2
%25 = icmp ne i32 %24, 1
br i1 %25, label %26, label %67
26: ; preds = %5
store i32 1, i32* %22
%27 = load double*, double** %6
%28 = load i32, i32* %8
%29 = mul nsw i32 0, %28
%30 = add nsw i32 0, %29
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %27, i64 %31
%33 = load double, double* %32
store double %33, double* %13
%34 = load double*, double** %6
%35 = load i32, i32* %8
%36 = mul nsw i32 1, %35
%37 = add nsw i32 0, %36
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %34, i64 %38
%40 = load double, double* %39
store double %40, double* %14
%41 = load double*, double** %6
%42 = load i32, i32* %9
%43 = load i32, i32* %8
%44 = mul nsw i32 0, %43
%45 = add nsw i32 %42, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %41, i64 %46
%48 = load double, double* %47
store double %48, double* %16
%49 = load double*, double** %6
%50 = load i32, i32* %9
%51 = load i32, i32* %8
%52 = mul nsw i32 1, %51
%53 = add nsw i32 %50, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %49, i64 %54
%56 = load double, double* %55
store double %56, double* %17
%57 = load double, double* %16
%58 = load double, double* %17
%59 = fadd double %57, %58
%60 = load double, double* %14
%61 = load double, double* %13
%62 = fsub double %60, %61
%63 = fmul double %59, %62
%64 = fdiv double %63, 2.000000e+00
%65 = load double, double* %12
%66 = fadd double %65, %64
store double %66, double* %12
br label %67
67: ; preds = %26, %5
%68 = load i32, i32* %22
store i32 %68, i32* %11
br label %69
69: ; preds = %192, %67
%70 = load i32, i32* %11
%71 = load i32, i32* %7
%72 = sub nsw i32 %71, 2
%73 = icmp slt i32 %70, %72
br i1 %73, label %74, label %195
74: ; preds = %69
%75 = load double*, double** %6
%76 = load i32, i32* %11
%77 = add nsw i32 %76, 0
%78 = load i32, i32* %8
%79 = mul nsw i32 %77, %78
%80 = add nsw i32 0, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %75, i64 %81
%83 = load double, double* %82
store double %83, double* %13
%84 = load double*, double** %6
%85 = load i32, i32* %11
%86 = add nsw i32 %85, 1
%87 = load i32, i32* %8
%88 = mul nsw i32 %86, %87
%89 = add nsw i32 0, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %84, i64 %90
%92 = load double, double* %91
store double %92, double* %14
%93 = load double*, double** %6
%94 = load i32, i32* %11
%95 = add nsw i32 %94, 2
%96 = load i32, i32* %8
%97 = mul nsw i32 %95, %96
%98 = add nsw i32 0, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %93, i64 %99
%101 = load double, double* %100
store double %101, double* %15
%102 = load double*, double** %6
%103 = load i32, i32* %9
%104 = load i32, i32* %11
%105 = add nsw i32 %104, 0
%106 = load i32, i32* %8
%107 = mul nsw i32 %105, %106
%108 = add nsw i32 %103, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %102, i64 %109
%111 = load double, double* %110
store double %111, double* %16
%112 = load double*, double** %6
%113 = load i32, i32* %9
%114 = load i32, i32* %11
%115 = add nsw i32 %114, 1
%116 = load i32, i32* %8
%117 = mul nsw i32 %115, %116
%118 = add nsw i32 %113, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %112, i64 %119
%121 = load double, double* %120
store double %121, double* %17
%122 = load double*, double** %6
%123 = load i32, i32* %9
%124 = load i32, i32* %11
%125 = add nsw i32 %124, 2
%126 = load i32, i32* %8
%127 = mul nsw i32 %125, %126
%128 = add nsw i32 %123, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %122, i64 %129
%131 = load double, double* %130
store double %131, double* %18
%132 = load double, double* %17
%133 = load double, double* %16
%134 = fsub double %132, %133
%135 = load double, double* %14
%136 = load double, double* %13
%137 = fsub double %135, %136
%138 = fdiv double %134, %137
store double %138, double* %19
%139 = load double, double* %18
%140 = load double, double* %17
%141 = fsub double %139, %140
%142 = load double, double* %15
%143 = load double, double* %14
%144 = fsub double %142, %143
%145 = fdiv double %141, %144
store double %145, double* %20
%146 = load double, double* %20
%147 = load double, double* %19
%148 = fsub double %146, %147
%149 = load double, double* %15
%150 = load double, double* %13
%151 = fsub double %149, %150
%152 = fdiv double %148, %151
store double %152, double* %21
%153 = load double, double* %16
%154 = load double, double* %19
%155 = load double, double* %13
%156 = fneg double %154
%157 = call double @llvm.fmuladd.f64(double %156, double %155, double %153)
%158 = load double, double* %21
%159 = load double, double* %13
%160 = fmul double %158, %159
%161 = load double, double* %14
%162 = call double @llvm.fmuladd.f64(double %160, double %161, double %157)
%163 = load double, double* %15
%164 = load double, double* %13
%165 = fsub double %163, %164
%166 = load double, double* %19
%167 = load double, double* %21
%168 = load double, double* %13
%169 = load double, double* %14
%170 = fadd double %168, %169
%171 = fneg double %167
%172 = call double @llvm.fmuladd.f64(double %171, double %170, double %166)
%173 = load double, double* %15
%174 = call double @pow(double %173, i32 2)
%175 = load double, double* %13
%176 = call double @pow(double %175, i32 2)
%177 = fsub double %174, %176
%178 = fmul double %172, %177
%179 = fdiv double %178, 2.000000e+00
%180 = call double @llvm.fmuladd.f64(double %162, double %165, double %179)
%181 = load double, double* %21
%182 = load double, double* %15
%183 = call double @pow(double %182, i32 3)
%184 = load double, double* %13
%185 = call double @pow(double %184, i32 3)
%186 = fsub double %183, %185
%187 = fmul double %181, %186
%188 = fdiv double %187, 3.000000e+00
%189 = fadd double %180, %188
%190 = load double, double* %12
%191 = fadd double %190, %189
store double %191, double* %12
br label %192
192: ; preds = %74
%193 = load i32, i32* %11
%194 = add nsw i32 %193, 2
store i32 %194, i32* %11
br label %69
195: ; preds = %69
%196 = load double, double* %12
%197 = load double*, double** %10
store double %196, double* %197
ret i32 0
}

LLVM IR (-O2):
define i32 @simpson(double* nocapture %0, i32 %1, i32 %2, i32 %3, double* nocapture writeonly %4) {
%6 = srem i32 %1, 2
%7 = icmp eq i32 %6, 1
br i1 %7, label %25, label %8
8: ; preds = %5
%9 = load double, double* %0
%10 = sext i32 %2 to i64
%11 = getelementptr inbounds double, double* %0, i64 %10
%12 = load double, double* %11
%13 = sext i32 %3 to i64
%14 = getelementptr inbounds double, double* %0, i64 %13
%15 = load double, double* %14
%16 = add nsw i32 %3, %2
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds double, double* %0, i64 %17
%19 = load double, double* %18
%20 = fadd double %15, %19
%21 = fsub double %12, %9
%22 = fmul double %21, %20
%23 = fmul double %22, 5.000000e-01
%24 = fadd double %23, 0.000000e+00
br label %25
25: ; preds = %8, %5
%26 = phi double [ %24, %8 ], [ 0.000000e+00, %5 ]
%27 = phi i32 [ 1, %8 ], [ 0, %5 ]
%28 = add nsw i32 %1, -2
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %95
30: ; preds = %25
%31 = zext i32 %27 to i64
%32 = sext i32 %2 to i64
%33 = sext i32 %3 to i64
%34 = sext i32 %28 to i64
br label %35
35: ; preds = %30, %35
%36 = phi i64 [ %31, %30 ], [ %45, %35 ]
%37 = phi double [ %26, %30 ], [ %93, %35 ]
%38 = mul nsw i64 %36, %32
%39 = getelementptr inbounds double, double* %0, i64 %38
%40 = load double, double* %39
%41 = add nuw nsw i64 %36, 1
%42 = mul nsw i64 %41, %32
%43 = getelementptr inbounds double, double* %0, i64 %42
%44 = load double, double* %43
%45 = add nuw nsw i64 %36, 2
%46 = mul nsw i64 %45, %32
%47 = getelementptr inbounds double, double* %0, i64 %46
%48 = load double, double* %47
%49 = add nsw i64 %38, %33
%50 = getelementptr inbounds double, double* %0, i64 %49
%51 = load double, double* %50
%52 = add nsw i64 %42, %33
%53 = getelementptr inbounds double, double* %0, i64 %52
%54 = load double, double* %53
%55 = add nsw i64 %46, %33
%56 = getelementptr inbounds double, double* %0, i64 %55
%57 = load double, double* %56
%58 = insertelement <2 x double> poison, double %57, i64 0
%59 = insertelement <2 x double> %58, double %54, i64 1
%60 = insertelement <2 x double> poison, double %54, i64 0
%61 = insertelement <2 x double> %60, double %51, i64 1
%62 = fsub <2 x double> %59, %61
%63 = insertelement <2 x double> poison, double %48, i64 0
%64 = insertelement <2 x double> %63, double %44, i64 1
%65 = insertelement <2 x double> poison, double %44, i64 0
%66 = insertelement <2 x double> %65, double %40, i64 1
%67 = fsub <2 x double> %64, %66
%68 = fdiv <2 x double> %62, %67
%69 = extractelement <2 x double> %68, i64 0
%70 = extractelement <2 x double> %68, i64 1
%71 = fsub double %69, %70
%72 = fsub double %48, %40
%73 = fdiv double %71, %72
%74 = fneg double %70
%75 = tail call double @llvm.fmuladd.f64(double %74, double %40, double %51)
%76 = fmul double %40, %73
%77 = tail call double @llvm.fmuladd.f64(double %76, double %44, double %75)
%78 = fadd double %40, %44
%79 = fneg double %73
%80 = tail call double @llvm.fmuladd.f64(double %79, double %78, double %70)
%81 = tail call double @pow(double %48, i32 2)
%82 = tail call double @pow(double %40, i32 2)
%83 = fsub double %81, %82
%84 = fmul double %83, %80
%85 = fmul double %84, 5.000000e-01
%86 = tail call double @llvm.fmuladd.f64(double %77, double %72, double %85)
%87 = tail call double @pow(double %48, i32 3)
%88 = tail call double @pow(double %40, i32 3)
%89 = fsub double %87, %88
%90 = fmul double %73, %89
%91 = fdiv double %90, 3.000000e+00
%92 = fadd double %91, %86
%93 = fadd double %37, %92
%94 = icmp slt i64 %45, %34
br i1 %94, label %35, label %95
95: ; preds = %35, %25
%96 = phi double [ %26, %25 ], [ %93, %35 ]
store double %96, double* %4
ret i32 0
}