#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 */
scalar_t__ fabs(double);
void normalize_array(int n, double *x) {
  int i;
  double val, maxval;
  maxval = x[0];
  for (i = 1; i < n; ++i) {
    val = x[i];
    if (fabs(val) > fabs(maxval))
      maxval = val;
  }
  for (i = 0; i < n; ++i)
    x[i] /= maxval;
}


x86 assembly (clang, -O0):
<normalize_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1196 <normalize_array+0x86>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x30(%rbp)
movsd  -0x28(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
cmp    %rcx,%rax
jle    1183 <normalize_array+0x73>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1188 <normalize_array+0x78>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1133 <normalize_array+0x23>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11d2 <normalize_array+0xc2>
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    119d <normalize_array+0x8d>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<normalize_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r13
movsd  (%rsi),%xmm0
mov    %edi,%r15d
cmp    $0x2,%edi
mov    %edi,0x24(%rsp)
jl     1150 <normalize_array+0x40>
lea    -0x1(%r15),%r12
lea    -0x2(%r15),%rax
mov    %r12d,%r14d
and    $0x3,%r14d
cmp    $0x3,%rax
jae    1159 <normalize_array+0x49>
mov    $0x1,%ebx
jmp    1254 <normalize_array+0x144>
movapd %xmm0,%xmm3
jmp    12b4 <normalize_array+0x1a4>
movsd  %xmm0,0x8(%rsp)
and    $0xfffffffffffffffc,%r12
xor    %ebx,%ebx
jmp    117d <normalize_array+0x6d>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rbx
cmp    %rbx,%r12
je     124a <normalize_array+0x13a>
movsd  0x8(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1030 <fabs@plt>
mov    %rax,%rbp
movsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbp
jg     11ae <normalize_array+0x9e>
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x10(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1030 <fabs@plt>
mov    %rax,%rbp
movsd  0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbp
jg     11df <normalize_array+0xcf>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1030 <fabs@plt>
mov    %rax,%rbp
movsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbp
jg     1210 <normalize_array+0x100>
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1030 <fabs@plt>
mov    %rax,%rbp
movsd  0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbp
jg     1170 <normalize_array+0x60>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    1170 <normalize_array+0x60>
add    $0x1,%rbx
movsd  0x8(%rsp),%xmm0
movapd %xmm0,%xmm3
test   %r14,%r14
je     12b4 <normalize_array+0x1a4>
lea    0x0(,%rbx,8),%r12
add    %r13,%r12
xor    %ebx,%ebx
jmp    127d <normalize_array+0x16d>
nopl   0x0(%rax)
add    $0x1,%rbx
movapd %xmm3,%xmm0
cmp    %rbx,%r14
je     12b4 <normalize_array+0x1a4>
movsd  %xmm0,0x8(%rsp)
movsd  (%r12,%rbx,8),%xmm0
movaps %xmm0,0x10(%rsp)
call   1030 <fabs@plt>
mov    %rax,%rbp
movsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
movapd 0x10(%rsp),%xmm3
cmp    %rax,%rbp
jg     1270 <normalize_array+0x160>
movsd  0x8(%rsp),%xmm3
jmp    1270 <normalize_array+0x160>
mov    0x24(%rsp),%eax
test   %eax,%eax
jle    136b <normalize_array+0x25b>
cmp    $0x1,%eax
jne    12cc <normalize_array+0x1bc>
xor    %eax,%eax
jmp    1350 <normalize_array+0x240>
mov    %r15d,%eax
and    $0xfffffffe,%eax
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     137a <normalize_array+0x26a>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdx,8),%xmm1
movupd 0x10(%r13,%rdx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rdx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%r13,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1300 <normalize_array+0x1f0>
test   $0x1,%cl
je     1345 <normalize_array+0x235>
movupd 0x0(%r13,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rdx,8)
cmp    %r15,%rax
je     136b <normalize_array+0x25b>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1350 <normalize_array+0x240>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%cl
jne    1333 <normalize_array+0x223>
jmp    1345 <normalize_array+0x235>

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

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