#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double sin(double);
void rlft3(float ***data, float **speq, unsigned long nn1, unsigned long nn2,
           unsigned long nn3, int isign) {
  void fourn(float data[], unsigned long nn[], int ndim, int isign);
  void nrerror(char error_text[]);
  unsigned long i1, i2, i3, j1, j2, j3, nn[4], ii3;
  double theta, wi, wpi, wpr, wr, wtemp;
  float c1, c2, h1r, h1i, h2r, h2i;
  if (1 + &data[nn1][nn2][nn3] - &data[1][1][1] != nn1 * nn2 * nn3)
    nrerror("rlft3: problem with dimensions or contiguity of data array\n");
  c1 = 0.5;
  c2 = -0.5 * isign;
  theta = isign * (6.28318530717959 / nn3);
  wtemp = sin(0.5 * theta);
  wpr = -2.0 * wtemp * wtemp;
  wpi = sin(theta);
  nn[1] = nn1;
  nn[2] = nn2;
  nn[3] = nn3 >> 1;
  if (isign == 1) {
    fourn(&data[1][1][1] - 1, nn, 3, isign);
    for (i1 = 1; i1 <= nn1; i1++)
      for (i2 = 1, j2 = 0; i2 <= nn2; i2++) {
        speq[i1][++j2] = data[i1][i2][1];
        speq[i1][++j2] = data[i1][i2][2];
      }
  }
  for (i1 = 1; i1 <= nn1; i1++) {
    j1 = (i1 != 1 ? nn1 - i1 + 2 : 1);
    wr = 1.0;
    wi = 0.0;
    for (ii3 = 1, i3 = 1; i3 <= (nn3 >> 2) + 1; i3++, ii3 += 2) {
      for (i2 = 1; i2 <= nn2; i2++) {
        if (i3 == 1) {
          j2 = (i2 != 1 ? ((nn2 - i2) << 1) + 3 : 1);
          h1r = c1 * (data[i1][i2][1] + speq[j1][j2]);
          h1i = c1 * (data[i1][i2][2] - speq[j1][j2 + 1]);
          h2i = c2 * (data[i1][i2][1] - speq[j1][j2]);
          h2r = -c2 * (data[i1][i2][2] + speq[j1][j2 + 1]);
          data[i1][i2][1] = h1r + h2r;
          data[i1][i2][2] = h1i + h2i;
          speq[j1][j2] = h1r - h2r;
          speq[j1][j2 + 1] = h2i - h1i;
        } else {
          j2 = (i2 != 1 ? nn2 - i2 + 2 : 1);
          j3 = nn3 + 3 - (i3 << 1);
          h1r = c1 * (data[i1][i2][ii3] + data[j1][j2][j3]);
          h1i = c1 * (data[i1][i2][ii3 + 1] - data[j1][j2][j3 + 1]);
          h2i = c2 * (data[i1][i2][ii3] - data[j1][j2][j3]);
          h2r = -c2 * (data[i1][i2][ii3 + 1] + data[j1][j2][j3 + 1]);
          data[i1][i2][ii3] = h1r + wr * h2r - wi * h2i;
          data[i1][i2][ii3 + 1] = h1i + wr * h2i + wi * h2r;
          data[j1][j2][j3] = h1r - wr * h2r + wi * h2i;
          data[j1][j2][j3 + 1] = -h1i + wr * h2i + wi * h2r;
        }
      }
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
    }
  }
  if (isign == -1)
    fourn(&data[1][1][1] - 1, nn, 3, isign);
}


x86 assembly (clang, -O0):
<rlft3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    0x8(%rcx),%rcx
add    $0x4,%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x18(%rbp),%rcx
imul   -0x20(%rbp),%rcx
imul   -0x28(%rbp),%rcx
cmp    %rcx,%rax
je     11b0 <rlft3+0x80>
lea    0xea5(%rip),%rdi
call   1040 <nrerror@plt>
movl   $0x3f000000,-0xbc(%rbp)
cvtsi2sdl -0x2c(%rbp),%xmm0
movsd  0xe51(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
cvtsi2sdl -0x2c(%rbp),%xmm0
movaps 0xe4d(%rip),%xmm1
movq   -0x28(%rbp),%xmm2
punpckldq %xmm1,%xmm2
movapd 0xe4c(%rip),%xmm1
subpd  %xmm1,%xmm2
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0xe05(%rip),%xmm1
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xde5(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
call   1050 <sin@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xdc0(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1050 <sin@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x68(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jne    138c <rlft3+0x25c>
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x8(%rax),%rdi
add    $0x4,%rdi
add    $0xfffffffffffffffc,%rdi
lea    -0x80(%rbp),%rsi
mov    -0x2c(%rbp),%ecx
mov    $0x3,%edx
call   1030 <fourn@plt>
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     1387 <rlft3+0x257>
movq   $0x1,-0x40(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     1371 <rlft3+0x241>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12de <rlft3+0x1ae>
jmp    1376 <rlft3+0x246>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12c0 <rlft3+0x190>
jmp    138c <rlft3+0x25c>
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     1aa5 <rlft3+0x975>
cmpq   $0x1,-0x38(%rbp)
je     13c5 <rlft3+0x295>
mov    -0x18(%rbp),%rax
sub    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xd8(%rbp)
jmp    13d6 <rlft3+0x2a6>
mov    $0x1,%eax
mov    %rax,-0xd8(%rbp)
jmp    13d6 <rlft3+0x2a6>
mov    -0xd8(%rbp),%rax
mov    %rax,-0x50(%rbp)
movsd  0xc37(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movq   $0x1,-0x88(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
ja     1a8f <rlft3+0x95f>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     19dd <rlft3+0x8ad>
cmpq   $0x1,-0x48(%rbp)
jne    1645 <rlft3+0x515>
cmpq   $0x1,-0x40(%rbp)
je     1470 <rlft3+0x340>
mov    -0x20(%rbp),%rax
sub    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x3,%rax
mov    %rax,-0xe0(%rbp)
jmp    1481 <rlft3+0x351>
mov    $0x1,%eax
mov    %rax,-0xe0(%rbp)
jmp    1481 <rlft3+0x351>
mov    -0xe0(%rbp),%rax
mov    %rax,-0x58(%rbp)
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
addss  -0xcc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc8(%rbp),%xmm0
ff
addss  -0xd0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x8(%rax)
movss  -0xc4(%rbp),%xmm0
ff
subss  -0xcc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
jmp    19c7 <rlft3+0x897>
cmpq   $0x1,-0x40(%rbp)
je     1668 <rlft3+0x538>
mov    -0x20(%rbp),%rax
sub    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xe8(%rbp)
jmp    1679 <rlft3+0x549>
mov    $0x1,%eax
mov    %rax,-0xe8(%rbp)
jmp    1679 <rlft3+0x549>
mov    -0xe8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
add    $0x3,%rax
mov    -0x48(%rbp),%rcx
shl    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movss  -0xd0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0xc4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movss  -0xd0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
jmp    19cc <rlft3+0x89c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1430 <rlft3+0x300>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x88(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x88(%rbp)
jmp    140f <rlft3+0x2df>
jmp    1a94 <rlft3+0x964>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1394 <rlft3+0x264>
cmpl   $0xffffffff,-0x2c(%rbp)
jne    1ad4 <rlft3+0x9a4>
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x8(%rax),%rdi
add    $0x4,%rdi
add    $0xfffffffffffffffc,%rdi
lea    -0x80(%rbp),%rsi
mov    -0x2c(%rbp),%ecx
mov    $0x3,%edx
call   1030 <fourn@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rlft3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdi,%r15
mov    (%rdi,%rdx,8),%rax
lea    0x0(,%r8,4),%rdi
add    (%rax,%rcx,8),%rdi
mov    %r9d,0x1c(%rsp)
mov    %rsi,0x48(%rsp)
mov    0x8(%r15),%rax
sub    0x8(%rax),%rdi
sar    $0x2,%rdi
mov    %rcx,0x8(%rsp)
mov    %rcx,%rax
mov    %rdx,0x10(%rsp)
imul   %rdx,%rax
mov    %r8,%r14
imul   %r8,%rax
cmp    %rax,%rdi
je     1193 <rlft3+0x63>
lea    0xee6(%rip),%rdi
call   1040 <nrerror@plt>
mov    0x1c(%rsp),%ebp
cvtsi2sd %ebp,%xmm2
mov    %r14,%rbx
movq   %r14,%xmm0
punpckldq 0xe85(%rip),%xmm0
subpd  0xe8d(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe41(%rip),%xmm3
divsd  %xmm1,%xmm3
movsd  %xmm2,0x28(%rsp)
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x30(%rsp)
movsd  0xe2d(%rip),%xmm0
mulsd  %xmm3,%xmm0
call   1050 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x30(%rsp),%xmm0
call   1050 <sin@plt>
movaps %xmm0,0x30(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    0x8(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %r14,%rax
shr    %rax
mov    %rax,0x78(%rsp)
cmp    $0x1,%ebp
jne    133f <rlft3+0x20f>
mov    0x8(%r15),%rax
mov    0x8(%rax),%rdi
lea    0x60(%rsp),%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1030 <fourn@plt>
cmpq   $0x0,0x10(%rsp)
je     168c <rlft3+0x55c>
mov    0x8(%rsp),%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
mov    $0x1,%r8d
jmp    1282 <rlft3+0x152>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r8),%rcx
cmp    0x10(%rsp),%r8
mov    %rcx,%r8
je     133f <rlft3+0x20f>
cmpq   $0x0,0x8(%rsp)
je     1270 <rlft3+0x140>
mov    (%r15,%r8,8),%rsi
mov    0x48(%rsp),%rcx
mov    (%rcx,%r8,8),%rdx
cmpq   $0x1,0x8(%rsp)
jne    12b0 <rlft3+0x180>
mov    $0x1,%ecx
xor    %edi,%edi
jmp    130a <rlft3+0x1da>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ecx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,-0x4(%rdx,%rcx,8)
movss  0x8(%rbp),%xmm0
movss  %xmm0,(%rdx,%rcx,8)
mov    0x8(%rsi,%rcx,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,8)
movss  0x8(%rbp),%xmm0
add    $0x4,%rdi
movss  %xmm0,0x8(%rdx,%rcx,8)
lea    (%rax,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
cmp    $0x1,%rbp
jne    12c0 <rlft3+0x190>
testb  $0x1,0x8(%rsp)
je     1270 <rlft3+0x140>
mov    (%rsi,%rcx,8),%rcx
movss  0x4(%rcx),%xmm0
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movss  %xmm0,(%rdx,%rsi,1)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0x8(%rdx,%rdi,4)
jmp    1270 <rlft3+0x140>
cmpq   $0x0,0x10(%rsp)
je     1669 <rlft3+0x539>
movsd  0x28(%rsp),%xmm0
mulsd  0xca7(%rip),%xmm0
cvtsd2ss %xmm0,%xmm13
movsd  0xcb1(%rip),%xmm11
movsd  0x20(%rsp),%xmm0
mulsd  %xmm0,%xmm11
mulsd  %xmm0,%xmm11
mov    0x10(%rsp),%rax
add    $0x2,%rax
mov    %rax,0x50(%rsp)
mov    %r14,%rax
mov    %r14,%r11
shr    $0x2,%r11
add    $0x3,%rax
mov    %rax,0x28(%rsp)
movaps 0xcb0(%rip),%xmm14
xorps  %xmm13,%xmm14
add    $0x1,%r11
unpcklpd %xmm11,%xmm11
movaps 0x30(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x20(%rsp)
lea    0x1(%rax,%rax,1),%rax
mov    %rax,0x58(%rsp)
mov    $0x1,%r8d
movss  0xc8f(%rip),%xmm15
mov    $0x1,%eax
jmp    1402 <rlft3+0x2d2>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%rcx
cmp    0x10(%rsp),%rax
mov    %rcx,%rax
je     1669 <rlft3+0x539>
mov    0x50(%rsp),%rdx
sub    %rax,%rdx
cmp    $0x1,%rax
cmove  %rax,%rdx
mov    $0x1,%esi
mov    $0x1,%ecx
movsd  0xbfc(%rip),%xmm7
jmp    1475 <rlft3+0x345>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm7,%xmm10
unpckhpd %xmm7,%xmm10
xorpd  0xc1d(%rip),%xmm10
unpcklpd %xmm7,%xmm10
mulpd  0x30(%rsp),%xmm10
movapd %xmm7,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm10,%xmm0
addpd  %xmm0,%xmm7
lea    0x1(%rsi),%rdi
add    $0x2,%rcx
cmp    %r11,%rsi
mov    %rdi,%rsi
je     13f0 <rlft3+0x2c0>
cmpq   $0x0,0x8(%rsp)
je     1430 <rlft3+0x300>
mov    0x28(%rsp),%r14
sub    %rsi,%r14
sub    %rsi,%r14
movapd %xmm7,%xmm9
unpckhpd %xmm7,%xmm9
movapd %xmm9,%xmm10
movapd 0xbc1(%rip),%xmm0
xorpd  %xmm0,%xmm10
movapd %xmm7,%xmm12
xorpd  %xmm0,%xmm12
mov    0x58(%rsp),%r10
xor    %r12d,%r12d
mov    0x20(%rsp),%r9
jmp    15d0 <rlft3+0x4a0>
test   %r12,%r12
mov    %r9,%rdi
cmove  %r8,%rdi
mov    (%r15,%rax,8),%rbx
mov    0x8(%rbx,%r12,8),%r13
mov    (%r15,%rdx,8),%rbx
mov    %r15,%rbp
mov    (%rbx,%rdi,8),%r15
movss  0x0(%r13,%rcx,4),%xmm0
movss  0x4(%r13,%rcx,4),%xmm1
movss  (%r15,%r14,4),%xmm2
movss  0x4(%r15,%r14,4),%xmm5
movaps %xmm0,%xmm6
addss  %xmm2,%xmm6
mulss  %xmm15,%xmm6
movaps %xmm1,%xmm4
subss  %xmm5,%xmm4
mulss  %xmm15,%xmm4
subss  %xmm2,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm5,%xmm1
mulss  %xmm14,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
cvtss2sd %xmm1,%xmm1
movapd %xmm7,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm2,%xmm5
cvtss2sd %xmm0,%xmm0
movapd %xmm10,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm5,%xmm6
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
movss  %xmm5,0x0(%r13,%rcx,4)
cvtss2sd %xmm4,%xmm4
movapd %xmm7,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm5,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm9,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,0x4(%r13,%rcx,4)
mulsd  %xmm12,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm9,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r15,%r14,4)
subsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
xorps  %xmm0,%xmm0
cvtsd2ss %xmm5,%xmm0
movss  %xmm0,0x4(%r15,%r14,4)
mov    %rbp,%r15
add    $0xffffffffffffffff,%r9
add    $0x1,%r12
add    $0xfffffffffffffffe,%r10
cmp    $0x1,%r9
je     1443 <rlft3+0x313>
cmp    $0x1,%rsi
jne    14c0 <rlft3+0x390>
test   %r12,%r12
mov    %r10,%rbp
cmove  %r8,%rbp
mov    (%r15,%rax,8),%rdi
mov    0x8(%rdi,%r12,8),%rbx
mov    0x48(%rsp),%rdi
mov    (%rdi,%rdx,8),%rdi
movss  0x4(%rbx),%xmm6
movss  0x8(%rbx),%xmm5
movss  (%rdi,%rbp,4),%xmm0
movss  0x4(%rdi,%rbp,4),%xmm2
movaps %xmm6,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm15,%xmm1
movaps %xmm5,%xmm8
subss  %xmm2,%xmm8
mulss  %xmm15,%xmm8
subss  %xmm0,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm2,%xmm5
mulss  %xmm14,%xmm5
movaps %xmm1,%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,0x4(%rbx)
movaps %xmm6,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,0x8(%rbx)
subss  %xmm5,%xmm1
movss  %xmm1,(%rdi,%rbp,4)
subss  %xmm8,%xmm6
movss  %xmm6,0x4(%rdi,%rbp,4)
jmp    15ba <rlft3+0x48a>
cmpl   $0xffffffff,0x1c(%rsp)
jne    168c <rlft3+0x55c>
mov    0x8(%r15),%rax
mov    0x8(%rax),%rdi
lea    0x60(%rsp),%rsi
mov    $0x3,%edx
mov    $0xffffffff,%ecx
call   1030 <fourn@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [60 x i8] c"rlft3: problem with dimensions or contiguity of data array\0A\00"
define void @rlft3(float*** %0, float** %1, i64 %2, i64 %3, i64 %4, i32 %5) {
%7 = alloca float***
%8 = alloca float**
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca [4 x i64]
%20 = alloca i64
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
store float*** %0, float**** %7
store float** %1, float*** %8
store i64 %2, i64* %9
store i64 %3, i64* %10
store i64 %4, i64* %11
store i32 %5, i32* %12
%33 = load float***, float**** %7
%34 = load i64, i64* %9
%35 = getelementptr inbounds float**, float*** %33, i64 %34
%36 = load float**, float*** %35
%37 = load i64, i64* %10
%38 = getelementptr inbounds float*, float** %36, i64 %37
%39 = load float*, float** %38
%40 = load i64, i64* %11
%41 = getelementptr inbounds float, float* %39, i64 %40
%42 = getelementptr inbounds float, float* %41, i64 1
%43 = load float***, float**** %7
%44 = getelementptr inbounds float**, float*** %43, i64 1
%45 = load float**, float*** %44
%46 = getelementptr inbounds float*, float** %45, i64 1
%47 = load float*, float** %46
%48 = getelementptr inbounds float, float* %47, i64 1
%49 = ptrtoint float* %42 to i64
%50 = ptrtoint float* %48 to i64
%51 = sub i64 %49, %50
%52 = sdiv exact i64 %51, 4
%53 = load i64, i64* %9
%54 = load i64, i64* %10
%55 = mul i64 %53, %54
%56 = load i64, i64* %11
%57 = mul i64 %55, %56
%58 = icmp ne i64 %52, %57
br i1 %58, label %59, label %60
59: ; preds = %6
br label %60
60: ; preds = %59, %6
store float 5.000000e-01, float* %27
%61 = load i32, i32* %12
%62 = sitofp i32 %61 to double
%63 = fmul double -5.000000e-01, %62
%64 = fptrunc double %63 to float
store float %64, float* %28
%65 = load i32, i32* %12
%66 = sitofp i32 %65 to double
%67 = load i64, i64* %11
%68 = uitofp i64 %67 to double
%69 = fdiv double 0x401921FB54442D1C, %68
%70 = fmul double %66, %69
store double %70, double* %21
%71 = load double, double* %21
%72 = fmul double 5.000000e-01, %71
%73 = call double @sin(double %72)
store double %73, double* %26
%74 = load double, double* %26
%75 = fmul double -2.000000e+00, %74
%76 = load double, double* %26
%77 = fmul double %75, %76
store double %77, double* %24
%78 = load double, double* %21
%79 = call double @sin(double %78)
store double %79, double* %23
%80 = load i64, i64* %9
%81 = getelementptr inbounds [4 x i64], [4 x i64]* %19, i64 0, i64 1
store i64 %80, i64* %81
%82 = load i64, i64* %10
%83 = getelementptr inbounds [4 x i64], [4 x i64]* %19, i64 0, i64 2
store i64 %82, i64* %83
%84 = load i64, i64* %11
%85 = lshr i64 %84, 1
%86 = getelementptr inbounds [4 x i64], [4 x i64]* %19, i64 0, i64 3
store i64 %85, i64* %86
%87 = load i32, i32* %12
%88 = icmp eq i32 %87, 1
br i1 %88, label %89, label %149
89: ; preds = %60
%90 = load float***, float**** %7
%91 = getelementptr inbounds float**, float*** %90, i64 1
%92 = load float**, float*** %91
%93 = getelementptr inbounds float*, float** %92, i64 1
%94 = load float*, float** %93
%95 = getelementptr inbounds float, float* %94, i64 1
%96 = getelementptr inbounds float, float* %95, i64 -1
%97 = getelementptr inbounds [4 x i64], [4 x i64]* %19, i64 0, i64 0
%98 = load i32, i32* %12
store i64 1, i64* %13
br label %99
99: ; preds = %145, %89
%100 = load i64, i64* %13
%101 = load i64, i64* %9
%102 = icmp ule i64 %100, %101
br i1 %102, label %103, label %148
103: ; preds = %99
store i64 1, i64* %14
store i64 0, i64* %17
br label %104
104: ; preds = %141, %103
%105 = load i64, i64* %14
%106 = load i64, i64* %10
%107 = icmp ule i64 %105, %106
br i1 %107, label %108, label %144
108: ; preds = %104
%109 = load float***, float**** %7
%110 = load i64, i64* %13
%111 = getelementptr inbounds float**, float*** %109, i64 %110
%112 = load float**, float*** %111
%113 = load i64, i64* %14
%114 = getelementptr inbounds float*, float** %112, i64 %113
%115 = load float*, float** %114
%116 = getelementptr inbounds float, float* %115, i64 1
%117 = load float, float* %116
%118 = load float**, float*** %8
%119 = load i64, i64* %13
%120 = getelementptr inbounds float*, float** %118, i64 %119
%121 = load float*, float** %120
%122 = load i64, i64* %17
%123 = add i64 %122, 1
store i64 %123, i64* %17
%124 = getelementptr inbounds float, float* %121, i64 %123
store float %117, float* %124
%125 = load float***, float**** %7
%126 = load i64, i64* %13
%127 = getelementptr inbounds float**, float*** %125, i64 %126
%128 = load float**, float*** %127
%129 = load i64, i64* %14
%130 = getelementptr inbounds float*, float** %128, i64 %129
%131 = load float*, float** %130
%132 = getelementptr inbounds float, float* %131, i64 2
%133 = load float, float* %132
%134 = load float**, float*** %8
%135 = load i64, i64* %13
%136 = getelementptr inbounds float*, float** %134, i64 %135
%137 = load float*, float** %136
%138 = load i64, i64* %17
%139 = add i64 %138, 1
store i64 %139, i64* %17
%140 = getelementptr inbounds float, float* %137, i64 %139
store float %133, float* %140
br label %141
141: ; preds = %108
%142 = load i64, i64* %14
%143 = add i64 %142, 1
store i64 %143, i64* %14
br label %104
144: ; preds = %104
br label %145
145: ; preds = %144
%146 = load i64, i64* %13
%147 = add i64 %146, 1
store i64 %147, i64* %13
br label %99
148: ; preds = %99
br label %149
149: ; preds = %148, %60
store i64 1, i64* %13
br label %150
150: ; preds = %537, %149
%151 = load i64, i64* %13
%152 = load i64, i64* %9
%153 = icmp ule i64 %151, %152
br i1 %153, label %154, label %540
154: ; preds = %150
%155 = load i64, i64* %13
%156 = icmp ne i64 %155, 1
br i1 %156, label %157, label %162
157: ; preds = %154
%158 = load i64, i64* %9
%159 = load i64, i64* %13
%160 = sub i64 %158, %159
%161 = add i64 %160, 2
br label %163
162: ; preds = %154
br label %163
163: ; preds = %162, %157
%164 = phi i64 [ %161, %157 ], [ 1, %162 ]
store i64 %164, i64* %16
store double 1.000000e+00, double* %25
store double 0.000000e+00, double* %22
store i64 1, i64* %20
store i64 1, i64* %15
br label %165
165: ; preds = %531, %163
%166 = load i64, i64* %15
%167 = load i64, i64* %11
%168 = lshr i64 %167, 2
%169 = add i64 %168, 1
%170 = icmp ule i64 %166, %169
br i1 %170, label %171, label %536
171: ; preds = %165
store i64 1, i64* %14
br label %172
172: ; preds = %510, %171
%173 = load i64, i64* %14
%174 = load i64, i64* %10
%175 = icmp ule i64 %173, %174
br i1 %175, label %176, label %513
176: ; preds = %172
%177 = load i64, i64* %15
%178 = icmp eq i64 %177, 1
br i1 %178, label %179, label %311
179: ; preds = %176
%180 = load i64, i64* %14
%181 = icmp ne i64 %180, 1
br i1 %181, label %182, label %188
182: ; preds = %179
%183 = load i64, i64* %10
%184 = load i64, i64* %14
%185 = sub i64 %183, %184
%186 = shl i64 %185, 1
%187 = add i64 %186, 3
br label %189
188: ; preds = %179
br label %189
189: ; preds = %188, %182
%190 = phi i64 [ %187, %182 ], [ 1, %188 ]
store i64 %190, i64* %17
%191 = load float, float* %27
%192 = load float***, float**** %7
%193 = load i64, i64* %13
%194 = getelementptr inbounds float**, float*** %192, i64 %193
%195 = load float**, float*** %194
%196 = load i64, i64* %14
%197 = getelementptr inbounds float*, float** %195, i64 %196
%198 = load float*, float** %197
%199 = getelementptr inbounds float, float* %198, i64 1
%200 = load float, float* %199
%201 = load float**, float*** %8
%202 = load i64, i64* %16
%203 = getelementptr inbounds float*, float** %201, i64 %202
%204 = load float*, float** %203
%205 = load i64, i64* %17
%206 = getelementptr inbounds float, float* %204, i64 %205
%207 = load float, float* %206
%208 = fadd float %200, %207
%209 = fmul float %191, %208
store float %209, float* %29
%210 = load float, float* %27
%211 = load float***, float**** %7
%212 = load i64, i64* %13
%213 = getelementptr inbounds float**, float*** %211, i64 %212
%214 = load float**, float*** %213
%215 = load i64, i64* %14
%216 = getelementptr inbounds float*, float** %214, i64 %215
%217 = load float*, float** %216
%218 = getelementptr inbounds float, float* %217, i64 2
%219 = load float, float* %218
%220 = load float**, float*** %8
%221 = load i64, i64* %16
%222 = getelementptr inbounds float*, float** %220, i64 %221
%223 = load float*, float** %222
%224 = load i64, i64* %17
%225 = add i64 %224, 1
%226 = getelementptr inbounds float, float* %223, i64 %225
%227 = load float, float* %226
%228 = fsub float %219, %227
%229 = fmul float %210, %228
store float %229, float* %30
%230 = load float, float* %28
%231 = load float***, float**** %7
%232 = load i64, i64* %13
%233 = getelementptr inbounds float**, float*** %231, i64 %232
%234 = load float**, float*** %233
%235 = load i64, i64* %14
%236 = getelementptr inbounds float*, float** %234, i64 %235
%237 = load float*, float** %236
%238 = getelementptr inbounds float, float* %237, i64 1
%239 = load float, float* %238
%240 = load float**, float*** %8
%241 = load i64, i64* %16
%242 = getelementptr inbounds float*, float** %240, i64 %241
%243 = load float*, float** %242
%244 = load i64, i64* %17
%245 = getelementptr inbounds float, float* %243, i64 %244
%246 = load float, float* %245
%247 = fsub float %239, %246
%248 = fmul float %230, %247
store float %248, float* %32
%249 = load float, float* %28
%250 = fneg float %249
%251 = load float***, float**** %7
%252 = load i64, i64* %13
%253 = getelementptr inbounds float**, float*** %251, i64 %252
%254 = load float**, float*** %253
%255 = load i64, i64* %14
%256 = getelementptr inbounds float*, float** %254, i64 %255
%257 = load float*, float** %256
%258 = getelementptr inbounds float, float* %257, i64 2
%259 = load float, float* %258
%260 = load float**, float*** %8
%261 = load i64, i64* %16
%262 = getelementptr inbounds float*, float** %260, i64 %261
%263 = load float*, float** %262
%264 = load i64, i64* %17
%265 = add i64 %264, 1
%266 = getelementptr inbounds float, float* %263, i64 %265
%267 = load float, float* %266
%268 = fadd float %259, %267
%269 = fmul float %250, %268
store float %269, float* %31
%270 = load float, float* %29
%271 = load float, float* %31
%272 = fadd float %270, %271
%273 = load float***, float**** %7
%274 = load i64, i64* %13
%275 = getelementptr inbounds float**, float*** %273, i64 %274
%276 = load float**, float*** %275
%277 = load i64, i64* %14
%278 = getelementptr inbounds float*, float** %276, i64 %277
%279 = load float*, float** %278
%280 = getelementptr inbounds float, float* %279, i64 1
store float %272, float* %280
%281 = load float, float* %30
%282 = load float, float* %32
%283 = fadd float %281, %282
%284 = load float***, float**** %7
%285 = load i64, i64* %13
%286 = getelementptr inbounds float**, float*** %284, i64 %285
%287 = load float**, float*** %286
%288 = load i64, i64* %14
%289 = getelementptr inbounds float*, float** %287, i64 %288
%290 = load float*, float** %289
%291 = getelementptr inbounds float, float* %290, i64 2
store float %283, float* %291
%292 = load float, float* %29
%293 = load float, float* %31
%294 = fsub float %292, %293
%295 = load float**, float*** %8
%296 = load i64, i64* %16
%297 = getelementptr inbounds float*, float** %295, i64 %296
%298 = load float*, float** %297
%299 = load i64, i64* %17
%300 = getelementptr inbounds float, float* %298, i64 %299
store float %294, float* %300
%301 = load float, float* %32
%302 = load float, float* %30
%303 = fsub float %301, %302
%304 = load float**, float*** %8
%305 = load i64, i64* %16
%306 = getelementptr inbounds float*, float** %304, i64 %305
%307 = load float*, float** %306
%308 = load i64, i64* %17
%309 = add i64 %308, 1
%310 = getelementptr inbounds float, float* %307, i64 %309
store float %303, float* %310
br label %509
311: ; preds = %176
%312 = load i64, i64* %14
%313 = icmp ne i64 %312, 1
br i1 %313, label %314, label %319
314: ; preds = %311
%315 = load i64, i64* %10
%316 = load i64, i64* %14
%317 = sub i64 %315, %316
%318 = add i64 %317, 2
br label %320
319: ; preds = %311
br label %320
320: ; preds = %319, %314
%321 = phi i64 [ %318, %314 ], [ 1, %319 ]
store i64 %321, i64* %17
%322 = load i64, i64* %11
%323 = add i64 %322, 3
%324 = load i64, i64* %15
%325 = shl i64 %324, 1
%326 = sub i64 %323, %325
store i64 %326, i64* %18
%327 = load float, float* %27
%328 = load float***, float**** %7
%329 = load i64, i64* %13
%330 = getelementptr inbounds float**, float*** %328, i64 %329
%331 = load float**, float*** %330
%332 = load i64, i64* %14
%333 = getelementptr inbounds float*, float** %331, i64 %332
%334 = load float*, float** %333
%335 = load i64, i64* %20
%336 = getelementptr inbounds float, float* %334, i64 %335
%337 = load float, float* %336
%338 = load float***, float**** %7
%339 = load i64, i64* %16
%340 = getelementptr inbounds float**, float*** %338, i64 %339
%341 = load float**, float*** %340
%342 = load i64, i64* %17
%343 = getelementptr inbounds float*, float** %341, i64 %342
%344 = load float*, float** %343
%345 = load i64, i64* %18
%346 = getelementptr inbounds float, float* %344, i64 %345
%347 = load float, float* %346
%348 = fadd float %337, %347
%349 = fmul float %327, %348
store float %349, float* %29
%350 = load float, float* %27
%351 = load float***, float**** %7
%352 = load i64, i64* %13
%353 = getelementptr inbounds float**, float*** %351, i64 %352
%354 = load float**, float*** %353
%355 = load i64, i64* %14
%356 = getelementptr inbounds float*, float** %354, i64 %355
%357 = load float*, float** %356
%358 = load i64, i64* %20
%359 = add i64 %358, 1
%360 = getelementptr inbounds float, float* %357, i64 %359
%361 = load float, float* %360
%362 = load float***, float**** %7
%363 = load i64, i64* %16
%364 = getelementptr inbounds float**, float*** %362, i64 %363
%365 = load float**, float*** %364
%366 = load i64, i64* %17
%367 = getelementptr inbounds float*, float** %365, i64 %366
%368 = load float*, float** %367
%369 = load i64, i64* %18
%370 = add i64 %369, 1
%371 = getelementptr inbounds float, float* %368, i64 %370
%372 = load float, float* %371
%373 = fsub float %361, %372
%374 = fmul float %350, %373
store float %374, float* %30
%375 = load float, float* %28
%376 = load float***, float**** %7
%377 = load i64, i64* %13
%378 = getelementptr inbounds float**, float*** %376, i64 %377
%379 = load float**, float*** %378
%380 = load i64, i64* %14
%381 = getelementptr inbounds float*, float** %379, i64 %380
%382 = load float*, float** %381
%383 = load i64, i64* %20
%384 = getelementptr inbounds float, float* %382, i64 %383
%385 = load float, float* %384
%386 = load float***, float**** %7
%387 = load i64, i64* %16
%388 = getelementptr inbounds float**, float*** %386, i64 %387
%389 = load float**, float*** %388
%390 = load i64, i64* %17
%391 = getelementptr inbounds float*, float** %389, i64 %390
%392 = load float*, float** %391
%393 = load i64, i64* %18
%394 = getelementptr inbounds float, float* %392, i64 %393
%395 = load float, float* %394
%396 = fsub float %385, %395
%397 = fmul float %375, %396
store float %397, float* %32
%398 = load float, float* %28
%399 = fneg float %398
%400 = load float***, float**** %7
%401 = load i64, i64* %13
%402 = getelementptr inbounds float**, float*** %400, i64 %401
%403 = load float**, float*** %402
%404 = load i64, i64* %14
%405 = getelementptr inbounds float*, float** %403, i64 %404
%406 = load float*, float** %405
%407 = load i64, i64* %20
%408 = add i64 %407, 1
%409 = getelementptr inbounds float, float* %406, i64 %408
%410 = load float, float* %409
%411 = load float***, float**** %7
%412 = load i64, i64* %16
%413 = getelementptr inbounds float**, float*** %411, i64 %412
%414 = load float**, float*** %413
%415 = load i64, i64* %17
%416 = getelementptr inbounds float*, float** %414, i64 %415
%417 = load float*, float** %416
%418 = load i64, i64* %18
%419 = add i64 %418, 1
%420 = getelementptr inbounds float, float* %417, i64 %419
%421 = load float, float* %420
%422 = fadd float %410, %421
%423 = fmul float %399, %422
store float %423, float* %31
%424 = load float, float* %29
%425 = fpext float %424 to double
%426 = load double, double* %25
%427 = load float, float* %31
%428 = fpext float %427 to double
%429 = call double @llvm.fmuladd.f64(double %426, double %428, double %425)
%430 = load double, double* %22
%431 = load float, float* %32
%432 = fpext float %431 to double
%433 = fneg double %430
%434 = call double @llvm.fmuladd.f64(double %433, double %432, double %429)
%435 = fptrunc double %434 to float
%436 = load float***, float**** %7
%437 = load i64, i64* %13
%438 = getelementptr inbounds float**, float*** %436, i64 %437
%439 = load float**, float*** %438
%440 = load i64, i64* %14
%441 = getelementptr inbounds float*, float** %439, i64 %440
%442 = load float*, float** %441
%443 = load i64, i64* %20
%444 = getelementptr inbounds float, float* %442, i64 %443
store float %435, float* %444
%445 = load float, float* %30
%446 = fpext float %445 to double
%447 = load double, double* %25
%448 = load float, float* %32
%449 = fpext float %448 to double
%450 = call double @llvm.fmuladd.f64(double %447, double %449, double %446)
%451 = load double, double* %22
%452 = load float, float* %31
%453 = fpext float %452 to double
%454 = call double @llvm.fmuladd.f64(double %451, double %453, double %450)
%455 = fptrunc double %454 to float
%456 = load float***, float**** %7
%457 = load i64, i64* %13
%458 = getelementptr inbounds float**, float*** %456, i64 %457
%459 = load float**, float*** %458
%460 = load i64, i64* %14
%461 = getelementptr inbounds float*, float** %459, i64 %460
%462 = load float*, float** %461
%463 = load i64, i64* %20
%464 = add i64 %463, 1
%465 = getelementptr inbounds float, float* %462, i64 %464
store float %455, float* %465
%466 = load float, float* %29
%467 = fpext float %466 to double
%468 = load double, double* %25
%469 = load float, float* %31
%470 = fpext float %469 to double
%471 = fneg double %468
%472 = call double @llvm.fmuladd.f64(double %471, double %470, double %467)
%473 = load double, double* %22
%474 = load float, float* %32
%475 = fpext float %474 to double
%476 = call double @llvm.fmuladd.f64(double %473, double %475, double %472)
%477 = fptrunc double %476 to float
%478 = load float***, float**** %7
%479 = load i64, i64* %16
%480 = getelementptr inbounds float**, float*** %478, i64 %479
%481 = load float**, float*** %480
%482 = load i64, i64* %17
%483 = getelementptr inbounds float*, float** %481, i64 %482
%484 = load float*, float** %483
%485 = load i64, i64* %18
%486 = getelementptr inbounds float, float* %484, i64 %485
store float %477, float* %486
%487 = load float, float* %30
%488 = fneg float %487
%489 = fpext float %488 to double
%490 = load double, double* %25
%491 = load float, float* %32
%492 = fpext float %491 to double
%493 = call double @llvm.fmuladd.f64(double %490, double %492, double %489)
%494 = load double, double* %22
%495 = load float, float* %31
%496 = fpext float %495 to double
%497 = call double @llvm.fmuladd.f64(double %494, double %496, double %493)
%498 = fptrunc double %497 to float
%499 = load float***, float**** %7
%500 = load i64, i64* %16
%501 = getelementptr inbounds float**, float*** %499, i64 %500
%502 = load float**, float*** %501
%503 = load i64, i64* %17
%504 = getelementptr inbounds float*, float** %502, i64 %503
%505 = load float*, float** %504
%506 = load i64, i64* %18
%507 = add i64 %506, 1
%508 = getelementptr inbounds float, float* %505, i64 %507
store float %498, float* %508
br label %509
509: ; preds = %320, %189
br label %510
510: ; preds = %509
%511 = load i64, i64* %14
%512 = add i64 %511, 1
store i64 %512, i64* %14
br label %172
513: ; preds = %172
%514 = load double, double* %25
store double %514, double* %26
%515 = load double, double* %24
%516 = load double, double* %22
%517 = load double, double* %23
%518 = fmul double %516, %517
%519 = fneg double %518
%520 = call double @llvm.fmuladd.f64(double %514, double %515, double %519)
%521 = load double, double* %25
%522 = fadd double %520, %521
store double %522, double* %25
%523 = load double, double* %22
%524 = load double, double* %24
%525 = load double, double* %26
%526 = load double, double* %23
%527 = fmul double %525, %526
%528 = call double @llvm.fmuladd.f64(double %523, double %524, double %527)
%529 = load double, double* %22
%530 = fadd double %528, %529
store double %530, double* %22
br label %531
531: ; preds = %513
%532 = load i64, i64* %15
%533 = add i64 %532, 1
store i64 %533, i64* %15
%534 = load i64, i64* %20
%535 = add i64 %534, 2
store i64 %535, i64* %20
br label %165
536: ; preds = %165
br label %537
537: ; preds = %536
%538 = load i64, i64* %13
%539 = add i64 %538, 1
store i64 %539, i64* %13
br label %150
540: ; preds = %150
%541 = load i32, i32* %12
%542 = icmp eq i32 %541, -1
br i1 %542, label %543, label %553
543: ; preds = %540
%544 = load float***, float**** %7
%545 = getelementptr inbounds float**, float*** %544, i64 1
%546 = load float**, float*** %545
%547 = getelementptr inbounds float*, float** %546, i64 1
%548 = load float*, float** %547
%549 = getelementptr inbounds float, float* %548, i64 1
%550 = getelementptr inbounds float, float* %549, i64 -1
%551 = getelementptr inbounds [4 x i64], [4 x i64]* %19, i64 0, i64 0
%552 = load i32, i32* %12
br label %553
553: ; preds = %543, %540
ret void
}

LLVM IR (-O2):
@.str = [60 x i8] c"rlft3: problem with dimensions or contiguity of data array\0A\00"
define void @rlft3(float*** nocapture %0, float** nocapture %1, i64 %2, i64 %3, i64 %4, i32 %5) {
%7 = alloca [4 x i64]
%8 = bitcast [4 x i64]* %7 to i8*
%9 = getelementptr inbounds float**, float*** %0, i64 %2
%10 = load float**, float*** %9
%11 = getelementptr inbounds float*, float** %10, i64 %3
%12 = load float*, float** %11
%13 = getelementptr inbounds float, float* %12, i64 %4
%14 = getelementptr inbounds float, float* %13, i64 1
%15 = getelementptr inbounds float**, float*** %0, i64 1
%16 = load float**, float*** %15
%17 = getelementptr inbounds float*, float** %16, i64 1
%18 = load float*, float** %17
%19 = getelementptr inbounds float, float* %18, i64 1
%20 = ptrtoint float* %14 to i64
%21 = ptrtoint float* %19 to i64
%22 = sub i64 %20, %21
%23 = ashr exact i64 %22, 2
%24 = mul i64 %3, %2
%25 = mul i64 %24, %4
%26 = icmp eq i64 %23, %25
br i1 %26, label %28, label %27
27: ; preds = %6
tail call void @nrerror(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str, i64 0, i64 0))
br label %28
28: ; preds = %27, %6
%29 = sitofp i32 %5 to double
%30 = fmul double %29, -5.000000e-01
%31 = fptrunc double %30 to float
%32 = uitofp i64 %4 to double
%33 = fdiv double 0x401921FB54442D1C, %32
%34 = fmul double %33, %29
%35 = fmul double %34, 5.000000e-01
%36 = tail call double @sin(double %35)
%37 = fmul double %36, -2.000000e+00
%38 = fmul double %36, %37
%39 = tail call double @sin(double %34)
%40 = getelementptr inbounds [4 x i64], [4 x i64]* %7, i64 0, i64 1
store i64 %2, i64* %40
%41 = getelementptr inbounds [4 x i64], [4 x i64]* %7, i64 0, i64 2
store i64 %3, i64* %41
%42 = lshr i64 %4, 1
%43 = getelementptr inbounds [4 x i64], [4 x i64]* %7, i64 0, i64 3
store i64 %42, i64* %43
%44 = icmp eq i32 %5, 1
br i1 %44, label %45, label %109
45: ; preds = %28
%46 = load float**, float*** %15
%47 = getelementptr inbounds float*, float** %46, i64 1
%48 = load float*, float** %47
%49 = getelementptr inbounds [4 x i64], [4 x i64]* %7, i64 0, i64 0
%50 = icmp eq i64 %2, 0
br i1 %50, label %247, label %51
51: ; preds = %45
%52 = icmp eq i64 %3, 0
%53 = and i64 %3, 1
%54 = icmp eq i64 %3, 1
%55 = and i64 %3, -2
%56 = icmp eq i64 %53, 0
br label %57
57: ; preds = %51, %106
%58 = phi i64 [ 1, %51 ], [ %107, %106 ]
br i1 %52, label %106, label %59
59: ; preds = %57
%60 = getelementptr inbounds float**, float*** %0, i64 %58
%61 = load float**, float*** %60
%62 = getelementptr inbounds float*, float** %1, i64 %58
%63 = load float*, float** %62
br i1 %54, label %92, label %64
64: ; preds = %59, %64
%65 = phi i64 [ %89, %64 ], [ 1, %59 ]
%66 = phi i64 [ %87, %64 ], [ 0, %59 ]
%67 = phi i64 [ %90, %64 ], [ 0, %59 ]
%68 = getelementptr inbounds float*, float** %61, i64 %65
%69 = load float*, float** %68
%70 = getelementptr inbounds float, float* %69, i64 1
%71 = load float, float* %70
%72 = or i64 %66, 1
%73 = getelementptr inbounds float, float* %63, i64 %72
store float %71, float* %73
%74 = getelementptr inbounds float, float* %69, i64 2
%75 = load float, float* %74
%76 = or i64 %66, 2
%77 = getelementptr inbounds float, float* %63, i64 %76
store float %75, float* %77
%78 = add nuw i64 %65, 1
%79 = getelementptr inbounds float*, float** %61, i64 %78
%80 = load float*, float** %79
%81 = getelementptr inbounds float, float* %80, i64 1
%82 = load float, float* %81
%83 = or i64 %66, 3
%84 = getelementptr inbounds float, float* %63, i64 %83
store float %82, float* %84
%85 = getelementptr inbounds float, float* %80, i64 2
%86 = load float, float* %85
%87 = add i64 %66, 4
%88 = getelementptr inbounds float, float* %63, i64 %87
store float %86, float* %88
%89 = add nuw i64 %65, 2
%90 = add i64 %67, 2
%91 = icmp eq i64 %90, %55
br i1 %91, label %92, label %64
92: ; preds = %64, %59
%93 = phi i64 [ 1, %59 ], [ %89, %64 ]
%94 = phi i64 [ 0, %59 ], [ %87, %64 ]
br i1 %56, label %106, label %95
95: ; preds = %92
%96 = getelementptr inbounds float*, float** %61, i64 %93
%97 = load float*, float** %96
%98 = getelementptr inbounds float, float* %97, i64 1
%99 = load float, float* %98
%100 = or i64 %94, 1
%101 = getelementptr inbounds float, float* %63, i64 %100
store float %99, float* %101
%102 = getelementptr inbounds float, float* %97, i64 2
%103 = load float, float* %102
%104 = add i64 %94, 2
%105 = getelementptr inbounds float, float* %63, i64 %104
store float %103, float* %105
br label %106
106: ; preds = %95, %92, %57
%107 = add nuw i64 %58, 1
%108 = icmp eq i64 %58, %2
br i1 %108, label %109, label %57
109: ; preds = %106, %28
%110 = icmp eq i64 %2, 0
br i1 %110, label %240, label %111
111: ; preds = %109
%112 = add i64 %2, 2
%113 = lshr i64 %4, 2
%114 = icmp eq i64 %3, 0
%115 = add i64 %3, 2
%116 = add i64 %4, 3
%117 = fneg float %31
%118 = add nuw nsw i64 %113, 1
%119 = insertelement <2 x double> poison, double %38, i64 0
%120 = shufflevector <2 x double> %119, <2 x double> poison, <2 x i32> zeroinitializer
%121 = insertelement <2 x double> poison, double %39, i64 0
%122 = shufflevector <2 x double> %121, <2 x double> poison, <2 x i32> zeroinitializer
br label %123
123: ; preds = %111, %237
%124 = phi i64 [ 1, %111 ], [ %238, %237 ]
%125 = icmp eq i64 %124, 1
%126 = sub i64 %112, %124
%127 = select i1 %125, i64 1, i64 %126
%128 = getelementptr inbounds float**, float*** %0, i64 %124
%129 = getelementptr inbounds float**, float*** %0, i64 %127
%130 = getelementptr inbounds float*, float** %1, i64 %127
br label %131
131: ; preds = %123, %227
%132 = phi i64 [ 1, %123 ], [ %234, %227 ]
%133 = phi i64 [ 1, %123 ], [ %235, %227 ]
%134 = phi <2 x double> [ <double 1.000000e+00, double 0.000000e+00>, %123 ], [ %233, %227 ]
br i1 %114, label %135, label %138
135: ; preds = %131
%136 = extractelement <2 x double> %134, i64 1
%137 = fneg double %136
br label %227
138: ; preds = %131
%139 = icmp eq i64 %132, 1
%140 = mul nsw i64 %132, -2
%141 = add i64 %116, %140
%142 = add nuw i64 %133, 1
%143 = add i64 %141, 1
%144 = extractelement <2 x double> %134, i64 1
%145 = fneg double %144
%146 = extractelement <2 x double> %134, i64 0
%147 = fneg double %146
br label %148
148: ; preds = %138, %224
%149 = phi i64 [ 1, %138 ], [ %225, %224 ]
%150 = icmp eq i64 %149, 1
br i1 %139, label %151, label %181
151: ; preds = %148
%152 = sub i64 %3, %149
%153 = shl i64 %152, 1
%154 = add i64 %153, 3
%155 = select i1 %150, i64 1, i64 %154
%156 = load float**, float*** %128
%157 = getelementptr inbounds float*, float** %156, i64 %149
%158 = load float*, float** %157
%159 = getelementptr inbounds float, float* %158, i64 1
%160 = load float, float* %159
%161 = load float*, float** %130
%162 = getelementptr inbounds float, float* %161, i64 %155
%163 = load float, float* %162
%164 = fadd float %160, %163
%165 = fmul float %164, 5.000000e-01
%166 = getelementptr inbounds float, float* %158, i64 2
%167 = load float, float* %166
%168 = add i64 %155, 1
%169 = getelementptr inbounds float, float* %161, i64 %168
%170 = load float, float* %169
%171 = fsub float %167, %170
%172 = fmul float %171, 5.000000e-01
%173 = fsub float %160, %163
%174 = fmul float %173, %31
%175 = fadd float %167, %170
%176 = fmul float %175, %117
%177 = fadd float %165, %176
store float %177, float* %159
%178 = fadd float %174, %172
store float %178, float* %166
%179 = fsub float %165, %176
store float %179, float* %162
%180 = fsub float %174, %172
store float %180, float* %169
br label %224
181: ; preds = %148
%182 = sub i64 %115, %149
%183 = select i1 %150, i64 1, i64 %182
%184 = load float**, float*** %128
%185 = getelementptr inbounds float*, float** %184, i64 %149
%186 = load float*, float** %185
%187 = getelementptr inbounds float, float* %186, i64 %133
%188 = load float, float* %187
%189 = load float**, float*** %129
%190 = getelementptr inbounds float*, float** %189, i64 %183
%191 = load float*, float** %190
%192 = getelementptr inbounds float, float* %191, i64 %141
%193 = load float, float* %192
%194 = fadd float %188, %193
%195 = fmul float %194, 5.000000e-01
%196 = getelementptr inbounds float, float* %186, i64 %142
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %191, i64 %143
%199 = load float, float* %198
%200 = fsub float %197, %199
%201 = fmul float %200, 5.000000e-01
%202 = fsub float %188, %193
%203 = fmul float %202, %31
%204 = fadd float %197, %199
%205 = fmul float %204, %117
%206 = fpext float %195 to double
%207 = fpext float %205 to double
%208 = call double @llvm.fmuladd.f64(double %146, double %207, double %206)
%209 = fpext float %203 to double
%210 = call double @llvm.fmuladd.f64(double %145, double %209, double %208)
%211 = fptrunc double %210 to float
store float %211, float* %187
%212 = fpext float %201 to double
%213 = call double @llvm.fmuladd.f64(double %146, double %209, double %212)
%214 = call double @llvm.fmuladd.f64(double %144, double %207, double %213)
%215 = fptrunc double %214 to float
store float %215, float* %196
%216 = call double @llvm.fmuladd.f64(double %147, double %207, double %206)
%217 = call double @llvm.fmuladd.f64(double %144, double %209, double %216)
%218 = fptrunc double %217 to float
store float %218, float* %192
%219 = fneg float %201
%220 = fpext float %219 to double
%221 = call double @llvm.fmuladd.f64(double %146, double %209, double %220)
%222 = call double @llvm.fmuladd.f64(double %144, double %207, double %221)
%223 = fptrunc double %222 to float
store float %223, float* %198
br label %224
224: ; preds = %151, %181
%225 = add nuw i64 %149, 1
%226 = icmp eq i64 %149, %3
br i1 %226, label %227, label %148
227: ; preds = %224, %135
%228 = phi double [ %137, %135 ], [ %145, %224 ]
%229 = insertelement <2 x double> poison, double %228, i64 0
%230 = shufflevector <2 x double> %229, <2 x double> %134, <2 x i32> <i32 0, i32 2>
%231 = fmul <2 x double> %122, %230
%232 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %134, <2 x double> %120, <2 x double> %231)
%233 = fadd <2 x double> %134, %232
%234 = add nuw nsw i64 %132, 1
%235 = add nuw i64 %133, 2
%236 = icmp eq i64 %132, %118
br i1 %236, label %237, label %131
237: ; preds = %227
%238 = add nuw i64 %124, 1
%239 = icmp eq i64 %124, %2
br i1 %239, label %240, label %123
240: ; preds = %237, %109
%241 = icmp eq i32 %5, -1
br i1 %241, label %242, label %247
242: ; preds = %240
%243 = load float**, float*** %15
%244 = getelementptr inbounds float*, float** %243, i64 1
%245 = load float*, float** %244
%246 = getelementptr inbounds [4 x i64], [4 x i64]* %7, i64 0, i64 0
br label %247
247: ; preds = %45, %242, %240
ret void
}