#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 */
scalar_t__ fabs(double);
int /*<<< orphan*/ fit(int, double *, double *, double *, double, double, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *, ...);
double interpolate(int, double *, double *, double *, double, double, int);
int /*<<< orphan*/ is_monotonic(int, double *);
int /*<<< orphan*/ non_monotonic_error();
scalar_t__ realloc(double *, int);
int /*<<< orphan*/ stderr;
void do_spline(int used, int len, double **t, int ydimension, double **y,
               double **z, double tension, int periodic,
               int spec_boundary_condition, double k, int precision,
               double first_t, double last_t, double spacing_t,
               int no_of_intervals, int spec_first_t, int spec_last_t,
               int spec_spacing_t, int spec_no_of_intervals,
               int suppress_adirissa, double *do_spline_x,
               double **do_spline_yy) {
  int range_count = 0;
  int lastval = 0;
  int i;
  if (used + 1 == 0)
    return;
  if (used + 1 == 1) {
    fprintf(stderr, "%s: cannot construct a spline from a single data point\n",
            "do_spline");
    return;
  }
  if (!periodic && used + 1 <= 2) {
    if (spec_boundary_condition)
      fprintf(
          stderr,
          "%s: only 2 data points, so ignoring specified boundary condition\n",
          "do_spline");
    k = 0.0;
  }
  if (!is_monotonic(used, *t))
    non_monotonic_error();
  if (periodic) {
    int print_warning = 0;
    for (i = 0; i < ydimension; i++) {
      if (y[i][used] != y[i][0])
        print_warning = 1;
      y[i][used] = y[i][0];
    }
    if (print_warning == 1)
      fprintf(
          stderr,
          "%s: setting final y value equal to initial to ensure periodicity\n",
          "do_spline");
    if (used + 1 >= len) {
      len++;
      *t = (double *)realloc(*t, sizeof(double) * len);
      for (i = 0; i < ydimension; i++) {
        y[i] = (double *)realloc(y[i], sizeof(double) * len);
        z[i] = (double *)realloc(z[i], sizeof(double) * len);
      }
    }
    (*t)[used + 1] = (*t)[used] + ((*t)[1] - (*t)[0]);
    for (i = 0; i < ydimension; i++)
      y[i][used + 1] = y[i][1];
  }
  for (i = 0; i < ydimension; i++)
    fit(used + (periodic ? 1 : 0), *t, y[i], z[i], k, tension, periodic);
  if (!spec_first_t)
    first_t = (*t)[0];
  if (!spec_last_t)
    last_t = (*t)[used];
  if (!spec_spacing_t) {
    if (no_of_intervals > 0)
      spacing_t = (last_t - first_t) / no_of_intervals;
    else
      spacing_t = 0;
  } else {
    if ((last_t - first_t) * spacing_t < 0.0) {
      fprintf(stderr, "%s: specified spacing is of wrong sign, corrected\n",
              "do_spline");
      spacing_t = -spacing_t;
    }
    if (spec_no_of_intervals)
      fprintf(stderr, "%s: ignoring specified number of intervals\n",
              "do_spline");
    no_of_intervals = (int)(fabs((last_t - first_t) / spacing_t) + 0.0000001);
  }
  if (last_t == (*t)[0])
    lastval = 1;
  else if (last_t == (*t)[used])
    lastval = 2;
  for (i = 0; i <= no_of_intervals; ++i) {
    double x;
    x = first_t + spacing_t * i;
    if (i == no_of_intervals) {
      if (lastval == 1)
        x = (*t)[0];
      else if (lastval == 2)
        x = (*t)[used];
    }
    if (periodic || (x - (*t)[0]) * (x - (*t)[used]) <= 0) {
      int j;
      for (j = 0; j < ydimension; j++) {
        do_spline_yy[j][i] =
            interpolate(used, *t, y[j], z[j], x, tension, periodic);
        do_spline_x[i] = x;
      }
    } else
      range_count++;
  }
  switch (range_count) {
  case 0:
    break;
  case 1:
    fprintf(
        stderr,
        "%s: one requested point could not be computed (out of data range)\n",
        "do_spline");
    break;
  default:
    fprintf(
        stderr,
        "%s: %d requested points could not be computed (out of data range)\n",
        "do_spline", range_count);
    break;
  }
}


x86 assembly (clang, -O0):
<do_spline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
movsd  %xmm3,-0x48(%rbp)
movsd  %xmm4,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jne    11eb <do_spline+0x7b>
jmp    1835 <do_spline+0x6c5>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cmp    $0x1,%eax
jne    121d <do_spline+0xad>
mov    0x2ddf(%rip),%rax
mov    (%rax),%edi
lea    0xdfe(%rip),%rsi
lea    0xe2f(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
jmp    1835 <do_spline+0x6c5>
cmpl   $0x0,0x10(%rbp)
jne    1266 <do_spline+0xf6>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cmp    $0x2,%eax
jg     1266 <do_spline+0xf6>
cmpl   $0x0,0x18(%rbp)
je     125e <do_spline+0xee>
mov    0x2d99(%rip),%rax
mov    (%rax),%edi
lea    0xdfa(%rip),%rsi
lea    0xde9(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
call   1030 <is_monotonic@plt>
cmp    $0x0,%eax
jne    1285 <do_spline+0x115>
mov    $0x0,%al
call   1070 <non_monotonic_error@plt>
cmpl   $0x0,0x10(%rbp)
je     1484 <do_spline+0x314>
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1319 <do_spline+0x1a9>
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
ucomisd (%rax),%xmm0
jne    12df <do_spline+0x16f>
jp     12df <do_spline+0x16f>
jmp    12e6 <do_spline+0x176>
movl   $0x1,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    129d <do_spline+0x12d>
cmpl   $0x1,-0x60(%rbp)
jne    1341 <do_spline+0x1d1>
mov    0x2cb6(%rip),%rax
mov    (%rax),%edi
lea    0xd59(%rip),%rsi
lea    0xd06(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jl     13f3 <do_spline+0x283>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%esi
call   1080 <realloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ee <do_spline+0x27e>
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%esi
call   1080 <realloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%esi
call   1080 <realloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1380 <do_spline+0x210>
jmp    13f3 <do_spline+0x283>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    147f <do_spline+0x30f>
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    143a <do_spline+0x2ca>
jmp    1484 <do_spline+0x314>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ec <do_spline+0x37c>
mov    -0x4(%rbp),%edi
mov    0x10(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
add    %eax,%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mov    0x10(%rbp),%r8d
call   1090 <fit@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    148b <do_spline+0x31b>
cmpl   $0x0,0x30(%rbp)
jne    1506 <do_spline+0x396>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x0,0x38(%rbp)
jne    1525 <do_spline+0x3b5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,0x40(%rbp)
jne    1563 <do_spline+0x3f3>
cmpl   $0x0,0x28(%rbp)
jle    1556 <do_spline+0x3e6>
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    155e <do_spline+0x3ee>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1612 <do_spline+0x4a2>
movsd  -0x48(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    15be <do_spline+0x44e>
mov    0x2a5a(%rip),%rax
mov    (%rax),%edi
lea    0xb3f(%rip),%rsi
lea    0xaaa(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,0x48(%rbp)
je     15e6 <do_spline+0x476>
mov    0x2a11(%rip),%rax
mov    (%rax),%edi
lea    0xb29(%rip),%rsi
lea    0xa61(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %rax,%xmm0
movsd  0x9f9(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,0x28(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
ucomisd (%rax),%xmm0
jne    163a <do_spline+0x4ca>
jp     163a <do_spline+0x4ca>
movl   $0x1,-0x58(%rbp)
jmp    1667 <do_spline+0x4f7>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1662 <do_spline+0x4f2>
jp     1662 <do_spline+0x4f2>
movl   $0x2,-0x58(%rbp)
jmp    1667 <do_spline+0x4f7>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x28(%rbp),%eax
jg     17c8 <do_spline+0x658>
movsd  -0x40(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
cvtsi2sdl -0x5c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x28(%rbp),%eax
jne    16ea <do_spline+0x57a>
cmpl   $0x1,-0x58(%rbp)
jne    16c1 <do_spline+0x551>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    16e5 <do_spline+0x575>
cmpl   $0x2,-0x58(%rbp)
jne    16e0 <do_spline+0x570>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    16e5 <do_spline+0x575>
jmp    16ea <do_spline+0x57a>
cmpl   $0x0,0x10(%rbp)
jne    172a <do_spline+0x5ba>
movsd  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     17ac <do_spline+0x63c>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17a7 <do_spline+0x637>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movsd  -0x68(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mov    0x10(%rbp),%r8d
call   1060 <interpolate@plt>
mov    0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1731 <do_spline+0x5c1>
jmp    17b5 <do_spline+0x645>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    17ba <do_spline+0x64a>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    166e <do_spline+0x4fe>
mov    -0x54(%rbp),%eax
mov    %eax,-0x70(%rbp)
test   %eax,%eax
je     17ec <do_spline+0x67c>
jmp    17db <do_spline+0x66b>
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
je     17f1 <do_spline+0x681>
jmp    1814 <do_spline+0x6a4>
jmp    1835 <do_spline+0x6c5>
mov    0x27e8(%rip),%rax
mov    (%rax),%edi
lea    0x92c(%rip),%rsi
lea    0x838(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
jmp    1835 <do_spline+0x6c5>
mov    0x27c5(%rip),%rax
mov    (%rax),%edi
mov    -0x54(%rbp),%ecx
lea    0x949(%rip),%rsi
lea    0x812(%rip),%rdx
mov    $0x0,%al
call   1050 <fprintf@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_spline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x78(%rsp)
mov    %edi,%eax
inc    %eax
jne    119e <do_spline+0x2e>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edi,%r14d
test   %edi,%edi
je     126e <do_spline+0xfe>
mov    %r8,%r13
mov    %rdx,%r15
mov    %eax,0xc(%rsp)
movsd  %xmm1,0x28(%rsp)
movsd  %xmm3,0x18(%rsp)
mov    %ecx,0x4(%rsp)
movapd %xmm4,0x40(%rsp)
movsd  %xmm2,0x20(%rsp)
movsd  %xmm0,0x30(%rsp)
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r12
mov    0x108(%rsp),%eax
mov    %eax,0x38(%rsp)
mov    0x100(%rsp),%eax
mov    %eax,0x10(%rsp)
mov    0xf8(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0xf0(%rsp),%eax
mov    %eax,0x68(%rsp)
mov    0xe8(%rsp),%eax
mov    %rax,0x70(%rsp)
mov    0xd0(%rsp),%eax
cmp    $0x1,%r14d
mov    %eax,0x8(%rsp)
mov    %rsi,0x80(%rsp)
jg     128d <do_spline+0x11d>
test   %eax,%eax
jne    128d <do_spline+0x11d>
cmpl   $0x0,0xd8(%rsp)
je     1283 <do_spline+0x113>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x2d8b(%rip),%rax
mov    (%rax),%edi
lea    0xe04(%rip),%rsi
lea    0xdf3(%rip),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
jmp    128d <do_spline+0x11d>
mov    0x2d6b(%rip),%rax
mov    (%rax),%edi
lea    0xda2(%rip),%rsi
jmp    1872 <do_spline+0x702>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    (%r15),%rsi
mov    %r14d,%edi
call   1030 <is_monotonic@plt>
test   %eax,%eax
jne    12a3 <do_spline+0x133>
xor    %eax,%eax
call   1070 <non_monotonic_error@plt>
movslq %r14d,%rax
mov    %rax,0x58(%rsp)
mov    0x8(%rsp),%ecx
test   %ecx,%ecx
movsd  0x20(%rsp),%xmm3
mov    %r14d,0x3c(%rsp)
mov    %rbp,0x88(%rsp)
mov    %r12,0x90(%rsp)
mov    %r15,0x60(%rsp)
je     1507 <do_spline+0x397>
mov    0x4(%rsp),%ecx
test   %ecx,%ecx
mov    0x58(%rsp),%r14
jle    13a8 <do_spline+0x238>
mov    %ecx,%eax
cmp    $0x1,%ecx
jne    12f5 <do_spline+0x185>
xor    %edx,%edx
xor    %ecx,%ecx
jmp    135d <do_spline+0x1ed>
mov    %eax,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
mov    $0x1,%edi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rdx,8),%rbp
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  0x0(%rbp),%xmm1
ucomisd %xmm1,%xmm0
movsd  %xmm1,0x0(%rbp,%r14,8)
mov    0x8(%r13,%rdx,8),%rbp
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  0x0(%rbp),%xmm1
cmovne %edi,%ecx
cmovp  %edi,%ecx
ucomisd %xmm1,%xmm0
cmovne %edi,%ecx
cmovp  %edi,%ecx
movsd  %xmm1,0x0(%rbp,%r14,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1310 <do_spline+0x1a0>
test   $0x1,%al
je     1385 <do_spline+0x215>
mov    0x0(%r13,%rdx,8),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  (%rax),%xmm1
ucomisd %xmm1,%xmm0
mov    $0x1,%edx
cmovne %edx,%ecx
cmovp  %edx,%ecx
movsd  %xmm1,(%rax,%r14,8)
cmp    $0x1,%ecx
jne    13a8 <do_spline+0x238>
mov    0x2c4f(%rip),%rax
mov    (%rax),%edi
lea    0xd0a(%rip),%rsi
lea    0xcb7(%rip),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0x80(%rsp),%rax
cmp    %eax,0xc(%rsp)
mov    0x78(%rsp),%r15
jl     1419 <do_spline+0x2a9>
mov    0x60(%rsp),%rbp
mov    0x0(%rbp),%rdi
lea    0x8(,%rax,8),%ebx
mov    %ebx,%esi
call   1080 <realloc@plt>
mov    %rax,0x0(%rbp)
cmpl   $0x0,0x4(%rsp)
jle    1419 <do_spline+0x2a9>
mov    0x4(%rsp),%r12d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rbp,8),%rdi
mov    %ebx,%esi
call   1080 <realloc@plt>
mov    %rax,0x0(%r13,%rbp,8)
mov    (%r15,%rbp,8),%rdi
mov    %ebx,%esi
call   1080 <realloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    13f0 <do_spline+0x280>
mov    0x60(%rsp),%r15
mov    (%r15),%rcx
movsd  0x8(%rcx),%xmm0
subsd  (%rcx),%xmm0
addsd  (%rcx,%r14,8),%xmm0
movslq 0xc(%rsp),%rax
movsd  %xmm0,(%rcx,%rax,8)
mov    0x4(%rsp),%ebp
test   %ebp,%ebp
jle    1466 <do_spline+0x2f6>
mov    %ebp,%edx
lea    -0x1(%rdx),%rsi
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x3,%rsi
movsd  0x20(%rsp),%xmm3
mov    0x3c(%rsp),%r14d
mov    0x8(%rsp),%ecx
jae    1489 <do_spline+0x319>
xor    %esi,%esi
jmp    14d5 <do_spline+0x365>
movl   $0x0,0xc(%rsp)
movsd  0x30(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
movapd 0x40(%rsp),%xmm2
mov    0x8(%rsp),%ecx
jmp    1592 <do_spline+0x422>
and    $0xfffffffc,%edx
xor    %esi,%esi
xchg   %ax,%ax
mov    0x0(%r13,%rsi,8),%rdi
movsd  0x8(%rdi),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x8(%r13,%rsi,8),%rdi
movsd  0x8(%rdi),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x10(%r13,%rsi,8),%rdi
movsd  0x8(%rdi),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x18(%r13,%rsi,8),%rdi
movsd  0x8(%rdi),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1490 <do_spline+0x320>
test   %rbp,%rbp
je     1507 <do_spline+0x397>
lea    0x0(,%rsi,8),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rsi,8),%rdi
movsd  0x8(%rdi),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    14f0 <do_spline+0x380>
mov    0x4(%rsp),%ebp
test   %ebp,%ebp
setg   %al
mov    %eax,0xc(%rsp)
jle    1579 <do_spline+0x409>
cmp    $0x1,%ecx
sbb    $0xffffffff,%r14d
mov    %ebp,%r12d
xor    %ebp,%ebp
movsd  0x30(%rsp),%xmm1
mov    0x78(%rsp),%rbx
nopl   (%rax)
mov    (%r15),%rsi
mov    0x0(%r13,%rbp,8),%rdx
mov    (%rbx,%rbp,8),%rcx
mov    %r14d,%edi
movsd  0x28(%rsp),%xmm0
mov    0x8(%rsp),%r8d
call   1090 <fit@plt>
mov    0x8(%rsp),%ecx
movsd  0x30(%rsp),%xmm1
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1530 <do_spline+0x3c0>
movsd  0x20(%rsp),%xmm3
movapd 0x40(%rsp),%xmm2
mov    0x58(%rsp),%r14
mov    0x4(%rsp),%ebp
jmp    1592 <do_spline+0x422>
movl   $0x0,0xc(%rsp)
movsd  0x30(%rsp),%xmm1
movapd 0x40(%rsp),%xmm2
mov    0x58(%rsp),%r14
movsd  0x18(%rsp),%xmm5
cmpl   $0x0,0x68(%rsp)
mov    0x70(%rsp),%rdx
je     168a <do_spline+0x51a>
cmpl   $0x0,0x14(%rsp)
jne    15b8 <do_spline+0x448>
mov    (%r15),%rax
movsd  (%rax,%r14,8),%xmm5
cmpl   $0x0,0x10(%rsp)
movsd  %xmm3,0x20(%rsp)
je     16a1 <do_spline+0x531>
movapd %xmm5,%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x28(%rsp)
mulsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movsd  %xmm5,0x18(%rsp)
jbe    1617 <do_spline+0x4a7>
mov    0x29ee(%rip),%rax
mov    (%rax),%edi
lea    0xaeb(%rip),%rsi
lea    0xa56(%rip),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
movapd 0x40(%rsp),%xmm2
xorpd  0x9e9(%rip),%xmm2
mov    0x38(%rsp),%eax
test   %eax,%eax
movapd %xmm2,0x40(%rsp)
je     1649 <do_spline+0x4d9>
mov    0x29b4(%rip),%rax
mov    (%rax),%edi
lea    0xae4(%rip),%rsi
lea    0xa1c(%rip),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
movapd 0x40(%rsp),%xmm2
movsd  0x28(%rsp),%xmm0
divsd  %xmm2,%xmm0
call   1040 <fabs@plt>
movapd 0x40(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x9a2(%rip),%xmm0
cvttsd2si %xmm0,%edx
movsd  0x30(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
mov    0x8(%rsp),%ecx
movsd  0x18(%rsp),%xmm5
jmp    16be <do_spline+0x54e>
mov    (%r15),%rax
movsd  (%rax),%xmm3
cmpl   $0x0,0x14(%rsp)
jne    15b8 <do_spline+0x448>
jmp    15af <do_spline+0x43f>
test   %edx,%edx
jle    16ba <do_spline+0x54a>
movapd %xmm5,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
divsd  %xmm0,%xmm4
jmp    16be <do_spline+0x54e>
xorpd  %xmm4,%xmm4
mov    (%r15),%rax
ucomisd (%rax),%xmm5
jne    16e0 <do_spline+0x570>
jp     16e0 <do_spline+0x570>
mov    $0x1,%al
mov    %eax,0x4(%rsp)
movl   $0x0,0x10(%rsp)
test   %edx,%edx
jns    1708 <do_spline+0x598>
jmp    118c <do_spline+0x1c>
ucomisd (%rax,%r14,8),%xmm5
jne    18b9 <do_spline+0x749>
jp     18b9 <do_spline+0x749>
mov    $0x1,%al
mov    %eax,0x10(%rsp)
movl   $0x0,0x4(%rsp)
test   %edx,%edx
js     118c <do_spline+0x1c>
mov    %edx,%esi
add    $0x1,%edx
mov    %ebp,%edi
xor    %ebx,%ebx
lea    0x0(,%r14,8),%rax
mov    %rax,0x68(%rsp)
movl   $0x0,0x14(%rsp)
movapd %xmm4,0x40(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rsi,0x18(%rsp)
mov    0x88(%rsp),%r12
jmp    175d <do_spline+0x5ed>
addl   $0x1,0x14(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
cmp    %rdx,%rbx
je     1851 <do_spline+0x6e1>
xorps  %xmm5,%xmm5
cvtsi2sd %ebx,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
cmp    %rsi,%rbx
jne    1793 <do_spline+0x623>
cmpb   $0x0,0x4(%rsp)
je     1780 <do_spline+0x610>
mov    (%r15),%rax
jmp    178f <do_spline+0x61f>
nopl   (%rax)
cmpb   $0x0,0x10(%rsp)
je     1793 <do_spline+0x623>
mov    (%r15),%rax
add    0x68(%rsp),%rax
movsd  (%rax),%xmm5
test   %ecx,%ecx
jne    17ba <do_spline+0x64a>
mov    (%r15),%rax
movapd %xmm5,%xmm0
subsd  (%rax),%xmm0
movapd %xmm5,%xmm2
subsd  (%rax,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
jb     1740 <do_spline+0x5d0>
cmpb   $0x0,0xc(%rsp)
je     1750 <do_spline+0x5e0>
xor    %ebp,%ebp
mov    0x3c(%rsp),%r15d
movsd  %xmm5,0x28(%rsp)
xchg   %ax,%ax
mov    0x60(%rsp),%rax
mov    (%rax),%rsi
mov    0x0(%r13,%rbp,8),%rdx
mov    0x78(%rsp),%rax
mov    (%rax,%rbp,8),%rcx
mov    %rdi,%r14
mov    %r15d,%edi
movapd %xmm5,%xmm0
mov    0x8(%rsp),%r8d
call   1060 <interpolate@plt>
movsd  0x28(%rsp),%xmm5
mov    %r14,%rdi
mov    0x8(%rsp),%ecx
movsd  0x30(%rsp),%xmm1
mov    (%r12,%rbp,8),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    0x90(%rsp),%rax
movsd  %xmm5,(%rax,%rbx,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    17d0 <do_spline+0x660>
movsd  0x20(%rsp),%xmm3
movapd 0x40(%rsp),%xmm4
mov    0x60(%rsp),%r15
mov    0x58(%rsp),%r14
mov    0x70(%rsp),%rdx
mov    0x18(%rsp),%rsi
jmp    1750 <do_spline+0x5e0>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
je     118c <do_spline+0x1c>
mov    0x277c(%rip),%rax
cmp    $0x1,%ecx
jne    1891 <do_spline+0x721>
mov    (%rax),%edi
lea    0x8d3(%rip),%rsi
lea    0x7df(%rip),%rdx
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <fprintf@plt>
mov    (%rax),%edi
lea    0x8ee(%rip),%rsi
lea    0x7b7(%rip),%rdx
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <fprintf@plt>
movl   $0x0,0x4(%rsp)
jmp    16cf <do_spline+0x55f>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [56 x i8] c"%s: cannot construct a spline from a single data point\0A\00"
@.str.1 = [10 x i8] c"do_spline\00"
@.str.2 = [66 x i8] c"%s: only 2 data points, so ignoring specified boundary condition\0A\00"
@.str.3 = [66 x i8] c"%s: setting final y value equal to initial to ensure periodicity\0A\00"
@.str.4 = [51 x i8] c"%s: specified spacing is of wrong sign, corrected\0A\00"
@.str.5 = [44 x i8] c"%s: ignoring specified number of intervals\0A\00"
@.str.6 = [67 x i8] c"%s: one requested point could not be computed (out of data range)\0A\00"
@.str.7 = [67 x i8] c"%s: %d requested points could not be computed (out of data range)\0A\00"
define void @do_spline(i32 %0, i32 %1, double** %2, i32 %3, double** %4, double** %5, double %6, i32 %7, i32 %8, double %9, i32 %10, double %11, double %12, double %13, i32 %14, i32 %15, i32 %16, i32 %17, i32 %18, i32 %19, double* %20, double** %21) {
%23 = alloca i32
%24 = alloca i32
%25 = alloca double**
%26 = alloca i32
%27 = alloca double**
%28 = alloca double**
%29 = alloca double
%30 = alloca i32
%31 = alloca i32
%32 = alloca double
%33 = alloca i32
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca double*
%44 = alloca double**
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca double
%50 = alloca i32
store i32 %0, i32* %23
store i32 %1, i32* %24
store double** %2, double*** %25
store i32 %3, i32* %26
store double** %4, double*** %27
store double** %5, double*** %28
store double %6, double* %29
store i32 %7, i32* %30
store i32 %8, i32* %31
store double %9, double* %32
store i32 %10, i32* %33
store double %11, double* %34
store double %12, double* %35
store double %13, double* %36
store i32 %14, i32* %37
store i32 %15, i32* %38
store i32 %16, i32* %39
store i32 %17, i32* %40
store i32 %18, i32* %41
store i32 %19, i32* %42
store double* %20, double** %43
store double** %21, double*** %44
store i32 0, i32* %45
store i32 0, i32* %46
%51 = load i32, i32* %23
%52 = add nsw i32 %51, 1
%53 = icmp eq i32 %52, 0
br i1 %53, label %54, label %55
54: ; preds = %22
br label %462
55: ; preds = %22
%56 = load i32, i32* %23
%57 = add nsw i32 %56, 1
%58 = icmp eq i32 %57, 1
br i1 %58, label %59, label %62
59: ; preds = %55
%60 = load i32, i32* @stderr
%61 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %60, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %462
62: ; preds = %55
%63 = load i32, i32* %30
%64 = icmp ne i32 %63, 0
br i1 %64, label %76, label %65
65: ; preds = %62
%66 = load i32, i32* %23
%67 = add nsw i32 %66, 1
%68 = icmp sle i32 %67, 2
br i1 %68, label %69, label %76
69: ; preds = %65
%70 = load i32, i32* %31
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %75
72: ; preds = %69
%73 = load i32, i32* @stderr
%74 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %73, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %75
75: ; preds = %72, %69
store double 0.000000e+00, double* %32
br label %76
76: ; preds = %75, %65, %62
%77 = load i32, i32* %23
%78 = load double**, double*** %25
%79 = load double*, double** %78
%80 = call i32 @is_monotonic(i32 %77, double* %79)
%81 = icmp ne i32 %80, 0
br i1 %81, label %84, label %82
82: ; preds = %76
%83 = call i32 (...) @non_monotonic_error()
br label %84
84: ; preds = %82, %76
%85 = load i32, i32* %30
%86 = icmp ne i32 %85, 0
br i1 %86, label %87, label %240
87: ; preds = %84
store i32 0, i32* %48
store i32 0, i32* %47
br label %88
88: ; preds = %127, %87
%89 = load i32, i32* %47
%90 = load i32, i32* %26
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %130
92: ; preds = %88
%93 = load double**, double*** %27
%94 = load i32, i32* %47
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double*, double** %93, i64 %95
%97 = load double*, double** %96
%98 = load i32, i32* %23
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %97, i64 %99
%101 = load double, double* %100
%102 = load double**, double*** %27
%103 = load i32, i32* %47
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double*, double** %102, i64 %104
%106 = load double*, double** %105
%107 = getelementptr inbounds double, double* %106, i64 0
%108 = load double, double* %107
%109 = fcmp une double %101, %108
br i1 %109, label %110, label %111
110: ; preds = %92
store i32 1, i32* %48
br label %111
111: ; preds = %110, %92
%112 = load double**, double*** %27
%113 = load i32, i32* %47
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double*, double** %112, i64 %114
%116 = load double*, double** %115
%117 = getelementptr inbounds double, double* %116, i64 0
%118 = load double, double* %117
%119 = load double**, double*** %27
%120 = load i32, i32* %47
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double*, double** %119, i64 %121
%123 = load double*, double** %122
%124 = load i32, i32* %23
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
store double %118, double* %126
br label %127
127: ; preds = %111
%128 = load i32, i32* %47
%129 = add nsw i32 %128, 1
store i32 %129, i32* %47
br label %88
130: ; preds = %88
%131 = load i32, i32* %48
%132 = icmp eq i32 %131, 1
br i1 %132, label %133, label %136
133: ; preds = %130
%134 = load i32, i32* @stderr
%135 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %134, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %136
136: ; preds = %133, %130
%137 = load i32, i32* %23
%138 = add nsw i32 %137, 1
%139 = load i32, i32* %24
%140 = icmp sge i32 %138, %139
br i1 %140, label %141, label %192
141: ; preds = %136
%142 = load i32, i32* %24
%143 = add nsw i32 %142, 1
store i32 %143, i32* %24
%144 = load double**, double*** %25
%145 = load double*, double** %144
%146 = load i32, i32* %24
%147 = sext i32 %146 to i64
%148 = mul i64 8, %147
%149 = trunc i64 %148 to i32
%150 = call i64 @realloc(double* %145, i32 %149)
%151 = inttoptr i64 %150 to double*
%152 = load double**, double*** %25
store double* %151, double** %152
store i32 0, i32* %47
br label %153
153: ; preds = %188, %141
%154 = load i32, i32* %47
%155 = load i32, i32* %26
%156 = icmp slt i32 %154, %155
br i1 %156, label %157, label %191
157: ; preds = %153
%158 = load double**, double*** %27
%159 = load i32, i32* %47
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double*, double** %158, i64 %160
%162 = load double*, double** %161
%163 = load i32, i32* %24
%164 = sext i32 %163 to i64
%165 = mul i64 8, %164
%166 = trunc i64 %165 to i32
%167 = call i64 @realloc(double* %162, i32 %166)
%168 = inttoptr i64 %167 to double*
%169 = load double**, double*** %27
%170 = load i32, i32* %47
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double*, double** %169, i64 %171
store double* %168, double** %172
%173 = load double**, double*** %28
%174 = load i32, i32* %47
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double*, double** %173, i64 %175
%177 = load double*, double** %176
%178 = load i32, i32* %24
%179 = sext i32 %178 to i64
%180 = mul i64 8, %179
%181 = trunc i64 %180 to i32
%182 = call i64 @realloc(double* %177, i32 %181)
%183 = inttoptr i64 %182 to double*
%184 = load double**, double*** %28
%185 = load i32, i32* %47
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double*, double** %184, i64 %186
store double* %183, double** %187
br label %188
188: ; preds = %157
%189 = load i32, i32* %47
%190 = add nsw i32 %189, 1
store i32 %190, i32* %47
br label %153
191: ; preds = %153
br label %192
192: ; preds = %191, %136
%193 = load double**, double*** %25
%194 = load double*, double** %193
%195 = load i32, i32* %23
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
%199 = load double**, double*** %25
%200 = load double*, double** %199
%201 = getelementptr inbounds double, double* %200, i64 1
%202 = load double, double* %201
%203 = load double**, double*** %25
%204 = load double*, double** %203
%205 = getelementptr inbounds double, double* %204, i64 0
%206 = load double, double* %205
%207 = fsub double %202, %206
%208 = fadd double %198, %207
%209 = load double**, double*** %25
%210 = load double*, double** %209
%211 = load i32, i32* %23
%212 = add nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %210, i64 %213
store double %208, double* %214
store i32 0, i32* %47
br label %215
215: ; preds = %236, %192
%216 = load i32, i32* %47
%217 = load i32, i32* %26
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %239
219: ; preds = %215
%220 = load double**, double*** %27
%221 = load i32, i32* %47
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double*, double** %220, i64 %222
%224 = load double*, double** %223
%225 = getelementptr inbounds double, double* %224, i64 1
%226 = load double, double* %225
%227 = load double**, double*** %27
%228 = load i32, i32* %47
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double*, double** %227, i64 %229
%231 = load double*, double** %230
%232 = load i32, i32* %23
%233 = add nsw i32 %232, 1
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double, double* %231, i64 %234
store double %226, double* %235
br label %236
236: ; preds = %219
%237 = load i32, i32* %47
%238 = add nsw i32 %237, 1
store i32 %238, i32* %47
br label %215
239: ; preds = %215
br label %240
240: ; preds = %239, %84
store i32 0, i32* %47
br label %241
241: ; preds = %268, %240
%242 = load i32, i32* %47
%243 = load i32, i32* %26
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %271
245: ; preds = %241
%246 = load i32, i32* %23
%247 = load i32, i32* %30
%248 = icmp ne i32 %247, 0
%249 = zext i1 %248 to i64
%250 = select i1 %248, i32 1, i32 0
%251 = add nsw i32 %246, %250
%252 = load double**, double*** %25
%253 = load double*, double** %252
%254 = load double**, double*** %27
%255 = load i32, i32* %47
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double*, double** %254, i64 %256
%258 = load double*, double** %257
%259 = load double**, double*** %28
%260 = load i32, i32* %47
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double*, double** %259, i64 %261
%263 = load double*, double** %262
%264 = load double, double* %32
%265 = load double, double* %29
%266 = load i32, i32* %30
%267 = call i32 @fit(i32 %251, double* %253, double* %258, double* %263, double %264, double %265, i32 %266)
br label %268
268: ; preds = %245
%269 = load i32, i32* %47
%270 = add nsw i32 %269, 1
store i32 %270, i32* %47
br label %241
271: ; preds = %241
%272 = load i32, i32* %38
%273 = icmp ne i32 %272, 0
br i1 %273, label %279, label %274
274: ; preds = %271
%275 = load double**, double*** %25
%276 = load double*, double** %275
%277 = getelementptr inbounds double, double* %276, i64 0
%278 = load double, double* %277
store double %278, double* %34
br label %279
279: ; preds = %274, %271
%280 = load i32, i32* %39
%281 = icmp ne i32 %280, 0
br i1 %281, label %289, label %282
282: ; preds = %279
%283 = load double**, double*** %25
%284 = load double*, double** %283
%285 = load i32, i32* %23
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %284, i64 %286
%288 = load double, double* %287
store double %288, double* %35
br label %289
289: ; preds = %282, %279
%290 = load i32, i32* %40
%291 = icmp ne i32 %290, 0
br i1 %291, label %304, label %292
292: ; preds = %289
%293 = load i32, i32* %37
%294 = icmp sgt i32 %293, 0
br i1 %294, label %295, label %302
295: ; preds = %292
%296 = load double, double* %35
%297 = load double, double* %34
%298 = fsub double %296, %297
%299 = load i32, i32* %37
%300 = sitofp i32 %299 to double
%301 = fdiv double %298, %300
store double %301, double* %36
br label %303
302: ; preds = %292
store double 0.000000e+00, double* %36
br label %303
303: ; preds = %302, %295
br label %332
304: ; preds = %289
%305 = load double, double* %35
%306 = load double, double* %34
%307 = fsub double %305, %306
%308 = load double, double* %36
%309 = fmul double %307, %308
%310 = fcmp olt double %309, 0.000000e+00
br i1 %310, label %311, label %316
311: ; preds = %304
%312 = load i32, i32* @stderr
%313 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %312, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%314 = load double, double* %36
%315 = fneg double %314
store double %315, double* %36
br label %316
316: ; preds = %311, %304
%317 = load i32, i32* %41
%318 = icmp ne i32 %317, 0
br i1 %318, label %319, label %322
319: ; preds = %316
%320 = load i32, i32* @stderr
%321 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %320, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %322
322: ; preds = %319, %316
%323 = load double, double* %35
%324 = load double, double* %34
%325 = fsub double %323, %324
%326 = load double, double* %36
%327 = fdiv double %325, %326
%328 = call i64 @fabs(double %327)
%329 = sitofp i64 %328 to double
%330 = fadd double %329, 0x3E7AD7F29ABCAF48
%331 = fptosi double %330 to i32
store i32 %331, i32* %37
br label %332
332: ; preds = %322, %303
%333 = load double, double* %35
%334 = load double**, double*** %25
%335 = load double*, double** %334
%336 = getelementptr inbounds double, double* %335, i64 0
%337 = load double, double* %336
%338 = fcmp oeq double %333, %337
br i1 %338, label %339, label %340
339: ; preds = %332
store i32 1, i32* %46
br label %351
340: ; preds = %332
%341 = load double, double* %35
%342 = load double**, double*** %25
%343 = load double*, double** %342
%344 = load i32, i32* %23
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
%347 = load double, double* %346
%348 = fcmp oeq double %341, %347
br i1 %348, label %349, label %350
349: ; preds = %340
store i32 2, i32* %46
br label %350
350: ; preds = %349, %340
br label %351
351: ; preds = %350, %339
store i32 0, i32* %47
br label %352
352: ; preds = %449, %351
%353 = load i32, i32* %47
%354 = load i32, i32* %37
%355 = icmp sle i32 %353, %354
br i1 %355, label %356, label %452
356: ; preds = %352
%357 = load double, double* %34
%358 = load double, double* %36
%359 = load i32, i32* %47
%360 = sitofp i32 %359 to double
%361 = call double @llvm.fmuladd.f64(double %358, double %360, double %357)
store double %361, double* %49
%362 = load i32, i32* %47
%363 = load i32, i32* %37
%364 = icmp eq i32 %362, %363
br i1 %364, label %365, label %385
365: ; preds = %356
%366 = load i32, i32* %46
%367 = icmp eq i32 %366, 1
br i1 %367, label %368, label %373
368: ; preds = %365
%369 = load double**, double*** %25
%370 = load double*, double** %369
%371 = getelementptr inbounds double, double* %370, i64 0
%372 = load double, double* %371
store double %372, double* %49
br label %384
373: ; preds = %365
%374 = load i32, i32* %46
%375 = icmp eq i32 %374, 2
br i1 %375, label %376, label %383
376: ; preds = %373
%377 = load double**, double*** %25
%378 = load double*, double** %377
%379 = load i32, i32* %23
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
%382 = load double, double* %381
store double %382, double* %49
br label %383
383: ; preds = %376, %373
br label %384
384: ; preds = %383, %368
br label %385
385: ; preds = %384, %356
%386 = load i32, i32* %30
%387 = icmp ne i32 %386, 0
br i1 %387, label %405, label %388
388: ; preds = %385
%389 = load double, double* %49
%390 = load double**, double*** %25
%391 = load double*, double** %390
%392 = getelementptr inbounds double, double* %391, i64 0
%393 = load double, double* %392
%394 = fsub double %389, %393
%395 = load double, double* %49
%396 = load double**, double*** %25
%397 = load double*, double** %396
%398 = load i32, i32* %23
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %397, i64 %399
%401 = load double, double* %400
%402 = fsub double %395, %401
%403 = fmul double %394, %402
%404 = fcmp ole double %403, 0.000000e+00
br i1 %404, label %405, label %445
405: ; preds = %388, %385
store i32 0, i32* %50
br label %406
406: ; preds = %441, %405
%407 = load i32, i32* %50
%408 = load i32, i32* %26
%409 = icmp slt i32 %407, %408
br i1 %409, label %410, label %444
410: ; preds = %406
%411 = load i32, i32* %23
%412 = load double**, double*** %25
%413 = load double*, double** %412
%414 = load double**, double*** %27
%415 = load i32, i32* %50
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double*, double** %414, i64 %416
%418 = load double*, double** %417
%419 = load double**, double*** %28
%420 = load i32, i32* %50
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double*, double** %419, i64 %421
%423 = load double*, double** %422
%424 = load double, double* %49
%425 = load double, double* %29
%426 = load i32, i32* %30
%427 = call double @interpolate(i32 %411, double* %413, double* %418, double* %423, double %424, double %425, i32 %426)
%428 = load double**, double*** %44
%429 = load i32, i32* %50
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double*, double** %428, i64 %430
%432 = load double*, double** %431
%433 = load i32, i32* %47
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds double, double* %432, i64 %434
store double %427, double* %435
%436 = load double, double* %49
%437 = load double*, double** %43
%438 = load i32, i32* %47
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %437, i64 %439
store double %436, double* %440
br label %441
441: ; preds = %410
%442 = load i32, i32* %50
%443 = add nsw i32 %442, 1
store i32 %443, i32* %50
br label %406
444: ; preds = %406
br label %448
445: ; preds = %388
%446 = load i32, i32* %45
%447 = add nsw i32 %446, 1
store i32 %447, i32* %45
br label %448
448: ; preds = %445, %444
br label %449
449: ; preds = %448
%450 = load i32, i32* %47
%451 = add nsw i32 %450, 1
store i32 %451, i32* %47
br label %352
452: ; preds = %352
%453 = load i32, i32* %45
switch i32 %453, label %458 [
i32 0, label %454
i32 1, label %455
]
454: ; preds = %452
br label %462
455: ; preds = %452
%456 = load i32, i32* @stderr
%457 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %456, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %462
458: ; preds = %452
%459 = load i32, i32* @stderr
%460 = load i32, i32* %45
%461 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %459, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %460)
br label %462
462: ; preds = %54, %59, %458, %455, %454
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [56 x i8] c"%s: cannot construct a spline from a single data point\0A\00"
@.str.1 = [10 x i8] c"do_spline\00"
@.str.2 = [66 x i8] c"%s: only 2 data points, so ignoring specified boundary condition\0A\00"
@.str.3 = [66 x i8] c"%s: setting final y value equal to initial to ensure periodicity\0A\00"
@.str.4 = [51 x i8] c"%s: specified spacing is of wrong sign, corrected\0A\00"
@.str.5 = [44 x i8] c"%s: ignoring specified number of intervals\0A\00"
@.str.6 = [67 x i8] c"%s: one requested point could not be computed (out of data range)\0A\00"
@.str.7 = [67 x i8] c"%s: %d requested points could not be computed (out of data range)\0A\00"
define void @do_spline(i32 %0, i32 %1, double** nocapture %2, i32 %3, double** nocapture %4, double** nocapture %5, double %6, i32 %7, i32 %8, double %9, i32 %10, double %11, double %12, double %13, i32 %14, i32 %15, i32 %16, i32 %17, i32 %18, i32 %19, double* nocapture writeonly %20, double** nocapture %21) {
%23 = add nsw i32 %0, 1
%24 = icmp eq i32 %23, 0
br i1 %24, label %320, label %25
25: ; preds = %22
%26 = icmp eq i32 %0, 0
br i1 %26, label %27, label %30
27: ; preds = %25
%28 = load i32, i32* @stderr
%29 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %28, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %320
30: ; preds = %25
%31 = icmp eq i32 %7, 0
%32 = icmp slt i32 %0, 2
%33 = and i1 %32, %31
br i1 %33, label %34, label %39
34: ; preds = %30
%35 = icmp eq i32 %8, 0
br i1 %35, label %39, label %36
36: ; preds = %34
%37 = load i32, i32* @stderr
%38 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %37, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %39
39: ; preds = %34, %36, %30
%40 = phi double [ %9, %30 ], [ 0.000000e+00, %36 ], [ 0.000000e+00, %34 ]
%41 = load double*, double** %2
%42 = tail call i32 @is_monotonic(i32 %0, double* %41)
%43 = icmp eq i32 %42, 0
br i1 %43, label %44, label %46
44: ; preds = %39
%45 = tail call i32 (...) @non_monotonic_error()
br label %46
46: ; preds = %44, %39
br i1 %31, label %181, label %47
47: ; preds = %46
%48 = icmp sgt i32 %3, 0
br i1 %48, label %49, label %97
49: ; preds = %47
%50 = sext i32 %0 to i64
%51 = zext i32 %3 to i64
%52 = and i64 %51, 1
%53 = icmp eq i32 %3, 1
br i1 %53, label %78, label %54
54: ; preds = %49
%55 = and i64 %51, 4294967294
br label %56
56: ; preds = %56, %54
%57 = phi i64 [ 0, %54 ], [ %75, %56 ]
%58 = phi i32 [ 0, %54 ], [ %74, %56 ]
%59 = phi i64 [ 0, %54 ], [ %76, %56 ]
%60 = getelementptr inbounds double*, double** %4, i64 %57
%61 = load double*, double** %60
%62 = getelementptr inbounds double, double* %61, i64 %50
%63 = load double, double* %62
%64 = load double, double* %61
%65 = fcmp une double %63, %64
store double %64, double* %62
%66 = or i64 %57, 1
%67 = getelementptr inbounds double*, double** %4, i64 %66
%68 = load double*, double** %67
%69 = getelementptr inbounds double, double* %68, i64 %50
%70 = load double, double* %69
%71 = load double, double* %68
%72 = fcmp une double %70, %71
%73 = select i1 %72, i1 true, i1 %65
%74 = select i1 %73, i32 1, i32 %58
store double %71, double* %69
%75 = add nuw nsw i64 %57, 2
%76 = add i64 %59, 2
%77 = icmp eq i64 %76, %55
br i1 %77, label %78, label %56
78: ; preds = %56, %49
%79 = phi i32 [ undef, %49 ], [ %74, %56 ]
%80 = phi i64 [ 0, %49 ], [ %75, %56 ]
%81 = phi i32 [ 0, %49 ], [ %74, %56 ]
%82 = icmp eq i64 %52, 0
br i1 %82, label %91, label %83
83: ; preds = %78
%84 = getelementptr inbounds double*, double** %4, i64 %80
%85 = load double*, double** %84
%86 = getelementptr inbounds double, double* %85, i64 %50
%87 = load double, double* %86
%88 = load double, double* %85
%89 = fcmp une double %87, %88
%90 = select i1 %89, i32 1, i32 %81
store double %88, double* %86
br label %91
91: ; preds = %78, %83
%92 = phi i32 [ %79, %78 ], [ %90, %83 ]
%93 = icmp eq i32 %92, 1
br i1 %93, label %94, label %97
94: ; preds = %91
%95 = load i32, i32* @stderr
%96 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %95, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %97
97: ; preds = %47, %94, %91
%98 = icmp slt i32 %23, %1
br i1 %98, label %119, label %99
99: ; preds = %97
%100 = load double*, double** %2
%101 = shl i32 %1, 3
%102 = add i32 %101, 8
%103 = tail call i64 @realloc(double* %100, i32 %102)
%104 = inttoptr i64 %103 to double*
store double* %104, double** %2
br i1 %48, label %105, label %119
105: ; preds = %99
%106 = zext i32 %3 to i64
br label %107
107: ; preds = %105, %107
%108 = phi i64 [ 0, %105 ], [ %117, %107 ]
%109 = getelementptr inbounds double*, double** %4, i64 %108
%110 = load double*, double** %109
%111 = tail call i64 @realloc(double* %110, i32 %102)
%112 = inttoptr i64 %111 to double*
store double* %112, double** %109
%113 = getelementptr inbounds double*, double** %5, i64 %108
%114 = load double*, double** %113
%115 = tail call i64 @realloc(double* %114, i32 %102)
%116 = inttoptr i64 %115 to double*
store double* %116, double** %113
%117 = add nuw nsw i64 %108, 1
%118 = icmp eq i64 %117, %106
br i1 %118, label %119, label %107
119: ; preds = %107, %99, %97
%120 = load double*, double** %2
%121 = sext i32 %0 to i64
%122 = getelementptr inbounds double, double* %120, i64 %121
%123 = load double, double* %122
%124 = getelementptr inbounds double, double* %120, i64 1
%125 = load double, double* %124
%126 = load double, double* %120
%127 = fsub double %125, %126
%128 = fadd double %123, %127
%129 = sext i32 %23 to i64
%130 = getelementptr inbounds double, double* %120, i64 %129
store double %128, double* %130
br i1 %48, label %131, label %198
131: ; preds = %119
%132 = zext i32 %3 to i64
%133 = add nsw i64 %132, -1
%134 = and i64 %132, 3
%135 = icmp ult i64 %133, 3
br i1 %135, label %167, label %136
136: ; preds = %131
%137 = and i64 %132, 4294967292
br label %138
138: ; preds = %138, %136
%139 = phi i64 [ 0, %136 ], [ %164, %138 ]
%140 = phi i64 [ 0, %136 ], [ %165, %138 ]
%141 = getelementptr inbounds double*, double** %4, i64 %139
%142 = load double*, double** %141
%143 = getelementptr inbounds double, double* %142, i64 1
%144 = load double, double* %143
%145 = getelementptr inbounds double, double* %142, i64 %129
store double %144, double* %145
%146 = or i64 %139, 1
%147 = getelementptr inbounds double*, double** %4, i64 %146
%148 = load double*, double** %147
%149 = getelementptr inbounds double, double* %148, i64 1
%150 = load double, double* %149
%151 = getelementptr inbounds double, double* %148, i64 %129
store double %150, double* %151
%152 = or i64 %139, 2
%153 = getelementptr inbounds double*, double** %4, i64 %152
%154 = load double*, double** %153
%155 = getelementptr inbounds double, double* %154, i64 1
%156 = load double, double* %155
%157 = getelementptr inbounds double, double* %154, i64 %129
store double %156, double* %157
%158 = or i64 %139, 3
%159 = getelementptr inbounds double*, double** %4, i64 %158
%160 = load double*, double** %159
%161 = getelementptr inbounds double, double* %160, i64 1
%162 = load double, double* %161
%163 = getelementptr inbounds double, double* %160, i64 %129
store double %162, double* %163
%164 = add nuw nsw i64 %139, 4
%165 = add i64 %140, 4
%166 = icmp eq i64 %165, %137
br i1 %166, label %167, label %138
167: ; preds = %138, %131
%168 = phi i64 [ 0, %131 ], [ %164, %138 ]
%169 = icmp eq i64 %134, 0
br i1 %169, label %181, label %170
170: ; preds = %167, %170
%171 = phi i64 [ %178, %170 ], [ %168, %167 ]
%172 = phi i64 [ %179, %170 ], [ 0, %167 ]
%173 = getelementptr inbounds double*, double** %4, i64 %171
%174 = load double*, double** %173
%175 = getelementptr inbounds double, double* %174, i64 1
%176 = load double, double* %175
%177 = getelementptr inbounds double, double* %174, i64 %129
store double %176, double* %177
%178 = add nuw nsw i64 %171, 1
%179 = add i64 %172, 1
%180 = icmp eq i64 %179, %134
br i1 %180, label %181, label %170
181: ; preds = %167, %170, %46
%182 = icmp sgt i32 %3, 0
br i1 %182, label %183, label %198
183: ; preds = %181
%184 = xor i1 %31, true
%185 = zext i1 %184 to i32
%186 = add nsw i32 %185, %0
%187 = zext i32 %3 to i64
br label %188
188: ; preds = %183, %188
%189 = phi i64 [ 0, %183 ], [ %196, %188 ]
%190 = load double*, double** %2
%191 = getelementptr inbounds double*, double** %4, i64 %189
%192 = load double*, double** %191
%193 = getelementptr inbounds double*, double** %5, i64 %189
%194 = load double*, double** %193
%195 = tail call i32 @fit(i32 %186, double* %190, double* %192, double* %194, double %40, double %6, i32 %7)
%196 = add nuw nsw i64 %189, 1
%197 = icmp eq i64 %196, %187
br i1 %197, label %198, label %188
198: ; preds = %188, %119, %181
%199 = phi i1 [ false, %181 ], [ false, %119 ], [ %182, %188 ]
%200 = icmp eq i32 %15, 0
br i1 %200, label %201, label %204
201: ; preds = %198
%202 = load double*, double** %2
%203 = load double, double* %202
br label %204
204: ; preds = %201, %198
%205 = phi double [ %11, %198 ], [ %203, %201 ]
%206 = icmp eq i32 %16, 0
br i1 %206, label %207, label %212
207: ; preds = %204
%208 = load double*, double** %2
%209 = sext i32 %0 to i64
%210 = getelementptr inbounds double, double* %208, i64 %209
%211 = load double, double* %210
br label %212
212: ; preds = %207, %204
%213 = phi double [ %12, %204 ], [ %211, %207 ]
%214 = icmp eq i32 %17, 0
br i1 %214, label %215, label %221
215: ; preds = %212
%216 = icmp sgt i32 %14, 0
br i1 %216, label %217, label %241
217: ; preds = %215
%218 = fsub double %213, %205
%219 = sitofp i32 %14 to double
%220 = fdiv double %218, %219
br label %241
221: ; preds = %212
%222 = fsub double %213, %205
%223 = fmul double %222, %13
%224 = fcmp olt double %223, 0.000000e+00
br i1 %224, label %225, label %229
225: ; preds = %221
%226 = load i32, i32* @stderr
%227 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %226, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%228 = fneg double %13
br label %229
229: ; preds = %225, %221
%230 = phi double [ %228, %225 ], [ %13, %221 ]
%231 = icmp eq i32 %18, 0
br i1 %231, label %235, label %232
232: ; preds = %229
%233 = load i32, i32* @stderr
%234 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %233, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %235
235: ; preds = %232, %229
%236 = fdiv double %222, %230
%237 = tail call i64 @fabs(double %236)
%238 = sitofp i64 %237 to double
%239 = fadd double %238, 0x3E7AD7F29ABCAF48
%240 = fptosi double %239 to i32
br label %241
241: ; preds = %215, %217, %235
%242 = phi i32 [ %240, %235 ], [ %14, %217 ], [ %14, %215 ]
%243 = phi double [ %230, %235 ], [ %220, %217 ], [ 0.000000e+00, %215 ]
%244 = load double*, double** %2
%245 = load double, double* %244
%246 = fcmp oeq double %213, %245
br i1 %246, label %253, label %247
247: ; preds = %241
%248 = sext i32 %0 to i64
%249 = getelementptr inbounds double, double* %244, i64 %248
%250 = load double, double* %249
%251 = fcmp oeq double %213, %250
br i1 %251, label %252, label %253
252: ; preds = %247
br label %253
253: ; preds = %241, %247, %252
%254 = phi i1 [ false, %247 ], [ false, %252 ], [ true, %241 ]
%255 = phi i1 [ false, %247 ], [ true, %252 ], [ false, %241 ]
%256 = icmp slt i32 %242, 0
br i1 %256, label %320, label %257
257: ; preds = %253
%258 = sext i32 %0 to i64
%259 = zext i32 %242 to i64
%260 = add nuw i32 %242, 1
%261 = zext i32 %260 to i64
%262 = zext i32 %3 to i64
br label %263
263: ; preds = %257, %309
%264 = phi i64 [ 0, %257 ], [ %311, %309 ]
%265 = phi i32 [ 0, %257 ], [ %310, %309 ]
%266 = trunc i64 %264 to i32
%267 = sitofp i32 %266 to double
%268 = tail call double @llvm.fmuladd.f64(double %243, double %267, double %205)
%269 = icmp eq i64 %264, %259
br i1 %269, label %270, label %280
270: ; preds = %263
br i1 %254, label %271, label %273
271: ; preds = %270
%272 = load double*, double** %2
br label %277
273: ; preds = %270
br i1 %255, label %274, label %280
274: ; preds = %273
%275 = load double*, double** %2
%276 = getelementptr inbounds double, double* %275, i64 %258
br label %277
277: ; preds = %274, %271
%278 = phi double* [ %272, %271 ], [ %276, %274 ]
%279 = load double, double* %278
br label %280
280: ; preds = %277, %273, %263
%281 = phi double [ %268, %273 ], [ %268, %263 ], [ %279, %277 ]
br i1 %31, label %282, label %291
282: ; preds = %280
%283 = load double*, double** %2
%284 = load double, double* %283
%285 = fsub double %281, %284
%286 = getelementptr inbounds double, double* %283, i64 %258
%287 = load double, double* %286
%288 = fsub double %281, %287
%289 = fmul double %285, %288
%290 = fcmp ugt double %289, 0.000000e+00
br i1 %290, label %307, label %291
291: ; preds = %282, %280
br i1 %199, label %292, label %309
292: ; preds = %291
%293 = getelementptr inbounds double, double* %20, i64 %264
br label %294
294: ; preds = %292, %294
%295 = phi i64 [ 0, %292 ], [ %305, %294 ]
%296 = load double*, double** %2
%297 = getelementptr inbounds double*, double** %4, i64 %295
%298 = load double*, double** %297
%299 = getelementptr inbounds double*, double** %5, i64 %295
%300 = load double*, double** %299
%301 = tail call double @interpolate(i32 %0, double* %296, double* %298, double* %300, double %281, double %6, i32 %7)
%302 = getelementptr inbounds double*, double** %21, i64 %295
%303 = load double*, double** %302
%304 = getelementptr inbounds double, double* %303, i64 %264
store double %301, double* %304
store double %281, double* %293
%305 = add nuw nsw i64 %295, 1
%306 = icmp eq i64 %305, %262
br i1 %306, label %309, label %294
307: ; preds = %282
%308 = add nsw i32 %265, 1
br label %309
309: ; preds = %294, %291, %307
%310 = phi i32 [ %308, %307 ], [ %265, %291 ], [ %265, %294 ]
%311 = add nuw nsw i64 %264, 1
%312 = icmp eq i64 %311, %261
br i1 %312, label %313, label %263
313: ; preds = %309
switch i32 %310, label %317 [
i32 0, label %320
i32 1, label %314
]
314: ; preds = %313
%315 = load i32, i32* @stderr
%316 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %315, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
br label %320
317: ; preds = %313
%318 = load i32, i32* @stderr
%319 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %318, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %310)
br label %320
320: ; preds = %253, %313, %314, %317, %22, %27
ret void
}