#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 */
typedef int uint32_t;
typedef int int16_t;

/* Variables and functions */
void bitrevR2(float *ioptr, int M, int16_t *BRLow) {
  float f0r;
  float f0i;
  float f1r;
  float f1i;
  float f2r;
  float f2i;
  float f3r;
  float f3i;
  float f4r;
  float f4i;
  float f5r;
  float f5i;
  float f6r;
  float f6i;
  float f7r;
  float f7i;
  float t0r;
  float t0i;
  float t1r;
  float t1i;
  float *p0r;
  float *p1r;
  float *IOP;
  float *iolimit;
  int Colstart;
  int iCol;
  unsigned int posA;
  unsigned int posAi;
  unsigned int posB;
  unsigned int posBi;
  const unsigned int Nrems2 = ((uint32_t)1 << ((M + 3) / 2));
  const unsigned int Nroot_1_ColInc = ((uint32_t)1 << (M)) - Nrems2;
  const unsigned int Nroot_1 = ((uint32_t)1 << (M / 2 - 1)) - 1;
  const unsigned int ColstartShift = (M + 1) / 2 + 1;
  posA = ((uint32_t)1 << (M));
  posAi = posA + 1;
  posB = posA + 2;
  posBi = posB + 1;
  iolimit = ioptr + Nrems2;
  for (; ioptr < iolimit; ioptr += ((uint32_t)1 << (M / 2 + 1))) {
    for (Colstart = Nroot_1; Colstart >= 0; Colstart--) {
      iCol = Nroot_1;
      p0r = ioptr + Nroot_1_ColInc + BRLow[Colstart] * 4;
      IOP = ioptr + (Colstart << ColstartShift);
      p1r = IOP + BRLow[iCol] * 4;
      f0r = *(p0r);
      f0i = *(p0r + 1);
      f1r = *(p0r + posA);
      f1i = *(p0r + posAi);
      for (; iCol > Colstart;) {
        f2r = *(p0r + 2);
        f2i = *(p0r + (2 + 1));
        f3r = *(p0r + posB);
        f3i = *(p0r + posBi);
        f4r = *(p1r);
        f4i = *(p1r + 1);
        f5r = *(p1r + posA);
        f5i = *(p1r + posAi);
        f6r = *(p1r + 2);
        f6i = *(p1r + (2 + 1));
        f7r = *(p1r + posB);
        f7i = *(p1r + posBi);
        t0r = f0r + f1r;
        t0i = f0i + f1i;
        f1r = f0r - f1r;
        f1i = f0i - f1i;
        t1r = f2r + f3r;
        t1i = f2i + f3i;
        f3r = f2r - f3r;
        f3i = f2i - f3i;
        f0r = f4r + f5r;
        f0i = f4i + f5i;
        f5r = f4r - f5r;
        f5i = f4i - f5i;
        f2r = f6r + f7r;
        f2i = f6i + f7i;
        f7r = f6r - f7r;
        f7i = f6i - f7i;
        *(p1r) = t0r;
        *(p1r + 1) = t0i;
        *(p1r + 2) = f1r;
        *(p1r + (2 + 1)) = f1i;
        *(p1r + posA) = t1r;
        *(p1r + posAi) = t1i;
        *(p1r + posB) = f3r;
        *(p1r + posBi) = f3i;
        *(p0r) = f0r;
        *(p0r + 1) = f0i;
        *(p0r + 2) = f5r;
        *(p0r + (2 + 1)) = f5i;
        *(p0r + posA) = f2r;
        *(p0r + posAi) = f2i;
        *(p0r + posB) = f7r;
        *(p0r + posBi) = f7i;
        p0r -= Nrems2;
        f0r = *(p0r);
        f0i = *(p0r + 1);
        f1r = *(p0r + posA);
        f1i = *(p0r + posAi);
        iCol -= 1;
        p1r = IOP + BRLow[iCol] * 4;
      }
      f2r = *(p0r + 2);
      f2i = *(p0r + (2 + 1));
      f3r = *(p0r + posB);
      f3i = *(p0r + posBi);
      t0r = f0r + f1r;
      t0i = f0i + f1i;
      f1r = f0r - f1r;
      f1i = f0i - f1i;
      t1r = f2r + f3r;
      t1i = f2i + f3i;
      f3r = f2r - f3r;
      f3i = f2i - f3i;
      *(p0r) = t0r;
      *(p0r + 1) = t0i;
      *(p0r + 2) = f1r;
      *(p0r + (2 + 1)) = f1i;
      *(p0r + posA) = t1r;
      *(p0r + posAi) = t1i;
      *(p0r + posB) = f3r;
      *(p0r + posBi) = f3i;
    }
  }
}


x86 assembly (clang, -O0):
<bitrevR2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x3,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x88(%rbp),%rax
jae    17bf <bitrevR2+0x6bf>
mov    -0xac(%rbp),%eax
mov    %eax,-0x8c(%rbp)
cmpl   $0x0,-0x8c(%rbp)
jl     178a <bitrevR2+0x68a>
mov    -0xac(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x8c(%rbp),%edx
mov    -0xb0(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x90(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jle    1633 <bitrevR2+0x533>
mov    -0x70(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x70(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x78(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x78(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x24(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x20(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x90(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x90(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    12c0 <bitrevR2+0x1c0>
mov    -0x70(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x70(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x24(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x98(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8c(%rbp)
jmp    11ef <bitrevR2+0xef>
jmp    178f <bitrevR2+0x68f>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
add    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    11d2 <bitrevR2+0xd2>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrevR2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x30,%rsp
mov    %rdx,%r14
mov    %esi,%r9d
lea    0x3(%r9),%eax
shr    $0x1f,%eax
lea    (%r9,%rax,1),%ecx
add    $0x3,%ecx
shr    %ecx
mov    $0x1,%r13d
mov    $0x1,%r12d
shl    %cl,%r12d
mov    $0x1,%r15d
mov    %r9d,%ecx
shl    %cl,%r15d
mov    %esi,%r8d
shr    $0x1f,%r8d
add    %esi,%r8d
shr    %r8d
lea    -0x1(%r8),%ecx
mov    $0xffffffff,%ebp
shl    %cl,%ebp
not    %ebp
mov    %esi,%eax
add    $0x1,%eax
shr    $0x1f,%eax
lea    (%r9,%rax,1),%r11d
add    $0x1,%r11d
sar    %r11d
add    $0x1,%r11d
lea    (%rdi,%r12,4),%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%r12,4),%rsi
lea    0x3(%r15),%rdx
lea    0x2(%r15),%rax
mov    %r15d,%ebx
sub    %r12d,%ebx
movslq %ebp,%r9
add    $0x1,%r8b
mov    %r8d,%ecx
shl    %cl,%r13d
movslq %r13d,%r10
mov    (%r14,%r9,4),%ecx
mov    %ecx,-0x70(%rsp)
neg    %rsi
mov    %rsi,0x20(%rsp)
mov    %rbx,%rcx
sub    %r12,%rcx
mov    %rdi,%rsi
mov    %r15,%rdi
lea    (%rsi,%rcx,4),%rcx
mov    %rcx,-0x48(%rsp)
lea    0x2(%rbx,%r15,1),%rcx
lea    (%rsi,%rcx,4),%rcx
mov    %rcx,-0x50(%rsp)
lea    0x3(%rbx,%r15,1),%rcx
lea    (%rsi,%rcx,4),%rcx
mov    %rcx,-0x58(%rsp)
lea    0x1(%r15),%ecx
mov    %rcx,-0x18(%rsp)
lea    0x4(%rsi,%rbx,4),%rcx
mov    %rcx,-0x60(%rsp)
mov    %r10,-0x8(%rsp)
lea    0x0(,%r10,4),%rcx
mov    %rcx,-0x10(%rsp)
mov    %rbx,(%rsp)
lea    (%rsi,%rbx,4),%rcx
mov    %rcx,-0x68(%rsp)
mov    %rbp,-0x38(%rsp)
mov    %r11d,-0x6c(%rsp)
mov    %rdx,-0x20(%rsp)
mov    %rax,-0x28(%rsp)
mov    %r15,-0x30(%rsp)
jmp    126c <bitrevR2+0x16c>
nopl   (%rax)
mov    -0x8(%rsp),%rcx
mov    -0x40(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
mov    -0x10(%rsp),%rcx
add    %rcx,-0x60(%rsp)
add    %rcx,-0x48(%rsp)
add    %rcx,-0x50(%rsp)
add    %rcx,-0x58(%rsp)
add    %rcx,-0x68(%rsp)
cmp    0x8(%rsp),%rsi
mov    -0x38(%rsp),%rbp
jae    158f <bitrevR2+0x48f>
mov    (%rsp),%rcx
mov    %rsi,-0x40(%rsp)
lea    (%rsi,%rcx,4),%r13
mov    %rbp,%rcx
mov    %r13,0x10(%rsp)
jmp    132e <bitrevR2+0x22e>
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%r13,1),%r9
add    $0x4,%r9
movaps %xmm14,%xmm6
shufps $0x55,%xmm14,%xmm6
mov    -0x80(%rsp),%rbx
mov    %edi,%r11d
mov    %rax,%rdi
mov    %r8,%rax
mov    %r12,%rdx
movss  0x8(%rsi),%xmm0
movss  0xc(%rsi),%xmm4
movss  (%rsi,%rax,4),%xmm5
movss  (%rsi,%rdx,4),%xmm8
movaps %xmm14,%xmm7
addss  %xmm1,%xmm7
movaps %xmm6,%xmm3
addss  %xmm2,%xmm3
subss  %xmm1,%xmm14
subss  %xmm2,%xmm6
movaps %xmm0,%xmm1
addss  %xmm5,%xmm1
movaps %xmm4,%xmm2
addss  %xmm8,%xmm2
subss  %xmm5,%xmm0
subss  %xmm8,%xmm4
movss  %xmm7,(%rsi)
movss  %xmm3,(%r9)
movss  %xmm14,0x8(%rsi)
movss  %xmm6,0xc(%rsi)
movss  %xmm1,(%r15)
movss  %xmm2,0x0(%rbp)
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm4,(%rsi,%rdx,4)
mov    %rbx,%rcx
add    $0xffffffffffffffff,%rcx
test   %ebx,%ebx
jle    1230 <bitrevR2+0x130>
mov    %rdx,%r12
mov    %rax,%r8
movslq (%r14,%rcx,4),%r10
mov    %r10,%rbx
mov    %rcx,%rdx
mov    %edx,%r9d
mov    %r11d,%ecx
shl    %cl,%r9d
shl    $0x4,%rbx
lea    (%rbx,%r13,1),%rsi
movsd  0x0(%r13,%rbx,1),%xmm14
lea    (%rsi,%rdi,4),%r15
movss  (%rsi,%rdi,4),%xmm1
mov    -0x18(%rsp),%rax
lea    (%rsi,%rax,4),%rbp
movss  (%rsi,%rax,4),%xmm2
mov    %rdx,-0x80(%rsp)
mov    %rdi,%rax
mov    %r11d,%edi
mov    -0x38(%rsp),%r11
cmp    %r11d,%edx
jge    1290 <bitrevR2+0x190>
shl    $0x2,%r10
movslq %r9d,%rsi
mov    -0x40(%rsp),%rdi
lea    (%rdi,%rsi,4),%rcx
unpcklps %xmm2,%xmm1
mov    %r10,0x18(%rsp)
lea    0x0(,%r10,4),%rdi
mov    -0x68(%rsp),%r12
mov    -0x58(%rsp),%r13
mov    %r11,%rsi
mov    %r15,-0x78(%rsp)
mov    -0x50(%rsp),%r10
mov    -0x48(%rsp),%r11
mov    -0x60(%rsp),%r9
mov    -0x70(%rsp),%ebx
movaps %xmm1,%xmm3
xchg   %ax,%ax
mov    %rbp,0x28(%rsp)
shl    $0x2,%ebx
movslq %ebx,%rbx
mov    %r14,%rbp
lea    (%rcx,%rbx,4),%r14
movss  0x8(%r12,%rdi,1),%xmm15
movss  0xc(%r12,%rdi,1),%xmm2
movss  (%r10,%rdi,1),%xmm8
movss  0x0(%r13,%rdi,1),%xmm9
movss  (%rcx,%rbx,4),%xmm1
movss  0x4(%rcx,%rbx,4),%xmm5
mov    -0x30(%rsp),%r8
movss  (%r14,%r8,4),%xmm10
mov    -0x18(%rsp),%r15
movss  (%r14,%r15,4),%xmm11
movss  0x8(%rcx,%rbx,4),%xmm6
movss  0xc(%rcx,%rbx,4),%xmm7
mov    -0x28(%rsp),%rax
movss  (%r14,%rax,4),%xmm12
mov    -0x20(%rsp),%rdx
movss  (%r14,%rdx,4),%xmm13
movaps %xmm14,%xmm0
addps  %xmm3,%xmm0
subps  %xmm3,%xmm14
movlhps %xmm14,%xmm0
movups %xmm0,(%rcx,%rbx,4)
movaps %xmm15,%xmm14
addss  %xmm8,%xmm14
movaps %xmm2,%xmm3
addss  %xmm9,%xmm3
subss  %xmm8,%xmm15
subss  %xmm9,%xmm2
movaps %xmm1,%xmm8
addss  %xmm10,%xmm8
movaps %xmm5,%xmm9
addss  %xmm11,%xmm9
subss  %xmm10,%xmm1
subss  %xmm11,%xmm5
movaps %xmm6,%xmm4
addss  %xmm12,%xmm4
movaps %xmm7,%xmm0
addss  %xmm13,%xmm0
subss  %xmm12,%xmm6
subss  %xmm13,%xmm7
movss  %xmm14,(%r14,%r8,4)
movss  %xmm3,(%r14,%r15,4)
movss  %xmm15,(%r14,%rax,4)
movss  %xmm2,(%r14,%rdx,4)
mov    %rbp,%r14
movss  %xmm8,(%r12,%rdi,1)
movss  %xmm9,0x4(%r12,%rdi,1)
movss  %xmm1,0x8(%r12,%rdi,1)
movss  %xmm5,0xc(%r12,%rdi,1)
mov    -0x78(%rsp),%rax
movss  %xmm4,(%rax)
mov    0x28(%rsp),%rax
movss  %xmm0,(%rax)
movss  %xmm6,(%r10,%rdi,1)
movss  %xmm7,0x0(%r13,%rdi,1)
add    $0xffffffff,%esi
lea    (%r11,%rdi,1),%rbp
mov    (%r14,%rsi,4),%ebx
movsd  (%r11,%rdi,1),%xmm14
lea    0x0(,%r8,4),%rax
add    %rbp,%rax
mov    %rax,-0x78(%rsp)
movss  0x0(%rbp,%r8,4),%xmm1
movss  0x0(%rbp,%r15,4),%xmm2
lea    0x0(%rbp,%r15,4),%rbp
movaps %xmm1,%xmm3
unpcklps %xmm2,%xmm3
mov    0x20(%rsp),%rax
add    %rax,%r9
add    %rax,%r11
add    %rax,%r10
add    %rax,%r13
add    %rax,%r12
cmp    -0x80(%rsp),%esi
jg     13d0 <bitrevR2+0x2d0>
movaps %xmm14,%xmm6
shufps $0x55,%xmm14,%xmm6
mov    0x18(%rsp),%rsi
lea    (%r9,%rsi,4),%r9
lea    (%r12,%rsi,4),%rsi
mov    -0x30(%rsp),%rdi
mov    -0x6c(%rsp),%r11d
mov    -0x20(%rsp),%rdx
mov    -0x28(%rsp),%rax
mov    0x10(%rsp),%r13
mov    -0x80(%rsp),%rbx
mov    -0x78(%rsp),%r15
jmp    12b2 <bitrevR2+0x1b2>
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @bitrevR2(float* %0, i32 %1, i32* nocapture %2) {
%4 = add nsw i32 %1, 3
%5 = sdiv i32 %4, 2
%6 = shl nuw i32 1, %5
%7 = shl nuw i32 1, %1
%8 = sdiv i32 %1, 2
%9 = add nsw i32 %8, -1
%10 = shl nsw i32 -1, %9
%11 = xor i32 %10, -1
%12 = add nsw i32 %1, 1
%13 = sdiv i32 %12, 2
%14 = add nsw i32 %13, 1
%15 = zext i32 %6 to i64
%16 = getelementptr inbounds float, float* %0, i64 %15
%17 = add nuw i32 %7, 3
%18 = add nuw i32 %7, 2
%19 = add nuw i32 %7, 1
%20 = sub i32 %7, %6
%21 = zext i32 %20 to i64
%22 = sext i32 %11 to i64
%23 = zext i32 %7 to i64
%24 = zext i32 %19 to i64
%25 = getelementptr inbounds i32, i32* %2, i64 %22
%26 = zext i32 %18 to i64
%27 = zext i32 %17 to i64
%28 = sub nsw i64 0, %15
%29 = add nsw i32 %8, 1
%30 = shl nuw i32 1, %29
%31 = sext i32 %30 to i64
%32 = zext i32 %11 to i64
%33 = load i32, i32* %25
br label %34
34: ; preds = %159, %3
%35 = phi float* [ %0, %3 ], [ %160, %159 ]
%36 = getelementptr inbounds float, float* %35, i64 %21
br label %37
37: ; preds = %34, %132
%38 = phi i64 [ %32, %34 ], [ %157, %132 ]
%39 = getelementptr inbounds i32, i32* %2, i64 %38
%40 = load i32, i32* %39
%41 = shl nsw i32 %40, 2
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %36, i64 %42
%44 = trunc i64 %38 to i32
%45 = shl i32 %44, %14
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %35, i64 %46
%48 = getelementptr inbounds float, float* %43, i64 1
%49 = bitcast float* %43 to <2 x float>*
%50 = load <2 x float>, <2 x float>* %49
%51 = getelementptr inbounds float, float* %43, i64 %23
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %43, i64 %24
%54 = load float, float* %53
%55 = icmp slt i32 %44, %11
%56 = extractelement <2 x float> %50, i64 0
%57 = extractelement <2 x float> %50, i64 1
br i1 %55, label %58, label %132
58: ; preds = %37
%59 = insertelement <2 x float> poison, float %52, i64 0
%60 = insertelement <2 x float> %59, float %54, i64 1
br label %61
61: ; preds = %58, %61
%62 = phi i32 [ %118, %61 ], [ %33, %58 ]
%63 = phi float* [ %124, %61 ], [ %53, %58 ]
%64 = phi float* [ %122, %61 ], [ %51, %58 ]
%65 = phi float* [ %119, %61 ], [ %48, %58 ]
%66 = phi i32 [ %115, %61 ], [ %11, %58 ]
%67 = phi float* [ %114, %61 ], [ %43, %58 ]
%68 = phi <2 x float> [ %121, %61 ], [ %50, %58 ]
%69 = phi <2 x float> [ %128, %61 ], [ %60, %58 ]
%70 = shufflevector <2 x float> %69, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%71 = shufflevector <2 x float> %68, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%72 = shl nsw i32 %62, 2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %47, i64 %73
%75 = getelementptr inbounds float, float* %67, i64 2
%76 = load float, float* %75
%77 = getelementptr inbounds float, float* %67, i64 3
%78 = load float, float* %77
%79 = getelementptr inbounds float, float* %67, i64 %26
%80 = load float, float* %79
%81 = getelementptr inbounds float, float* %67, i64 %27
%82 = load float, float* %81
%83 = load float, float* %74
%84 = getelementptr inbounds float, float* %74, i64 1
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %74, i64 %23
%87 = load float, float* %86
%88 = getelementptr inbounds float, float* %74, i64 %24
%89 = load float, float* %88
%90 = getelementptr inbounds float, float* %74, i64 2
%91 = load float, float* %90
%92 = getelementptr inbounds float, float* %74, i64 3
%93 = load float, float* %92
%94 = getelementptr inbounds float, float* %74, i64 %26
%95 = load float, float* %94
%96 = getelementptr inbounds float, float* %74, i64 %27
%97 = load float, float* %96
%98 = fadd <4 x float> %71, %70
%99 = fsub <4 x float> %71, %70
%100 = shufflevector <4 x float> %98, <4 x float> %99, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
%101 = fadd float %76, %80
%102 = fadd float %78, %82
%103 = fsub float %76, %80
%104 = fsub float %78, %82
%105 = fadd float %83, %87
%106 = fadd float %85, %89
%107 = fsub float %83, %87
%108 = fsub float %85, %89
%109 = fadd float %91, %95
%110 = fadd float %93, %97
%111 = fsub float %91, %95
%112 = fsub float %93, %97
%113 = bitcast float* %74 to <4 x float>*
store <4 x float> %100, <4 x float>* %113
store float %101, float* %86
store float %102, float* %88
store float %103, float* %94
store float %104, float* %96
store float %105, float* %67
store float %106, float* %65
store float %107, float* %75
store float %108, float* %77
store float %109, float* %64
store float %110, float* %63
store float %111, float* %79
store float %112, float* %81
%114 = getelementptr inbounds float, float* %67, i64 %28
%115 = add nsw i32 %66, -1
%116 = zext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %2, i64 %116
%118 = load i32, i32* %117
%119 = getelementptr inbounds float, float* %114, i64 1
%120 = bitcast float* %114 to <2 x float>*
%121 = load <2 x float>, <2 x float>* %120
%122 = getelementptr inbounds float, float* %114, i64 %23
%123 = load float, float* %122
%124 = getelementptr inbounds float, float* %114, i64 %24
%125 = load float, float* %124
%126 = icmp sgt i32 %115, %44
%127 = insertelement <2 x float> poison, float %123, i64 0
%128 = insertelement <2 x float> %127, float %125, i64 1
br i1 %126, label %61, label %129
129: ; preds = %61
%130 = extractelement <2 x float> %121, i64 1
%131 = extractelement <2 x float> %121, i64 0
br label %132
132: ; preds = %129, %37
%133 = phi float* [ %43, %37 ], [ %114, %129 ]
%134 = phi float [ %56, %37 ], [ %131, %129 ]
%135 = phi float* [ %48, %37 ], [ %119, %129 ]
%136 = phi float [ %57, %37 ], [ %130, %129 ]
%137 = phi float* [ %51, %37 ], [ %122, %129 ]
%138 = phi float [ %52, %37 ], [ %123, %129 ]
%139 = phi float* [ %53, %37 ], [ %124, %129 ]
%140 = phi float [ %54, %37 ], [ %125, %129 ]
%141 = getelementptr inbounds float, float* %133, i64 2
%142 = load float, float* %141
%143 = getelementptr inbounds float, float* %133, i64 3
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %133, i64 %26
%146 = load float, float* %145
%147 = getelementptr inbounds float, float* %133, i64 %27
%148 = load float, float* %147
%149 = fadd float %134, %138
%150 = fadd float %136, %140
%151 = fsub float %134, %138
%152 = fsub float %136, %140
%153 = fadd float %142, %146
%154 = fadd float %144, %148
%155 = fsub float %142, %146
%156 = fsub float %144, %148
store float %149, float* %133
store float %150, float* %135
store float %151, float* %141
store float %152, float* %143
store float %153, float* %137
store float %154, float* %139
store float %155, float* %145
store float %156, float* %147
%157 = add nsw i64 %38, -1
%158 = icmp sgt i32 %44, 0
br i1 %158, label %37, label %159
159: ; preds = %132
%160 = getelementptr inbounds float, float* %35, i64 %31
%161 = icmp ult float* %160, %16
br i1 %161, label %34, label %162
162: ; preds = %159
ret void
}