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

/* Forward declarations */

/* Type definitions */
struct complex {
  int dummy;
};

/* Variables and functions */
scalar_t__ check_malloc(int);
double cos(float);
int /*<<< orphan*/ forfft(float *, int, int);
int /*<<< orphan*/ invfft(float *, int, int);
float sfrand(long *);
int /*<<< orphan*/ wfilt(struct complex *, int, float *, float *);
void randomize(float *st, int nt, float *rand, float *dt, float *f0, long *seed,
               int pos_only) {
  int it, ntp2, tapl;
  float rfac, rmax, *rt;
  float arg;
  float amax = -99.0;
  int itzero = 0;
  int nzflag = 0;
  for (it = 0; it < nt; it++) {
    if (st[it] > amax)
      amax = st[it];
    if (st[it] == (float)(0.0) && nzflag)
      itzero = it;
    if (st[it] != (float)(0.0))
      nzflag = 1;
    else
      nzflag = 0;
  }
  ntp2 = 2;
  while (itzero > ntp2)
    ntp2 = ntp2 * 2;
  rt = (float *)check_malloc(ntp2 * sizeof(float));
  for (it = 0; it < ntp2; it++)
    rt[it] = sfrand(seed);
  forfft(rt, ntp2, -1);
  wfilt((struct complex *)rt, ntp2, dt, f0);
  invfft(rt, ntp2, 1);
  tapl = (int)(0.5 / ((*f0) * (*dt)));
  for (it = 0; it < tapl; it++) {
    arg = it * 3.141592654 / tapl;
    rt[it] = 0.5 * (1.0 - cos(arg)) * rt[it];
    rt[itzero - it - 1] = 0.5 * (1.0 - cos(arg)) * rt[itzero - it - 1];
  }
  rmax = 0.0;
  for (it = 0; it < itzero; it++) {
    if (rt[it] > rmax)
      rmax = rt[it];
    if (-rt[it] > rmax)
      rmax = -rt[it];
  }
  rfac = (*rand) * amax / rmax;
  for (it = 0; it < itzero; it++) {
    st[it] = st[it] + rfac * rt[it];
    if (st[it] < 0.0 && pos_only)
      st[it] = 0.0;
  }
}


x86 assembly (clang, -O0):
<randomize>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  0xe76(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1252 <randomize+0xf2>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    11d9 <randomize+0x79>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1208 <randomize+0xa8>
jp     1208 <randomize+0xa8>
cmpl   $0x0,-0x60(%rbp)
je     1208 <randomize+0xa8>
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    122c <randomize+0xcc>
jp     122c <randomize+0xcc>
jmp    1238 <randomize+0xd8>
movl   $0x1,-0x60(%rbp)
jmp    123f <randomize+0xdf>
movl   $0x0,-0x60(%rbp)
jmp    1244 <randomize+0xe4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a4 <randomize+0x44>
movl   $0x2,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1273 <randomize+0x113>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1259 <randomize+0xf9>
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <check_malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    12bd <randomize+0x15d>
mov    -0x30(%rbp),%rdi
call   1040 <sfrand@plt>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128d <randomize+0x12d>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    $0xffffffff,%edx
call   1080 <forfft@plt>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1050 <wfilt@plt>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    $0x1,%edx
call   1030 <invfft@plt>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcf9(%rip),%xmm0
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13fe <randomize+0x29e>
cvtsi2sdl -0x34(%rbp),%xmm0
movsd  0xcde(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x3c(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
call   1070 <cos@plt>
movsd  0xcae(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xc9a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
call   1070 <cos@plt>
movsd  0xc66(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xc52(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1321 <randomize+0x1c1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1498 <randomize+0x338>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    1442 <randomize+0x2e2>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    1485 <randomize+0x325>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    148a <randomize+0x32a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    140d <randomize+0x2ad>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x58(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1541 <randomize+0x3e1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x40(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    152e <randomize+0x3ce>
cmpl   $0x0,0x10(%rbp)
je     152e <randomize+0x3ce>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1533 <randomize+0x3d3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b6 <randomize+0x356>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<randomize>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%rbp
mov    %r8,(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rdx,0x10(%rsp)
test   %esi,%esi
jle    119e <randomize+0x3e>
mov    %esi,%ecx
cmp    $0x1,%esi
jne    11ae <randomize+0x4e>
movss  0xe6e(%rip),%xmm4
xor    %eax,%eax
xor    %edx,%edx
xor    %r12d,%r12d
jmp    122a <randomize+0xca>
xor    %r12d,%r12d
movss  0xe57(%rip),%xmm4
jmp    1252 <randomize+0xf2>
mov    %ecx,%esi
and    $0xfffffffe,%esi
movss  0xe45(%rip),%xmm4
xor    %eax,%eax
xorps  %xmm0,%xmm0
xor    %edx,%edx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi,%rax,4),%xmm1
movss  0x4(%rdi,%rax,4),%xmm2
ucomiss %xmm1,%xmm0
mov    %eax,%ebx
cmovne %r12d,%ebx
cmovp  %r12d,%ebx
test   %edx,%edx
cmove  %r12d,%ebx
lea    0x1(%rax),%edx
ucomiss %xmm2,%xmm0
cmovne %ebx,%edx
cmovp  %ebx,%edx
ucomiss %xmm1,%xmm0
cmovne %edx,%ebx
mov    %ebx,%r12d
cmovp  %edx,%r12d
maxss  %xmm4,%xmm1
xorps  %xmm3,%xmm3
cmpneqss %xmm2,%xmm3
movaps %xmm2,%xmm4
maxss  %xmm1,%xmm4
movd   %xmm3,%edx
and    $0x1,%edx
add    $0x2,%rax
cmp    %rsi,%rax
jne    11d0 <randomize+0x70>
test   $0x1,%cl
je     1252 <randomize+0xf2>
movss  (%rdi,%rax,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
cmovne %r12d,%eax
cmovp  %r12d,%eax
maxss  %xmm4,%xmm0
test   %edx,%edx
cmove  %r12d,%eax
movaps %xmm0,%xmm4
mov    %eax,%r12d
movaps %xmm4,0x20(%rsp)
mov    %rdi,0x18(%rsp)
mov    $0x2,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%r15d
lea    (%r15,%r15,1),%eax
cmp    %r15d,%r12d
jg     1270 <randomize+0x110>
lea    0x0(,%r15,4),%edi
call   1060 <check_malloc@plt>
mov    %rax,%r13
cmp    $0x2,%r15d
mov    $0x1,%ebx
cmovae %r15d,%ebx
xor    %r14d,%r14d
nopl   0x0(%rax)
mov    %rbp,%rdi
call   1040 <sfrand@plt>
movss  %xmm0,0x0(%r13,%r14,4)
add    $0x1,%r14
cmp    %r14,%rbx
jne    12a0 <randomize+0x140>
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0xffffffff,%edx
call   1080 <forfft@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    0x8(%rsp),%rbx
mov    %rbx,%rdx
mov    (%rsp),%rbp
mov    %rbp,%rcx
call   1050 <wfilt@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
call   1030 <invfft@plt>
movss  0x0(%rbp),%xmm0
mulss  (%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd01(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%eax
test   %eax,%eax
jle    13d1 <randomize+0x271>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rsp)
mov    %eax,%r15d
lea    -0x1(%r12),%ebp
xor    %ebx,%ebx
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd  0xcd1(%rip),%xmm0
divsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
call   1070 <cos@plt>
movsd  0xcbd(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0xca1(%rip),%xmm1
movss  0x0(%r13,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
movss  0x8(%rsp),%xmm0
call   1070 <cos@plt>
movsd  0xc74(%rip),%xmm2
movsd  0xc7c(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
movslq %ebp,%rbp
movss  0x0(%r13,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbx
add    $0xffffffff,%ebp
cmp    %rbx,%r15
jne    1330 <randomize+0x1d0>
test   %r12d,%r12d
mov    0x18(%rsp),%rdi
movaps 0x20(%rsp),%xmm7
mov    0x70(%rsp),%ebp
jle    15de <randomize+0x47e>
mov    %r12d,%eax
cmp    $0x1,%r12d
jne    13f8 <randomize+0x298>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1446 <randomize+0x2e6>
mov    %eax,%edx
and    $0xfffffffe,%edx
xorps  %xmm2,%xmm2
xor    %ecx,%ecx
movaps 0xc17(%rip),%xmm1
nopl   0x0(%rax)
movss  0x0(%r13,%rcx,4),%xmm3
movss  0x4(%r13,%rcx,4),%xmm0
movaps %xmm3,%xmm4
maxss  %xmm2,%xmm4
xorps  %xmm1,%xmm3
maxss  %xmm4,%xmm3
movaps %xmm0,%xmm2
maxss  %xmm3,%xmm2
xorps  %xmm1,%xmm0
maxss  %xmm2,%xmm0
add    $0x2,%rcx
movaps %xmm0,%xmm2
cmp    %rcx,%rdx
jne    1410 <randomize+0x2b0>
test   $0x1,%al
je     1466 <randomize+0x306>
movss  0x0(%r13,%rcx,4),%xmm1
movaps %xmm1,%xmm2
maxss  %xmm0,%xmm2
xorps  0xbc1(%rip),%xmm1
maxss  %xmm2,%xmm1
movaps %xmm1,%xmm0
test   %r12d,%r12d
jle    15de <randomize+0x47e>
mov    0x10(%rsp),%rcx
mulss  (%rcx),%xmm7
divss  %xmm0,%xmm7
cmp    $0x8,%r12d
jb     14a3 <randomize+0x343>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %rdi,%rcx
jbe    1535 <randomize+0x3d5>
lea    (%rdi,%rax,4),%rcx
cmp    %rcx,%r13
jae    1535 <randomize+0x3d5>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     14d6 <randomize+0x376>
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm7,%xmm0
addss  (%rdi,%rcx,4),%xmm0
test   %ebp,%ebp
je     14cd <randomize+0x36d>
xorps  %xmm1,%xmm1
maxss  %xmm0,%xmm1
movaps %xmm1,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
jne    14f3 <randomize+0x393>
jmp    15de <randomize+0x47e>
movss  %xmm0,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
je     15de <randomize+0x47e>
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm7,%xmm0
addss  (%rdi,%rcx,4),%xmm0
test   %ebp,%ebp
je     1511 <randomize+0x3b1>
xorps  %xmm1,%xmm1
maxss  %xmm0,%xmm1
movaps %xmm1,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm0
mulss  %xmm7,%xmm0
addss  0x4(%rdi,%rcx,4),%xmm0
je     14e0 <randomize+0x380>
xorps  %xmm1,%xmm1
maxss  %xmm0,%xmm1
movaps %xmm1,%xmm0
jmp    14e0 <randomize+0x380>
xor    %edx,%edx
test   %ebp,%ebp
setne  %dl
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm1
lea    0x0(,%rax,4),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
xorps  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rsi,1),%xmm3
movups 0x10(%rdi,%rsi,1),%xmm4
movups 0x0(%r13,%rsi,1),%xmm5
movups 0x10(%r13,%rsi,1),%xmm6
mulps  %xmm0,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm0,%xmm6
addps  %xmm4,%xmm6
movaps %xmm5,%xmm3
cmpltps %xmm2,%xmm3
movaps %xmm6,%xmm4
cmpltps %xmm2,%xmm4
andps  %xmm1,%xmm3
pslld  $0x1f,%xmm3
psrad  $0x1f,%xmm3
andps  %xmm1,%xmm4
pslld  $0x1f,%xmm4
psrad  $0x1f,%xmm4
pandn  %xmm5,%xmm3
pandn  %xmm6,%xmm4
movdqu %xmm3,(%rdi,%rsi,1)
movdqu %xmm4,0x10(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1570 <randomize+0x410>
cmp    %rax,%rcx
jne    14a5 <randomize+0x345>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.complex = type { i32 }
define void @randomize(float* nocapture %0, i32 %1, float* nocapture %2, float* %3, float* %4, i64* %5, i32 %6) {
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %33
9: ; preds = %7
%10 = zext i32 %1 to i64
%11 = and i64 %10, 1
%12 = icmp eq i32 %1, 1
br i1 %12, label %15, label %13
13: ; preds = %9
%14 = and i64 %10, 4294967294
br label %36
15: ; preds = %36, %9
%16 = phi float [ undef, %9 ], [ %56, %36 ]
%17 = phi i32 [ undef, %9 ], [ %60, %36 ]
%18 = phi i64 [ 0, %9 ], [ %63, %36 ]
%19 = phi i32 [ 0, %9 ], [ %62, %36 ]
%20 = phi i32 [ 0, %9 ], [ %60, %36 ]
%21 = phi float [ -9.900000e+01, %9 ], [ %56, %36 ]
%22 = icmp eq i64 %11, 0
br i1 %22, label %33, label %23
23: ; preds = %15
%24 = getelementptr inbounds float, float* %0, i64 %18
%25 = load float, float* %24
%26 = fcmp ogt float %25, %21
%27 = select i1 %26, float %25, float %21
%28 = fcmp oeq float %25, 0.000000e+00
%29 = icmp ne i32 %19, 0
%30 = and i1 %29, %28
%31 = trunc i64 %18 to i32
%32 = select i1 %30, i32 %31, i32 %20
br label %33
33: ; preds = %23, %15, %7
%34 = phi float [ -9.900000e+01, %7 ], [ %16, %15 ], [ %27, %23 ]
%35 = phi i32 [ 0, %7 ], [ %17, %15 ], [ %32, %23 ]
br label %66
36: ; preds = %36, %13
%37 = phi i64 [ 0, %13 ], [ %63, %36 ]
%38 = phi i32 [ 0, %13 ], [ %62, %36 ]
%39 = phi i32 [ 0, %13 ], [ %60, %36 ]
%40 = phi float [ -9.900000e+01, %13 ], [ %56, %36 ]
%41 = phi i64 [ 0, %13 ], [ %64, %36 ]
%42 = getelementptr inbounds float, float* %0, i64 %37
%43 = load float, float* %42
%44 = fcmp ogt float %43, %40
%45 = select i1 %44, float %43, float %40
%46 = fcmp oeq float %43, 0.000000e+00
%47 = icmp ne i32 %38, 0
%48 = and i1 %47, %46
%49 = trunc i64 %37 to i32
%50 = select i1 %48, i32 %49, i32 %39
%51 = fcmp une float %43, 0.000000e+00
%52 = or i64 %37, 1
%53 = getelementptr inbounds float, float* %0, i64 %52
%54 = load float, float* %53
%55 = fcmp ogt float %54, %45
%56 = select i1 %55, float %54, float %45
%57 = fcmp oeq float %54, 0.000000e+00
%58 = and i1 %51, %57
%59 = trunc i64 %52 to i32
%60 = select i1 %58, i32 %59, i32 %50
%61 = fcmp une float %54, 0.000000e+00
%62 = zext i1 %61 to i32
%63 = add nuw nsw i64 %37, 2
%64 = add i64 %41, 2
%65 = icmp eq i64 %64, %14
br i1 %65, label %15, label %36
66: ; preds = %66, %33
%67 = phi i32 [ %69, %66 ], [ 2, %33 ]
%68 = icmp sgt i32 %35, %67
%69 = shl nsw i32 %67, 1
br i1 %68, label %66, label %70
70: ; preds = %66
%71 = shl i32 %67, 2
%72 = tail call i64 @check_malloc(i32 %71)
%73 = inttoptr i64 %72 to float*
%74 = inttoptr i64 %72 to i8*
%75 = call i32 @llvm.umax.i32(i32 %67, i32 1)
%76 = zext i32 %75 to i64
br label %77
77: ; preds = %70, %77
%78 = phi i64 [ 0, %70 ], [ %81, %77 ]
%79 = tail call float @sfrand(i64* %5)
%80 = getelementptr inbounds float, float* %73, i64 %78
store float %79, float* %80
%81 = add nuw nsw i64 %78, 1
%82 = icmp eq i64 %81, %76
br i1 %82, label %83, label %77
83: ; preds = %77
%84 = tail call i32 @forfft(float* %73, i32 %67, i32 -1)
%85 = inttoptr i64 %72 to %struct.complex*
%86 = tail call i32 @wfilt(%struct.complex* %85, i32 %67, float* %3, float* %4)
%87 = tail call i32 @invfft(float* %73, i32 %67, i32 1)
%88 = load float, float* %4
%89 = load float, float* %3
%90 = fmul float %88, %89
%91 = fpext float %90 to double
%92 = fdiv double 5.000000e-01, %91
%93 = fptosi double %92 to i32
%94 = icmp sgt i32 %93, 0
br i1 %94, label %95, label %98
95: ; preds = %83
%96 = sitofp i32 %93 to double
%97 = zext i32 %93 to i64
br label %106
98: ; preds = %106, %83
%99 = icmp sgt i32 %35, 0
br i1 %99, label %100, label %264
100: ; preds = %98
%101 = zext i32 %35 to i64
%102 = and i64 %101, 1
%103 = icmp eq i32 %35, 1
br i1 %103, label %157, label %104
104: ; preds = %100
%105 = and i64 %101, 4294967294
br label %135
106: ; preds = %95, %106
%107 = phi i64 [ 0, %95 ], [ %133, %106 ]
%108 = trunc i64 %107 to i32
%109 = sitofp i32 %108 to double
%110 = fmul double %109, 0x400921FB54524550
%111 = fdiv double %110, %96
%112 = fptrunc double %111 to float
%113 = tail call double @cos(float %112)
%114 = fsub double 1.000000e+00, %113
%115 = fmul double %114, 5.000000e-01
%116 = getelementptr inbounds float, float* %73, i64 %107
%117 = load float, float* %116
%118 = fpext float %117 to double
%119 = fmul double %115, %118
%120 = fptrunc double %119 to float
store float %120, float* %116
%121 = tail call double @cos(float %112)
%122 = fsub double 1.000000e+00, %121
%123 = fmul double %122, 5.000000e-01
%124 = trunc i64 %107 to i32
%125 = xor i32 %124, -1
%126 = add i32 %35, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %73, i64 %127
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = fmul double %123, %130
%132 = fptrunc double %131 to float
store float %132, float* %128
%133 = add nuw nsw i64 %107, 1
%134 = icmp eq i64 %133, %97
br i1 %134, label %98, label %106
135: ; preds = %135, %104
%136 = phi i64 [ 0, %104 ], [ %154, %135 ]
%137 = phi float [ 0.000000e+00, %104 ], [ %153, %135 ]
%138 = phi i64 [ 0, %104 ], [ %155, %135 ]
%139 = getelementptr inbounds float, float* %73, i64 %136
%140 = load float, float* %139
%141 = fcmp ogt float %140, %137
%142 = select i1 %141, float %140, float %137
%143 = fneg float %140
%144 = fcmp olt float %142, %143
%145 = select i1 %144, float %143, float %142
%146 = or i64 %136, 1
%147 = getelementptr inbounds float, float* %73, i64 %146
%148 = load float, float* %147
%149 = fcmp ogt float %148, %145
%150 = select i1 %149, float %148, float %145
%151 = fneg float %148
%152 = fcmp olt float %150, %151
%153 = select i1 %152, float %151, float %150
%154 = add nuw nsw i64 %136, 2
%155 = add i64 %138, 2
%156 = icmp eq i64 %155, %105
br i1 %156, label %157, label %135
157: ; preds = %135, %100
%158 = phi float [ undef, %100 ], [ %153, %135 ]
%159 = phi i64 [ 0, %100 ], [ %154, %135 ]
%160 = phi float [ 0.000000e+00, %100 ], [ %153, %135 ]
%161 = icmp eq i64 %102, 0
br i1 %161, label %170, label %162
162: ; preds = %157
%163 = getelementptr inbounds float, float* %73, i64 %159
%164 = load float, float* %163
%165 = fcmp ogt float %164, %160
%166 = select i1 %165, float %164, float %160
%167 = fneg float %164
%168 = fcmp olt float %166, %167
%169 = select i1 %168, float %167, float %166
br label %170
170: ; preds = %157, %162
%171 = phi float [ %158, %157 ], [ %169, %162 ]
%172 = load float, float* %2
%173 = fmul float %34, %172
%174 = fdiv float %173, %171
br i1 %99, label %175, label %264
175: ; preds = %170
%176 = icmp ne i32 %6, 0
%177 = zext i32 %35 to i64
%178 = icmp ult i32 %35, 8
br i1 %178, label %224, label %179
179: ; preds = %175
%180 = getelementptr float, float* %0, i64 %101
%181 = bitcast float* %180 to i8*
%182 = getelementptr float, float* %73, i64 %101
%183 = icmp ugt float* %182, %0
%184 = icmp ult i8* %74, %181
%185 = and i1 %183, %184
br i1 %185, label %224, label %186
186: ; preds = %179
%187 = and i64 %101, 4294967288
%188 = insertelement <4 x float> poison, float %174, i64 0
%189 = shufflevector <4 x float> %188, <4 x float> poison, <4 x i32> zeroinitializer
%190 = insertelement <4 x float> poison, float %174, i64 0
%191 = shufflevector <4 x float> %190, <4 x float> poison, <4 x i32> zeroinitializer
%192 = insertelement <4 x i1> poison, i1 %176, i64 0
%193 = shufflevector <4 x i1> %192, <4 x i1> poison, <4 x i32> zeroinitializer
%194 = insertelement <4 x i1> poison, i1 %176, i64 0
%195 = shufflevector <4 x i1> %194, <4 x i1> poison, <4 x i32> zeroinitializer
br label %196
196: ; preds = %196, %186
%197 = phi i64 [ 0, %186 ], [ %220, %196 ]
%198 = getelementptr inbounds float, float* %0, i64 %197
%199 = bitcast float* %198 to <4 x float>*
%200 = load <4 x float>, <4 x float>* %199
%201 = getelementptr inbounds float, float* %198, i64 4
%202 = bitcast float* %201 to <4 x float>*
%203 = load <4 x float>, <4 x float>* %202
%204 = getelementptr inbounds float, float* %73, i64 %197
%205 = bitcast float* %204 to <4 x float>*
%206 = load <4 x float>, <4 x float>* %205
%207 = getelementptr inbounds float, float* %204, i64 4
%208 = bitcast float* %207 to <4 x float>*
%209 = load <4 x float>, <4 x float>* %208
%210 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %189, <4 x float> %206, <4 x float> %200)
%211 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %191, <4 x float> %209, <4 x float> %203)
%212 = fcmp olt <4 x float> %210, zeroinitializer
%213 = fcmp olt <4 x float> %211, zeroinitializer
%214 = and <4 x i1> %193, %212
%215 = and <4 x i1> %195, %213
%216 = select <4 x i1> %214, <4 x float> zeroinitializer, <4 x float> %210
%217 = select <4 x i1> %215, <4 x float> zeroinitializer, <4 x float> %211
%218 = bitcast float* %198 to <4 x float>*
store <4 x float> %216, <4 x float>* %218
%219 = bitcast float* %201 to <4 x float>*
store <4 x float> %217, <4 x float>* %219
%220 = add nuw i64 %197, 8
%221 = icmp eq i64 %220, %187
br i1 %221, label %222, label %196
222: ; preds = %196
%223 = icmp eq i64 %187, %101
br i1 %223, label %264, label %224
224: ; preds = %179, %175, %222
%225 = phi i64 [ 0, %179 ], [ 0, %175 ], [ %187, %222 ]
%226 = xor i64 %225, -1
%227 = and i64 %101, 1
%228 = icmp eq i64 %227, 0
br i1 %228, label %239, label %229
229: ; preds = %224
%230 = getelementptr inbounds float, float* %0, i64 %225
%231 = load float, float* %230
%232 = getelementptr inbounds float, float* %73, i64 %225
%233 = load float, float* %232
%234 = tail call float @llvm.fmuladd.f32(float %174, float %233, float %231)
%235 = fcmp olt float %234, 0.000000e+00
%236 = and i1 %176, %235
%237 = select i1 %236, float 0.000000e+00, float %234
store float %237, float* %230
%238 = or i64 %225, 1
br label %239
239: ; preds = %229, %224
%240 = phi i64 [ %225, %224 ], [ %238, %229 ]
%241 = sub nsw i64 0, %101
%242 = icmp eq i64 %226, %241
br i1 %242, label %264, label %243
243: ; preds = %239, %243
%244 = phi i64 [ %262, %243 ], [ %240, %239 ]
%245 = getelementptr inbounds float, float* %0, i64 %244
%246 = load float, float* %245
%247 = getelementptr inbounds float, float* %73, i64 %244
%248 = load float, float* %247
%249 = tail call float @llvm.fmuladd.f32(float %174, float %248, float %246)
%250 = fcmp olt float %249, 0.000000e+00
%251 = and i1 %176, %250
%252 = select i1 %251, float 0.000000e+00, float %249
store float %252, float* %245
%253 = add nuw nsw i64 %244, 1
%254 = getelementptr inbounds float, float* %0, i64 %253
%255 = load float, float* %254
%256 = getelementptr inbounds float, float* %73, i64 %253
%257 = load float, float* %256
%258 = tail call float @llvm.fmuladd.f32(float %174, float %257, float %255)
%259 = fcmp olt float %258, 0.000000e+00
%260 = and i1 %176, %259
%261 = select i1 %260, float 0.000000e+00, float %258
store float %261, float* %254
%262 = add nuw nsw i64 %244, 2
%263 = icmp eq i64 %262, %177
br i1 %263, label %264, label %243
264: ; preds = %239, %243, %222, %98, %170
ret void
}