#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*/ free(double *);
scalar_t__ malloc(int);
double *bspline(double *output, double *x, int nx, double *knots, int nknots,
                int m, int d, int lower, int upper) {
  int nbasis;
  int index, i, j, k;
  double *result, *b, *b0, *b1;
  double *f0, *f1;
  double denom;
  nbasis = upper - lower;
  result = output;
  f0 = (double *)malloc(sizeof(double) * nx);
  f1 = (double *)malloc(sizeof(double) * nx);
  if (m == 1) {
    for (i = 0; i < nbasis; i++) {
      index = i + lower;
      if (index < nknots - 1) {
        if ((knots[index] != knots[index + 1]) && (d <= 0)) {
          for (k = 0; k < nx; k++) {
            *result =
                (double)(x[k] >= knots[index]) * (x[k] < knots[index + 1]);
            result++;
          }
        } else {
          for (k = 0; k < nx; k++) {
            *result = 0.;
            result++;
          }
        }
      } else {
        for (k = 0; k < nx; k++) {
          *result = 0.;
          result++;
        }
      }
    }
  } else {
    b = (double *)malloc(sizeof(double) * (nbasis + 1) * nx);
    bspline(b, x, nx, knots, nknots, m - 1, d - 1, lower, upper + 1);
    for (i = 0; i < nbasis; i++) {
      b0 = b + nx * i;
      b1 = b + nx * (i + 1);
      index = i + lower;
      if ((knots[index] != knots[index + m - 1]) && (index + m - 1 < nknots)) {
        denom = knots[index + m - 1] - knots[index];
        if (d <= 0) {
          for (k = 0; k < nx; k++) {
            f0[k] = (x[k] - knots[index]) / denom;
          }
        } else {
          for (k = 0; k < nx; k++) {
            f0[k] = (m - 1) / (knots[index + m - 1] - knots[index]);
          }
        }
      } else {
        for (k = 0; k < nx; k++) {
          f0[k] = 0.;
        }
      }
      index = i + lower + 1;
      if ((knots[index] != knots[index + m - 1]) && (index + m - 1 < nknots)) {
        denom = knots[index + m - 1] - knots[index];
        if (d <= 0) {
          for (k = 0; k < nx; k++) {
            f1[k] = (knots[index + m - 1] - x[k]) / denom;
          }
        } else {
          for (k = 0; k < nx; k++) {
            f1[k] = -(m - 1) / (knots[index + m - 1] - knots[index]);
          }
        }
      } else {
        for (k = 0; k < nx; k++) {
          f1[k] = 0.;
        }
      }
      for (k = 0; k < nx; k++) {
        *result = f0[k] * (*b0) + f1[k] * (*b1);
        b0++;
        b1++;
        result++;
      }
    }
    free(b);
  }
  free(f0);
  free(f1);
  result = result - nx * nbasis;
  return (result);
}


x86 assembly (clang, -O0):
<bspline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    0x20(%rbp),%eax
sub    0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpl   $0x1,-0x28(%rbp)
jne    132d <bspline+0x1fd>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1328 <bspline+0x1f8>
mov    -0x34(%rbp),%eax
add    0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12d8 <bspline+0x1a8>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    11f9 <bspline+0xc9>
jp     11f9 <bspline+0xc9>
jmp    1296 <bspline+0x166>
cmpl   $0x0,0x10(%rbp)
jg     1296 <bspline+0x166>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1291 <bspline+0x161>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm2,%xmm1
seta   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    120a <bspline+0xda>
jmp    12d3 <bspline+0x1a3>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ce <bspline+0x19e>
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    129d <bspline+0x16d>
jmp    12d3 <bspline+0x1a3>
jmp    1315 <bspline+0x1e5>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1310 <bspline+0x1e0>
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12df <bspline+0x1af>
jmp    1315 <bspline+0x1e5>
jmp    131a <bspline+0x1ea>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a3 <bspline+0x73>
jmp    175d <bspline+0x62d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
sub    $0x1,%r9d
mov    0x10(%rbp),%r11d
sub    $0x1,%r11d
mov    0x18(%rbp),%r10d
mov    0x20(%rbp),%eax
add    $0x1,%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <bspline@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1754 <bspline+0x624>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x34(%rbp),%eax
add    0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1411 <bspline+0x2e1>
jp     1411 <bspline+0x2e1>
jmp    150e <bspline+0x3de>
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
sub    $0x1,%eax
cmp    -0x24(%rbp),%eax
jge    150e <bspline+0x3de>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,0x10(%rbp)
jg     14a6 <bspline+0x376>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14a1 <bspline+0x371>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    145b <bspline+0x32b>
jmp    1509 <bspline+0x3d9>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1504 <bspline+0x3d4>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ad <bspline+0x37d>
jmp    1509 <bspline+0x3d9>
jmp    1544 <bspline+0x414>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    153f <bspline+0x40f>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1515 <bspline+0x3e5>
jmp    1544 <bspline+0x414>
mov    -0x34(%rbp),%eax
add    0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1583 <bspline+0x453>
jp     1583 <bspline+0x453>
jmp    168c <bspline+0x55c>
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
sub    $0x1,%eax
cmp    -0x24(%rbp),%eax
jge    168c <bspline+0x55c>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,0x10(%rbp)
jg     1620 <bspline+0x4f0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    161b <bspline+0x4eb>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15cd <bspline+0x49d>
jmp    1687 <bspline+0x557>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1682 <bspline+0x552>
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1627 <bspline+0x4f7>
jmp    1687 <bspline+0x557>
jmp    16c2 <bspline+0x592>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16bd <bspline+0x58d>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1693 <bspline+0x563>
jmp    16c2 <bspline+0x592>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1741 <bspline+0x611>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16c9 <bspline+0x599>
jmp    1746 <bspline+0x616>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1392 <bspline+0x262>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bspline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9d,%ebx
mov    %r8d,0x10(%rsp)
mov    %rcx,0x30(%rsp)
mov    %edx,%r13d
mov    %rsi,0x38(%rsp)
mov    %rdi,%r14
mov    0x180(%rsp),%r15d
mov    0x178(%rsp),%eax
mov    %r15d,%ebp
sub    %eax,%ebp
lea    0x0(,%r13,8),%r12d
mov    %r12d,%edi
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r12d,%edi
call   1060 <malloc@plt>
mov    %rbx,%r12
cmp    $0x1,%ebx
mov    0x30(%rsp),%rbx
mov    %r13,0x18(%rsp)
mov    %rax,0x58(%rsp)
mov    %rbp,0xf0(%rsp)
jne    13af <bspline+0x26f>
mov    0x178(%rsp),%edx
mov    0x10(%rsp),%eax
test   %ebp,%ebp
jle    215e <bspline+0x101e>
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    0x18(%rsp),%rsi
mov    %esi,%r15d
lea    0x0(,%r15,8),%rax
mov    %rax,0x10(%rsp)
lea    -0x1(%rsi),%eax
add    $0x1,%rax
mov    %rax,0x20(%rsp)
movslq %edx,%r8
movslq %ecx,%r9
mov    %ebp,%r13d
add    $0xffffffffffffffff,%r15
mov    %r15,0x40(%rsp)
and    $0xfffffffffffffffe,%r15
neg    %r15
xor    %r12d,%r12d
movsd  0x1de6(%rip),%xmm3
mov    0x38(%rsp),%rdi
mov    0x170(%rsp),%ebx
mov    0x30(%rsp),%rbp
jmp    123d <bspline+0xfd>
nopl   (%rax)
add    $0x1,%r12
cmp    %r13,%r12
je     217d <bspline+0x103d>
lea    (%r12,%r8,1),%rax
cmp    %r9,%rax
jge    1360 <bspline+0x220>
test   %ebx,%ebx
jg     1360 <bspline+0x220>
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
jne    126a <bspline+0x12a>
jnp    1360 <bspline+0x220>
test   %esi,%esi
jle    1230 <bspline+0xf0>
movsd  (%rdi),%xmm2
cmplesd %xmm2,%xmm0
andpd  %xmm3,%xmm0
cmpltsd %xmm1,%xmm2
andpd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r14)
add    $0x8,%r14
cmp    $0x1,%esi
je     1230 <bspline+0xf0>
mov    $0x1,%ecx
cmp    $0x2,%esi
je     1318 <bspline+0x1d8>
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rdi,%rcx,8),%xmm1
cmplesd %xmm1,%xmm0
andpd  %xmm3,%xmm0
cmpltsd 0x8(%rbp,%rax,8),%xmm1
andpd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x8(%rdi,%rcx,8),%xmm1
cmplesd %xmm1,%xmm0
cmpltsd 0x8(%rbp,%rax,8),%xmm1
andpd  %xmm3,%xmm0
andpd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14)
add    $0x10,%r14
lea    (%r15,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    12b0 <bspline+0x170>
testb  $0x1,0x40(%rsp)
je     1230 <bspline+0xf0>
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rdi,%rcx,8),%xmm1
cmplesd %xmm1,%xmm0
andpd  %xmm3,%xmm0
cmpltsd 0x8(%rbp,%rax,8),%xmm1
andpd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
add    $0x8,%r14
jmp    1230 <bspline+0xf0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %esi,%esi
jle    1230 <bspline+0xf0>
mov    %r14,%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
mov    %r8,%rbx
mov    %r9,%rbp
call   1040 <memset@plt>
movsd  0x1c7b(%rip),%xmm3
mov    %rbp,%r9
mov    %rbx,%r8
mov    0x30(%rsp),%rbp
mov    0x170(%rsp),%ebx
mov    0x38(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rax
lea    (%r14,%rax,8),%r14
jmp    1230 <bspline+0xf0>
lea    0x8(,%rbp,8),%edi
imul   %r13d,%edi
call   1060 <malloc@plt>
mov    %rax,%rdi
lea    -0x1(%r12),%r9d
mov    0x170(%rsp),%eax
add    $0xffffffff,%eax
add    $0x1,%r15d
sub    $0x8,%rsp
mov    %rdi,0xa8(%rsp)
mov    0x40(%rsp),%rsi
mov    %r13d,%edx
mov    %rbx,%rcx
mov    0x18(%rsp),%r8d
mov    %r9d,0x28(%rsp)
push   %r15
mov    0x188(%rsp),%r10d
push   %r10
push   %rax
call   1050 <bspline@plt>
add    $0x20,%rsp
test   %ebp,%ebp
jle    2165 <bspline+0x1025>
cvtsi2sdl 0x20(%rsp),%xmm5
mov    $0x1,%eax
sub    %r12d,%eax
cvtsi2sd %eax,%xmm6
mov    0xa0(%rsp),%r11
mov    %r13d,%ebx
mov    0x28(%rsp),%r9
lea    (%r9,%rbx,8),%rdi
mov    0x38(%rsp),%r8
lea    0x8(%r8),%r10
lea    (%r8,%rbx,8),%rcx
lea    -0x1(%rbx),%rdx
mov    %rbp,%r15
lea    0x8(%r9),%rbp
lea    -0x3(%rbx),%rsi
mov    %rsi,0x88(%rsp)
shr    %rsi
add    $0x1,%rsi
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x78(%rsp)
mov    %rdx,0x48(%rsp)
or     $0x1,%rdx
mov    %rdx,0x70(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x80(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x68(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x60(%rsp)
mov    %rbp,0xa8(%rsp)
cmp    %rcx,%rbp
setb   %dl
mov    %rdi,0xb0(%rsp)
cmp    %rdi,%r10
setb   %al
and    %dl,%al
mov    %al,0xe(%rsp)
mov    0x58(%rsp),%rdx
lea    0x8(%rdx),%rax
mov    %rax,0xf8(%rsp)
cmp    %rcx,%rax
setb   %cl
lea    (%rdx,%rbx,8),%rax
mov    %rax,0xb8(%rsp)
cmp    %rax,%r10
setb   %al
and    %cl,%al
mov    %al,0xf(%rsp)
mov    0x178(%rsp),%eax
movslq %eax,%rcx
movslq %r12d,%rdx
movslq 0x10(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0xc8(%rsp)
lea    0x0(,%rbx,8),%rax
mov    %rax,0xd0(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0xe8(%rsp)
movslq %r13d,%rsi
mov    %r15d,%eax
mov    %rax,0x120(%rsp)
lea    (%rsi,%rbx,1),%rax
mov    %rax,0x100(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x108(%rsp)
lea    (%rcx,%rdx,1),%rax
mov    %rax,0xe0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x130(%rsp)
mov    %rdx,0x128(%rsp)
lea    -0x1(%rcx,%rdx,1),%rax
mov    %rax,0xd8(%rsp)
lea    0x10(%r11),%rax
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x118(%rsp)
mov    %rsi,0x110(%rsp)
lea    (%r11,%rsi,8),%rdi
add    $0x10,%rdi
xor    %r15d,%r15d
mov    %r13,%rsi
mov    %r9,%r13
mov    %r8,%r10
mov    0x30(%rsp),%r8
movsd  %xmm5,0x98(%rsp)
movsd  %xmm6,0x90(%rsp)
mov    %rbx,0x20(%rsp)
jmp    1616 <bspline+0x4d6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rbp
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rdi
mov    0x10(%rsp),%r15
mov    0x118(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%rdi
mov    %rbp,%r14
cmp    0x120(%rsp),%r15
mov    0x20(%rsp),%rbx
je     2168 <bspline+0x1028>
mov    %rdi,0x50(%rsp)
mov    %rax,0x40(%rsp)
mov    %r15,%rbp
mov    0x130(%rsp),%rax
lea    (%r15,%rax,1),%r12
lea    0x1(%r15),%rax
mov    %rax,0x10(%rsp)
movsd  (%r8,%r12,8),%xmm1
mov    0x128(%rsp),%rax
lea    (%r12,%rax,1),%r15
movsd  -0x8(%r8,%r15,8),%xmm0
ucomisd %xmm0,%xmm1
jne    165d <bspline+0x51d>
jnp    1750 <bspline+0x610>
cmp    0xc0(%rsp),%r15
jg     1750 <bspline+0x610>
lea    (%r8,%r12,8),%rcx
mov    0x108(%rsp),%rax
add    %rbp,%rax
lea    (%r8,%rax,8),%rdx
subsd  %xmm1,%xmm0
mov    0x170(%rsp),%eax
test   %eax,%eax
jle    17d7 <bspline+0x697>
test   %esi,%esi
jle    1aa0 <bspline+0x960>
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
cmp    $0x1,%esi
je     1aa0 <bspline+0x960>
mov    $0x1,%eax
cmpq   $0x2,0x48(%rsp)
jb     190f <bspline+0x7cf>
mov    %rsi,%r11
mov    0xd8(%rsp),%rsi
add    %rbp,%rsi
lea    (%r8,%rsi,8),%r9
mov    0xe0(%rsp),%rsi
mov    %rbp,%rdi
add    %rsi,%rbp
lea    (%r8,%rbp,8),%rbp
mov    0xa8(%rsp),%rbx
cmp    %rdx,%rbx
setb   %r13b
mov    0xb0(%rsp),%rsi
cmp    %rsi,%rcx
setb   %dl
cmp    %rbp,%rbx
setb   %cl
cmp    %rsi,%r9
setb   %sil
test   %dl,%r13b
jne    187a <bspline+0x73a>
and    %sil,%cl
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%rbx
mov    %r11,%rsi
mov    %rdi,%rbp
jne    190f <bspline+0x7cf>
cmpq   $0x2,0x88(%rsp)
jae    188f <bspline+0x74f>
xor    %eax,%eax
jmp    18c8 <bspline+0x788>
nopw   0x0(%rax,%rax,1)
test   %esi,%esi
jle    1aa0 <bspline+0x960>
mov    %r13,%rdi
xor    %esi,%esi
mov    0xd0(%rsp),%rdx
call   1040 <memset@plt>
mov    0x30(%rsp),%r8
movsd  0x8(%r8,%r12,8),%xmm2
movsd  (%r8,%r15,8),%xmm1
ucomisd %xmm1,%xmm2
jne    1788 <bspline+0x648>
jnp    1b98 <bspline+0xa58>
cmp    0xc0(%rsp),%r15
jge    1b98 <bspline+0xa58>
lea    (%r8,%r15,8),%rax
mov    0x170(%rsp),%ecx
test   %ecx,%ecx
jle    184c <bspline+0x70c>
lea    (%r8,%r12,8),%rcx
add    $0x8,%rcx
mov    0x18(%rsp),%rsi
mov    0x58(%rsp),%r12
mov    0x38(%rsp),%r10
movsd  0x98(%rsp),%xmm5
movsd  0x90(%rsp),%xmm6
jmp    1aef <bspline+0x9af>
test   %esi,%esi
jle    1aa0 <bspline+0x960>
movsd  (%r10),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%r13)
cmp    $0x1,%esi
je     1aa0 <bspline+0x960>
mov    $0x1,%eax
cmpq   $0x2,0x48(%rsp)
jb     1a28 <bspline+0x8e8>
cmp    %rdx,0xa8(%rsp)
setb   %dl
cmp    0xb0(%rsp),%rcx
setb   %cl
and    %dl,%cl
or     0xe(%rsp),%cl
jne    1a28 <bspline+0x8e8>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x2,0x88(%rsp)
jae    1996 <bspline+0x856>
xor    %eax,%eax
jmp    19e6 <bspline+0x8a6>
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
mov    0x18(%rsp),%rsi
mov    0x58(%rsp),%r12
mov    0x38(%rsp),%r10
movsd  0x98(%rsp),%xmm5
movsd  0x90(%rsp),%xmm6
jmp    1bf2 <bspline+0xab2>
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%rbx
mov    %r11,%rsi
mov    %rdi,%rbp
jmp    190f <bspline+0x7cf>
movsd  -0x8(%r8,%r15,8),%xmm1
subsd  (%r8,%r12,8),%xmm1
movapd %xmm5,%xmm0
divsd  %xmm1,%xmm0
unpcklpd %xmm0,%xmm0
mov    0x68(%rsp),%rcx
xor    %eax,%eax
nop
movupd %xmm0,0x8(%r13,%rax,8)
movupd %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    18b0 <bspline+0x770>
testb  $0x1,0x80(%rsp)
01
je     18fa <bspline+0x7ba>
shl    $0x3,%rax
movsd  -0x8(%r8,%r15,8),%xmm0
subsd  (%r8,%r12,8),%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
unpcklpd %xmm1,%xmm1
or     $0x8,%rax
movupd %xmm1,0x0(%r13,%rax,1)
mov    0x70(%rsp),%rax
mov    0x78(%rsp),%rcx
cmp    %rcx,0x48(%rsp)
je     1aa0 <bspline+0x960>
mov    %rax,%rcx
test   $0x1,%bl
jne    1937 <bspline+0x7f7>
movsd  -0x8(%r8,%r15,8),%xmm0
subsd  (%r8,%r12,8),%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x60(%rsp),%rax
je     1aa0 <bspline+0x960>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r8,%r15,8),%xmm0
subsd  (%r8,%r12,8),%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  -0x8(%r8,%r15,8),%xmm0
subsd  (%r8,%r12,8),%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1950 <bspline+0x810>
jmp    1aa0 <bspline+0x960>
movsd  (%r8,%r12,8),%xmm2
unpcklpd %xmm2,%xmm2
mov    0x68(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd 0x8(%r10,%rax,8),%xmm3
subpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,0x8(%r13,%rax,8)
movupd 0x18(%r10,%rax,8),%xmm3
subpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,0x18(%r13,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    19b0 <bspline+0x870>
testb  $0x1,0x80(%rsp)
01
je     1a17 <bspline+0x8d7>
shl    $0x3,%rax
movsd  (%r8,%r12,8),%xmm2
unpcklpd %xmm2,%xmm2
or     $0x8,%rax
movupd (%r10,%rax,1),%xmm3
subpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,0x0(%r13,%rax,1)
mov    0x70(%rsp),%rax
mov    0x78(%rsp),%rcx
cmp    %rcx,0x48(%rsp)
je     1aa0 <bspline+0x960>
mov    %rax,%rcx
test   $0x1,%bl
jne    1a4b <bspline+0x90b>
movsd  (%r10,%rax,8),%xmm1
subsd  (%r8,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x60(%rsp),%rax
je     1aa0 <bspline+0x960>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r10,%rcx,8),%xmm1
subsd  (%r8,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  0x8(%r10,%rcx,8),%xmm1
subsd  (%r8,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1a60 <bspline+0x920>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r8,%r12,8),%xmm2
movsd  (%r8,%r15,8),%xmm1
ucomisd %xmm1,%xmm2
jne    1ab9 <bspline+0x979>
jnp    1b90 <bspline+0xa50>
cmp    0xc0(%rsp),%r15
jge    1b90 <bspline+0xa50>
lea    (%r8,%r15,8),%rax
mov    0x170(%rsp),%ecx
test   %ecx,%ecx
jle    1bdd <bspline+0xa9d>
test   %esi,%esi
jle    15e0 <bspline+0x4a0>
lea    (%r8,%r12,8),%rcx
add    $0x8,%rcx
mov    0x58(%rsp),%r12
subsd  %xmm2,%xmm1
movapd %xmm6,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r12)
mov    %rsi,%r11
cmp    $0x1,%esi
je     1e80 <bspline+0xd40>
mov    $0x1,%edx
cmpq   $0x2,0x48(%rsp)
jae    1c8b <bspline+0xb4b>
mov    %rdx,%rsi
test   $0x1,%bl
jne    1b40 <bspline+0xa00>
movsd  (%rax),%xmm0
subsd  (%rcx),%xmm0
movapd %xmm6,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x60(%rsp),%rdx
je     1e80 <bspline+0xd40>
xchg   %ax,%ax
movsd  (%rax),%xmm0
subsd  (%rcx),%xmm0
movapd %xmm6,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
movsd  (%rax),%xmm0
subsd  (%rcx),%xmm0
movapd %xmm6,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    1b50 <bspline+0xa10>
jmp    1e80 <bspline+0xd40>
nopl   0x0(%rax,%rax,1)
test   %esi,%esi
jle    1c67 <bspline+0xb27>
mov    0x58(%rsp),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    0xd0(%rsp),%rdx
call   1040 <memset@plt>
mov    0x30(%rsp),%r8
mov    0x18(%rsp),%rsi
mov    0x38(%rsp),%r10
mov    0xa0(%rsp),%rax
movsd  0x98(%rsp),%xmm5
movsd  0x90(%rsp),%xmm6
jmp    1e93 <bspline+0xd53>
test   %esi,%esi
mov    0x58(%rsp),%r12
jle    15e0 <bspline+0x4a0>
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
subsd  (%r10),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12)
mov    %rsi,%r11
cmp    $0x1,%esi
je     1e80 <bspline+0xd40>
mov    $0x1,%ecx
cmpq   $0x2,0x48(%rsp)
jb     1e0d <bspline+0xccd>
lea    (%r8,%r15,8),%rdx
cmp    %r12,%rdx
seta   %dl
cmp    0xb8(%rsp),%rax
setb   %bl
and    %dl,%bl
or     0xf(%rsp),%bl
mov    0x20(%rsp),%rbx
mov    0x28(%rsp),%r13
jne    1e0d <bspline+0xccd>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x2,0x88(%rsp)
jae    1d7e <bspline+0xc3e>
xor    %ecx,%ecx
jmp    1dce <bspline+0xc8e>
mov    %r14,%rbp
mov    0x18(%rsp),%rsi
mov    0x38(%rsp),%r10
movsd  0x98(%rsp),%xmm5
movsd  0x90(%rsp),%xmm6
jmp    15e3 <bspline+0x4a3>
mov    %rbp,%rdi
lea    (%r8,%r15,8),%rsi
cmp    %r12,%rcx
seta   %r9b
mov    0xb8(%rsp),%rbp
cmp    %rbp,%rcx
setb   %r8b
cmp    %r12,%rsi
seta   %bl
cmp    %rbp,%rax
setb   %sil
test   %r8b,%r9b
jne    1ce4 <bspline+0xba4>
and    %sil,%bl
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rbx
mov    %rdi,%rbp
jne    1b1e <bspline+0x9de>
cmpq   $0x2,0x88(%rsp)
jae    1cfb <bspline+0xbbb>
xor    %edx,%edx
jmp    1d38 <bspline+0xbf8>
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rbx
mov    %rdi,%rbp
jmp    1b1e <bspline+0x9de>
movsd  (%rax),%xmm1
subsd  (%rcx),%xmm1
movapd %xmm6,%xmm0
divsd  %xmm1,%xmm0
unpcklpd %xmm0,%xmm0
mov    0x68(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd %xmm0,0x8(%r12,%rdx,8)
movupd %xmm0,0x18(%r12,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1d20 <bspline+0xbe0>
testb  $0x1,0x80(%rsp)
01
je     1d64 <bspline+0xc24>
shl    $0x3,%rdx
movsd  (%rax),%xmm0
subsd  (%rcx),%xmm0
movapd %xmm6,%xmm1
divsd  %xmm0,%xmm1
unpcklpd %xmm1,%xmm1
or     $0x8,%rdx
movupd %xmm1,(%r12,%rdx,1)
mov    0x70(%rsp),%rdx
mov    0x78(%rsp),%rsi
cmp    %rsi,0x48(%rsp)
jne    1b1e <bspline+0x9de>
jmp    1e80 <bspline+0xd40>
movsd  (%rax),%xmm2
unpcklpd %xmm2,%xmm2
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movupd 0x8(%r10,%rcx,8),%xmm3
movapd %xmm2,%xmm4
subpd  %xmm3,%xmm4
divpd  %xmm1,%xmm4
movupd %xmm4,0x8(%r12,%rcx,8)
movupd 0x18(%r10,%rcx,8),%xmm3
movapd %xmm2,%xmm4
subpd  %xmm3,%xmm4
divpd  %xmm1,%xmm4
movupd %xmm4,0x18(%r12,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1d90 <bspline+0xc50>
testb  $0x1,0x80(%rsp)
01
je     1dfc <bspline+0xcbc>
shl    $0x3,%rcx
movsd  (%rax),%xmm2
unpcklpd %xmm2,%xmm2
or     $0x8,%rcx
movupd (%r10,%rcx,1),%xmm3
subpd  %xmm3,%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rcx,1)
mov    0x70(%rsp),%rcx
mov    0x78(%rsp),%rdx
cmp    %rdx,0x48(%rsp)
je     1e80 <bspline+0xd40>
mov    %rcx,%rdx
test   $0x1,%bl
jne    1e2d <bspline+0xced>
movsd  (%rax),%xmm1
subsd  (%r10,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
lea    0x1(%rcx),%rdx
not    %rcx
cmp    0x60(%rsp),%rcx
je     1e80 <bspline+0xd40>
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
subsd  (%r10,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
movsd  (%rax),%xmm1
subsd  0x8(%r10,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    1e40 <bspline+0xd00>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,%rsi
test   %esi,%esi
mov    0xa0(%rsp),%rax
jle    15e0 <bspline+0x4a0>
mov    0x110(%rsp),%rdx
imul   %rdx,%rbp
lea    (%rax,%rbp,8),%r11
mov    0x10(%rsp),%r15
mov    %r15,%rcx
imul   %rdx,%rcx
lea    (%rax,%rcx,8),%r9
cmp    $0x4,%esi
jae    1ee0 <bspline+0xda0>
xor    %edx,%edx
mov    %r14,%rbp
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rdi
testb  $0x1,0x20(%rsp)
je     2067 <bspline+0xf27>
jmp    2090 <bspline+0xf50>
nopw   0x0(%rax,%rax,1)
add    %rbp,%rdx
lea    (%rax,%rdx,8),%rsi
mov    0x100(%rsp),%rcx
lea    (%rcx,%rbp,1),%rdx
lea    (%rax,%rdx,8),%rdx
add    %rbx,%rbp
lea    (%rax,%rbp,8),%rbp
lea    (%r14,%rbx,8),%rdi
cmp    0xb0(%rsp),%r14
setb   %al
cmp    %rdi,%r13
setb   %r15b
cmp    %rdx,%r14
setb   %dl
cmp    %rdi,%rsi
setb   %r10b
cmp    %rbp,%r14
setb   %bl
cmp    %rdi,%r11
setb   %r8b
cmp    0xb8(%rsp),%r14
setb   %sil
cmp    %rdi,%r12
setb   %cl
test   %r15b,%al
jne    202f <bspline+0xeef>
and    %r10b,%dl
jne    202f <bspline+0xeef>
and    %r8b,%bl
mov    0x38(%rsp),%r10
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rdi
mov    0x10(%rsp),%r15
jne    206c <bspline+0xf2c>
and    %cl,%sil
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r8
jne    201c <bspline+0xedc>
mov    0xc8(%rsp),%rcx
lea    (%r9,%rcx,8),%r9
lea    (%r11,%rcx,8),%r11
lea    (%r14,%rcx,8),%rbp
xor    %edx,%edx
mov    0xe8(%rsp),%rcx
movupd 0x0(%r13,%rdx,1),%xmm0
movupd 0x10(%r13,%rdx,1),%xmm1
movupd -0x10(%rax,%rdx,1),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rax,%rdx,1),%xmm0
mulpd  %xmm1,%xmm0
movupd (%r12,%rdx,1),%xmm1
movupd 0x10(%r12,%rdx,1),%xmm3
movupd -0x10(%rdi,%rdx,1),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd (%rdi,%rdx,1),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm4,(%r14,%rdx,1)
movupd %xmm1,0x10(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rcx
jne    1fa0 <bspline+0xe60>
mov    0xc8(%rsp),%rcx
mov    %rcx,%rdx
cmp    0x20(%rsp),%rcx
mov    0x18(%rsp),%rsi
je     15f2 <bspline+0x4b2>
jmp    2060 <bspline+0xf20>
xor    %edx,%edx
mov    %r14,%rbp
mov    0x18(%rsp),%rsi
testb  $0x1,0x20(%rsp)
je     2067 <bspline+0xf27>
jmp    2090 <bspline+0xf50>
xor    %edx,%edx
mov    %r14,%rbp
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%r13
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rdi
mov    0x10(%rsp),%r15
nopw   0x0(%rax,%rax,1)
testb  $0x1,0x20(%rsp)
jne    2090 <bspline+0xf50>
mov    %rdx,%rbx
jmp    20c3 <bspline+0xf83>
xor    %edx,%edx
mov    %r14,%rbp
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r8
testb  $0x1,0x20(%rsp)
je     2067 <bspline+0xf27>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  (%r12,%rdx,8),%xmm1
mulsd  (%r9),%xmm1
mulsd  (%r11),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x8,%r11
add    $0x8,%r9
add    $0x8,%rbp
mov    %rdx,%rbx
or     $0x1,%rbx
not    %rdx
cmp    0x60(%rsp),%rdx
je     15f2 <bspline+0x4b2>
mov    %rsi,%r14
mov    0x20(%rsp),%rdx
sub    %rbx,%rdx
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rsi
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,1),%xmm0
movsd  -0x8(%rsi,%rbx,1),%xmm1
mulsd  (%r9,%rbx,1),%xmm1
mulsd  (%r11,%rbx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,1)
movsd  (%rcx,%rbx,1),%xmm0
movsd  (%rsi,%rbx,1),%xmm1
mulsd  0x8(%r9,%rbx,1),%xmm1
mulsd  0x8(%r11,%rbx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,1)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    2100 <bspline+0xfc0>
add    %rbx,%rbp
mov    0x28(%rsp),%r13
mov    %r14,%rsi
jmp    15f2 <bspline+0x4b2>
mov    0x18(%rsp),%rsi
jmp    217d <bspline+0x103d>
mov    %r14,%rbp
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rsi
mov    %rbp,%r14
mov    0x28(%rsp),%rdi
mov    %rsi,%rbx
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0xf0(%rsp),%rax
imul   %ebx,%eax
cltq
shl    $0x3,%rax
sub    %rax,%r14
mov    %r14,%rax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double* @bspline(double* writeonly %0, double* nocapture %1, i32 %2, double* nocapture %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8) {
%10 = sub i32 %8, %7
%11 = shl i32 %2, 3
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = inttoptr i64 %12 to i8*
%15 = inttoptr i64 %12 to i8*
%16 = tail call i64 @malloc(i32 %11)
%17 = inttoptr i64 %16 to double*
%18 = inttoptr i64 %16 to i8*
%19 = inttoptr i64 %16 to i8*
%20 = icmp eq i32 %5, 1
br i1 %20, label %21, label %114
21: ; preds = %9
%22 = icmp sgt i32 %10, 0
br i1 %22, label %23, label %758
23: ; preds = %21
%24 = add nsw i32 %4, -1
%25 = icmp sgt i32 %2, 0
%26 = icmp slt i32 %6, 1
%27 = zext i32 %2 to i64
%28 = shl nuw nsw i64 %27, 3
%29 = add i32 %2, -1
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %30, 1
%32 = sext i32 %7 to i64
%33 = sext i32 %24 to i64
%34 = zext i32 %10 to i64
%35 = add nsw i64 %27, -1
%36 = and i64 %35, 1
%37 = icmp eq i32 %2, 2
%38 = and i64 %35, -2
%39 = icmp eq i64 %36, 0
br label %40
40: ; preds = %23, %110
%41 = phi i64 [ 0, %23 ], [ %112, %110 ]
%42 = phi double* [ %0, %23 ], [ %111, %110 ]
%43 = bitcast double* %42 to i8*
%44 = add nsw i64 %41, %32
%45 = icmp slt i64 %44, %33
br i1 %45, label %47, label %46
46: ; preds = %40
br i1 %25, label %93, label %110
47: ; preds = %40
%48 = getelementptr inbounds double, double* %3, i64 %44
%49 = load double, double* %48
%50 = add nsw i64 %44, 1
%51 = getelementptr inbounds double, double* %3, i64 %50
%52 = load double, double* %51
%53 = fcmp une double %49, %52
%54 = and i1 %26, %53
br i1 %54, label %56, label %55
55: ; preds = %47
br i1 %25, label %93, label %110
56: ; preds = %47
br i1 %25, label %57, label %110
57: ; preds = %56
%58 = load double, double* %1
%59 = fcmp oge double %58, %49
%60 = uitofp i1 %59 to double
%61 = fcmp olt double %58, %52
%62 = uitofp i1 %61 to double
%63 = fmul double %60, %62
store double %63, double* %42
%64 = getelementptr inbounds double, double* %42, i64 1
switch i32 %2, label %65 [
i32 1, label %110
i32 2, label %95
]
65: ; preds = %57, %65
%66 = phi i64 [ %90, %65 ], [ 1, %57 ]
%67 = phi double* [ %89, %65 ], [ %64, %57 ]
%68 = phi i64 [ %91, %65 ], [ 0, %57 ]
%69 = load double, double* %48
%70 = load double, double* %51
%71 = getelementptr inbounds double, double* %1, i64 %66
%72 = load double, double* %71
%73 = fcmp oge double %72, %69
%74 = uitofp i1 %73 to double
%75 = fcmp olt double %72, %70
%76 = uitofp i1 %75 to double
%77 = fmul double %74, %76
store double %77, double* %67
%78 = getelementptr inbounds double, double* %67, i64 1
%79 = add nuw nsw i64 %66, 1
%80 = load double, double* %48
%81 = load double, double* %51
%82 = getelementptr inbounds double, double* %1, i64 %79
%83 = load double, double* %82
%84 = fcmp oge double %83, %80
%85 = uitofp i1 %84 to double
%86 = fcmp olt double %83, %81
%87 = uitofp i1 %86 to double
%88 = fmul double %85, %87
store double %88, double* %78
%89 = getelementptr inbounds double, double* %67, i64 2
%90 = add nuw nsw i64 %66, 2
%91 = add i64 %68, 2
%92 = icmp eq i64 %91, %38
br i1 %92, label %95, label %65
93: ; preds = %55, %46
%94 = getelementptr double, double* %42, i64 %31
br label %110
95: ; preds = %65, %57
%96 = phi double* [ undef, %57 ], [ %89, %65 ]
%97 = phi i64 [ 1, %57 ], [ %90, %65 ]
%98 = phi double* [ %64, %57 ], [ %89, %65 ]
br i1 %39, label %110, label %99
99: ; preds = %95
%100 = load double, double* %48
%101 = load double, double* %51
%102 = getelementptr inbounds double, double* %1, i64 %97
%103 = load double, double* %102
%104 = fcmp oge double %103, %100
%105 = uitofp i1 %104 to double
%106 = fcmp olt double %103, %101
%107 = uitofp i1 %106 to double
%108 = fmul double %105, %107
store double %108, double* %98
%109 = getelementptr inbounds double, double* %98, i64 1
br label %110
110: ; preds = %99, %95, %57, %93, %46, %55, %56
%111 = phi double* [ %42, %56 ], [ %42, %55 ], [ %42, %46 ], [ %94, %93 ], [ %64, %57 ], [ %96, %95 ], [ %109, %99 ]
%112 = add nuw nsw i64 %41, 1
%113 = icmp eq i64 %112, %34
br i1 %113, label %758, label %40
114: ; preds = %9
%115 = shl i32 %10, 3
%116 = add i32 %115, 8
%117 = mul i32 %116, %2
%118 = tail call i64 @malloc(i32 %117)
%119 = inttoptr i64 %118 to double*
%120 = add nsw i32 %5, -1
%121 = add nsw i32 %6, -1
%122 = add nsw i32 %8, 1
%123 = tail call double* @bspline(double* %119, double* %1, i32 %2, double* %3, i32 %4, i32 %120, i32 %121, i32 %7, i32 %122)
%124 = icmp sgt i32 %10, 0
br i1 %124, label %125, label %755
125: ; preds = %114
%126 = icmp slt i32 %6, 1
%127 = icmp sgt i32 %2, 0
%128 = sitofp i32 %120 to double
%129 = sub i32 1, %5
%130 = sitofp i32 %129 to double
%131 = zext i32 %2 to i64
%132 = shl nuw nsw i64 %131, 3
%133 = sext i32 %2 to i64
%134 = sext i32 %7 to i64
%135 = sext i32 %5 to i64
%136 = sext i32 %4 to i64
%137 = zext i32 %10 to i64
%138 = getelementptr double, double* %13, i64 %131
%139 = add nsw i64 %133, %131
%140 = getelementptr double, double* %17, i64 %131
%141 = getelementptr double, double* %17, i64 1
%142 = getelementptr double, double* %17, i64 %131
%143 = getelementptr double, double* %1, i64 1
%144 = getelementptr double, double* %1, i64 %131
%145 = add nsw i64 %131, -1
%146 = getelementptr double, double* %17, i64 %131
%147 = add nsw i64 %131, -1
%148 = getelementptr double, double* %13, i64 1
%149 = getelementptr double, double* %13, i64 %131
%150 = add nsw i64 %134, 1
%151 = getelementptr double, double* %1, i64 1
%152 = getelementptr double, double* %1, i64 %131
%153 = add nsw i64 %131, -1
%154 = getelementptr double, double* %13, i64 1
%155 = getelementptr double, double* %13, i64 %131
%156 = add nsw i64 %134, 1
%157 = add nsw i64 %134, %135
%158 = add nsw i64 %157, -1
%159 = add nsw i64 %131, -1
%160 = add nsw i64 %131, -3
%161 = lshr i64 %160, 1
%162 = add nuw i64 %161, 1
%163 = icmp eq i32 %2, 1
%164 = icmp ult i64 %159, 2
%165 = and i64 %159, -2
%166 = or i64 %159, 1
%167 = and i64 %162, 1
%168 = icmp ult i64 %160, 2
%169 = and i64 %162, -2
%170 = icmp eq i64 %167, 0
%171 = icmp eq i64 %159, %165
%172 = and i64 %131, 1
%173 = icmp eq i64 %172, 0
%174 = sub nsw i64 0, %131
%175 = icmp eq i32 %2, 1
%176 = icmp ult i64 %153, 2
%177 = icmp ult double* %148, %152
%178 = icmp ult double* %151, %149
%179 = and i1 %177, %178
%180 = and i64 %153, -2
%181 = or i64 %153, 1
%182 = and i64 %162, 1
%183 = icmp ult i64 %160, 2
%184 = and i64 %162, -2
%185 = icmp eq i64 %182, 0
%186 = icmp eq i64 %153, %180
%187 = and i64 %131, 1
%188 = icmp eq i64 %187, 0
%189 = sub nsw i64 0, %131
%190 = icmp eq i32 %2, 1
%191 = icmp ult i64 %147, 2
%192 = and i64 %147, -2
%193 = or i64 %147, 1
%194 = and i64 %162, 1
%195 = icmp ult i64 %160, 2
%196 = and i64 %162, -2
%197 = icmp eq i64 %194, 0
%198 = icmp eq i64 %147, %192
%199 = and i64 %131, 1
%200 = icmp eq i64 %199, 0
%201 = sub nsw i64 0, %131
%202 = icmp eq i32 %2, 1
%203 = icmp ult i64 %145, 2
%204 = icmp ult double* %141, %144
%205 = icmp ult double* %143, %142
%206 = and i1 %204, %205
%207 = and i64 %145, -2
%208 = or i64 %145, 1
%209 = and i64 %162, 1
%210 = icmp ult i64 %160, 2
%211 = and i64 %162, -2
%212 = icmp eq i64 %209, 0
%213 = icmp eq i64 %145, %207
%214 = and i64 %131, 1
%215 = icmp eq i64 %214, 0
%216 = sub nsw i64 0, %131
%217 = icmp ult i32 %2, 4
%218 = and i64 %131, 4294967292
%219 = icmp eq i64 %218, %131
%220 = and i64 %131, 1
%221 = icmp eq i64 %220, 0
%222 = sub nsw i64 0, %131
br label %226
223: ; preds = %718, %725, %698, %529, %459, %454, %638
%224 = phi double* [ %228, %638 ], [ %228, %454 ], [ %228, %459 ], [ %228, %529 ], [ %661, %698 ], [ %719, %718 ], [ %752, %725 ]
%225 = icmp eq i64 %251, %137
br i1 %225, label %755, label %226
226: ; preds = %125, %223
%227 = phi i64 [ 0, %125 ], [ %251, %223 ]
%228 = phi double* [ %0, %125 ], [ %224, %223 ]
%229 = add i64 %227, %134
%230 = getelementptr double, double* %3, i64 %229
%231 = add i64 %156, %227
%232 = getelementptr double, double* %3, i64 %231
%233 = add i64 %158, %227
%234 = getelementptr double, double* %3, i64 %233
%235 = add i64 %157, %227
%236 = getelementptr double, double* %3, i64 %235
%237 = add i64 %227, %134
%238 = getelementptr double, double* %3, i64 %237
%239 = add i64 %150, %227
%240 = getelementptr double, double* %3, i64 %239
%241 = mul i64 %227, %133
%242 = add i64 %241, %133
%243 = getelementptr double, double* %119, i64 %242
%244 = add i64 %139, %241
%245 = getelementptr double, double* %119, i64 %244
%246 = getelementptr double, double* %119, i64 %241
%247 = add i64 %241, %131
%248 = getelementptr double, double* %119, i64 %247
%249 = mul nsw i64 %227, %133
%250 = getelementptr inbounds double, double* %119, i64 %249
%251 = add nuw nsw i64 %227, 1
%252 = mul nsw i64 %251, %133
%253 = getelementptr inbounds double, double* %119, i64 %252
%254 = add nsw i64 %227, %134
%255 = getelementptr inbounds double, double* %3, i64 %254
%256 = load double, double* %255
%257 = add nsw i64 %254, %135
%258 = add nsw i64 %257, -1
%259 = getelementptr inbounds double, double* %3, i64 %258
%260 = load double, double* %259
%261 = fcmp oeq double %256, %260
%262 = icmp sgt i64 %257, %136
%263 = select i1 %261, i1 true, i1 %262
br i1 %263, label %264, label %265
264: ; preds = %226
br i1 %127, label %445, label %436
265: ; preds = %226
%266 = fsub double %260, %256
br i1 %126, label %332, label %267
267: ; preds = %265
br i1 %127, label %268, label %436
268: ; preds = %267
%269 = fsub double %260, %256
%270 = fdiv double %128, %269
store double %270, double* %13
br i1 %163, label %436, label %271
271: ; preds = %268
br i1 %164, label %319, label %272
272: ; preds = %271
%273 = icmp ult double* %154, %232
%274 = icmp ult double* %230, %155
%275 = and i1 %273, %274
%276 = icmp ult double* %154, %236
%277 = icmp ult double* %234, %155
%278 = and i1 %276, %277
%279 = or i1 %275, %278
br i1 %279, label %319, label %280
280: ; preds = %272
br i1 %168, label %306, label %281
281: ; preds = %280
%282 = load double, double* %259
%283 = load double, double* %255
%284 = fsub double %282, %283
%285 = fdiv double %128, %284
%286 = insertelement <2 x double> poison, double %285, i64 0
%287 = shufflevector <2 x double> %286, <2 x double> poison, <2 x i32> zeroinitializer
%288 = load double, double* %259
%289 = load double, double* %255
%290 = fsub double %288, %289
%291 = fdiv double %128, %290
%292 = insertelement <2 x double> poison, double %291, i64 0
%293 = shufflevector <2 x double> %292, <2 x double> poison, <2 x i32> zeroinitializer
br label %294
294: ; preds = %294, %281
%295 = phi i64 [ 0, %281 ], [ %303, %294 ]
%296 = phi i64 [ 0, %281 ], [ %304, %294 ]
%297 = or i64 %295, 1
%298 = getelementptr inbounds double, double* %13, i64 %297
%299 = bitcast double* %298 to <2 x double>*
store <2 x double> %287, <2 x double>* %299
%300 = or i64 %295, 3
%301 = getelementptr inbounds double, double* %13, i64 %300
%302 = bitcast double* %301 to <2 x double>*
store <2 x double> %293, <2 x double>* %302
%303 = add nuw i64 %295, 4
%304 = add nuw i64 %296, 2
%305 = icmp eq i64 %304, %169
br i1 %305, label %306, label %294
306: ; preds = %294, %280
%307 = phi i64 [ 0, %280 ], [ %303, %294 ]
br i1 %170, label %318, label %308
308: ; preds = %306
%309 = or i64 %307, 1
%310 = load double, double* %259
%311 = load double, double* %255
%312 = fsub double %310, %311
%313 = fdiv double %128, %312
%314 = insertelement <2 x double> poison, double %313, i64 0
%315 = shufflevector <2 x double> %314, <2 x double> poison, <2 x i32> zeroinitializer
%316 = getelementptr inbounds double, double* %13, i64 %309
%317 = bitcast double* %316 to <2 x double>*
store <2 x double> %315, <2 x double>* %317
br label %318
318: ; preds = %306, %308
br i1 %171, label %436, label %319
319: ; preds = %272, %271, %318
%320 = phi i64 [ 1, %272 ], [ 1, %271 ], [ %166, %318 ]
%321 = xor i64 %320, -1
br i1 %173, label %322, label %329
322: ; preds = %319
%323 = load double, double* %259
%324 = load double, double* %255
%325 = fsub double %323, %324
%326 = fdiv double %128, %325
%327 = getelementptr inbounds double, double* %13, i64 %320
store double %326, double* %327
%328 = add nuw nsw i64 %320, 1
br label %329
329: ; preds = %322, %319
%330 = phi i64 [ %320, %319 ], [ %328, %322 ]
%331 = icmp eq i64 %321, %174
br i1 %331, label %436, label %421
332: ; preds = %265
br i1 %127, label %333, label %436
333: ; preds = %332
%334 = load double, double* %1
%335 = fsub double %334, %256
%336 = fdiv double %335, %266
store double %336, double* %13
br i1 %175, label %436, label %337
337: ; preds = %333
br i1 %176, label %390, label %338
338: ; preds = %337
%339 = icmp ult double* %148, %240
%340 = icmp ult double* %238, %149
%341 = and i1 %339, %340
%342 = or i1 %341, %179
br i1 %342, label %390, label %343
343: ; preds = %338
%344 = insertelement <2 x double> poison, double %266, i64 0
%345 = shufflevector <2 x double> %344, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %183, label %375, label %346
346: ; preds = %343
%347 = load double, double* %255
%348 = insertelement <2 x double> poison, double %347, i64 0
%349 = shufflevector <2 x double> %348, <2 x double> poison, <2 x i32> zeroinitializer
%350 = load double, double* %255
%351 = insertelement <2 x double> poison, double %350, i64 0
%352 = shufflevector <2 x double> %351, <2 x double> poison, <2 x i32> zeroinitializer
br label %353
353: ; preds = %353, %346
%354 = phi i64 [ 0, %346 ], [ %372, %353 ]
%355 = phi i64 [ 0, %346 ], [ %373, %353 ]
%356 = or i64 %354, 1
%357 = getelementptr inbounds double, double* %1, i64 %356
%358 = bitcast double* %357 to <2 x double>*
%359 = load <2 x double>, <2 x double>* %358
%360 = fsub <2 x double> %359, %349
%361 = fdiv <2 x double> %360, %345
%362 = getelementptr inbounds double, double* %13, i64 %356
%363 = bitcast double* %362 to <2 x double>*
store <2 x double> %361, <2 x double>* %363
%364 = or i64 %354, 3
%365 = getelementptr inbounds double, double* %1, i64 %364
%366 = bitcast double* %365 to <2 x double>*
%367 = load <2 x double>, <2 x double>* %366
%368 = fsub <2 x double> %367, %352
%369 = fdiv <2 x double> %368, %345
%370 = getelementptr inbounds double, double* %13, i64 %364
%371 = bitcast double* %370 to <2 x double>*
store <2 x double> %369, <2 x double>* %371
%372 = add nuw i64 %354, 4
%373 = add nuw i64 %355, 2
%374 = icmp eq i64 %373, %184
br i1 %374, label %375, label %353
375: ; preds = %353, %343
%376 = phi i64 [ 0, %343 ], [ %372, %353 ]
br i1 %185, label %389, label %377
377: ; preds = %375
%378 = or i64 %376, 1
%379 = load double, double* %255
%380 = insertelement <2 x double> poison, double %379, i64 0
%381 = shufflevector <2 x double> %380, <2 x double> poison, <2 x i32> zeroinitializer
%382 = getelementptr inbounds double, double* %1, i64 %378
%383 = bitcast double* %382 to <2 x double>*
%384 = load <2 x double>, <2 x double>* %383
%385 = fsub <2 x double> %384, %381
%386 = fdiv <2 x double> %385, %345
%387 = getelementptr inbounds double, double* %13, i64 %378
%388 = bitcast double* %387 to <2 x double>*
store <2 x double> %386, <2 x double>* %388
br label %389
389: ; preds = %375, %377
br i1 %186, label %436, label %390
390: ; preds = %338, %337, %389
%391 = phi i64 [ 1, %338 ], [ 1, %337 ], [ %181, %389 ]
%392 = xor i64 %391, -1
br i1 %188, label %393, label %401
393: ; preds = %390
%394 = load double, double* %255
%395 = getelementptr inbounds double, double* %1, i64 %391
%396 = load double, double* %395
%397 = fsub double %396, %394
%398 = fdiv double %397, %266
%399 = getelementptr inbounds double, double* %13, i64 %391
store double %398, double* %399
%400 = add nuw nsw i64 %391, 1
br label %401
401: ; preds = %393, %390
%402 = phi i64 [ %391, %390 ], [ %400, %393 ]
%403 = icmp eq i64 %392, %189
br i1 %403, label %436, label %404
404: ; preds = %401, %404
%405 = phi i64 [ %419, %404 ], [ %402, %401 ]
%406 = load double, double* %255
%407 = getelementptr inbounds double, double* %1, i64 %405
%408 = load double, double* %407
%409 = fsub double %408, %406
%410 = fdiv double %409, %266
%411 = getelementptr inbounds double, double* %13, i64 %405
store double %410, double* %411
%412 = add nuw nsw i64 %405, 1
%413 = load double, double* %255
%414 = getelementptr inbounds double, double* %1, i64 %412
%415 = load double, double* %414
%416 = fsub double %415, %413
%417 = fdiv double %416, %266
%418 = getelementptr inbounds double, double* %13, i64 %412
store double %417, double* %418
%419 = add nuw nsw i64 %405, 2
%420 = icmp eq i64 %419, %131
br i1 %420, label %436, label %404
421: ; preds = %329, %421
%422 = phi i64 [ %434, %421 ], [ %330, %329 ]
%423 = load double, double* %259
%424 = load double, double* %255
%425 = fsub double %423, %424
%426 = fdiv double %128, %425
%427 = getelementptr inbounds double, double* %13, i64 %422
store double %426, double* %427
%428 = add nuw nsw i64 %422, 1
%429 = load double, double* %259
%430 = load double, double* %255
%431 = fsub double %429, %430
%432 = fdiv double %128, %431
%433 = getelementptr inbounds double, double* %13, i64 %428
store double %432, double* %433
%434 = add nuw nsw i64 %422, 2
%435 = icmp eq i64 %434, %131
br i1 %435, label %436, label %421
436: ; preds = %329, %421, %401, %404, %268, %318, %333, %389, %267, %332, %264
%437 = add nsw i64 %254, 1
%438 = getelementptr inbounds double, double* %3, i64 %437
%439 = load double, double* %438
%440 = getelementptr inbounds double, double* %3, i64 %257
%441 = load double, double* %440
%442 = fcmp une double %439, %441
%443 = icmp slt i64 %257, %136
%444 = select i1 %442, i1 %443, i1 false
br i1 %444, label %456, label %454
445: ; preds = %264
%446 = add nsw i64 %254, 1
%447 = getelementptr inbounds double, double* %3, i64 %446
%448 = load double, double* %447
%449 = getelementptr inbounds double, double* %3, i64 %257
%450 = load double, double* %449
%451 = fcmp une double %448, %450
%452 = icmp slt i64 %257, %136
%453 = select i1 %451, i1 %452, i1 false
br i1 %453, label %457, label %455
454: ; preds = %436
br i1 %127, label %455, label %223
455: ; preds = %454, %445
br label %639
456: ; preds = %436
br i1 %126, label %529, label %459
457: ; preds = %445
%458 = fsub double %450, %448
br i1 %126, label %531, label %460
459: ; preds = %456
br i1 %127, label %460, label %223
460: ; preds = %457, %459
%461 = phi double [ %441, %459 ], [ %450, %457 ]
%462 = phi double* [ %440, %459 ], [ %449, %457 ]
%463 = phi double [ %439, %459 ], [ %448, %457 ]
%464 = phi double* [ %438, %459 ], [ %447, %457 ]
%465 = fsub double %461, %463
%466 = fdiv double %130, %465
store double %466, double* %17
br i1 %190, label %638, label %467
467: ; preds = %460
br i1 %191, label %516, label %468
468: ; preds = %467
%469 = getelementptr inbounds double, double* %3, i64 %257
%470 = icmp ugt double* %464, %17
%471 = icmp ult double* %464, %146
%472 = and i1 %470, %471
%473 = icmp ugt double* %469, %17
%474 = icmp ult double* %462, %146
%475 = and i1 %473, %474
%476 = or i1 %472, %475
br i1 %476, label %516, label %477
477: ; preds = %468
br i1 %195, label %503, label %478
478: ; preds = %477
%479 = load double, double* %462
%480 = load double, double* %464
%481 = fsub double %479, %480
%482 = fdiv double %130, %481
%483 = insertelement <2 x double> poison, double %482, i64 0
%484 = shufflevector <2 x double> %483, <2 x double> poison, <2 x i32> zeroinitializer
%485 = load double, double* %462
%486 = load double, double* %464
%487 = fsub double %485, %486
%488 = fdiv double %130, %487
%489 = insertelement <2 x double> poison, double %488, i64 0
%490 = shufflevector <2 x double> %489, <2 x double> poison, <2 x i32> zeroinitializer
br label %491
491: ; preds = %491, %478
%492 = phi i64 [ 0, %478 ], [ %500, %491 ]
%493 = phi i64 [ 0, %478 ], [ %501, %491 ]
%494 = or i64 %492, 1
%495 = getelementptr inbounds double, double* %17, i64 %494
%496 = bitcast double* %495 to <2 x double>*
store <2 x double> %484, <2 x double>* %496
%497 = or i64 %492, 3
%498 = getelementptr inbounds double, double* %17, i64 %497
%499 = bitcast double* %498 to <2 x double>*
store <2 x double> %490, <2 x double>* %499
%500 = add nuw i64 %492, 4
%501 = add nuw i64 %493, 2
%502 = icmp eq i64 %501, %196
br i1 %502, label %503, label %491
503: ; preds = %491, %477
%504 = phi i64 [ 0, %477 ], [ %500, %491 ]
br i1 %197, label %515, label %505
505: ; preds = %503
%506 = or i64 %504, 1
%507 = load double, double* %462
%508 = load double, double* %464
%509 = fsub double %507, %508
%510 = fdiv double %130, %509
%511 = insertelement <2 x double> poison, double %510, i64 0
%512 = shufflevector <2 x double> %511, <2 x double> poison, <2 x i32> zeroinitializer
%513 = getelementptr inbounds double, double* %17, i64 %506
%514 = bitcast double* %513 to <2 x double>*
store <2 x double> %512, <2 x double>* %514
br label %515
515: ; preds = %503, %505
br i1 %198, label %638, label %516
516: ; preds = %468, %467, %515
%517 = phi i64 [ 1, %468 ], [ 1, %467 ], [ %193, %515 ]
%518 = xor i64 %517, -1
br i1 %200, label %519, label %526
519: ; preds = %516
%520 = load double, double* %462
%521 = load double, double* %464
%522 = fsub double %520, %521
%523 = fdiv double %130, %522
%524 = getelementptr inbounds double, double* %17, i64 %517
store double %523, double* %524
%525 = add nuw nsw i64 %517, 1
br label %526
526: ; preds = %519, %516
%527 = phi i64 [ %517, %516 ], [ %525, %519 ]
%528 = icmp eq i64 %518, %201
br i1 %528, label %638, label %623
529: ; preds = %456
%530 = fsub double %441, %439
br i1 %127, label %531, label %223
531: ; preds = %457, %529
%532 = phi double [ %441, %529 ], [ %450, %457 ]
%533 = phi double* [ %440, %529 ], [ %449, %457 ]
%534 = phi double [ %530, %529 ], [ %458, %457 ]
%535 = load double, double* %1
%536 = fsub double %532, %535
%537 = fdiv double %536, %534
store double %537, double* %17
br i1 %202, label %638, label %538
538: ; preds = %531
br i1 %203, label %592, label %539
539: ; preds = %538
%540 = getelementptr inbounds double, double* %3, i64 %257
%541 = icmp ugt double* %540, %17
%542 = icmp ult double* %533, %142
%543 = and i1 %541, %542
%544 = or i1 %543, %206
br i1 %544, label %592, label %545
545: ; preds = %539
%546 = insertelement <2 x double> poison, double %534, i64 0
%547 = shufflevector <2 x double> %546, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %210, label %577, label %548
548: ; preds = %545
%549 = load double, double* %533
%550 = insertelement <2 x double> poison, double %549, i64 0
%551 = shufflevector <2 x double> %550, <2 x double> poison, <2 x i32> zeroinitializer
%552 = load double, double* %533
%553 = insertelement <2 x double> poison, double %552, i64 0
%554 = shufflevector <2 x double> %553, <2 x double> poison, <2 x i32> zeroinitializer
br label %555
555: ; preds = %555, %548
%556 = phi i64 [ 0, %548 ], [ %574, %555 ]
%557 = phi i64 [ 0, %548 ], [ %575, %555 ]
%558 = or i64 %556, 1
%559 = getelementptr inbounds double, double* %1, i64 %558
%560 = bitcast double* %559 to <2 x double>*
%561 = load <2 x double>, <2 x double>* %560
%562 = fsub <2 x double> %551, %561
%563 = fdiv <2 x double> %562, %547
%564 = getelementptr inbounds double, double* %17, i64 %558
%565 = bitcast double* %564 to <2 x double>*
store <2 x double> %563, <2 x double>* %565
%566 = or i64 %556, 3
%567 = getelementptr inbounds double, double* %1, i64 %566
%568 = bitcast double* %567 to <2 x double>*
%569 = load <2 x double>, <2 x double>* %568
%570 = fsub <2 x double> %554, %569
%571 = fdiv <2 x double> %570, %547
%572 = getelementptr inbounds double, double* %17, i64 %566
%573 = bitcast double* %572 to <2 x double>*
store <2 x double> %571, <2 x double>* %573
%574 = add nuw i64 %556, 4
%575 = add nuw i64 %557, 2
%576 = icmp eq i64 %575, %211
br i1 %576, label %577, label %555
577: ; preds = %555, %545
%578 = phi i64 [ 0, %545 ], [ %574, %555 ]
br i1 %212, label %591, label %579
579: ; preds = %577
%580 = or i64 %578, 1
%581 = load double, double* %533
%582 = insertelement <2 x double> poison, double %581, i64 0
%583 = shufflevector <2 x double> %582, <2 x double> poison, <2 x i32> zeroinitializer
%584 = getelementptr inbounds double, double* %1, i64 %580
%585 = bitcast double* %584 to <2 x double>*
%586 = load <2 x double>, <2 x double>* %585
%587 = fsub <2 x double> %583, %586
%588 = fdiv <2 x double> %587, %547
%589 = getelementptr inbounds double, double* %17, i64 %580
%590 = bitcast double* %589 to <2 x double>*
store <2 x double> %588, <2 x double>* %590
br label %591
591: ; preds = %577, %579
br i1 %213, label %638, label %592
592: ; preds = %539, %538, %591
%593 = phi i64 [ 1, %539 ], [ 1, %538 ], [ %208, %591 ]
%594 = xor i64 %593, -1
br i1 %215, label %595, label %603
595: ; preds = %592
%596 = load double, double* %533
%597 = getelementptr inbounds double, double* %1, i64 %593
%598 = load double, double* %597
%599 = fsub double %596, %598
%600 = fdiv double %599, %534
%601 = getelementptr inbounds double, double* %17, i64 %593
store double %600, double* %601
%602 = add nuw nsw i64 %593, 1
br label %603
603: ; preds = %595, %592
%604 = phi i64 [ %593, %592 ], [ %602, %595 ]
%605 = icmp eq i64 %594, %216
br i1 %605, label %638, label %606
606: ; preds = %603, %606
%607 = phi i64 [ %621, %606 ], [ %604, %603 ]
%608 = load double, double* %533
%609 = getelementptr inbounds double, double* %1, i64 %607
%610 = load double, double* %609
%611 = fsub double %608, %610
%612 = fdiv double %611, %534
%613 = getelementptr inbounds double, double* %17, i64 %607
store double %612, double* %613
%614 = add nuw nsw i64 %607, 1
%615 = load double, double* %533
%616 = getelementptr inbounds double, double* %1, i64 %614
%617 = load double, double* %616
%618 = fsub double %615, %617
%619 = fdiv double %618, %534
%620 = getelementptr inbounds double, double* %17, i64 %614
store double %619, double* %620
%621 = add nuw nsw i64 %607, 2
%622 = icmp eq i64 %621, %131
br i1 %622, label %638, label %606
623: ; preds = %526, %623
%624 = phi i64 [ %636, %623 ], [ %527, %526 ]
%625 = load double, double* %462
%626 = load double, double* %464
%627 = fsub double %625, %626
%628 = fdiv double %130, %627
%629 = getelementptr inbounds double, double* %17, i64 %624
store double %628, double* %629
%630 = add nuw nsw i64 %624, 1
%631 = load double, double* %462
%632 = load double, double* %464
%633 = fsub double %631, %632
%634 = fdiv double %130, %633
%635 = getelementptr inbounds double, double* %17, i64 %630
store double %634, double* %635
%636 = add nuw nsw i64 %624, 2
%637 = icmp eq i64 %636, %131
br i1 %637, label %638, label %623
638: ; preds = %526, %623, %603, %606, %460, %515, %531, %591
br i1 %127, label %639, label %223
639: ; preds = %455, %638
br i1 %217, label %699, label %640
640: ; preds = %639
%641 = getelementptr double, double* %228, i64 %131
%642 = bitcast double* %641 to i8*
%643 = icmp ult double* %228, %138
%644 = icmp ult i8* %14, %642
%645 = and i1 %643, %644
%646 = icmp ult double* %228, %245
%647 = icmp ult double* %243, %641
%648 = and i1 %646, %647
%649 = or i1 %645, %648
%650 = icmp ult double* %228, %248
%651 = icmp ult double* %246, %641
%652 = and i1 %650, %651
%653 = or i1 %649, %652
%654 = icmp ult double* %228, %140
%655 = icmp ult i8* %18, %642
%656 = and i1 %654, %655
%657 = or i1 %653, %656
br i1 %657, label %699, label %658
658: ; preds = %640
%659 = getelementptr double, double* %253, i64 %218
%660 = getelementptr double, double* %250, i64 %218
%661 = getelementptr double, double* %228, i64 %218
br label %662
662: ; preds = %662, %658
%663 = phi i64 [ 0, %658 ], [ %696, %662 ]
%664 = getelementptr double, double* %253, i64 %663
%665 = getelementptr double, double* %250, i64 %663
%666 = getelementptr double, double* %228, i64 %663
%667 = getelementptr inbounds double, double* %13, i64 %663
%668 = bitcast double* %667 to <2 x double>*
%669 = load <2 x double>, <2 x double>* %668
%670 = getelementptr inbounds double, double* %667, i64 2
%671 = bitcast double* %670 to <2 x double>*
%672 = load <2 x double>, <2 x double>* %671
%673 = bitcast double* %665 to <2 x double>*
%674 = load <2 x double>, <2 x double>* %673
%675 = getelementptr double, double* %665, i64 2
%676 = bitcast double* %675 to <2 x double>*
%677 = load <2 x double>, <2 x double>* %676
%678 = getelementptr inbounds double, double* %17, i64 %663
%679 = bitcast double* %678 to <2 x double>*
%680 = load <2 x double>, <2 x double>* %679
%681 = getelementptr inbounds double, double* %678, i64 2
%682 = bitcast double* %681 to <2 x double>*
%683 = load <2 x double>, <2 x double>* %682
%684 = bitcast double* %664 to <2 x double>*
%685 = load <2 x double>, <2 x double>* %684
%686 = getelementptr double, double* %664, i64 2
%687 = bitcast double* %686 to <2 x double>*
%688 = load <2 x double>, <2 x double>* %687
%689 = fmul <2 x double> %680, %685
%690 = fmul <2 x double> %683, %688
%691 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %669, <2 x double> %674, <2 x double> %689)
%692 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %672, <2 x double> %677, <2 x double> %690)
%693 = bitcast double* %666 to <2 x double>*
store <2 x double> %691, <2 x double>* %693
%694 = getelementptr double, double* %666, i64 2
%695 = bitcast double* %694 to <2 x double>*
store <2 x double> %692, <2 x double>* %695
%696 = add nuw i64 %663, 4
%697 = icmp eq i64 %696, %218
br i1 %697, label %698, label %662
698: ; preds = %662
br i1 %219, label %223, label %699
699: ; preds = %640, %639, %698
%700 = phi i64 [ 0, %640 ], [ 0, %639 ], [ %218, %698 ]
%701 = phi double* [ %253, %640 ], [ %253, %639 ], [ %659, %698 ]
%702 = phi double* [ %250, %640 ], [ %250, %639 ], [ %660, %698 ]
%703 = phi double* [ %228, %640 ], [ %228, %639 ], [ %661, %698 ]
%704 = xor i64 %700, -1
br i1 %221, label %718, label %705
705: ; preds = %699
%706 = getelementptr inbounds double, double* %13, i64 %700
%707 = load double, double* %706
%708 = load double, double* %702
%709 = getelementptr inbounds double, double* %17, i64 %700
%710 = load double, double* %709
%711 = load double, double* %701
%712 = fmul double %710, %711
%713 = tail call double @llvm.fmuladd.f64(double %707, double %708, double %712)
store double %713, double* %703
%714 = getelementptr inbounds double, double* %702, i64 1
%715 = getelementptr inbounds double, double* %701, i64 1
%716 = getelementptr inbounds double, double* %703, i64 1
%717 = or i64 %700, 1
br label %718
718: ; preds = %705, %699
%719 = phi double* [ undef, %699 ], [ %716, %705 ]
%720 = phi i64 [ %700, %699 ], [ %717, %705 ]
%721 = phi double* [ %701, %699 ], [ %715, %705 ]
%722 = phi double* [ %702, %699 ], [ %714, %705 ]
%723 = phi double* [ %703, %699 ], [ %716, %705 ]
%724 = icmp eq i64 %704, %222
br i1 %724, label %223, label %725
725: ; preds = %718, %725
%726 = phi i64 [ %753, %725 ], [ %720, %718 ]
%727 = phi double* [ %751, %725 ], [ %721, %718 ]
%728 = phi double* [ %750, %725 ], [ %722, %718 ]
%729 = phi double* [ %752, %725 ], [ %723, %718 ]
%730 = getelementptr inbounds double, double* %13, i64 %726
%731 = load double, double* %730
%732 = load double, double* %728
%733 = getelementptr inbounds double, double* %17, i64 %726
%734 = load double, double* %733
%735 = load double, double* %727
%736 = fmul double %734, %735
%737 = tail call double @llvm.fmuladd.f64(double %731, double %732, double %736)
store double %737, double* %729
%738 = getelementptr inbounds double, double* %728, i64 1
%739 = getelementptr inbounds double, double* %727, i64 1
%740 = getelementptr inbounds double, double* %729, i64 1
%741 = add nuw nsw i64 %726, 1
%742 = getelementptr inbounds double, double* %13, i64 %741
%743 = load double, double* %742
%744 = load double, double* %738
%745 = getelementptr inbounds double, double* %17, i64 %741
%746 = load double, double* %745
%747 = load double, double* %739
%748 = fmul double %746, %747
%749 = tail call double @llvm.fmuladd.f64(double %743, double %744, double %748)
store double %749, double* %740
%750 = getelementptr inbounds double, double* %728, i64 2
%751 = getelementptr inbounds double, double* %727, i64 2
%752 = getelementptr inbounds double, double* %729, i64 2
%753 = add nuw nsw i64 %726, 2
%754 = icmp eq i64 %753, %131
br i1 %754, label %223, label %725
755: ; preds = %223, %114
%756 = phi double* [ %0, %114 ], [ %224, %223 ]
%757 = tail call i32 @free(double* %119)
br label %758
758: ; preds = %110, %21, %755
%759 = phi double* [ %756, %755 ], [ %0, %21 ], [ %111, %110 ]
%760 = tail call i32 @free(double* %13)
%761 = tail call i32 @free(double* %17)
%762 = mul nsw i32 %10, %2
%763 = sext i32 %762 to i64
%764 = sub nsw i64 0, %763
%765 = getelementptr inbounds double, double* %759, i64 %764
ret double* %765
}