#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 */
typedef int int8_t;
typedef size_t int32_t;

/* Variables and functions */
int abs(int);
void normalizeAmplitude(int8_t **buffer, int32_t size) {
  int32_t i;
  int maximum = 0;
  for (i = 0; i < size; i++)
    if (abs((*buffer)[i]) > maximum)
      maximum = abs((*buffer)[i]);
  for (i = 0; i < size; i++)
    (*buffer)[i] *= 127 / (float)maximum;
}


x86 assembly (clang, -O0):
<normalizeAmplitude>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1185 <normalizeAmplitude+0x75>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
cmp    -0x1c(%rbp),%eax
jle    116f <normalizeAmplitude+0x5f>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
mov    %eax,-0x1c(%rbp)
jmp    1174 <normalizeAmplitude+0x64>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    112f <normalizeAmplitude+0x1f>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11d8 <normalizeAmplitude+0xc8>
cvtsi2ssl -0x1c(%rbp),%xmm0
movss  0xe58(%rip),%xmm1
divss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    118d <normalizeAmplitude+0x7d>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<normalizeAmplitude>:
test   %rsi,%rsi
je     13fc <normalizeAmplitude+0x2fc>
mov    (%rdi),%r9
cmp    $0x8,%rsi
jae    111c <normalizeAmplitude+0x1c>
xor    %eax,%eax
xor    %r10d,%r10d
jmp    12c1 <normalizeAmplitude+0x1c1>
mov    %rsi,%r10
and    $0xfffffffffffffff8,%r10
lea    -0x8(%r10),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     13fd <normalizeAmplitude+0x2fd>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%r9,%rdx,4),%xmm5
movdqu 0x10(%r9,%rdx,4),%xmm6
movdqu 0x20(%r9,%rdx,4),%xmm3
movdqu 0x30(%r9,%rdx,4),%xmm2
movdqa %xmm5,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm5
pxor   %xmm4,%xmm5
movdqa %xmm6,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm6
pxor   %xmm4,%xmm6
movdqa %xmm5,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm5
pandn  %xmm0,%xmm4
por    %xmm5,%xmm4
movdqa %xmm6,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm6
pandn  %xmm1,%xmm5
por    %xmm6,%xmm5
movdqa %xmm3,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm3
pxor   %xmm0,%xmm3
movdqa %xmm2,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm2
pxor   %xmm0,%xmm2
movdqa %xmm3,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm3
pandn  %xmm4,%xmm0
por    %xmm3,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1150 <normalizeAmplitude+0x50>
test   $0x1,%r8b
je     1272 <normalizeAmplitude+0x172>
movdqu (%r9,%rdx,4),%xmm2
movdqu 0x10(%r9,%rdx,4),%xmm3
movdqa %xmm2,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm2
pxor   %xmm4,%xmm2
movdqa %xmm3,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm3
pxor   %xmm4,%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%eax
cmp    %rsi,%r10
je     12eb <normalizeAmplitude+0x1eb>
mov    %eax,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r9,%r10,4),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    %edx,%eax
cmovle %edx,%eax
add    $0x1,%r10
mov    %eax,%edx
cmp    %r10,%rsi
jne    12d0 <normalizeAmplitude+0x1d0>
test   %rsi,%rsi
je     13fc <normalizeAmplitude+0x2fc>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0xcfd(%rip),%xmm0
divss  %xmm1,%xmm0
mov    (%rdi),%rax
cmp    $0x8,%rsi
jae    1317 <normalizeAmplitude+0x217>
xor    %ecx,%ecx
jmp    13e0 <normalizeAmplitude+0x2e0>
mov    %rsi,%rcx
and    $0xfffffffffffffff8,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1416 <normalizeAmplitude+0x316>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm2
movups 0x10(%rax,%rdx,4),%xmm3
movups 0x20(%rax,%rdx,4),%xmm4
movups 0x30(%rax,%rdx,4),%xmm5
cvtdq2ps %xmm2,%xmm2
cvtdq2ps %xmm3,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
cvttps2dq %xmm2,%xmm2
cvttps2dq %xmm3,%xmm3
movups %xmm2,(%rax,%rdx,4)
movups %xmm3,0x10(%rax,%rdx,4)
cvtdq2ps %xmm4,%xmm2
cvtdq2ps %xmm5,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
cvttps2dq %xmm2,%xmm2
cvttps2dq %xmm3,%xmm3
movdqu %xmm2,0x20(%rax,%rdx,4)
movdqu %xmm3,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1350 <normalizeAmplitude+0x250>
test   $0x1,%r8b
je     13d7 <normalizeAmplitude+0x2d7>
movups (%rax,%rdx,4),%xmm2
movups 0x10(%rax,%rdx,4),%xmm3
cvtdq2ps %xmm2,%xmm2
cvtdq2ps %xmm3,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
cvttps2dq %xmm2,%xmm1
cvttps2dq %xmm3,%xmm2
movups %xmm1,(%rax,%rdx,4)
movdqu %xmm2,0x10(%rax,%rdx,4)
cmp    %rsi,%rcx
je     13fc <normalizeAmplitude+0x2fc>
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2ssl (%rax,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
cvttss2si %xmm1,%edx
mov    %edx,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    13e0 <normalizeAmplitude+0x2e0>
ret
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
test   $0x1,%r8b
jne    1213 <normalizeAmplitude+0x113>
jmp    1272 <normalizeAmplitude+0x172>
xor    %edx,%edx
test   $0x1,%r8b
jne    13b0 <normalizeAmplitude+0x2b0>
jmp    13d7 <normalizeAmplitude+0x2d7>

LLVM IR (-O0):
define void @normalizeAmplitude(i32** %0, i64 %1) {
%3 = alloca i32**
%4 = alloca i64
%5 = alloca i64
%6 = alloca i32
store i32** %0, i32*** %3
store i64 %1, i64* %4
store i32 0, i32* %6
store i64 0, i64* %5
br label %7
7: ; preds = %28, %2
%8 = load i64, i64* %5
%9 = load i64, i64* %4
%10 = icmp ult i64 %8, %9
br i1 %10, label %11, label %31
11: ; preds = %7
%12 = load i32**, i32*** %3
%13 = load i32*, i32** %12
%14 = load i64, i64* %5
%15 = getelementptr inbounds i32, i32* %13, i64 %14
%16 = load i32, i32* %15
%17 = call i32 @abs(i32 %16)
%18 = load i32, i32* %6
%19 = icmp sgt i32 %17, %18
br i1 %19, label %20, label %27
20: ; preds = %11
%21 = load i32**, i32*** %3
%22 = load i32*, i32** %21
%23 = load i64, i64* %5
%24 = getelementptr inbounds i32, i32* %22, i64 %23
%25 = load i32, i32* %24
%26 = call i32 @abs(i32 %25)
store i32 %26, i32* %6
br label %27
27: ; preds = %20, %11
br label %28
28: ; preds = %27
%29 = load i64, i64* %5
%30 = add i64 %29, 1
store i64 %30, i64* %5
br label %7
31: ; preds = %7
store i64 0, i64* %5
br label %32
32: ; preds = %48, %31
%33 = load i64, i64* %5
%34 = load i64, i64* %4
%35 = icmp ult i64 %33, %34
br i1 %35, label %36, label %51
36: ; preds = %32
%37 = load i32, i32* %6
%38 = sitofp i32 %37 to float
%39 = fdiv float 1.270000e+02, %38
%40 = load i32**, i32*** %3
%41 = load i32*, i32** %40
%42 = load i64, i64* %5
%43 = getelementptr inbounds i32, i32* %41, i64 %42
%44 = load i32, i32* %43
%45 = sitofp i32 %44 to float
%46 = fmul float %45, %39
%47 = fptosi float %46 to i32
store i32 %47, i32* %43
br label %48
48: ; preds = %36
%49 = load i64, i64* %5
%50 = add i64 %49, 1
store i64 %50, i64* %5
br label %32
51: ; preds = %32
ret void
}

LLVM IR (-O2):
define void @normalizeAmplitude(i32** nocapture %0, i64 %1) {
%3 = icmp eq i64 %1, 0
br i1 %3, label %175, label %4
4: ; preds = %2
%5 = load i32*, i32** %0
%6 = icmp ult i64 %1, 8
br i1 %6, label %76, label %7
7: ; preds = %4
%8 = and i64 %1, -8
%9 = add i64 %8, -8
%10 = lshr exact i64 %9, 3
%11 = add nuw nsw i64 %10, 1
%12 = and i64 %11, 1
%13 = icmp eq i64 %9, 0
br i1 %13, label %49, label %14
14: ; preds = %7
%15 = and i64 %11, 4611686018427387902
br label %16
16: ; preds = %16, %14
%17 = phi i64 [ 0, %14 ], [ %46, %16 ]
%18 = phi <4 x i32> [ zeroinitializer, %14 ], [ %44, %16 ]
%19 = phi <4 x i32> [ zeroinitializer, %14 ], [ %45, %16 ]
%20 = phi i64 [ 0, %14 ], [ %47, %16 ]
%21 = getelementptr inbounds i32, i32* %5, i64 %17
%22 = bitcast i32* %21 to <4 x i32>*
%23 = load <4 x i32>, <4 x i32>* %22
%24 = getelementptr inbounds i32, i32* %21, i64 4
%25 = bitcast i32* %24 to <4 x i32>*
%26 = load <4 x i32>, <4 x i32>* %25
%27 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %23, i1 true)
%28 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %26, i1 true)
%29 = icmp sgt <4 x i32> %27, %18
%30 = icmp sgt <4 x i32> %28, %19
%31 = select <4 x i1> %29, <4 x i32> %27, <4 x i32> %18
%32 = select <4 x i1> %30, <4 x i32> %28, <4 x i32> %19
%33 = or i64 %17, 8
%34 = getelementptr inbounds i32, i32* %5, i64 %33
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = getelementptr inbounds i32, i32* %34, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %36, i1 true)
%41 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %39, i1 true)
%42 = icmp sgt <4 x i32> %40, %31
%43 = icmp sgt <4 x i32> %41, %32
%44 = select <4 x i1> %42, <4 x i32> %40, <4 x i32> %31
%45 = select <4 x i1> %43, <4 x i32> %41, <4 x i32> %32
%46 = add nuw i64 %17, 16
%47 = add i64 %20, 2
%48 = icmp eq i64 %47, %15
br i1 %48, label %49, label %16
49: ; preds = %16, %7
%50 = phi <4 x i32> [ undef, %7 ], [ %44, %16 ]
%51 = phi <4 x i32> [ undef, %7 ], [ %45, %16 ]
%52 = phi i64 [ 0, %7 ], [ %46, %16 ]
%53 = phi <4 x i32> [ zeroinitializer, %7 ], [ %44, %16 ]
%54 = phi <4 x i32> [ zeroinitializer, %7 ], [ %45, %16 ]
%55 = icmp eq i64 %12, 0
br i1 %55, label %69, label %56
56: ; preds = %49
%57 = getelementptr inbounds i32, i32* %5, i64 %52
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %59, i1 true)
%64 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %62, i1 true)
%65 = icmp sgt <4 x i32> %63, %53
%66 = icmp sgt <4 x i32> %64, %54
%67 = select <4 x i1> %65, <4 x i32> %63, <4 x i32> %53
%68 = select <4 x i1> %66, <4 x i32> %64, <4 x i32> %54
br label %69
69: ; preds = %49, %56
%70 = phi <4 x i32> [ %50, %49 ], [ %67, %56 ]
%71 = phi <4 x i32> [ %51, %49 ], [ %68, %56 ]
%72 = icmp sgt <4 x i32> %70, %71
%73 = select <4 x i1> %72, <4 x i32> %70, <4 x i32> %71
%74 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %73)
%75 = icmp eq i64 %8, %1
br i1 %75, label %79, label %76
76: ; preds = %4, %69
%77 = phi i32 [ 0, %4 ], [ %74, %69 ]
%78 = phi i64 [ 0, %4 ], [ %8, %69 ]
br label %156
79: ; preds = %156, %69
%80 = phi i32 [ %74, %69 ], [ %163, %156 ]
br i1 %3, label %175, label %81
81: ; preds = %79
%82 = sitofp i32 %80 to float
%83 = fdiv float 1.270000e+02, %82
%84 = load i32*, i32** %0
%85 = icmp ult i64 %1, 8
br i1 %85, label %154, label %86
86: ; preds = %81
%87 = and i64 %1, -8
%88 = insertelement <4 x float> poison, float %83, i64 0
%89 = shufflevector <4 x float> %88, <4 x float> poison, <4 x i32> zeroinitializer
%90 = insertelement <4 x float> poison, float %83, i64 0
%91 = shufflevector <4 x float> %90, <4 x float> poison, <4 x i32> zeroinitializer
%92 = add i64 %87, -8
%93 = lshr exact i64 %92, 3
%94 = add nuw nsw i64 %93, 1
%95 = and i64 %94, 1
%96 = icmp eq i64 %92, 0
br i1 %96, label %134, label %97
97: ; preds = %86
%98 = and i64 %94, 4611686018427387902
br label %99
99: ; preds = %99, %97
%100 = phi i64 [ 0, %97 ], [ %131, %99 ]
%101 = phi i64 [ 0, %97 ], [ %132, %99 ]
%102 = getelementptr inbounds i32, i32* %84, i64 %100
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr inbounds i32, i32* %102, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = sitofp <4 x i32> %104 to <4 x float>
%109 = sitofp <4 x i32> %107 to <4 x float>
%110 = fmul <4 x float> %89, %108
%111 = fmul <4 x float> %91, %109
%112 = fptosi <4 x float> %110 to <4 x i32>
%113 = fptosi <4 x float> %111 to <4 x i32>
%114 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %112, <4 x i32>* %114
%115 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %113, <4 x i32>* %115
%116 = or i64 %100, 8
%117 = getelementptr inbounds i32, i32* %84, i64 %116
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = getelementptr inbounds i32, i32* %117, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
%122 = load <4 x i32>, <4 x i32>* %121
%123 = sitofp <4 x i32> %119 to <4 x float>
%124 = sitofp <4 x i32> %122 to <4 x float>
%125 = fmul <4 x float> %89, %123
%126 = fmul <4 x float> %91, %124
%127 = fptosi <4 x float> %125 to <4 x i32>
%128 = fptosi <4 x float> %126 to <4 x i32>
%129 = bitcast i32* %117 to <4 x i32>*
store <4 x i32> %127, <4 x i32>* %129
%130 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %128, <4 x i32>* %130
%131 = add nuw i64 %100, 16
%132 = add i64 %101, 2
%133 = icmp eq i64 %132, %98
br i1 %133, label %134, label %99
134: ; preds = %99, %86
%135 = phi i64 [ 0, %86 ], [ %131, %99 ]
%136 = icmp eq i64 %95, 0
br i1 %136, label %152, label %137
137: ; preds = %134
%138 = getelementptr inbounds i32, i32* %84, i64 %135
%139 = bitcast i32* %138 to <4 x i32>*
%140 = load <4 x i32>, <4 x i32>* %139
%141 = getelementptr inbounds i32, i32* %138, i64 4
%142 = bitcast i32* %141 to <4 x i32>*
%143 = load <4 x i32>, <4 x i32>* %142
%144 = sitofp <4 x i32> %140 to <4 x float>
%145 = sitofp <4 x i32> %143 to <4 x float>
%146 = fmul <4 x float> %89, %144
%147 = fmul <4 x float> %91, %145
%148 = fptosi <4 x float> %146 to <4 x i32>
%149 = fptosi <4 x float> %147 to <4 x i32>
%150 = bitcast i32* %138 to <4 x i32>*
store <4 x i32> %148, <4 x i32>* %150
%151 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %149, <4 x i32>* %151
br label %152
152: ; preds = %134, %137
%153 = icmp eq i64 %87, %1
br i1 %153, label %175, label %154
154: ; preds = %81, %152
%155 = phi i64 [ 0, %81 ], [ %87, %152 ]
br label %166
156: ; preds = %76, %156
%157 = phi i32 [ %163, %156 ], [ %77, %76 ]
%158 = phi i64 [ %164, %156 ], [ %78, %76 ]
%159 = getelementptr inbounds i32, i32* %5, i64 %158
%160 = load i32, i32* %159
%161 = tail call i32 @llvm.abs.i32(i32 %160, i1 true)
%162 = icmp sgt i32 %161, %157
%163 = select i1 %162, i32 %161, i32 %157
%164 = add nuw i64 %158, 1
%165 = icmp eq i64 %164, %1
br i1 %165, label %79, label %156
166: ; preds = %154, %166
%167 = phi i64 [ %173, %166 ], [ %155, %154 ]
%168 = getelementptr inbounds i32, i32* %84, i64 %167
%169 = load i32, i32* %168
%170 = sitofp i32 %169 to float
%171 = fmul float %83, %170
%172 = fptosi float %171 to i32
store i32 %172, i32* %168
%173 = add nuw i64 %167, 1
%174 = icmp eq i64 %173, %1
br i1 %174, label %175, label %166
175: ; preds = %166, %152, %2, %79
ret void
}