int multitap(int num_points, int nwin, double *lam, float npi, double *tapers,
             double *tapsum) {
  int i, k, kk;
  double ww, cs, ai, an, eps, rlu, rlb, aa;
  double dfac, drat, invgamma, gamma, bh, tapsq, TWOPI, DPI;
  double *diag, *offdiag, *offsq;
  double *scratch1, *scratch2, *scratch3, *scratch4, *scratch6;
  double anpi;
  double *ell;
  int *ip;
  double *evecs;
  long len;
  int ierr;
  int m11;
  DPI = (double)3.1415926535897923846;
  TWOPI = (double)2 * DPI;
  anpi = npi;
  an = (double)(num_points);
  ww = (double)(anpi) / an;
  cs = cos(TWOPI * ww);
  ell = alloc_dvec((long)0, (long)nwin);
  diag = alloc_dvec((long)0, (long)num_points);
  offdiag = alloc_dvec((long)0, (long)num_points);
  offsq = alloc_dvec((long)0, (long)num_points);
  scratch1 = alloc_dvec((long)0, (long)num_points);
  scratch2 = alloc_dvec((long)0, (long)num_points);
  scratch3 = alloc_dvec((long)0, (long)num_points);
  scratch4 = alloc_dvec((long)0, (long)num_points);
  scratch6 = alloc_dvec((long)0, (long)num_points);
  for (i = 0; i < num_points; i++) {
    ai = (double)(i);
    diag[i] = -cs * (((an - 1.) / 2. - ai)) * (((an - 1.) / 2. - ai));
    offdiag[i] = -ai * (an - ai) / 2.;
    offsq[i] = offdiag[i] * offdiag[i];
  }
  eps = 1.0e-16;
  m11 = 1;
  ip = alloc_ivec((long)0, (long)nwin);
  jtridib_(&num_points, &eps, diag, offdiag, offsq, &rlb, &rlu, &m11, &nwin,
           lam, ip, &ierr, scratch1, scratch2);
  len = num_points * nwin;
  evecs = alloc_dvec((long)0, (long)len);
  jtinvit_(&num_points, &num_points, diag, offdiag, offsq, &nwin, lam, ip,
           evecs, &ierr, scratch1, scratch2, scratch3, scratch4, scratch6);
  free(scratch1);
  free(scratch2);
  free(scratch3);
  free(scratch4);
  free(scratch6);
  dfac = (double)an * DPI * ww;
  drat = (double)8. * dfac;
  dfac = (double)4. * sqrt(DPI * dfac) * exp((double)(-2.0) * dfac);
  for (k = 0; k < nwin; k++) {
    lam[k] = (double)1.0 - (double)dfac;
    dfac = dfac * drat / (double)(k + 1);
  }
  gamma =
      log((double)8. * an * sin((double)2. * DPI * ww)) + (double)0.5772156649;
  invgamma = 1. / gamma;
  for (k = 0; k < nwin; k++) {
    bh = -2. * DPI * (an * ww - (double)(k) / (double)2. - (double).25) *
         invgamma;
    ell[k] = (double)1. / ((double)1. + exp(DPI * (double)bh));
  }
  for (i = 0; i < nwin; i++)
    lam[i] = ((ell[i]) >= (lam[i]) ? (ell[i]) : (lam[i]));
  for (k = 0; k < nwin; k++) {
    kk = (k)*num_points;
    tapsum[k] = 0.;
    tapsq = 0.;
    for (i = 0; i < num_points; i++) {
      aa = evecs[i + kk];
      tapers[i + kk] = aa;
      tapsum[k] = tapsum[k] + aa;
      tapsq = tapsq + aa * aa;
    }
    aa = sqrt(tapsq / (double)num_points);
    tapsum[k] = tapsum[k] / aa;
    for (i = 0; i < num_points; i++) {
      tapers[i + kk] = tapers[i + kk] / aa;
    }
  }
  free(ell);
  free(diag);
  free(offdiag);
  free(offsq);
  free(ip);
  free(evecs);
  return 1;
}


x86 assembly (clang, -O0):
<multitap>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %edi,-0x2c(%rbp)
mov    %esi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
movss  %xmm0,-0x3c(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
movsd  0xe35(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0xe1d(%rip),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
cvtsi2sdl -0x2c(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0x70(%rbp)
movslq -0x30(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x130(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0xe8(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0xf0(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0xf8(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x100(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x108(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x110(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x118(%rbp)
movslq -0x2c(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x120(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1428 <multitap+0x288>
cvtsi2sdl -0x54(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm1
movsd  0xcdb(%rip),%xmm2
subsd  %xmm2,%xmm1
movsd  0xc9f(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
movsd  0xcb5(%rip),%xmm2
subsd  %xmm2,%xmm1
movsd  0xc79(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc2a(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1316 <multitap+0x176>
movsd  0xbf8(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x150(%rbp)
movslq -0x30(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   1060 <alloc_ivec@plt>
cltq
mov    %rax,-0x138(%rbp)
mov    -0xe8(%rbp),%rdx
mov    -0xf0(%rbp),%rcx
mov    -0xf8(%rbp),%r8
mov    -0x38(%rbp),%r14
mov    -0x138(%rbp),%rbx
mov    -0x100(%rbp),%r10
mov    -0x108(%rbp),%rax
lea    -0x2c(%rbp),%rdi
lea    -0x88(%rbp),%rsi
lea    -0x98(%rbp),%r9
lea    -0x90(%rbp),%r13
lea    -0x150(%rbp),%r12
lea    -0x30(%rbp),%r15
lea    -0x14c(%rbp),%r11
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
mov    $0x0,%al
call   10b0 <jtridib_@plt>
mov    -0x2c(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
mov    $0x0,%al
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,-0x140(%rbp)
mov    -0xe8(%rbp),%rdx
mov    -0xf0(%rbp),%rcx
mov    -0xf8(%rbp),%r8
mov    -0x38(%rbp),%rax
mov    -0x138(%rbp),%r13
mov    -0x140(%rbp),%r12
mov    -0x100(%rbp),%r14
mov    -0x108(%rbp),%rbx
mov    -0x110(%rbp),%r11
mov    -0x118(%rbp),%r10
mov    -0x120(%rbp),%rsi
mov    %rsi,-0x160(%rbp)
lea    -0x2c(%rbp),%rsi
lea    -0x30(%rbp),%r9
lea    -0x14c(%rbp),%r15
mov    %rsi,%rdi
mov    %rax,(%rsp)
mov    -0x160(%rbp),%rax
mov    %r13,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r11,0x30(%rsp)
mov    %r10,0x38(%rsp)
mov    %rax,0x40(%rsp)
mov    $0x0,%al
call   1040 <jtinvit_@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
mov    -0x120(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x80(%rbp),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0xa19(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9e1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x9c5(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
call   1070 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16d3 <multitap+0x533>
movsd  0x9a6(%rip),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1676 <multitap+0x4d6>
movsd  0x945(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  0x910(%rip),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
call   1050 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1090 <log@plt>
movsd  0x91a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8fe(%rip),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    180a <multitap+0x66a>
movsd  0x8b3(%rip),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
cvtsi2sdl -0x58(%rbp),%xmm2
movsd  0x884(%rip),%xmm4
divsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x899(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
call   1070 <exp@plt>
movsd  0x854(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x848(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1749 <multitap+0x5a9>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1895 <multitap+0x6f5>
mov    -0x130(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     185d <multitap+0x6bd>
mov    -0x130(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1872 <multitap+0x6d2>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1811 <multitap+0x671>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1a0f <multitap+0x86f>
mov    -0x58(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    196f <multitap+0x7cf>
mov    -0x140(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    18d4 <multitap+0x734>
movsd  -0xd0(%rbp),%xmm0
ff
cvtsi2sdl -0x2c(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    19fc <multitap+0x85c>
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    19b6 <multitap+0x816>
jmp    1a01 <multitap+0x861>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    189c <multitap+0x6fc>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x138(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<multitap>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r8,%r14
mov    %rcx,0x28(%rsp)
mov    %rdx,%r12
mov    %esi,%r15d
mov    %edi,%ebx
mov    %edi,0x14(%rsp)
mov    %esi,0x4(%rsp)
cvtsi2sd %edi,%xmm2
movapd %xmm2,0x30(%rsp)
cvtss2sd %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  0xe1d(%rip),%xmm0
movsd  %xmm1,0x70(%rsp)
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xa8(%rsp)
call   1080 <cos@plt>
movapd %xmm0,0x80(%rsp)
movslq %r15d,%rsi
xor    %edi,%edi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
mov    %eax,0x64(%rsp)
movslq %ebx,%r15
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,0x58(%rsp)
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
movslq %eax,%rbp
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
movslq %eax,%r13
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,0xa0(%rsp)
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,0x8(%rsp)
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,0x98(%rsp)
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
cltq
mov    %rax,0x40(%rsp)
xor    %edi,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
movapd 0x80(%rsp),%xmm6
movapd 0x30(%rsp),%xmm11
mov    %rbp,%r8
mov    0x58(%rsp),%rbp
cltq
mov    %rax,0x78(%rsp)
test   %r15d,%r15d
mov    %r8,0x18(%rsp)
jle    146c <multitap+0x2cc>
xorpd  0xd80(%rip),%xmm6
movsd  0xd20(%rip),%xmm0
addsd  %xmm11,%xmm0
mulsd  0xd1b(%rip),%xmm0
mov    %ebx,%eax
cmp    $0x1,%ebx
jne    1303 <multitap+0x163>
xor    %ecx,%ecx
jmp    140b <multitap+0x26b>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
lea    (%r8,%rax,8),%rdi
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
cmp    %rdi,%rbp
setb   %r9b
cmp    %rcx,%r8
setb   %r10b
cmp    %rsi,%rbp
setb   %dl
cmp    %rcx,%r13
setb   %r11b
cmp    %rsi,%r8
setb   %sil
cmp    %rdi,%r13
setb   %r8b
xor    %ecx,%ecx
test   %r10b,%r9b
jne    1406 <multitap+0x266>
and    %r11b,%dl
jne    1406 <multitap+0x266>
and    %r8b,%sil
mov    0x18(%rsp),%r8
jne    140b <multitap+0x26b>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm10
unpcklpd %xmm0,%xmm10
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
movapd %xmm11,%xmm3
unpcklpd %xmm11,%xmm3
movdqa 0xcdf(%rip),%xmm4
xor    %edx,%edx
movapd 0xce4(%rip),%xmm8
movdqa 0xceb(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
nop
cvtdq2pd %xmm4,%xmm7
movapd %xmm10,%xmm5
subpd  %xmm7,%xmm5
movapd %xmm5,%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm1
movupd %xmm1,0x0(%rbp,%rdx,8)
movapd %xmm3,%xmm1
subpd  %xmm7,%xmm1
mulpd  %xmm7,%xmm1
mulpd  %xmm8,%xmm1
movupd %xmm1,(%r8,%rdx,8)
mulpd  %xmm1,%xmm1
movupd %xmm1,0x0(%r13,%rdx,8)
add    $0x2,%rdx
paddd  %xmm9,%xmm4
cmp    %rdx,%rcx
jne    13b0 <multitap+0x210>
cmp    %rax,%rcx
jne    140b <multitap+0x26b>
jmp    146c <multitap+0x2cc>
mov    0x18(%rsp),%r8
movsd  0xc05(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
movapd %xmm0,%xmm3
subsd  %xmm2,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,0x0(%rbp,%rcx,8)
movapd %xmm11,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,(%r8,%rcx,8)
mulsd  %xmm3,%xmm3
movsd  %xmm3,0x0(%r13,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1420 <multitap+0x280>
movabs $0x3c9cd2b297d889bc,%rax
d2 9c 3c
mov    %rax,0xb0(%rsp)
movl   $0x1,0x68(%rsp)
xor    %edi,%edi
mov    0x20(%rsp),%rsi
xor    %eax,%eax
mov    %rbp,%rbx
mov    %r8,%rbp
call   1060 <alloc_ivec@plt>
mov    %r13,%r15
movslq %eax,%r10
mov    %r10,0x80(%rsp)
lea    0x6c(%rsp),%r13
lea    0x4(%rsp),%r11
lea    0x14(%rsp),%rdi
lea    0xb0(%rsp),%rsi
lea    0xb8(%rsp),%r9
mov    %rbx,%rdx
mov    %rbp,%rcx
mov    %r15,%r8
mov    $0x0,%eax
push   0x8(%rsp)
mov    0xa8(%rsp),%rbp
push   %rbp
push   %r13
push   %r10
push   %r12
push   %r11
mov    %r11,%r13
lea    0x98(%rsp),%rbx
push   %rbx
lea    0xf8(%rsp),%rbx
push   %rbx
call   10b0 <jtridib_@plt>
add    $0x40,%rsp
movslq 0x14(%rsp),%rax
movslq 0x4(%rsp),%rsi
imul   %rax,%rsi
xor    %edi,%edi
xor    %eax,%eax
call   10c0 <alloc_dvec@plt>
movslq %eax,%r10
sub    $0x8,%rsp
lea    0x1c(%rsp),%rdi
mov    %rdi,%rsi
mov    0x60(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    %r15,0x98(%rsp)
mov    %r15,%r8
mov    %r13,%r9
xor    %eax,%eax
push   0x80(%rsp)
push   0x50(%rsp)
mov    0xb0(%rsp),%r15
push   %r15
mov    0x28(%rsp),%r13
push   %r13
mov    %rbp,%rbx
push   %rbp
lea    0x9c(%rsp),%rbp
push   %rbp
mov    %r10,0x58(%rsp)
push   %r10
push   0xc0(%rsp)
push   %r12
call   1040 <jtinvit_@plt>
add    $0x50,%rsp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
movsd  0xa62(%rip),%xmm1
movapd 0x30(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x70(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm2,0x40(%rsp)
jb     15ec <multitap+0x44c>
sqrtsd %xmm0,%xmm0
jmp    15f7 <multitap+0x457>
call   10a0 <sqrt@plt>
movapd 0x40(%rsp),%xmm2
movsd  %xmm0,0x8(%rsp)
movsd  0xa2b(%rip),%xmm0
mulsd  %xmm2,%xmm0
call   1070 <exp@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
mov    0x90(%rsp),%r13
movapd 0x30(%rsp),%xmm2
movsd  0x8(%rsp),%xmm3
jle    16bd <multitap+0x51d>
mulsd  0xa02(%rip),%xmm3
mulsd  %xmm0,%xmm3
cmp    $0x1,%eax
jne    1643 <multitap+0x4a3>
xor    %ecx,%ecx
jmp    16a7 <multitap+0x507>
movapd 0x40(%rsp),%xmm4
mulsd  0x9d7(%rip),%xmm4
mov    %eax,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
movsd  0x9e0(%rip),%xmm0
movapd %xmm0,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
mulsd  %xmm4,%xmm3
lea    0x1(%rcx),%esi
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd  %xmm1,%xmm3
movapd %xmm0,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,0x8(%r12,%rcx,8)
mulsd  %xmm4,%xmm3
add    $0x2,%rcx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm3
cmp    %rcx,%rdx
jne    1660 <multitap+0x4c0>
test   $0x1,%al
je     16bd <multitap+0x51d>
movsd  0x98d(%rip),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movslq 0x64(%rsp),%rbx
movsd  0x95e(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1050 <sin@plt>
mulsd  0x8(%rsp),%xmm0
call   1090 <log@plt>
cmpl   $0x0,0x4(%rsp)
jle    1be5 <multitap+0xa45>
addsd  0x948(%rip),%xmm0
movsd  0x938(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %ebp,%ebp
movapd 0x30(%rsp),%xmm2
mulsd  0x70(%rsp),%xmm2
movapd %xmm2,0x30(%rsp)
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x8d9(%rip),%xmm0
addsd  %xmm2,%xmm0
addsd  0x905(%rip),%xmm0
mulsd  0x905(%rip),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x8bf(%rip),%xmm0
call   1070 <exp@plt>
movapd 0x30(%rsp),%xmm2
movsd  0x8cc(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
cmp    %rax,%rbp
jl     1730 <multitap+0x590>
mov    %eax,%eax
test   %eax,%eax
jle    1be5 <multitap+0xa45>
cmp    $0x4,%eax
jb     17b8 <multitap+0x618>
lea    (%rbx,%rax,8),%rcx
cmp    %r12,%rcx
jbe    185d <multitap+0x6bd>
lea    (%r12,%rax,8),%rcx
cmp    %rcx,%rbx
jae    185d <multitap+0x6bd>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     17ee <multitap+0x64e>
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%r12,%rcx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movlpd %xmm2,(%r12,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     199d <multitap+0x7fd>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%r12,%rcx,8),%xmm1
movsd  0x8(%r12,%rcx,8),%xmm2
movapd %xmm1,%xmm3
cmplesd %xmm0,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm1,%xmm3
orpd   %xmm0,%xmm3
movlpd %xmm3,(%r12,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movapd %xmm2,%xmm1
cmplesd %xmm0,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movlpd %xmm1,0x8(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1800 <multitap+0x660>
jmp    199d <multitap+0x7fd>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1c37 <multitap+0xa97>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rdx,8),%xmm1
movupd 0x10(%rbx,%rdx,8),%xmm2
movupd (%r12,%rdx,8),%xmm3
movupd 0x10(%r12,%rdx,8),%xmm4
movupd 0x20(%r12,%rdx,8),%xmm5
movupd 0x30(%r12,%rdx,8),%xmm0
movapd %xmm3,%xmm6
cmplepd %xmm1,%xmm6
movapd %xmm4,%xmm7
cmplepd %xmm2,%xmm7
andpd  %xmm6,%xmm1
andnpd %xmm3,%xmm6
orpd   %xmm1,%xmm6
andpd  %xmm7,%xmm2
andnpd %xmm4,%xmm7
orpd   %xmm2,%xmm7
movupd %xmm6,(%r12,%rdx,8)
movupd %xmm7,0x10(%r12,%rdx,8)
movupd 0x20(%rbx,%rdx,8),%xmm1
movupd 0x30(%rbx,%rdx,8),%xmm2
movapd %xmm5,%xmm3
cmplepd %xmm1,%xmm3
movapd %xmm0,%xmm4
cmplepd %xmm2,%xmm4
andpd  %xmm3,%xmm1
andnpd %xmm5,%xmm3
orpd   %xmm1,%xmm3
andpd  %xmm4,%xmm2
andnpd %xmm0,%xmm4
orpd   %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rdx,8)
movupd %xmm4,0x30(%r12,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1890 <multitap+0x6f0>
test   $0x1,%sil
je     1994 <multitap+0x7f4>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd (%r12,%rdx,8),%xmm2
movupd 0x10(%r12,%rdx,8),%xmm3
movapd %xmm2,%xmm4
cmplepd %xmm0,%xmm4
movapd %xmm3,%xmm5
cmplepd %xmm1,%xmm5
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
andpd  %xmm5,%xmm1
andnpd %xmm3,%xmm5
orpd   %xmm1,%xmm5
movupd %xmm4,(%r12,%rdx,8)
movupd %xmm5,0x10(%r12,%rdx,8)
cmp    %rax,%rcx
jne    17ba <multitap+0x61a>
test   %eax,%eax
jle    1be5 <multitap+0xa45>
mov    0x14(%rsp),%eax
mov    0x28(%rsp),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,0x30(%rsp)
mov    0x20(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0x8(%rsp)
add    $0x10,%rcx
mov    %rcx,0x40(%rsp)
xor    %r15d,%r15d
xorpd  %xmm4,%xmm4
jmp    19f2 <multitap+0x852>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
movslq 0x4(%rsp),%rcx
cmp    %rcx,%r15
jge    1be5 <multitap+0xa45>
mov    %r15d,%ecx
imul   %eax,%ecx
movq   $0x0,(%r14,%r15,8)
movslq %ecx,%r12
xorpd  %xmm0,%xmm0
test   %eax,%eax
jle    1ac4 <multitap+0x924>
mov    %eax,%ecx
cmp    $0x1,%eax
jne    1a20 <multitap+0x880>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    1a90 <multitap+0x8f0>
xchg   %ax,%ax
mov    %ecx,%esi
and    $0xfffffffe,%esi
mov    0x30(%rsp),%rdx
lea    (%rdx,%r12,8),%rdi
mov    0x8(%rsp),%rdx
lea    (%rdx,%r12,8),%rbp
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopl   (%rax)
movsd  -0x8(%rbp,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%rdx,8)
movsd  (%r14,%r15,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%r15,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
movsd  (%r14,%r15,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%r15,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1a40 <multitap+0x8a0>
test   $0x1,%cl
je     1ac4 <multitap+0x924>
add    %r12,%rdx
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
mov    0x28(%rsp),%rcx
movsd  %xmm1,(%rcx,%rdx,8)
movsd  (%r14,%r15,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%r15,8)
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     1ae0 <multitap+0x940>
sqrtsd %xmm0,%xmm0
jmp    1ae9 <multitap+0x949>
nopl   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  (%r14,%r15,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r15,8)
mov    0x14(%rsp),%eax
test   %eax,%eax
jle    19e0 <multitap+0x840>
cmp    $0x1,%eax
jne    1b20 <multitap+0x980>
xor    %ecx,%ecx
jmp    1bae <multitap+0xa0e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1bdc <multitap+0xa3c>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x40(%rsp),%rsi
lea    (%rsi,%r12,8),%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rbp,%rsi,8),%xmm2
movupd 0x0(%rbp,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rbp,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x0(%rbp,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b60 <multitap+0x9c0>
test   $0x1,%dl
je     1ba5 <multitap+0xa05>
add    %r12,%rsi
mov    0x28(%rsp),%rdx
movupd (%rdx,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdx,%rsi,8)
cmp    %rax,%rcx
je     19e0 <multitap+0x840>
mov    0x28(%rsp),%rdx
lea    (%rdx,%r12,8),%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1bc0 <multitap+0xa20>
jmp    19e0 <multitap+0x840>
xor    %esi,%esi
test   $0x1,%dl
jne    1b8f <multitap+0x9ef>
jmp    1ba5 <multitap+0xa05>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1945 <multitap+0x7a5>
jmp    1994 <multitap+0x7f4>

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

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