void scbitrevR2(float *ioptr, int M, short *BRLow, float scale) {
  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) = scale * t0r;
        *(p1r + 1) = scale * t0i;
        *(p1r + 2) = scale * f1r;
        *(p1r + (2 + 1)) = scale * f1i;
        *(p1r + posA) = scale * t1r;
        *(p1r + posAi) = scale * t1i;
        *(p1r + posB) = scale * f3r;
        *(p1r + posBi) = scale * f3i;
        *(p0r) = scale * f0r;
        *(p0r + 1) = scale * f0i;
        *(p0r + 2) = scale * f5r;
        *(p0r + (2 + 1)) = scale * f5i;
        *(p0r + posA) = scale * f2r;
        *(p0r + posAi) = scale * f2i;
        *(p0r + posB) = scale * f7r;
        *(p0r + posBi) = scale * 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) = scale * t0r;
      *(p0r + 1) = scale * t0i;
      *(p0r + 2) = scale * f1r;
      *(p0r + (2 + 1)) = scale * f1i;
      *(p0r + posA) = scale * t1r;
      *(p0r + posAi) = scale * t1i;
      *(p0r + posB) = scale * f3r;
      *(p0r + posBi) = scale * f3i;
    };
  };
}


x86 assembly (clang, -O0):
<scbitrevR2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%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,-0xac(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xac(%rbp),%ecx
sub    %rcx,%rax
mov    %eax,-0xb0(%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,-0xb4(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xac(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x90(%rbp),%rax
jae    1853 <scbitrevR2+0x753>
mov    -0xb4(%rbp),%eax
mov    %eax,-0x94(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     1823 <scbitrevR2+0x723>
mov    -0xb4(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xb0(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%edx
mov    -0xb8(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x98(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jle    16a4 <scbitrevR2+0x5a4>
mov    -0x78(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x78(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x80(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x80(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x80(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x80(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x98(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x98(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
jmp    12dd <scbitrevR2+0x1dd>
mov    -0x78(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x78(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    1204 <scbitrevR2+0x104>
jmp    1828 <scbitrevR2+0x728>
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    11e7 <scbitrevR2+0xe7>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scbitrevR2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %esi,%r8d
mov    %rdi,-0x70(%rsp)
lea    0x3(%r8),%eax
shr    $0x1f,%eax
add    %r8d,%eax
add    $0x3,%eax
sar    %eax
mov    $0x1,%edi
mov    %eax,%ecx
shl    %cl,%rdi
mov    $0x1,%esi
mov    %r8d,%ecx
shl    %cl,%rsi
mov    %r8d,%r14d
shr    $0x1f,%r14d
add    %r8d,%r14d
sar    %r14d
lea    -0x1(%r14),%ecx
mov    $0xffffffffffffffff,%rbp
shl    %cl,%rbp
mov    %rbp,-0x58(%rsp)
cmp    $0x1f,%eax
jbe    116e <scbitrevR2+0x6e>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edi,%r9d
mov    -0x58(%rsp),%r11
mov    %r11d,%ecx
not    %ecx
mov    %r8d,%eax
add    $0x1,%eax
shr    $0x1f,%eax
lea    (%r8,%rax,1),%ebp
add    $0x1,%ebp
sar    %ebp
add    $0x1,%ebp
mov    -0x70(%rsp),%rbx
lea    (%rbx,%r9,4),%rax
mov    %rax,0x20(%rsp)
lea    0x3(%rsi),%r15d
lea    0x2(%rsi),%r13d
lea    0x1(%rsi),%eax
mov    %rax,(%rsp)
mov    %esi,%r12d
sub    %edi,%esi
movslq %ecx,%rax
add    $0x1,%r14b
mov    %r14d,%ecx
mov    $0x1,%edi
shl    %cl,%rdi
mov    %rax,%rcx
mov    %rax,-0x28(%rsp)
mov    %eax,%ecx
mov    %rcx,0x8(%rsp)
movaps %xmm0,%xmm14
shufps $0x0,%xmm0,%xmm14
lea    0x4(%rbx,%rsi,4),%rcx
mov    %rcx,-0x30(%rsp)
mov    %rdi,0x28(%rsp)
lea    0x0(,%rdi,4),%rcx
mov    %rcx,0x18(%rsp)
lea    0x0(,%r9,4),%rax
neg    %rax
mov    $0xfffffffe,%ecx
sub    %r11d,%ecx
movslq %ecx,%rcx
mov    %rcx,0x30(%rsp)
mov    %rsi,%rcx
sub    %r9,%rcx
lea    (%rbx,%rcx,4),%rcx
mov    %rcx,-0x38(%rsp)
lea    (%rsi,%r13,1),%rcx
lea    (%rbx,%rcx,4),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rsi,%r15,1),%rcx
lea    (%rbx,%rcx,4),%rcx
mov    %rcx,-0x48(%rsp)
mov    %rsi,0x10(%rsp)
lea    (%rbx,%rsi,4),%rcx
mov    %rcx,-0x50(%rsp)
mov    %ebp,-0x5c(%rsp)
movaps %xmm0,0x50(%rsp)
mov    %rdx,-0x10(%rsp)
mov    %r15,-0x18(%rsp)
mov    %r13,-0x20(%rsp)
jmp    12ac <scbitrevR2+0x1ac>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x70(%rsp),%rcx
mov    0x28(%rsp),%rsi
lea    (%rcx,%rsi,4),%rcx
mov    0x18(%rsp),%rsi
add    %rsi,-0x30(%rsp)
add    %rsi,-0x38(%rsp)
add    %rsi,-0x40(%rsp)
add    %rsi,-0x48(%rsp)
add    %rsi,-0x50(%rsp)
mov    %rcx,-0x70(%rsp)
cmp    0x20(%rsp),%rcx
jae    115f <scbitrevR2+0x5f>
cmpl   $0x0,-0x58(%rsp)
jns    1270 <scbitrevR2+0x170>
mov    -0x70(%rsp),%rcx
mov    0x10(%rsp),%rsi
lea    (%rcx,%rsi,4),%r9
mov    -0x28(%rsp),%rcx
movzwl (%rdx,%rcx,2),%ecx
mov    %cx,-0x72(%rsp)
mov    0x8(%rsp),%r11
mov    %r9,0x38(%rsp)
jmp    1399 <scbitrevR2+0x299>
xchg   %ax,%ax
mov    %r14d,%ebp
lea    (%r9,%rsi,1),%rdi
add    $0x4,%rdi
movaps %xmm9,%xmm6
shufps $0x55,%xmm9,%xmm6
movss  0x8(%rbx),%xmm2
movss  0xc(%rbx),%xmm1
movss  (%rbx,%r13,4),%xmm10
movss  (%rbx,%r15,4),%xmm8
movaps %xmm9,%xmm7
addss  %xmm3,%xmm7
movaps %xmm6,%xmm5
addss  %xmm4,%xmm5
subss  %xmm3,%xmm9
subss  %xmm4,%xmm6
movaps %xmm2,%xmm3
addss  %xmm10,%xmm3
movaps %xmm1,%xmm4
addss  %xmm8,%xmm4
subss  %xmm10,%xmm2
subss  %xmm8,%xmm1
mulss  %xmm0,%xmm7
movss  %xmm7,(%rbx)
mulss  %xmm0,%xmm5
movss  %xmm5,(%rdi)
mulss  %xmm0,%xmm9
movss  %xmm9,0x8(%rbx)
mulss  %xmm0,%xmm6
movss  %xmm6,0xc(%rbx)
mulss  %xmm0,%xmm3
movss  %xmm3,(%rcx)
mulss  %xmm0,%xmm4
mov    -0x68(%rsp),%rcx
movss  %xmm4,(%rcx)
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%r13,4)
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%r15,4)
lea    -0x1(%r11),%rcx
test   %r11,%r11
mov    %rcx,%r11
jle    1270 <scbitrevR2+0x170>
movswq (%rdx,%r11,2),%r8
mov    %r8,%rsi
mov    %r11d,%r10d
mov    %ebp,%ecx
shl    %cl,%r10d
shl    $0x4,%rsi
lea    (%r9,%rsi,1),%rbx
movsd  (%r9,%rsi,1),%xmm9
mov    %ebp,%r14d
mov    %r12,%rdi
lea    (%rbx,%r12,4),%rcx
movss  (%rbx,%r12,4),%xmm3
mov    (%rsp),%rbp
lea    (%rbx,%rbp,4),%rdi
mov    %rdi,-0x68(%rsp)
movss  (%rbx,%rbp,4),%xmm4
mov    -0x28(%rsp),%rdi
cmp    %rdi,%r11
jge    12e0 <scbitrevR2+0x1e0>
shl    $0x2,%r8
movslq %r10d,%rsi
mov    -0x70(%rsp),%rdi
mov    %r11,-0x8(%rsp)
lea    (%rdi,%rsi,4),%r11
unpcklps %xmm4,%xmm3
mov    %r8,0x40(%rsp)
lea    0x0(,%r8,4),%r9
mov    -0x50(%rsp),%r8
mov    -0x48(%rsp),%r15
mov    -0x40(%rsp),%r13
mov    -0x38(%rsp),%rdi
mov    0x30(%rsp),%rdx
mov    -0x30(%rsp),%r14
movzwl -0x72(%rsp),%ebx
movaps %xmm3,%xmm7
mov    %rcx,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,0x48(%rsp)
movswl %bx,%esi
shl    $0x2,%esi
movslq %esi,%rsi
lea    (%r11,%rsi,4),%rbx
movss  0x8(%r8,%r9,1),%xmm2
movss  0xc(%r8,%r9,1),%xmm1
movss  0x0(%r13,%r9,1),%xmm10
movss  (%r15,%r9,1),%xmm11
movss  (%r11,%rsi,4),%xmm6
movss  0x4(%r11,%rsi,4),%xmm5
mov    %r12,%r10
movss  (%rbx,%r12,4),%xmm12
mov    (%rsp),%rbp
movss  (%rbx,%rbp,4),%xmm13
movss  0x8(%r11,%rsi,4),%xmm4
movss  0xc(%r11,%rsi,4),%xmm15
movaps %xmm14,%xmm0
mov    -0x20(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm14
movaps %xmm9,%xmm3
addps  %xmm7,%xmm3
subps  %xmm7,%xmm9
mov    %rax,%r12
mov    -0x18(%rsp),%rax
movss  (%rbx,%rax,4),%xmm8
movlhps %xmm9,%xmm3
movaps %xmm2,%xmm7
addss  %xmm10,%xmm7
subss  %xmm10,%xmm2
movaps %xmm1,%xmm10
addss  %xmm11,%xmm10
subss  %xmm11,%xmm1
movaps %xmm6,%xmm11
addss  %xmm12,%xmm11
subss  %xmm12,%xmm6
movaps %xmm5,%xmm12
addss  %xmm13,%xmm12
subss  %xmm13,%xmm5
movaps %xmm4,%xmm9
addss  %xmm14,%xmm9
subss  %xmm14,%xmm4
movaps %xmm0,%xmm14
movaps 0x50(%rsp),%xmm0
movaps %xmm15,%xmm13
addss  %xmm8,%xmm13
subss  %xmm8,%xmm15
mulps  %xmm14,%xmm3
movups %xmm3,(%r11,%rsi,4)
mulss  %xmm0,%xmm7
movss  %xmm7,(%rbx,%r10,4)
mulss  %xmm0,%xmm10
movss  %xmm10,(%rbx,%rbp,4)
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
mov    %r12,%rax
mulss  %xmm0,%xmm11
movss  %xmm11,(%r8,%r9,1)
mulss  %xmm0,%xmm12
movss  %xmm12,0x4(%r8,%r9,1)
mulss  %xmm0,%xmm6
movss  %xmm6,0x8(%r8,%r9,1)
mulss  %xmm0,%xmm5
movss  %xmm5,0xc(%r8,%r9,1)
mulss  %xmm0,%xmm9
mov    0x48(%rsp),%rcx
movss  %xmm9,(%rcx)
mulss  %xmm0,%xmm13
mov    -0x68(%rsp),%rcx
movss  %xmm13,(%rcx)
mulss  %xmm0,%xmm4
movss  %xmm4,0x0(%r13,%r9,1)
mulss  %xmm0,%xmm15
movss  %xmm15,(%r15,%r9,1)
lea    (%rdi,%r9,1),%rcx
mov    %edx,%esi
mov    -0x10(%rsp),%rbx
movzwl (%rbx,%rsi,2),%ebx
movsd  (%rdi,%r9,1),%xmm9
lea    (%rcx,%r10,4),%rsi
mov    %r10,%r12
movss  (%rcx,%r10,4),%xmm3
movss  (%rcx,%rbp,4),%xmm4
lea    (%rcx,%rbp,4),%rcx
mov    %rcx,-0x68(%rsp)
movaps %xmm3,%xmm7
unpcklps %xmm4,%xmm7
add    %rax,%r14
add    %rax,%rdi
add    %rax,%r13
add    %rax,%r15
add    %rax,%r8
cmp    %rdx,-0x8(%rsp)
lea    -0x1(%rdx),%rdx
jl     1440 <scbitrevR2+0x340>
movaps %xmm9,%xmm6
shufps $0x55,%xmm9,%xmm6
mov    0x40(%rsp),%rdx
lea    (%r14,%rdx,4),%rdi
lea    (%r8,%rdx,4),%rbx
mov    -0x10(%rsp),%rdx
mov    -0x5c(%rsp),%ebp
mov    -0x18(%rsp),%r15
mov    -0x20(%rsp),%r13
mov    0x38(%rsp),%r9
mov    -0x8(%rsp),%r11
mov    %rsi,%rcx
jmp    12f4 <scbitrevR2+0x1f4>

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

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