#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*/ cft1st_128(float *);
int /*<<< orphan*/ cftmdl_128(float *);
void cftbsub_128(float *a) {
  int j, j1, j2, j3, l;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  cft1st_128(a);
  cftmdl_128(a);
  l = 32;
  for (j = 0; j < l; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    x0r = a[j] + a[j1];
    x0i = -a[j + 1] - a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = -a[j + 1] + a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i - x2i;
    a[j2] = x0r - x2r;
    a[j2 + 1] = x0i + x2i;
    a[j1] = x1r - x3i;
    a[j1 + 1] = x1i - x3r;
    a[j3] = x1r + x3i;
    a[j3 + 1] = x1i + x3r;
  }
}


x86 assembly (clang, -O0):
<cftbsub_128>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <cft1st_128@plt>
mov    -0x8(%rbp),%rdi
call   1040 <cftmdl_128@plt>
movl   $0x20,-0x1c(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1387 <cftbsub_128+0x267>
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xc(%rbp)
jmp    114c <cftbsub_128+0x2c>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftbsub_128>:
push   %rbx
mov    %rdi,%rbx
call   1030 <cft1st_128@plt>
mov    %rbx,%rdi
call   1040 <cftmdl_128@plt>
movups (%rbx),%xmm5
movups 0x10(%rbx),%xmm0
movups 0x20(%rbx),%xmm10
movups 0x30(%rbx),%xmm8
movaps %xmm5,%xmm11
shufps $0x88,%xmm0,%xmm11
shufps $0xdd,%xmm0,%xmm5
movups 0x90(%rbx),%xmm0
movups 0x80(%rbx),%xmm12
movaps %xmm12,%xmm6
shufps $0x88,%xmm0,%xmm6
shufps $0xdd,%xmm0,%xmm12
movaps %xmm11,%xmm7
addps  %xmm6,%xmm7
movaps 0xe86(%rip),%xmm9
movaps %xmm5,%xmm13
xorps  %xmm9,%xmm13
subps  %xmm12,%xmm13
subps  %xmm6,%xmm11
subps  %xmm5,%xmm12
movups 0x110(%rbx),%xmm0
movups 0x100(%rbx),%xmm5
movaps %xmm5,%xmm6
shufps $0x88,%xmm0,%xmm6
shufps $0xdd,%xmm0,%xmm5
movups 0x190(%rbx),%xmm0
movups 0x180(%rbx),%xmm1
movaps %xmm1,%xmm3
shufps $0x88,%xmm0,%xmm3
shufps $0xdd,%xmm0,%xmm1
movaps %xmm6,%xmm0
addps  %xmm3,%xmm0
movaps %xmm5,%xmm4
addps  %xmm1,%xmm4
subps  %xmm3,%xmm6
subps  %xmm1,%xmm5
movaps %xmm7,%xmm1
addps  %xmm0,%xmm1
movaps %xmm13,%xmm3
subps  %xmm4,%xmm3
movaps %xmm1,%xmm2
unpckhps %xmm3,%xmm2
unpcklps %xmm3,%xmm1
movups %xmm1,(%rbx)
movups %xmm2,0x10(%rbx)
subps  %xmm0,%xmm7
addps  %xmm13,%xmm4
movaps %xmm7,%xmm0
unpckhps %xmm4,%xmm0
unpcklps %xmm4,%xmm7
movups %xmm7,0x100(%rbx)
movups %xmm0,0x110(%rbx)
movaps %xmm11,%xmm0
subps  %xmm5,%xmm0
movaps %xmm12,%xmm1
subps  %xmm6,%xmm1
movaps %xmm0,%xmm2
unpckhps %xmm1,%xmm2
unpcklps %xmm1,%xmm0
movups %xmm0,0x80(%rbx)
movups %xmm2,0x90(%rbx)
addps  %xmm11,%xmm5
addps  %xmm12,%xmm6
movaps %xmm5,%xmm0
unpckhps %xmm6,%xmm0
unpcklps %xmm6,%xmm5
movups %xmm5,0x180(%rbx)
movups %xmm0,0x190(%rbx)
movaps %xmm10,%xmm11
shufps $0x88,%xmm8,%xmm11
shufps $0xdd,%xmm8,%xmm10
movups 0xb0(%rbx),%xmm0
movups 0xa0(%rbx),%xmm8
movaps %xmm8,%xmm1
shufps $0x88,%xmm0,%xmm1
shufps $0xdd,%xmm0,%xmm8
movaps %xmm11,%xmm5
addps  %xmm1,%xmm5
movaps %xmm10,%xmm12
xorps  %xmm9,%xmm12
subps  %xmm8,%xmm12
subps  %xmm1,%xmm11
subps  %xmm10,%xmm8
movups 0x130(%rbx),%xmm0
movups 0x120(%rbx),%xmm1
movaps %xmm1,%xmm4
shufps $0x88,%xmm0,%xmm4
shufps $0xdd,%xmm0,%xmm1
movups 0x1b0(%rbx),%xmm0
movups 0x1a0(%rbx),%xmm7
movaps %xmm7,%xmm3
shufps $0x88,%xmm0,%xmm3
shufps $0xdd,%xmm0,%xmm7
movaps %xmm4,%xmm0
addps  %xmm3,%xmm0
movaps %xmm1,%xmm2
addps  %xmm7,%xmm2
subps  %xmm3,%xmm4
subps  %xmm7,%xmm1
movaps %xmm5,%xmm3
addps  %xmm0,%xmm3
movaps %xmm12,%xmm7
subps  %xmm2,%xmm7
movaps %xmm3,%xmm6
unpckhps %xmm7,%xmm6
unpcklps %xmm7,%xmm3
movups %xmm3,0x20(%rbx)
movups %xmm6,0x30(%rbx)
subps  %xmm0,%xmm5
addps  %xmm12,%xmm2
movaps %xmm5,%xmm0
unpckhps %xmm2,%xmm0
unpcklps %xmm2,%xmm5
movups %xmm5,0x120(%rbx)
movups %xmm0,0x130(%rbx)
movaps %xmm11,%xmm0
subps  %xmm1,%xmm0
movaps %xmm8,%xmm2
subps  %xmm4,%xmm2
movaps %xmm0,%xmm3
unpckhps %xmm2,%xmm3
unpcklps %xmm2,%xmm0
movups %xmm0,0xa0(%rbx)
movups %xmm3,0xb0(%rbx)
addps  %xmm11,%xmm1
addps  %xmm8,%xmm4
movaps %xmm1,%xmm0
unpckhps %xmm4,%xmm0
unpcklps %xmm4,%xmm1
movups %xmm1,0x1a0(%rbx)
movups %xmm0,0x1b0(%rbx)
movups 0x50(%rbx),%xmm0
movups 0x40(%rbx),%xmm3
movaps %xmm3,%xmm8
shufps $0x88,%xmm0,%xmm8
shufps $0xdd,%xmm0,%xmm3
movups 0xd0(%rbx),%xmm0
movups 0xc0(%rbx),%xmm10
movaps %xmm10,%xmm4
shufps $0x88,%xmm0,%xmm4
shufps $0xdd,%xmm0,%xmm10
movaps %xmm8,%xmm5
addps  %xmm4,%xmm5
movaps %xmm3,%xmm11
xorps  %xmm9,%xmm11
subps  %xmm10,%xmm11
subps  %xmm4,%xmm8
subps  %xmm3,%xmm10
movups 0x150(%rbx),%xmm0
movups 0x140(%rbx),%xmm3
movaps %xmm3,%xmm4
shufps $0x88,%xmm0,%xmm4
shufps $0xdd,%xmm0,%xmm3
movups 0x1d0(%rbx),%xmm0
movups 0x1c0(%rbx),%xmm7
movaps %xmm7,%xmm1
shufps $0x88,%xmm0,%xmm1
shufps $0xdd,%xmm0,%xmm7
movaps %xmm4,%xmm0
addps  %xmm1,%xmm0
movaps %xmm3,%xmm2
addps  %xmm7,%xmm2
subps  %xmm1,%xmm4
subps  %xmm7,%xmm3
movaps %xmm5,%xmm1
addps  %xmm0,%xmm1
movaps %xmm11,%xmm7
subps  %xmm2,%xmm7
movaps %xmm1,%xmm6
unpcklps %xmm7,%xmm6
unpckhps %xmm7,%xmm1
movups %xmm1,0x50(%rbx)
movups %xmm6,0x40(%rbx)
subps  %xmm0,%xmm5
addps  %xmm11,%xmm2
movaps %xmm5,%xmm0
unpcklps %xmm2,%xmm0
unpckhps %xmm2,%xmm5
movups %xmm5,0x150(%rbx)
movups %xmm0,0x140(%rbx)
movaps %xmm8,%xmm0
subps  %xmm3,%xmm0
movaps %xmm10,%xmm1
subps  %xmm4,%xmm1
movaps %xmm0,%xmm2
unpckhps %xmm1,%xmm2
unpcklps %xmm1,%xmm0
movups %xmm0,0xc0(%rbx)
movups %xmm2,0xd0(%rbx)
addps  %xmm8,%xmm3
addps  %xmm10,%xmm4
movaps %xmm3,%xmm0
unpckhps %xmm4,%xmm0
unpcklps %xmm4,%xmm3
movups %xmm3,0x1c0(%rbx)
movups %xmm0,0x1d0(%rbx)
movups 0x60(%rbx),%xmm0
movups 0x70(%rbx),%xmm3
movups 0xe0(%rbx),%xmm10
movups 0xf0(%rbx),%xmm4
movaps %xmm0,%xmm8
shufps $0x88,%xmm3,%xmm8
shufps $0xdd,%xmm3,%xmm0
movaps %xmm10,%xmm3
shufps $0x88,%xmm4,%xmm3
shufps $0xdd,%xmm4,%xmm10
movaps %xmm8,%xmm5
addps  %xmm3,%xmm5
xorps  %xmm0,%xmm9
subps  %xmm10,%xmm9
subps  %xmm3,%xmm8
subps  %xmm0,%xmm10
movups 0x170(%rbx),%xmm0
movups 0x160(%rbx),%xmm3
movaps %xmm3,%xmm4
shufps $0x88,%xmm0,%xmm4
shufps $0xdd,%xmm0,%xmm3
movups 0x1f0(%rbx),%xmm0
movups 0x1e0(%rbx),%xmm6
movaps %xmm6,%xmm7
shufps $0x88,%xmm0,%xmm7
shufps $0xdd,%xmm0,%xmm6
movaps %xmm4,%xmm0
addps  %xmm7,%xmm0
movaps %xmm3,%xmm2
addps  %xmm6,%xmm2
subps  %xmm7,%xmm4
subps  %xmm6,%xmm3
movaps %xmm5,%xmm6
addps  %xmm0,%xmm6
movaps %xmm9,%xmm7
subps  %xmm2,%xmm7
movaps %xmm6,%xmm1
unpcklps %xmm7,%xmm1
unpckhps %xmm7,%xmm6
movups %xmm6,0x70(%rbx)
movups %xmm1,0x60(%rbx)
subps  %xmm0,%xmm5
addps  %xmm9,%xmm2
movaps %xmm5,%xmm0
unpcklps %xmm2,%xmm0
unpckhps %xmm2,%xmm5
movups %xmm5,0x170(%rbx)
movups %xmm0,0x160(%rbx)
movaps %xmm8,%xmm0
subps  %xmm3,%xmm0
movaps %xmm10,%xmm1
subps  %xmm4,%xmm1
movaps %xmm0,%xmm2
unpcklps %xmm1,%xmm2
unpckhps %xmm1,%xmm0
movups %xmm0,0xf0(%rbx)
movups %xmm2,0xe0(%rbx)
addps  %xmm8,%xmm3
addps  %xmm10,%xmm4
movaps %xmm3,%xmm0
unpcklps %xmm4,%xmm0
unpckhps %xmm4,%xmm3
movups %xmm3,0x1f0(%rbx)
movups %xmm0,0x1e0(%rbx)
pop    %rbx
ret

LLVM IR (-O0):
define void @cftbsub_128(float* %0) {
%2 = alloca float*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
store float* %0, float** %2
%16 = load float*, float** %2
%17 = call i32 @cft1st_128(float* %16)
%18 = load float*, float** %2
%19 = call i32 @cftmdl_128(float* %18)
store i32 32, i32* %7
store i32 0, i32* %3
br label %20
20: ; preds = %192, %1
%21 = load i32, i32* %3
%22 = load i32, i32* %7
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %195
24: ; preds = %20
%25 = load i32, i32* %3
%26 = load i32, i32* %7
%27 = add nsw i32 %25, %26
store i32 %27, i32* %4
%28 = load i32, i32* %4
%29 = load i32, i32* %7
%30 = add nsw i32 %28, %29
store i32 %30, i32* %5
%31 = load i32, i32* %5
%32 = load i32, i32* %7
%33 = add nsw i32 %31, %32
store i32 %33, i32* %6
%34 = load float*, float** %2
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %34, i64 %36
%38 = load float, float* %37
%39 = load float*, float** %2
%40 = load i32, i32* %4
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
%44 = fadd float %38, %43
store float %44, float* %8
%45 = load float*, float** %2
%46 = load i32, i32* %3
%47 = add nsw i32 %46, 1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %45, i64 %48
%50 = load float, float* %49
%51 = fneg float %50
%52 = load float*, float** %2
%53 = load i32, i32* %4
%54 = add nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %52, i64 %55
%57 = load float, float* %56
%58 = fsub float %51, %57
store float %58, float* %9
%59 = load float*, float** %2
%60 = load i32, i32* %3
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float*, float** %2
%65 = load i32, i32* %4
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = fsub float %63, %68
store float %69, float* %10
%70 = load float*, float** %2
%71 = load i32, i32* %3
%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 = fneg float %75
%77 = load float*, float** %2
%78 = load i32, i32* %4
%79 = add nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %77, i64 %80
%82 = load float, float* %81
%83 = fadd float %76, %82
store float %83, float* %11
%84 = load float*, float** %2
%85 = load i32, i32* %5
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
%89 = load float*, float** %2
%90 = load i32, i32* %6
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
%93 = load float, float* %92
%94 = fadd float %88, %93
store float %94, float* %12
%95 = load float*, float** %2
%96 = load i32, i32* %5
%97 = add nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %95, i64 %98
%100 = load float, float* %99
%101 = load float*, float** %2
%102 = load i32, i32* %6
%103 = add nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %101, i64 %104
%106 = load float, float* %105
%107 = fadd float %100, %106
store float %107, float* %13
%108 = load float*, float** %2
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = load float*, float** %2
%114 = load i32, i32* %6
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = fsub float %112, %117
store float %118, float* %14
%119 = load float*, float** %2
%120 = load i32, i32* %5
%121 = add nsw i32 %120, 1
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %119, i64 %122
%124 = load float, float* %123
%125 = load float*, float** %2
%126 = load i32, i32* %6
%127 = add nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %125, i64 %128
%130 = load float, float* %129
%131 = fsub float %124, %130
store float %131, float* %15
%132 = load float, float* %8
%133 = load float, float* %12
%134 = fadd float %132, %133
%135 = load float*, float** %2
%136 = load i32, i32* %3
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
store float %134, float* %138
%139 = load float, float* %9
%140 = load float, float* %13
%141 = fsub float %139, %140
%142 = load float*, float** %2
%143 = load i32, i32* %3
%144 = add nsw i32 %143, 1
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %142, i64 %145
store float %141, float* %146
%147 = load float, float* %8
%148 = load float, float* %12
%149 = fsub float %147, %148
%150 = load float*, float** %2
%151 = load i32, i32* %5
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
store float %149, float* %153
%154 = load float, float* %9
%155 = load float, float* %13
%156 = fadd float %154, %155
%157 = load float*, float** %2
%158 = load i32, i32* %5
%159 = add nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %157, i64 %160
store float %156, float* %161
%162 = load float, float* %10
%163 = load float, float* %15
%164 = fsub float %162, %163
%165 = load float*, float** %2
%166 = load i32, i32* %4
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %165, i64 %167
store float %164, float* %168
%169 = load float, float* %11
%170 = load float, float* %14
%171 = fsub float %169, %170
%172 = load float*, float** %2
%173 = load i32, i32* %4
%174 = add nsw i32 %173, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %172, i64 %175
store float %171, float* %176
%177 = load float, float* %10
%178 = load float, float* %15
%179 = fadd float %177, %178
%180 = load float*, float** %2
%181 = load i32, i32* %6
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
store float %179, float* %183
%184 = load float, float* %11
%185 = load float, float* %14
%186 = fadd float %184, %185
%187 = load float*, float** %2
%188 = load i32, i32* %6
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %187, i64 %190
store float %186, float* %191
br label %192
192: ; preds = %24
%193 = load i32, i32* %3
%194 = add nsw i32 %193, 2
store i32 %194, i32* %3
br label %20
195: ; preds = %20
ret void
}

LLVM IR (-O2):
define void @cftbsub_128(float* %0) {
%2 = tail call i32 @cft1st_128(float* %0)
%3 = tail call i32 @cftmdl_128(float* %0)
%4 = bitcast float* %0 to <8 x float>*
%5 = load <8 x float>, <8 x float>* %4
%6 = shufflevector <8 x float> %5, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%7 = shufflevector <8 x float> %5, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%8 = getelementptr inbounds float, float* %0, i64 32
%9 = bitcast float* %8 to <8 x float>*
%10 = load <8 x float>, <8 x float>* %9
%11 = shufflevector <8 x float> %10, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%12 = shufflevector <8 x float> %10, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%13 = fadd <4 x float> %6, %11
%14 = fneg <4 x float> %7
%15 = fsub <4 x float> %14, %12
%16 = fsub <4 x float> %6, %11
%17 = fsub <4 x float> %12, %7
%18 = getelementptr inbounds float, float* %0, i64 64
%19 = bitcast float* %18 to <8 x float>*
%20 = load <8 x float>, <8 x float>* %19
%21 = shufflevector <8 x float> %20, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%22 = shufflevector <8 x float> %20, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%23 = getelementptr inbounds float, float* %0, i64 96
%24 = bitcast float* %23 to <8 x float>*
%25 = load <8 x float>, <8 x float>* %24
%26 = shufflevector <8 x float> %25, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%27 = shufflevector <8 x float> %25, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%28 = fadd <4 x float> %21, %26
%29 = fadd <4 x float> %22, %27
%30 = fsub <4 x float> %21, %26
%31 = fsub <4 x float> %22, %27
%32 = fadd <4 x float> %13, %28
%33 = fsub <4 x float> %15, %29
%34 = bitcast float* %0 to <8 x float>*
%35 = shufflevector <4 x float> %32, <4 x float> %33, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %35, <8 x float>* %34
%36 = fsub <4 x float> %13, %28
%37 = fadd <4 x float> %15, %29
%38 = getelementptr inbounds float, float* %0, i64 64
%39 = bitcast float* %38 to <8 x float>*
%40 = shufflevector <4 x float> %36, <4 x float> %37, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %40, <8 x float>* %39
%41 = fsub <4 x float> %16, %31
%42 = fsub <4 x float> %17, %30
%43 = getelementptr inbounds float, float* %0, i64 32
%44 = bitcast float* %43 to <8 x float>*
%45 = shufflevector <4 x float> %41, <4 x float> %42, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %45, <8 x float>* %44
%46 = fadd <4 x float> %16, %31
%47 = fadd <4 x float> %17, %30
%48 = getelementptr inbounds float, float* %0, i64 96
%49 = bitcast float* %48 to <8 x float>*
%50 = shufflevector <4 x float> %46, <4 x float> %47, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %50, <8 x float>* %49
%51 = getelementptr inbounds float, float* %0, i64 8
%52 = bitcast float* %51 to <8 x float>*
%53 = load <8 x float>, <8 x float>* %52
%54 = shufflevector <8 x float> %53, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%55 = shufflevector <8 x float> %53, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%56 = getelementptr inbounds float, float* %0, i64 40
%57 = bitcast float* %56 to <8 x float>*
%58 = load <8 x float>, <8 x float>* %57
%59 = shufflevector <8 x float> %58, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%60 = shufflevector <8 x float> %58, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%61 = fadd <4 x float> %54, %59
%62 = fneg <4 x float> %55
%63 = fsub <4 x float> %62, %60
%64 = fsub <4 x float> %54, %59
%65 = fsub <4 x float> %60, %55
%66 = getelementptr inbounds float, float* %0, i64 72
%67 = bitcast float* %66 to <8 x float>*
%68 = load <8 x float>, <8 x float>* %67
%69 = shufflevector <8 x float> %68, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%70 = shufflevector <8 x float> %68, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%71 = getelementptr inbounds float, float* %0, i64 104
%72 = bitcast float* %71 to <8 x float>*
%73 = load <8 x float>, <8 x float>* %72
%74 = shufflevector <8 x float> %73, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%75 = shufflevector <8 x float> %73, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%76 = fadd <4 x float> %69, %74
%77 = fadd <4 x float> %70, %75
%78 = fsub <4 x float> %69, %74
%79 = fsub <4 x float> %70, %75
%80 = fadd <4 x float> %61, %76
%81 = fsub <4 x float> %63, %77
%82 = getelementptr inbounds float, float* %0, i64 8
%83 = bitcast float* %82 to <8 x float>*
%84 = shufflevector <4 x float> %80, <4 x float> %81, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %84, <8 x float>* %83
%85 = fsub <4 x float> %61, %76
%86 = fadd <4 x float> %63, %77
%87 = getelementptr inbounds float, float* %0, i64 72
%88 = bitcast float* %87 to <8 x float>*
%89 = shufflevector <4 x float> %85, <4 x float> %86, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %89, <8 x float>* %88
%90 = fsub <4 x float> %64, %79
%91 = fsub <4 x float> %65, %78
%92 = getelementptr inbounds float, float* %0, i64 40
%93 = bitcast float* %92 to <8 x float>*
%94 = shufflevector <4 x float> %90, <4 x float> %91, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %94, <8 x float>* %93
%95 = fadd <4 x float> %64, %79
%96 = fadd <4 x float> %65, %78
%97 = getelementptr inbounds float, float* %0, i64 104
%98 = bitcast float* %97 to <8 x float>*
%99 = shufflevector <4 x float> %95, <4 x float> %96, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %99, <8 x float>* %98
%100 = getelementptr inbounds float, float* %0, i64 16
%101 = bitcast float* %100 to <8 x float>*
%102 = load <8 x float>, <8 x float>* %101
%103 = shufflevector <8 x float> %102, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%104 = shufflevector <8 x float> %102, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%105 = getelementptr inbounds float, float* %0, i64 48
%106 = bitcast float* %105 to <8 x float>*
%107 = load <8 x float>, <8 x float>* %106
%108 = shufflevector <8 x float> %107, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%109 = shufflevector <8 x float> %107, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%110 = fadd <4 x float> %103, %108
%111 = fneg <4 x float> %104
%112 = fsub <4 x float> %111, %109
%113 = fsub <4 x float> %103, %108
%114 = fsub <4 x float> %109, %104
%115 = getelementptr inbounds float, float* %0, i64 80
%116 = bitcast float* %115 to <8 x float>*
%117 = load <8 x float>, <8 x float>* %116
%118 = shufflevector <8 x float> %117, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%119 = shufflevector <8 x float> %117, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%120 = getelementptr inbounds float, float* %0, i64 112
%121 = bitcast float* %120 to <8 x float>*
%122 = load <8 x float>, <8 x float>* %121
%123 = shufflevector <8 x float> %122, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%124 = shufflevector <8 x float> %122, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%125 = fadd <4 x float> %118, %123
%126 = fadd <4 x float> %119, %124
%127 = fsub <4 x float> %118, %123
%128 = fsub <4 x float> %119, %124
%129 = fadd <4 x float> %110, %125
%130 = fsub <4 x float> %112, %126
%131 = getelementptr inbounds float, float* %0, i64 16
%132 = bitcast float* %131 to <8 x float>*
%133 = shufflevector <4 x float> %129, <4 x float> %130, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %133, <8 x float>* %132
%134 = fsub <4 x float> %110, %125
%135 = fadd <4 x float> %112, %126
%136 = getelementptr inbounds float, float* %0, i64 80
%137 = bitcast float* %136 to <8 x float>*
%138 = shufflevector <4 x float> %134, <4 x float> %135, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %138, <8 x float>* %137
%139 = fsub <4 x float> %113, %128
%140 = fsub <4 x float> %114, %127
%141 = getelementptr inbounds float, float* %0, i64 48
%142 = bitcast float* %141 to <8 x float>*
%143 = shufflevector <4 x float> %139, <4 x float> %140, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %143, <8 x float>* %142
%144 = fadd <4 x float> %113, %128
%145 = fadd <4 x float> %114, %127
%146 = getelementptr inbounds float, float* %0, i64 112
%147 = bitcast float* %146 to <8 x float>*
%148 = shufflevector <4 x float> %144, <4 x float> %145, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %148, <8 x float>* %147
%149 = getelementptr inbounds float, float* %0, i64 24
%150 = bitcast float* %149 to <8 x float>*
%151 = load <8 x float>, <8 x float>* %150
%152 = shufflevector <8 x float> %151, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%153 = shufflevector <8 x float> %151, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%154 = getelementptr inbounds float, float* %0, i64 56
%155 = bitcast float* %154 to <8 x float>*
%156 = load <8 x float>, <8 x float>* %155
%157 = shufflevector <8 x float> %156, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%158 = shufflevector <8 x float> %156, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%159 = fadd <4 x float> %152, %157
%160 = fneg <4 x float> %153
%161 = fsub <4 x float> %160, %158
%162 = fsub <4 x float> %152, %157
%163 = fsub <4 x float> %158, %153
%164 = getelementptr inbounds float, float* %0, i64 88
%165 = bitcast float* %164 to <8 x float>*
%166 = load <8 x float>, <8 x float>* %165
%167 = shufflevector <8 x float> %166, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%168 = shufflevector <8 x float> %166, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%169 = getelementptr inbounds float, float* %0, i64 120
%170 = bitcast float* %169 to <8 x float>*
%171 = load <8 x float>, <8 x float>* %170
%172 = shufflevector <8 x float> %171, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%173 = shufflevector <8 x float> %171, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%174 = fadd <4 x float> %167, %172
%175 = fadd <4 x float> %168, %173
%176 = fsub <4 x float> %167, %172
%177 = fsub <4 x float> %168, %173
%178 = fadd <4 x float> %159, %174
%179 = fsub <4 x float> %161, %175
%180 = getelementptr inbounds float, float* %0, i64 24
%181 = bitcast float* %180 to <8 x float>*
%182 = shufflevector <4 x float> %178, <4 x float> %179, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %182, <8 x float>* %181
%183 = fsub <4 x float> %159, %174
%184 = fadd <4 x float> %161, %175
%185 = getelementptr inbounds float, float* %0, i64 88
%186 = bitcast float* %185 to <8 x float>*
%187 = shufflevector <4 x float> %183, <4 x float> %184, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %187, <8 x float>* %186
%188 = fsub <4 x float> %162, %177
%189 = fsub <4 x float> %163, %176
%190 = getelementptr inbounds float, float* %0, i64 56
%191 = bitcast float* %190 to <8 x float>*
%192 = shufflevector <4 x float> %188, <4 x float> %189, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %192, <8 x float>* %191
%193 = fadd <4 x float> %162, %177
%194 = fadd <4 x float> %163, %176
%195 = getelementptr inbounds float, float* %0, i64 120
%196 = bitcast float* %195 to <8 x float>*
%197 = shufflevector <4 x float> %193, <4 x float> %194, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %197, <8 x float>* %196
ret void
}