void bitrevR2(float *ioptr, int M, short *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 = ((unsigned long)1 << ((M + 3) / 2));
  const unsigned int Nroot_1_ColInc = ((unsigned long)1 << (M)) - Nrems2;
  const unsigned int Nroot_1 = ((unsigned long)1 << (M / 2 - 1)) - 1;
  const unsigned int ColstartShift = (M + 1) / 2 + 1;
  posA = ((unsigned long)1 << (M));
  posAi = posA + 1;
  posB = posA + 2;
  posBi = posB + 1;
  iolimit = ioptr + Nrems2;
  for (; ioptr < iolimit; ioptr += ((unsigned long)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,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %eax,-0xa4(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xa4(%rbp),%ecx
sub    %rcx,%rax
mov    %eax,-0xa8(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
sub    $0x1,%rax
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),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
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    17cd <bitrevR2+0x6cd>
mov    -0xac(%rbp),%eax
mov    %eax,-0x8c(%rbp)
cmpl   $0x0,-0x8c(%rbp)
jl     179d <bitrevR2+0x69d>
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
movswl (%rcx,%rdx,2),%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
movswl (%rcx,%rdx,2),%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    1646 <bitrevR2+0x546>
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
movswl (%rcx,%rdx,2),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    12d2 <bitrevR2+0x1d2>
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    11ff <bitrevR2+0xff>
jmp    17a2 <bitrevR2+0x6a2>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
shl    $0x2,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    11e2 <bitrevR2+0xe2>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrevR2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %esi,%r8d
mov    %rdi,-0x78(%rsp)
lea    0x3(%r8),%eax
shr    $0x1f,%eax
add    %r8d,%eax
add    $0x3,%eax
sar    %eax
mov    $0x1,%r13d
mov    %eax,%ecx
shl    %cl,%r13
mov    $0x1,%esi
mov    %r8d,%ecx
shl    %cl,%rsi
mov    %r8d,%ebx
shr    $0x1f,%ebx
add    %r8d,%ebx
sar    %ebx
lea    -0x1(%rbx),%ecx
mov    $0xffffffffffffffff,%rdi
shl    %cl,%rdi
mov    %rdi,-0x60(%rsp)
cmp    $0x1f,%eax
jbe    116c <bitrevR2+0x6c>
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13d,%r9d
mov    -0x60(%rsp),%r11
mov    %r11d,%r10d
not    %r10d
mov    %r8d,%eax
add    $0x1,%eax
shr    $0x1f,%eax
add    %r8d,%eax
add    $0x1,%eax
sar    %eax
add    $0x1,%eax
mov    %eax,-0x64(%rsp)
mov    -0x78(%rsp),%rdi
lea    (%rdi,%r9,4),%rax
mov    %rax,0x18(%rsp)
lea    0x3(%rsi),%r15d
lea    0x2(%rsi),%r14d
lea    0x1(%rsi),%ebp
mov    %esi,%r12d
sub    %r13d,%esi
add    $0x1,%bl
mov    %ebx,%ecx
mov    $0x1,%ebx
shl    %cl,%rbx
movslq %r10d,%r13
mov    %r13d,%ecx
mov    %rcx,(%rsp)
lea    (%rdi,%rsi,4),%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rsp)
mov    %rbx,0x20(%rsp)
lea    0x0(,%rbx,4),%rcx
mov    %rcx,0x10(%rsp)
lea    0x0(,%r9,4),%r10
neg    %r10
mov    $0xfffffffe,%ecx
sub    %r11d,%ecx
movslq %ecx,%rcx
mov    %rcx,0x28(%rsp)
mov    %rsi,%rcx
sub    %r9,%rcx
mov    %rbp,%r9
lea    (%rdi,%rcx,4),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rsi,%r14,1),%rcx
lea    (%rdi,%rcx,4),%rcx
mov    %rcx,-0x48(%rsp)
lea    (%rsi,%r15,1),%rcx
lea    (%rdi,%rcx,4),%rcx
mov    %rcx,-0x50(%rsp)
mov    %rsi,0x8(%rsp)
lea    (%rdi,%rsi,4),%rcx
mov    %rcx,-0x58(%rsp)
mov    %r13,0x30(%rsp)
mov    %r14,-0x10(%rsp)
mov    %rdx,-0x18(%rsp)
mov    %r15,-0x20(%rsp)
mov    %r12,-0x28(%rsp)
mov    %rbp,-0x30(%rsp)
jmp    129c <bitrevR2+0x19c>
nopl   0x0(%rax)
mov    -0x78(%rsp),%rcx
mov    0x20(%rsp),%rsi
lea    (%rcx,%rsi,4),%rcx
mov    0x10(%rsp),%rsi
add    %rsi,-0x38(%rsp)
add    %rsi,-0x40(%rsp)
add    %rsi,-0x48(%rsp)
add    %rsi,-0x50(%rsp)
add    %rsi,-0x58(%rsp)
mov    %rcx,-0x78(%rsp)
cmp    0x18(%rsp),%rcx
jae    115d <bitrevR2+0x5d>
cmpl   $0x0,-0x60(%rsp)
jns    1260 <bitrevR2+0x160>
mov    -0x78(%rsp),%rcx
mov    0x8(%rsp),%rsi
lea    (%rcx,%rsi,4),%rax
movzwl (%rdx,%r13,2),%ecx
mov    %cx,-0x7a(%rsp)
mov    (%rsp),%rbp
mov    %rax,0x38(%rsp)
jmp    135f <bitrevR2+0x25f>
nopl   0x0(%rax)
lea    (%rax,%rsi,1),%rdi
add    $0x4,%rdi
movaps %xmm14,%xmm6
shufps $0x55,%xmm14,%xmm6
movss  0x8(%rbx),%xmm0
movss  0xc(%rbx),%xmm4
movss  (%rbx,%r14,4),%xmm5
movss  (%rbx,%r15,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,(%rbx)
movss  %xmm3,(%rdi)
movss  %xmm14,0x8(%rbx)
movss  %xmm6,0xc(%rbx)
movss  %xmm1,(%r11)
movss  %xmm2,(%rcx)
movss  %xmm0,(%rbx,%r14,4)
movss  %xmm4,(%rbx,%r15,4)
lea    -0x1(%rbp),%rcx
test   %rbp,%rbp
mov    %rcx,%rbp
jle    1260 <bitrevR2+0x160>
movswq (%rdx,%rbp,2),%r8
mov    %r8,%rsi
mov    %ebp,%edi
mov    -0x64(%rsp),%ecx
shl    %cl,%edi
shl    $0x4,%rsi
lea    (%rax,%rsi,1),%rbx
movsd  (%rax,%rsi,1),%xmm14
lea    (%rbx,%r12,4),%r11
movss  (%rbx,%r12,4),%xmm1
lea    (%rbx,%r9,4),%rcx
movss  (%rbx,%r9,4),%xmm2
cmp    %r13,%rbp
jge    12d0 <bitrevR2+0x1d0>
shl    $0x2,%r8
movslq %edi,%rsi
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rsi,4),%rax
unpcklps %xmm2,%xmm1
mov    %r8,0x40(%rsp)
lea    0x0(,%r8,4),%r8
mov    %rbp,-0x8(%rsp)
mov    -0x58(%rsp),%r9
mov    -0x50(%rsp),%r15
mov    -0x48(%rsp),%r14
mov    -0x40(%rsp),%rdi
mov    0x28(%rsp),%rdx
mov    %r11,-0x70(%rsp)
mov    -0x38(%rsp),%r12
movzwl -0x7a(%rsp),%ebx
movaps %xmm1,%xmm3
nopw   0x0(%rax,%rax,1)
mov    %rcx,0x48(%rsp)
movswl %bx,%esi
shl    $0x2,%esi
movslq %esi,%rsi
lea    (%rax,%rsi,4),%rbx
movss  0x8(%r9,%r8,1),%xmm15
movss  0xc(%r9,%r8,1),%xmm2
movss  (%r14,%r8,1),%xmm8
movss  (%r15,%r8,1),%xmm9
movss  (%rax,%rsi,4),%xmm1
movss  0x4(%rax,%rsi,4),%xmm5
mov    -0x28(%rsp),%r11
movss  (%rbx,%r11,4),%xmm10
mov    -0x30(%rsp),%r13
movss  (%rbx,%r13,4),%xmm11
movss  0x8(%rax,%rsi,4),%xmm6
movss  0xc(%rax,%rsi,4),%xmm7
mov    %r10,%rcx
mov    -0x10(%rsp),%r10
movss  (%rbx,%r10,4),%xmm12
mov    -0x20(%rsp),%rbp
movss  (%rbx,%rbp,4),%xmm13
movaps %xmm14,%xmm0
addps  %xmm3,%xmm0
subps  %xmm3,%xmm14
movlhps %xmm14,%xmm0
movups %xmm0,(%rax,%rsi,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,(%rbx,%r11,4)
movss  %xmm3,(%rbx,%r13,4)
movss  %xmm15,(%rbx,%r10,4)
mov    %rcx,%r10
movss  %xmm2,(%rbx,%rbp,4)
movss  %xmm8,(%r9,%r8,1)
movss  %xmm9,0x4(%r9,%r8,1)
movss  %xmm1,0x8(%r9,%r8,1)
movss  %xmm5,0xc(%r9,%r8,1)
mov    -0x70(%rsp),%rcx
movss  %xmm4,(%rcx)
mov    0x48(%rsp),%rcx
movss  %xmm0,(%rcx)
movss  %xmm6,(%r14,%r8,1)
movss  %xmm7,(%r15,%r8,1)
lea    (%rdi,%r8,1),%rsi
mov    %edx,%ecx
mov    -0x18(%rsp),%rbx
movzwl (%rbx,%rcx,2),%ebx
movsd  (%rdi,%r8,1),%xmm14
lea    (%rsi,%r11,4),%rcx
mov    %rcx,-0x70(%rsp)
movss  (%rsi,%r11,4),%xmm1
movss  (%rsi,%r13,4),%xmm2
lea    (%rsi,%r13,4),%rcx
movaps %xmm1,%xmm3
unpcklps %xmm2,%xmm3
add    %r10,%r12
add    %r10,%rdi
add    %r10,%r14
add    %r10,%r15
add    %r10,%r9
cmp    %rdx,-0x8(%rsp)
lea    -0x1(%rdx),%rdx
jl     13f0 <bitrevR2+0x2f0>
movaps %xmm14,%xmm6
shufps $0x55,%xmm14,%xmm6
mov    0x40(%rsp),%rdx
lea    (%r12,%rdx,4),%rdi
lea    (%r9,%rdx,4),%rbx
mov    -0x18(%rsp),%rdx
mov    -0x20(%rsp),%r15
mov    -0x10(%rsp),%r14
mov    -0x30(%rsp),%r9
mov    -0x28(%rsp),%r12
mov    0x30(%rsp),%r13
mov    0x38(%rsp),%rax
mov    -0x8(%rsp),%rbp
mov    -0x70(%rsp),%r11
jmp    12e1 <bitrevR2+0x1e1>

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

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