void resample(s, nt, dt, isamp, ntpad, ntrsmp, newdt, p) float *s, *p, *dt,
    *newdt;
int nt, isamp, ntpad, ntrsmp;
{
  float df, f, f0, fl, fl2, fac;
  int i, j;
  int ord = 4;
  float one = 1.0;
  int minus = -1;
  int plus = 1;
  taper_norm(s, dt, nt);
  zapit(s + nt, (ntpad) - (nt));
  for (i = ntpad - 1; i >= 0; i--) {
    s[2 * i] = s[i];
    s[2 * i + 1] = 0.0;
  }
  fourg_(s, &ntpad, &minus, p);
  if (isamp > 0)
    zapit(s + ntpad, 2 * ntrsmp - ntpad);
  else if (isamp < 0) {
    if (ord) {
      f0 = 0.8 / (2.0 * (*newdt));
      df = 1.0 / (ntrsmp * (*newdt));
      for (i = 1; i < ntrsmp / 2; i++) {
        f = i * df;
        fl = f / f0;
        fl2 = fl * fl;
        fl = fl2;
        for (j = 1; j < ord; j++)
          fl = fl * fl2;
        fac = one / (one + fl);
        s[2 * i] = fac * s[2 * i];
        s[2 * i + 1] = fac * s[2 * i + 1];
      }
    }
    s[ntrsmp] = s[ntrsmp + 1] = 0.0;
  }
  for (i = 1; i < ntrsmp / 2; i++) {
    s[2 * (ntrsmp - i)] = s[2 * i];
    s[2 * (ntrsmp - i) + 1] = -s[2 * i + 1];
  }
  fourg_(s, &ntrsmp, &plus, p);
  for (i = 0; i < ntrsmp; i++)
    s[i] = s[2 * i];
  norm(s, newdt, ntrsmp);
}


x86 assembly (clang, -O0):
<resample>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x4,-0x48(%rbp)
movss  0xe8b(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0xffffffff,-0x50(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    $0x0,%al
call   1030 <taper_norm@plt>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%esi
sub    -0xc(%rbp),%esi
mov    $0x0,%al
call   1050 <zapit@plt>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     120e <resample+0xce>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    11bf <resample+0x7f>
mov    -0x8(%rbp),%rdi
mov    0x18(%rbp),%rcx
lea    -0x20(%rbp),%rsi
lea    -0x50(%rbp),%rdx
mov    $0x0,%al
call   1060 <fourg_@plt>
cmpl   $0x0,-0x1c(%rbp)
jle    1253 <resample+0x113>
mov    -0x8(%rbp),%rdi
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%esi
shl    $0x1,%esi
sub    -0x20(%rbp),%esi
mov    $0x0,%al
call   1050 <zapit@plt>
jmp    13f3 <resample+0x2b3>
cmpl   $0x0,-0x1c(%rbp)
jge    13ee <resample+0x2ae>
cmpl   $0x0,-0x48(%rbp)
je     13c9 <resample+0x289>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd9d(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xd89(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
cvtsi2ssl -0x24(%rbp),%xmm0
mov    0x10(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd5b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%eax
cmp    %ecx,%eax
jge    13c4 <resample+0x284>
cvtsi2ssl -0x40(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1346 <resample+0x206>
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    131d <resample+0x1dd>
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
addss  -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12c1 <resample+0x181>
jmp    13c9 <resample+0x289>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    13f3 <resample+0x2b3>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x5c(%rbp),%eax
cmp    %ecx,%eax
jge    1487 <resample+0x347>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13fa <resample+0x2ba>
mov    -0x8(%rbp),%rdi
mov    0x18(%rbp),%rcx
lea    -0x24(%rbp),%rsi
lea    -0x54(%rbp),%rdx
mov    $0x0,%al
call   1060 <fourg_@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14de <resample+0x39e>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14a5 <resample+0x365>
mov    -0x8(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    $0x0,%al
call   1040 <norm@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<resample>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9d,%r12d
mov    %r8d,%r15d
mov    %ecx,%r13d
mov    %esi,%ebp
mov    %rdi,%rbx
mov    0x58(%rsp),%r14
mov    %r8d,0xc(%rsp)
mov    %r9d,0x8(%rsp)
movl   $0xffffffff,0x14(%rsp)
ff
movl   $0x1,0x10(%rsp)
mov    %rdx,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <taper_norm@plt>
movslq %ebp,%rax
lea    (%rbx,%rax,4),%rdi
mov    %r15d,%esi
sub    %eax,%esi
xor    %eax,%eax
call   1050 <zapit@plt>
test   %r15d,%r15d
jle    124b <resample+0x10b>
mov    %r15d,%esi
test   $0x1,%sil
je     11cf <resample+0x8f>
movss  -0x4(%rbx,%rsi,4),%xmm0
add    $0xffffffffffffffff,%rsi
lea    (%rsi,%rsi,1),%eax
cltq
movss  %xmm0,(%rbx,%rax,4)
lea    (%rsi,%rsi,1),%eax
add    $0x1,%eax
cltq
movl   $0x0,(%rbx,%rax,4)
cmp    $0x1,%r15d
je     124b <resample+0x10b>
lea    (%rbx,%rsi,4),%rax
add    $0xfffffffffffffffc,%rax
lea    (%rsi,%rsi,1),%r8d
add    $0xfffffffc,%r8d
or     $0x1,%r8
mov    %rsi,%rdx
add    $0x1,%rdx
lea    (%rsi,%rsi,1),%r9d
add    $0xfffffffe,%r9d
lea    0x1(%r9),%rdi
xor    %ebp,%ebp
xchg   %ax,%ax
movss  (%rax,%rbp,2),%xmm0
lea    (%r9,%rbp,1),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rbx,%rcx,4)
lea    (%rdi,%rbp,1),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rbx,%rcx,4)
movss  -0x4(%rax,%rbp,2),%xmm0
lea    (%r8,%rbp,1),%rcx
lea    -0x1(%rcx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rbx,%rsi,4)
movslq %ecx,%rcx
movl   $0x0,(%rbx,%rcx,4)
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffe,%rdx
cmp    $0x1,%rdx
ja     1200 <resample+0xc0>
mov    0x50(%rsp),%r15
lea    0xc(%rsp),%rsi
lea    0x14(%rsp),%rdx
mov    %rbx,%rdi
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <fourg_@plt>
test   %r13d,%r13d
jle    128a <resample+0x14a>
movslq 0xc(%rsp),%rax
lea    (%rbx,%rax,4),%rdi
lea    (%r12,%r12,1),%esi
sub    %eax,%esi
xor    %eax,%eax
call   1050 <zapit@plt>
cmp    $0x4,%r12d
jge    1296 <resample+0x156>
jmp    12de <resample+0x19e>
js     139f <resample+0x25f>
cmp    $0x4,%r12d
jl     12de <resample+0x19e>
mov    %r12d,%eax
shr    %eax
lea    (%r12,%r12,1),%ecx
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rax
xor    %edx,%edx
movaps 0xd91(%rip),%xmm0
nop
movss  0x8(%rbx,%rdx,8),%xmm1
lea    -0x1(%rcx),%esi
movslq %esi,%rsi
movss  %xmm1,(%rbx,%rsi,4)
movss  0xc(%rbx,%rdx,8),%xmm1
xorps  %xmm0,%xmm1
movslq %ecx,%rcx
movss  %xmm1,(%rbx,%rcx,4)
add    $0xfffffffe,%ecx
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12b0 <resample+0x170>
lea    0x8(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %rbx,%rdi
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <fourg_@plt>
mov    0x8(%rsp),%edx
test   %edx,%edx
jle    1383 <resample+0x243>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1314 <resample+0x1d4>
xor    %ecx,%ecx
jmp    1357 <resample+0x217>
mov    %edx,%esi
and    $0xfffffffc,%esi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,8),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x8(%rbx,%rcx,8),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x10(%rbx,%rcx,8),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movss  0x18(%rbx,%rcx,8),%xmm0
movss  %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1320 <resample+0x1e0>
test   %rax,%rax
je     1383 <resample+0x243>
lea    (%rbx,%rcx,4),%rsi
lea    (%rbx,%rcx,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx,%rdi,8),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1370 <resample+0x230>
mov    %rbx,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <norm@plt>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x4,%r12d
jl     1504 <resample+0x3c4>
movss  (%r15),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
addsd  %xmm0,%xmm0
movsd  0xc3f(%rip),%xmm2
divsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm9
cvtsi2ss %r12d,%xmm3
mulss  %xmm1,%xmm3
movss  0xc2c(%rip),%xmm10
movaps %xmm10,%xmm11
divss  %xmm3,%xmm11
mov    %r12d,%eax
shr    %eax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     14b0 <resample+0x370>
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rcx
movaps %xmm11,%xmm3
shufps $0x0,%xmm11,%xmm3
movaps %xmm9,%xmm4
shufps $0x0,%xmm9,%xmm4
movaps 0xbef(%rip),%xmm5
xor    %edi,%edi
movaps 0xbf6(%rip),%xmm6
movdqa 0xbfd(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtdq2ps %xmm5,%xmm0
mulps  %xmm3,%xmm0
divps  %xmm4,%xmm0
mulps  %xmm0,%xmm0
movaps %xmm0,%xmm7
mulps  %xmm0,%xmm7
mulps  %xmm0,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps %xmm6,%xmm0
divps  %xmm7,%xmm0
movups 0x8(%rbx,%rdi,8),%xmm2
movups 0x18(%rbx,%rdi,8),%xmm1
movaps %xmm2,%xmm7
shufps $0x88,%xmm1,%xmm7
shufps $0xdd,%xmm1,%xmm2
mulps  %xmm0,%xmm7
mulps  %xmm0,%xmm2
movaps %xmm7,%xmm0
unpckhps %xmm2,%xmm0
unpcklps %xmm2,%xmm7
movups %xmm7,0x8(%rbx,%rdi,8)
movups %xmm0,0x18(%rbx,%rdi,8)
add    $0x4,%rdi
paddd  %xmm8,%xmm5
cmp    %rdi,%rsi
jne    1440 <resample+0x300>
cmp    %rsi,%rdx
je     1504 <resample+0x3c4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm11,%xmm0
divss  %xmm9,%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm10,%xmm1
movaps %xmm10,%xmm0
divss  %xmm1,%xmm0
movss  (%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rcx,8)
mulss  0x4(%rbx,%rcx,8),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14b0 <resample+0x370>
movslq %r12d,%rax
movq   $0x0,(%rbx,%rax,4)
cmp    $0x4,%r12d
jge    1296 <resample+0x156>
jmp    12de <resample+0x19e>

LLVM IR (-O0):
define void @resample(float* %0, i32 %1, float* %2, i32 %3, i32 %4, i32 %5, float* %6, float* %7) {
%9 = alloca float*
%10 = alloca i32
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca i32
%28 = alloca i32
store float* %0, float** %9
store i32 %1, i32* %10
store float* %2, float** %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store float* %6, float** %15
store float* %7, float** %16
store i32 4, i32* %25
store float 1.000000e+00, float* %26
store i32 -1, i32* %27
store i32 1, i32* %28
%29 = load float*, float** %9
%30 = load float*, float** %11
%31 = load i32, i32* %10
%32 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @taper_norm to i32 (float*, float*, i32, ...)*)(float* %29, float* %30, i32 %31)
%33 = load float*, float** %9
%34 = load i32, i32* %10
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
%37 = load i32, i32* %13
%38 = load i32, i32* %10
%39 = sub nsw i32 %37, %38
%40 = call i32 (float*, i32, ...) bitcast (i32 (...)* @zapit to i32 (float*, i32, ...)*)(float* %36, i32 %39)
%41 = load i32, i32* %13
%42 = sub nsw i32 %41, 1
store i32 %42, i32* %23
br label %43
43: ; preds = %63, %8
%44 = load i32, i32* %23
%45 = icmp sge i32 %44, 0
br i1 %45, label %46, label %66
46: ; preds = %43
%47 = load float*, float** %9
%48 = load i32, i32* %23
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
%51 = load float, float* %50
%52 = load float*, float** %9
%53 = load i32, i32* %23
%54 = mul nsw i32 2, %53
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %52, i64 %55
store float %51, float* %56
%57 = load float*, float** %9
%58 = load i32, i32* %23
%59 = mul nsw i32 2, %58
%60 = add nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %57, i64 %61
store float 0.000000e+00, float* %62
br label %63
63: ; preds = %46
%64 = load i32, i32* %23
%65 = add nsw i32 %64, -1
store i32 %65, i32* %23
br label %43
66: ; preds = %43
%67 = load float*, float** %9
%68 = load float*, float** %16
%69 = call i32 (float*, i32*, i32*, float*, ...) bitcast (i32 (...)* @fourg_ to i32 (float*, i32*, i32*, float*, ...)*)(float* %67, i32* %13, i32* %27, float* %68)
%70 = load i32, i32* %12
%71 = icmp sgt i32 %70, 0
br i1 %71, label %72, label %82
72: ; preds = %66
%73 = load float*, float** %9
%74 = load i32, i32* %13
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = load i32, i32* %14
%78 = mul nsw i32 2, %77
%79 = load i32, i32* %13
%80 = sub nsw i32 %78, %79
%81 = call i32 (float*, i32, ...) bitcast (i32 (...)* @zapit to i32 (float*, i32, ...)*)(float* %76, i32 %80)
br label %180
82: ; preds = %66
%83 = load i32, i32* %12
%84 = icmp slt i32 %83, 0
br i1 %84, label %85, label %179
85: ; preds = %82
%86 = load i32, i32* %25
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %169
88: ; preds = %85
%89 = load float*, float** %15
%90 = load float, float* %89
%91 = fpext float %90 to double
%92 = fmul double 2.000000e+00, %91
%93 = fdiv double 8.000000e-01, %92
%94 = fptrunc double %93 to float
store float %94, float* %19
%95 = load i32, i32* %14
%96 = sitofp i32 %95 to float
%97 = load float*, float** %15
%98 = load float, float* %97
%99 = fmul float %96, %98
%100 = fpext float %99 to double
%101 = fdiv double 1.000000e+00, %100
%102 = fptrunc double %101 to float
store float %102, float* %17
store i32 1, i32* %23
br label %103
103: ; preds = %165, %88
%104 = load i32, i32* %23
%105 = load i32, i32* %14
%106 = sdiv i32 %105, 2
%107 = icmp slt i32 %104, %106
br i1 %107, label %108, label %168
108: ; preds = %103
%109 = load i32, i32* %23
%110 = sitofp i32 %109 to float
%111 = load float, float* %17
%112 = fmul float %110, %111
store float %112, float* %18
%113 = load float, float* %18
%114 = load float, float* %19
%115 = fdiv float %113, %114
store float %115, float* %20
%116 = load float, float* %20
%117 = load float, float* %20
%118 = fmul float %116, %117
store float %118, float* %21
%119 = load float, float* %21
store float %119, float* %20
store i32 1, i32* %24
br label %120
120: ; preds = %128, %108
%121 = load i32, i32* %24
%122 = load i32, i32* %25
%123 = icmp slt i32 %121, %122
br i1 %123, label %124, label %131
124: ; preds = %120
%125 = load float, float* %20
%126 = load float, float* %21
%127 = fmul float %125, %126
store float %127, float* %20
br label %128
128: ; preds = %124
%129 = load i32, i32* %24
%130 = add nsw i32 %129, 1
store i32 %130, i32* %24
br label %120
131: ; preds = %120
%132 = load float, float* %26
%133 = load float, float* %26
%134 = load float, float* %20
%135 = fadd float %133, %134
%136 = fdiv float %132, %135
store float %136, float* %22
%137 = load float, float* %22
%138 = load float*, float** %9
%139 = load i32, i32* %23
%140 = mul nsw i32 2, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %138, i64 %141
%143 = load float, float* %142
%144 = fmul float %137, %143
%145 = load float*, float** %9
%146 = load i32, i32* %23
%147 = mul nsw i32 2, %146
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %145, i64 %148
store float %144, float* %149
%150 = load float, float* %22
%151 = load float*, float** %9
%152 = load i32, i32* %23
%153 = mul nsw i32 2, %152
%154 = add nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %151, i64 %155
%157 = load float, float* %156
%158 = fmul float %150, %157
%159 = load float*, float** %9
%160 = load i32, i32* %23
%161 = mul nsw i32 2, %160
%162 = add nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %159, i64 %163
store float %158, float* %164
br label %165
165: ; preds = %131
%166 = load i32, i32* %23
%167 = add nsw i32 %166, 1
store i32 %167, i32* %23
br label %103
168: ; preds = %103
br label %169
169: ; preds = %168, %85
%170 = load float*, float** %9
%171 = load i32, i32* %14
%172 = add nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %170, i64 %173
store float 0.000000e+00, float* %174
%175 = load float*, float** %9
%176 = load i32, i32* %14
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %175, i64 %177
store float 0.000000e+00, float* %178
br label %179
179: ; preds = %169, %82
br label %180
180: ; preds = %179, %72
store i32 1, i32* %23
br label %181
181: ; preds = %216, %180
%182 = load i32, i32* %23
%183 = load i32, i32* %14
%184 = sdiv i32 %183, 2
%185 = icmp slt i32 %182, %184
br i1 %185, label %186, label %219
186: ; preds = %181
%187 = load float*, float** %9
%188 = load i32, i32* %23
%189 = mul nsw i32 2, %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %187, i64 %190
%192 = load float, float* %191
%193 = load float*, float** %9
%194 = load i32, i32* %14
%195 = load i32, i32* %23
%196 = sub nsw i32 %194, %195
%197 = mul nsw i32 2, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %193, i64 %198
store float %192, float* %199
%200 = load float*, float** %9
%201 = load i32, i32* %23
%202 = mul nsw i32 2, %201
%203 = add nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %200, i64 %204
%206 = load float, float* %205
%207 = fneg float %206
%208 = load float*, float** %9
%209 = load i32, i32* %14
%210 = load i32, i32* %23
%211 = sub nsw i32 %209, %210
%212 = mul nsw i32 2, %211
%213 = add nsw i32 %212, 1
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %208, i64 %214
store float %207, float* %215
br label %216
216: ; preds = %186
%217 = load i32, i32* %23
%218 = add nsw i32 %217, 1
store i32 %218, i32* %23
br label %181
219: ; preds = %181
%220 = load float*, float** %9
%221 = load float*, float** %16
%222 = call i32 (float*, i32*, i32*, float*, ...) bitcast (i32 (...)* @fourg_ to i32 (float*, i32*, i32*, float*, ...)*)(float* %220, i32* %14, i32* %28, float* %221)
store i32 0, i32* %23
br label %223
223: ; preds = %238, %219
%224 = load i32, i32* %23
%225 = load i32, i32* %14
%226 = icmp slt i32 %224, %225
br i1 %226, label %227, label %241
227: ; preds = %223
%228 = load float*, float** %9
%229 = load i32, i32* %23
%230 = mul nsw i32 2, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds float, float* %228, i64 %231
%233 = load float, float* %232
%234 = load float*, float** %9
%235 = load i32, i32* %23
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %234, i64 %236
store float %233, float* %237
br label %238
238: ; preds = %227
%239 = load i32, i32* %23
%240 = add nsw i32 %239, 1
store i32 %240, i32* %23
br label %223
241: ; preds = %223
%242 = load float*, float** %9
%243 = load float*, float** %15
%244 = load i32, i32* %14
%245 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @norm to i32 (float*, float*, i32, ...)*)(float* %242, float* %243, i32 %244)
ret void
}

LLVM IR (-O2):
define void @resample(float* %0, i32 %1, float* %2, i32 %3, i32 %4, i32 %5, float* %6, float* %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 %4, i32* %9
store i32 %5, i32* %10
%13 = bitcast i32* %11 to i8*
store i32 -1, i32* %11
%14 = bitcast i32* %12 to i8*
store i32 1, i32* %12
%15 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @taper_norm to i32 (float*, float*, i32, ...)*)(float* %0, float* %2, i32 %1)
%16 = sext i32 %1 to i64
%17 = getelementptr inbounds float, float* %0, i64 %16
%18 = sub nsw i32 %4, %1
%19 = tail call i32 (float*, i32, ...) bitcast (i32 (...)* @zapit to i32 (float*, i32, ...)*)(float* %17, i32 %18)
%20 = icmp sgt i32 %4, 0
br i1 %20, label %21, label %62
21: ; preds = %8
%22 = zext i32 %4 to i64
%23 = and i64 %22, 1
%24 = icmp eq i64 %23, 0
br i1 %24, label %36, label %25
25: ; preds = %21
%26 = add nsw i64 %22, -1
%27 = trunc i64 %26 to i32
%28 = getelementptr inbounds float, float* %0, i64 %26
%29 = load float, float* %28
%30 = shl nuw nsw i32 %27, 1
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float, float* %0, i64 %31
store float %29, float* %32
%33 = or i32 %30, 1
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %0, i64 %34
store float 0.000000e+00, float* %35
br label %36
36: ; preds = %25, %21
%37 = phi i64 [ %22, %21 ], [ %26, %25 ]
%38 = icmp eq i32 %4, 1
br i1 %38, label %62, label %39
39: ; preds = %36, %39
%40 = phi i64 [ %51, %39 ], [ %37, %36 ]
%41 = add nsw i64 %40, -1
%42 = trunc i64 %41 to i32
%43 = getelementptr inbounds float, float* %0, i64 %41
%44 = load float, float* %43
%45 = shl nuw nsw i32 %42, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %0, i64 %46
store float %44, float* %47
%48 = or i32 %45, 1
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %0, i64 %49
store float 0.000000e+00, float* %50
%51 = add nsw i64 %40, -2
%52 = trunc i64 %51 to i32
%53 = getelementptr inbounds float, float* %0, i64 %51
%54 = load float, float* %53
%55 = shl nuw nsw i32 %52, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %0, i64 %56
store float %54, float* %57
%58 = or i32 %55, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %0, i64 %59
store float 0.000000e+00, float* %60
%61 = icmp ugt i64 %41, 1
br i1 %61, label %39, label %62
62: ; preds = %36, %39, %8
%63 = call i32 (float*, i32*, i32*, float*, ...) bitcast (i32 (...)* @fourg_ to i32 (float*, i32*, i32*, float*, ...)*)(float* %0, i32* %9, i32* %11, float* %7)
%64 = icmp sgt i32 %3, 0
br i1 %64, label %65, label %72
65: ; preds = %62
%66 = load i32, i32* %9
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %0, i64 %67
%69 = shl nsw i32 %5, 1
%70 = sub nsw i32 %69, %66
%71 = call i32 (float*, i32, ...) bitcast (i32 (...)* @zapit to i32 (float*, i32, ...)*)(float* %68, i32 %70)
br label %157
72: ; preds = %62
%73 = icmp slt i32 %3, 0
br i1 %73, label %74, label %157
74: ; preds = %72
%75 = load float, float* %6
%76 = fpext float %75 to double
%77 = fmul double %76, 2.000000e+00
%78 = fdiv double 8.000000e-01, %77
%79 = fptrunc double %78 to float
%80 = sitofp i32 %5 to float
%81 = fmul float %75, %80
%82 = fdiv float 1.000000e+00, %81
%83 = icmp sgt i32 %5, 3
br i1 %83, label %84, label %151
84: ; preds = %74
%85 = lshr i32 %5, 1
%86 = zext i32 %85 to i64
%87 = add nsw i64 %86, -1
%88 = icmp ult i64 %87, 4
br i1 %88, label %127, label %89
89: ; preds = %84
%90 = and i64 %87, -4
%91 = or i64 %90, 1
%92 = insertelement <4 x float> poison, float %82, i64 0
%93 = shufflevector <4 x float> %92, <4 x float> poison, <4 x i32> zeroinitializer
%94 = insertelement <4 x float> poison, float %79, i64 0
%95 = shufflevector <4 x float> %94, <4 x float> poison, <4 x i32> zeroinitializer
%96 = getelementptr inbounds float, float* %0, i64 -1
br label %97
97: ; preds = %97, %89
%98 = phi i64 [ 0, %89 ], [ %122, %97 ]
%99 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %89 ], [ %123, %97 ]
%100 = sitofp <4 x i32> %99 to <4 x float>
%101 = fmul <4 x float> %93, %100
%102 = fdiv <4 x float> %101, %95
%103 = fmul <4 x float> %102, %102
%104 = fmul <4 x float> %103, %103
%105 = fmul <4 x float> %103, %104
%106 = fmul <4 x float> %103, %105
%107 = fadd <4 x float> %106, <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
%108 = fdiv <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %107
%109 = shl i64 %98, 1
%110 = or i64 %109, 2
%111 = getelementptr inbounds float, float* %0, i64 %110
%112 = bitcast float* %111 to <8 x float>*
%113 = load <8 x float>, <8 x float>* %112
%114 = shufflevector <8 x float> %113, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%115 = shufflevector <8 x float> %113, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%116 = fmul <4 x float> %108, %114
%117 = or i64 %109, 3
%118 = fmul <4 x float> %108, %115
%119 = getelementptr inbounds float, float* %96, i64 %117
%120 = bitcast float* %119 to <8 x float>*
%121 = shufflevector <4 x float> %116, <4 x float> %118, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %121, <8 x float>* %120
%122 = add nuw i64 %98, 4
%123 = add <4 x i32> %99, <i32 4, i32 4, i32 4, i32 4>
%124 = icmp eq i64 %122, %90
br i1 %124, label %125, label %97
125: ; preds = %97
%126 = icmp eq i64 %87, %90
br i1 %126, label %151, label %127
127: ; preds = %84, %125
%128 = phi i64 [ 1, %84 ], [ %91, %125 ]
br label %129
129: ; preds = %127, %129
%130 = phi i64 [ %149, %129 ], [ %128, %127 ]
%131 = trunc i64 %130 to i32
%132 = sitofp i32 %131 to float
%133 = fmul float %82, %132
%134 = fdiv float %133, %79
%135 = fmul float %134, %134
%136 = fmul float %135, %135
%137 = fmul float %135, %136
%138 = fmul float %135, %137
%139 = fadd float %138, 1.000000e+00
%140 = fdiv float 1.000000e+00, %139
%141 = shl nuw nsw i64 %130, 1
%142 = getelementptr inbounds float, float* %0, i64 %141
%143 = load float, float* %142
%144 = fmul float %140, %143
store float %144, float* %142
%145 = or i64 %141, 1
%146 = getelementptr inbounds float, float* %0, i64 %145
%147 = load float, float* %146
%148 = fmul float %140, %147
store float %148, float* %146
%149 = add nuw nsw i64 %130, 1
%150 = icmp eq i64 %149, %86
br i1 %150, label %151, label %129
151: ; preds = %129, %125, %74
%152 = add nsw i32 %5, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %0, i64 %153
store float 0.000000e+00, float* %154
%155 = sext i32 %5 to i64
%156 = getelementptr inbounds float, float* %0, i64 %155
store float 0.000000e+00, float* %156
br label %157
157: ; preds = %72, %151, %65
%158 = icmp sgt i32 %5, 3
br i1 %158, label %159, label %181
159: ; preds = %157
%160 = lshr i32 %5, 1
%161 = zext i32 %160 to i64
br label %162
162: ; preds = %159, %162
%163 = phi i64 [ 1, %159 ], [ %179, %162 ]
%164 = shl nuw nsw i64 %163, 1
%165 = getelementptr inbounds float, float* %0, i64 %164
%166 = load float, float* %165
%167 = trunc i64 %163 to i32
%168 = sub i32 %5, %167
%169 = shl nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %0, i64 %170
store float %166, float* %171
%172 = or i64 %164, 1
%173 = getelementptr inbounds float, float* %0, i64 %172
%174 = load float, float* %173
%175 = fneg float %174
%176 = or i32 %169, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %0, i64 %177
store float %175, float* %178
%179 = add nuw nsw i64 %163, 1
%180 = icmp eq i64 %179, %161
br i1 %180, label %181, label %162
181: ; preds = %162, %157
%182 = call i32 (float*, i32*, i32*, float*, ...) bitcast (i32 (...)* @fourg_ to i32 (float*, i32*, i32*, float*, ...)*)(float* %0, i32* %10, i32* %12, float* %7)
%183 = load i32, i32* %10
%184 = icmp sgt i32 %183, 0
br i1 %184, label %185, label %230
185: ; preds = %181
%186 = zext i32 %183 to i64
%187 = add nsw i64 %186, -1
%188 = and i64 %186, 3
%189 = icmp ult i64 %187, 3
br i1 %189, label %217, label %190
190: ; preds = %185
%191 = and i64 %186, 4294967292
br label %192
192: ; preds = %192, %190
%193 = phi i64 [ 0, %190 ], [ %214, %192 ]
%194 = phi i64 [ 0, %190 ], [ %215, %192 ]
%195 = shl nuw nsw i64 %193, 1
%196 = getelementptr inbounds float, float* %0, i64 %195
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %0, i64 %193
store float %197, float* %198
%199 = or i64 %193, 1
%200 = shl nuw nsw i64 %199, 1
%201 = getelementptr inbounds float, float* %0, i64 %200
%202 = load float, float* %201
%203 = getelementptr inbounds float, float* %0, i64 %199
store float %202, float* %203
%204 = or i64 %193, 2
%205 = shl nuw nsw i64 %204, 1
%206 = getelementptr inbounds float, float* %0, i64 %205
%207 = load float, float* %206
%208 = getelementptr inbounds float, float* %0, i64 %204
store float %207, float* %208
%209 = or i64 %193, 3
%210 = shl nuw nsw i64 %209, 1
%211 = getelementptr inbounds float, float* %0, i64 %210
%212 = load float, float* %211
%213 = getelementptr inbounds float, float* %0, i64 %209
store float %212, float* %213
%214 = add nuw nsw i64 %193, 4
%215 = add i64 %194, 4
%216 = icmp eq i64 %215, %191
br i1 %216, label %217, label %192
217: ; preds = %192, %185
%218 = phi i64 [ 0, %185 ], [ %214, %192 ]
%219 = icmp eq i64 %188, 0
br i1 %219, label %230, label %220
220: ; preds = %217, %220
%221 = phi i64 [ %227, %220 ], [ %218, %217 ]
%222 = phi i64 [ %228, %220 ], [ 0, %217 ]
%223 = shl nuw nsw i64 %221, 1
%224 = getelementptr inbounds float, float* %0, i64 %223
%225 = load float, float* %224
%226 = getelementptr inbounds float, float* %0, i64 %221
store float %225, float* %226
%227 = add nuw nsw i64 %221, 1
%228 = add i64 %222, 1
%229 = icmp eq i64 %228, %188
br i1 %229, label %230, label %220
230: ; preds = %217, %220, %181
%231 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @norm to i32 (float*, float*, i32, ...)*)(float* %0, float* %6, i32 %183)
ret void
}