void LLdiscreteHartleyFloat(float *A, const int nPoints, const float *sinTab) {
  int i, j, n, n2, theta_inc, nptDiv2;
  float alpha, beta;
  for (i = 0; i < nPoints; i += 4) {
    const float x0 = A[i];
    const float x1 = A[i + 1];
    const float x2 = A[i + 2];
    const float x3 = A[i + 3];
    const float y0 = x0 + x1;
    const float y1 = x0 - x1;
    const float y2 = x2 + x3;
    const float y3 = x2 - x3;
    A[i] = y0 + y2;
    A[i + 2] = y0 - y2;
    A[i + 1] = y1 + y3;
    A[i + 3] = y1 - y3;
  }
  for (i = 0; i < nPoints; i += 8) {
    alpha = A[i];
    beta = A[i + 4];
    A[i] = alpha + beta;
    A[i + 4] = alpha - beta;
    alpha = A[i + 2];
    beta = A[i + 6];
    A[i + 2] = alpha + beta;
    A[i + 6] = alpha - beta;
    alpha = A[i + 1];
    const float beta1 =
        0.70710678118654752440084436210485f * (A[i + 5] + A[i + 7]);
    const float beta2 =
        0.70710678118654752440084436210485f * (A[i + 5] - A[i + 7]);
    A[i + 1] = alpha + beta1;
    A[i + 5] = alpha - beta1;
    alpha = A[i + 3];
    A[i + 3] = alpha + beta2;
    A[i + 7] = alpha - beta2;
  }
  n = 16;
  n2 = 8;
  theta_inc = nPoints >> 4;
  nptDiv2 = nPoints >> 2;
  while (n <= nPoints) {
    for (i = 0; i < nPoints; i += n) {
      int theta = theta_inc;
      const int n4 = n2 >> 1;
      alpha = A[i];
      beta = A[i + n2];
      A[i] = alpha + beta;
      A[i + n2] = alpha - beta;
      alpha = A[i + n4];
      beta = A[i + n2 + n4];
      A[i + n4] = alpha + beta;
      A[i + n2 + n4] = alpha - beta;
      for (j = 1; j < n4; j++) {
        float sinval = sinTab[theta];
        float cosval = sinTab[theta + nptDiv2];
        float alpha1 = A[i + j];
        float alpha2 = A[i - j + n2];
        float beta1 = A[i + j + n2] * cosval + A[i - j + n] * sinval;
        float beta2 = A[i + j + n2] * sinval - A[i - j + n] * cosval;
        theta += theta_inc;
        A[i + j] = alpha1 + beta1;
        A[i + j + n2] = alpha1 - beta1;
        A[i - j + n2] = alpha2 + beta2;
        A[i - j + n] = alpha2 - beta2;
      }
    }
    n <<= 1;
    n2 <<= 1;
    theta_inc >>= 1;
  }
}


x86 assembly (clang, -O0):
<LLdiscreteHartleyFloat>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122e <LLdiscreteHartleyFloat+0x12e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1116 <LLdiscreteHartleyFloat+0x16>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1419 <LLdiscreteHartleyFloat+0x319>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xcba(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0xc85(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x1c(%rbp)
jmp    1235 <LLdiscreteHartleyFloat+0x135>
movl   $0x10,-0x24(%rbp)
movl   $0x8,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x4,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     16ee <LLdiscreteHartleyFloat+0x5ee>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16ce <LLdiscreteHartleyFloat+0x5ce>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    16bb <LLdiscreteHartleyFloat+0x5bb>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1536 <LLdiscreteHartleyFloat+0x436>
jmp    16c0 <LLdiscreteHartleyFloat+0x5c0>
mov    -0x24(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    144c <LLdiscreteHartleyFloat+0x34c>
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1439 <LLdiscreteHartleyFloat+0x339>
pop    %rbp
ret

x86 assembly (clang, -O2):
<LLdiscreteHartleyFloat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,-0x38(%rsp)
mov    %esi,-0x50(%rsp)
test   %esi,%esi
jle    15a1 <LLdiscreteHartleyFloat+0x4a1>
mov    -0x50(%rsp),%edx
lea    -0x1(%rdx),%r8
cmp    $0xc,%r8
jae    1130 <LLdiscreteHartleyFloat+0x30>
xor    %eax,%eax
jmp    1250 <LLdiscreteHartleyFloat+0x150>
mov    %r8,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rbx
and    $0xfffffffffffffffc,%rbx
lea    0x0(,%rbx,4),%rax
mov    %rbx,%rsi
mov    %rdi,%rbp
movss  0x30(%rbp),%xmm0
movss  0x20(%rbp),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rbp),%xmm2
movss  0x0(%rbp),%xmm0
unpcklps %xmm2,%xmm0
movlhps %xmm1,%xmm0
movss  0x4(%rbp),%xmm4
movss  0x8(%rbp),%xmm1
movss  0xc(%rbp),%xmm2
movss  0x34(%rbp),%xmm3
movss  0x24(%rbp),%xmm5
unpcklps %xmm3,%xmm5
movss  0x14(%rbp),%xmm3
unpcklps %xmm3,%xmm4
movlhps %xmm5,%xmm4
movss  0x38(%rbp),%xmm3
movss  0x28(%rbp),%xmm5
unpcklps %xmm3,%xmm5
movss  0x18(%rbp),%xmm3
unpcklps %xmm3,%xmm1
movlhps %xmm5,%xmm1
movss  0x3c(%rbp),%xmm3
movss  0x2c(%rbp),%xmm5
unpcklps %xmm3,%xmm5
movss  0x1c(%rbp),%xmm3
unpcklps %xmm3,%xmm2
movlhps %xmm5,%xmm2
movaps %xmm0,%xmm3
addps  %xmm4,%xmm3
subps  %xmm4,%xmm0
movaps %xmm1,%xmm4
addps  %xmm2,%xmm4
subps  %xmm2,%xmm1
movaps %xmm3,%xmm2
addps  %xmm4,%xmm2
subps  %xmm4,%xmm3
movaps %xmm0,%xmm4
addps  %xmm1,%xmm4
subps  %xmm1,%xmm0
movaps %xmm3,%xmm1
unpcklps %xmm0,%xmm1
movaps %xmm4,%xmm5
shufps $0x11,%xmm2,%xmm5
shufps $0xe2,%xmm1,%xmm5
movaps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movaps %xmm2,%xmm6
unpcklps %xmm4,%xmm6
shufps $0x24,%xmm1,%xmm6
movaps %xmm3,%xmm1
unpckhps %xmm0,%xmm1
movaps %xmm4,%xmm7
shufps $0x33,%xmm2,%xmm7
shufps $0xe2,%xmm1,%xmm7
unpckhpd %xmm3,%xmm0
unpckhps %xmm4,%xmm2
shufps $0x24,%xmm0,%xmm2
movups %xmm2,0x20(%rbp)
movups %xmm7,0x30(%rbp)
movups %xmm6,0x0(%rbp)
movups %xmm5,0x10(%rbp)
add    $0x40,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1150 <LLdiscreteHartleyFloat+0x50>
cmp    %rbx,%rcx
je     12b3 <LLdiscreteHartleyFloat+0x1b3>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm0
movss  0x4(%rdi,%rax,4),%xmm1
movss  0x8(%rdi,%rax,4),%xmm2
movss  0xc(%rdi,%rax,4),%xmm3
movaps %xmm0,%xmm4
addss  %xmm1,%xmm4
subss  %xmm1,%xmm0
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
subss  %xmm3,%xmm2
movaps %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,(%rdi,%rax,4)
subss  %xmm1,%xmm4
movss  %xmm4,0x8(%rdi,%rax,4)
movaps %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
subss  %xmm2,%xmm0
movss  %xmm0,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rdx,%rax
jb     1250 <LLdiscreteHartleyFloat+0x150>
cmpl   $0x0,-0x50(%rsp)
jle    15a1 <LLdiscreteHartleyFloat+0x4a1>
cmp    $0x18,%r8
jae    12cb <LLdiscreteHartleyFloat+0x1cb>
xor    %ecx,%ecx
jmp    14e8 <LLdiscreteHartleyFloat+0x3e8>
shr    $0x3,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    0x0(,%r9,8),%rcx
movaps 0xd16(%rip),%xmm8
mov    %r9,%r10
mov    %rdi,%rax
movss  0x60(%rax),%xmm0
movss  0x40(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x20(%rax),%xmm0
movss  (%rax),%xmm10
unpcklps %xmm0,%xmm10
movlhps %xmm1,%xmm10
movss  0x4(%rax),%xmm3
movss  0x8(%rax),%xmm13
movss  0xc(%rax),%xmm12
movss  0x70(%rax),%xmm0
movss  0x50(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x30(%rax),%xmm0
movss  0x10(%rax),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm10,%xmm9
addps  %xmm5,%xmm9
subps  %xmm5,%xmm10
movss  0x68(%rax),%xmm0
movss  0x48(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x28(%rax),%xmm0
unpcklps %xmm0,%xmm13
movlhps %xmm1,%xmm13
movss  0x78(%rax),%xmm0
movss  0x58(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x38(%rax),%xmm0
movss  0x18(%rax),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm13,%xmm11
addps  %xmm5,%xmm11
subps  %xmm5,%xmm13
movss  0x64(%rax),%xmm0
movss  0x44(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x24(%rax),%xmm0
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x74(%rax),%xmm0
movss  0x54(%rax),%xmm5
unpcklps %xmm0,%xmm5
movss  0x34(%rax),%xmm0
movss  0x14(%rax),%xmm1
unpcklps %xmm0,%xmm1
movlhps %xmm5,%xmm1
movss  0x7c(%rax),%xmm0
movss  0x5c(%rax),%xmm5
unpcklps %xmm0,%xmm5
movss  0x3c(%rax),%xmm0
movss  0x1c(%rax),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm5,%xmm6
movaps %xmm1,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm8,%xmm0
subps  %xmm6,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm3,%xmm7
addps  %xmm0,%xmm7
subps  %xmm0,%xmm3
movss  0x6c(%rax),%xmm0
movss  0x4c(%rax),%xmm5
unpcklps %xmm0,%xmm5
movss  0x2c(%rax),%xmm0
unpcklps %xmm0,%xmm12
movlhps %xmm5,%xmm12
movaps %xmm1,%xmm0
addps  %xmm12,%xmm0
subps  %xmm1,%xmm12
movaps %xmm0,%xmm1
movlhps %xmm11,%xmm1
movaps %xmm9,%xmm14
unpcklps %xmm7,%xmm14
shufps $0x24,%xmm1,%xmm14
movaps %xmm12,%xmm6
movlhps %xmm13,%xmm6
movaps %xmm10,%xmm15
unpcklps %xmm3,%xmm15
shufps $0x24,%xmm6,%xmm15
movaps %xmm11,%xmm4
unpcklps %xmm0,%xmm4
movaps %xmm7,%xmm6
shufps $0x11,%xmm9,%xmm6
shufps $0xe2,%xmm4,%xmm6
movaps %xmm13,%xmm4
unpcklps %xmm12,%xmm4
movaps %xmm3,%xmm2
shufps $0x11,%xmm10,%xmm2
shufps $0xe2,%xmm4,%xmm2
movaps %xmm0,%xmm4
unpckhpd %xmm11,%xmm4
movaps %xmm9,%xmm5
unpckhps %xmm7,%xmm5
shufps $0x24,%xmm4,%xmm5
movaps %xmm12,%xmm4
unpckhpd %xmm13,%xmm4
movaps %xmm10,%xmm1
unpckhps %xmm3,%xmm1
shufps $0x24,%xmm4,%xmm1
unpckhps %xmm0,%xmm11
shufps $0x33,%xmm9,%xmm7
shufps $0xe2,%xmm11,%xmm7
unpckhps %xmm12,%xmm13
shufps $0x33,%xmm10,%xmm3
shufps $0xe2,%xmm13,%xmm3
movups %xmm3,0x70(%rax)
movups %xmm7,0x60(%rax)
movups %xmm1,0x50(%rax)
movups %xmm5,0x40(%rax)
movups %xmm2,0x30(%rax)
movups %xmm6,0x20(%rax)
movups %xmm15,0x10(%rax)
movups %xmm14,(%rax)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%r10
jne    12f0 <LLdiscreteHartleyFloat+0x1f0>
cmp    %r9,%r8
je     159a <LLdiscreteHartleyFloat+0x49a>
movss  0xb20(%rip),%xmm0
movss  0x10(%rdi,%rcx,4),%xmm1
movss  (%rdi,%rcx,4),%xmm2
movss  0x4(%rdi,%rcx,4),%xmm3
movaps %xmm2,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%rdi,%rcx,4)
subss  %xmm1,%xmm2
movss  %xmm2,0x10(%rdi,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm1
movss  0x18(%rdi,%rcx,4),%xmm2
movaps %xmm1,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,0x8(%rdi,%rcx,4)
subss  %xmm2,%xmm1
movss  %xmm1,0x18(%rdi,%rcx,4)
movss  0x14(%rdi,%rcx,4),%xmm1
movss  0x1c(%rdi,%rcx,4),%xmm2
movaps %xmm1,%xmm4
addss  %xmm2,%xmm4
mulss  %xmm0,%xmm4
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm3,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rdi,%rcx,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x14(%rdi,%rcx,4)
movss  0xc(%rdi,%rcx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,0xc(%rdi,%rcx,4)
subss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rdi,%rcx,4)
add    $0x8,%rcx
cmp    %rdx,%rcx
jb     14f0 <LLdiscreteHartleyFloat+0x3f0>
cmpl   $0x10,-0x50(%rsp)
jge    15ac <LLdiscreteHartleyFloat+0x4ac>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x50(%rsp),%eax
mov    %eax,%ecx
shr    $0x2,%ecx
mov    %rcx,-0x40(%rsp)
shr    $0x4,%eax
mov    $0x8,%esi
mov    $0x10,%ebp
mov    %rdx,-0x28(%rsp)
jmp    15e8 <LLdiscreteHartleyFloat+0x4e8>
xchg   %ax,%ax
mov    -0x4c(%rsp),%ebp
add    %ebp,%ebp
mov    -0x48(%rsp),%esi
add    %esi,%esi
mov    -0x44(%rsp),%eax
shr    %eax
cmp    -0x50(%rsp),%ebp
jg     15a1 <LLdiscreteHartleyFloat+0x4a1>
mov    %esi,%ecx
sar    %ecx
mov    %esi,-0x48(%rsp)
movslq %esi,%rsi
mov    %ebp,-0x4c(%rsp)
movslq %ebp,%rbp
mov    %eax,-0x44(%rsp)
mov    %eax,%eax
cmp    $0x3,%ecx
mov    $0x2,%ebx
cmovge %ecx,%ebx
movslq %ecx,%rcx
mov    %rcx,-0x18(%rsp)
mov    -0x40(%rsp),%rcx
add    %rax,%rcx
shl    $0x2,%rax
lea    -0x1(%rbp),%r12
lea    -0x1(%rsi),%r9
mov    %rsi,-0x8(%rsp)
lea    0x1(%rsi),%r14
mov    %rbp,-0x10(%rsp)
lea    0x0(,%rbp,4),%rsi
mov    %rsi,-0x20(%rsp)
add    $0xffffffffffffffff,%rbx
mov    %rbx,-0x30(%rsp)
mov    $0x4,%r11d
xor    %r10d,%r10d
jmp    1684 <LLdiscreteHartleyFloat+0x584>
cs nopw 0x0(%rax,%rax,1)
mov    -0x10(%rsp),%rdx
add    %rdx,%r10
add    %rdx,%r12
add    %rdx,%r9
add    %rdx,%r14
add    -0x20(%rsp),%r11
mov    -0x28(%rsp),%rdx
cmp    %rdx,%r10
jge    15d0 <LLdiscreteHartleyFloat+0x4d0>
mov    -0x8(%rsp),%rbx
lea    (%r10,%rbx,1),%rdx
mov    -0x18(%rsp),%rbp
lea    (%r10,%rbp,1),%rsi
add    %rdx,%rbp
movss  (%rdi,%r10,4),%xmm0
movss  (%rdi,%rdx,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%r10,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rdx,4)
movss  (%rdi,%rsi,4),%xmm0
movss  (%rdi,%rbp,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rsi,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rbp,4)
cmp    $0x3,%ebx
jl     1660 <LLdiscreteHartleyFloat+0x560>
mov    -0x30(%rsp),%r15
mov    %r11,%rdx
mov    %r14,%rsi
mov    %r9,%r8
mov    %r12,%rbp
mov    -0x38(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%r13,%rax,1),%xmm0
movss  0x0(%r13,%rcx,4),%xmm1
add    %rax,%r13
movss  (%rdi,%rdx,1),%xmm2
movss  (%rdi,%r8,4),%xmm3
movss  (%rdi,%rsi,4),%xmm4
movss  (%rdi,%rbp,4),%xmm5
movaps %xmm0,%xmm6
mulss  %xmm5,%xmm6
mulss  %xmm4,%xmm0
mulss  %xmm1,%xmm4
addss  %xmm6,%xmm4
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm0
movaps %xmm2,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%rdi,%rdx,1)
subss  %xmm4,%xmm2
movss  %xmm2,(%rdi,%rsi,4)
movaps %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%r8,4)
subss  %xmm0,%xmm3
movss  %xmm3,(%rdi,%rbp,4)
add    $0xffffffffffffffff,%rbp
add    $0xffffffffffffffff,%r8
add    $0x1,%rsi
add    $0x4,%rdx
add    $0xffffffffffffffff,%r15
jne    1700 <LLdiscreteHartleyFloat+0x600>
jmp    1660 <LLdiscreteHartleyFloat+0x560>

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

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