void scbitrevR2(float *ioptr, long 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;
  long Colstart;
  long iCol;
  unsigned long posA;
  unsigned long posAi;
  unsigned long posB;
  unsigned long posBi;
  const unsigned long Nrems2 = ((unsigned long)1 << ((M + 3) / 2));
  const unsigned long Nroot_1_ColInc = ((unsigned long)1 << (M)) - Nrems2;
  const unsigned long Nroot_1 = ((unsigned long)1 << (M / 2 - 1)) - 1;
  const unsigned long 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    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x10(%rbp),%rcx
mov    $0x1,%eax
shl    %cl,%rax
sub    -0xc8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
sub    $0x1,%rcx
mov    $0x1,%eax
shl    %cl,%rax
sub    $0x1,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
add    $0x1,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x10(%rbp),%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x90(%rbp),%rax
jae    1891 <scbitrevR2+0x791>
mov    -0xd8(%rbp),%rax
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
jl     185e <scbitrevR2+0x75e>
mov    -0xd8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
mov    -0x98(%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    -0x98(%rbp),%rdx
mov    -0xe0(%rbp),%rcx
shl    %cl,%rdx
mov    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0xa0(%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    -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0xa0(%rbp),%rax
cmp    -0x98(%rbp),%rax
jle    16d6 <scbitrevR2+0x5d6>
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    -0xb8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xc0(%rbp),%rcx
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    -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xb0(%rbp),%rcx
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    -0xb8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xc0(%rbp),%rcx
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    -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0xc0(%rbp),%rcx
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    -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc8(%rbp),%rdx
mov    -0x78(%rbp),%rax
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    -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0xa0(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0xa0(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
jmp    12fd <scbitrevR2+0x1fd>
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    -0xb8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xc0(%rbp),%rcx
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    -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x98(%rbp)
jmp    121d <scbitrevR2+0x11d>
jmp    1863 <scbitrevR2+0x763>
mov    -0x10(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
add    $0x1,%rcx
mov    $0x1,%eax
shl    %cl,%rax
shl    $0x2,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    11fe <scbitrevR2+0xfe>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scbitrevR2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r9
lea    0x3(%rsi),%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
add    %eax,%ecx
shr    %ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    $0x1,%esi
mov    %r9d,%ecx
shl    %cl,%rsi
mov    %r9,%r8
shr    $0x3f,%r8
add    %r9,%r8
sar    %r8
lea    -0x1(%r8),%ecx
mov    $0xffffffffffffffff,%r15
shl    %cl,%r15
lea    -0x7b(%r9),%rcx
cmp    $0x2,%rcx
jae    115f <scbitrevR2+0x5f>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rsi,%rbx
sub    %rax,%rbx
not    %r15
lea    0x1(%r9),%rcx
shr    $0x3f,%rcx
lea    (%r9,%rcx,1),%r12
add    $0x1,%r12
sar    %r12
add    $0x1,%r12
add    $0x1,%r8b
mov    %r8d,%ecx
mov    $0x1,%ebp
shl    %cl,%rbp
lea    0x1(%rsi),%rcx
mov    %rcx,-0x20(%rsp)
lea    (%rdi,%rax,4),%rcx
mov    %rcx,-0x38(%rsp)
movzwl (%rdx,%r15,2),%ecx
mov    %cx,-0x62(%rsp)
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
mov    %rbx,-0x30(%rsp)
lea    (%rdi,%rbx,4),%rcx
mov    %rcx,-0x48(%rsp)
lea    (%rsi,%rsi,1),%rcx
lea    (%rax,%rax,1),%r9
mov    %rcx,%r8
sub    %r9,%r8
mov    %rsi,%rbx
sub    %r9,%rbx
mov    %rbp,-0x28(%rsp)
lea    0x0(,%rbp,4),%rbp
mov    %rbp,-0x40(%rsp)
sub    %rax,%rcx
lea    0x0(,%rax,4),%rbp
neg    %rbp
lea    (%rdi,%r8,4),%rax
mov    %rax,-0x50(%rsp)
lea    (%rdi,%rcx,4),%rax
mov    %rax,-0x58(%rsp)
lea    (%rdi,%rbx,4),%rax
mov    %rax,-0x60(%rsp)
mov    %r15,-0x10(%rsp)
mov    %r12,-0x18(%rsp)
jmp    124d <scbitrevR2+0x14d>
nopl   0x0(%rax)
mov    -0x28(%rsp),%rax
lea    (%rdi,%rax,4),%rdi
mov    -0x40(%rsp),%rax
add    %rax,-0x48(%rsp)
add    %rax,-0x50(%rsp)
add    %rax,-0x58(%rsp)
add    %rax,-0x60(%rsp)
cmp    -0x38(%rsp),%rdi
jae    1154 <scbitrevR2+0x54>
mov    -0x30(%rsp),%rax
lea    (%rdi,%rax,4),%r10
movzwl -0x62(%rsp),%ecx
mov    %r15,%r14
mov    %rdi,-0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movswl %cx,%eax
shl    $0x2,%eax
movslq %eax,%r8
mov    %r14,%rax
mov    %r12d,%ecx
shl    %cl,%rax
lea    (%r10,%r8,4),%rbx
movsd  (%r10,%r8,4),%xmm14
movsd  (%rbx,%rsi,4),%xmm9
cmp    %r15,%r14
jge    1440 <scbitrevR2+0x340>
lea    (%rdi,%rax,4),%r12
mov    -0x60(%rsp),%r11
mov    -0x58(%rsp),%rcx
mov    -0x50(%rsp),%rdi
mov    -0x48(%rsp),%r13
movzwl -0x62(%rsp),%ebx
nopl   0x0(%rax,%rax,1)
movswl %bx,%eax
shl    $0x2,%eax
movslq %eax,%r9
lea    (%r12,%r9,4),%rbx
movsd  0x8(%r13,%r8,4),%xmm3
movsd  0x8(%rcx,%r8,4),%xmm15
movss  (%r12,%r9,4),%xmm7
movss  0x4(%r12,%r9,4),%xmm6
movss  (%rbx,%rsi,4),%xmm10
movss  0x4(%rbx,%rsi,4),%xmm11
movss  0x8(%r12,%r9,4),%xmm5
movss  0xc(%r12,%r9,4),%xmm4
movss  0x8(%rbx,%rsi,4),%xmm12
movss  0xc(%rbx,%rsi,4),%xmm13
movaps %xmm14,%xmm2
addps  %xmm9,%xmm2
subps  %xmm9,%xmm14
movlhps %xmm14,%xmm2
movaps %xmm3,%xmm1
addps  %xmm15,%xmm1
subps  %xmm15,%xmm3
movlhps %xmm3,%xmm1
movaps %xmm7,%xmm3
addss  %xmm10,%xmm3
movaps %xmm6,%xmm9
addss  %xmm11,%xmm9
subss  %xmm10,%xmm7
subss  %xmm11,%xmm6
movaps %xmm5,%xmm10
addss  %xmm12,%xmm10
movaps %xmm4,%xmm11
addss  %xmm13,%xmm11
subss  %xmm12,%xmm5
subss  %xmm13,%xmm4
mulps  %xmm8,%xmm2
movups %xmm2,(%r12,%r9,4)
mulps  %xmm8,%xmm1
movups %xmm1,(%rbx,%rsi,4)
mulss  %xmm0,%xmm3
movss  %xmm3,0x0(%r13,%r8,4)
mulss  %xmm0,%xmm9
movss  %xmm9,0x4(%r13,%r8,4)
mulss  %xmm0,%xmm7
movss  %xmm7,0x8(%r13,%r8,4)
mulss  %xmm0,%xmm6
movss  %xmm6,0xc(%r13,%r8,4)
mulss  %xmm0,%xmm10
movss  %xmm10,(%rcx,%r8,4)
mulss  %xmm0,%xmm11
movss  %xmm11,0x4(%rcx,%r8,4)
mulss  %xmm0,%xmm5
movss  %xmm5,0x8(%rcx,%r8,4)
mulss  %xmm0,%xmm4
movss  %xmm4,0xc(%rcx,%r8,4)
movzwl -0x2(%rdx,%r15,2),%ebx
add    $0xffffffffffffffff,%r15
movsd  (%r11,%r8,4),%xmm14
movsd  (%rdi,%r8,4),%xmm9
add    %rbp,%r13
add    %rbp,%rdi
add    %rbp,%rcx
add    %rbp,%r11
cmp    %r14,%r15
jg     12c0 <scbitrevR2+0x1c0>
movaps %xmm9,%xmm10
shufps $0x55,%xmm9,%xmm10
movaps %xmm14,%xmm5
shufps $0x55,%xmm14,%xmm5
lea    0x0(,%r8,4),%rbx
add    %r13,%rbx
lea    0x4(%r13,%r8,4),%rax
lea    (%rcx,%r8,4),%r11
lea    0x4(%rcx,%r8,4),%rcx
mov    -0x10(%rsp),%r15
mov    -0x8(%rsp),%rdi
mov    -0x18(%rsp),%r12
jmp    1467 <scbitrevR2+0x367>
nopl   0x0(%rax,%rax,1)
lea    (%r10,%r8,4),%rax
add    $0x4,%rax
movaps %xmm14,%xmm5
shufps $0x55,%xmm14,%xmm5
lea    (%rbx,%rsi,4),%r11
mov    -0x20(%rsp),%rcx
lea    (%rbx,%rcx,4),%rcx
movaps %xmm9,%xmm10
shufps $0x55,%xmm9,%xmm10
movss  0x8(%rbx),%xmm2
movss  0xc(%rbx),%xmm1
movss  0x8(%rbx,%rsi,4),%xmm12
movss  0xc(%rbx,%rsi,4),%xmm11
movaps %xmm14,%xmm3
addss  %xmm9,%xmm3
movaps %xmm5,%xmm4
addss  %xmm10,%xmm4
subss  %xmm9,%xmm14
subss  %xmm10,%xmm5
movaps %xmm2,%xmm7
addss  %xmm12,%xmm7
movaps %xmm1,%xmm6
addss  %xmm11,%xmm6
subss  %xmm12,%xmm2
subss  %xmm11,%xmm1
mulss  %xmm0,%xmm3
movss  %xmm3,(%rbx)
mulss  %xmm0,%xmm4
movss  %xmm4,(%rax)
mulss  %xmm0,%xmm14
movss  %xmm14,0x8(%rbx)
mulss  %xmm0,%xmm5
movss  %xmm5,0xc(%rbx)
mulss  %xmm0,%xmm7
movss  %xmm7,(%r11)
mulss  %xmm0,%xmm6
movss  %xmm6,(%rcx)
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%rbx,%rsi,4)
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rbx,%rsi,4)
test   %r14,%r14
jle    1220 <scbitrevR2+0x120>
add    $0xffffffffffffffff,%r14
movzwl (%rdx,%r14,2),%ecx
jmp    1270 <scbitrevR2+0x170>

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

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