#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*/ calculateFlatnessMeasure(float *, char *, float *, float *,
                                            unsigned char const *, int);
int /*<<< orphan*/ diff(float *, float *, unsigned char const *, int, char *);
int /*<<< orphan*/ memcpy(float *, float *, int);
void calculateDetectorInput(float **pQuotaBuffer, char *indexVector,
                            float **tonalityDiff, float **pSfmOrig,
                            float **pSfmSbr, const unsigned char *freqBandTable,
                            int nSfb, int noEstPerFrame, int move,
                            int noQmfBands) {
  int est;
  ;
  ;
  for (est = 0; est < move; est++) {
    ;
    ;
    ;
    ;
    ;
    memcpy(tonalityDiff[est], tonalityDiff[est + noEstPerFrame],
           noQmfBands * sizeof(float));
    ;
    ;
    ;
    ;
    ;
    memcpy(pSfmOrig[est], pSfmOrig[est + noEstPerFrame],
           noQmfBands * sizeof(float));
    ;
    ;
    ;
    ;
    ;
    memcpy(pSfmSbr[est], pSfmSbr[est + noEstPerFrame],
           noQmfBands * sizeof(float));
  };
  ;
  for (est = 0; est < noEstPerFrame; est++) {
    ;
    diff(pQuotaBuffer[est + move], tonalityDiff[est + move], freqBandTable,
         nSfb, indexVector);
    ;
    calculateFlatnessMeasure(pQuotaBuffer[est + move], indexVector,
                             pSfmOrig[est + move], pSfmSbr[est + move],
                             freqBandTable, nSfb);
  };
}


x86 assembly (clang, -O0):
<calculateDetectorInput>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1201 <calculateDetectorInput+0xd1>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq 0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq 0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq 0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1163 <calculateDetectorInput+0x33>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1298 <calculateDetectorInput+0x168>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x30(%rbp),%rdx
mov    0x10(%rbp),%ecx
mov    -0x10(%rbp),%r8
call   1050 <diff@plt>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x30(%rbp),%r8
mov    0x10(%rbp),%r9d
call   1030 <calculateFlatnessMeasure@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1208 <calculateDetectorInput+0xd8>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculateDetectorInput>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x18(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rdx,%rcx
mov    %rsi,0x20(%rsp)
mov    %rdi,0x10(%rsp)
cmpl   $0x0,0x80(%rsp)
jle    11de <calculateDetectorInput+0xae>
mov    0x88(%rsp),%ebp
shl    $0x2,%ebp
movslq 0x78(%rsp),%rax
lea    (%rcx,%rax,8),%r12
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%r13
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rbx,8),%rdi
mov    (%r12,%rbx,8),%rsi
mov    %ebp,%edx
mov    %rcx,%r14
call   1040 <memcpy@plt>
mov    0x8(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
mov    0x0(%r13,%rbx,8),%rsi
mov    %ebp,%edx
call   1040 <memcpy@plt>
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
mov    (%r15,%rbx,8),%rsi
mov    %ebp,%edx
call   1040 <memcpy@plt>
mov    %r14,%rcx
add    $0x1,%rbx
mov    0x80(%rsp),%eax
cmp    %rbx,%rax
jne    1190 <calculateDetectorInput+0x60>
mov    0x8(%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x78(%rsp),%edi
test   %edi,%edi
mov    0x28(%rsp),%r14
mov    0x20(%rsp),%r13
jle    127a <calculateDetectorInput+0x14a>
movslq 0x80(%rsp),%rax
mov    %edi,%edi
mov    %rdi,0x30(%rsp)
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,8),%rbp
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x10(%rsp)
lea    (%rdx,%rax,8),%rcx
mov    %rcx,0x8(%rsp)
lea    (%rsi,%rax,8),%r15
xor    %r12d,%r12d
nop
mov    0x0(%rbp,%r12,8),%rdi
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rsi
mov    %r14,%rdx
mov    0x70(%rsp),%ebx
mov    %ebx,%ecx
mov    %r13,%r8
call   1050 <diff@plt>
mov    0x0(%rbp,%r12,8),%rdi
mov    0x8(%rsp),%rax
mov    (%rax,%r12,8),%rdx
mov    (%r15,%r12,8),%rcx
mov    %r13,%rsi
mov    %r14,%r8
mov    %ebx,%r9d
call   1030 <calculateFlatnessMeasure@plt>
add    $0x1,%r12
cmp    %r12,0x30(%rsp)
jne    1230 <calculateDetectorInput+0x100>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @calculateDetectorInput(float** %0, i8* %1, float** %2, float** %3, float** %4, i8* %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = alloca float**
%12 = alloca i8*
%13 = alloca float**
%14 = alloca float**
%15 = alloca float**
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store float** %0, float*** %11
store i8* %1, i8** %12
store float** %2, float*** %13
store float** %3, float*** %14
store float** %4, float*** %15
store i8* %5, i8** %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i32 %9, i32* %20
store i32 0, i32* %21
br label %22
22: ; preds = %78, %10
%23 = load i32, i32* %21
%24 = load i32, i32* %19
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %81
26: ; preds = %22
%27 = load float**, float*** %13
%28 = load i32, i32* %21
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float*, float** %27, i64 %29
%31 = load float*, float** %30
%32 = load float**, float*** %13
%33 = load i32, i32* %21
%34 = load i32, i32* %18
%35 = add nsw i32 %33, %34
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float*, float** %32, i64 %36
%38 = load float*, float** %37
%39 = load i32, i32* %20
%40 = sext i32 %39 to i64
%41 = mul i64 %40, 4
%42 = trunc i64 %41 to i32
%43 = call i32 @memcpy(float* %31, float* %38, i32 %42)
%44 = load float**, float*** %14
%45 = load i32, i32* %21
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float*, float** %44, i64 %46
%48 = load float*, float** %47
%49 = load float**, float*** %14
%50 = load i32, i32* %21
%51 = load i32, i32* %18
%52 = add nsw i32 %50, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float*, float** %49, i64 %53
%55 = load float*, float** %54
%56 = load i32, i32* %20
%57 = sext i32 %56 to i64
%58 = mul i64 %57, 4
%59 = trunc i64 %58 to i32
%60 = call i32 @memcpy(float* %48, float* %55, i32 %59)
%61 = load float**, float*** %15
%62 = load i32, i32* %21
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float*, float** %61, i64 %63
%65 = load float*, float** %64
%66 = load float**, float*** %15
%67 = load i32, i32* %21
%68 = load i32, i32* %18
%69 = add nsw i32 %67, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float*, float** %66, i64 %70
%72 = load float*, float** %71
%73 = load i32, i32* %20
%74 = sext i32 %73 to i64
%75 = mul i64 %74, 4
%76 = trunc i64 %75 to i32
%77 = call i32 @memcpy(float* %65, float* %72, i32 %76)
br label %78
78: ; preds = %26
%79 = load i32, i32* %21
%80 = add nsw i32 %79, 1
store i32 %80, i32* %21
br label %22
81: ; preds = %22
store i32 0, i32* %21
br label %82
82: ; preds = %130, %81
%83 = load i32, i32* %21
%84 = load i32, i32* %18
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %133
86: ; preds = %82
%87 = load float**, float*** %11
%88 = load i32, i32* %21
%89 = load i32, i32* %19
%90 = add nsw i32 %88, %89
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float*, float** %87, i64 %91
%93 = load float*, float** %92
%94 = load float**, float*** %13
%95 = load i32, i32* %21
%96 = load i32, i32* %19
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float*, float** %94, i64 %98
%100 = load float*, float** %99
%101 = load i8*, i8** %16
%102 = load i32, i32* %17
%103 = load i8*, i8** %12
%104 = call i32 @diff(float* %93, float* %100, i8* %101, i32 %102, i8* %103)
%105 = load float**, float*** %11
%106 = load i32, i32* %21
%107 = load i32, i32* %19
%108 = add nsw i32 %106, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float*, float** %105, i64 %109
%111 = load float*, float** %110
%112 = load i8*, i8** %12
%113 = load float**, float*** %14
%114 = load i32, i32* %21
%115 = load i32, i32* %19
%116 = add nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float*, float** %113, i64 %117
%119 = load float*, float** %118
%120 = load float**, float*** %15
%121 = load i32, i32* %21
%122 = load i32, i32* %19
%123 = add nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float*, float** %120, i64 %124
%126 = load float*, float** %125
%127 = load i8*, i8** %16
%128 = load i32, i32* %17
%129 = call i32 @calculateFlatnessMeasure(float* %111, i8* %112, float* %119, float* %126, i8* %127, i32 %128)
br label %130
130: ; preds = %86
%131 = load i32, i32* %21
%132 = add nsw i32 %131, 1
store i32 %132, i32* %21
br label %82
133: ; preds = %82
ret void
}

LLVM IR (-O2):
define void @calculateDetectorInput(float** nocapture %0, i8* %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, i8* %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = icmp sgt i32 %8, 0
br i1 %11, label %12, label %16
12: ; preds = %10
%13 = shl i32 %9, 2
%14 = sext i32 %7 to i64
%15 = zext i32 %8 to i64
br label %21
16: ; preds = %21, %10
%17 = icmp sgt i32 %7, 0
br i1 %17, label %18, label %57
18: ; preds = %16
%19 = sext i32 %8 to i64
%20 = zext i32 %7 to i64
br label %41
21: ; preds = %12, %21
%22 = phi i64 [ 0, %12 ], [ %39, %21 ]
%23 = getelementptr inbounds float*, float** %2, i64 %22
%24 = load float*, float** %23
%25 = add nsw i64 %22, %14
%26 = getelementptr inbounds float*, float** %2, i64 %25
%27 = load float*, float** %26
%28 = tail call i32 @memcpy(float* %24, float* %27, i32 %13)
%29 = getelementptr inbounds float*, float** %3, i64 %22
%30 = load float*, float** %29
%31 = getelementptr inbounds float*, float** %3, i64 %25
%32 = load float*, float** %31
%33 = tail call i32 @memcpy(float* %30, float* %32, i32 %13)
%34 = getelementptr inbounds float*, float** %4, i64 %22
%35 = load float*, float** %34
%36 = getelementptr inbounds float*, float** %4, i64 %25
%37 = load float*, float** %36
%38 = tail call i32 @memcpy(float* %35, float* %37, i32 %13)
%39 = add nuw nsw i64 %22, 1
%40 = icmp eq i64 %39, %15
br i1 %40, label %16, label %21
41: ; preds = %18, %41
%42 = phi i64 [ 0, %18 ], [ %55, %41 ]
%43 = add nsw i64 %42, %19
%44 = getelementptr inbounds float*, float** %0, i64 %43
%45 = load float*, float** %44
%46 = getelementptr inbounds float*, float** %2, i64 %43
%47 = load float*, float** %46
%48 = tail call i32 @diff(float* %45, float* %47, i8* %5, i32 %6, i8* %1)
%49 = load float*, float** %44
%50 = getelementptr inbounds float*, float** %3, i64 %43
%51 = load float*, float** %50
%52 = getelementptr inbounds float*, float** %4, i64 %43
%53 = load float*, float** %52
%54 = tail call i32 @calculateFlatnessMeasure(float* %49, i8* %1, float* %51, float* %53, i8* %5, i32 %6)
%55 = add nuw nsw i64 %42, 1
%56 = icmp eq i64 %55, %20
br i1 %56, label %57, label %41
57: ; preds = %41, %16
ret void
}