#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 */
unsigned long compare(char *, float ***, float ***, unsigned long,
                      unsigned long, unsigned long, double);
float ***f3tensor(int, unsigned long, int, unsigned long, int, unsigned long);
int /*<<< orphan*/ free_f3tensor(float ***, int, unsigned long, int,
                                 unsigned long, int, unsigned long);
int /*<<< orphan*/ free_matrix(float **, int, unsigned long, int,
                               unsigned long);
float **matrix(int, unsigned long, int, unsigned long);
int /*<<< orphan*/ printf(char *, double);
int ran1(long *);
int /*<<< orphan*/ rlft3(float ***, float **, unsigned long, unsigned long,
                         unsigned long, int);
int main(void) {
  long idum = (-3);
  unsigned long err, i, j, k, nn1 = 32, nn2 = 8, nn3 = 16;
  float fnorm, ***data1, ***data2, **speq1;
  fnorm = (float)nn1 * (float)nn2 * (float)nn3 / 2.0;
  data1 = f3tensor(1, nn1, 1, nn2, 1, nn3);
  data2 = f3tensor(1, nn1, 1, nn2, 1, nn3);
  speq1 = matrix(1, nn1, 1, nn2 << 1);
  for (i = 1; i <= nn1; i++)
    for (j = 1; j <= nn2; j++)
      for (k = 1; k <= nn3; k++)
        data2[i][j][k] = fnorm * (data1[i][j][k] = 2 * ran1(&idum) - 1);
  rlft3(data1, speq1, nn1, nn2, nn3, 1);
  rlft3(data1, speq1, nn1, nn2, nn3, -1);
  err = compare("data", data1, data2, nn1, nn2, nn3, 0.0008);
  if (err) {
    printf("Comparison error at tolerance %12.6f\n", 0.0008);
    printf("Total number of errors is %d\n", err);
  } else {
    printf("Data compares OK to tolerance %12.6f\n", 0.0008);
  }
  free_matrix(speq1, 1, nn1, 1, nn2 << 1);
  free_f3tensor(data2, 1, nn1, 1, nn2, 1, nn3);
  free_f3tensor(data1, 1, nn1, 1, nn2, 1, nn3);
  return (err > 0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0xfffffffffffffffd,-0x10(%rbp)
ff
movq   $0x20,-0x38(%rbp)
movq   $0x8,-0x40(%rbp)
movq   $0x10,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x70(%rbp)
test   %rax,%rax
movss  %xmm0,-0x6c(%rbp)
js     11ef <main+0x6f>
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x78(%rbp)
test   %rax,%rax
movss  %xmm0,-0x74(%rbp)
js     1236 <main+0xb6>
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x74(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x84(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x80(%rbp)
js     128f <main+0x10f>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd54(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r9
mov    $0x1,%r8d
mov    %r8d,%edi
mov    %r8d,%edx
call   1040 <f3tensor@plt>
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r9
mov    $0x1,%r8d
mov    %r8d,%edi
mov    %r8d,%edx
call   1040 <f3tensor@plt>
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <matrix@plt>
mov    %rax,-0x68(%rbp)
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x38(%rbp),%rax
ja     13fc <main+0x27c>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x40(%rbp),%rax
ja     13e6 <main+0x266>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
ja     13d0 <main+0x250>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
lea    -0x10(%rbp),%rdi
call   1080 <ran1@plt>
movss  -0x8c(%rbp),%xmm0
ff
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm1,(%rax,%rcx,4)
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    134b <main+0x1cb>
jmp    13d5 <main+0x255>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1335 <main+0x1b5>
jmp    13eb <main+0x26b>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    131f <main+0x19f>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    $0x1,%r9d
call   1030 <rlft3@plt>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    $0xffffffff,%r9d
call   1030 <rlft3@plt>
mov    -0x58(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%r8
mov    -0x48(%rbp),%r9
lea    0xbdb(%rip),%rdi
movsd  0xbab(%rip),%xmm0
call   1090 <compare@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     14bd <main+0x33d>
lea    0xbbd(%rip),%rdi
movsd  0xb88(%rip),%xmm0
call   1060 <printf@plt>
movaps 0xb84(%rip),%xmm1
movq   -0x18(%rbp),%xmm0
punpckldq %xmm1,%xmm0
movapd 0xb83(%rip),%xmm1
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
lea    0xba8(%rip),%rdi
call   1060 <printf@plt>
jmp    14d1 <main+0x351>
lea    0xbb5(%rip),%rdi
movsd  0xb3c(%rip),%xmm0
call   1060 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%r8
shl    $0x1,%r8
mov    $0x1,%ecx
mov    %ecx,%esi
call   1050 <free_matrix@plt>
mov    -0x60(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%r8
mov    -0x48(%rbp),%rax
mov    $0x1,%r9d
mov    %r9d,%esi
mov    %r9d,%ecx
mov    %rax,(%rsp)
call   10a0 <free_f3tensor@plt>
mov    -0x58(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%r8
mov    -0x48(%rbp),%rax
mov    $0x1,%r9d
mov    %r9d,%esi
mov    %r9d,%ecx
mov    %rax,(%rsp)
call   10a0 <free_f3tensor@plt>
cmpq   $0x0,-0x18(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movq   $0xfffffffffffffffd,0x10(%rsp)
ff ff
mov    $0x20,%esi
mov    $0x8,%ecx
mov    $0x10,%r9d
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%r8d
call   1040 <f3tensor@plt>
mov    %rax,%r14
mov    $0x20,%esi
mov    $0x8,%ecx
mov    $0x10,%r9d
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%r8d
call   1040 <f3tensor@plt>
mov    %rax,%r13
mov    $0x20,%esi
mov    $0x10,%ecx
mov    $0x1,%edi
mov    $0x1,%edx
call   1070 <matrix@plt>
mov    %rax,0x8(%rsp)
mov    $0x1,%ebx
lea    0x10(%rsp),%r12
nop
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12,%rdi
call   1080 <ran1@plt>
movss  0xdc0(%rip),%xmm1
add    %eax,%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r14,%rbx,8),%rax
mov    (%rax,%rbp,8),%rax
movss  %xmm0,0x4(%rax,%r15,4)
mulss  %xmm1,%xmm0
mov    0x0(%r13,%rbx,8),%rax
mov    (%rax,%rbp,8),%rax
movss  %xmm0,0x4(%rax,%r15,4)
add    $0x1,%r15
cmp    $0x10,%r15
jne    1230 <main+0xb0>
add    $0x1,%rbp
cmp    $0x9,%rbp
jne    1220 <main+0xa0>
add    $0x1,%rbx
cmp    $0x21,%rbx
jne    1210 <main+0x90>
mov    $0x20,%edx
mov    $0x8,%ecx
mov    $0x10,%r8d
mov    %r14,%rdi
mov    0x8(%rsp),%rbx
mov    %rbx,%rsi
mov    $0x1,%r9d
call   1030 <rlft3@plt>
mov    $0x20,%edx
mov    $0x8,%ecx
mov    $0x10,%r8d
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0xffffffff,%r9d
call   1030 <rlft3@plt>
lea    0xd55(%rip),%rdi
movsd  0xd25(%rip),%xmm0
mov    $0x20,%ecx
mov    $0x8,%r8d
mov    $0x10,%r9d
mov    %r14,%rsi
mov    %r13,%rdx
call   1090 <compare@plt>
mov    %rax,%r12
test   %rax,%rax
je     1345 <main+0x1c5>
lea    0xd27(%rip),%rdi
movsd  0xcf2(%rip),%xmm0
call   1060 <printf@plt>
movq   %r12,%xmm1
punpckldq 0xce8(%rip),%xmm1
subpd  0xcf0(%rip),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
lea    0xd18(%rip),%rdi
jmp    1354 <main+0x1d4>
lea    0xd2d(%rip),%rdi
movsd  0xcb4(%rip),%xmm0
call   1060 <printf@plt>
mov    $0x20,%edx
mov    $0x10,%r8d
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%ecx
call   1050 <free_matrix@plt>
movq   $0x10,(%rsp)
mov    $0x20,%edx
mov    $0x8,%r8d
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r9d
call   10a0 <free_f3tensor@plt>
movq   $0x10,(%rsp)
mov    $0x20,%edx
mov    $0x8,%r8d
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r9d
call   10a0 <free_f3tensor@plt>
xor    %eax,%eax
test   %r12,%r12
setne  %al
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"data\00"
@.str.1 = [38 x i8] c"Comparison error at tolerance %12.6f\0A\00"
@.str.2 = [30 x i8] c"Total number of errors is %d\0A\00"
@.str.3 = [38 x i8] c"Data compares OK to tolerance %12.6f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i64
%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***
%12 = alloca float***
%13 = alloca float**
store i32 0, i32* %1
store i64 -3, i64* %2
store i64 32, i64* %7
store i64 8, i64* %8
store i64 16, i64* %9
%14 = load i64, i64* %7
%15 = uitofp i64 %14 to float
%16 = load i64, i64* %8
%17 = uitofp i64 %16 to float
%18 = fmul float %15, %17
%19 = load i64, i64* %9
%20 = uitofp i64 %19 to float
%21 = fmul float %18, %20
%22 = fpext float %21 to double
%23 = fdiv double %22, 2.000000e+00
%24 = fptrunc double %23 to float
store float %24, float* %10
%25 = load i64, i64* %7
%26 = load i64, i64* %8
%27 = load i64, i64* %9
%28 = call float*** @f3tensor(i32 1, i64 %25, i32 1, i64 %26, i32 1, i64 %27)
store float*** %28, float**** %11
%29 = load i64, i64* %7
%30 = load i64, i64* %8
%31 = load i64, i64* %9
%32 = call float*** @f3tensor(i32 1, i64 %29, i32 1, i64 %30, i32 1, i64 %31)
store float*** %32, float**** %12
%33 = load i64, i64* %7
%34 = load i64, i64* %8
%35 = shl i64 %34, 1
%36 = call float** @matrix(i32 1, i64 %33, i32 1, i64 %35)
store float** %36, float*** %13
store i64 1, i64* %4
br label %37
37: ; preds = %84, %0
%38 = load i64, i64* %4
%39 = load i64, i64* %7
%40 = icmp ule i64 %38, %39
br i1 %40, label %41, label %87
41: ; preds = %37
store i64 1, i64* %5
br label %42
42: ; preds = %80, %41
%43 = load i64, i64* %5
%44 = load i64, i64* %8
%45 = icmp ule i64 %43, %44
br i1 %45, label %46, label %83
46: ; preds = %42
store i64 1, i64* %6
br label %47
47: ; preds = %76, %46
%48 = load i64, i64* %6
%49 = load i64, i64* %9
%50 = icmp ule i64 %48, %49
br i1 %50, label %51, label %79
51: ; preds = %47
%52 = load float, float* %10
%53 = call i32 @ran1(i64* %2)
%54 = mul nsw i32 2, %53
%55 = sub nsw i32 %54, 1
%56 = sitofp i32 %55 to float
%57 = load float***, float**** %11
%58 = load i64, i64* %4
%59 = getelementptr inbounds float**, float*** %57, i64 %58
%60 = load float**, float*** %59
%61 = load i64, i64* %5
%62 = getelementptr inbounds float*, float** %60, i64 %61
%63 = load float*, float** %62
%64 = load i64, i64* %6
%65 = getelementptr inbounds float, float* %63, i64 %64
store float %56, float* %65
%66 = fmul float %52, %56
%67 = load float***, float**** %12
%68 = load i64, i64* %4
%69 = getelementptr inbounds float**, float*** %67, i64 %68
%70 = load float**, float*** %69
%71 = load i64, i64* %5
%72 = getelementptr inbounds float*, float** %70, i64 %71
%73 = load float*, float** %72
%74 = load i64, i64* %6
%75 = getelementptr inbounds float, float* %73, i64 %74
store float %66, float* %75
br label %76
76: ; preds = %51
%77 = load i64, i64* %6
%78 = add i64 %77, 1
store i64 %78, i64* %6
br label %47
79: ; preds = %47
br label %80
80: ; preds = %79
%81 = load i64, i64* %5
%82 = add i64 %81, 1
store i64 %82, i64* %5
br label %42
83: ; preds = %42
br label %84
84: ; preds = %83
%85 = load i64, i64* %4
%86 = add i64 %85, 1
store i64 %86, i64* %4
br label %37
87: ; preds = %37
%88 = load float***, float**** %11
%89 = load float**, float*** %13
%90 = load i64, i64* %7
%91 = load i64, i64* %8
%92 = load i64, i64* %9
%93 = call i32 @rlft3(float*** %88, float** %89, i64 %90, i64 %91, i64 %92, i32 1)
%94 = load float***, float**** %11
%95 = load float**, float*** %13
%96 = load i64, i64* %7
%97 = load i64, i64* %8
%98 = load i64, i64* %9
%99 = call i32 @rlft3(float*** %94, float** %95, i64 %96, i64 %97, i64 %98, i32 -1)
%100 = load float***, float**** %11
%101 = load float***, float**** %12
%102 = load i64, i64* %7
%103 = load i64, i64* %8
%104 = load i64, i64* %9
%105 = call i64 @compare(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), float*** %100, float*** %101, i64 %102, i64 %103, i64 %104, double 8.000000e-04)
store i64 %105, i64* %3
%106 = load i64, i64* %3
%107 = icmp ne i64 %106, 0
br i1 %107, label %108, label %113
108: ; preds = %87
%109 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.1, i64 0, i64 0), double 8.000000e-04)
%110 = load i64, i64* %3
%111 = uitofp i64 %110 to double
%112 = call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double %111)
br label %115
113: ; preds = %87
%114 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), double 8.000000e-04)
br label %115
115: ; preds = %113, %108
%116 = load float**, float*** %13
%117 = load i64, i64* %7
%118 = load i64, i64* %8
%119 = shl i64 %118, 1
%120 = call i32 @free_matrix(float** %116, i32 1, i64 %117, i32 1, i64 %119)
%121 = load float***, float**** %12
%122 = load i64, i64* %7
%123 = load i64, i64* %8
%124 = load i64, i64* %9
%125 = call i32 @free_f3tensor(float*** %121, i32 1, i64 %122, i32 1, i64 %123, i32 1, i64 %124)
%126 = load float***, float**** %11
%127 = load i64, i64* %7
%128 = load i64, i64* %8
%129 = load i64, i64* %9
%130 = call i32 @free_f3tensor(float*** %126, i32 1, i64 %127, i32 1, i64 %128, i32 1, i64 %129)
%131 = load i64, i64* %3
%132 = icmp ugt i64 %131, 0
%133 = zext i1 %132 to i32
ret i32 %133
}

LLVM IR (-O2):
@.str = [5 x i8] c"data\00"
@.str.1 = [38 x i8] c"Comparison error at tolerance %12.6f\0A\00"
@.str.2 = [30 x i8] c"Total number of errors is %d\0A\00"
@.str.3 = [38 x i8] c"Data compares OK to tolerance %12.6f\0A\00"
define i32 @main() {
%1 = alloca i64
%2 = bitcast i64* %1 to i8*
store i64 -3, i64* %1
%3 = tail call float*** @f3tensor(i32 1, i64 32, i32 1, i64 8, i32 1, i64 16)
%4 = tail call float*** @f3tensor(i32 1, i64 32, i32 1, i64 8, i32 1, i64 16)
%5 = tail call float** @matrix(i32 1, i64 32, i32 1, i64 16)
br label %6
6: ; preds = %0, %32
%7 = phi i64 [ 1, %0 ], [ %33, %32 ]
%8 = getelementptr inbounds float**, float*** %3, i64 %7
%9 = getelementptr inbounds float**, float*** %4, i64 %7
br label %10
10: ; preds = %6, %29
%11 = phi i64 [ 1, %6 ], [ %30, %29 ]
br label %12
12: ; preds = %10, %12
%13 = phi i64 [ 1, %10 ], [ %27, %12 ]
%14 = call i32 @ran1(i64* %1)
%15 = shl nsw i32 %14, 1
%16 = add nsw i32 %15, -1
%17 = sitofp i32 %16 to float
%18 = load float**, float*** %8
%19 = getelementptr inbounds float*, float** %18, i64 %11
%20 = load float*, float** %19
%21 = getelementptr inbounds float, float* %20, i64 %13
store float %17, float* %21
%22 = fmul float %17, 2.048000e+03
%23 = load float**, float*** %9
%24 = getelementptr inbounds float*, float** %23, i64 %11
%25 = load float*, float** %24
%26 = getelementptr inbounds float, float* %25, i64 %13
store float %22, float* %26
%27 = add nuw nsw i64 %13, 1
%28 = icmp eq i64 %27, 17
br i1 %28, label %29, label %12
29: ; preds = %12
%30 = add nuw nsw i64 %11, 1
%31 = icmp eq i64 %30, 9
br i1 %31, label %32, label %10
32: ; preds = %29
%33 = add nuw nsw i64 %7, 1
%34 = icmp eq i64 %33, 33
br i1 %34, label %35, label %6
35: ; preds = %32
%36 = call i32 @rlft3(float*** %3, float** %5, i64 32, i64 8, i64 16, i32 1)
%37 = call i32 @rlft3(float*** %3, float** %5, i64 32, i64 8, i64 16, i32 -1)
%38 = call i64 @compare(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), float*** %3, float*** %4, i64 32, i64 8, i64 16, double 8.000000e-04)
%39 = icmp eq i64 %38, 0
br i1 %39, label %44, label %40
40: ; preds = %35
%41 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.1, i64 0, i64 0), double 8.000000e-04)
%42 = uitofp i64 %38 to double
%43 = call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double %42)
br label %46
44: ; preds = %35
%45 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), double 8.000000e-04)
br label %46
46: ; preds = %44, %40
%47 = call i32 @free_matrix(float** %5, i32 1, i64 32, i32 1, i64 16)
%48 = call i32 @free_f3tensor(float*** %4, i32 1, i64 32, i32 1, i64 8, i32 1, i64 16)
%49 = call i32 @free_f3tensor(float*** %3, i32 1, i64 32, i32 1, i64 8, i32 1, i64 16)
%50 = icmp ne i64 %38, 0
%51 = zext i1 %50 to i32
ret i32 %51
}