#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double dymTableSpline(double q[4], double *table, int iu, int icol, int colWise,
                      int nt1, int nt2) {
  int last = nt1;
  int j;
  double m1, m2, m3, m4, m5;
  double t3, t4;
  double a2, a3, a4;
  double wleft, wright, sw;
  double p0;
  j = (iu < 2) ? 2 : (iu > last) ? last : iu;
  a3 = (colWise ? (table[(j - 1) + (1 - 1) * nt1])
                : (table[(1 - 1) + (j - 1) * nt2])) -
       (colWise ? (table[(j - 1 - 1) + (1 - 1) * nt1])
                : (table[(1 - 1) + (j - 1 - 1) * nt2]));
  m3 = ((colWise ? (table[(j - 1) + (icol - 1) * nt1])
                 : (table[(icol - 1) + (j - 1) * nt2])) -
        (colWise ? (table[(j - 1 - 1) + (icol - 1) * nt1])
                 : (table[(icol - 1) + (j - 1 - 1) * nt2]))) /
       a3;
  p0 = (colWise ? (table[(j - 1 - 1) + (1 - 1) * nt1])
                : (table[(1 - 1) + (j - 1 - 1) * nt2]));
  q[0] = (colWise ? (table[(j - 1 - 1) + (icol - 1) * nt1])
                  : (table[(icol - 1) + (j - 1 - 1) * nt2]));
  if (last != 2) {
    if (j != 2) {
      a2 = (colWise ? (table[(j - 1 - 1) + (1 - 1) * nt1])
                    : (table[(1 - 1) + (j - 1 - 1) * nt2])) -
           (colWise ? (table[(j - 2 - 1) + (1 - 1) * nt1])
                    : (table[(1 - 1) + (j - 2 - 1) * nt2]));
      m2 = ((colWise ? (table[(j - 1 - 1) + (icol - 1) * nt1])
                     : (table[(icol - 1) + (j - 1 - 1) * nt2])) -
            (colWise ? (table[(j - 2 - 1) + (icol - 1) * nt1])
                     : (table[(icol - 1) + (j - 2 - 1) * nt2]))) /
           a2;
      if (j != last) {
        a4 = (colWise ? (table[(j + 1 - 1) + (1 - 1) * nt1])
                      : (table[(1 - 1) + (j + 1 - 1) * nt2])) -
             (colWise ? (table[(j - 1) + (1 - 1) * nt1])
                      : (table[(1 - 1) + (j - 1) * nt2]));
        m4 = ((colWise ? (table[(j + 1 - 1) + (icol - 1) * nt1])
                       : (table[(icol - 1) + (j + 1 - 1) * nt2])) -
              (colWise ? (table[(j - 1) + (icol - 1) * nt1])
                       : (table[(icol - 1) + (j - 1) * nt2]))) /
             a4;
      } else {
        a4 = 1;
        m4 = m3 + m3 - m2;
      }
    } else {
      a2 = 1;
      a4 = (colWise ? (table[(j + 1 - 1) + (1 - 1) * nt1])
                    : (table[(1 - 1) + (j + 1 - 1) * nt2])) -
           (colWise ? (table[(j - 1) + (1 - 1) * nt1])
                    : (table[(1 - 1) + (j - 1) * nt2]));
      m4 = ((colWise ? (table[(j + 1 - 1) + (icol - 1) * nt1])
                     : (table[(icol - 1) + (j + 1 - 1) * nt2])) -
            (colWise ? (table[(j - 1) + (icol - 1) * nt1])
                     : (table[(icol - 1) + (j - 1) * nt2]))) /
           a4;
      m2 = m3 + m3 - m4;
    }
  } else {
    a2 = 1;
    a4 = 1;
    m2 = m3;
    m4 = m3;
  }
  if (j > 3) {
    m1 = ((colWise ? (table[(j - 2 - 1) + (icol - 1) * nt1])
                   : (table[(icol - 1) + (j - 2 - 1) * nt2])) -
          (colWise ? (table[(j - 3 - 1) + (icol - 1) * nt1])
                   : (table[(icol - 1) + (j - 3 - 1) * nt2]))) /
         ((colWise ? (table[(j - 2 - 1) + (1 - 1) * nt1])
                   : (table[(1 - 1) + (j - 2 - 1) * nt2])) -
          (colWise ? (table[(j - 3 - 1) + (1 - 1) * nt1])
                   : (table[(1 - 1) + (j - 3 - 1) * nt2])));
  } else {
    m1 = m2 + m2 - m3;
  }
  if (j < last - 1) {
    m5 = ((colWise ? (table[(j + 2 - 1) + (icol - 1) * nt1])
                   : (table[(icol - 1) + (j + 2 - 1) * nt2])) -
          (colWise ? (table[(j + 1 - 1) + (icol - 1) * nt1])
                   : (table[(icol - 1) + (j + 1 - 1) * nt2]))) /
         ((colWise ? (table[(j + 2 - 1) + (1 - 1) * nt1])
                   : (table[(1 - 1) + (j + 2 - 1) * nt2])) -
          (colWise ? (table[(j + 1 - 1) + (1 - 1) * nt1])
                   : (table[(1 - 1) + (j + 1 - 1) * nt2])));
  } else {
    m5 = m4 + m4 - m3;
  }
  if (iu < last + 1) {
    wleft = fabs(m4 - m3);
    wright = fabs(m2 - m1);
    sw = wleft + wright;
    if (sw == 0) {
      wleft = 0.5;
      wright = 0.5;
      sw = 1.0;
    }
    t3 = (wleft * m2 + wright * m3) / sw;
    if (iu > 1) {
      wleft = fabs(m5 - m4);
      wright = fabs(m3 - m2);
      sw = wleft + wright;
      if (sw == 0) {
        wleft = 0.5;
        wright = 0.5;
        sw = 1.0;
      }
      t4 = (wleft * m3 + wright * m4) / sw;
    } else {
      t4 = t3;
      t3 = 0.5 *
           (m1 + m2 - a4 * (a3 - a4) * (m3 - m4) / ((a3 + a4) * (a3 + a4)));
      p0 = (colWise ? (table[(j - 1 - 1) + (1 - 1) * nt1])
                    : (table[(1 - 1) + (j - 1 - 1) * nt2])) -
           a4;
      q[0] = (colWise ? (table[(j - 1 - 1) + (icol - 1) * nt1])
                      : (table[(icol - 1) + (j - 1 - 1) * nt2])) -
             m2 * a4;
      a3 = a4;
      m3 = m2;
    }
  } else {
    wleft = fabs(m5 - m4);
    wright = fabs(m3 - m2);
    sw = wleft + wright;
    if (sw == 0) {
      wleft = 0.5;
      wright = 0.5;
      sw = 1.0;
    }
    t4 = (wleft * m3 + wright * m4) / sw;
    t3 = t4;
    t4 = 0.5 * (m4 + m5 - a2 * (a2 - a3) * (m2 - m3) / ((a2 + a3) * (a2 + a3)));
    p0 = (colWise ? (table[(j - 1) + (1 - 1) * nt1])
                  : (table[(1 - 1) + (j - 1) * nt2]));
    q[0] = (colWise ? (table[(j - 1) + (icol - 1) * nt1])
                    : (table[(icol - 1) + (j - 1) * nt2]));
    m3 = m4;
    a3 = a2;
  }
  q[1] = t3;
  q[2] = (2.0 * (m3 - t3) + m3 - t4) / a3;
  q[3] = (-m3 - m3 + t3 + t4) / (a3 * a3);
  return p0;
}


x86 assembly (clang, -O0):
<dymTableSpline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x14(%rbp)
jge    1144 <dymTableSpline+0x44>
mov    $0x2,%eax
mov    %eax,-0x9c(%rbp)
jmp    1173 <dymTableSpline+0x73>
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    115e <dymTableSpline+0x5e>
mov    -0x24(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    1167 <dymTableSpline+0x67>
mov    -0x14(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     11ab <dymTableSpline+0xab>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    11cc <dymTableSpline+0xcc>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     120e <dymTableSpline+0x10e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1232 <dymTableSpline+0x132>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1280 <dymTableSpline+0x180>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    12a6 <dymTableSpline+0x1a6>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     12ee <dymTableSpline+0x1ee>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1317 <dymTableSpline+0x217>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1367 <dymTableSpline+0x267>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    138b <dymTableSpline+0x28b>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     13d3 <dymTableSpline+0x2d3>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    13fc <dymTableSpline+0x2fc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x2,-0x24(%rbp)
je     19b4 <dymTableSpline+0x8b4>
cmpl   $0x2,-0x28(%rbp)
je     17d5 <dymTableSpline+0x6d5>
cmpl   $0x0,-0x1c(%rbp)
je     1452 <dymTableSpline+0x352>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1476 <dymTableSpline+0x376>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     14b8 <dymTableSpline+0x3b8>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    14dc <dymTableSpline+0x3dc>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     152d <dymTableSpline+0x42d>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1556 <dymTableSpline+0x456>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     159e <dymTableSpline+0x49e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    15c7 <dymTableSpline+0x4c7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x2,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     17af <dymTableSpline+0x6af>
cmpl   $0x0,-0x1c(%rbp)
je     1623 <dymTableSpline+0x523>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1647 <dymTableSpline+0x547>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1686 <dymTableSpline+0x586>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    16a7 <dymTableSpline+0x5a7>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     16f8 <dymTableSpline+0x5f8>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1721 <dymTableSpline+0x621>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1766 <dymTableSpline+0x666>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    178c <dymTableSpline+0x68c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    17d0 <dymTableSpline+0x6d0>
movsd  0x1849(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    19af <dymTableSpline+0x8af>
movsd  0x1823(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1814 <dymTableSpline+0x714>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    1838 <dymTableSpline+0x738>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1877 <dymTableSpline+0x777>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    1898 <dymTableSpline+0x798>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     18e9 <dymTableSpline+0x7e9>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1912 <dymTableSpline+0x812>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1957 <dymTableSpline+0x857>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    197d <dymTableSpline+0x87d>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    19e2 <dymTableSpline+0x8e2>
movsd  0x1644(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x1637(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x3,-0x28(%rbp)
jle    1bc0 <dymTableSpline+0xac0>
cmpl   $0x0,-0x1c(%rbp)
je     1a24 <dymTableSpline+0x924>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
jmp    1a4d <dymTableSpline+0x94d>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x2,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1a95 <dymTableSpline+0x995>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x3,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
jmp    1abe <dymTableSpline+0x9be>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x3,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1b0c <dymTableSpline+0xa0c>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
jmp    1b30 <dymTableSpline+0xa30>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1b72 <dymTableSpline+0xa72>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x3,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
jmp    1b96 <dymTableSpline+0xa96>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x3,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1a8(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1bd4 <dymTableSpline+0xad4>
movsd  -0x38(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1db9 <dymTableSpline+0xcb9>
cmpl   $0x0,-0x1c(%rbp)
je     1c1d <dymTableSpline+0xb1d>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
jmp    1c46 <dymTableSpline+0xb46>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1c8e <dymTableSpline+0xb8e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
jmp    1cb7 <dymTableSpline+0xbb7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0x1c0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1d05 <dymTableSpline+0xc05>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    1d29 <dymTableSpline+0xc29>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     1d6b <dymTableSpline+0xc6b>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
jmp    1d8f <dymTableSpline+0xc8f>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm1
ff
movsd  -0x1e0(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1dcd <dymTableSpline+0xccd>
movsd  -0x48(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    20f1 <dymTableSpline+0xff1>
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movaps 0x1221(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movaps 0x1207(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e72 <dymTableSpline+0xd72>
jp     1e72 <dymTableSpline+0xd72>
movsd  0x11bb(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x11ae(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x1196(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    1f6d <dymTableSpline+0xe6d>
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movaps 0x1157(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movaps 0x113d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1f3c <dymTableSpline+0xe3c>
jp     1f3c <dymTableSpline+0xe3c>
movsd  0x10f1(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10e4(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x10cc(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
jmp    20ec <dymTableSpline+0xfec>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x30(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
subsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  -0x40(%rbp),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  -0x70(%rbp),%xmm2
addsd  -0x78(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm3
addsd  -0x78(%rbp),%xmm3
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
movsd  0x103e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     2005 <dymTableSpline+0xf05>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
jmp    2029 <dymTableSpline+0xf29>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     2076 <dymTableSpline+0xf76>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
jmp    209f <dymTableSpline+0xf9f>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    22f6 <dymTableSpline+0x11f6>
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movaps 0xf0e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movaps 0xef4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2185 <dymTableSpline+0x1085>
jp     2185 <dymTableSpline+0x1085>
movsd  0xea8(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe9b(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe83(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
subsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
subsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  -0x68(%rbp),%xmm2
addsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
addsd  -0x70(%rbp),%xmm3
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
movsd  0xdfa(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     2246 <dymTableSpline+0x1146>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x0,-0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
jmp    2267 <dymTableSpline+0x1167>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
je     22ac <dymTableSpline+0x11ac>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
jmp    22d2 <dymTableSpline+0x11d2>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x200(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x40(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x60(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
subsd  -0x40(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x98(%rbp),%xmm0
ff
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dymTableSpline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,-0x38(%rsp)
mov    0x38(%rsp),%r11d
cmp    %r9d,%edx
mov    %edx,%eax
cmovg  %r9d,%eax
cmp    $0x2,%edx
mov    $0x2,%r13d
cmovge %eax,%r13d
lea    -0x1(%r13),%r12d
mov    %r12d,%ebx
imul   %r11d,%ebx
lea    -0x2(%r13),%r15d
mov    %r15d,%r10d
imul   %r11d,%r10d
mov    %rcx,-0x40(%rsp)
lea    -0x1(%rcx),%r14d
mov    %r12d,%eax
mov    %r8d,-0x44(%rsp)
test   %r8d,%r8d
cmove  %ebx,%eax
movslq %eax,%rcx
mov    %r15d,%eax
cmove  %r10d,%eax
mov    %rcx,-0x28(%rsp)
movsd  (%rsi,%rcx,8),%xmm11
movslq %eax,%r8
movsd  (%rsi,%r8,8),%xmm0
subsd  %xmm0,%xmm11
je     1196 <dymTableSpline+0x96>
mov    %r14d,%eax
imul   %r9d,%eax
lea    (%r12,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm2
add    %r15d,%eax
cltq
jmp    11a7 <dymTableSpline+0xa7>
lea    (%r14,%rbx,1),%eax
cltq
movsd  (%rsi,%rax,8),%xmm2
lea    (%r14,%r10,1),%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
subsd  %xmm1,%xmm2
divsd  %xmm11,%xmm2
mov    -0x38(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0xe39(%rip),%xmm9
cmp    $0x2,%r9d
jne    1241 <dymTableSpline+0x141>
movapd %xmm2,%xmm13
movapd %xmm2,%xmm10
movapd %xmm9,%xmm8
cmp    $0x4,%r13d
jl     1378 <dymTableSpline+0x278>
cmpl   $0x0,-0x44(%rsp)
mov    %r15,-0x8(%rsp)
mov    %r12,-0x10(%rsp)
mov    %r10,-0x18(%rsp)
mov    %rbx,-0x20(%rsp)
mov    %edx,-0x2c(%rsp)
mov    %r8,%rdx
je     12c5 <dymTableSpline+0x1c5>
mov    -0x44(%rsp),%ebx
lea    -0x3(%r13),%r12d
mov    %r14d,%eax
imul   %r9d,%eax
lea    (%rax,%r13,1),%edi
add    $0xfffffffd,%edi
lea    -0x4(%r13),%r10d
lea    (%rax,%r13,1),%r8d
add    $0xfffffffc,%r8d
mov    %r12d,%r15d
imul   %r11d,%r15d
mov    %r10d,%ecx
imul   %r11d,%ecx
jmp    12f2 <dymTableSpline+0x1f2>
cmp    $0x2,%r13d
jne    128a <dymTableSpline+0x18a>
lea    (%r11,%r11,1),%ecx
mov    $0x2,%eax
cmpl   $0x0,-0x44(%rsp)
cmove  %ecx,%eax
cltq
mov    $0x1,%ebp
cmove  %r11d,%ebp
movsd  (%rsi,%rax,8),%xmm9
movslq %ebp,%rax
subsd  (%rsi,%rax,8),%xmm9
je     1343 <dymTableSpline+0x243>
mov    %r14d,%eax
imul   %r9d,%eax
lea    0x2(%rax),%ecx
add    $0x1,%eax
jmp    134a <dymTableSpline+0x24a>
lea    -0x3(%r13),%ebp
mov    %ebp,%eax
imul   %r11d,%eax
mov    %ebp,%ecx
cmpl   $0x0,-0x44(%rsp)
cmove  %eax,%ecx
movsd  (%rsi,%r8,8),%xmm8
movslq %ecx,%rcx
subsd  (%rsi,%rcx,8),%xmm8
je     16de <dymTableSpline+0x5de>
mov    %r14d,%eax
imul   %r9d,%eax
lea    (%r15,%rax,1),%ecx
add    %eax,%ebp
jmp    16e7 <dymTableSpline+0x5e7>
mov    -0x44(%rsp),%ebx
lea    -0x3(%r13),%r12d
mov    %r12d,%r15d
imul   %r11d,%r15d
mov    -0x40(%rsp),%r8
lea    (%r8,%r15,1),%edi
add    $0xffffffff,%edi
lea    -0x4(%r13),%r10d
mov    %r10d,%ecx
imul   %r11d,%ecx
add    %ecx,%r8d
add    $0xffffffff,%r8d
test   %ebx,%ebx
movslq %edi,%rax
movsd  (%rsi,%rax,8),%xmm7
movslq %r8d,%rax
subsd  (%rsi,%rax,8),%xmm7
mov    %r12d,%eax
movslq %r15d,%rdi
cmovne %rax,%rdi
mov    %r10d,%eax
movslq %ecx,%rcx
cmovne %rax,%rcx
movsd  (%rsi,%rdi,8),%xmm1
subsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm1,%xmm7
mov    -0x8(%rsp),%r15
mov    -0x10(%rsp),%r12
mov    -0x18(%rsp),%r10
mov    -0x20(%rsp),%rbx
mov    %rdx,%r8
mov    -0x2c(%rsp),%edx
jmp    1386 <dymTableSpline+0x286>
add    %r14d,%ecx
lea    (%r14,%r11,1),%eax
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm10
cltq
subsd  (%rsi,%rax,8),%xmm10
divsd  %xmm9,%xmm10
movapd %xmm2,%xmm13
addsd  %xmm2,%xmm13
subsd  %xmm10,%xmm13
movsd  0xc88(%rip),%xmm8
movapd %xmm13,%xmm7
addsd  %xmm13,%xmm7
subsd  %xmm2,%xmm7
lea    -0x1(%r9),%eax
cmp    %eax,%r13d
jge    13b8 <dymTableSpline+0x2b8>
cmpl   $0x0,-0x44(%rsp)
je     1536 <dymTableSpline+0x436>
lea    0x1(%r13),%ecx
mov    %r14d,%ebp
imul   %r9d,%ebp
lea    0x1(%r13,%rbp,1),%eax
add    %r13d,%ebp
mov    $0x1,%r11d
jmp    1562 <dymTableSpline+0x462>
movapd %xmm10,%xmm6
addsd  %xmm10,%xmm6
subsd  %xmm2,%xmm6
cmp    %r9d,%edx
jg     1596 <dymTableSpline+0x496>
movapd %xmm10,%xmm4
subsd  %xmm2,%xmm4
movapd 0xc2f(%rip),%xmm8
andpd  %xmm8,%xmm4
movapd %xmm13,%xmm3
subsd  %xmm7,%xmm3
andpd  %xmm8,%xmm3
movapd %xmm4,%xmm1
addsd  %xmm3,%xmm1
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm1
movsd  0xbfb(%rip),%xmm12
jne    1416 <dymTableSpline+0x316>
jp     1416 <dymTableSpline+0x316>
movapd %xmm12,%xmm4
jne    141f <dymTableSpline+0x31f>
jp     141f <dymTableSpline+0x31f>
movapd %xmm12,%xmm3
jne    142b <dymTableSpline+0x32b>
jp     142b <dymTableSpline+0x32b>
movsd  0xbd5(%rip),%xmm1
mulsd  %xmm2,%xmm3
mulsd  %xmm13,%xmm4
addsd  %xmm3,%xmm4
divsd  %xmm1,%xmm4
cmp    $0x2,%edx
jl     14ac <dymTableSpline+0x3ac>
subsd  %xmm10,%xmm6
andpd  %xmm8,%xmm6
movapd %xmm2,%xmm3
subsd  %xmm13,%xmm3
andpd  %xmm8,%xmm3
movapd %xmm6,%xmm1
addsd  %xmm3,%xmm1
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm1
movsd  0xb97(%rip),%xmm5
jne    1479 <dymTableSpline+0x379>
jp     1479 <dymTableSpline+0x379>
movapd %xmm5,%xmm6
jne    1481 <dymTableSpline+0x381>
jp     1481 <dymTableSpline+0x381>
movapd %xmm5,%xmm3
jne    148d <dymTableSpline+0x38d>
jp     148d <dymTableSpline+0x38d>
movsd  0xb73(%rip),%xmm1
mulsd  %xmm3,%xmm10
mulsd  %xmm2,%xmm6
addsd  %xmm10,%xmm6
divsd  %xmm1,%xmm6
movapd %xmm4,%xmm7
movapd %xmm6,%xmm4
jmp    1678 <dymTableSpline+0x578>
imul   %r9d,%r14d
add    %r14d,%r15d
cmpl   $0x0,-0x44(%rsp)
addsd  %xmm13,%xmm7
movapd %xmm11,%xmm0
subsd  %xmm9,%xmm0
mulsd  %xmm9,%xmm0
subsd  %xmm10,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm9,%xmm11
mulsd  %xmm11,%xmm11
divsd  %xmm11,%xmm2
subsd  %xmm2,%xmm7
mulsd  0xb18(%rip),%xmm7
movsd  (%rsi,%r8,8),%xmm0
subsd  %xmm9,%xmm0
mov    -0x40(%rsp),%rax
lea    -0x1(%rax,%r10,1),%eax
cmovne %r15d,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
movapd %xmm13,%xmm2
mulsd  %xmm9,%xmm2
subsd  %xmm2,%xmm1
mov    -0x38(%rsp),%rax
movsd  %xmm1,(%rax)
movapd %xmm13,%xmm2
movapd %xmm9,%xmm11
jmp    1678 <dymTableSpline+0x578>
lea    0x1(%r13),%ecx
mov    %ecx,%eax
imul   %r11d,%eax
mov    -0x40(%rsp),%rbp
add    %ebp,%eax
add    $0xffffffff,%eax
mov    %r14,%rdi
mov    %rbx,%r14
mov    %r13d,%ebx
imul   %r11d,%ebx
add    %ebx,%ebp
add    $0xffffffff,%ebp
mov    %r14,%rbx
mov    %rdi,%r14
cltq
movsd  (%rsi,%rax,8),%xmm6
movslq %ebp,%rax
subsd  (%rsi,%rax,8),%xmm6
imul   %r11d,%ecx
movslq %ecx,%rax
movsd  (%rsi,%rax,8),%xmm1
imul   %r11d,%r13d
movslq %r13d,%rax
subsd  (%rsi,%rax,8),%xmm1
divsd  %xmm1,%xmm6
cmp    %r9d,%edx
jle    13cf <dymTableSpline+0x2cf>
movapd %xmm6,%xmm7
subsd  %xmm10,%xmm7
movapd 0xa69(%rip),%xmm0
andpd  %xmm0,%xmm7
movapd %xmm2,%xmm4
subsd  %xmm13,%xmm4
andpd  %xmm0,%xmm4
movapd %xmm7,%xmm0
addsd  %xmm4,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  0xa37(%rip),%xmm9
jne    15da <dymTableSpline+0x4da>
jp     15da <dymTableSpline+0x4da>
movapd %xmm9,%xmm7
jne    15e3 <dymTableSpline+0x4e3>
jp     15e3 <dymTableSpline+0x4e3>
movapd %xmm9,%xmm4
jne    15ef <dymTableSpline+0x4ef>
jp     15ef <dymTableSpline+0x4ef>
movsd  0xa11(%rip),%xmm0
imul   %r9d,%r14d
add    %r14d,%r12d
cmpl   $0x0,-0x44(%rsp)
mulsd  %xmm10,%xmm4
mulsd  %xmm2,%xmm7
addsd  %xmm4,%xmm7
divsd  %xmm0,%xmm7
addsd  %xmm10,%xmm6
movapd %xmm8,%xmm0
subsd  %xmm11,%xmm0
mulsd  %xmm8,%xmm0
subsd  %xmm2,%xmm13
mulsd  %xmm0,%xmm13
addsd  %xmm8,%xmm11
mulsd  %xmm11,%xmm11
divsd  %xmm11,%xmm13
subsd  %xmm13,%xmm6
mulsd  %xmm9,%xmm6
mov    -0x40(%rsp),%rax
lea    -0x1(%rax,%rbx,1),%eax
cmovne %r12d,%eax
mov    -0x28(%rsp),%rcx
movsd  (%rsi,%rcx,8),%xmm0
cltq
movsd  (%rsi,%rax,8),%xmm1
mov    -0x38(%rsp),%rax
movsd  %xmm1,(%rax)
movapd %xmm10,%xmm2
movapd %xmm6,%xmm4
movapd %xmm8,%xmm11
mov    -0x38(%rsp),%rax
movsd  %xmm7,0x8(%rax)
movapd %xmm2,%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movapd 0x986(%rip),%xmm3
xorpd  %xmm2,%xmm3
subsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
unpcklpd %xmm3,%xmm2
subsd  %xmm4,%xmm1
unpcklpd %xmm4,%xmm4
addpd  %xmm2,%xmm4
movsd  %xmm1,%xmm4
movapd %xmm11,%xmm1
mulsd  %xmm11,%xmm1
unpcklpd %xmm1,%xmm11
divpd  %xmm11,%xmm4
movupd %xmm4,0x10(%rax)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r14,%r10,1),%ecx
add    %r14d,%eax
mov    %eax,%ebp
movslq %ecx,%rax
movsd  (%rsi,%rax,8),%xmm13
movslq %ebp,%rax
subsd  (%rsi,%rax,8),%xmm13
divsd  %xmm8,%xmm13
cmp    %r9d,%r13d
jne    1717 <dymTableSpline+0x617>
movapd %xmm2,%xmm10
addsd  %xmm2,%xmm10
subsd  %xmm13,%xmm10
jmp    11dc <dymTableSpline+0xdc>
mov    %r13d,%ecx
imul   %r11d,%ecx
mov    %r13d,%eax
cmpl   $0x0,-0x44(%rsp)
cmove  %ecx,%eax
cltq
movsd  (%rsi,%rax,8),%xmm9
mov    -0x28(%rsp),%rax
subsd  (%rsi,%rax,8),%xmm9
je     174e <dymTableSpline+0x64e>
mov    %r14d,%eax
imul   %r9d,%eax
lea    (%rax,%r13,1),%ecx
add    %r12d,%eax
jmp    1755 <dymTableSpline+0x655>
add    %r14d,%ecx
lea    (%r14,%rbx,1),%eax
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm10
cltq
subsd  (%rsi,%rax,8),%xmm10
divsd  %xmm9,%xmm10
jmp    11dc <dymTableSpline+0xdc>

LLVM IR (-O0):
define double @dymTableSpline(double* %0, double* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
store double* %0, double** %8
store double* %1, double** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%31 = load i32, i32* %13
store i32 %31, i32* %15
%32 = load i32, i32* %10
%33 = icmp slt i32 %32, 2
br i1 %33, label %34, label %35
34: ; preds = %7
br label %45
35: ; preds = %7
%36 = load i32, i32* %10
%37 = load i32, i32* %15
%38 = icmp sgt i32 %36, %37
br i1 %38, label %39, label %41
39: ; preds = %35
%40 = load i32, i32* %15
br label %43
41: ; preds = %35
%42 = load i32, i32* %10
br label %43
43: ; preds = %41, %39
%44 = phi i32 [ %40, %39 ], [ %42, %41 ]
br label %45
45: ; preds = %43, %34
%46 = phi i32 [ 2, %34 ], [ %44, %43 ]
store i32 %46, i32* %16
%47 = load i32, i32* %12
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %59
49: ; preds = %45
%50 = load double*, double** %9
%51 = load i32, i32* %16
%52 = sub nsw i32 %51, 1
%53 = load i32, i32* %13
%54 = mul nsw i32 0, %53
%55 = add nsw i32 %52, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %50, i64 %56
%58 = load double, double* %57
br label %69
59: ; preds = %45
%60 = load double*, double** %9
%61 = load i32, i32* %16
%62 = sub nsw i32 %61, 1
%63 = load i32, i32* %14
%64 = mul nsw i32 %62, %63
%65 = add nsw i32 0, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %60, i64 %66
%68 = load double, double* %67
br label %69
69: ; preds = %59, %49
%70 = phi double [ %58, %49 ], [ %68, %59 ]
%71 = load i32, i32* %12
%72 = icmp ne i32 %71, 0
br i1 %72, label %73, label %84
73: ; preds = %69
%74 = load double*, double** %9
%75 = load i32, i32* %16
%76 = sub nsw i32 %75, 1
%77 = sub nsw i32 %76, 1
%78 = load i32, i32* %13
%79 = mul nsw i32 0, %78
%80 = add nsw i32 %77, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %74, i64 %81
%83 = load double, double* %82
br label %95
84: ; preds = %69
%85 = load double*, double** %9
%86 = load i32, i32* %16
%87 = sub nsw i32 %86, 1
%88 = sub nsw i32 %87, 1
%89 = load i32, i32* %14
%90 = mul nsw i32 %88, %89
%91 = add nsw i32 0, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %85, i64 %92
%94 = load double, double* %93
br label %95
95: ; preds = %84, %73
%96 = phi double [ %83, %73 ], [ %94, %84 ]
%97 = fsub double %70, %96
store double %97, double* %25
%98 = load i32, i32* %12
%99 = icmp ne i32 %98, 0
br i1 %99, label %100, label %112
100: ; preds = %95
%101 = load double*, double** %9
%102 = load i32, i32* %16
%103 = sub nsw i32 %102, 1
%104 = load i32, i32* %11
%105 = sub nsw i32 %104, 1
%106 = load i32, i32* %13
%107 = mul nsw i32 %105, %106
%108 = add nsw i32 %103, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %101, i64 %109
%111 = load double, double* %110
br label %124
112: ; preds = %95
%113 = load double*, double** %9
%114 = load i32, i32* %11
%115 = sub nsw i32 %114, 1
%116 = load i32, i32* %16
%117 = sub nsw i32 %116, 1
%118 = load i32, i32* %14
%119 = mul nsw i32 %117, %118
%120 = add nsw i32 %115, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %113, i64 %121
%123 = load double, double* %122
br label %124
124: ; preds = %112, %100
%125 = phi double [ %111, %100 ], [ %123, %112 ]
%126 = load i32, i32* %12
%127 = icmp ne i32 %126, 0
br i1 %127, label %128, label %141
128: ; preds = %124
%129 = load double*, double** %9
%130 = load i32, i32* %16
%131 = sub nsw i32 %130, 1
%132 = sub nsw i32 %131, 1
%133 = load i32, i32* %11
%134 = sub nsw i32 %133, 1
%135 = load i32, i32* %13
%136 = mul nsw i32 %134, %135
%137 = add nsw i32 %132, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %129, i64 %138
%140 = load double, double* %139
br label %154
141: ; preds = %124
%142 = load double*, double** %9
%143 = load i32, i32* %11
%144 = sub nsw i32 %143, 1
%145 = load i32, i32* %16
%146 = sub nsw i32 %145, 1
%147 = sub nsw i32 %146, 1
%148 = load i32, i32* %14
%149 = mul nsw i32 %147, %148
%150 = add nsw i32 %144, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %142, i64 %151
%153 = load double, double* %152
br label %154
154: ; preds = %141, %128
%155 = phi double [ %140, %128 ], [ %153, %141 ]
%156 = fsub double %125, %155
%157 = load double, double* %25
%158 = fdiv double %156, %157
store double %158, double* %19
%159 = load i32, i32* %12
%160 = icmp ne i32 %159, 0
br i1 %160, label %161, label %172
161: ; preds = %154
%162 = load double*, double** %9
%163 = load i32, i32* %16
%164 = sub nsw i32 %163, 1
%165 = sub nsw i32 %164, 1
%166 = load i32, i32* %13
%167 = mul nsw i32 0, %166
%168 = add nsw i32 %165, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %162, i64 %169
%171 = load double, double* %170
br label %183
172: ; preds = %154
%173 = load double*, double** %9
%174 = load i32, i32* %16
%175 = sub nsw i32 %174, 1
%176 = sub nsw i32 %175, 1
%177 = load i32, i32* %14
%178 = mul nsw i32 %176, %177
%179 = add nsw i32 0, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %173, i64 %180
%182 = load double, double* %181
br label %183
183: ; preds = %172, %161
%184 = phi double [ %171, %161 ], [ %182, %172 ]
store double %184, double* %30
%185 = load i32, i32* %12
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %200
187: ; preds = %183
%188 = load double*, double** %9
%189 = load i32, i32* %16
%190 = sub nsw i32 %189, 1
%191 = sub nsw i32 %190, 1
%192 = load i32, i32* %11
%193 = sub nsw i32 %192, 1
%194 = load i32, i32* %13
%195 = mul nsw i32 %193, %194
%196 = add nsw i32 %191, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %188, i64 %197
%199 = load double, double* %198
br label %213
200: ; preds = %183
%201 = load double*, double** %9
%202 = load i32, i32* %11
%203 = sub nsw i32 %202, 1
%204 = load i32, i32* %16
%205 = sub nsw i32 %204, 1
%206 = sub nsw i32 %205, 1
%207 = load i32, i32* %14
%208 = mul nsw i32 %206, %207
%209 = add nsw i32 %203, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double, double* %201, i64 %210
%212 = load double, double* %211
br label %213
213: ; preds = %200, %187
%214 = phi double [ %199, %187 ], [ %212, %200 ]
%215 = load double*, double** %8
%216 = getelementptr inbounds double, double* %215, i64 0
store double %214, double* %216
%217 = load i32, i32* %15
%218 = icmp ne i32 %217, 2
br i1 %218, label %219, label %581
219: ; preds = %213
%220 = load i32, i32* %16
%221 = icmp ne i32 %220, 2
br i1 %221, label %222, label %462
222: ; preds = %219
%223 = load i32, i32* %12
%224 = icmp ne i32 %223, 0
br i1 %224, label %225, label %236
225: ; preds = %222
%226 = load double*, double** %9
%227 = load i32, i32* %16
%228 = sub nsw i32 %227, 1
%229 = sub nsw i32 %228, 1
%230 = load i32, i32* %13
%231 = mul nsw i32 0, %230
%232 = add nsw i32 %229, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %226, i64 %233
%235 = load double, double* %234
br label %247
236: ; preds = %222
%237 = load double*, double** %9
%238 = load i32, i32* %16
%239 = sub nsw i32 %238, 1
%240 = sub nsw i32 %239, 1
%241 = load i32, i32* %14
%242 = mul nsw i32 %240, %241
%243 = add nsw i32 0, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %237, i64 %244
%246 = load double, double* %245
br label %247
247: ; preds = %236, %225
%248 = phi double [ %235, %225 ], [ %246, %236 ]
%249 = load i32, i32* %12
%250 = icmp ne i32 %249, 0
br i1 %250, label %251, label %262
251: ; preds = %247
%252 = load double*, double** %9
%253 = load i32, i32* %16
%254 = sub nsw i32 %253, 2
%255 = sub nsw i32 %254, 1
%256 = load i32, i32* %13
%257 = mul nsw i32 0, %256
%258 = add nsw i32 %255, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %252, i64 %259
%261 = load double, double* %260
br label %273
262: ; preds = %247
%263 = load double*, double** %9
%264 = load i32, i32* %16
%265 = sub nsw i32 %264, 2
%266 = sub nsw i32 %265, 1
%267 = load i32, i32* %14
%268 = mul nsw i32 %266, %267
%269 = add nsw i32 0, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %263, i64 %270
%272 = load double, double* %271
br label %273
273: ; preds = %262, %251
%274 = phi double [ %261, %251 ], [ %272, %262 ]
%275 = fsub double %248, %274
store double %275, double* %24
%276 = load i32, i32* %12
%277 = icmp ne i32 %276, 0
br i1 %277, label %278, label %291
278: ; preds = %273
%279 = load double*, double** %9
%280 = load i32, i32* %16
%281 = sub nsw i32 %280, 1
%282 = sub nsw i32 %281, 1
%283 = load i32, i32* %11
%284 = sub nsw i32 %283, 1
%285 = load i32, i32* %13
%286 = mul nsw i32 %284, %285
%287 = add nsw i32 %282, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %279, i64 %288
%290 = load double, double* %289
br label %304
291: ; preds = %273
%292 = load double*, double** %9
%293 = load i32, i32* %11
%294 = sub nsw i32 %293, 1
%295 = load i32, i32* %16
%296 = sub nsw i32 %295, 1
%297 = sub nsw i32 %296, 1
%298 = load i32, i32* %14
%299 = mul nsw i32 %297, %298
%300 = add nsw i32 %294, %299
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds double, double* %292, i64 %301
%303 = load double, double* %302
br label %304
304: ; preds = %291, %278
%305 = phi double [ %290, %278 ], [ %303, %291 ]
%306 = load i32, i32* %12
%307 = icmp ne i32 %306, 0
br i1 %307, label %308, label %321
308: ; preds = %304
%309 = load double*, double** %9
%310 = load i32, i32* %16
%311 = sub nsw i32 %310, 2
%312 = sub nsw i32 %311, 1
%313 = load i32, i32* %11
%314 = sub nsw i32 %313, 1
%315 = load i32, i32* %13
%316 = mul nsw i32 %314, %315
%317 = add nsw i32 %312, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %309, i64 %318
%320 = load double, double* %319
br label %334
321: ; preds = %304
%322 = load double*, double** %9
%323 = load i32, i32* %11
%324 = sub nsw i32 %323, 1
%325 = load i32, i32* %16
%326 = sub nsw i32 %325, 2
%327 = sub nsw i32 %326, 1
%328 = load i32, i32* %14
%329 = mul nsw i32 %327, %328
%330 = add nsw i32 %324, %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %322, i64 %331
%333 = load double, double* %332
br label %334
334: ; preds = %321, %308
%335 = phi double [ %320, %308 ], [ %333, %321 ]
%336 = fsub double %305, %335
%337 = load double, double* %24
%338 = fdiv double %336, %337
store double %338, double* %18
%339 = load i32, i32* %16
%340 = load i32, i32* %15
%341 = icmp ne i32 %339, %340
br i1 %341, label %342, label %455
342: ; preds = %334
%343 = load i32, i32* %12
%344 = icmp ne i32 %343, 0
br i1 %344, label %345, label %356
345: ; preds = %342
%346 = load double*, double** %9
%347 = load i32, i32* %16
%348 = add nsw i32 %347, 1
%349 = sub nsw i32 %348, 1
%350 = load i32, i32* %13
%351 = mul nsw i32 0, %350
%352 = add nsw i32 %349, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %346, i64 %353
%355 = load double, double* %354
br label %367
356: ; preds = %342
%357 = load double*, double** %9
%358 = load i32, i32* %16
%359 = add nsw i32 %358, 1
%360 = sub nsw i32 %359, 1
%361 = load i32, i32* %14
%362 = mul nsw i32 %360, %361
%363 = add nsw i32 0, %362
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %357, i64 %364
%366 = load double, double* %365
br label %367
367: ; preds = %356, %345
%368 = phi double [ %355, %345 ], [ %366, %356 ]
%369 = load i32, i32* %12
%370 = icmp ne i32 %369, 0
br i1 %370, label %371, label %381
371: ; preds = %367
%372 = load double*, double** %9
%373 = load i32, i32* %16
%374 = sub nsw i32 %373, 1
%375 = load i32, i32* %13
%376 = mul nsw i32 0, %375
%377 = add nsw i32 %374, %376
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %372, i64 %378
%380 = load double, double* %379
br label %391
381: ; preds = %367
%382 = load double*, double** %9
%383 = load i32, i32* %16
%384 = sub nsw i32 %383, 1
%385 = load i32, i32* %14
%386 = mul nsw i32 %384, %385
%387 = add nsw i32 0, %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %382, i64 %388
%390 = load double, double* %389
br label %391
391: ; preds = %381, %371
%392 = phi double [ %380, %371 ], [ %390, %381 ]
%393 = fsub double %368, %392
store double %393, double* %26
%394 = load i32, i32* %12
%395 = icmp ne i32 %394, 0
br i1 %395, label %396, label %409
396: ; preds = %391
%397 = load double*, double** %9
%398 = load i32, i32* %16
%399 = add nsw i32 %398, 1
%400 = sub nsw i32 %399, 1
%401 = load i32, i32* %11
%402 = sub nsw i32 %401, 1
%403 = load i32, i32* %13
%404 = mul nsw i32 %402, %403
%405 = add nsw i32 %400, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %397, i64 %406
%408 = load double, double* %407
br label %422
409: ; preds = %391
%410 = load double*, double** %9
%411 = load i32, i32* %11
%412 = sub nsw i32 %411, 1
%413 = load i32, i32* %16
%414 = add nsw i32 %413, 1
%415 = sub nsw i32 %414, 1
%416 = load i32, i32* %14
%417 = mul nsw i32 %415, %416
%418 = add nsw i32 %412, %417
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %410, i64 %419
%421 = load double, double* %420
br label %422
422: ; preds = %409, %396
%423 = phi double [ %408, %396 ], [ %421, %409 ]
%424 = load i32, i32* %12
%425 = icmp ne i32 %424, 0
br i1 %425, label %426, label %438
426: ; preds = %422
%427 = load double*, double** %9
%428 = load i32, i32* %16
%429 = sub nsw i32 %428, 1
%430 = load i32, i32* %11
%431 = sub nsw i32 %430, 1
%432 = load i32, i32* %13
%433 = mul nsw i32 %431, %432
%434 = add nsw i32 %429, %433
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %427, i64 %435
%437 = load double, double* %436
br label %450
438: ; preds = %422
%439 = load double*, double** %9
%440 = load i32, i32* %11
%441 = sub nsw i32 %440, 1
%442 = load i32, i32* %16
%443 = sub nsw i32 %442, 1
%444 = load i32, i32* %14
%445 = mul nsw i32 %443, %444
%446 = add nsw i32 %441, %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %439, i64 %447
%449 = load double, double* %448
br label %450
450: ; preds = %438, %426
%451 = phi double [ %437, %426 ], [ %449, %438 ]
%452 = fsub double %423, %451
%453 = load double, double* %26
%454 = fdiv double %452, %453
store double %454, double* %20
br label %461
455: ; preds = %334
store double 1.000000e+00, double* %26
%456 = load double, double* %19
%457 = load double, double* %19
%458 = fadd double %456, %457
%459 = load double, double* %18
%460 = fsub double %458, %459
store double %460, double* %20
br label %461
461: ; preds = %455, %450
br label %580
462: ; preds = %219
store double 1.000000e+00, double* %24
%463 = load i32, i32* %12
%464 = icmp ne i32 %463, 0
br i1 %464, label %465, label %476
465: ; preds = %462
%466 = load double*, double** %9
%467 = load i32, i32* %16
%468 = add nsw i32 %467, 1
%469 = sub nsw i32 %468, 1
%470 = load i32, i32* %13
%471 = mul nsw i32 0, %470
%472 = add nsw i32 %469, %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %466, i64 %473
%475 = load double, double* %474
br label %487
476: ; preds = %462
%477 = load double*, double** %9
%478 = load i32, i32* %16
%479 = add nsw i32 %478, 1
%480 = sub nsw i32 %479, 1
%481 = load i32, i32* %14
%482 = mul nsw i32 %480, %481
%483 = add nsw i32 0, %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %477, i64 %484
%486 = load double, double* %485
br label %487
487: ; preds = %476, %465
%488 = phi double [ %475, %465 ], [ %486, %476 ]
%489 = load i32, i32* %12
%490 = icmp ne i32 %489, 0
br i1 %490, label %491, label %501
491: ; preds = %487
%492 = load double*, double** %9
%493 = load i32, i32* %16
%494 = sub nsw i32 %493, 1
%495 = load i32, i32* %13
%496 = mul nsw i32 0, %495
%497 = add nsw i32 %494, %496
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds double, double* %492, i64 %498
%500 = load double, double* %499
br label %511
501: ; preds = %487
%502 = load double*, double** %9
%503 = load i32, i32* %16
%504 = sub nsw i32 %503, 1
%505 = load i32, i32* %14
%506 = mul nsw i32 %504, %505
%507 = add nsw i32 0, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %502, i64 %508
%510 = load double, double* %509
br label %511
511: ; preds = %501, %491
%512 = phi double [ %500, %491 ], [ %510, %501 ]
%513 = fsub double %488, %512
store double %513, double* %26
%514 = load i32, i32* %12
%515 = icmp ne i32 %514, 0
br i1 %515, label %516, label %529
516: ; preds = %511
%517 = load double*, double** %9
%518 = load i32, i32* %16
%519 = add nsw i32 %518, 1
%520 = sub nsw i32 %519, 1
%521 = load i32, i32* %11
%522 = sub nsw i32 %521, 1
%523 = load i32, i32* %13
%524 = mul nsw i32 %522, %523
%525 = add nsw i32 %520, %524
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double, double* %517, i64 %526
%528 = load double, double* %527
br label %542
529: ; preds = %511
%530 = load double*, double** %9
%531 = load i32, i32* %11
%532 = sub nsw i32 %531, 1
%533 = load i32, i32* %16
%534 = add nsw i32 %533, 1
%535 = sub nsw i32 %534, 1
%536 = load i32, i32* %14
%537 = mul nsw i32 %535, %536
%538 = add nsw i32 %532, %537
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %530, i64 %539
%541 = load double, double* %540
br label %542
542: ; preds = %529, %516
%543 = phi double [ %528, %516 ], [ %541, %529 ]
%544 = load i32, i32* %12
%545 = icmp ne i32 %544, 0
br i1 %545, label %546, label %558
546: ; preds = %542
%547 = load double*, double** %9
%548 = load i32, i32* %16
%549 = sub nsw i32 %548, 1
%550 = load i32, i32* %11
%551 = sub nsw i32 %550, 1
%552 = load i32, i32* %13
%553 = mul nsw i32 %551, %552
%554 = add nsw i32 %549, %553
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %547, i64 %555
%557 = load double, double* %556
br label %570
558: ; preds = %542
%559 = load double*, double** %9
%560 = load i32, i32* %11
%561 = sub nsw i32 %560, 1
%562 = load i32, i32* %16
%563 = sub nsw i32 %562, 1
%564 = load i32, i32* %14
%565 = mul nsw i32 %563, %564
%566 = add nsw i32 %561, %565
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %559, i64 %567
%569 = load double, double* %568
br label %570
570: ; preds = %558, %546
%571 = phi double [ %557, %546 ], [ %569, %558 ]
%572 = fsub double %543, %571
%573 = load double, double* %26
%574 = fdiv double %572, %573
store double %574, double* %20
%575 = load double, double* %19
%576 = load double, double* %19
%577 = fadd double %575, %576
%578 = load double, double* %20
%579 = fsub double %577, %578
store double %579, double* %18
br label %580
580: ; preds = %570, %461
br label %584
581: ; preds = %213
store double 1.000000e+00, double* %24
store double 1.000000e+00, double* %26
%582 = load double, double* %19
store double %582, double* %18
%583 = load double, double* %19
store double %583, double* %20
br label %584
584: ; preds = %581, %580
%585 = load i32, i32* %16
%586 = icmp sgt i32 %585, 3
br i1 %586, label %587, label %703
587: ; preds = %584
%588 = load i32, i32* %12
%589 = icmp ne i32 %588, 0
br i1 %589, label %590, label %603
590: ; preds = %587
%591 = load double*, double** %9
%592 = load i32, i32* %16
%593 = sub nsw i32 %592, 2
%594 = sub nsw i32 %593, 1
%595 = load i32, i32* %11
%596 = sub nsw i32 %595, 1
%597 = load i32, i32* %13
%598 = mul nsw i32 %596, %597
%599 = add nsw i32 %594, %598
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %591, i64 %600
%602 = load double, double* %601
br label %616
603: ; preds = %587
%604 = load double*, double** %9
%605 = load i32, i32* %11
%606 = sub nsw i32 %605, 1
%607 = load i32, i32* %16
%608 = sub nsw i32 %607, 2
%609 = sub nsw i32 %608, 1
%610 = load i32, i32* %14
%611 = mul nsw i32 %609, %610
%612 = add nsw i32 %606, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds double, double* %604, i64 %613
%615 = load double, double* %614
br label %616
616: ; preds = %603, %590
%617 = phi double [ %602, %590 ], [ %615, %603 ]
%618 = load i32, i32* %12
%619 = icmp ne i32 %618, 0
br i1 %619, label %620, label %633
620: ; preds = %616
%621 = load double*, double** %9
%622 = load i32, i32* %16
%623 = sub nsw i32 %622, 3
%624 = sub nsw i32 %623, 1
%625 = load i32, i32* %11
%626 = sub nsw i32 %625, 1
%627 = load i32, i32* %13
%628 = mul nsw i32 %626, %627
%629 = add nsw i32 %624, %628
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds double, double* %621, i64 %630
%632 = load double, double* %631
br label %646
633: ; preds = %616
%634 = load double*, double** %9
%635 = load i32, i32* %11
%636 = sub nsw i32 %635, 1
%637 = load i32, i32* %16
%638 = sub nsw i32 %637, 3
%639 = sub nsw i32 %638, 1
%640 = load i32, i32* %14
%641 = mul nsw i32 %639, %640
%642 = add nsw i32 %636, %641
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %634, i64 %643
%645 = load double, double* %644
br label %646
646: ; preds = %633, %620
%647 = phi double [ %632, %620 ], [ %645, %633 ]
%648 = fsub double %617, %647
%649 = load i32, i32* %12
%650 = icmp ne i32 %649, 0
br i1 %650, label %651, label %662
651: ; preds = %646
%652 = load double*, double** %9
%653 = load i32, i32* %16
%654 = sub nsw i32 %653, 2
%655 = sub nsw i32 %654, 1
%656 = load i32, i32* %13
%657 = mul nsw i32 0, %656
%658 = add nsw i32 %655, %657
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %652, i64 %659
%661 = load double, double* %660
br label %673
662: ; preds = %646
%663 = load double*, double** %9
%664 = load i32, i32* %16
%665 = sub nsw i32 %664, 2
%666 = sub nsw i32 %665, 1
%667 = load i32, i32* %14
%668 = mul nsw i32 %666, %667
%669 = add nsw i32 0, %668
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %663, i64 %670
%672 = load double, double* %671
br label %673
673: ; preds = %662, %651
%674 = phi double [ %661, %651 ], [ %672, %662 ]
%675 = load i32, i32* %12
%676 = icmp ne i32 %675, 0
br i1 %676, label %677, label %688
677: ; preds = %673
%678 = load double*, double** %9
%679 = load i32, i32* %16
%680 = sub nsw i32 %679, 3
%681 = sub nsw i32 %680, 1
%682 = load i32, i32* %13
%683 = mul nsw i32 0, %682
%684 = add nsw i32 %681, %683
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds double, double* %678, i64 %685
%687 = load double, double* %686
br label %699
688: ; preds = %673
%689 = load double*, double** %9
%690 = load i32, i32* %16
%691 = sub nsw i32 %690, 3
%692 = sub nsw i32 %691, 1
%693 = load i32, i32* %14
%694 = mul nsw i32 %692, %693
%695 = add nsw i32 0, %694
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds double, double* %689, i64 %696
%698 = load double, double* %697
br label %699
699: ; preds = %688, %677
%700 = phi double [ %687, %677 ], [ %698, %688 ]
%701 = fsub double %674, %700
%702 = fdiv double %648, %701
store double %702, double* %17
br label %709
703: ; preds = %584
%704 = load double, double* %18
%705 = load double, double* %18
%706 = fadd double %704, %705
%707 = load double, double* %19
%708 = fsub double %706, %707
store double %708, double* %17
br label %709
709: ; preds = %703, %699
%710 = load i32, i32* %16
%711 = load i32, i32* %15
%712 = sub nsw i32 %711, 1
%713 = icmp slt i32 %710, %712
br i1 %713, label %714, label %830
714: ; preds = %709
%715 = load i32, i32* %12
%716 = icmp ne i32 %715, 0
br i1 %716, label %717, label %730
717: ; preds = %714
%718 = load double*, double** %9
%719 = load i32, i32* %16
%720 = add nsw i32 %719, 2
%721 = sub nsw i32 %720, 1
%722 = load i32, i32* %11
%723 = sub nsw i32 %722, 1
%724 = load i32, i32* %13
%725 = mul nsw i32 %723, %724
%726 = add nsw i32 %721, %725
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds double, double* %718, i64 %727
%729 = load double, double* %728
br label %743
730: ; preds = %714
%731 = load double*, double** %9
%732 = load i32, i32* %11
%733 = sub nsw i32 %732, 1
%734 = load i32, i32* %16
%735 = add nsw i32 %734, 2
%736 = sub nsw i32 %735, 1
%737 = load i32, i32* %14
%738 = mul nsw i32 %736, %737
%739 = add nsw i32 %733, %738
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %731, i64 %740
%742 = load double, double* %741
br label %743
743: ; preds = %730, %717
%744 = phi double [ %729, %717 ], [ %742, %730 ]
%745 = load i32, i32* %12
%746 = icmp ne i32 %745, 0
br i1 %746, label %747, label %760
747: ; preds = %743
%748 = load double*, double** %9
%749 = load i32, i32* %16
%750 = add nsw i32 %749, 1
%751 = sub nsw i32 %750, 1
%752 = load i32, i32* %11
%753 = sub nsw i32 %752, 1
%754 = load i32, i32* %13
%755 = mul nsw i32 %753, %754
%756 = add nsw i32 %751, %755
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds double, double* %748, i64 %757
%759 = load double, double* %758
br label %773
760: ; preds = %743
%761 = load double*, double** %9
%762 = load i32, i32* %11
%763 = sub nsw i32 %762, 1
%764 = load i32, i32* %16
%765 = add nsw i32 %764, 1
%766 = sub nsw i32 %765, 1
%767 = load i32, i32* %14
%768 = mul nsw i32 %766, %767
%769 = add nsw i32 %763, %768
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %761, i64 %770
%772 = load double, double* %771
br label %773
773: ; preds = %760, %747
%774 = phi double [ %759, %747 ], [ %772, %760 ]
%775 = fsub double %744, %774
%776 = load i32, i32* %12
%777 = icmp ne i32 %776, 0
br i1 %777, label %778, label %789
778: ; preds = %773
%779 = load double*, double** %9
%780 = load i32, i32* %16
%781 = add nsw i32 %780, 2
%782 = sub nsw i32 %781, 1
%783 = load i32, i32* %13
%784 = mul nsw i32 0, %783
%785 = add nsw i32 %782, %784
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds double, double* %779, i64 %786
%788 = load double, double* %787
br label %800
789: ; preds = %773
%790 = load double*, double** %9
%791 = load i32, i32* %16
%792 = add nsw i32 %791, 2
%793 = sub nsw i32 %792, 1
%794 = load i32, i32* %14
%795 = mul nsw i32 %793, %794
%796 = add nsw i32 0, %795
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds double, double* %790, i64 %797
%799 = load double, double* %798
br label %800
800: ; preds = %789, %778
%801 = phi double [ %788, %778 ], [ %799, %789 ]
%802 = load i32, i32* %12
%803 = icmp ne i32 %802, 0
br i1 %803, label %804, label %815
804: ; preds = %800
%805 = load double*, double** %9
%806 = load i32, i32* %16
%807 = add nsw i32 %806, 1
%808 = sub nsw i32 %807, 1
%809 = load i32, i32* %13
%810 = mul nsw i32 0, %809
%811 = add nsw i32 %808, %810
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double, double* %805, i64 %812
%814 = load double, double* %813
br label %826
815: ; preds = %800
%816 = load double*, double** %9
%817 = load i32, i32* %16
%818 = add nsw i32 %817, 1
%819 = sub nsw i32 %818, 1
%820 = load i32, i32* %14
%821 = mul nsw i32 %819, %820
%822 = add nsw i32 0, %821
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds double, double* %816, i64 %823
%825 = load double, double* %824
br label %826
826: ; preds = %815, %804
%827 = phi double [ %814, %804 ], [ %825, %815 ]
%828 = fsub double %801, %827
%829 = fdiv double %775, %828
store double %829, double* %21
br label %836
830: ; preds = %709
%831 = load double, double* %20
%832 = load double, double* %20
%833 = fadd double %831, %832
%834 = load double, double* %19
%835 = fsub double %833, %834
store double %835, double* %21
br label %836
836: ; preds = %830, %826
%837 = load i32, i32* %10
%838 = load i32, i32* %15
%839 = add nsw i32 %838, 1
%840 = icmp slt i32 %837, %839
br i1 %840, label %841, label %982
841: ; preds = %836
%842 = load double, double* %20
%843 = load double, double* %19
%844 = fsub double %842, %843
%845 = call double @llvm.fabs.f64(double %844)
store double %845, double* %27
%846 = load double, double* %18
%847 = load double, double* %17
%848 = fsub double %846, %847
%849 = call double @llvm.fabs.f64(double %848)
store double %849, double* %28
%850 = load double, double* %27
%851 = load double, double* %28
%852 = fadd double %850, %851
store double %852, double* %29
%853 = load double, double* %29
%854 = fcmp oeq double %853, 0.000000e+00
br i1 %854, label %855, label %856
855: ; preds = %841
store double 5.000000e-01, double* %27
store double 5.000000e-01, double* %28
store double 1.000000e+00, double* %29
br label %856
856: ; preds = %855, %841
%857 = load double, double* %27
%858 = load double, double* %18
%859 = load double, double* %28
%860 = load double, double* %19
%861 = fmul double %859, %860
%862 = call double @llvm.fmuladd.f64(double %857, double %858, double %861)
%863 = load double, double* %29
%864 = fdiv double %862, %863
store double %864, double* %22
%865 = load i32, i32* %10
%866 = icmp sgt i32 %865, 1
br i1 %866, label %867, label %891
867: ; preds = %856
%868 = load double, double* %21
%869 = load double, double* %20
%870 = fsub double %868, %869
%871 = call double @llvm.fabs.f64(double %870)
store double %871, double* %27
%872 = load double, double* %19
%873 = load double, double* %18
%874 = fsub double %872, %873
%875 = call double @llvm.fabs.f64(double %874)
store double %875, double* %28
%876 = load double, double* %27
%877 = load double, double* %28
%878 = fadd double %876, %877
store double %878, double* %29
%879 = load double, double* %29
%880 = fcmp oeq double %879, 0.000000e+00
br i1 %880, label %881, label %882
881: ; preds = %867
store double 5.000000e-01, double* %27
store double 5.000000e-01, double* %28
store double 1.000000e+00, double* %29
br label %882
882: ; preds = %881, %867
%883 = load double, double* %27
%884 = load double, double* %19
%885 = load double, double* %28
%886 = load double, double* %20
%887 = fmul double %885, %886
%888 = call double @llvm.fmuladd.f64(double %883, double %884, double %887)
%889 = load double, double* %29
%890 = fdiv double %888, %889
store double %890, double* %23
br label %981
891: ; preds = %856
%892 = load double, double* %22
store double %892, double* %23
%893 = load double, double* %17
%894 = load double, double* %18
%895 = fadd double %893, %894
%896 = load double, double* %26
%897 = load double, double* %25
%898 = load double, double* %26
%899 = fsub double %897, %898
%900 = fmul double %896, %899
%901 = load double, double* %19
%902 = load double, double* %20
%903 = fsub double %901, %902
%904 = fmul double %900, %903
%905 = load double, double* %25
%906 = load double, double* %26
%907 = fadd double %905, %906
%908 = load double, double* %25
%909 = load double, double* %26
%910 = fadd double %908, %909
%911 = fmul double %907, %910
%912 = fdiv double %904, %911
%913 = fsub double %895, %912
%914 = fmul double 5.000000e-01, %913
store double %914, double* %22
%915 = load i32, i32* %12
%916 = icmp ne i32 %915, 0
br i1 %916, label %917, label %928
917: ; preds = %891
%918 = load double*, double** %9
%919 = load i32, i32* %16
%920 = sub nsw i32 %919, 1
%921 = sub nsw i32 %920, 1
%922 = load i32, i32* %13
%923 = mul nsw i32 0, %922
%924 = add nsw i32 %921, %923
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds double, double* %918, i64 %925
%927 = load double, double* %926
br label %939
928: ; preds = %891
%929 = load double*, double** %9
%930 = load i32, i32* %16
%931 = sub nsw i32 %930, 1
%932 = sub nsw i32 %931, 1
%933 = load i32, i32* %14
%934 = mul nsw i32 %932, %933
%935 = add nsw i32 0, %934
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %929, i64 %936
%938 = load double, double* %937
br label %939
939: ; preds = %928, %917
%940 = phi double [ %927, %917 ], [ %938, %928 ]
%941 = load double, double* %26
%942 = fsub double %940, %941
store double %942, double* %30
%943 = load i32, i32* %12
%944 = icmp ne i32 %943, 0
br i1 %944, label %945, label %958
945: ; preds = %939
%946 = load double*, double** %9
%947 = load i32, i32* %16
%948 = sub nsw i32 %947, 1
%949 = sub nsw i32 %948, 1
%950 = load i32, i32* %11
%951 = sub nsw i32 %950, 1
%952 = load i32, i32* %13
%953 = mul nsw i32 %951, %952
%954 = add nsw i32 %949, %953
%955 = sext i32 %954 to i64
%956 = getelementptr inbounds double, double* %946, i64 %955
%957 = load double, double* %956
br label %971
958: ; preds = %939
%959 = load double*, double** %9
%960 = load i32, i32* %11
%961 = sub nsw i32 %960, 1
%962 = load i32, i32* %16
%963 = sub nsw i32 %962, 1
%964 = sub nsw i32 %963, 1
%965 = load i32, i32* %14
%966 = mul nsw i32 %964, %965
%967 = add nsw i32 %961, %966
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds double, double* %959, i64 %968
%970 = load double, double* %969
br label %971
971: ; preds = %958, %945
%972 = phi double [ %957, %945 ], [ %970, %958 ]
%973 = load double, double* %18
%974 = load double, double* %26
%975 = fneg double %973
%976 = call double @llvm.fmuladd.f64(double %975, double %974, double %972)
%977 = load double*, double** %8
%978 = getelementptr inbounds double, double* %977, i64 0
store double %976, double* %978
%979 = load double, double* %26
store double %979, double* %25
%980 = load double, double* %18
store double %980, double* %19
br label %981
981: ; preds = %971, %882
br label %1085
982: ; preds = %836
%983 = load double, double* %21
%984 = load double, double* %20
%985 = fsub double %983, %984
%986 = call double @llvm.fabs.f64(double %985)
store double %986, double* %27
%987 = load double, double* %19
%988 = load double, double* %18
%989 = fsub double %987, %988
%990 = call double @llvm.fabs.f64(double %989)
store double %990, double* %28
%991 = load double, double* %27
%992 = load double, double* %28
%993 = fadd double %991, %992
store double %993, double* %29
%994 = load double, double* %29
%995 = fcmp oeq double %994, 0.000000e+00
br i1 %995, label %996, label %997
996: ; preds = %982
store double 5.000000e-01, double* %27
store double 5.000000e-01, double* %28
store double 1.000000e+00, double* %29
br label %997
997: ; preds = %996, %982
%998 = load double, double* %27
%999 = load double, double* %19
%1000 = load double, double* %28
%1001 = load double, double* %20
%1002 = fmul double %1000, %1001
%1003 = call double @llvm.fmuladd.f64(double %998, double %999, double %1002)
%1004 = load double, double* %29
%1005 = fdiv double %1003, %1004
store double %1005, double* %23
%1006 = load double, double* %23
store double %1006, double* %22
%1007 = load double, double* %20
%1008 = load double, double* %21
%1009 = fadd double %1007, %1008
%1010 = load double, double* %24
%1011 = load double, double* %24
%1012 = load double, double* %25
%1013 = fsub double %1011, %1012
%1014 = fmul double %1010, %1013
%1015 = load double, double* %18
%1016 = load double, double* %19
%1017 = fsub double %1015, %1016
%1018 = fmul double %1014, %1017
%1019 = load double, double* %24
%1020 = load double, double* %25
%1021 = fadd double %1019, %1020
%1022 = load double, double* %24
%1023 = load double, double* %25
%1024 = fadd double %1022, %1023
%1025 = fmul double %1021, %1024
%1026 = fdiv double %1018, %1025
%1027 = fsub double %1009, %1026
%1028 = fmul double 5.000000e-01, %1027
store double %1028, double* %23
%1029 = load i32, i32* %12
%1030 = icmp ne i32 %1029, 0
br i1 %1030, label %1031, label %1041
1031: ; preds = %997
%1032 = load double*, double** %9
%1033 = load i32, i32* %16
%1034 = sub nsw i32 %1033, 1
%1035 = load i32, i32* %13
%1036 = mul nsw i32 0, %1035
%1037 = add nsw i32 %1034, %1036
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds double, double* %1032, i64 %1038
%1040 = load double, double* %1039
br label %1051
1041: ; preds = %997
%1042 = load double*, double** %9
%1043 = load i32, i32* %16
%1044 = sub nsw i32 %1043, 1
%1045 = load i32, i32* %14
%1046 = mul nsw i32 %1044, %1045
%1047 = add nsw i32 0, %1046
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1042, i64 %1048
%1050 = load double, double* %1049
br label %1051
1051: ; preds = %1041, %1031
%1052 = phi double [ %1040, %1031 ], [ %1050, %1041 ]
store double %1052, double* %30
%1053 = load i32, i32* %12
%1054 = icmp ne i32 %1053, 0
br i1 %1054, label %1055, label %1067
1055: ; preds = %1051
%1056 = load double*, double** %9
%1057 = load i32, i32* %16
%1058 = sub nsw i32 %1057, 1
%1059 = load i32, i32* %11
%1060 = sub nsw i32 %1059, 1
%1061 = load i32, i32* %13
%1062 = mul nsw i32 %1060, %1061
%1063 = add nsw i32 %1058, %1062
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds double, double* %1056, i64 %1064
%1066 = load double, double* %1065
br label %1079
1067: ; preds = %1051
%1068 = load double*, double** %9
%1069 = load i32, i32* %11
%1070 = sub nsw i32 %1069, 1
%1071 = load i32, i32* %16
%1072 = sub nsw i32 %1071, 1
%1073 = load i32, i32* %14
%1074 = mul nsw i32 %1072, %1073
%1075 = add nsw i32 %1070, %1074
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1068, i64 %1076
%1078 = load double, double* %1077
br label %1079
1079: ; preds = %1067, %1055
%1080 = phi double [ %1066, %1055 ], [ %1078, %1067 ]
%1081 = load double*, double** %8
%1082 = getelementptr inbounds double, double* %1081, i64 0
store double %1080, double* %1082
%1083 = load double, double* %20
store double %1083, double* %19
%1084 = load double, double* %24
store double %1084, double* %25
br label %1085
1085: ; preds = %1079, %981
%1086 = load double, double* %22
%1087 = load double*, double** %8
%1088 = getelementptr inbounds double, double* %1087, i64 1
store double %1086, double* %1088
%1089 = load double, double* %19
%1090 = load double, double* %22
%1091 = fsub double %1089, %1090
%1092 = load double, double* %19
%1093 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %1091, double %1092)
%1094 = load double, double* %23
%1095 = fsub double %1093, %1094
%1096 = load double, double* %25
%1097 = fdiv double %1095, %1096
%1098 = load double*, double** %8
%1099 = getelementptr inbounds double, double* %1098, i64 2
store double %1097, double* %1099
%1100 = load double, double* %19
%1101 = fneg double %1100
%1102 = load double, double* %19
%1103 = fsub double %1101, %1102
%1104 = load double, double* %22
%1105 = fadd double %1103, %1104
%1106 = load double, double* %23
%1107 = fadd double %1105, %1106
%1108 = load double, double* %25
%1109 = load double, double* %25
%1110 = fmul double %1108, %1109
%1111 = fdiv double %1107, %1110
%1112 = load double*, double** %8
%1113 = getelementptr inbounds double, double* %1112, i64 3
store double %1111, double* %1113
%1114 = load double, double* %30
ret double %1114
}

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