void f_iir_tline_filter(double *src, double *dest, int sx, int sy,
                        double *filter, double tanp) {
  double *p0, *p1, *p2, *p3;
  double *buf0, *buf1, *buf2, *buf3;
  double *uplusbuf;
  int i, j;
  double b1, b2, b3;
  double sum, sumsq;
  double uplus, vplus;
  double unp, unp1, unp2;
  double M[9];
  double pix, prev, val;
  double res, prevres;
  double xf;
  int x;
  double c, d;
  double e, f;
  int q4 = 0;
  if (tanp <= 0.0) {
    q4 = 1;
    tanp = -tanp;
  }
  uplusbuf = malloc(sx * sizeof(*uplusbuf));
  buf0 = malloc((sx + sy * tanp + 2) * sizeof(*buf0));
  buf1 = malloc((sx + sy * tanp + 2) * sizeof(*buf1));
  buf2 = malloc((sx + sy * tanp + 2) * sizeof(*buf2));
  buf3 = malloc((sx + sy * tanp + 2) * sizeof(*buf3));
  if (q4) {
    buf0 += (int)(sy * tanp + 1);
    buf1 += (int)(sy * tanp + 1);
    buf2 += (int)(sy * tanp + 1);
    buf3 += (int)(sy * tanp + 1);
  }
  sumsq = filter[3];
  sum = sumsq * sumsq;
  b1 = filter[2];
  b2 = filter[1];
  b3 = filter[0];
  p1 = buf1;
  p2 = buf2;
  p3 = buf3;
  for (j = 0; j < sx; j++) {
    pix = *src++;
    *dest++ = pix;
    *p1++ = pix;
    *p2++ = pix;
    *p3++ = pix;
  }
  src += (sy - 2) * sx;
  for (j = 0; j < sx; j++)
    uplusbuf[j] = *src++ * sumsq / (1.0 - b1 - b2 - b3);
  src -= (sy - 1) * sx;
  x = 0;
  for (i = 1; i < sy; i++) {
    xf = i * tanp;
    if (q4) {
      p1 = buf1 - x;
      p2 = buf2 - x;
      p3 = buf3 - x;
      for (j = 1; j <= (int)(xf)-x; j++) {
        p1[-j] = p1[0];
        p2[-j] = p2[0];
        p3[-j] = p3[0];
      }
    } else {
      p1 = buf1 + x;
      p2 = buf2 + x;
      p3 = buf3 + x;
      for (j = 1; j <= (int)(xf)-x; j++) {
        p1[sx + j - 1] = p1[sx - 1];
        p2[sx + j - 1] = p2[sx - 1];
        p3[sx + j - 1] = p3[sx - 1];
      }
    }
    x = (int)xf;
    c = xf - (double)x;
    d = 1.0 - c;
    e = c;
    f = d;
    if (!q4) {
      res = d;
      d = c;
      c = res;
      res = f;
      f = e;
      e = res;
    }
    c *= sumsq;
    d *= sumsq;
    if (q4) {
      p0 = buf0 - x;
      p1 = buf1 - x;
      p2 = buf2 - x;
      p3 = buf3 - x;
    } else {
      p0 = buf0 + x;
      p1 = buf1 + x;
      p2 = buf2 + x;
      p3 = buf3 + x;
    }
    prev = *src;
    prevres = sumsq * prev + b1 * *p1 + b2 * *p2 + b3 * *p3;
    for (j = 0; j < sx; j++) {
      pix = *src++;
      val = c * pix + d * prev;
      prev = pix;
      res = val + b1 * *p1++ + b2 * *p2++ + b3 * *p3++;
      *p0++ = res;
      *dest++ = f * res + e * prevres;
      prevres = res;
    }
    p0 = buf3;
    buf3 = buf2;
    buf2 = buf1;
    buf1 = buf0;
    buf0 = p0;
  }
  b1 = filter[4];
  b2 = filter[5];
  b3 = filter[6];
  TriggsM(filter, M);
  x = (int)((sy - 1) * tanp);
  if (q4) {
    p1 = buf1 + sx - x;
    p2 = buf2 + sx - x;
    p3 = buf3 + sx - x;
  } else {
    p1 = buf1 + sx + x;
    p2 = buf2 + sx + x;
    p3 = buf3 + sx + x;
  }
  p0 = uplusbuf + sx;
  for (j = 0; j < sx; j++) {
    uplus = *(--p0);
    vplus = uplus / (1.0 - b1 - b2 - b3);
    unp = *(--p1) - uplus;
    unp1 = *(--p2) - uplus;
    unp2 = *(--p3) - uplus;
    pix = M[0] * unp + M[1] * unp1 + M[2] * unp2 + vplus;
    pix *= sumsq;
    *(--dest) = pix;
    *p1 = pix;
    pix = M[3] * unp + M[4] * unp1 + M[5] * unp2 + vplus;
    *p2 = pix * sumsq;
    pix = M[6] * unp + M[7] * unp1 + M[8] * unp2 + vplus;
    *p3 = pix * sumsq;
  }
  for (i = sy - 2; i >= 0; i--) {
    xf = i * tanp;
    if (q4) {
      p1 = buf1 - x;
      p2 = buf2 - x;
      p3 = buf3 - x;
      for (j = 1; j <= x - (int)(xf); j++) {
        p1[sx + j - 1] = p1[sx - 1];
        p2[sx + j - 1] = p2[sx - 1];
        p3[sx + j - 1] = p3[sx - 1];
      }
    } else {
      p1 = buf1 + x;
      p2 = buf2 + x;
      p3 = buf3 + x;
      for (j = 1; j <= x - (int)(xf); j++) {
        p1[-j] = p1[0];
        p2[-j] = p2[0];
        p3[-j] = p3[0];
      }
    }
    x = (int)xf;
    c = xf - (double)x;
    d = 1.0 - c;
    e = c;
    f = d;
    c *= sumsq;
    d *= sumsq;
    if (!q4) {
      res = d;
      d = c;
      c = res;
      res = f;
      f = e;
      e = res;
    }
    if (q4) {
      p0 = buf0 + sx - x;
      p1 = buf1 + sx - x;
      p2 = buf2 + sx - x;
      p3 = buf3 + sx - x;
    } else {
      p0 = buf0 + sx + x;
      p1 = buf1 + sx + x;
      p2 = buf2 + sx + x;
      p3 = buf3 + sx + x;
    }
    prev = *(dest - 1);
    prevres = sumsq * prev + b1 * *(p1 - 1) + b2 * *(p2 - 1) + b3 * *(p3 - 1);
    for (j = 0; j < sx; j++) {
      pix = *(--dest);
      val = d * pix + c * prev;
      prev = pix;
      res = val + b1 * *(--p1) + b2 * *(--p2) + b3 * *(--p3);
      *(--p0) = res;
      *dest = e * res + f * prevres;
      prevres = res;
    }
    p0 = buf3;
    buf3 = buf2;
    buf2 = buf1;
    buf1 = buf0;
    buf0 = p0;
  }
  if (q4) {
    buf0 -= (int)(sy * tanp + 1);
    buf1 -= (int)(sy * tanp + 1);
    buf2 -= (int)(sy * tanp + 1);
    buf3 -= (int)(sy * tanp + 1);
  }
  free(buf0);
  free(buf1);
  free(buf2);
  free(buf3);
  free(uplusbuf);
}


x86 assembly (clang, -O0):
<f_iir_tline_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x16c(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x28(%rbp),%xmm0
jb     1195 <f_iir_tline_filter+0x65>
movl   $0x1,-0x16c(%rbp)
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1e3b(%rip),%xmm1
movsd  %xmm1,-0x188(%rbp)
ff
addsd  %xmm1,%xmm0
movsd  0x1e2f(%rip),%xmm1
movsd  %xmm1,-0x180(%rbp)
ff
mulsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
movsd  0x1e14(%rip),%xmm1
movsd  %xmm1,-0x178(%rbp)
ff
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1050 <malloc@plt>
movsd  -0x188(%rbp),%xmm3
ff
movsd  -0x180(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm1
ff
mov    %rax,-0x50(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm4
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm5
mulsd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm0
movaps %xmm0,%xmm2
cvttsd2si %xmm2,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1050 <malloc@plt>
movsd  -0x188(%rbp),%xmm3
ff
movsd  -0x180(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm1
ff
mov    %rax,-0x58(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm4
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm5
mulsd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm0
movaps %xmm0,%xmm2
cvttsd2si %xmm2,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1050 <malloc@plt>
movsd  -0x188(%rbp),%xmm3
ff
movsd  -0x180(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm1
ff
mov    %rax,-0x60(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm4
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm5
mulsd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm0
movaps %xmm0,%xmm2
cvttsd2si %xmm2,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpl   $0x0,-0x16c(%rbp)
je     1403 <f_iir_tline_filter+0x2d3>
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1cbf(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1c8f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1c5f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1c2f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    151b <f_iir_tline_filter+0x3eb>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    147a <f_iir_tline_filter+0x34a>
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a1 <f_iir_tline_filter+0x471>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x1aab(%rip),%xmm1
subsd  -0x80(%rbp),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
subsd  -0x90(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    153e <f_iir_tline_filter+0x40e>
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x144(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b87 <f_iir_tline_filter+0xa57>
cvtsi2sdl -0x74(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
je     16cd <f_iir_tline_filter+0x59d>
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cvttsd2si -0x140(%rbp),%ecx
ff
sub    -0x144(%rbp),%ecx
cmp    %ecx,%eax
jg     16c8 <f_iir_tline_filter+0x598>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1656 <f_iir_tline_filter+0x526>
jmp    17b7 <f_iir_tline_filter+0x687>
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cvttsd2si -0x140(%rbp),%ecx
ff
sub    -0x144(%rbp),%ecx
cmp    %ecx,%eax
jg     17b2 <f_iir_tline_filter+0x682>
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1716 <f_iir_tline_filter+0x5e6>
jmp    17b7 <f_iir_tline_filter+0x687>
cvttsd2si -0x140(%rbp),%eax
ff
mov    %eax,-0x144(%rbp)
movsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdl -0x144(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x182f(%rip),%xmm0
subsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
jne    1886 <f_iir_tline_filter+0x756>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
je     1934 <f_iir_tline_filter+0x804>
mov    -0x50(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    198c <f_iir_tline_filter+0x85c>
mov    -0x50(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mov    -0x38(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b51 <f_iir_tline_filter+0xa21>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x158(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x160(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1a00 <f_iir_tline_filter+0x8d0>
mov    -0x68(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    15d3 <f_iir_tline_filter+0x4a3>
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0x110(%rbp),%rsi
mov    $0x0,%al
call   1040 <TriggsM@plt>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0x0,-0x16c(%rbp)
je     1c66 <f_iir_tline_filter+0xb36>
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1cc9 <f_iir_tline_filter+0xb99>
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f1a <f_iir_tline_filter+0xdea>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x30(%rbp)
movsd  -0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x12fd(%rip),%xmm1
subsd  -0x80(%rbp),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
subsd  -0x90(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  -0x8(%rax),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  -0x8(%rax),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  -0x8(%rax),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  %xmm0,-0x8(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1ce3 <f_iir_tline_filter+0xbb3>
mov    -0x18(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jl     252f <f_iir_tline_filter+0x13ff>
cvtsi2sdl -0x74(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
je     2047 <f_iir_tline_filter+0xf17>
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x144(%rbp),%ecx
cvttsd2si -0x140(%rbp),%edx
ff
sub    %edx,%ecx
cmp    %ecx,%eax
jg     2042 <f_iir_tline_filter+0xf12>
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1fa4 <f_iir_tline_filter+0xe74>
jmp    2109 <f_iir_tline_filter+0xfd9>
mov    -0x58(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x144(%rbp),%ecx
cvttsd2si -0x140(%rbp),%edx
ff
sub    %edx,%ecx
cmp    %ecx,%eax
jg     2104 <f_iir_tline_filter+0xfd4>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    2090 <f_iir_tline_filter+0xf60>
jmp    2109 <f_iir_tline_filter+0xfd9>
cvttsd2si -0x140(%rbp),%eax
ff
mov    %eax,-0x144(%rbp)
movsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdl -0x144(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0xedd(%rip),%xmm0
subsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
jne    2208 <f_iir_tline_filter+0x10d8>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
cmpl   $0x0,-0x16c(%rbp)
je     22b2 <f_iir_tline_filter+0x1182>
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    2336 <f_iir_tline_filter+0x1206>
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  -0x8(%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mov    -0x38(%rbp),%rax
mulsd  -0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x40(%rbp),%rax
movsd  -0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  -0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    24f9 <f_iir_tline_filter+0x13c9>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  -0x8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x150(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  -0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  -0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  -0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x30(%rbp)
movsd  %xmm0,-0x8(%rax)
movsd  -0x160(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x168(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    23ae <f_iir_tline_filter+0x127e>
mov    -0x68(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    1f23 <f_iir_tline_filter+0xdf3>
cmpl   $0x0,-0x16c(%rbp)
je     2610 <f_iir_tline_filter+0x14e0>
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xac6(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa91(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa5c(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa27(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<f_iir_tline_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
movapd %xmm0,0x90(%rsp)
mov    %r8,0x38(%rsp)
mov    %ecx,%ebp
mov    %rsi,%r13
mov    %rdi,%r14
movapd 0x1ea1(%rip),%xmm2
xorpd  %xmm0,%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm3
cmpnlesd %xmm1,%xmm3
movapd %xmm3,%xmm1
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm3,0x50(%rsp)
mov    %rdx,0x18(%rsp)
movslq %edx,%rbx
lea    0x0(,%rbx,8),%rdi
call   1050 <malloc@plt>
mov    %rbx,0x30(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mov    %rbp,0x28(%rsp)
xorps  %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
movsd  %xmm2,0x48(%rsp)
movapd 0x50(%rsp),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  0x1e41(%rip),%xmm1
mulsd  0x1e41(%rip),%xmm1
cvttsd2si %xmm1,%rcx
mov    %rax,0x80(%rsp)
mov    %rcx,%rax
sar    $0x3f,%rax
subsd  0x1e2d(%rip),%xmm1
cvttsd2si %xmm1,%r15
and    %rax,%r15
or     %rcx,%r15
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r15,%rdi
call   1050 <malloc@plt>
movapd 0x90(%rsp),%xmm5
xorpd  %xmm0,%xmm0
ucomisd %xmm5,%xmm0
movsd  0x48(%rsp),%xmm0
jae    124b <f_iir_tline_filter+0x11b>
movapd 0x50(%rsp),%xmm4
mov    %rbx,%rdi
jmp    1275 <f_iir_tline_filter+0x145>
movapd 0x50(%rsp),%xmm4
mulsd  %xmm4,%xmm0
addsd  0x1dcb(%rip),%xmm0
cvttsd2si %xmm0,%ecx
movslq %ecx,%rcx
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%r12,%rcx,8),%r12
lea    (%rbx,%rcx,8),%rdi
lea    (%rax,%rcx,8),%rax
mov    0x38(%rsp),%rcx
movsd  0x18(%rcx),%xmm0
movapd %xmm0,0x60(%rsp)
movsd  0x10(%rcx),%xmm11
movsd  (%rcx),%xmm12
movsd  0x8(%rcx),%xmm8
mov    0x18(%rsp),%rbx
test   %ebx,%ebx
mov    0x80(%rsp),%r9
mov    0x28(%rsp),%r11
jle    140b <f_iir_tline_filter+0x2db>
lea    -0x1(%rbx),%edx
xor    %ecx,%ecx
cmp    $0x3,%edx
mov    %rbp,%r15
mov    %r12,0x10(%rsp)
jb     12ec <f_iir_tline_filter+0x1bc>
lea    (%r14,%rdx,8),%rsi
add    $0x8,%rsi
cmp    %r13,%rsi
jbe    1423 <f_iir_tline_filter+0x2f3>
lea    0x8(,%rdx,8),%rsi
add    %r13,%rsi
cmp    %r14,%rsi
jbe    1423 <f_iir_tline_filter+0x2f3>
mov    0x10(%rsp),%r12
mov    %rdi,%r10
mov    %rdi,%rsi
mov    %rax,%rdi
mov    0x18(%rsp),%rbx
mov    %ebx,%ebp
sub    %ecx,%ebp
mov    %ecx,%r8d
not    %r8d
add    %ebx,%r8d
test   $0x3,%bpl
je     1357 <f_iir_tline_filter+0x227>
sub    %cl,%bl
movzbl %bl,%ebx
and    $0x3,%ebx
shl    $0x3,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,1),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,1)
movsd  %xmm0,(%r12,%rbp,1)
movsd  %xmm0,(%rsi,%rbp,1)
movsd  %xmm0,(%rdi,%rbp,1)
add    $0x1,%ecx
add    $0x8,%rbp
cmp    %ebp,%ebx
jne    1320 <f_iir_tline_filter+0x1f0>
add    %rbp,%r14
add    %rbp,%r13
add    %rbp,%r12
add    %rbp,%rsi
add    %rbp,%rdi
mov    %r15,%rbp
cmp    $0x3,%r8d
jb     1541 <f_iir_tline_filter+0x411>
mov    0x18(%rsp),%rbx
sub    %ecx,%ebx
xor    %ebp,%ebp
xor    %ecx,%ecx
nop
movsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
movsd  %xmm0,(%r12,%rbp,8)
movsd  %xmm0,(%rsi,%rbp,8)
movsd  %xmm0,(%rdi,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r13,%rbp,8)
movsd  %xmm0,0x8(%r12,%rbp,8)
movsd  %xmm0,0x8(%rsi,%rbp,8)
movsd  %xmm0,0x8(%rdi,%rbp,8)
movsd  0x10(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r13,%rbp,8)
movsd  %xmm0,0x10(%r12,%rbp,8)
movsd  %xmm0,0x10(%rsi,%rbp,8)
movsd  %xmm0,0x10(%rdi,%rbp,8)
movsd  0x18(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r13,%rbp,8)
movsd  %xmm0,0x18(%r12,%rbp,8)
movsd  %xmm0,0x18(%rsi,%rbp,8)
movsd  %xmm0,0x18(%rdi,%rbp,8)
add    $0xffffffffffffffe0,%rcx
add    $0x4,%rbp
cmp    %ebp,%ebx
jne    1370 <f_iir_tline_filter+0x240>
sub    %rcx,%r14
sub    %rcx,%r13
jmp    153e <f_iir_tline_filter+0x40e>
lea    -0x2(%r11),%ecx
mov    %rcx,0x78(%rsp)
imul   %ebx,%ecx
movslq %ecx,%rcx
lea    (%r14,%rcx,8),%r8
jmp    1624 <f_iir_tline_filter+0x4f4>
add    $0x1,%rdx
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     22f4 <f_iir_tline_filter+0x11c4>
mov    %rdi,%r10
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movups (%r14,%rsi,8),%xmm0
movups 0x10(%r14,%rsi,8),%xmm1
movups %xmm0,0x0(%r13,%rsi,8)
movups %xmm1,0x10(%r13,%rsi,8)
movups %xmm0,(%rbx,%rsi,8)
movups %xmm1,0x10(%rbx,%rsi,8)
movups %xmm0,(%r10,%rsi,8)
movups %xmm1,0x10(%r10,%rsi,8)
movups %xmm0,(%rax,%rsi,8)
movups %xmm1,0x10(%rax,%rsi,8)
movupd 0x20(%r14,%rsi,8),%xmm0
movupd 0x30(%r14,%rsi,8),%xmm1
movupd %xmm0,0x20(%r13,%rsi,8)
movupd %xmm1,0x30(%r13,%rsi,8)
movupd %xmm0,0x20(%rbx,%rsi,8)
movupd %xmm1,0x30(%rbx,%rsi,8)
movupd %xmm0,0x20(%r10,%rsi,8)
movupd %xmm1,0x30(%r10,%rsi,8)
movupd %xmm0,0x20(%rax,%rsi,8)
movupd %xmm1,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1460 <f_iir_tline_filter+0x330>
test   $0x1,%bpl
je     152c <f_iir_tline_filter+0x3fc>
movupd (%r14,%rsi,8),%xmm0
movupd 0x10(%r14,%rsi,8),%xmm1
movupd %xmm0,0x0(%r13,%rsi,8)
movupd %xmm1,0x10(%r13,%rsi,8)
mov    0x10(%rsp),%rdi
movupd %xmm0,(%rdi,%rsi,8)
movupd %xmm1,0x10(%rdi,%rsi,8)
mov    %r10,%rdi
movupd %xmm0,(%r10,%rsi,8)
movupd %xmm1,0x10(%r10,%rsi,8)
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm1,0x10(%rax,%rsi,8)
lea    (%r14,%rcx,8),%r14
lea    0x0(%r13,%rcx,8),%r13
cmp    %rcx,%rdx
jne    22de <f_iir_tline_filter+0x11ae>
mov    %r15,%rbp
lea    -0x2(%r11),%ecx
mov    %rcx,0x78(%rsp)
mov    0x18(%rsp),%rbx
imul   %ebx,%ecx
movslq %ecx,%rdi
lea    (%r14,%rdi,8),%r8
test   %ebx,%ebx
jle    161c <f_iir_tline_filter+0x4ec>
movsd  0x1abf(%rip),%xmm3
subsd  %xmm11,%xmm3
subsd  %xmm8,%xmm3
subsd  %xmm12,%xmm3
mov    %ebx,%edx
cmp    $0x1,%ebx
je     159d <f_iir_tline_filter+0x46d>
lea    (%rdi,%rdx,1),%rcx
lea    (%r14,%rcx,8),%rcx
cmp    %rcx,%r9
jae    2223 <f_iir_tline_filter+0x10f3>
lea    (%r9,%rdx,8),%rcx
cmp    %r8,%rcx
jbe    2223 <f_iir_tline_filter+0x10f3>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
test   $0x1,%dl
mov    %r10,%rdi
je     15ca <f_iir_tline_filter+0x49a>
movsd  (%r8),%xmm0
mulsd  0x60(%rsp),%xmm0
add    $0x8,%r8
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r9,%rsi,8)
or     $0x1,%rsi
mov    0x18(%rsp),%rbx
add    %rdx,%rcx
je     1615 <f_iir_tline_filter+0x4e5>
movapd 0x60(%rsp),%xmm1
nopw   0x0(%rax,%rax,1)
movsd  (%r8),%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r9,%rsi,8)
movsd  0x8(%r8),%xmm0
mulsd  %xmm1,%xmm0
add    $0x10,%r8
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%r9,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    15e0 <f_iir_tline_filter+0x4b0>
mov    0x10(%rsp),%r12
jmp    1624 <f_iir_tline_filter+0x4f4>
mov    0x10(%rsp),%r12
mov    %r10,%rdi
lea    -0x1(%r11),%ecx
cmp    $0x2,%r11d
mov    %ecx,0x8c(%rsp)
jl     1aa7 <f_iir_tline_filter+0x977>
imul   %ebx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
sub    %rcx,%r8
lea    -0x1(%rbx),%ecx
mov    %ecx,0x40(%rsp)
movslq %ecx,%r14
mov    $0x1,%r10d
movsd  0x19ca(%rip),%xmm1
xor    %r11d,%r11d
xorpd  %xmm2,%xmm2
movapd %xmm1,%xmm3
jmp    16bf <f_iir_tline_filter+0x58f>
nopl   0x0(%rax,%rax,1)
add    %rcx,%r8
add    $0x8,%r8
lea    0x8(%r13,%rcx,1),%r13
movapd 0x90(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mov    %rsi,%rdx
mov    %r9,%rsi
movsd  0x198f(%rip),%xmm1
xorpd  %xmm2,%xmm2
movsd  0x8(%rsp),%xmm3
addsd  %xmm1,%xmm3
add    $0x1,%r10d
mov    %rdx,%rbp
mov    %rsi,%rax
mov    %r15,%rdi
cmp    0x28(%rsp),%r10d
je     1ab0 <f_iir_tline_filter+0x980>
mov    %r12,%r15
mov    %rdi,%rsi
mov    %rax,%rdx
ucomisd %xmm5,%xmm2
mulsd  %xmm3,%xmm4
movslq %r11d,%rbx
cvttsd2si %xmm4,%r9d
jae    17f0 <f_iir_tline_filter+0x6c0>
cmp    %r9d,%r11d
jge    1910 <f_iir_tline_filter+0x7e0>
mov    0x18(%rsp),%r12
mov    %rbp,0x10(%rsp)
lea    (%r15,%rbx,8),%rdi
mov    %rsi,0x20(%rsp)
lea    (%rsi,%rbx,8),%rax
mov    %rdx,0x8(%rsp)
lea    (%rdx,%rbx,8),%rbp
mov    %r9d,%edx
sub    %r11d,%edx
add    $0x1,%edx
lea    -0x1(%rdx),%r11
mov    $0x1,%ecx
cmp    $0x2,%edx
je     17a4 <f_iir_tline_filter+0x674>
mov    %r11,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
mov    %r12d,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%r14,8),%xmm0
movslq %ebx,%rbx
movsd  %xmm0,(%rdi,%rbx,8)
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rdi,%r14,8),%xmm0
lea    0x1(%rbx),%esi
movslq %esi,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x2,%ebx
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1740 <f_iir_tline_filter+0x610>
test   $0x1,%r11b
je     17d3 <f_iir_tline_filter+0x6a3>
movsd  (%rdi,%r14,8),%xmm0
add    %r14d,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %r9d,%r11d
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%rsi
jmp    1918 <f_iir_tline_filter+0x7e8>
nopw   0x0(%rax,%rax,1)
cmp    %r9d,%r11d
jge    1910 <f_iir_tline_filter+0x7e0>
mov    %rbp,0x10(%rsp)
lea    0x0(,%rbx,8),%rcx
mov    %rdx,%rbp
mov    %r15,%rdx
sub    %rcx,%rdx
mov    %rsi,%rax
sub    %rcx,%rax
mov    %rbp,0x8(%rsp)
sub    %rcx,%rbp
mov    %r9d,%edi
sub    %r11d,%edi
add    $0x1,%edi
lea    -0x1(%rdi),%r11
mov    $0x1,%ecx
cmp    $0x2,%edi
mov    0x18(%rsp),%r12
je     18cc <f_iir_tline_filter+0x79c>
neg    %rbx
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdi
add    $0xfffffffffffffff8,%rdi
lea    (%rsi,%rbx,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    (%r15,%rbx,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    %r11,0x20(%rsp)
and    $0xfffffffffffffffe,%r11
neg    %r11
xor    %r12d,%r12d
nopl   0x0(%rax)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rcx,%r12,8)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rdi,%r12,8)
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x8(%rbx,%r12,8)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x8(%rcx,%r12,8)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,-0x8(%rdi,%r12,8)
add    $0xfffffffffffffffe,%r12
cmp    %r12,%r11
jne    1870 <f_iir_tline_filter+0x740>
mov    $0x1,%ecx
sub    %r12,%rcx
mov    0x18(%rsp),%r12
mov    0x20(%rsp),%r11
test   $0x1,%r11b
je     18f9 <f_iir_tline_filter+0x7c9>
movsd  (%rdx),%xmm0
shl    $0x3,%rcx
sub    %rcx,%rdx
movsd  %xmm0,(%rdx)
movsd  (%rax),%xmm0
sub    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  0x0(%rbp),%xmm0
sub    %rcx,%rbp
movsd  %xmm0,0x0(%rbp)
mov    %r9d,%r11d
mov    0x8(%rsp),%rdx
mov    0x10(%rsp),%rbp
jmp    1918 <f_iir_tline_filter+0x7e8>
nopl   0x0(%rax,%rax,1)
mov    %r9d,%r11d
mov    0x18(%rsp),%r12
movslq %r11d,%rax
mov    %rax,%rcx
neg    %rcx
ucomisd %xmm5,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
subsd  %xmm0,%xmm4
movapd %xmm1,%xmm15
subsd  %xmm4,%xmm15
jb     1950 <f_iir_tline_filter+0x820>
movapd %xmm4,%xmm14
jmp    195a <f_iir_tline_filter+0x82a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm15,%xmm14
movapd %xmm4,%xmm15
cmovb  %rax,%rcx
test   %r12d,%r12d
jle    1a90 <f_iir_tline_filter+0x960>
movsd  %xmm3,0x8(%rsp)
movapd 0x60(%rsp),%xmm2
movapd %xmm2,%xmm10
mulsd  %xmm14,%xmm10
movapd %xmm2,%xmm3
mulsd  %xmm15,%xmm3
movsd  (%r8),%xmm9
movsd  (%r15,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm5
movsd  (%rdx,%rcx,8),%xmm7
movapd %xmm11,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm9,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm8,%xmm13
mulsd  %xmm5,%xmm13
addsd  %xmm2,%xmm13
movapd %xmm12,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm13,%xmm1
mov    %rbp,%r12
lea    0x0(%rbp,%rcx,8),%rax
lea    0x8(%r15,%rcx,8),%rbp
mov    %rsi,%r9
lea    0x8(%rsi,%rcx,8),%rdi
mov    %rdx,%rsi
lea    (%rdx,%rcx,8),%rdx
add    $0x8,%rdx
mov    0x40(%rsp),%ebx
xor    %ecx,%ecx
movapd %xmm9,%xmm6
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm6,%xmm2
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm2
movapd %xmm10,%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm8,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm12,%xmm7
movapd %xmm7,%xmm1
addsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%rcx,1)
mulsd  %xmm14,%xmm4
movapd %xmm15,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,1)
sub    $0x1,%ebx
jb     1670 <f_iir_tline_filter+0x540>
movapd %xmm9,%xmm6
movsd  0x8(%r8,%rcx,1),%xmm9
movsd  0x0(%rbp,%rcx,1),%xmm0
movsd  (%rdi,%rcx,1),%xmm5
movsd  (%rdx,%rcx,1),%xmm7
add    $0x8,%rcx
jmp    1a00 <f_iir_tline_filter+0x8d0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%r12
movapd 0x90(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
jmp    16a3 <f_iir_tline_filter+0x573>
mov    %rdi,%r15
mov    %rax,%rsi
mov    %rbp,%rdx
mov    %rdx,0x8(%rsp)
mov    %rsi,%r14
mov    %r12,%rbx
mov    0x38(%rsp),%rdi
movsd  0x20(%rdi),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x28(%rdi),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x30(%rdi),%xmm0
movsd  %xmm0,0x20(%rsp)
lea    0xa0(%rsp),%rsi
xor    %eax,%eax
call   1040 <TriggsM@plt>
movsd  0x10(%rsp),%xmm2
movsd  0x40(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8c(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
cvttsd2si %xmm0,%r10d
mov    0x18(%rsp),%r12
test   %r12d,%r12d
jle    1c9e <f_iir_tline_filter+0xb6e>
movslq %r10d,%rax
mov    %rax,%rdx
neg    %rdx
xorpd  %xmm0,%xmm0
movapd 0x90(%rsp),%xmm14
ucomisd %xmm14,%xmm0
cmovb  %rax,%rdx
movsd  0x14df(%rip),%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm1,%xmm0
movsd  0x20(%rsp),%xmm7
subsd  %xmm7,%xmm0
mov    0x80(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,8),%r8
add    $0xfffffffffffffff8,%r8
add    %rcx,%rdx
mov    %rbx,%rsi
lea    (%rbx,%rdx,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    (%r15,%rdx,8),%rdi
add    $0xfffffffffffffff8,%rdi
lea    (%r14,%rdx,8),%rax
add    $0xfffffffffffffff8,%rax
xor    %edx,%edx
mov    %r12d,%ebp
movapd 0x60(%rsp),%xmm12
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rdx,1),%xmm3
movsd  (%rcx,%rdx,1),%xmm1
subsd  %xmm3,%xmm1
movsd  (%rdi,%rdx,1),%xmm4
subsd  %xmm3,%xmm4
movsd  (%rax,%rdx,1),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm0,%xmm3
movsd  0xa8(%rsp),%xmm5
mulsd  %xmm4,%xmm5
movsd  0xa0(%rsp),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm5,%xmm6
movsd  0xb0(%rsp),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm12,%xmm5
movsd  %xmm5,-0x8(%r13,%rdx,1)
movsd  %xmm5,(%rcx,%rdx,1)
movsd  0xc0(%rsp),%xmm5
mulsd  %xmm4,%xmm5
movsd  0xb8(%rsp),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm5,%xmm6
movsd  0xc8(%rsp),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm12,%xmm5
mulsd  0xd8(%rsp),%xmm4
movsd  %xmm5,(%rdi,%rdx,1)
mulsd  0xd0(%rsp),%xmm1
addsd  %xmm4,%xmm1
mulsd  0xe0(%rsp),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm12,%xmm2
movsd  %xmm2,(%rax,%rdx,1)
add    $0xfffffffffffffff8,%rdx
add    $0xffffffff,%ebp
jne    1ba0 <f_iir_tline_filter+0xa70>
add    %rdx,%r13
movsd  0x48(%rsp),%xmm2
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r9
mov    0x28(%rsp),%rax
jmp    1ccd <f_iir_tline_filter+0xb9d>
movapd 0x90(%rsp),%xmm14
movsd  0x48(%rsp),%xmm2
mov    %rbx,%rsi
mov    0x30(%rsp),%r8
movapd 0x60(%rsp),%xmm12
mov    0x78(%rsp),%r9
mov    0x28(%rsp),%rax
movsd  0x20(%rsp),%xmm7
mov    0x8(%rsp),%rcx
cmp    $0x2,%eax
jl     21a9 <f_iir_tline_filter+0x1079>
lea    -0x1(%r12),%eax
mov    %eax,0x20(%rsp)
movslq %eax,%r11
lea    -0x2(%r8),%rax
mov    %rax,0x38(%rsp)
xorpd  %xmm3,%xmm3
jmp    1d41 <f_iir_tline_filter+0xc11>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm9,%xmm7
add    %rbx,%r13
add    $0xfffffffffffffff8,%r13
movsd  0x48(%rsp),%xmm2
mov    %r14,%rsi
movapd 0x60(%rsp),%xmm12
mov    %r15,%rbp
mov    0x8(%rsp),%rdx
xorpd  %xmm3,%xmm3
lea    -0x1(%r9),%eax
mov    %rdi,%rcx
mov    %rbp,%r14
mov    %rdx,%r15
test   %r9d,%r9d
mov    %eax,%r9d
jle    21b2 <f_iir_tline_filter+0x1082>
mov    %rsi,%rdx
mov    %r15,%rbp
mov    %r14,%rdi
mov    %rcx,%rsi
ucomisd %xmm14,%xmm3
xorps  %xmm10,%xmm10
cvtsi2sd %r9d,%xmm10
mulsd  0x50(%rsp),%xmm10
movslq %r10d,%rbx
mov    %rdx,0x8(%rsp)
cvttsd2si %xmm10,%r15d
jae    1e80 <f_iir_tline_filter+0xd50>
sub    %r15d,%r10d
jle    1fb0 <f_iir_tline_filter+0xe80>
mov    %rsi,%r8
lea    (%rdx,%rbx,8),%rdx
lea    0x0(,%rbx,8),%rcx
add    %rbp,%rcx
lea    (%rdi,%rbx,8),%r12
add    $0x1,%r10d
lea    -0x1(%r10),%r14
mov    $0x1,%esi
cmp    $0x2,%r10d
je     1e34 <f_iir_tline_filter+0xd04>
mov    %rbp,%rax
lea    (%rdi,%rbx,8),%rbp
add    $0xfffffffffffffff8,%rbp
mov    %rax,0x28(%rsp)
lea    -0x8(%rax,%rbx,8),%rsi
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    %r14,%r10
and    $0xfffffffffffffffe,%r10
neg    %r10
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  (%r12),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x8(%rbx,%rax,8)
movsd  (%rcx),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
movsd  (%r12),%xmm0
movsd  %xmm0,-0x8(%rbp,%rax,8)
add    $0xfffffffffffffffe,%rax
cmp    %rax,%r10
jne    1de0 <f_iir_tline_filter+0xcb0>
mov    $0x1,%esi
sub    %rax,%rsi
mov    0x28(%rsp),%rbp
test   $0x1,%r14b
je     1e63 <f_iir_tline_filter+0xd33>
movsd  (%rdx),%xmm0
shl    $0x3,%rsi
sub    %rsi,%rdx
movsd  %xmm0,(%rdx)
movsd  (%rcx),%xmm0
sub    %rsi,%rcx
movsd  %xmm0,(%rcx)
movsd  (%r12),%xmm0
sub    %rsi,%r12
movsd  %xmm0,(%r12)
mov    0x18(%rsp),%r12
mov    %r8,%rsi
mov    0x30(%rsp),%r8
jmp    1f6a <f_iir_tline_filter+0xe3a>
cs nopw 0x0(%rax,%rax,1)
nop
sub    %r15d,%r10d
jle    2020 <f_iir_tline_filter+0xef0>
mov    %rsi,%r8
shl    $0x3,%rbx
mov    %rdx,%rax
sub    %rbx,%rax
mov    %rbp,0x28(%rsp)
mov    %rbp,%rdx
sub    %rbx,%rdx
mov    %rdi,%rsi
sub    %rbx,%rsi
add    $0x1,%r10d
lea    -0x1(%r10),%r14
mov    $0x1,%ecx
cmp    $0x2,%r10d
je     1f30 <f_iir_tline_filter+0xe00>
mov    %r14,%r10
and    $0xfffffffffffffffe,%r10
neg    %r10
mov    $0x1,%ecx
mov    %r12d,%ebp
nopl   0x0(%rax)
movsd  (%rax,%r11,8),%xmm0
movslq %ebp,%rbp
movsd  %xmm0,(%rax,%rbp,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
movsd  (%rax,%r11,8),%xmm0
lea    0x1(%rbp),%ebx
movslq %ebx,%rbx
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
movsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x2,%ebp
lea    (%r10,%rcx,1),%rbx
add    $0x2,%rbx
add    $0x2,%rcx
cmp    $0x1,%rbx
jne    1ed0 <f_iir_tline_filter+0xda0>
test   $0x1,%r14b
je     1f5d <f_iir_tline_filter+0xe2d>
movsd  (%rax,%r11,8),%xmm0
add    %r11d,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    %r8,%rsi
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%rbp
mov    0x8(%rsp),%rdx
ucomisd %xmm14,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
subsd  %xmm0,%xmm10
movsd  0x109e(%rip),%xmm13
subsd  %xmm10,%xmm13
movapd %xmm12,%xmm8
mulsd  %xmm10,%xmm8
movapd %xmm12,%xmm11
mulsd  %xmm13,%xmm11
jb     1fdf <f_iir_tline_filter+0xeaf>
jmp    204f <f_iir_tline_filter+0xf1f>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
subsd  %xmm0,%xmm10
movsd  0x1062(%rip),%xmm13
subsd  %xmm10,%xmm13
movapd %xmm12,%xmm8
mulsd  %xmm10,%xmm8
movapd %xmm12,%xmm11
mulsd  %xmm13,%xmm11
movapd %xmm13,%xmm0
movapd %xmm11,%xmm1
lea    (%rsi,%r8,8),%rax
movslq %r15d,%rcx
lea    (%rax,%rcx,8),%rax
mov    %r15d,%r10d
movapd %xmm10,%xmm13
movapd %xmm0,%xmm10
movapd %xmm8,%xmm11
movapd %xmm1,%xmm8
test   %r12d,%r12d
jg     2074 <f_iir_tline_filter+0xf44>
jmp    1d28 <f_iir_tline_filter+0xbf8>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
subsd  %xmm0,%xmm10
movsd  0xff2(%rip),%xmm13
subsd  %xmm10,%xmm13
movapd %xmm12,%xmm8
mulsd  %xmm10,%xmm8
movapd %xmm12,%xmm11
mulsd  %xmm13,%xmm11
lea    (%rsi,%r8,8),%rax
movslq %r15d,%rdx
mov    %rdx,%rcx
neg    %rcx
shl    $0x3,%rdx
sub    %rdx,%rax
mov    0x8(%rsp),%rdx
mov    %r15d,%r10d
test   %r12d,%r12d
jle    1d28 <f_iir_tline_filter+0xbf8>
mov    %rsi,%r14
mov    %rbp,%r15
mov    %rdx,%rbp
lea    (%rdx,%r8,8),%rdx
lea    (%r15,%r8,8),%rsi
lea    (%rdi,%r8,8),%rbx
movsd  -0x8(%r13),%xmm4
movapd %xmm7,%xmm15
movsd  -0x8(%rdx,%rcx,8),%xmm7
movsd  -0x8(%rsi,%rcx,8),%xmm6
movsd  -0x8(%rbx,%rcx,8),%xmm0
movsd  0x10(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm12,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
movsd  0x40(%rsp),%xmm5
movapd %xmm5,%xmm12
mulsd  %xmm6,%xmm12
addsd  %xmm2,%xmm12
movapd %xmm15,%xmm9
mulsd  %xmm0,%xmm15
addsd  %xmm12,%xmm15
movapd %xmm5,%xmm12
movapd %xmm3,%xmm5
mov    0x38(%rsp),%rbx
lea    0x0(%rbp,%rbx,8),%rdx
mov    %r15,%rsi
lea    (%rdx,%rcx,8),%rbp
lea    (%r15,%rbx,8),%rdx
lea    (%rdx,%rcx,8),%rdx
lea    (%rdi,%rbx,8),%rsi
lea    (%rsi,%rcx,8),%rsi
mov    0x20(%rsp),%ecx
xor    %ebx,%ebx
movapd %xmm4,%xmm3
nopl   0x0(%rax)
movapd %xmm3,%xmm2
movapd %xmm4,%xmm3
movapd %xmm15,%xmm4
mulsd  %xmm13,%xmm4
mulsd  %xmm8,%xmm2
movapd %xmm11,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm5,%xmm7
addsd  %xmm1,%xmm7
mulsd  %xmm12,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm9,%xmm0
movapd %xmm0,%xmm15
addsd  %xmm6,%xmm15
movsd  %xmm15,-0x8(%rax,%rbx,1)
movapd %xmm10,%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,-0x8(%r13,%rbx,1)
sub    $0x1,%ecx
jb     1d00 <f_iir_tline_filter+0xbd0>
movsd  -0x10(%r13,%rbx,1),%xmm4
movsd  0x0(%rbp,%rbx,1),%xmm7
movsd  (%rdx,%rbx,1),%xmm6
movsd  (%rsi,%rbx,1),%xmm0
add    $0xfffffffffffffff8,%rbx
jmp    2120 <f_iir_tline_filter+0xff0>
mov    %r15,%rdx
mov    %r14,%rbp
mov    %rcx,%rdi
xorpd  %xmm0,%xmm0
ucomisd %xmm14,%xmm0
jb     21e1 <f_iir_tline_filter+0x10b1>
mulsd  0x50(%rsp),%xmm2
addsd  0xe5d(%rip),%xmm2
cvttsd2si %xmm2,%eax
cltq
shl    $0x3,%rax
sub    %rax,%rdi
sub    %rax,%rsi
sub    %rax,%rdx
sub    %rax,%rbp
mov    %rsi,%rbx
mov    %rdx,%r14
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edx,%esi
and    $0xfffffffe,%esi
movapd 0x60(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
lea    -0x2(%rsi),%rcx
mov    %rcx,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     2308 <f_iir_tline_filter+0x11d8>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%r14,%rdi,8),%rbx
add    $0x10,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rbx,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r9,%rdi,8)
movupd (%rbx,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r9,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rcx
jne    2270 <f_iir_tline_filter+0x1140>
test   $0x1,%bpl
je     22bc <f_iir_tline_filter+0x118c>
movupd (%r8,%rdi,8),%xmm2
mulpd  %xmm2,%xmm0
divpd  %xmm1,%xmm0
movupd %xmm0,(%r9,%rdi,8)
lea    (%r8,%rsi,8),%r8
cmp    %rdx,%rsi
mov    %r15,%rbp
jne    159f <f_iir_tline_filter+0x46f>
mov    0x10(%rsp),%r12
mov    %r10,%rdi
mov    0x18(%rsp),%rbx
jmp    1624 <f_iir_tline_filter+0x4f4>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,8),%r12
lea    (%r10,%rcx,8),%rsi
lea    (%rax,%rcx,8),%rdi
jmp    12f5 <f_iir_tline_filter+0x1c5>
xor    %esi,%esi
mov    %rdi,%r10
test   $0x1,%bpl
jne    14e6 <f_iir_tline_filter+0x3b6>
jmp    152c <f_iir_tline_filter+0x3fc>
xor    %edi,%edi
test   $0x1,%bpl
jne    22a8 <f_iir_tline_filter+0x1178>
jmp    22bc <f_iir_tline_filter+0x118c>

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

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