#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 */
int /*<<< orphan*/ fourn(float *, unsigned long *, int, int);
int /*<<< orphan*/ free_lvector(unsigned long *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
unsigned long *lvector(int, int);
int /*<<< orphan*/ printf(char *, ...);
int ran1(long *);
float *vector(int, int);
int main(void) {
  int isign;
  long idum = (-23);
  unsigned long i, j, k, l, ndum = 2, *nn;
  float *data1, *data2;
  nn = lvector(1, 3);
  data1 = vector(1, 1024);
  data2 = vector(1, 1024);
  for (i = 1; i <= 3; i++)
    nn[i] = (ndum <<= 1);
  for (i = 1; i <= nn[3]; i++)
    for (j = 1; j <= nn[2]; j++)
      for (k = 1; k <= nn[1]; k++) {
        l = k + (j - 1) * nn[1] + (i - 1) * nn[2] * nn[1];
        l = (l << 1) - 1;
        data2[l] = data1[l] = 2 * ran1(&idum) - 1;
        l++;
        data2[l] = data1[l] = 2 * ran1(&idum) - 1;
      }
  isign = 1;
  fourn(data2, nn, 3, isign);
  isign = -1;
  fourn(data2, nn, 3, isign);
  printf("Double 3-dimensional transform\n\n");
  printf("%22s %24s %20s\n", "Double transf.", "Original data", "Ratio");
  printf("%10s %13s %12s %13s %11s %13s\n\n", "real", "imag.", "real", "imag.",
         "real", "imag.");
  for (i = 1; i <= 4; i++) {
    k = 2 * (j = 2 * i);
    l = k + (j - 1) * nn[1] + (i - 1) * nn[2] * nn[1];
    l = (l << 1) - 1;
    printf("%12.2f %12.2f %10.2f %12.2f %14.2f %12.2f\n", data2[l],
           data2[l + 1], data1[l], data1[l + 1], data2[l] / data1[l],
           data2[l + 1] / data1[l + 1]);
  }
  printf("\nThe product of transform lengths is: %4lu\n",
         nn[1] * nn[2] * nn[3]);
  free_vector(data2, 1, 1024);
  free_vector(data1, 1, 1024);
  free_lvector(nn, 1, 3);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0xffffffffffffffe9,-0x10(%rbp)
ff
movq   $0x2,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x3,%esi
call   1090 <lvector@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edi
mov    $0x400,%esi
call   1070 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    $0x1,%edi
mov    $0x400,%esi
call   1070 <vector@plt>
mov    %rax,-0x50(%rbp)
movq   $0x1,-0x18(%rbp)
cmpq   $0x3,-0x18(%rbp)
ja     1204 <main+0x94>
mov    -0x38(%rbp),%rdx
shl    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11d0 <main+0x60>
movq   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
cmp    0x18(%rcx),%rax
ja     133e <main+0x1ce>
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
cmp    0x10(%rcx),%rax
ja     1328 <main+0x1b8>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
cmp    0x8(%rcx),%rax
ja     1312 <main+0x1a2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x40(%rbp),%rdx
imul   0x8(%rdx),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x40(%rbp),%rdx
imul   0x10(%rdx),%rcx
mov    -0x40(%rbp),%rdx
imul   0x8(%rdx),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
lea    -0x10(%rbp),%rdi
call   1080 <ran1@plt>
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
lea    -0x10(%rbp),%rdi
call   1080 <ran1@plt>
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1240 <main+0xd0>
jmp    1317 <main+0x1a7>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1226 <main+0xb6>
jmp    132d <main+0x1bd>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    120c <main+0x9c>
movl   $0x1,-0x8(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x8(%rbp),%ecx
mov    $0x3,%edx
call   1030 <fourn@plt>
movl   $0xffffffff,-0x8(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x8(%rbp),%ecx
mov    $0x3,%edx
call   1030 <fourn@plt>
lea    0xc83(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xc96(%rip),%rdi
lea    0xc9f(%rip),%rsi
lea    0xca7(%rip),%rdx
lea    0xcae(%rip),%rcx
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xca6(%rip),%rdi
lea    0xcbf(%rip),%r9
lea    0xcbd(%rip),%rax
mov    %r9,%rsi
mov    %rax,%rdx
mov    %r9,%rcx
mov    %rax,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x1,-0x18(%rbp)
cmpq   $0x4,-0x18(%rbp)
ja     14e6 <main+0x376>
mov    -0x18(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x20(%rbp)
shl    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x40(%rbp),%rdx
imul   0x8(%rdx),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x40(%rbp),%rdx
imul   0x10(%rdx),%rcx
mov    -0x40(%rbp),%rdx
imul   0x8(%rdx),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm4
cvtss2sd %xmm4,%xmm4
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm5
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
divss  0x4(%rax,%rcx,4),%xmm5
cvtss2sd %xmm5,%xmm5
lea    0xbb1(%rip),%rdi
mov    $0x6,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    13db <main+0x26b>
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rsi
mov    -0x40(%rbp),%rax
imul   0x10(%rax),%rsi
mov    -0x40(%rbp),%rax
imul   0x18(%rax),%rsi
lea    0xba3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x50(%rbp),%rdi
mov    $0x1,%esi
mov    $0x400,%edx
call   1060 <free_vector@plt>
mov    -0x48(%rbp),%rdi
mov    $0x1,%esi
mov    $0x400,%edx
call   1060 <free_vector@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1040 <free_lvector@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movq   $0xffffffffffffffe9,0x40(%rsp)
ff ff
mov    $0x1,%edi
mov    $0x3,%esi
call   10a0 <lvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x400,%esi
call   1080 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x400,%esi
call   1080 <vector@plt>
mov    %rax,%rbp
movaps 0xe2c(%rip),%xmm0
movups %xmm0,0x8(%rbx)
movq   $0x10,0x18(%rbx)
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    $0x4,%eax
mov    $0x8,%r13d
mov    $0x10,%r8d
xor    %ecx,%ecx
mov    $0x8,%edx
mov    %r14,0x18(%rsp)
mov    %rbp,0x20(%rsp)
mov    %rbx,0x30(%rsp)
mov    0x18(%rsp),%r12
jmp    1247 <main+0xc7>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rbx),%r8
mov    %r13,%rdx
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%rdi
add    $0x1,%rdi
add    $0x1,%rcx
mov    %rdi,0x10(%rsp)
cmp    %r8,%rdi
ja     1317 <main+0x197>
test   %rdx,%rdx
je     1310 <main+0x190>
mov    $0x1,%edx
xor    %edi,%edi
jmp    1279 <main+0xf9>
nopl   0x0(%rax)
xor    %eax,%eax
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
add    $0x1,%rdi
cmp    %r13,%rdx
mov    0x20(%rsp),%rbp
ja     1220 <main+0xa0>
test   %rax,%rax
mov    %rdx,0x28(%rsp)
je     1260 <main+0xe0>
mov    $0x1,%r15d
mov    %rdi,0x38(%rsp)
xchg   %ax,%ax
imul   %rcx,%r13
add    %rdi,%r13
imul   %rax,%r13
add    %r15,%r13
lea    0x40(%rsp),%rbx
mov    %rbx,%rdi
mov    %rcx,%r14
call   1090 <ran1@plt>
add    %eax,%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x4(%r12,%r13,8)
mov    0x20(%rsp),%rbp
movss  %xmm0,-0x4(%rbp,%r13,8)
mov    %rbx,%rdi
call   1090 <ran1@plt>
mov    0x38(%rsp),%rdi
mov    %r14,%rcx
mov    0x30(%rsp),%rbx
lea    -0x1(%rax,%rax,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%r12,%r13,8)
movss  %xmm0,0x0(%rbp,%r13,8)
add    $0x1,%r15
mov    0x8(%rbx),%rax
mov    0x10(%rbx),%r13
cmp    %rax,%r15
jbe    1290 <main+0x110>
jmp    1262 <main+0xe2>
xor    %edx,%edx
jmp    122c <main+0xac>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1030 <fourn@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0xffffffff,%ecx
call   1030 <fourn@plt>
lea    0xd7d(%rip),%rdi
call   1040 <puts@plt>
lea    0xcbc(%rip),%rdi
lea    0xcc5(%rip),%rsi
lea    0xccd(%rip),%rdx
lea    0xcd4(%rip),%rcx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcf1(%rip),%rdx
mov    %rdx,(%rsp)
lea    0xcc1(%rip),%rdi
lea    0xcda(%rip),%rcx
mov    %rcx,%rsi
mov    %rdx,%r8
mov    %rcx,%r9
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x1c(%rbp,%rax,8),%xmm4
movss  0x20(%rbp,%rax,8),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
cvtss2sd %xmm5,%xmm1
movss  0x1c(%r14,%rax,8),%xmm6
movss  0x20(%r14,%rax,8),%xmm7
cvtss2sd %xmm6,%xmm2
cvtss2sd %xmm7,%xmm3
divss  %xmm6,%xmm4
cvtss2sd %xmm4,%xmm4
divss  %xmm7,%xmm5
cvtss2sd %xmm5,%xmm5
lea    0xc8d(%rip),%r15
mov    %r15,%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
add    $0x3,%rax
imul   0x8(%rbx),%rax
movss  0x3c(%rbp,%rax,8),%xmm4
movss  0x40(%rbp,%rax,8),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
movss  0x3c(%r14,%rax,8),%xmm6
movss  0x40(%r14,%rax,8),%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divss  %xmm6,%xmm4
cvtss2sd %xmm4,%xmm4
divss  %xmm7,%xmm5
cvtss2sd %xmm5,%xmm5
mov    %r15,%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
add    %rax,%rax
add    $0x5,%rax
imul   0x8(%rbx),%rax
movss  0x5c(%rbp,%rax,8),%xmm4
movss  0x60(%rbp,%rax,8),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
movss  0x5c(%r14,%rax,8),%xmm6
movss  0x60(%r14,%rax,8),%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divss  %xmm6,%xmm4
cvtss2sd %xmm4,%xmm4
divss  %xmm7,%xmm5
cvtss2sd %xmm5,%xmm5
mov    %r15,%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
lea    (%rax,%rax,2),%rax
add    $0x7,%rax
imul   0x8(%rbx),%rax
movss  0x7c(%rbp,%rax,8),%xmm4
movss  0x80(%rbp,%rax,8),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
movss  0x7c(%r14,%rax,8),%xmm6
movss  0x80(%r14,%rax,8),%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divss  %xmm6,%xmm4
cvtss2sd %xmm4,%xmm4
divss  %xmm7,%xmm5
cvtss2sd %xmm5,%xmm5
mov    %r15,%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rsi
imul   0x8(%rbx),%rsi
imul   0x18(%rbx),%rsi
lea    0xb75(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    $0x400,%edx
call   1070 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x400,%edx
call   1070 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1050 <free_lvector@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [33 x i8] c"Double 3-dimensional transform\0A\0A\00"
@.str.1 = [16 x i8] c"%22s %24s %20s\0A\00"
@.str.2 = [15 x i8] c"Double transf.\00"
@.str.3 = [14 x i8] c"Original data\00"
@.str.4 = [6 x i8] c"Ratio\00"
@.str.5 = [32 x i8] c"%10s %13s %12s %13s %11s %13s\0A\0A\00"
@.str.6 = [5 x i8] c"real\00"
@.str.7 = [6 x i8] c"imag.\00"
@.str.8 = [43 x i8] c"%12.2f %12.2f %10.2f %12.2f %14.2f %12.2f\0A\00"
@.str.9 = [44 x i8] c"\0AThe product of transform lengths is: %4lu\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i64
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64*
%10 = alloca float*
%11 = alloca float*
store i32 0, i32* %1
store i64 -23, i64* %3
store i64 2, i64* %8
%12 = call i64* @lvector(i32 1, i32 3)
store i64* %12, i64** %9
%13 = call float* @vector(i32 1, i32 1024)
store float* %13, float** %10
%14 = call float* @vector(i32 1, i32 1024)
store float* %14, float** %11
store i64 1, i64* %4
br label %15
15: ; preds = %24, %0
%16 = load i64, i64* %4
%17 = icmp ule i64 %16, 3
br i1 %17, label %18, label %27
18: ; preds = %15
%19 = load i64, i64* %8
%20 = shl i64 %19, 1
store i64 %20, i64* %8
%21 = load i64*, i64** %9
%22 = load i64, i64* %4
%23 = getelementptr inbounds i64, i64* %21, i64 %22
store i64 %20, i64* %23
br label %24
24: ; preds = %18
%25 = load i64, i64* %4
%26 = add i64 %25, 1
store i64 %26, i64* %4
br label %15
27: ; preds = %15
store i64 1, i64* %4
br label %28
28: ; preds = %101, %27
%29 = load i64, i64* %4
%30 = load i64*, i64** %9
%31 = getelementptr inbounds i64, i64* %30, i64 3
%32 = load i64, i64* %31
%33 = icmp ule i64 %29, %32
br i1 %33, label %34, label %104
34: ; preds = %28
store i64 1, i64* %5
br label %35
35: ; preds = %97, %34
%36 = load i64, i64* %5
%37 = load i64*, i64** %9
%38 = getelementptr inbounds i64, i64* %37, i64 2
%39 = load i64, i64* %38
%40 = icmp ule i64 %36, %39
br i1 %40, label %41, label %100
41: ; preds = %35
store i64 1, i64* %6
br label %42
42: ; preds = %93, %41
%43 = load i64, i64* %6
%44 = load i64*, i64** %9
%45 = getelementptr inbounds i64, i64* %44, i64 1
%46 = load i64, i64* %45
%47 = icmp ule i64 %43, %46
br i1 %47, label %48, label %96
48: ; preds = %42
%49 = load i64, i64* %6
%50 = load i64, i64* %5
%51 = sub i64 %50, 1
%52 = load i64*, i64** %9
%53 = getelementptr inbounds i64, i64* %52, i64 1
%54 = load i64, i64* %53
%55 = mul i64 %51, %54
%56 = add i64 %49, %55
%57 = load i64, i64* %4
%58 = sub i64 %57, 1
%59 = load i64*, i64** %9
%60 = getelementptr inbounds i64, i64* %59, i64 2
%61 = load i64, i64* %60
%62 = mul i64 %58, %61
%63 = load i64*, i64** %9
%64 = getelementptr inbounds i64, i64* %63, i64 1
%65 = load i64, i64* %64
%66 = mul i64 %62, %65
%67 = add i64 %56, %66
store i64 %67, i64* %7
%68 = load i64, i64* %7
%69 = shl i64 %68, 1
%70 = sub i64 %69, 1
store i64 %70, i64* %7
%71 = call i32 @ran1(i64* %3)
%72 = mul nsw i32 2, %71
%73 = sub nsw i32 %72, 1
%74 = sitofp i32 %73 to float
%75 = load float*, float** %10
%76 = load i64, i64* %7
%77 = getelementptr inbounds float, float* %75, i64 %76
store float %74, float* %77
%78 = load float*, float** %11
%79 = load i64, i64* %7
%80 = getelementptr inbounds float, float* %78, i64 %79
store float %74, float* %80
%81 = load i64, i64* %7
%82 = add i64 %81, 1
store i64 %82, i64* %7
%83 = call i32 @ran1(i64* %3)
%84 = mul nsw i32 2, %83
%85 = sub nsw i32 %84, 1
%86 = sitofp i32 %85 to float
%87 = load float*, float** %10
%88 = load i64, i64* %7
%89 = getelementptr inbounds float, float* %87, i64 %88
store float %86, float* %89
%90 = load float*, float** %11
%91 = load i64, i64* %7
%92 = getelementptr inbounds float, float* %90, i64 %91
store float %86, float* %92
br label %93
93: ; preds = %48
%94 = load i64, i64* %6
%95 = add i64 %94, 1
store i64 %95, i64* %6
br label %42
96: ; preds = %42
br label %97
97: ; preds = %96
%98 = load i64, i64* %5
%99 = add i64 %98, 1
store i64 %99, i64* %5
br label %35
100: ; preds = %35
br label %101
101: ; preds = %100
%102 = load i64, i64* %4
%103 = add i64 %102, 1
store i64 %103, i64* %4
br label %28
104: ; preds = %28
store i32 1, i32* %2
%105 = load float*, float** %11
%106 = load i64*, i64** %9
%107 = load i32, i32* %2
%108 = call i32 @fourn(float* %105, i64* %106, i32 3, i32 %107)
store i32 -1, i32* %2
%109 = load float*, float** %11
%110 = load i64*, i64** %9
%111 = load i32, i32* %2
%112 = call i32 @fourn(float* %109, i64* %110, i32 3, i32 %111)
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0))
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0))
store i64 1, i64* %4
br label %116
116: ; preds = %190, %104
%117 = load i64, i64* %4
%118 = icmp ule i64 %117, 4
br i1 %118, label %119, label %193
119: ; preds = %116
%120 = load i64, i64* %4
%121 = mul i64 2, %120
store i64 %121, i64* %5
%122 = mul i64 2, %121
store i64 %122, i64* %6
%123 = load i64, i64* %6
%124 = load i64, i64* %5
%125 = sub i64 %124, 1
%126 = load i64*, i64** %9
%127 = getelementptr inbounds i64, i64* %126, i64 1
%128 = load i64, i64* %127
%129 = mul i64 %125, %128
%130 = add i64 %123, %129
%131 = load i64, i64* %4
%132 = sub i64 %131, 1
%133 = load i64*, i64** %9
%134 = getelementptr inbounds i64, i64* %133, i64 2
%135 = load i64, i64* %134
%136 = mul i64 %132, %135
%137 = load i64*, i64** %9
%138 = getelementptr inbounds i64, i64* %137, i64 1
%139 = load i64, i64* %138
%140 = mul i64 %136, %139
%141 = add i64 %130, %140
store i64 %141, i64* %7
%142 = load i64, i64* %7
%143 = shl i64 %142, 1
%144 = sub i64 %143, 1
store i64 %144, i64* %7
%145 = load float*, float** %11
%146 = load i64, i64* %7
%147 = getelementptr inbounds float, float* %145, i64 %146
%148 = load float, float* %147
%149 = fpext float %148 to double
%150 = load float*, float** %11
%151 = load i64, i64* %7
%152 = add i64 %151, 1
%153 = getelementptr inbounds float, float* %150, i64 %152
%154 = load float, float* %153
%155 = fpext float %154 to double
%156 = load float*, float** %10
%157 = load i64, i64* %7
%158 = getelementptr inbounds float, float* %156, i64 %157
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = load float*, float** %10
%162 = load i64, i64* %7
%163 = add i64 %162, 1
%164 = getelementptr inbounds float, float* %161, i64 %163
%165 = load float, float* %164
%166 = fpext float %165 to double
%167 = load float*, float** %11
%168 = load i64, i64* %7
%169 = getelementptr inbounds float, float* %167, i64 %168
%170 = load float, float* %169
%171 = load float*, float** %10
%172 = load i64, i64* %7
%173 = getelementptr inbounds float, float* %171, i64 %172
%174 = load float, float* %173
%175 = fdiv float %170, %174
%176 = fpext float %175 to double
%177 = load float*, float** %11
%178 = load i64, i64* %7
%179 = add i64 %178, 1
%180 = getelementptr inbounds float, float* %177, i64 %179
%181 = load float, float* %180
%182 = load float*, float** %10
%183 = load i64, i64* %7
%184 = add i64 %183, 1
%185 = getelementptr inbounds float, float* %182, i64 %184
%186 = load float, float* %185
%187 = fdiv float %181, %186
%188 = fpext float %187 to double
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), double %149, double %155, double %160, double %166, double %176, double %188)
br label %190
190: ; preds = %119
%191 = load i64, i64* %4
%192 = add i64 %191, 1
store i64 %192, i64* %4
br label %116
193: ; preds = %116
%194 = load i64*, i64** %9
%195 = getelementptr inbounds i64, i64* %194, i64 1
%196 = load i64, i64* %195
%197 = load i64*, i64** %9
%198 = getelementptr inbounds i64, i64* %197, i64 2
%199 = load i64, i64* %198
%200 = mul i64 %196, %199
%201 = load i64*, i64** %9
%202 = getelementptr inbounds i64, i64* %201, i64 3
%203 = load i64, i64* %202
%204 = mul i64 %200, %203
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.9, i64 0, i64 0), i64 %204)
%206 = load float*, float** %11
%207 = call i32 @free_vector(float* %206, i32 1, i32 1024)
%208 = load float*, float** %10
%209 = call i32 @free_vector(float* %208, i32 1, i32 1024)
%210 = load i64*, i64** %9
%211 = call i32 @free_lvector(i64* %210, i32 1, i32 3)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [16 x i8] c"%22s %24s %20s\0A\00"
@.str.2 = [15 x i8] c"Double transf.\00"
@.str.3 = [14 x i8] c"Original data\00"
@.str.4 = [6 x i8] c"Ratio\00"
@.str.5 = [32 x i8] c"%10s %13s %12s %13s %11s %13s\0A\0A\00"
@.str.6 = [5 x i8] c"real\00"
@.str.7 = [6 x i8] c"imag.\00"
@.str.8 = [43 x i8] c"%12.2f %12.2f %10.2f %12.2f %14.2f %12.2f\0A\00"
@.str.9 = [44 x i8] c"\0AThe product of transform lengths is: %4lu\0A\00"
@str = [32 x i8] c"Double 3-dimensional transform\0A\00"
define i32 @main() {
%1 = alloca i64
%2 = bitcast i64* %1 to i8*
store i64 -23, i64* %1
%3 = tail call i64* @lvector(i32 1, i32 3)
%4 = tail call float* @vector(i32 1, i32 1024)
%5 = tail call float* @vector(i32 1, i32 1024)
%6 = getelementptr inbounds i64, i64* %3, i64 1
%7 = getelementptr inbounds i64, i64* %3, i64 2
%8 = bitcast i64* %6 to <2 x i64>*
store <2 x i64> <i64 4, i64 8>, <2 x i64>* %8
%9 = getelementptr inbounds i64, i64* %3, i64 3
store i64 16, i64* %9
br label %10
10: ; preds = %0, %61
%11 = phi i64 [ 16, %0 ], [ %62, %61 ]
%12 = phi i64 [ 8, %0 ], [ %63, %61 ]
%13 = phi i64 [ 8, %0 ], [ %64, %61 ]
%14 = phi i64 [ 4, %0 ], [ %65, %61 ]
%15 = phi i64 [ 8, %0 ], [ %66, %61 ]
%16 = phi i64 [ 1, %0 ], [ %67, %61 ]
%17 = icmp eq i64 %15, 0
br i1 %17, label %61, label %18
18: ; preds = %10
%19 = add i64 %16, -1
br label %20
20: ; preds = %18, %54
%21 = phi i64 [ %12, %18 ], [ %55, %54 ]
%22 = phi i64 [ %13, %18 ], [ %55, %54 ]
%23 = phi i64 [ %14, %18 ], [ %56, %54 ]
%24 = phi i64 [ 1, %18 ], [ %57, %54 ]
%25 = icmp eq i64 %23, 0
br i1 %25, label %54, label %26
26: ; preds = %20
%27 = add i64 %24, -1
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ %22, %26 ], [ %53, %28 ]
%30 = phi i64 [ %23, %26 ], [ %51, %28 ]
%31 = phi i64 [ 1, %26 ], [ %50, %28 ]
%32 = mul i64 %29, %19
%33 = add i64 %27, %32
%34 = mul i64 %33, %30
%35 = add i64 %34, %31
%36 = shl i64 %35, 1
%37 = add i64 %36, -1
%38 = call i32 @ran1(i64* %1)
%39 = shl nsw i32 %38, 1
%40 = add nsw i32 %39, -1
%41 = sitofp i32 %40 to float
%42 = getelementptr inbounds float, float* %4, i64 %37
store float %41, float* %42
%43 = getelementptr inbounds float, float* %5, i64 %37
store float %41, float* %43
%44 = call i32 @ran1(i64* %1)
%45 = shl nsw i32 %44, 1
%46 = add nsw i32 %45, -1
%47 = sitofp i32 %46 to float
%48 = getelementptr inbounds float, float* %4, i64 %36
store float %47, float* %48
%49 = getelementptr inbounds float, float* %5, i64 %36
store float %47, float* %49
%50 = add i64 %31, 1
%51 = load i64, i64* %6
%52 = icmp ugt i64 %50, %51
%53 = load i64, i64* %7
br i1 %52, label %54, label %28
54: ; preds = %28, %20
%55 = phi i64 [ %21, %20 ], [ %53, %28 ]
%56 = phi i64 [ 0, %20 ], [ %51, %28 ]
%57 = add i64 %24, 1
%58 = icmp ugt i64 %57, %55
br i1 %58, label %59, label %20
59: ; preds = %54
%60 = load i64, i64* %9
br label %61
61: ; preds = %59, %10
%62 = phi i64 [ %60, %59 ], [ %11, %10 ]
%63 = phi i64 [ %55, %59 ], [ %12, %10 ]
%64 = phi i64 [ %55, %59 ], [ %13, %10 ]
%65 = phi i64 [ %56, %59 ], [ %14, %10 ]
%66 = phi i64 [ %55, %59 ], [ 0, %10 ]
%67 = add i64 %16, 1
%68 = icmp ugt i64 %67, %62
br i1 %68, label %69, label %10
69: ; preds = %61
%70 = call i32 @fourn(float* %5, i64* %3, i32 3, i32 1)
%71 = call i32 @fourn(float* %5, i64* %3, i32 3, i32 -1)
%72 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str, i64 0, i64 0))
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0))
%74 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0))
%75 = load i64, i64* %6
%76 = shl i64 %75, 1
%77 = add i64 %76, 8
%78 = add i64 %76, 7
%79 = getelementptr inbounds float, float* %5, i64 %78
%80 = load float, float* %79
%81 = fpext float %80 to double
%82 = getelementptr inbounds float, float* %5, i64 %77
%83 = load float, float* %82
%84 = fpext float %83 to double
%85 = getelementptr inbounds float, float* %4, i64 %78
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = getelementptr inbounds float, float* %4, i64 %77
%89 = load float, float* %88
%90 = fpext float %89 to double
%91 = fdiv float %80, %86
%92 = fpext float %91 to double
%93 = fdiv float %83, %89
%94 = fpext float %93 to double
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), double %81, double %84, double %87, double %90, double %92, double %94)
%96 = load i64, i64* %6
%97 = load i64, i64* %7
%98 = add i64 %97, 3
%99 = mul i64 %98, %96
%100 = shl i64 %99, 1
%101 = add i64 %100, 16
%102 = add i64 %100, 15
%103 = getelementptr inbounds float, float* %5, i64 %102
%104 = load float, float* %103
%105 = fpext float %104 to double
%106 = getelementptr inbounds float, float* %5, i64 %101
%107 = load float, float* %106
%108 = fpext float %107 to double
%109 = getelementptr inbounds float, float* %4, i64 %102
%110 = load float, float* %109
%111 = fpext float %110 to double
%112 = getelementptr inbounds float, float* %4, i64 %101
%113 = load float, float* %112
%114 = fpext float %113 to double
%115 = fdiv float %104, %110
%116 = fpext float %115 to double
%117 = fdiv float %107, %113
%118 = fpext float %117 to double
%119 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), double %105, double %108, double %111, double %114, double %116, double %118)
%120 = load i64, i64* %6
%121 = load i64, i64* %7
%122 = shl i64 %121, 1
%123 = add i64 %122, 5
%124 = mul i64 %123, %120
%125 = shl i64 %124, 1
%126 = add i64 %125, 24
%127 = add i64 %125, 23
%128 = getelementptr inbounds float, float* %5, i64 %127
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = getelementptr inbounds float, float* %5, i64 %126
%132 = load float, float* %131
%133 = fpext float %132 to double
%134 = getelementptr inbounds float, float* %4, i64 %127
%135 = load float, float* %134
%136 = fpext float %135 to double
%137 = getelementptr inbounds float, float* %4, i64 %126
%138 = load float, float* %137
%139 = fpext float %138 to double
%140 = fdiv float %129, %135
%141 = fpext float %140 to double
%142 = fdiv float %132, %138
%143 = fpext float %142 to double
%144 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), double %130, double %133, double %136, double %139, double %141, double %143)
%145 = load i64, i64* %6
%146 = load i64, i64* %7
%147 = mul i64 %146, 3
%148 = add i64 %147, 7
%149 = mul i64 %148, %145
%150 = shl i64 %149, 1
%151 = add i64 %150, 32
%152 = add i64 %150, 31
%153 = getelementptr inbounds float, float* %5, i64 %152
%154 = load float, float* %153
%155 = fpext float %154 to double
%156 = getelementptr inbounds float, float* %5, i64 %151
%157 = load float, float* %156
%158 = fpext float %157 to double
%159 = getelementptr inbounds float, float* %4, i64 %152
%160 = load float, float* %159
%161 = fpext float %160 to double
%162 = getelementptr inbounds float, float* %4, i64 %151
%163 = load float, float* %162
%164 = fpext float %163 to double
%165 = fdiv float %154, %160
%166 = fpext float %165 to double
%167 = fdiv float %157, %163
%168 = fpext float %167 to double
%169 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), double %155, double %158, double %161, double %164, double %166, double %168)
%170 = load i64, i64* %6
%171 = load i64, i64* %7
%172 = mul i64 %171, %170
%173 = load i64, i64* %9
%174 = mul i64 %172, %173
%175 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.9, i64 0, i64 0), i64 %174)
%176 = call i32 @free_vector(float* %5, i32 1, i32 1024)
%177 = call i32 @free_vector(float* %4, i32 1, i32 1024)
%178 = call i32 @free_lvector(i64* %3, i32 1, i32 3)
ret i32 0
}