#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 */

/* Variables and functions */
int /*<<< orphan*/ fourt(float *, float *, int *, int, int /*<<< orphan*/,
                         int /*<<< orphan*/, float *, float *);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
int dftixb(float *xrr, float *xri, int isize, int ntot, float *workr,
           float *worki) {
  int i, ntotp1;
  float scale;
  if (ntot > isize)
    memset(xri + isize, 0, sizeof(float) * (ntot - isize));
  memset(xrr, 0, sizeof(float) * ntot * 2);
  ntotp1 = 2 * ntot - 1;
  for (i = 0; i < ntot; i++) {
    xrr[ntotp1 - i] = xrr[i];
    xri[ntotp1 - i] = -xri[i];
  }
  ntotp1 = ntot * 2;
  fourt(xrr, xri, &ntotp1, 1, 0, 0, workr, worki);
  for (i = 0; i < ntot; i++) {
    xrr[i] = xrr[i + ntot];
    xri[i] = xri[i + ntot];
  }
  scale = 1.0 / ntot;
  for (i = 0; i < ntot; i++) {
    xrr[i] *= scale;
    xri[i] *= scale;
  }
  return ntot;
}


x86 assembly (clang, -O0):
<dftixb>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    116e <dftixb+0x4e>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x8(%rbp),%rdi
movslq -0x18(%rbp),%rax
shl    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11ff <dftixb+0xdf>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    119a <dftixb+0x7a>
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
lea    -0x30(%rbp),%rdx
mov    $0x1,%ecx
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <fourt@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1294 <dftixb+0x174>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x18(%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    123c <dftixb+0x11c>
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  0xd5f(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12fd <dftixb+0x1dd>
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b5 <dftixb+0x195>
mov    -0x18(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dftixb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9,%r13
mov    %r8,%r12
mov    %ecx,%r14d
mov    %edx,%eax
mov    %rsi,%r15
mov    %rdi,%rbx
mov    %ecx,%edx
sub    %eax,%edx
jle    1152 <dftixb+0x32>
cltq
lea    (%r15,%rax,4),%rdi
shl    $0x2,%edx
xor    %esi,%esi
call   1030 <memset@plt>
lea    0x0(,%r14,8),%edx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
lea    (%r14,%r14,1),%eax
test   %r14d,%r14d
jle    1183 <dftixb+0x63>
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
mov    %r14d,%ebp
cmp    $0x1,%r14d
jne    11af <dftixb+0x8f>
xor    %edx,%edx
jmp    1213 <dftixb+0xf3>
mov    %eax,0x4(%rsp)
lea    0x4(%rsp),%rdx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x1,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
push   %r13
push   %r12
call   1040 <fourt@plt>
add    $0x10,%rsp
jmp    15d8 <dftixb+0x4b8>
mov    %ebp,%esi
and    $0xfffffffe,%esi
lea    -0x1(%rcx),%rdi
xor    %edx,%edx
movaps 0xe3f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,0x4(%rbx,%rdi,4)
movss  (%r15,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%r15,%rdi,4)
movss  0x4(%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdi,4)
movss  0x4(%r15,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r15,%rdi,4)
add    $0x2,%rdx
add    $0xfffffffffffffffe,%rdi
cmp    %rdx,%rsi
jne    11d0 <dftixb+0xb0>
test   $0x1,%bpl
je     1239 <dftixb+0x119>
movss  (%rbx,%rdx,4),%xmm0
sub    %rdx,%rcx
movss  %xmm0,(%rbx,%rcx,4)
movss  (%r15,%rdx,4),%xmm0
xorps  0xdcd(%rip),%xmm0
movss  %xmm0,(%r15,%rcx,4)
mov    %eax,0x4(%rsp)
lea    0x4(%rsp),%rdx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x1,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
push   %r13
push   %r12
call   1040 <fourt@plt>
add    $0x10,%rsp
test   %r14d,%r14d
jle    15d8 <dftixb+0x4b8>
cmp    $0x8,%r14d
jae    1276 <dftixb+0x156>
xor    %eax,%eax
jmp    13a1 <dftixb+0x281>
lea    (%rbx,%rbp,4),%rax
lea    (%rbx,%rbp,8),%rcx
lea    (%r15,%rbp,4),%rdx
lea    (%r15,%rbp,8),%rsi
cmp    %r15,%rbx
setb   %r8b
cmp    %r15,%rcx
seta   %r9b
cmp    %rbx,%rsi
seta   %cl
cmp    %rbx,%r15
setb   %sil
cmp    %rbx,%rdx
seta   %dl
cmp    %r15,%rax
seta   %dil
xor    %eax,%eax
test   %r9b,%r8b
jne    13a1 <dftixb+0x281>
and    %sil,%cl
jne    13a1 <dftixb+0x281>
and    %dil,%dl
jne    13a1 <dftixb+0x281>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     15ea <dftixb+0x4ca>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r15,%rbp,4),%rdi
add    $0x30,%rdi
lea    (%rbx,%rbp,4),%rcx
add    $0x30,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdx,4),%xmm0
movups -0x20(%rcx,%rdx,4),%xmm1
movups %xmm0,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
movups -0x30(%rdi,%rdx,4),%xmm0
movups -0x20(%rdi,%rdx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
movups -0x10(%rcx,%rdx,4),%xmm0
movups (%rcx,%rdx,4),%xmm1
movups %xmm0,0x20(%rbx,%rdx,4)
movups %xmm1,0x30(%rbx,%rdx,4)
movups -0x10(%rdi,%rdx,4),%xmm0
movups (%rdi,%rdx,4),%xmm1
movups %xmm0,0x20(%r15,%rdx,4)
movups %xmm1,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1310 <dftixb+0x1f0>
test   $0x1,%r8b
je     139c <dftixb+0x27c>
lea    (%rdx,%rbp,1),%rcx
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
movups (%r15,%rcx,4),%xmm0
movups 0x10(%r15,%rcx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
cmp    %rbp,%rax
je     1417 <dftixb+0x2f7>
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     13cb <dftixb+0x2ab>
lea    (%rax,%rbp,1),%rdx
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%r15,%rdx,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     1417 <dftixb+0x2f7>
lea    (%rbx,%rbp,4),%rcx
add    $0x4,%rcx
lea    (%r15,%rbp,4),%rdx
add    $0x4,%rdx
movss  -0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  -0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%r15,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    13e0 <dftixb+0x2c0>
test   %r14d,%r14d
jle    15d8 <dftixb+0x4b8>
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0xbe0(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
cmp    $0x8,%r14d
jb     145b <dftixb+0x33b>
lea    (%r15,%rbp,4),%rax
cmp    %rbx,%rax
jbe    14ee <dftixb+0x3ce>
lea    (%rbx,%rbp,4),%rax
cmp    %r15,%rax
jbe    14ee <dftixb+0x3ce>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     148b <dftixb+0x36b>
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  (%r15,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     15d8 <dftixb+0x4b8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  (%r15,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r15,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    14a0 <dftixb+0x380>
jmp    15d8 <dftixb+0x4b8>
mov    %ebp,%eax
and    $0xfffffff8,%eax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15fb <dftixb+0x4db>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm2
movups 0x10(%rbx,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
movups (%r15,%rcx,4),%xmm2
movups 0x10(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r15,%rcx,4)
movups %xmm3,0x10(%r15,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm2
movups 0x30(%rbx,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%rbx,%rcx,4)
movups %xmm3,0x30(%rbx,%rcx,4)
movups 0x20(%r15,%rcx,4),%xmm2
movups 0x30(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%r15,%rcx,4)
movups %xmm3,0x30(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1520 <dftixb+0x400>
test   $0x1,%dl
je     15cf <dftixb+0x4af>
movups (%rbx,%rcx,4),%xmm2
movups 0x10(%rbx,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
movups (%r15,%rcx,4),%xmm2
movups 0x10(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r15,%rcx,4)
movups %xmm3,0x10(%r15,%rcx,4)
cmp    %rbp,%rax
jne    145d <dftixb+0x33d>
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    1370 <dftixb+0x250>
jmp    139c <dftixb+0x27c>
xor    %ecx,%ecx
test   $0x1,%dl
jne    159b <dftixb+0x47b>
jmp    15cf <dftixb+0x4af>

LLVM IR (-O0):
define i32 @dftixb(float* %0, float* %1, i32 %2, i32 %3, float* %4, float* %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca float*
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store float* %4, float** %11
store float* %5, float** %12
%16 = load i32, i32* %10
%17 = load i32, i32* %9
%18 = icmp sgt i32 %16, %17
br i1 %18, label %19, label %31
19: ; preds = %6
%20 = load float*, float** %8
%21 = load i32, i32* %9
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
%24 = load i32, i32* %10
%25 = load i32, i32* %9
%26 = sub nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = mul i64 4, %27
%29 = trunc i64 %28 to i32
%30 = call i32 @memset(float* %23, i32 0, i32 %29)
br label %31
31: ; preds = %19, %6
%32 = load float*, float** %7
%33 = load i32, i32* %10
%34 = sext i32 %33 to i64
%35 = mul i64 4, %34
%36 = mul i64 %35, 2
%37 = trunc i64 %36 to i32
%38 = call i32 @memset(float* %32, i32 0, i32 %37)
%39 = load i32, i32* %10
%40 = mul nsw i32 2, %39
%41 = sub nsw i32 %40, 1
store i32 %41, i32* %14
store i32 0, i32* %13
br label %42
42: ; preds = %70, %31
%43 = load i32, i32* %13
%44 = load i32, i32* %10
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %73
46: ; preds = %42
%47 = load float*, float** %7
%48 = load i32, i32* %13
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
%51 = load float, float* %50
%52 = load float*, float** %7
%53 = load i32, i32* %14
%54 = load i32, i32* %13
%55 = sub nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %52, i64 %56
store float %51, float* %57
%58 = load float*, float** %8
%59 = load i32, i32* %13
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %58, i64 %60
%62 = load float, float* %61
%63 = fneg float %62
%64 = load float*, float** %8
%65 = load i32, i32* %14
%66 = load i32, i32* %13
%67 = sub nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %64, i64 %68
store float %63, float* %69
br label %70
70: ; preds = %46
%71 = load i32, i32* %13
%72 = add nsw i32 %71, 1
store i32 %72, i32* %13
br label %42
73: ; preds = %42
%74 = load i32, i32* %10
%75 = mul nsw i32 %74, 2
store i32 %75, i32* %14
%76 = load float*, float** %7
%77 = load float*, float** %8
%78 = load float*, float** %11
%79 = load float*, float** %12
%80 = call i32 @fourt(float* %76, float* %77, i32* %14, i32 1, i32 0, i32 0, float* %78, float* %79)
store i32 0, i32* %13
br label %81
81: ; preds = %108, %73
%82 = load i32, i32* %13
%83 = load i32, i32* %10
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %111
85: ; preds = %81
%86 = load float*, float** %7
%87 = load i32, i32* %13
%88 = load i32, i32* %10
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %86, i64 %90
%92 = load float, float* %91
%93 = load float*, float** %7
%94 = load i32, i32* %13
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %93, i64 %95
store float %92, float* %96
%97 = load float*, float** %8
%98 = load i32, i32* %13
%99 = load i32, i32* %10
%100 = add nsw i32 %98, %99
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %97, i64 %101
%103 = load float, float* %102
%104 = load float*, float** %8
%105 = load i32, i32* %13
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
store float %103, float* %107
br label %108
108: ; preds = %85
%109 = load i32, i32* %13
%110 = add nsw i32 %109, 1
store i32 %110, i32* %13
br label %81
111: ; preds = %81
%112 = load i32, i32* %10
%113 = sitofp i32 %112 to double
%114 = fdiv double 1.000000e+00, %113
%115 = fptrunc double %114 to float
store float %115, float* %15
store i32 0, i32* %13
br label %116
116: ; preds = %135, %111
%117 = load i32, i32* %13
%118 = load i32, i32* %10
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %138
120: ; preds = %116
%121 = load float, float* %15
%122 = load float*, float** %7
%123 = load i32, i32* %13
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %122, i64 %124
%126 = load float, float* %125
%127 = fmul float %126, %121
store float %127, float* %125
%128 = load float, float* %15
%129 = load float*, float** %8
%130 = load i32, i32* %13
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %129, i64 %131
%133 = load float, float* %132
%134 = fmul float %133, %128
store float %134, float* %132
br label %135
135: ; preds = %120
%136 = load i32, i32* %13
%137 = add nsw i32 %136, 1
store i32 %137, i32* %13
br label %116
138: ; preds = %116
%139 = load i32, i32* %10
ret i32 %139
}

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