#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 */
float FLT_MAX;
float *crscrl(int, float *, float *, int);
int /*<<< orphan*/ free(float *);
float sqrt(float);
float maxCor(float *data, float *syn, int n, int max_shift, int *delay,
             float *amp) {
  int i;
  float *crs, c, dataAuto, synAuto;
  for (dataAuto = 0., synAuto = 0., i = 0; i < n; i++) {
    dataAuto += data[i] * data[i];
    synAuto += syn[i] * syn[i];
  }
  if (max_shift < 0)
    max_shift = n;
  crs = crscrl(n, data, syn, 2 * max_shift);
  for (c = -FLT_MAX, i = 0; i <= 2 * max_shift; i++) {
    if (c < crs[i]) {
      c = crs[i];
      *delay = i;
    }
  }
  free(crs);
  *delay -= max_shift;
  *amp = c / synAuto;
  return (c / sqrt(dataAuto * synAuto));
}


x86 assembly (clang, -O0):
<maxCor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d7 <maxCor+0xa7>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1165 <maxCor+0x35>
cmpl   $0x0,-0x18(%rbp)
jge    11e7 <maxCor+0xb7>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
call   1040 <crscrl@plt>
mov    %rax,-0x38(%rbp)
mov    0x2de0(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     127f <maxCor+0x14f>
movss  -0x3c(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    126c <maxCor+0x13c>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1271 <maxCor+0x141>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1225 <maxCor+0xf5>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
movss  -0x3c(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
divss  %xmm1,%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<maxCor>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r14
mov    %r8,%r12
mov    %ecx,%r15d
mov    %edx,%eax
mov    %rsi,%rdx
mov    %rdi,%rsi
test   %eax,%eax
jle    1163 <maxCor+0x33>
mov    %eax,%ebx
cmp    $0x1,%eax
jne    1168 <maxCor+0x38>
xorps  %xmm0,%xmm0
xor    %edi,%edi
test   $0x1,%bl
jne    11bc <maxCor+0x8c>
jmp    11cf <maxCor+0x9f>
xorps  %xmm2,%xmm2
jmp    11cf <maxCor+0x9f>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
xorps  %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdx,%rdi,4),%xmm2
movss  0x4(%rdx,%rdi,4),%xmm3
movss  (%rsi,%rdi,4),%xmm1
unpcklps %xmm2,%xmm1
movss  0x4(%rsi,%rdi,4),%xmm2
unpcklps %xmm3,%xmm2
mulps  %xmm1,%xmm1
addps  %xmm0,%xmm1
mulps  %xmm2,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1180 <maxCor+0x50>
addps  %xmm1,%xmm2
test   $0x1,%bl
je     11cf <maxCor+0x9f>
movss  (%rdx,%rdi,4),%xmm1
movss  (%rsi,%rdi,4),%xmm2
unpcklps %xmm1,%xmm2
mulps  %xmm2,%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,0x10(%rsp)
test   %r15d,%r15d
cmovs  %eax,%r15d
lea    (%r15,%r15,1),%ebx
mov    %eax,%edi
mov    %ebx,%ecx
call   1040 <crscrl@plt>
mov    0x2df9(%rip),%rcx
movss  (%rcx),%xmm1
xorps  0xe06(%rip),%xmm1
test   %r15d,%r15d
js     12ad <maxCor+0x17d>
xor    %ecx,%ecx
test   %ebx,%ebx
cmovle %ecx,%ebx
or     $0x1,%ebx
mov    %ebx,%esi
add    $0xffffffff,%esi
mov    %ebx,%edx
and    $0x3,%edx
cmp    $0x3,%esi
jb     129a <maxCor+0x16a>
and    $0x7ffffffc,%ebx
xor    %ecx,%ecx
jmp    1239 <maxCor+0x109>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rcx
cmp    %rcx,%rbx
je     129a <maxCor+0x16a>
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    124a <maxCor+0x11a>
mov    %ecx,(%r12)
movaps %xmm0,%xmm1
movss  0x4(%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    125f <maxCor+0x12f>
lea    0x1(%rcx),%esi
mov    %esi,(%r12)
movaps %xmm0,%xmm1
movss  0x8(%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1274 <maxCor+0x144>
lea    0x2(%rcx),%esi
mov    %esi,(%r12)
movaps %xmm0,%xmm1
movss  0xc(%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1230 <maxCor+0x100>
lea    0x3(%rcx),%esi
mov    %esi,(%r12)
movaps %xmm0,%xmm1
jmp    1230 <maxCor+0x100>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
je     12ad <maxCor+0x17d>
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1290 <maxCor+0x160>
mov    %ecx,(%r12)
movaps %xmm0,%xmm1
jmp    1290 <maxCor+0x160>
movaps %xmm1,(%rsp)
mov    %rax,%rdi
call   1030 <free@plt>
movaps (%rsp),%xmm3
sub    %r15d,(%r12)
movaps 0x10(%rsp),%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm3,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
mulss  %xmm2,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12eb <maxCor+0x1bb>
sqrtss %xmm0,%xmm0
jmp    12f4 <maxCor+0x1c4>
call   1050 <sqrt@plt>
movaps (%rsp),%xmm3
divss  %xmm0,%xmm3
movaps %xmm3,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@FLT_MAX = global float 0.000000e+00
define float @maxCor(float* %0, float* %1, i32 %2, i32 %3, i32* %4, float* %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca float*
%13 = alloca i32
%14 = alloca float*
%15 = alloca float
%16 = alloca float
%17 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32* %4, i32** %11
store float* %5, float** %12
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %17
store i32 0, i32* %13
br label %18
18: ; preds = %47, %6
%19 = load i32, i32* %13
%20 = load i32, i32* %9
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %50
22: ; preds = %18
%23 = load float*, float** %7
%24 = load i32, i32* %13
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds float, float* %23, i64 %25
%27 = load float, float* %26
%28 = load float*, float** %7
%29 = load i32, i32* %13
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %28, i64 %30
%32 = load float, float* %31
%33 = load float, float* %16
%34 = call float @llvm.fmuladd.f32(float %27, float %32, float %33)
store float %34, float* %16
%35 = load float*, float** %8
%36 = load i32, i32* %13
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
%40 = load float*, float** %8
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
%44 = load float, float* %43
%45 = load float, float* %17
%46 = call float @llvm.fmuladd.f32(float %39, float %44, float %45)
store float %46, float* %17
br label %47
47: ; preds = %22
%48 = load i32, i32* %13
%49 = add nsw i32 %48, 1
store i32 %49, i32* %13
br label %18
50: ; preds = %18
%51 = load i32, i32* %10
%52 = icmp slt i32 %51, 0
br i1 %52, label %53, label %55
53: ; preds = %50
%54 = load i32, i32* %9
store i32 %54, i32* %10
br label %55
55: ; preds = %53, %50
%56 = load i32, i32* %9
%57 = load float*, float** %7
%58 = load float*, float** %8
%59 = load i32, i32* %10
%60 = mul nsw i32 2, %59
%61 = call float* @crscrl(i32 %56, float* %57, float* %58, i32 %60)
store float* %61, float** %14
%62 = load float, float* @FLT_MAX
%63 = fneg float %62
store float %63, float* %15
store i32 0, i32* %13
br label %64
64: ; preds = %86, %55
%65 = load i32, i32* %13
%66 = load i32, i32* %10
%67 = mul nsw i32 2, %66
%68 = icmp sle i32 %65, %67
br i1 %68, label %69, label %89
69: ; preds = %64
%70 = load float, float* %15
%71 = load float*, float** %14
%72 = load i32, i32* %13
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = fcmp olt float %70, %75
br i1 %76, label %77, label %85
77: ; preds = %69
%78 = load float*, float** %14
%79 = load i32, i32* %13
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %78, i64 %80
%82 = load float, float* %81
store float %82, float* %15
%83 = load i32, i32* %13
%84 = load i32*, i32** %11
store i32 %83, i32* %84
br label %85
85: ; preds = %77, %69
br label %86
86: ; preds = %85
%87 = load i32, i32* %13
%88 = add nsw i32 %87, 1
store i32 %88, i32* %13
br label %64
89: ; preds = %64
%90 = load float*, float** %14
%91 = call i32 @free(float* %90)
%92 = load i32, i32* %10
%93 = load i32*, i32** %11
%94 = load i32, i32* %93
%95 = sub nsw i32 %94, %92
store i32 %95, i32* %93
%96 = load float, float* %15
%97 = load float, float* %17
%98 = fdiv float %96, %97
%99 = load float*, float** %12
store float %98, float* %99
%100 = load float, float* %15
%101 = load float, float* %16
%102 = load float, float* %17
%103 = fmul float %101, %102
%104 = call float @sqrt(float %103)
%105 = fdiv float %100, %104
ret float %105
}

LLVM IR (-O2):
@FLT_MAX = global float 0.000000e+00
define float @maxCor(float* %0, float* %1, i32 %2, i32 %3, i32* nocapture %4, float* nocapture writeonly %5) {
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %51
8: ; preds = %6
%9 = zext i32 %2 to i64
%10 = and i64 %9, 1
%11 = icmp eq i32 %2, 1
br i1 %11, label %38, label %12
12: ; preds = %8
%13 = and i64 %9, 4294967294
br label %14
14: ; preds = %14, %12
%15 = phi i64 [ 0, %12 ], [ %33, %14 ]
%16 = phi <2 x float> [ zeroinitializer, %12 ], [ %32, %14 ]
%17 = phi i64 [ 0, %12 ], [ %34, %14 ]
%18 = getelementptr inbounds float, float* %0, i64 %15
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %1, i64 %15
%21 = load float, float* %20
%22 = insertelement <2 x float> poison, float %19, i64 0
%23 = insertelement <2 x float> %22, float %21, i64 1
%24 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %23, <2 x float> %23, <2 x float> %16)
%25 = or i64 %15, 1
%26 = getelementptr inbounds float, float* %0, i64 %25
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %1, i64 %25
%29 = load float, float* %28
%30 = insertelement <2 x float> poison, float %27, i64 0
%31 = insertelement <2 x float> %30, float %29, i64 1
%32 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %31, <2 x float> %31, <2 x float> %24)
%33 = add nuw nsw i64 %15, 2
%34 = add i64 %17, 2
%35 = icmp eq i64 %34, %13
br i1 %35, label %36, label %14
36: ; preds = %14
%37 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %31, <2 x float> %31, <2 x float> %24)
br label %38
38: ; preds = %36, %8
%39 = phi <2 x float> [ undef, %8 ], [ %37, %36 ]
%40 = phi i64 [ 0, %8 ], [ %33, %36 ]
%41 = phi <2 x float> [ zeroinitializer, %8 ], [ %32, %36 ]
%42 = icmp eq i64 %10, 0
br i1 %42, label %51, label %43
43: ; preds = %38
%44 = getelementptr inbounds float, float* %0, i64 %40
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %1, i64 %40
%47 = load float, float* %46
%48 = insertelement <2 x float> poison, float %45, i64 0
%49 = insertelement <2 x float> %48, float %47, i64 1
%50 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %49, <2 x float> %49, <2 x float> %41)
br label %51
51: ; preds = %43, %38, %6
%52 = phi <2 x float> [ zeroinitializer, %6 ], [ %39, %38 ], [ %50, %43 ]
%53 = icmp slt i32 %3, 0
%54 = select i1 %53, i32 %2, i32 %3
%55 = shl nsw i32 %54, 1
%56 = tail call float* @crscrl(i32 %2, float* %0, float* %1, i32 %55)
%57 = load float, float* @FLT_MAX
%58 = fneg float %57
%59 = icmp slt i32 %54, 0
br i1 %59, label %125, label %60
60: ; preds = %51
%61 = call i32 @llvm.smax.i32(i32 %55, i32 0)
%62 = or i32 %61, 1
%63 = zext i32 %62 to i64
%64 = add nsw i64 %63, -1
%65 = and i64 %63, 3
%66 = icmp ult i64 %64, 3
br i1 %66, label %107, label %67
67: ; preds = %60
%68 = and i64 %63, 2147483644
br label %69
69: ; preds = %102, %67
%70 = phi i64 [ 0, %67 ], [ %104, %102 ]
%71 = phi float [ %58, %67 ], [ %103, %102 ]
%72 = phi i64 [ 0, %67 ], [ %105, %102 ]
%73 = getelementptr inbounds float, float* %56, i64 %70
%74 = load float, float* %73
%75 = fcmp olt float %71, %74
br i1 %75, label %76, label %78
76: ; preds = %69
%77 = trunc i64 %70 to i32
store i32 %77, i32* %4
br label %78
78: ; preds = %69, %76
%79 = phi float [ %74, %76 ], [ %71, %69 ]
%80 = or i64 %70, 1
%81 = getelementptr inbounds float, float* %56, i64 %80
%82 = load float, float* %81
%83 = fcmp olt float %79, %82
br i1 %83, label %84, label %86
84: ; preds = %78
%85 = trunc i64 %80 to i32
store i32 %85, i32* %4
br label %86
86: ; preds = %84, %78
%87 = phi float [ %82, %84 ], [ %79, %78 ]
%88 = or i64 %70, 2
%89 = getelementptr inbounds float, float* %56, i64 %88
%90 = load float, float* %89
%91 = fcmp olt float %87, %90
br i1 %91, label %92, label %94
92: ; preds = %86
%93 = trunc i64 %88 to i32
store i32 %93, i32* %4
br label %94
94: ; preds = %92, %86
%95 = phi float [ %90, %92 ], [ %87, %86 ]
%96 = or i64 %70, 3
%97 = getelementptr inbounds float, float* %56, i64 %96
%98 = load float, float* %97
%99 = fcmp olt float %95, %98
br i1 %99, label %100, label %102
100: ; preds = %94
%101 = trunc i64 %96 to i32
store i32 %101, i32* %4
br label %102
102: ; preds = %100, %94
%103 = phi float [ %98, %100 ], [ %95, %94 ]
%104 = add nuw nsw i64 %70, 4
%105 = add i64 %72, 4
%106 = icmp eq i64 %105, %68
br i1 %106, label %107, label %69
107: ; preds = %60, %102
%108 = phi float [ undef, %60 ], [ %103, %102 ]
%109 = phi i64 [ 0, %60 ], [ %104, %102 ]
%110 = phi float [ %58, %60 ], [ %103, %102 ]
br label %111
111: ; preds = %120, %107
%112 = phi i64 [ %109, %107 ], [ %122, %120 ]
%113 = phi float [ %110, %107 ], [ %121, %120 ]
%114 = phi i64 [ 0, %107 ], [ %123, %120 ]
%115 = getelementptr inbounds float, float* %56, i64 %112
%116 = load float, float* %115
%117 = fcmp olt float %113, %116
br i1 %117, label %118, label %120
118: ; preds = %111
%119 = trunc i64 %112 to i32
store i32 %119, i32* %4
br label %120
120: ; preds = %118, %111
%121 = phi float [ %116, %118 ], [ %113, %111 ]
%122 = add nuw nsw i64 %112, 1
%123 = add i64 %114, 1
%124 = icmp eq i64 %123, %65
br i1 %124, label %125, label %111
125: ; preds = %120, %51
%126 = phi float [ %58, %51 ], [ %121, %120 ]
%127 = tail call i32 @free(float* %56)
%128 = load i32, i32* %4
%129 = sub nsw i32 %128, %54
store i32 %129, i32* %4
%130 = extractelement <2 x float> %52, i64 1
%131 = fdiv float %126, %130
store float %131, float* %5
%132 = extractelement <2 x float> %52, i64 0
%133 = fmul float %132, %130
%134 = tail call float @sqrt(float %133)
%135 = fdiv float %126, %134
ret float %135
}