#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*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ sortdi1(double *, int, int *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ subspl(double *, double *, int, double *, double *);
double splint(double xx[], double yy[], int n, double xi) {
  int flag, i, *jun, *k;
  double dxp, dxm, *h, hi, hi2, *p, *q, *r, *s, sm, si, *sp, *x, *y, yi;
  x = (double *)malloc(n * sizeof(double));
  if (x == NULL) {
    fprintf(stderr, "Error : Out of memory  in splint()\n");
    return 0.;
  }
  y = (double *)malloc(n * sizeof(double));
  if (y == NULL) {
    fprintf(stderr, "Error : Out of memory  in splint()\n");
    free((char *)x);
    return 0.;
  }
  for (i = 0, p = xx, flag = 0; i < n - 1; i++, p++) {
    if (*p >= *(p + 1)) {
      flag = 1;
      break;
    }
  }
  if (flag) {
    jun = (int *)malloc(n * sizeof(int));
    if (jun == NULL) {
      fprintf(stderr, "Error : Out of memory  in splint()\n");
      free((char *)x);
      free((char *)y);
      return 0.;
    }
    sortdi1(xx, n, jun);
    for (i = 0, p = x, q = y, k = jun; i < n; i++) {
      *p++ = *(xx + *k);
      *q++ = *(yy + *k++);
    }
    free((char *)jun);
  } else {
    for (i = 0, p = x, q = y, r = xx, s = yy; i < n; i++) {
      *p++ = *r++;
      *q++ = *s++;
    }
  }
  if (n < 2 || xi < *x || xi > *(x + n - 1)) {
    fprintf(stderr, "Error : Illegal parameter  in splint()\n");
    free((char *)x);
    free((char *)y);
    return 0.;
  }
  for (i = 0, p = x; i < n; i++) {
    if (*p++ == xi) {
      free((char *)x);
      free((char *)y);
      return *(y + i);
    }
  }
  h = (double *)malloc(n * sizeof(double));
  if (h == NULL) {
    fprintf(stderr, "Error : Out of memory  in splint()\n");
    free((char *)x);
    free((char *)y);
    return 0.;
  }
  sp = (double *)malloc(n * sizeof(double));
  if (sp == NULL) {
    fprintf(stderr, "Error : Out of memory  in splint()\n");
    free((char *)x);
    free((char *)y);
    free((char *)h);
    return 0.;
  }
  subspl(x, y, n - 1, h, sp);
  for (i = 1, p = x + 1; i <= n; i++, p++) {
    if (*(p - 1) <= xi && xi < *p) {
      sm = *(sp + i - 1);
      si = *(sp + i);
      hi = *(h + i);
      hi2 = hi * hi;
      dxp = *p - xi;
      dxm = xi - *(p - 1);
      yi = (sm * dxp * dxp * dxp + si * dxm * dxm * dxm +
            (6. * *(y + i - 1) - hi2 * sm) * dxp +
            (6. * *(y + i) - hi2 * si) * dxm) /
           hi / 6.;
      free((char *)x);
      free((char *)y);
      free((char *)h);
      free((char *)sp);
      return yi;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<splint>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
jne    11b1 <splint+0x61>
mov    0x2e4a(%rip),%rax
mov    (%rax),%edi
lea    0xe69(%rip),%rsi
call   1040 <fprintf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xb0(%rbp)
cmpq   $0x0,-0xb0(%rbp)
jne    1203 <splint+0xb3>
mov    0x2e04(%rip),%rax
mov    (%rax),%edi
lea    0xe23(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    126c <splint+0x11c>
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jb     124d <splint+0xfd>
movl   $0x1,-0x2c(%rbp)
jmp    126c <splint+0x11c>
jmp    1252 <splint+0x102>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
jmp    1219 <splint+0xc9>
cmpl   $0x0,-0x2c(%rbp)
je     137c <splint+0x22c>
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    12ce <splint+0x17e>
mov    0x2d45(%rip),%rax
mov    (%rax),%edi
lea    0xd64(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x38(%rbp),%rdx
call   1070 <sortdi1@plt>
movl   $0x0,-0x30(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    136e <splint+0x21e>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1303 <splint+0x1b3>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
jmp    141d <splint+0x2cd>
movl   $0x0,-0x30(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1418 <splint+0x2c8>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  %xmm0,(%rax)
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x88(%rbp)
movsd  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ac <splint+0x25c>
jmp    141d <splint+0x2cd>
cmpl   $0x2,-0x1c(%rbp)
jl     145d <splint+0x30d>
movsd  -0x28(%rbp),%xmm1
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
ja     145d <splint+0x30d>
movsd  -0x28(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
ucomisd -0x8(%rax,%rcx,8),%xmm0
jbe    1497 <splint+0x347>
mov    0x2b7c(%rip),%rax
mov    (%rax),%edi
lea    0xbbf(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
movl   $0x0,-0x30(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    151e <splint+0x3ce>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm0
ucomisd -0x28(%rbp),%xmm0
jne    150b <splint+0x3bb>
jp     150b <splint+0x3bb>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
jmp    1510 <splint+0x3c0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14a9 <splint+0x359>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    1576 <splint+0x426>
mov    0x2a9d(%rip),%rax
mov    (%rax),%edi
lea    0xabc(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa0(%rbp)
cmpq   $0x0,-0xa0(%rbp)
jne    15dd <splint+0x48d>
mov    0x2a3f(%rip),%rax
mov    (%rax),%edi
lea    0xa5e(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
mov    -0xa8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
mov    -0x58(%rbp),%rcx
mov    -0xa0(%rbp),%r8
call   1060 <subspl@plt>
movl   $0x1,-0x30(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1819 <splint+0x6c9>
mov    -0x70(%rbp),%rax
movsd  -0x8(%rax),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     17fa <splint+0x6aa>
movsd  -0x28(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    17fa <splint+0x6aa>
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x70(%rbp),%rax
subsd  -0x8(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  0x8c4(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  -0x98(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  0x873(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  0x851(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
jmp    1821 <splint+0x6d1>
jmp    17ff <splint+0x6af>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
jmp    1617 <splint+0x4c7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<splint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movsd  %xmm0,0x18(%rsp)
mov    %edx,%r15d
mov    %rsi,%rbp
mov    %rdi,%r12
lea    0x0(,%r15,8),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     11ee <splint+0x9e>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1208 <splint+0xb8>
mov    %rax,%r14
mov    %ebx,0x34(%rsp)
mov    %r15d,%ebx
lea    -0x1(%r15),%r10d
cmp    $0x2,%r15d
jl     11c8 <splint+0x78>
movsd  (%r12),%xmm0
mov    $0x1,%eax
nop
movapd %xmm0,%xmm1
movsd  (%r12,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
jae    1225 <splint+0xd5>
add    $0x1,%rax
cmp    %eax,%ebx
jne    11b0 <splint+0x60>
test   %r15d,%r15d
movsd  0x18(%rsp),%xmm1
jle    1637 <splint+0x4e7>
xor    %eax,%eax
cmp    $0x3,%r10d
jae    127e <splint+0x12e>
mov    %r13,%rcx
mov    %r14,%rdx
jmp    1540 <splint+0x3f0>
mov    0x2deb(%rip),%rax
mov    (%rax),%edi
lea    0xe1a(%rip),%rsi
call   1040 <fprintf@plt>
jmp    165c <splint+0x50c>
mov    0x2dd1(%rip),%rax
mov    (%rax),%edi
lea    0xe00(%rip),%rsi
call   1040 <fprintf@plt>
mov    %r13,%rdi
jmp    1657 <splint+0x507>
mov    %r10,0x10(%rsp)
lea    0x0(,%r15,4),%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     170d <splint+0x5bd>
mov    %r12,%rdi
mov    %r15d,%esi
mov    %rax,%rdx
mov    %rax,0x20(%rsp)
call   1070 <sortdi1@plt>
mov    0x20(%rsp),%rdi
mov    %rbx,0x28(%rsp)
test   %ebx,%ebx
jle    14c3 <splint+0x373>
cmpl   $0x3,0x10(%rsp)
jae    13dd <splint+0x28d>
mov    %rdi,%rax
mov    %r13,%r8
mov    %r14,%rsi
jmp    1486 <splint+0x336>
mov    %r10,0x10(%rsp)
mov    %r10d,%r10d
lea    0x8(,%r10,8),%rdi
add    %r13,%rdi
lea    (%r14,%r10,8),%r11
add    $0x8,%r11
lea    (%r12,%r10,8),%rsi
add    $0x8,%rsi
lea    0x8(,%r10,8),%rcx
add    %rbp,%rcx
cmp    %r11,%r13
setb   0x28(%rsp)
cmp    %rdi,%r14
setb   0x20(%rsp)
cmp    %rsi,%r13
setb   %dl
cmp    %r12,%rdi
seta   0xf(%rsp)
cmp    %rcx,%r13
setb   %r9b
cmp    %rbp,%rdi
seta   0xe(%rsp)
cmp    %rsi,%r14
setb   %dil
cmp    %r12,%r11
seta   %sil
cmp    %rcx,%r14
setb   %r8b
cmp    %rbp,%r11
seta   %r11b
mov    0x20(%rsp),%cl
test   %cl,0x28(%rsp)
jne    13cd <splint+0x27d>
and    0xf(%rsp),%dl
jne    13cd <splint+0x27d>
and    0xe(%rsp),%r9b
jne    13cd <splint+0x27d>
and    %sil,%dil
jne    13cd <splint+0x27d>
and    %r11b,%r8b
jne    13cd <splint+0x27d>
add    $0x1,%r10
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     14dd <splint+0x38d>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%r12,%rdx,8),%xmm0
movups 0x10(%r12,%rdx,8),%xmm1
movups %xmm0,0x0(%r13,%rdx,8)
movups %xmm1,0x10(%r13,%rdx,8)
movups 0x0(%rbp,%rdx,8),%xmm0
movups 0x10(%rbp,%rdx,8),%xmm1
movups %xmm0,(%r14,%rdx,8)
movups %xmm1,0x10(%r14,%rdx,8)
movups 0x20(%r12,%rdx,8),%xmm0
movups 0x30(%r12,%rdx,8),%xmm1
movups %xmm0,0x20(%r13,%rdx,8)
movups %xmm1,0x30(%r13,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm0
movupd 0x30(%rbp,%rdx,8),%xmm1
movupd %xmm0,0x20(%r14,%rdx,8)
movupd %xmm1,0x30(%r14,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1360 <splint+0x210>
jmp    14df <splint+0x38f>
mov    %r13,%rcx
mov    %r14,%rdx
mov    0x10(%rsp),%r10
jmp    1540 <splint+0x3f0>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
xor    %esi,%esi
xor    %edx,%edx
mov    %rdi,%rax
nopw   0x0(%rax,%rax,1)
movslq (%rax),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%r14,%rsi,8)
movslq 0x4(%rax),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rsi,8)
movslq 0x8(%rax),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r13,%rsi,8)
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rsi,8)
movslq 0xc(%rax),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r13,%rsi,8)
add    $0x10,%rax
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rsi,8)
add    $0xffffffffffffffe0,%rdx
add    $0x4,%rsi
cmp    %esi,%ecx
jne    13f0 <splint+0x2a0>
mov    %r13,%r8
sub    %rdx,%r8
mov    %r14,%rsi
sub    %rdx,%rsi
test   $0x3,%r15b
je     14c3 <splint+0x373>
mov    %r15d,%edx
and    $0x3,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%rax,%rcx,4),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%edx
jne    14a0 <splint+0x350>
call   1030 <free@plt>
movsd  0x18(%rsp),%xmm1
mov    0x28(%rsp),%rbx
mov    0x10(%rsp),%r10
jmp    1619 <splint+0x4c9>
xor    %edx,%edx
test   $0x1,%cl
je     1514 <splint+0x3c4>
movups (%r12,%rdx,8),%xmm0
movups 0x10(%r12,%rdx,8),%xmm1
movups %xmm0,0x0(%r13,%rdx,8)
movups %xmm1,0x10(%r13,%rdx,8)
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
cmp    %rax,%r10
movsd  0x18(%rsp),%xmm1
mov    0x10(%rsp),%r10
je     1619 <splint+0x4c9>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
lea    (%r14,%rax,8),%rdx
lea    0x0(%rbp,%rax,8),%rbp
lea    (%r12,%rax,8),%r12
mov    %r15d,%esi
sub    %eax,%esi
mov    %eax,%r8d
not    %r8d
add    %r15d,%r8d
test   $0x3,%sil
je     15a0 <splint+0x450>
mov    %rbx,%r9
mov    %r15d,%ebx
sub    %al,%bl
movzbl %bl,%esi
and    $0x3,%esi
shl    $0x3,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,1),%xmm0
movsd  %xmm0,(%rcx,%rdi,1)
movsd  0x0(%rbp,%rdi,1),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    $0x1,%eax
add    $0x8,%rdi
cmp    %edi,%esi
jne    1570 <splint+0x420>
add    %rdi,%rcx
add    %rdi,%rdx
add    %rdi,%rbp
add    %rdi,%r12
mov    %r9,%rbx
cmp    $0x3,%r8d
jb     1619 <splint+0x4c9>
mov    %r15d,%esi
sub    %eax,%esi
xor    %eax,%eax
nopl   (%rax)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %eax,%esi
jne    15b0 <splint+0x460>
cmp    $0x2,%r15d
jl     1637 <splint+0x4e7>
movsd  0x0(%r13),%xmm0
ucomisd %xmm1,%xmm0
ja     1637 <splint+0x4e7>
movslq %r15d,%rax
ucomisd -0x8(%r13,%rax,8),%xmm1
jbe    166f <splint+0x51f>
mov    0x29a2(%rip),%rax
mov    (%rax),%edi
lea    0x9f5(%rip),%rsi
call   1040 <fprintf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xorpd  %xmm0,%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm0
jne    1688 <splint+0x538>
jnp    169a <splint+0x54a>
cmp    %ebp,%r10d
je     16b2 <splint+0x562>
movsd  0x8(%r13,%rbp,8),%xmm0
add    $0x1,%rbp
jmp    1680 <splint+0x530>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
movsd  (%r14,%rbp,8),%xmm0
jmp    1660 <splint+0x510>
mov    %r10,%r12
mov    0x34(%rsp),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
test   %rax,%rax
je     170d <splint+0x5bd>
mov    %ebp,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1811 <splint+0x6c1>
mov    %rax,%rbp
mov    %r13,%rdi
mov    %r14,%rsi
mov    %r12d,%edx
mov    0x10(%rsp),%r12
mov    %r12,%rcx
mov    %rax,%r8
call   1060 <subspl@plt>
xorpd  %xmm0,%xmm0
test   %r15d,%r15d
jle    1660 <splint+0x510>
xor    %eax,%eax
movsd  0x18(%rsp),%xmm5
jmp    172e <splint+0x5de>
mov    0x28cc(%rip),%rax
mov    (%rax),%edi
lea    0x8fb(%rip),%rsi
jmp    1647 <splint+0x4f7>
add    $0x1,%rax
cmp    %eax,%ebx
je     1660 <splint+0x510>
movsd  0x0(%r13,%rax,8),%xmm4
ucomisd %xmm4,%xmm5
jb     1722 <splint+0x5d2>
movsd  0x8(%r13,%rax,8),%xmm1
ucomisd %xmm5,%xmm1
jbe    1722 <splint+0x5d2>
movsd  0x0(%rbp,%rax,8),%xmm3
movsd  0x8(%rbp,%rax,8),%xmm2
movsd  0x8(%r12,%rax,8),%xmm0
subsd  %xmm5,%xmm1
subsd  %xmm4,%xmm5
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm5,%xmm6
mulsd  %xmm2,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm1,%xmm4
addsd  %xmm6,%xmm4
movapd 0x871(%rip),%xmm6
xorpd  %xmm0,%xmm6
mulsd  %xmm0,%xmm6
mulsd  %xmm6,%xmm3
movsd  0x86c(%rip),%xmm8
movsd  (%r14,%rax,8),%xmm7
mulsd  %xmm8,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm4,%xmm7
mulsd  %xmm2,%xmm6
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm7,%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm8,%xmm1
movsd  %xmm1,0x18(%rsp)
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
movsd  0x18(%rsp),%xmm0
jmp    1660 <splint+0x510>
mov    0x27c8(%rip),%rax
mov    (%rax),%edi
lea    0x7f7(%rip),%rsi
call   1040 <fprintf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
jmp    1657 <splint+0x507>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [36 x i8] c"Error : Out of memory in splint()\0A\00"
@.str.1 = [40 x i8] c"Error : Illegal parameter in splint()\0A\00"
define double @splint(double* %0, double* %1, i32 %2, double %3) {
%5 = alloca double
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32*
%13 = alloca i32*
%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 double*
%23 = alloca double
%24 = alloca double
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double
store double* %0, double** %6
store double* %1, double** %7
store i32 %2, i32* %8
store double %3, double* %9
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = mul i64 %30, 8
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to double*
store double* %34, double** %26
%35 = load double*, double** %26
%36 = icmp eq double* %35, null
br i1 %36, label %37, label %40
37: ; preds = %4
%38 = load i32, i32* @stderr
%39 = call i32 @fprintf(i32 %38, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
store double 0.000000e+00, double* %5
br label %367
40: ; preds = %4
%41 = load i32, i32* %8
%42 = sext i32 %41 to i64
%43 = mul i64 %42, 8
%44 = trunc i64 %43 to i32
%45 = call i64 @malloc(i32 %44)
%46 = inttoptr i64 %45 to double*
store double* %46, double** %27
%47 = load double*, double** %27
%48 = icmp eq double* %47, null
br i1 %48, label %49, label %55
49: ; preds = %40
%50 = load i32, i32* @stderr
%51 = call i32 @fprintf(i32 %50, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%52 = load double*, double** %26
%53 = bitcast double* %52 to i8*
%54 = call i32 @free(i8* %53)
store double 0.000000e+00, double* %5
br label %367
55: ; preds = %40
store i32 0, i32* %11
%56 = load double*, double** %6
store double* %56, double** %19
store i32 0, i32* %10
br label %57
57: ; preds = %71, %55
%58 = load i32, i32* %11
%59 = load i32, i32* %8
%60 = sub nsw i32 %59, 1
%61 = icmp slt i32 %58, %60
br i1 %61, label %62, label %76
62: ; preds = %57
%63 = load double*, double** %19
%64 = load double, double* %63
%65 = load double*, double** %19
%66 = getelementptr inbounds double, double* %65, i64 1
%67 = load double, double* %66
%68 = fcmp oge double %64, %67
br i1 %68, label %69, label %70
69: ; preds = %62
store i32 1, i32* %10
br label %76
70: ; preds = %62
br label %71
71: ; preds = %70
%72 = load i32, i32* %11
%73 = add nsw i32 %72, 1
store i32 %73, i32* %11
%74 = load double*, double** %19
%75 = getelementptr inbounds double, double* %74, i32 1
store double* %75, double** %19
br label %57
76: ; preds = %69, %57
%77 = load i32, i32* %10
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %134
79: ; preds = %76
%80 = load i32, i32* %8
%81 = sext i32 %80 to i64
%82 = mul i64 %81, 4
%83 = trunc i64 %82 to i32
%84 = call i64 @malloc(i32 %83)
%85 = inttoptr i64 %84 to i32*
store i32* %85, i32** %12
%86 = load i32*, i32** %12
%87 = icmp eq i32* %86, null
br i1 %87, label %88, label %97
88: ; preds = %79
%89 = load i32, i32* @stderr
%90 = call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%91 = load double*, double** %26
%92 = bitcast double* %91 to i8*
%93 = call i32 @free(i8* %92)
%94 = load double*, double** %27
%95 = bitcast double* %94 to i8*
%96 = call i32 @free(i8* %95)
store double 0.000000e+00, double* %5
br label %367
97: ; preds = %79
%98 = load double*, double** %6
%99 = load i32, i32* %8
%100 = load i32*, i32** %12
%101 = call i32 @sortdi1(double* %98, i32 %99, i32* %100)
store i32 0, i32* %11
%102 = load double*, double** %26
store double* %102, double** %19
%103 = load double*, double** %27
store double* %103, double** %20
%104 = load i32*, i32** %12
store i32* %104, i32** %13
br label %105
105: ; preds = %127, %97
%106 = load i32, i32* %11
%107 = load i32, i32* %8
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %130
109: ; preds = %105
%110 = load double*, double** %6
%111 = load i32*, i32** %13
%112 = load i32, i32* %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %110, i64 %113
%115 = load double, double* %114
%116 = load double*, double** %19
%117 = getelementptr inbounds double, double* %116, i32 1
store double* %117, double** %19
store double %115, double* %116
%118 = load double*, double** %7
%119 = load i32*, i32** %13
%120 = getelementptr inbounds i32, i32* %119, i32 1
store i32* %120, i32** %13
%121 = load i32, i32* %119
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %118, i64 %122
%124 = load double, double* %123
%125 = load double*, double** %20
%126 = getelementptr inbounds double, double* %125, i32 1
store double* %126, double** %20
store double %124, double* %125
br label %127
127: ; preds = %109
%128 = load i32, i32* %11
%129 = add nsw i32 %128, 1
store i32 %129, i32* %11
br label %105
130: ; preds = %105
%131 = load i32*, i32** %12
%132 = bitcast i32* %131 to i8*
%133 = call i32 @free(i8* %132)
br label %158
134: ; preds = %76
store i32 0, i32* %11
%135 = load double*, double** %26
store double* %135, double** %19
%136 = load double*, double** %27
store double* %136, double** %20
%137 = load double*, double** %6
store double* %137, double** %21
%138 = load double*, double** %7
store double* %138, double** %22
br label %139
139: ; preds = %154, %134
%140 = load i32, i32* %11
%141 = load i32, i32* %8
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %157
143: ; preds = %139
%144 = load double*, double** %21
%145 = getelementptr inbounds double, double* %144, i32 1
store double* %145, double** %21
%146 = load double, double* %144
%147 = load double*, double** %19
%148 = getelementptr inbounds double, double* %147, i32 1
store double* %148, double** %19
store double %146, double* %147
%149 = load double*, double** %22
%150 = getelementptr inbounds double, double* %149, i32 1
store double* %150, double** %22
%151 = load double, double* %149
%152 = load double*, double** %20
%153 = getelementptr inbounds double, double* %152, i32 1
store double* %153, double** %20
store double %151, double* %152
br label %154
154: ; preds = %143
%155 = load i32, i32* %11
%156 = add nsw i32 %155, 1
store i32 %156, i32* %11
br label %139
157: ; preds = %139
br label %158
158: ; preds = %157, %130
%159 = load i32, i32* %8
%160 = icmp slt i32 %159, 2
br i1 %160, label %175, label %161
161: ; preds = %158
%162 = load double, double* %9
%163 = load double*, double** %26
%164 = load double, double* %163
%165 = fcmp olt double %162, %164
br i1 %165, label %175, label %166
166: ; preds = %161
%167 = load double, double* %9
%168 = load double*, double** %26
%169 = load i32, i32* %8
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = getelementptr inbounds double, double* %171, i64 -1
%173 = load double, double* %172
%174 = fcmp ogt double %167, %173
br i1 %174, label %175, label %184
175: ; preds = %166, %161, %158
%176 = load i32, i32* @stderr
%177 = call i32 @fprintf(i32 %176, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.1, i64 0, i64 0))
%178 = load double*, double** %26
%179 = bitcast double* %178 to i8*
%180 = call i32 @free(i8* %179)
%181 = load double*, double** %27
%182 = bitcast double* %181 to i8*
%183 = call i32 @free(i8* %182)
store double 0.000000e+00, double* %5
br label %367
184: ; preds = %166
store i32 0, i32* %11
%185 = load double*, double** %26
store double* %185, double** %19
br label %186
186: ; preds = %209, %184
%187 = load i32, i32* %11
%188 = load i32, i32* %8
%189 = icmp slt i32 %187, %188
br i1 %189, label %190, label %212
190: ; preds = %186
%191 = load double*, double** %19
%192 = getelementptr inbounds double, double* %191, i32 1
store double* %192, double** %19
%193 = load double, double* %191
%194 = load double, double* %9
%195 = fcmp oeq double %193, %194
br i1 %195, label %196, label %208
196: ; preds = %190
%197 = load double*, double** %26
%198 = bitcast double* %197 to i8*
%199 = call i32 @free(i8* %198)
%200 = load double*, double** %27
%201 = bitcast double* %200 to i8*
%202 = call i32 @free(i8* %201)
%203 = load double*, double** %27
%204 = load i32, i32* %11
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %203, i64 %205
%207 = load double, double* %206
store double %207, double* %5
br label %367
208: ; preds = %190
br label %209
209: ; preds = %208
%210 = load i32, i32* %11
%211 = add nsw i32 %210, 1
store i32 %211, i32* %11
br label %186
212: ; preds = %186
%213 = load i32, i32* %8
%214 = sext i32 %213 to i64
%215 = mul i64 %214, 8
%216 = trunc i64 %215 to i32
%217 = call i64 @malloc(i32 %216)
%218 = inttoptr i64 %217 to double*
store double* %218, double** %16
%219 = load double*, double** %16
%220 = icmp eq double* %219, null
br i1 %220, label %221, label %230
221: ; preds = %212
%222 = load i32, i32* @stderr
%223 = call i32 @fprintf(i32 %222, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%224 = load double*, double** %26
%225 = bitcast double* %224 to i8*
%226 = call i32 @free(i8* %225)
%227 = load double*, double** %27
%228 = bitcast double* %227 to i8*
%229 = call i32 @free(i8* %228)
store double 0.000000e+00, double* %5
br label %367
230: ; preds = %212
%231 = load i32, i32* %8
%232 = sext i32 %231 to i64
%233 = mul i64 %232, 8
%234 = trunc i64 %233 to i32
%235 = call i64 @malloc(i32 %234)
%236 = inttoptr i64 %235 to double*
store double* %236, double** %25
%237 = load double*, double** %25
%238 = icmp eq double* %237, null
br i1 %238, label %239, label %251
239: ; preds = %230
%240 = load i32, i32* @stderr
%241 = call i32 @fprintf(i32 %240, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%242 = load double*, double** %26
%243 = bitcast double* %242 to i8*
%244 = call i32 @free(i8* %243)
%245 = load double*, double** %27
%246 = bitcast double* %245 to i8*
%247 = call i32 @free(i8* %246)
%248 = load double*, double** %16
%249 = bitcast double* %248 to i8*
%250 = call i32 @free(i8* %249)
store double 0.000000e+00, double* %5
br label %367
251: ; preds = %230
%252 = load double*, double** %26
%253 = load double*, double** %27
%254 = load i32, i32* %8
%255 = sub nsw i32 %254, 1
%256 = load double*, double** %16
%257 = load double*, double** %25
%258 = call i32 @subspl(double* %252, double* %253, i32 %255, double* %256, double* %257)
store i32 1, i32* %11
%259 = load double*, double** %26
%260 = getelementptr inbounds double, double* %259, i64 1
store double* %260, double** %19
br label %261
261: ; preds = %361, %251
%262 = load i32, i32* %11
%263 = load i32, i32* %8
%264 = icmp sle i32 %262, %263
br i1 %264, label %265, label %366
265: ; preds = %261
%266 = load double*, double** %19
%267 = getelementptr inbounds double, double* %266, i64 -1
%268 = load double, double* %267
%269 = load double, double* %9
%270 = fcmp ole double %268, %269
br i1 %270, label %271, label %360
271: ; preds = %265
%272 = load double, double* %9
%273 = load double*, double** %19
%274 = load double, double* %273
%275 = fcmp olt double %272, %274
br i1 %275, label %276, label %360
276: ; preds = %271
%277 = load double*, double** %25
%278 = load i32, i32* %11
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %277, i64 %279
%281 = getelementptr inbounds double, double* %280, i64 -1
%282 = load double, double* %281
store double %282, double* %23
%283 = load double*, double** %25
%284 = load i32, i32* %11
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
store double %287, double* %24
%288 = load double*, double** %16
%289 = load i32, i32* %11
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
store double %292, double* %17
%293 = load double, double* %17
%294 = load double, double* %17
%295 = fmul double %293, %294
store double %295, double* %18
%296 = load double*, double** %19
%297 = load double, double* %296
%298 = load double, double* %9
%299 = fsub double %297, %298
store double %299, double* %14
%300 = load double, double* %9
%301 = load double*, double** %19
%302 = getelementptr inbounds double, double* %301, i64 -1
%303 = load double, double* %302
%304 = fsub double %300, %303
store double %304, double* %15
%305 = load double, double* %23
%306 = load double, double* %14
%307 = fmul double %305, %306
%308 = load double, double* %14
%309 = fmul double %307, %308
%310 = load double, double* %14
%311 = load double, double* %24
%312 = load double, double* %15
%313 = fmul double %311, %312
%314 = load double, double* %15
%315 = fmul double %313, %314
%316 = load double, double* %15
%317 = fmul double %315, %316
%318 = call double @llvm.fmuladd.f64(double %309, double %310, double %317)
%319 = load double*, double** %27
%320 = load i32, i32* %11
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %319, i64 %321
%323 = getelementptr inbounds double, double* %322, i64 -1
%324 = load double, double* %323
%325 = load double, double* %18
%326 = load double, double* %23
%327 = fmul double %325, %326
%328 = fneg double %327
%329 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %324, double %328)
%330 = load double, double* %14
%331 = call double @llvm.fmuladd.f64(double %329, double %330, double %318)
%332 = load double*, double** %27
%333 = load i32, i32* %11
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %332, i64 %334
%336 = load double, double* %335
%337 = load double, double* %18
%338 = load double, double* %24
%339 = fmul double %337, %338
%340 = fneg double %339
%341 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %336, double %340)
%342 = load double, double* %15
%343 = call double @llvm.fmuladd.f64(double %341, double %342, double %331)
%344 = load double, double* %17
%345 = fdiv double %343, %344
%346 = fdiv double %345, 6.000000e+00
store double %346, double* %28
%347 = load double*, double** %26
%348 = bitcast double* %347 to i8*
%349 = call i32 @free(i8* %348)
%350 = load double*, double** %27
%351 = bitcast double* %350 to i8*
%352 = call i32 @free(i8* %351)
%353 = load double*, double** %16
%354 = bitcast double* %353 to i8*
%355 = call i32 @free(i8* %354)
%356 = load double*, double** %25
%357 = bitcast double* %356 to i8*
%358 = call i32 @free(i8* %357)
%359 = load double, double* %28
store double %359, double* %5
br label %367
360: ; preds = %271, %265
br label %361
361: ; preds = %360
%362 = load i32, i32* %11
%363 = add nsw i32 %362, 1
store i32 %363, i32* %11
%364 = load double*, double** %19
%365 = getelementptr inbounds double, double* %364, i32 1
store double* %365, double** %19
br label %261
366: ; preds = %261
store double 0.000000e+00, double* %5
br label %367
367: ; preds = %366, %276, %239, %221, %196, %175, %88, %49, %37
%368 = load double, double* %5
ret double %368
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [36 x i8] c"Error : Out of memory in splint()\0A\00"
@.str.1 = [40 x i8] c"Error : Illegal parameter in splint()\0A\00"
define double @splint(double* %0, double* nocapture %1, i32 %2, double %3) {
%5 = sext i32 %2 to i64
%6 = shl i32 %2, 3
%7 = tail call i64 @malloc(i32 %6)
%8 = inttoptr i64 %7 to double*
%9 = inttoptr i64 %7 to i8*
%10 = icmp eq i64 %7, 0
br i1 %10, label %11, label %14
11: ; preds = %4
%12 = load i32, i32* @stderr
%13 = tail call i32 @fprintf(i32 %12, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
br label %430
14: ; preds = %4
%15 = tail call i64 @malloc(i32 %6)
%16 = inttoptr i64 %15 to double*
%17 = inttoptr i64 %15 to i8*
%18 = icmp eq i64 %15, 0
br i1 %18, label %24, label %19
19: ; preds = %14
%20 = add i32 %2, -1
%21 = icmp sgt i32 %2, 1
br i1 %21, label %22, label %31
22: ; preds = %19
%23 = load double, double* %0
br label %188
24: ; preds = %14
%25 = load i32, i32* @stderr
%26 = tail call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%27 = inttoptr i64 %7 to i8*
%28 = tail call i32 @free(i8* %27)
br label %430
29: ; preds = %188
%30 = icmp eq i32 %195, %20
br i1 %30, label %31, label %188
31: ; preds = %29, %19
%32 = icmp sgt i32 %2, 0
br i1 %32, label %33, label %327
33: ; preds = %31
%34 = zext i32 %20 to i64
%35 = add nuw nsw i64 %34, 1
%36 = icmp ult i32 %20, 3
br i1 %36, label %154, label %37
37: ; preds = %33
%38 = zext i32 %20 to i64
%39 = add nuw nsw i64 %38, 1
%40 = getelementptr double, double* %8, i64 %39
%41 = bitcast double* %40 to i8*
%42 = getelementptr double, double* %16, i64 %39
%43 = bitcast double* %42 to i8*
%44 = getelementptr double, double* %0, i64 %39
%45 = bitcast double* %44 to i8*
%46 = getelementptr double, double* %1, i64 %39
%47 = bitcast double* %46 to i8*
%48 = icmp ult i8* %9, %43
%49 = icmp ult i8* %17, %41
%50 = and i1 %48, %49
%51 = icmp ult i8* %9, %45
%52 = icmp ugt double* %40, %0
%53 = and i1 %51, %52
%54 = or i1 %50, %53
%55 = icmp ult i8* %9, %47
%56 = icmp ugt double* %40, %1
%57 = and i1 %55, %56
%58 = or i1 %54, %57
%59 = icmp ult i8* %17, %45
%60 = icmp ugt double* %42, %0
%61 = and i1 %59, %60
%62 = or i1 %58, %61
%63 = icmp ult i8* %17, %47
%64 = icmp ugt double* %42, %1
%65 = and i1 %63, %64
%66 = or i1 %62, %65
br i1 %66, label %154, label %67
67: ; preds = %37
%68 = and i64 %35, 8589934588
%69 = trunc i64 %68 to i32
%70 = getelementptr double, double* %8, i64 %68
%71 = getelementptr double, double* %16, i64 %68
%72 = getelementptr double, double* %1, i64 %68
%73 = getelementptr double, double* %0, i64 %68
%74 = add nsw i64 %68, -4
%75 = lshr exact i64 %74, 2
%76 = add nuw nsw i64 %75, 1
%77 = and i64 %76, 1
%78 = icmp eq i64 %74, 0
br i1 %78, label %128, label %79
79: ; preds = %67
%80 = and i64 %76, 9223372036854775806
br label %81
81: ; preds = %81, %79
%82 = phi i64 [ 0, %79 ], [ %125, %81 ]
%83 = phi i64 [ 0, %79 ], [ %126, %81 ]
%84 = getelementptr double, double* %8, i64 %82
%85 = getelementptr double, double* %16, i64 %82
%86 = getelementptr double, double* %1, i64 %82
%87 = getelementptr double, double* %0, i64 %82
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = bitcast double* %84 to <2 x double>*
store <2 x double> %89, <2 x double>* %93
%94 = getelementptr double, double* %84, i64 2
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %92, <2 x double>* %95
%96 = bitcast double* %86 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = getelementptr double, double* %86, i64 2
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = bitcast double* %85 to <2 x double>*
store <2 x double> %97, <2 x double>* %101
%102 = getelementptr double, double* %85, i64 2
%103 = bitcast double* %102 to <2 x double>*
store <2 x double> %100, <2 x double>* %103
%104 = or i64 %82, 4
%105 = getelementptr double, double* %8, i64 %104
%106 = getelementptr double, double* %16, i64 %104
%107 = getelementptr double, double* %1, i64 %104
%108 = getelementptr double, double* %0, i64 %104
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr double, double* %108, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = bitcast double* %105 to <2 x double>*
store <2 x double> %110, <2 x double>* %114
%115 = getelementptr double, double* %105, i64 2
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %113, <2 x double>* %116
%117 = bitcast double* %107 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr double, double* %107, i64 2
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = bitcast double* %106 to <2 x double>*
store <2 x double> %118, <2 x double>* %122
%123 = getelementptr double, double* %106, i64 2
%124 = bitcast double* %123 to <2 x double>*
store <2 x double> %121, <2 x double>* %124
%125 = add nuw i64 %82, 8
%126 = add i64 %83, 2
%127 = icmp eq i64 %126, %80
br i1 %127, label %128, label %81
128: ; preds = %81, %67
%129 = phi i64 [ 0, %67 ], [ %125, %81 ]
%130 = icmp eq i64 %77, 0
br i1 %130, label %152, label %131
131: ; preds = %128
%132 = getelementptr double, double* %8, i64 %129
%133 = getelementptr double, double* %16, i64 %129
%134 = getelementptr double, double* %1, i64 %129
%135 = getelementptr double, double* %0, i64 %129
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = getelementptr double, double* %135, i64 2
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = bitcast double* %132 to <2 x double>*
store <2 x double> %137, <2 x double>* %141
%142 = getelementptr double, double* %132, i64 2
%143 = bitcast double* %142 to <2 x double>*
store <2 x double> %140, <2 x double>* %143
%144 = bitcast double* %134 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr double, double* %134, i64 2
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = bitcast double* %133 to <2 x double>*
store <2 x double> %145, <2 x double>* %149
%150 = getelementptr double, double* %133, i64 2
%151 = bitcast double* %150 to <2 x double>*
store <2 x double> %148, <2 x double>* %151
br label %152
152: ; preds = %128, %131
%153 = icmp eq i64 %35, %68
br i1 %153, label %315, label %154
154: ; preds = %37, %33, %152
%155 = phi i32 [ 0, %37 ], [ 0, %33 ], [ %69, %152 ]
%156 = phi double* [ %8, %37 ], [ %8, %33 ], [ %70, %152 ]
%157 = phi double* [ %16, %37 ], [ %16, %33 ], [ %71, %152 ]
%158 = phi double* [ %1, %37 ], [ %1, %33 ], [ %72, %152 ]
%159 = phi double* [ %0, %37 ], [ %0, %33 ], [ %73, %152 ]
%160 = sub i32 %2, %155
%161 = xor i32 %155, -1
%162 = add i32 %161, %2
%163 = and i32 %160, 3
%164 = icmp eq i32 %163, 0
br i1 %164, label %181, label %165
165: ; preds = %154, %165
%166 = phi i32 [ %178, %165 ], [ %155, %154 ]
%167 = phi double* [ %174, %165 ], [ %156, %154 ]
%168 = phi double* [ %177, %165 ], [ %157, %154 ]
%169 = phi double* [ %175, %165 ], [ %158, %154 ]
%170 = phi double* [ %172, %165 ], [ %159, %154 ]
%171 = phi i32 [ %179, %165 ], [ 0, %154 ]
%172 = getelementptr inbounds double, double* %170, i64 1
%173 = load double, double* %170
%174 = getelementptr inbounds double, double* %167, i64 1
store double %173, double* %167
%175 = getelementptr inbounds double, double* %169, i64 1
%176 = load double, double* %169
%177 = getelementptr inbounds double, double* %168, i64 1
store double %176, double* %168
%178 = add nuw nsw i32 %166, 1
%179 = add i32 %171, 1
%180 = icmp eq i32 %179, %163
br i1 %180, label %181, label %165
181: ; preds = %165, %154
%182 = phi i32 [ %155, %154 ], [ %178, %165 ]
%183 = phi double* [ %156, %154 ], [ %174, %165 ]
%184 = phi double* [ %157, %154 ], [ %177, %165 ]
%185 = phi double* [ %158, %154 ], [ %175, %165 ]
%186 = phi double* [ %159, %154 ], [ %172, %165 ]
%187 = icmp ult i32 %162, 3
br i1 %187, label %315, label %283
188: ; preds = %22, %29
%189 = phi double [ %193, %29 ], [ %23, %22 ]
%190 = phi i32 [ %195, %29 ], [ 0, %22 ]
%191 = phi double* [ %192, %29 ], [ %0, %22 ]
%192 = getelementptr inbounds double, double* %191, i64 1
%193 = load double, double* %192
%194 = fcmp ult double %189, %193
%195 = add nuw nsw i32 %190, 1
br i1 %194, label %29, label %196
196: ; preds = %188
%197 = shl i32 %2, 2
%198 = tail call i64 @malloc(i32 %197)
%199 = inttoptr i64 %198 to i32*
%200 = icmp eq i64 %198, 0
br i1 %200, label %201, label %208
201: ; preds = %196
%202 = load i32, i32* @stderr
%203 = tail call i32 @fprintf(i32 %202, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%204 = inttoptr i64 %7 to i8*
%205 = tail call i32 @free(i8* %204)
%206 = inttoptr i64 %15 to i8*
%207 = tail call i32 @free(i8* %206)
br label %430
208: ; preds = %196
%209 = tail call i32 @sortdi1(double* %0, i32 %2, i32* %199)
%210 = icmp sgt i32 %2, 0
br i1 %210, label %211, label %280
211: ; preds = %208
%212 = and i32 %2, 3
%213 = icmp ult i32 %20, 3
br i1 %213, label %259, label %214
214: ; preds = %211
%215 = and i32 %2, -4
br label %216
216: ; preds = %216, %214
%217 = phi i32* [ %199, %214 ], [ %253, %216 ]
%218 = phi double* [ %8, %214 ], [ %252, %216 ]
%219 = phi double* [ %16, %214 ], [ %256, %216 ]
%220 = phi i32 [ 0, %214 ], [ %257, %216 ]
%221 = load i32, i32* %217
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %0, i64 %222
%224 = load double, double* %223
%225 = getelementptr inbounds double, double* %218, i64 1
store double %224, double* %218
%226 = getelementptr inbounds i32, i32* %217, i64 1
%227 = getelementptr inbounds double, double* %1, i64 %222
%228 = load double, double* %227
%229 = getelementptr inbounds double, double* %219, i64 1
store double %228, double* %219
%230 = load i32, i32* %226
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %0, i64 %231
%233 = load double, double* %232
%234 = getelementptr inbounds double, double* %218, i64 2
store double %233, double* %225
%235 = getelementptr inbounds i32, i32* %217, i64 2
%236 = getelementptr inbounds double, double* %1, i64 %231
%237 = load double, double* %236
%238 = getelementptr inbounds double, double* %219, i64 2
store double %237, double* %229
%239 = load i32, i32* %235
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %0, i64 %240
%242 = load double, double* %241
%243 = getelementptr inbounds double, double* %218, i64 3
store double %242, double* %234
%244 = getelementptr inbounds i32, i32* %217, i64 3
%245 = getelementptr inbounds double, double* %1, i64 %240
%246 = load double, double* %245
%247 = getelementptr inbounds double, double* %219, i64 3
store double %246, double* %238
%248 = load i32, i32* %244
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %0, i64 %249
%251 = load double, double* %250
%252 = getelementptr inbounds double, double* %218, i64 4
store double %251, double* %243
%253 = getelementptr inbounds i32, i32* %217, i64 4
%254 = getelementptr inbounds double, double* %1, i64 %249
%255 = load double, double* %254
%256 = getelementptr inbounds double, double* %219, i64 4
store double %255, double* %247
%257 = add i32 %220, 4
%258 = icmp eq i32 %257, %215
br i1 %258, label %259, label %216
259: ; preds = %216, %211
%260 = phi i32* [ %199, %211 ], [ %253, %216 ]
%261 = phi double* [ %8, %211 ], [ %252, %216 ]
%262 = phi double* [ %16, %211 ], [ %256, %216 ]
%263 = icmp eq i32 %212, 0
br i1 %263, label %280, label %264
264: ; preds = %259, %264
%265 = phi i32* [ %274, %264 ], [ %260, %259 ]
%266 = phi double* [ %273, %264 ], [ %261, %259 ]
%267 = phi double* [ %277, %264 ], [ %262, %259 ]
%268 = phi i32 [ %278, %264 ], [ 0, %259 ]
%269 = load i32, i32* %265
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %0, i64 %270
%272 = load double, double* %271
%273 = getelementptr inbounds double, double* %266, i64 1
store double %272, double* %266
%274 = getelementptr inbounds i32, i32* %265, i64 1
%275 = getelementptr inbounds double, double* %1, i64 %270
%276 = load double, double* %275
%277 = getelementptr inbounds double, double* %267, i64 1
store double %276, double* %267
%278 = add i32 %268, 1
%279 = icmp eq i32 %278, %212
br i1 %279, label %280, label %264
280: ; preds = %259, %264, %208
%281 = inttoptr i64 %198 to i8*
%282 = tail call i32 @free(i8* %281)
br label %315
283: ; preds = %181, %283
%284 = phi i32 [ %313, %283 ], [ %182, %181 ]
%285 = phi double* [ %309, %283 ], [ %183, %181 ]
%286 = phi double* [ %312, %283 ], [ %184, %181 ]
%287 = phi double* [ %310, %283 ], [ %185, %181 ]
%288 = phi double* [ %307, %283 ], [ %186, %181 ]
%289 = getelementptr inbounds double, double* %288, i64 1
%290 = load double, double* %288
%291 = getelementptr inbounds double, double* %285, i64 1
store double %290, double* %285
%292 = getelementptr inbounds double, double* %287, i64 1
%293 = load double, double* %287
%294 = getelementptr inbounds double, double* %286, i64 1
store double %293, double* %286
%295 = getelementptr inbounds double, double* %288, i64 2
%296 = load double, double* %289
%297 = getelementptr inbounds double, double* %285, i64 2
store double %296, double* %291
%298 = getelementptr inbounds double, double* %287, i64 2
%299 = load double, double* %292
%300 = getelementptr inbounds double, double* %286, i64 2
store double %299, double* %294
%301 = getelementptr inbounds double, double* %288, i64 3
%302 = load double, double* %295
%303 = getelementptr inbounds double, double* %285, i64 3
store double %302, double* %297
%304 = getelementptr inbounds double, double* %287, i64 3
%305 = load double, double* %298
%306 = getelementptr inbounds double, double* %286, i64 3
store double %305, double* %300
%307 = getelementptr inbounds double, double* %288, i64 4
%308 = load double, double* %301
%309 = getelementptr inbounds double, double* %285, i64 4
store double %308, double* %303
%310 = getelementptr inbounds double, double* %287, i64 4
%311 = load double, double* %304
%312 = getelementptr inbounds double, double* %286, i64 4
store double %311, double* %306
%313 = add nuw nsw i32 %284, 4
%314 = icmp eq i32 %313, %2
br i1 %314, label %315, label %283
315: ; preds = %181, %283, %152, %280
%316 = icmp slt i32 %2, 2
br i1 %316, label %327, label %317
317: ; preds = %315
%318 = load double, double* %8
%319 = fcmp ogt double %318, %3
br i1 %319, label %327, label %320
320: ; preds = %317
%321 = getelementptr inbounds double, double* %8, i64 %5
%322 = getelementptr inbounds double, double* %321, i64 -1
%323 = load double, double* %322
%324 = fcmp olt double %323, %3
br i1 %324, label %327, label %325
325: ; preds = %320
%326 = fcmp oeq double %318, %3
br i1 %326, label %336, label %344
327: ; preds = %31, %320, %317, %315
%328 = load i32, i32* @stderr
%329 = tail call i32 @fprintf(i32 %328, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.1, i64 0, i64 0))
%330 = inttoptr i64 %7 to i8*
%331 = tail call i32 @free(i8* %330)
%332 = inttoptr i64 %15 to i8*
%333 = tail call i32 @free(i8* %332)
br label %430
334: ; preds = %350
%335 = zext i32 %348 to i64
br label %336
336: ; preds = %334, %325
%337 = phi i64 [ %335, %334 ], [ 0, %325 ]
%338 = inttoptr i64 %7 to i8*
%339 = tail call i32 @free(i8* %338)
%340 = inttoptr i64 %15 to i8*
%341 = tail call i32 @free(i8* %340)
%342 = getelementptr inbounds double, double* %16, i64 %337
%343 = load double, double* %342
br label %430
344: ; preds = %325, %350
%345 = phi double* [ %347, %350 ], [ %8, %325 ]
%346 = phi i32 [ %348, %350 ], [ 0, %325 ]
%347 = getelementptr inbounds double, double* %345, i64 1
%348 = add nuw nsw i32 %346, 1
%349 = icmp eq i32 %348, %2
br i1 %349, label %353, label %350
350: ; preds = %344
%351 = load double, double* %347
%352 = fcmp oeq double %351, %3
br i1 %352, label %334, label %344
353: ; preds = %344
%354 = tail call i64 @malloc(i32 %6)
%355 = inttoptr i64 %354 to double*
%356 = icmp eq i64 %354, 0
br i1 %356, label %357, label %364
357: ; preds = %353
%358 = load i32, i32* @stderr
%359 = tail call i32 @fprintf(i32 %358, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%360 = inttoptr i64 %7 to i8*
%361 = tail call i32 @free(i8* %360)
%362 = inttoptr i64 %15 to i8*
%363 = tail call i32 @free(i8* %362)
br label %430
364: ; preds = %353
%365 = tail call i64 @malloc(i32 %6)
%366 = inttoptr i64 %365 to double*
%367 = icmp eq i64 %365, 0
br i1 %367, label %368, label %377
368: ; preds = %364
%369 = load i32, i32* @stderr
%370 = tail call i32 @fprintf(i32 %369, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%371 = inttoptr i64 %7 to i8*
%372 = tail call i32 @free(i8* %371)
%373 = inttoptr i64 %15 to i8*
%374 = tail call i32 @free(i8* %373)
%375 = inttoptr i64 %354 to i8*
%376 = tail call i32 @free(i8* %375)
br label %430
377: ; preds = %364
%378 = tail call i32 @subspl(double* %8, double* %16, i32 %20, double* %355, double* %366)
%379 = icmp slt i32 %2, 1
br i1 %379, label %430, label %380
380: ; preds = %377, %427
%381 = phi i32 [ %428, %427 ], [ 1, %377 ]
%382 = phi double* [ %383, %427 ], [ %8, %377 ]
%383 = getelementptr inbounds double, double* %382, i64 1
%384 = load double, double* %382
%385 = fcmp ugt double %384, %3
br i1 %385, label %427, label %386
386: ; preds = %380
%387 = load double, double* %383
%388 = fcmp ogt double %387, %3
br i1 %388, label %389, label %427
389: ; preds = %386
%390 = zext i32 %381 to i64
%391 = getelementptr inbounds double, double* %366, i64 %390
%392 = getelementptr inbounds double, double* %391, i64 -1
%393 = load double, double* %392
%394 = load double, double* %391
%395 = getelementptr inbounds double, double* %355, i64 %390
%396 = load double, double* %395
%397 = fsub double %387, %3
%398 = fsub double %3, %384
%399 = fmul double %397, %393
%400 = fmul double %397, %399
%401 = fmul double %398, %394
%402 = fmul double %398, %401
%403 = fmul double %398, %402
%404 = tail call double @llvm.fmuladd.f64(double %400, double %397, double %403)
%405 = getelementptr inbounds double, double* %16, i64 %390
%406 = getelementptr inbounds double, double* %405, i64 -1
%407 = load double, double* %406
%408 = fneg double %396
%409 = fmul double %396, %408
%410 = fmul double %393, %409
%411 = tail call double @llvm.fmuladd.f64(double %407, double 6.000000e+00, double %410)
%412 = tail call double @llvm.fmuladd.f64(double %411, double %397, double %404)
%413 = load double, double* %405
%414 = fmul double %394, %409
%415 = tail call double @llvm.fmuladd.f64(double %413, double 6.000000e+00, double %414)
%416 = tail call double @llvm.fmuladd.f64(double %415, double %398, double %412)
%417 = fdiv double %416, %396
%418 = fdiv double %417, 6.000000e+00
%419 = inttoptr i64 %7 to i8*
%420 = tail call i32 @free(i8* %419)
%421 = inttoptr i64 %15 to i8*
%422 = tail call i32 @free(i8* %421)
%423 = inttoptr i64 %354 to i8*
%424 = tail call i32 @free(i8* %423)
%425 = inttoptr i64 %365 to i8*
%426 = tail call i32 @free(i8* %425)
br label %430
427: ; preds = %380, %386
%428 = add nuw i32 %381, 1
%429 = icmp eq i32 %381, %2
br i1 %429, label %430, label %380
430: ; preds = %427, %377, %389, %368, %357, %336, %327, %201, %24, %11
%431 = phi double [ 0.000000e+00, %11 ], [ 0.000000e+00, %24 ], [ 0.000000e+00, %201 ], [ 0.000000e+00, %327 ], [ %343, %336 ], [ 0.000000e+00, %357 ], [ 0.000000e+00, %368 ], [ %418, %389 ], [ 0.000000e+00, %377 ], [ 0.000000e+00, %427 ]
ret double %431
}