#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*/ bitrv2(int, int *, float *);
int /*<<< orphan*/ cftfsub(int, float *, float *);
int /*<<< orphan*/ dctsub(int, float *, int, float *);
int /*<<< orphan*/ makect(int, int *, float *);
int /*<<< orphan*/ makewt(int, int *, float *);
int /*<<< orphan*/ rftfsub(int, float *, int, float *);
void dfct(int n, float *a, float *t, int *ip, float *w) {
  int j, k, l, m, mh, nw, nc;
  float xr, xi, yr, yi;
  nw = ip[0];
  if (n > (nw << 3)) {
    nw = n >> 3;
    makewt(nw, ip, w);
  }
  nc = ip[1];
  if (n > (nc << 1)) {
    nc = n >> 1;
    makect(nc, ip, w + nw);
  }
  m = n >> 1;
  yi = a[m];
  xi = a[0] + a[n];
  a[0] -= a[n];
  t[0] = xi - yi;
  t[m] = xi + yi;
  if (n > 2) {
    mh = m >> 1;
    for (j = 1; j < mh; j++) {
      k = m - j;
      xr = a[j] - a[n - j];
      xi = a[j] + a[n - j];
      yr = a[k] - a[n - k];
      yi = a[k] + a[n - k];
      a[j] = xr;
      a[k] = yr;
      t[j] = xi - yi;
      t[k] = xi + yi;
    }
    t[mh] = a[mh] + a[n - mh];
    a[mh] -= a[n - mh];
    dctsub(m, a, nc, w + nw);
    if (m > 4) {
      bitrv2(m, ip + 2, a);
      cftfsub(m, a, w);
      rftfsub(m, a, nc, w + nw);
    } else if (m == 4) {
      cftfsub(m, a, w);
    }
    a[n - 1] = a[0] - a[1];
    a[1] = a[0] + a[1];
    for (j = m - 2; j >= 2; j -= 2) {
      a[2 * j + 1] = a[j] + a[j + 1];
      a[2 * j - 1] = a[j] - a[j + 1];
    }
    l = 2;
    m = mh;
    while (m >= 2) {
      dctsub(m, t, nc, w + nw);
      if (m > 4) {
        bitrv2(m, ip + 2, t);
        cftfsub(m, t, w);
        rftfsub(m, t, nc, w + nw);
      } else if (m == 4) {
        cftfsub(m, t, w);
      }
      a[n - l] = t[0] - t[1];
      a[l] = t[0] + t[1];
      k = 0;
      for (j = 2; j < m; j += 2) {
        k += l << 2;
        a[k - l] = t[j] - t[j + 1];
        a[k + l] = t[j] + t[j + 1];
      }
      l <<= 1;
      mh = m >> 1;
      for (j = 0; j < mh; j++) {
        k = m - j;
        t[j] = t[m + k] - t[m + j];
        t[k] = t[m + k] + t[m + j];
      }
      t[mh] = t[m + mh];
      m = mh;
    }
    a[l] = t[0];
    a[n] = t[2] - t[1];
    a[0] = t[2] + t[1];
  } else {
    a[1] = a[0];
    a[2] = t[0];
    a[0] = t[1];
  }
}


x86 assembly (clang, -O0):
<dfct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x40(%rbp),%ecx
shl    $0x3,%ecx
cmp    %ecx,%eax
jle    11ae <dfct+0x4e>
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1040 <makewt@plt>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jle    11ed <dfct+0x8d>
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
call   1070 <makect@plt>
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x2,-0x4(%rbp)
jle    17c6 <dfct+0x666>
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1387 <dfct+0x227>
mov    -0x38(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1282 <dfct+0x122>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rcx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1030 <dctsub@plt>
cmpl   $0x4,-0x38(%rbp)
jle    144a <dfct+0x2ea>
mov    -0x38(%rbp),%edi
mov    -0x20(%rbp),%rsi
add    $0x8,%rsi
mov    -0x10(%rbp),%rdx
call   1060 <bitrv2@plt>
mov    -0x38(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1080 <cftfsub@plt>
mov    -0x38(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rcx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1050 <rftfsub@plt>
jmp    1469 <dfct+0x309>
cmpl   $0x4,-0x38(%rbp)
jne    1464 <dfct+0x304>
mov    -0x38(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1080 <cftfsub@plt>
jmp    1469 <dfct+0x309>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x38(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jl     152f <dfct+0x3cf>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    14af <dfct+0x34f>
movl   $0x2,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jl     1773 <dfct+0x613>
mov    -0x38(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rcx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1030 <dctsub@plt>
cmpl   $0x4,-0x38(%rbp)
jle    15b5 <dfct+0x455>
mov    -0x38(%rbp),%edi
mov    -0x20(%rbp),%rsi
add    $0x8,%rsi
mov    -0x18(%rbp),%rdx
call   1060 <bitrv2@plt>
mov    -0x38(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1080 <cftfsub@plt>
mov    -0x38(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rcx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1050 <rftfsub@plt>
jmp    15d4 <dfct+0x474>
cmpl   $0x4,-0x38(%rbp)
jne    15cf <dfct+0x46f>
mov    -0x38(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1080 <cftfsub@plt>
jmp    15d4 <dfct+0x474>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x30(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    16ab <dfct+0x54b>
mov    -0x34(%rbp),%eax
shl    $0x2,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1623 <dfct+0x4c3>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1749 <dfct+0x5e9>
mov    -0x38(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16c4 <dfct+0x564>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    153c <dfct+0x3dc>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    17f9 <dfct+0x699>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dfct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,%r12
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %edi,%ebp
mov    (%rcx),%r13d
lea    0x0(,%r13,8),%eax
cmp    %edi,%eax
mov    %r8,0x10(%rsp)
jge    11a7 <dfct+0x47>
mov    %ebp,%r13d
sar    $0x3,%r13d
mov    %r13d,%edi
mov    %r12,%rsi
mov    %r8,%rdx
call   1040 <makewt@plt>
mov    0x10(%rsp),%r8
mov    0x4(%r12),%eax
mov    %rax,0x20(%rsp)
add    %eax,%eax
mov    %ebp,%r15d
sar    %r15d
cmp    %ebp,%eax
jge    11dc <dfct+0x7c>
movslq %r13d,%rax
lea    (%r8,%rax,4),%rdx
mov    %r15d,%edi
mov    %r12,%rsi
call   1070 <makect@plt>
mov    0x10(%rsp),%r8
mov    %r15d,%eax
mov    %rax,0x20(%rsp)
movslq %r15d,%rdi
movss  (%r14,%rdi,4),%xmm0
movss  (%r14),%xmm1
movslq %ebp,%rax
movss  (%r14,%rax,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
subss  %xmm2,%xmm1
movss  %xmm1,(%r14)
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
addss  %xmm0,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
cmp    $0x3,%ebp
jl     1371 <dfct+0x211>
mov    %rax,0x38(%rsp)
mov    %r12,0x30(%rsp)
mov    %ebp,%r12d
shr    $0x2,%r12d
mov    %rbp,0x18(%rsp)
cmp    $0x8,%ebp
jb     12e1 <dfct+0x181>
cmp    $0x3,%r12d
mov    $0x2,%ebp
cmovae %r12d,%ebp
mov    0x38(%rsp),%rax
lea    (%r14,%rax,4),%rax
mov    $0x1,%ecx
mov    $0x1,%edx
sub    %rdi,%rdx
lea    (%r14,%rdi,4),%rsi
add    $0xfffffffffffffffc,%rsi
lea    (%rbx,%rdi,4),%r10
add    $0xfffffffffffffffc,%r10
lea    -0x4(,%rbp,4),%r9
ff
xor    %edi,%edi
nopl   0x0(%rax)
movss  (%r14,%rcx,4),%xmm0
movss  -0x4(%rax,%rdi,1),%xmm1
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
addss  %xmm1,%xmm0
movss  (%rsi,%rdi,1),%xmm1
movss  (%rax,%rdx,4),%xmm3
movaps %xmm1,%xmm4
subss  %xmm3,%xmm4
addss  %xmm3,%xmm1
movss  %xmm2,(%r14,%rcx,4)
movss  %xmm4,(%rsi,%rdi,1)
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
addss  %xmm0,%xmm1
movss  %xmm1,(%r10,%rdi,1)
add    $0x1,%rcx
add    $0xfffffffffffffffc,%rdi
add    $0x1,%rdx
mov    %r9,%rbp
add    %rdi,%rbp
jne    1280 <dfct+0x120>
mov    %r12d,%eax
movss  (%r14,%rax,4),%xmm0
mov    0x18(%rsp),%rbp
mov    %ebp,%ecx
sub    %r12d,%ecx
movslq %ecx,%rcx
addss  (%r14,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%r14,%rax,4),%xmm0
subss  (%r14,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
movslq %r13d,%rax
lea    (%r8,%rax,4),%r13
mov    %r15d,%edi
mov    %r14,%rsi
mov    0x20(%rsp),%rdx
mov    %r13,%rcx
call   1030 <dctsub@plt>
cmp    $0xa,%ebp
mov    %r13,0x50(%rsp)
jl     1390 <dfct+0x230>
mov    0x30(%rsp),%rax
lea    0x8(%rax),%rsi
mov    %r15d,%edi
mov    %r14,%rdx
call   1060 <bitrv2@plt>
mov    %r15d,%edi
mov    %r14,%rsi
mov    0x10(%rsp),%rdx
call   1080 <cftfsub@plt>
mov    %r15d,%edi
mov    %r14,%rsi
mov    0x20(%rsp),%rdx
mov    %r13,%rcx
call   1050 <rftfsub@plt>
jmp    13a8 <dfct+0x248>
movss  (%r14),%xmm0
movss  %xmm0,0x4(%r14)
movss  (%rbx),%xmm0
movss  %xmm0,0x8(%r14)
movss  0x4(%rbx),%xmm0
jmp    17fe <dfct+0x69e>
cmp    $0x4,%r15d
jne    13a8 <dfct+0x248>
mov    $0x4,%edi
mov    %r14,%rsi
mov    0x10(%rsp),%rdx
call   1080 <cftfsub@plt>
movss  (%r14),%xmm0
subss  0x4(%r14),%xmm0
mov    0x18(%rsp),%rcx
lea    -0x1(%rcx),%eax
movss  %xmm0,(%r14,%rax,4)
movss  (%r14),%xmm0
addss  0x4(%r14),%xmm0
movss  %xmm0,0x4(%r14)
cmp    $0x8,%ecx
jl     1428 <dfct+0x2c8>
mov    %r15d,%eax
add    $0x2,%eax
lea    (%r15,%r15,1),%ecx
add    $0xfffffffb,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x4(%rax),%edx
movss  (%r14,%rdx,4),%xmm0
lea    -0x3(%rax),%edx
movss  (%r14,%rdx,4),%xmm1
addss  %xmm0,%xmm1
lea    0x2(%rcx),%esi
movss  %xmm1,(%r14,%rsi,4)
subss  (%r14,%rdx,4),%xmm0
mov    %ecx,%edx
movss  %xmm0,(%r14,%rdx,4)
add    $0xfffffffe,%eax
add    $0xfffffffc,%ecx
cmp    $0x5,%eax
jg     13f0 <dfct+0x290>
mov    $0x2,%eax
cmpl   $0x8,0x18(%rsp)
jb     17d5 <dfct+0x675>
addq   $0x8,0x30(%rsp)
lea    0x4(%rbx),%rax
mov    %rax,0x40(%rsp)
mov    $0x2,%r13d
jmp    146b <dfct+0x30b>
nop
lea    (%r12,%r15,1),%eax
movss  (%rbx,%rax,4),%xmm0
mov    %r12d,%eax
movss  %xmm0,(%rbx,%rax,4)
cmp    $0x3,%r15d
jbe    17d2 <dfct+0x672>
mov    %r12d,%r15d
mov    %r12d,%edi
mov    %rbx,%rsi
mov    0x20(%rsp),%rbp
mov    %ebp,%edx
mov    0x50(%rsp),%r12
mov    %r12,%rcx
call   1030 <dctsub@plt>
cmp    $0x5,%r15d
jb     14d0 <dfct+0x370>
mov    %r15d,%edi
mov    0x30(%rsp),%rsi
mov    %rbx,%rdx
call   1060 <bitrv2@plt>
mov    %r15d,%edi
mov    %rbx,%rsi
mov    0x10(%rsp),%rdx
call   1080 <cftfsub@plt>
mov    %r15d,%edi
mov    %rbx,%rsi
mov    %ebp,%edx
mov    %r12,%rcx
call   1050 <rftfsub@plt>
mov    0x18(%rsp),%rbp
jmp    14ed <dfct+0x38d>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x4,%r15d
mov    0x18(%rsp),%rbp
jne    14ed <dfct+0x38d>
mov    $0x4,%edi
mov    %rbx,%rsi
mov    0x10(%rsp),%rdx
call   1080 <cftfsub@plt>
movss  (%rbx),%xmm0
subss  0x4(%rbx),%xmm0
mov    %ebp,%eax
sub    %r13d,%eax
cltq
movss  %xmm0,(%r14,%rax,4)
movss  (%rbx),%xmm0
addss  0x4(%rbx),%xmm0
movslq %r13d,%rax
movss  %xmm0,(%r14,%rax,4)
mov    %r15d,%ecx
cmp    $0x3,%r15d
jb     156c <dfct+0x40c>
lea    0x0(,%rax,4),%edx
movslq %edx,%rbp
lea    (%r14,%rax,4),%rdx
shl    $0x2,%rax
mov    %r14,%rsi
sub    %rax,%rsi
mov    $0x2,%edi
mov    %rbp,%rax
xchg   %ax,%ax
movss  (%rbx,%rdi,4),%xmm0
subss  0x4(%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  (%rbx,%rdi,4),%xmm0
addss  0x4(%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x2,%rdi
add    %rbp,%rax
cmp    %rcx,%rdi
jb     1540 <dfct+0x3e0>
add    %r13d,%r13d
mov    %r15d,%r12d
shr    %r12d
cmp    $0x1,%r15d
jbe    17c1 <dfct+0x661>
cmp    $0x2,%r12d
mov    $0x1,%esi
cmovae %r12d,%esi
cmp    $0x4,%esi
jae    1660 <dfct+0x500>
xor    %eax,%eax
mov    %rax,%rdx
test   $0x1,%sil
je     15d2 <dfct+0x472>
mov    %rcx,%rdx
sub    %rax,%rdx
lea    (%rdx,%rcx,1),%rdi
movss  (%rbx,%rdi,4),%xmm0
lea    (%rax,%rcx,1),%rbp
movss  (%rbx,%rbp,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%rax,4)
addss  (%rbx,%rdi,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
add    %rsi,%rax
je     1450 <dfct+0x2f0>
lea    (%rdx,%rcx,1),%rax
add    $0x1,%rax
mov    %rcx,%rdi
sub    %rdx,%rdi
shl    $0x3,%rcx
lea    0x0(,%rdx,4),%rbp
sub    %rbp,%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,1),%xmm0
movss  -0x4(%rbx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%rdx,4)
addss  (%rbx,%rcx,1),%xmm1
movss  %xmm1,(%rbx,%rdi,4)
movss  -0x4(%rbx,%rcx,1),%xmm0
movss  (%rbx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rbx,%rdx,4)
addss  -0x4(%rbx,%rcx,1),%xmm1
movss  %xmm1,-0x4(%rbx,%rdi,4)
add    $0x2,%rdx
add    $0x2,%rax
add    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffff8,%rcx
cmp    %rdx,%rsi
jne    1600 <dfct+0x4a0>
jmp    1450 <dfct+0x2f0>
nopl   0x0(%rax)
lea    -0x1(%rsi),%rax
mov    $0x4,%edx
mul    %rdx
lea    (%rbx,%rcx,4),%r8
seto   %dl
mov    %r8,%rdi
sub    %rax,%rdi
cmp    %r8,%rdi
ja     1595 <dfct+0x435>
test   %dl,%dl
jne    1595 <dfct+0x435>
lea    (%rbx,%rcx,8),%r10
mov    %r10,%rdi
sub    %rax,%rdi
cmp    %r10,%rdi
ja     1595 <dfct+0x435>
mov    $0x0,%eax
test   %dl,%dl
jne    1597 <dfct+0x437>
mov    0x40(%rsp),%r9
cmp    %rbx,%r9
seta   0xc(%rsp)
lea    (%rbx,%rsi,4),%rdi
lea    (%rcx,%rsi,1),%rax
lea    (%rbx,%rax,4),%r11
mov    %r11,0x28(%rsp)
mov    %rcx,%rax
sub    %rsi,%rax
lea    (%r9,%rax,4),%rbp
lea    (%r9,%rcx,4),%rdx
mov    %rdx,0x48(%rsp)
lea    (%rcx,%rcx,1),%rax
sub    %rsi,%rax
lea    (%r9,%rax,4),%rax
cmp    %rbx,%r11
seta   0xf(%rsp)
lea    (%r9,%rcx,8),%r9
cmp    %rdi,%r8
setb   0xe(%rsp)
cmp    %rbx,%rdx
seta   %dl
cmp    %rdi,%rbp
setb   0xd(%rsp)
cmp    %rbx,%r9
seta   %r11b
cmp    %rdi,%rax
setb   %dil
cmp    0x28(%rsp),%rbp
setb   0x28(%rsp)
cmp    %r9,%rbp
setb   %r9b
cmp    0x48(%rsp),%rax
setb   %bpl
mov    0xe(%rsp),%al
test   %al,0xf(%rsp)
jne    1595 <dfct+0x435>
and    0xd(%rsp),%dl
jne    1595 <dfct+0x435>
and    %dil,%r11b
jne    1595 <dfct+0x435>
mov    0x28(%rsp),%al
and    %al,0xc(%rsp)
jne    1595 <dfct+0x435>
mov    $0x0,%eax
and    %bpl,%r9b
jne    1597 <dfct+0x437>
mov    %esi,%eax
and    $0x1ffffffc,%eax
mov    $0xfffffffffffffff4,%rbp
xor    %edx,%edx
nopl   (%rax)
movups (%r10,%rbp,1),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups (%r8,%rdx,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%rbx,%rdx,4)
movups (%r10,%rbp,1),%xmm0
shufps $0x1b,%xmm1,%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r8,%rbp,1)
add    $0x4,%rdx
add    $0xfffffffffffffff0,%rbp
cmp    %rdx,%rax
jne    1780 <dfct+0x620>
cmp    %rsi,%rax
je     1450 <dfct+0x2f0>
jmp    1597 <dfct+0x437>
add    %r12d,%r15d
movss  (%rbx,%r15,4),%xmm0
mov    %r12d,%eax
movss  %xmm0,(%rbx,%rax,4)
movslq %r13d,%rax
movss  (%rbx),%xmm0
movss  %xmm0,(%r14,%rax,4)
movss  0x8(%rbx),%xmm0
subss  0x4(%rbx),%xmm0
mov    0x38(%rsp),%rax
movss  %xmm0,(%r14,%rax,4)
movss  0x8(%rbx),%xmm0
addss  0x4(%rbx),%xmm0
movss  %xmm0,(%r14)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dfct(i32 %0, float* %1, float* %2, i32* %3, float* %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32*
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
store i32 %0, i32* %6
store float* %1, float** %7
store float* %2, float** %8
store i32* %3, i32** %9
store float* %4, float** %10
%22 = load i32*, i32** %9
%23 = getelementptr inbounds i32, i32* %22, i64 0
%24 = load i32, i32* %23
store i32 %24, i32* %16
%25 = load i32, i32* %6
%26 = load i32, i32* %16
%27 = shl i32 %26, 3
%28 = icmp sgt i32 %25, %27
br i1 %28, label %29, label %36
29: ; preds = %5
%30 = load i32, i32* %6
%31 = ashr i32 %30, 3
store i32 %31, i32* %16
%32 = load i32, i32* %16
%33 = load i32*, i32** %9
%34 = load float*, float** %10
%35 = call i32 @makewt(i32 %32, i32* %33, float* %34)
br label %36
36: ; preds = %29, %5
%37 = load i32*, i32** %9
%38 = getelementptr inbounds i32, i32* %37, i64 1
%39 = load i32, i32* %38
store i32 %39, i32* %17
%40 = load i32, i32* %6
%41 = load i32, i32* %17
%42 = shl i32 %41, 1
%43 = icmp sgt i32 %40, %42
br i1 %43, label %44, label %54
44: ; preds = %36
%45 = load i32, i32* %6
%46 = ashr i32 %45, 1
store i32 %46, i32* %17
%47 = load i32, i32* %17
%48 = load i32*, i32** %9
%49 = load float*, float** %10
%50 = load i32, i32* %16
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
%53 = call i32 @makect(i32 %47, i32* %48, float* %52)
br label %54
54: ; preds = %44, %36
%55 = load i32, i32* %6
%56 = ashr i32 %55, 1
store i32 %56, i32* %14
%57 = load float*, float** %7
%58 = load i32, i32* %14
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
store float %61, float* %21
%62 = load float*, float** %7
%63 = getelementptr inbounds float, float* %62, i64 0
%64 = load float, float* %63
%65 = load float*, float** %7
%66 = load i32, i32* %6
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
%69 = load float, float* %68
%70 = fadd float %64, %69
store float %70, float* %19
%71 = load float*, float** %7
%72 = load i32, i32* %6
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = load float*, float** %7
%77 = getelementptr inbounds float, float* %76, i64 0
%78 = load float, float* %77
%79 = fsub float %78, %75
store float %79, float* %77
%80 = load float, float* %19
%81 = load float, float* %21
%82 = fsub float %80, %81
%83 = load float*, float** %8
%84 = getelementptr inbounds float, float* %83, i64 0
store float %82, float* %84
%85 = load float, float* %19
%86 = load float, float* %21
%87 = fadd float %85, %86
%88 = load float*, float** %8
%89 = load i32, i32* %14
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %88, i64 %90
store float %87, float* %91
%92 = load i32, i32* %6
%93 = icmp sgt i32 %92, 2
br i1 %93, label %94, label %530
94: ; preds = %54
%95 = load i32, i32* %14
%96 = ashr i32 %95, 1
store i32 %96, i32* %15
store i32 1, i32* %11
br label %97
97: ; preds = %181, %94
%98 = load i32, i32* %11
%99 = load i32, i32* %15
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %184
101: ; preds = %97
%102 = load i32, i32* %14
%103 = load i32, i32* %11
%104 = sub nsw i32 %102, %103
store i32 %104, i32* %12
%105 = load float*, float** %7
%106 = load i32, i32* %11
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %105, i64 %107
%109 = load float, float* %108
%110 = load float*, float** %7
%111 = load i32, i32* %6
%112 = load i32, i32* %11
%113 = sub nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %110, i64 %114
%116 = load float, float* %115
%117 = fsub float %109, %116
store float %117, float* %18
%118 = load float*, float** %7
%119 = load i32, i32* %11
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = load float*, float** %7
%124 = load i32, i32* %6
%125 = load i32, i32* %11
%126 = sub nsw i32 %124, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %123, i64 %127
%129 = load float, float* %128
%130 = fadd float %122, %129
store float %130, float* %19
%131 = load float*, float** %7
%132 = load i32, i32* %12
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %131, i64 %133
%135 = load float, float* %134
%136 = load float*, float** %7
%137 = load i32, i32* %6
%138 = load i32, i32* %12
%139 = sub nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %136, i64 %140
%142 = load float, float* %141
%143 = fsub float %135, %142
store float %143, float* %20
%144 = load float*, float** %7
%145 = load i32, i32* %12
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %7
%150 = load i32, i32* %6
%151 = load i32, i32* %12
%152 = sub nsw i32 %150, %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %149, i64 %153
%155 = load float, float* %154
%156 = fadd float %148, %155
store float %156, float* %21
%157 = load float, float* %18
%158 = load float*, float** %7
%159 = load i32, i32* %11
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
store float %157, float* %161
%162 = load float, float* %20
%163 = load float*, float** %7
%164 = load i32, i32* %12
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
store float %162, float* %166
%167 = load float, float* %19
%168 = load float, float* %21
%169 = fsub float %167, %168
%170 = load float*, float** %8
%171 = load i32, i32* %11
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %170, i64 %172
store float %169, float* %173
%174 = load float, float* %19
%175 = load float, float* %21
%176 = fadd float %174, %175
%177 = load float*, float** %8
%178 = load i32, i32* %12
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %177, i64 %179
store float %176, float* %180
br label %181
181: ; preds = %101
%182 = load i32, i32* %11
%183 = add nsw i32 %182, 1
store i32 %183, i32* %11
br label %97
184: ; preds = %97
%185 = load float*, float** %7
%186 = load i32, i32* %15
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %185, i64 %187
%189 = load float, float* %188
%190 = load float*, float** %7
%191 = load i32, i32* %6
%192 = load i32, i32* %15
%193 = sub nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float, float* %190, i64 %194
%196 = load float, float* %195
%197 = fadd float %189, %196
%198 = load float*, float** %8
%199 = load i32, i32* %15
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %198, i64 %200
store float %197, float* %201
%202 = load float*, float** %7
%203 = load i32, i32* %6
%204 = load i32, i32* %15
%205 = sub nsw i32 %203, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %202, i64 %206
%208 = load float, float* %207
%209 = load float*, float** %7
%210 = load i32, i32* %15
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
%214 = fsub float %213, %208
store float %214, float* %212
%215 = load i32, i32* %14
%216 = load float*, float** %7
%217 = load i32, i32* %17
%218 = load float*, float** %10
%219 = load i32, i32* %16
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %218, i64 %220
%222 = call i32 @dctsub(i32 %215, float* %216, i32 %217, float* %221)
%223 = load i32, i32* %14
%224 = icmp sgt i32 %223, 4
br i1 %224, label %225, label %243
225: ; preds = %184
%226 = load i32, i32* %14
%227 = load i32*, i32** %9
%228 = getelementptr inbounds i32, i32* %227, i64 2
%229 = load float*, float** %7
%230 = call i32 @bitrv2(i32 %226, i32* %228, float* %229)
%231 = load i32, i32* %14
%232 = load float*, float** %7
%233 = load float*, float** %10
%234 = call i32 @cftfsub(i32 %231, float* %232, float* %233)
%235 = load i32, i32* %14
%236 = load float*, float** %7
%237 = load i32, i32* %17
%238 = load float*, float** %10
%239 = load i32, i32* %16
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %238, i64 %240
%242 = call i32 @rftfsub(i32 %235, float* %236, i32 %237, float* %241)
br label %252
243: ; preds = %184
%244 = load i32, i32* %14
%245 = icmp eq i32 %244, 4
br i1 %245, label %246, label %251
246: ; preds = %243
%247 = load i32, i32* %14
%248 = load float*, float** %7
%249 = load float*, float** %10
%250 = call i32 @cftfsub(i32 %247, float* %248, float* %249)
br label %251
251: ; preds = %246, %243
br label %252
252: ; preds = %251, %225
%253 = load float*, float** %7
%254 = getelementptr inbounds float, float* %253, i64 0
%255 = load float, float* %254
%256 = load float*, float** %7
%257 = getelementptr inbounds float, float* %256, i64 1
%258 = load float, float* %257
%259 = fsub float %255, %258
%260 = load float*, float** %7
%261 = load i32, i32* %6
%262 = sub nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %260, i64 %263
store float %259, float* %264
%265 = load float*, float** %7
%266 = getelementptr inbounds float, float* %265, i64 0
%267 = load float, float* %266
%268 = load float*, float** %7
%269 = getelementptr inbounds float, float* %268, i64 1
%270 = load float, float* %269
%271 = fadd float %267, %270
%272 = load float*, float** %7
%273 = getelementptr inbounds float, float* %272, i64 1
store float %271, float* %273
%274 = load i32, i32* %14
%275 = sub nsw i32 %274, 2
store i32 %275, i32* %11
br label %276
276: ; preds = %316, %252
%277 = load i32, i32* %11
%278 = icmp sge i32 %277, 2
br i1 %278, label %279, label %319
279: ; preds = %276
%280 = load float*, float** %7
%281 = load i32, i32* %11
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
%284 = load float, float* %283
%285 = load float*, float** %7
%286 = load i32, i32* %11
%287 = add nsw i32 %286, 1
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %285, i64 %288
%290 = load float, float* %289
%291 = fadd float %284, %290
%292 = load float*, float** %7
%293 = load i32, i32* %11
%294 = mul nsw i32 2, %293
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %292, i64 %296
store float %291, float* %297
%298 = load float*, float** %7
%299 = load i32, i32* %11
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float, float* %298, i64 %300
%302 = load float, float* %301
%303 = load float*, float** %7
%304 = load i32, i32* %11
%305 = add nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %303, i64 %306
%308 = load float, float* %307
%309 = fsub float %302, %308
%310 = load float*, float** %7
%311 = load i32, i32* %11
%312 = mul nsw i32 2, %311
%313 = sub nsw i32 %312, 1
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds float, float* %310, i64 %314
store float %309, float* %315
br label %316
316: ; preds = %279
%317 = load i32, i32* %11
%318 = sub nsw i32 %317, 2
store i32 %318, i32* %11
br label %276
319: ; preds = %276
store i32 2, i32* %13
%320 = load i32, i32* %15
store i32 %320, i32* %14
br label %321
321: ; preds = %489, %319
%322 = load i32, i32* %14
%323 = icmp sge i32 %322, 2
br i1 %323, label %324, label %502
324: ; preds = %321
%325 = load i32, i32* %14
%326 = load float*, float** %8
%327 = load i32, i32* %17
%328 = load float*, float** %10
%329 = load i32, i32* %16
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
%332 = call i32 @dctsub(i32 %325, float* %326, i32 %327, float* %331)
%333 = load i32, i32* %14
%334 = icmp sgt i32 %333, 4
br i1 %334, label %335, label %353
335: ; preds = %324
%336 = load i32, i32* %14
%337 = load i32*, i32** %9
%338 = getelementptr inbounds i32, i32* %337, i64 2
%339 = load float*, float** %8
%340 = call i32 @bitrv2(i32 %336, i32* %338, float* %339)
%341 = load i32, i32* %14
%342 = load float*, float** %8
%343 = load float*, float** %10
%344 = call i32 @cftfsub(i32 %341, float* %342, float* %343)
%345 = load i32, i32* %14
%346 = load float*, float** %8
%347 = load i32, i32* %17
%348 = load float*, float** %10
%349 = load i32, i32* %16
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
%352 = call i32 @rftfsub(i32 %345, float* %346, i32 %347, float* %351)
br label %362
353: ; preds = %324
%354 = load i32, i32* %14
%355 = icmp eq i32 %354, 4
br i1 %355, label %356, label %361
356: ; preds = %353
%357 = load i32, i32* %14
%358 = load float*, float** %8
%359 = load float*, float** %10
%360 = call i32 @cftfsub(i32 %357, float* %358, float* %359)
br label %361
361: ; preds = %356, %353
br label %362
362: ; preds = %361, %335
%363 = load float*, float** %8
%364 = getelementptr inbounds float, float* %363, i64 0
%365 = load float, float* %364
%366 = load float*, float** %8
%367 = getelementptr inbounds float, float* %366, i64 1
%368 = load float, float* %367
%369 = fsub float %365, %368
%370 = load float*, float** %7
%371 = load i32, i32* %6
%372 = load i32, i32* %13
%373 = sub nsw i32 %371, %372
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %370, i64 %374
store float %369, float* %375
%376 = load float*, float** %8
%377 = getelementptr inbounds float, float* %376, i64 0
%378 = load float, float* %377
%379 = load float*, float** %8
%380 = getelementptr inbounds float, float* %379, i64 1
%381 = load float, float* %380
%382 = fadd float %378, %381
%383 = load float*, float** %7
%384 = load i32, i32* %13
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds float, float* %383, i64 %385
store float %382, float* %386
store i32 0, i32* %12
store i32 2, i32* %11
br label %387
387: ; preds = %432, %362
%388 = load i32, i32* %11
%389 = load i32, i32* %14
%390 = icmp slt i32 %388, %389
br i1 %390, label %391, label %435
391: ; preds = %387
%392 = load i32, i32* %13
%393 = shl i32 %392, 2
%394 = load i32, i32* %12
%395 = add nsw i32 %394, %393
store i32 %395, i32* %12
%396 = load float*, float** %8
%397 = load i32, i32* %11
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds float, float* %396, i64 %398
%400 = load float, float* %399
%401 = load float*, float** %8
%402 = load i32, i32* %11
%403 = add nsw i32 %402, 1
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds float, float* %401, i64 %404
%406 = load float, float* %405
%407 = fsub float %400, %406
%408 = load float*, float** %7
%409 = load i32, i32* %12
%410 = load i32, i32* %13
%411 = sub nsw i32 %409, %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float, float* %408, i64 %412
store float %407, float* %413
%414 = load float*, float** %8
%415 = load i32, i32* %11
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
%419 = load float*, float** %8
%420 = load i32, i32* %11
%421 = add nsw i32 %420, 1
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float, float* %419, i64 %422
%424 = load float, float* %423
%425 = fadd float %418, %424
%426 = load float*, float** %7
%427 = load i32, i32* %12
%428 = load i32, i32* %13
%429 = add nsw i32 %427, %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds float, float* %426, i64 %430
store float %425, float* %431
br label %432
432: ; preds = %391
%433 = load i32, i32* %11
%434 = add nsw i32 %433, 2
store i32 %434, i32* %11
br label %387
435: ; preds = %387
%436 = load i32, i32* %13
%437 = shl i32 %436, 1
store i32 %437, i32* %13
%438 = load i32, i32* %14
%439 = ashr i32 %438, 1
store i32 %439, i32* %15
store i32 0, i32* %11
br label %440
440: ; preds = %486, %435
%441 = load i32, i32* %11
%442 = load i32, i32* %15
%443 = icmp slt i32 %441, %442
br i1 %443, label %444, label %489
444: ; preds = %440
%445 = load i32, i32* %14
%446 = load i32, i32* %11
%447 = sub nsw i32 %445, %446
store i32 %447, i32* %12
%448 = load float*, float** %8
%449 = load i32, i32* %14
%450 = load i32, i32* %12
%451 = add nsw i32 %449, %450
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds float, float* %448, i64 %452
%454 = load float, float* %453
%455 = load float*, float** %8
%456 = load i32, i32* %14
%457 = load i32, i32* %11
%458 = add nsw i32 %456, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %455, i64 %459
%461 = load float, float* %460
%462 = fsub float %454, %461
%463 = load float*, float** %8
%464 = load i32, i32* %11
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %463, i64 %465
store float %462, float* %466
%467 = load float*, float** %8
%468 = load i32, i32* %14
%469 = load i32, i32* %12
%470 = add nsw i32 %468, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float, float* %467, i64 %471
%473 = load float, float* %472
%474 = load float*, float** %8
%475 = load i32, i32* %14
%476 = load i32, i32* %11
%477 = add nsw i32 %475, %476
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %474, i64 %478
%480 = load float, float* %479
%481 = fadd float %473, %480
%482 = load float*, float** %8
%483 = load i32, i32* %12
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds float, float* %482, i64 %484
store float %481, float* %485
br label %486
486: ; preds = %444
%487 = load i32, i32* %11
%488 = add nsw i32 %487, 1
store i32 %488, i32* %11
br label %440
489: ; preds = %440
%490 = load float*, float** %8
%491 = load i32, i32* %14
%492 = load i32, i32* %15
%493 = add nsw i32 %491, %492
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds float, float* %490, i64 %494
%496 = load float, float* %495
%497 = load float*, float** %8
%498 = load i32, i32* %15
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds float, float* %497, i64 %499
store float %496, float* %500
%501 = load i32, i32* %15
store i32 %501, i32* %14
br label %321
502: ; preds = %321
%503 = load float*, float** %8
%504 = getelementptr inbounds float, float* %503, i64 0
%505 = load float, float* %504
%506 = load float*, float** %7
%507 = load i32, i32* %13
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float, float* %506, i64 %508
store float %505, float* %509
%510 = load float*, float** %8
%511 = getelementptr inbounds float, float* %510, i64 2
%512 = load float, float* %511
%513 = load float*, float** %8
%514 = getelementptr inbounds float, float* %513, i64 1
%515 = load float, float* %514
%516 = fsub float %512, %515
%517 = load float*, float** %7
%518 = load i32, i32* %6
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds float, float* %517, i64 %519
store float %516, float* %520
%521 = load float*, float** %8
%522 = getelementptr inbounds float, float* %521, i64 2
%523 = load float, float* %522
%524 = load float*, float** %8
%525 = getelementptr inbounds float, float* %524, i64 1
%526 = load float, float* %525
%527 = fadd float %523, %526
%528 = load float*, float** %7
%529 = getelementptr inbounds float, float* %528, i64 0
store float %527, float* %529
br label %546
530: ; preds = %54
%531 = load float*, float** %7
%532 = getelementptr inbounds float, float* %531, i64 0
%533 = load float, float* %532
%534 = load float*, float** %7
%535 = getelementptr inbounds float, float* %534, i64 1
store float %533, float* %535
%536 = load float*, float** %8
%537 = getelementptr inbounds float, float* %536, i64 0
%538 = load float, float* %537
%539 = load float*, float** %7
%540 = getelementptr inbounds float, float* %539, i64 2
store float %538, float* %540
%541 = load float*, float** %8
%542 = getelementptr inbounds float, float* %541, i64 1
%543 = load float, float* %542
%544 = load float*, float** %7
%545 = getelementptr inbounds float, float* %544, i64 0
store float %543, float* %545
br label %546
546: ; preds = %530, %502
ret void
}

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