#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*/ muzzle_smooth(int, float *);
void muzzle_normalise(int samples, float profile[]) {
  int i;
  float min = 0, max = 0;
  for (i = 0; i < samples; i++) {
    if (i == 0) {
      min = profile[i];
      max = min;
      continue;
    }
    if (profile[i] > max)
      max = profile[i];
    if (profile[i] < min)
      min = profile[i];
  }
  if (max == min)
    return;
  for (i = 0; i < samples; i++) {
    profile[i] = (profile[i] - min) / (max - min);
  }
  muzzle_smooth(samples, profile);
}


x86 assembly (clang, -O0):
<muzzle_normalise>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11d6 <muzzle_normalise+0xc6>
cmpl   $0x0,-0x14(%rbp)
jne    116d <muzzle_normalise+0x5d>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    11c8 <muzzle_normalise+0xb8>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jbe    1196 <muzzle_normalise+0x86>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    11c3 <muzzle_normalise+0xb3>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
jmp    11c8 <muzzle_normalise+0xb8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1136 <muzzle_normalise+0x26>
movss  -0x1c(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jne    11f0 <muzzle_normalise+0xe0>
jp     11f0 <muzzle_normalise+0xe0>
jmp    124a <muzzle_normalise+0x13a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    123e <muzzle_normalise+0x12e>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f7 <muzzle_normalise+0xe7>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <muzzle_smooth@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<muzzle_normalise>:
test   %edi,%edi
jle    11f6 <muzzle_normalise+0xe6>
mov    %edi,%r8d
movss  (%rsi),%xmm0
cmp    $0x1,%edi
jne    1135 <muzzle_normalise+0x25>
ucomiss %xmm0,%xmm0
movaps %xmm0,%xmm1
jnp    11f6 <muzzle_normalise+0xe6>
jmp    11ff <muzzle_normalise+0xef>
lea    -0x1(%r8),%rcx
lea    -0x2(%r8),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1155 <muzzle_normalise+0x45>
mov    $0x1,%edx
movaps %xmm0,%xmm3
movaps %xmm0,%xmm2
jmp    11b4 <muzzle_normalise+0xa4>
and    $0xfffffffffffffffc,%rcx
xor    %edx,%edx
movaps %xmm0,%xmm2
xchg   %ax,%ax
movss  0x4(%rsi,%rdx,4),%xmm1
movss  0x8(%rsi,%rdx,4),%xmm3
movaps %xmm1,%xmm4
maxss  %xmm0,%xmm4
minss  %xmm2,%xmm1
movaps %xmm3,%xmm0
maxss  %xmm4,%xmm0
minss  %xmm1,%xmm3
movss  0xc(%rsi,%rdx,4),%xmm1
movaps %xmm1,%xmm4
maxss  %xmm0,%xmm4
minss  %xmm3,%xmm1
movss  0x10(%rsi,%rdx,4),%xmm2
movaps %xmm2,%xmm0
maxss  %xmm4,%xmm0
minss  %xmm1,%xmm2
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1160 <muzzle_normalise+0x50>
add    $0x1,%rdx
movaps %xmm0,%xmm3
movaps %xmm0,%xmm1
movaps %xmm2,%xmm0
test   %rax,%rax
je     11ef <muzzle_normalise+0xdf>
lea    (%rsi,%rdx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx,%rdx,4),%xmm0
movaps %xmm0,%xmm1
maxss  %xmm3,%xmm1
minss  %xmm2,%xmm0
add    $0x1,%rdx
movaps %xmm1,%xmm3
movaps %xmm0,%xmm2
cmp    %rdx,%rax
jne    11d0 <muzzle_normalise+0xc0>
ucomiss %xmm0,%xmm1
jne    11f7 <muzzle_normalise+0xe7>
jp     11f7 <muzzle_normalise+0xe7>
ret
test   %edi,%edi
jle    12ab <muzzle_normalise+0x19b>
subss  %xmm0,%xmm1
cmp    $0x4,%edi
jae    120f <muzzle_normalise+0xff>
xor    %ecx,%ecx
jmp    1290 <muzzle_normalise+0x180>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     126a <muzzle_normalise+0x15a>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
movups (%rsi,%rdx,4),%xmm4
movups 0x10(%rsi,%rdx,4),%xmm5
subps  %xmm2,%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rsi,%rdx,4)
subps  %xmm2,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x10(%rsi,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1240 <muzzle_normalise+0x130>
jmp    126c <muzzle_normalise+0x15c>
xor    %edx,%edx
test   $0x1,%r9b
je     1280 <muzzle_normalise+0x170>
movups (%rsi,%rdx,4),%xmm4
subps  %xmm2,%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rsi,%rdx,4)
cmp    %r8,%rcx
je     12ab <muzzle_normalise+0x19b>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi,%rcx,4),%xmm2
subss  %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1290 <muzzle_normalise+0x180>
jmp    1030 <muzzle_smooth@plt>

LLVM IR (-O0):
define void @muzzle_normalise(i32 %0, float* %1) {
%3 = alloca i32
%4 = alloca float*
%5 = alloca i32
%6 = alloca float
%7 = alloca float
store i32 %0, i32* %3
store float* %1, float** %4
store float 0.000000e+00, float* %6
store float 0.000000e+00, float* %7
store i32 0, i32* %5
br label %8
8: ; preds = %51, %2
%9 = load i32, i32* %5
%10 = load i32, i32* %3
%11 = icmp slt i32 %9, %10
br i1 %11, label %12, label %54
12: ; preds = %8
%13 = load i32, i32* %5
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %22
15: ; preds = %12
%16 = load float*, float** %4
%17 = load i32, i32* %5
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds float, float* %16, i64 %18
%20 = load float, float* %19
store float %20, float* %6
%21 = load float, float* %6
store float %21, float* %7
br label %51
22: ; preds = %12
%23 = load float*, float** %4
%24 = load i32, i32* %5
%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 = fcmp ogt float %27, %28
br i1 %29, label %30, label %36
30: ; preds = %22
%31 = load float*, float** %4
%32 = load i32, i32* %5
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %31, i64 %33
%35 = load float, float* %34
store float %35, float* %7
br label %36
36: ; preds = %30, %22
%37 = load float*, float** %4
%38 = load i32, i32* %5
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %37, i64 %39
%41 = load float, float* %40
%42 = load float, float* %6
%43 = fcmp olt float %41, %42
br i1 %43, label %44, label %50
44: ; preds = %36
%45 = load float*, float** %4
%46 = load i32, i32* %5
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
%49 = load float, float* %48
store float %49, float* %6
br label %50
50: ; preds = %44, %36
br label %51
51: ; preds = %50, %15
%52 = load i32, i32* %5
%53 = add nsw i32 %52, 1
store i32 %53, i32* %5
br label %8
54: ; preds = %8
%55 = load float, float* %7
%56 = load float, float* %6
%57 = fcmp oeq float %55, %56
br i1 %57, label %58, label %59
58: ; preds = %54
br label %87
59: ; preds = %54
store i32 0, i32* %5
br label %60
60: ; preds = %80, %59
%61 = load i32, i32* %5
%62 = load i32, i32* %3
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %83
64: ; preds = %60
%65 = load float*, float** %4
%66 = load i32, i32* %5
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
%69 = load float, float* %68
%70 = load float, float* %6
%71 = fsub float %69, %70
%72 = load float, float* %7
%73 = load float, float* %6
%74 = fsub float %72, %73
%75 = fdiv float %71, %74
%76 = load float*, float** %4
%77 = load i32, i32* %5
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %76, i64 %78
store float %75, float* %79
br label %80
80: ; preds = %64
%81 = load i32, i32* %5
%82 = add nsw i32 %81, 1
store i32 %82, i32* %5
br label %60
83: ; preds = %60
%84 = load i32, i32* %3
%85 = load float*, float** %4
%86 = call i32 @muzzle_smooth(i32 %84, float* %85)
br label %87
87: ; preds = %83, %58
ret void
}

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