resample(g, samp, nt) float *g, *samp;
int nt;
{
  float fac;
  int i, isamp, it;
  float *s;
  if (*samp < 1.0) {
    isamp = (int)(1.0 / (*samp) + 0.5);
    for (it = 0; it < nt * (*samp); it++)
      g[it] = g[it * isamp];
  } else {
    s = (float *)check_malloc(((int)(nt * (*samp))) * sizeof(float));
    isamp = (int)(*samp);
    for (it = 0; it < nt - 1; it++) {
      fac = (g[it + 1] - g[it]) / (*samp);
      for (i = 0; i < isamp; i++)
        s[it * isamp + i] = g[it] + i * fac;
    }
    for (it = (nt - 1) * isamp; it < (nt * isamp); it++)
      s[it] = g[(nt - 1) * isamp - 1];
    for (it = 0; it < (nt * isamp); it++)
      g[it] = s[it];
    free(s);
  }
}


x86 assembly (clang, -O0):
<resample>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeb9(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    11d1 <resample+0xb1>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe9b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0xe97(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cvtsi2ssl -0x2c(%rbp),%xmm1
cvtsi2ssl -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  (%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    11cc <resample+0xac>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1183 <resample+0x63>
jmp    134b <resample+0x22b>
cvtsi2ssl -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  (%rax),%xmm0
cvttss2si %xmm0,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1040 <check_malloc@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
cvttss2si (%rax),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12ae <resample+0x18e>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    129b <resample+0x17b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    124c <resample+0x12c>
jmp    12a0 <resample+0x180>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1208 <resample+0xe8>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1301 <resample+0x1e1>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12bb <resample+0x19b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1342 <resample+0x222>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1308 <resample+0x1e8>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<resample>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
movss  (%rsi),%xmm1
movss  0xec0(%rip),%xmm0
ucomiss %xmm1,%xmm0
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm0,%xmm2
jbe    11ba <resample+0x9a>
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm2
jbe    169c <resample+0x57c>
cvtss2sd %xmm1,%xmm1
movsd  0xed5(%rip),%xmm2
divsd  %xmm1,%xmm2
addsd  0xed1(%rip),%xmm2
cvttsd2si %xmm2,%eax
cltq
shl    $0x2,%rax
xor    %ecx,%ecx
mov    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%rcx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
movss  (%r14),%xmm2
mulss  %xmm0,%xmm2
add    %rax,%rdx
ucomiss %xmm1,%xmm2
ja     1190 <resample+0x70>
jmp    169c <resample+0x57c>
mov    %edx,%ebp
cvttss2si %xmm2,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1040 <check_malloc@plt>
movslq %eax,%r11
movss  (%r14),%xmm5
cvttss2si %xmm5,%r13d
lea    -0x1(%rbp),%eax
mov    %eax,0x4(%rsp)
mov    %rbp,0x18(%rsp)
cmp    $0x2,%ebp
jl     13ca <resample+0x2aa>
mov    %r14,%rbp
movslq %r13d,%rcx
mov    0x4(%rsp),%eax
mov    %rax,0x30(%rsp)
mov    %ecx,%eax
lea    -0x1(%rax),%rdx
mov    %rdx,0x8(%rsp)
and    $0xfffffffffffffff8,%rdx
lea    0x1(%rdx),%rsi
mov    %rsi,0x10(%rsp)
mov    %rax,%rsi
neg    %rsi
mov    %rsi,0x20(%rsp)
lea    0x14(%r11),%rsi
mov    %rcx,0x28(%rsp)
lea    0x0(,%rcx,4),%r15
xor    %r8d,%r8d
xorps  %xmm9,%xmm9
movdqa 0xdcd(%rip),%xmm8
movdqa 0xdd5(%rip),%xmm2
movdqa 0xddd(%rip),%xmm3
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r8),%r14
test   %r13d,%r13d
jle    13b0 <resample+0x290>
mov    %r8,%r12
imul   0x28(%rsp),%r12
movss  (%rbx,%r8,4),%xmm6
movss  0x4(%rbx,%r8,4),%xmm4
subss  %xmm6,%xmm4
divss  %xmm5,%xmm4
movaps %xmm4,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,(%r11,%r12,4)
cmp    $0x1,%r13d
je     13b0 <resample+0x290>
mov    $0x1,%r10d
cmpq   $0x8,0x8(%rsp)
jb     1340 <resample+0x220>
lea    (%r11,%r12,4),%rcx
add    $0x4,%rcx
mov    %rbp,%r9
lea    (%rbx,%r8,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rcx
mov    %r9,%rbp
jae    12e8 <resample+0x1c8>
lea    (%r12,%rax,1),%rcx
lea    (%r11,%rcx,4),%rcx
lea    (%rbx,%r8,4),%rbp
cmp    %rcx,%rbp
mov    %r9,%rbp
jb     1340 <resample+0x220>
movaps %xmm4,%xmm5
shufps $0x0,%xmm4,%xmm5
movss  (%rbx,%r8,4),%xmm6
shufps $0x0,%xmm6,%xmm6
xor    %ecx,%ecx
movdqa %xmm8,%xmm7
movdqa %xmm7,%xmm1
paddd  %xmm2,%xmm1
cvtdq2ps %xmm7,%xmm0
cvtdq2ps %xmm1,%xmm1
mulps  %xmm5,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm5,%xmm1
addps  %xmm6,%xmm1
movups %xmm0,-0x10(%rsi,%rcx,4)
movups %xmm1,(%rsi,%rcx,4)
add    $0x8,%rcx
paddd  %xmm3,%xmm7
cmp    %rcx,%rdx
jne    1300 <resample+0x1e0>
mov    0x10(%rsp),%r10
cmp    %rdx,0x8(%rsp)
je     13b0 <resample+0x290>
nopl   0x0(%rax)
mov    %r10,%r9
test   $0x1,%al
jne    1366 <resample+0x246>
xorps  %xmm0,%xmm0
cvtsi2ss %r10d,%xmm0
mulss  %xmm4,%xmm0
addss  (%rbx,%r8,4),%xmm0
add    %r10,%r12
movss  %xmm0,(%r11,%r12,4)
lea    0x1(%r10),%r9
not    %r10
cmp    0x20(%rsp),%r10
je     13b0 <resample+0x290>
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
mulss  %xmm4,%xmm0
addss  (%rbx,%r8,4),%xmm0
lea    0x1(%r9),%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
movss  %xmm0,(%rdi,%r9,4)
mulss  %xmm4,%xmm1
addss  (%rbx,%r8,4),%xmm1
movss  %xmm1,0x4(%rdi,%r9,4)
add    $0x2,%r9
cmp    %rax,%r9
jne    1370 <resample+0x250>
nopl   (%rax)
cmp    0x30(%rsp),%r14
je     13ca <resample+0x2aa>
movss  0x0(%rbp),%xmm5
add    %r15,%rsi
add    %r15,%rdi
mov    %r14,%r8
jmp    1260 <resample+0x140>
mov    0x4(%rsp),%eax
imul   %r13d,%eax
mov    0x18(%rsp),%r14
imul   %r13d,%r14d
cmp    %r14d,%eax
jge    1524 <resample+0x404>
cltq
lea    (%rbx,%rax,4),%rcx
add    $0xfffffffffffffffc,%rcx
movslq %r14d,%rdx
mov    %rdx,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jb     14b1 <resample+0x391>
lea    -0x1(%rax),%rsi
lea    (%r11,%rax,4),%rdi
lea    (%rbx,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdi
jae    1423 <resample+0x303>
lea    (%r11,%rdx,4),%rsi
cmp    %rsi,%rcx
jb     14b1 <resample+0x391>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     16ab <resample+0x58b>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %r9,%rbp
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%r11,%rax,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm0,-0x20(%rsi,%rdi,4)
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm0,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1470 <resample+0x350>
test   $0x1,%r9b
je     14a9 <resample+0x389>
add    %rax,%rdi
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,(%r11,%rdi,4)
movups %xmm0,0x10(%r11,%rdi,4)
cmp    %r8,%r10
je     1524 <resample+0x404>
add    %r8,%rax
mov    %r14d,%edi
sub    %eax,%edi
mov    %rax,%rsi
not    %rsi
add    %rdx,%rsi
and    $0x3,%rdi
je     14e4 <resample+0x3c4>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx),%xmm0
movss  %xmm0,(%r11,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    14d0 <resample+0x3b0>
cmp    $0x3,%rsi
jb     1524 <resample+0x404>
nopw   0x0(%rax,%rax,1)
movss  (%rcx),%xmm0
movss  %xmm0,(%r11,%rax,4)
movss  (%rcx),%xmm0
movss  %xmm0,0x4(%r11,%rax,4)
movss  (%rcx),%xmm0
movss  %xmm0,0x8(%r11,%rax,4)
movss  (%rcx),%xmm0
movss  %xmm0,0xc(%r11,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    14f0 <resample+0x3d0>
test   %r14d,%r14d
jle    1694 <resample+0x574>
mov    %r14d,%eax
cmp    $0x8,%r14d
jb     154c <resample+0x42c>
lea    (%r11,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    15c0 <resample+0x4a0>
lea    (%rbx,%rax,4),%rcx
cmp    %rcx,%r11
jae    15c0 <resample+0x4a0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1575 <resample+0x455>
movss  (%r11,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1560 <resample+0x440>
cmp    $0x3,%rdx
jb     1694 <resample+0x574>
nop
movss  (%r11,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%r11,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x8(%r11,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movss  0xc(%r11,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1580 <resample+0x460>
jmp    1694 <resample+0x574>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    15e3 <resample+0x4c3>
xor    %edi,%edi
jmp    1650 <resample+0x530>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%r11,%rdi,4),%xmm0
movups 0x10(%r11,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x20(%r11,%rdi,4),%xmm0
movups 0x30(%r11,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups 0x40(%r11,%rdi,4),%xmm0
movups 0x50(%r11,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups 0x60(%r11,%rdi,4),%xmm0
movups 0x70(%r11,%rdi,4),%xmm1
movups %xmm0,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    15f0 <resample+0x4d0>
test   %rdx,%rdx
je     168b <resample+0x56b>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r11,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1670 <resample+0x550>
cmp    %rax,%rcx
jne    154e <resample+0x42e>
mov    %r11,%rdi
call   1030 <free@plt>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    1493 <resample+0x373>
jmp    14a9 <resample+0x389>

LLVM IR (-O0):
define i32 @resample(float* %0, float* %1, i32 %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
%8 = alloca float
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float*
store float* %0, float** %5
store float* %1, float** %6
store i32 %2, i32* %7
%13 = load float*, float** %6
%14 = load float, float* %13
%15 = fpext float %14 to double
%16 = fcmp olt double %15, 1.000000e+00
br i1 %16, label %17, label %49
17: ; preds = %3
%18 = load float*, float** %6
%19 = load float, float* %18
%20 = fpext float %19 to double
%21 = fdiv double 1.000000e+00, %20
%22 = fadd double %21, 5.000000e-01
%23 = fptosi double %22 to i32
store i32 %23, i32* %10
store i32 0, i32* %11
br label %24
24: ; preds = %45, %17
%25 = load i32, i32* %11
%26 = sitofp i32 %25 to float
%27 = load i32, i32* %7
%28 = sitofp i32 %27 to float
%29 = load float*, float** %6
%30 = load float, float* %29
%31 = fmul float %28, %30
%32 = fcmp olt float %26, %31
br i1 %32, label %33, label %48
33: ; preds = %24
%34 = load float*, float** %5
%35 = load i32, i32* %11
%36 = load i32, i32* %10
%37 = mul nsw i32 %35, %36
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %34, i64 %38
%40 = load float, float* %39
%41 = load float*, float** %5
%42 = load i32, i32* %11
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
store float %40, float* %44
br label %45
45: ; preds = %33
%46 = load i32, i32* %11
%47 = add nsw i32 %46, 1
store i32 %47, i32* %11
br label %24
48: ; preds = %24
br label %165
49: ; preds = %3
%50 = load i32, i32* %7
%51 = sitofp i32 %50 to float
%52 = load float*, float** %6
%53 = load float, float* %52
%54 = fmul float %51, %53
%55 = fptosi float %54 to i32
%56 = sext i32 %55 to i64
%57 = mul i64 %56, 4
%58 = call i32 (i64, ...) bitcast (i32 (...)* @check_malloc to i32 (i64, ...)*)(i64 %57)
%59 = sext i32 %58 to i64
%60 = inttoptr i64 %59 to float*
store float* %60, float** %12
%61 = load float*, float** %6
%62 = load float, float* %61
%63 = fptosi float %62 to i32
store i32 %63, i32* %10
store i32 0, i32* %11
br label %64
64: ; preds = %111, %49
%65 = load i32, i32* %11
%66 = load i32, i32* %7
%67 = sub nsw i32 %66, 1
%68 = icmp slt i32 %65, %67
br i1 %68, label %69, label %114
69: ; preds = %64
%70 = load float*, float** %5
%71 = load i32, i32* %11
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %70, i64 %73
%75 = load float, float* %74
%76 = load float*, float** %5
%77 = load i32, i32* %11
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %76, i64 %78
%80 = load float, float* %79
%81 = fsub float %75, %80
%82 = load float*, float** %6
%83 = load float, float* %82
%84 = fdiv float %81, %83
store float %84, float* %8
store i32 0, i32* %9
br label %85
85: ; preds = %107, %69
%86 = load i32, i32* %9
%87 = load i32, i32* %10
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %110
89: ; preds = %85
%90 = load float*, float** %5
%91 = load i32, i32* %11
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %90, i64 %92
%94 = load float, float* %93
%95 = load i32, i32* %9
%96 = sitofp i32 %95 to float
%97 = load float, float* %8
%98 = call float @llvm.fmuladd.f32(float %96, float %97, float %94)
%99 = load float*, float** %12
%100 = load i32, i32* %11
%101 = load i32, i32* %10
%102 = mul nsw i32 %100, %101
%103 = load i32, i32* %9
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %99, i64 %105
store float %98, float* %106
br label %107
107: ; preds = %89
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
store i32 %109, i32* %9
br label %85
110: ; preds = %85
br label %111
111: ; preds = %110
%112 = load i32, i32* %11
%113 = add nsw i32 %112, 1
store i32 %113, i32* %11
br label %64
114: ; preds = %64
%115 = load i32, i32* %7
%116 = sub nsw i32 %115, 1
%117 = load i32, i32* %10
%118 = mul nsw i32 %116, %117
store i32 %118, i32* %11
br label %119
119: ; preds = %139, %114
%120 = load i32, i32* %11
%121 = load i32, i32* %7
%122 = load i32, i32* %10
%123 = mul nsw i32 %121, %122
%124 = icmp slt i32 %120, %123
br i1 %124, label %125, label %142
125: ; preds = %119
%126 = load float*, float** %5
%127 = load i32, i32* %7
%128 = sub nsw i32 %127, 1
%129 = load i32, i32* %10
%130 = mul nsw i32 %128, %129
%131 = sub nsw i32 %130, 1
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %126, i64 %132
%134 = load float, float* %133
%135 = load float*, float** %12
%136 = load i32, i32* %11
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
store float %134, float* %138
br label %139
139: ; preds = %125
%140 = load i32, i32* %11
%141 = add nsw i32 %140, 1
store i32 %141, i32* %11
br label %119
142: ; preds = %119
store i32 0, i32* %11
br label %143
143: ; preds = %159, %142
%144 = load i32, i32* %11
%145 = load i32, i32* %7
%146 = load i32, i32* %10
%147 = mul nsw i32 %145, %146
%148 = icmp slt i32 %144, %147
br i1 %148, label %149, label %162
149: ; preds = %143
%150 = load float*, float** %12
%151 = load i32, i32* %11
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
%154 = load float, float* %153
%155 = load float*, float** %5
%156 = load i32, i32* %11
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
store float %154, float* %158
br label %159
159: ; preds = %149
%160 = load i32, i32* %11
%161 = add nsw i32 %160, 1
store i32 %161, i32* %11
br label %143
162: ; preds = %143
%163 = load float*, float** %12
%164 = bitcast float* %163 to i8*
br label %165
165: ; preds = %162, %48
%166 = load i32, i32* %4
ret i32 %166
}

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