norm_area(s, n, dt) float *s, *dt;
int n;
{
  int i, n1;
  float area;
  n1 = n - 1;
  area = 0.5 * (*dt) * (s[0] + s[n1]);
  for (i = 1; i < n1; i++)
    area = area + (*dt) * s[i];
  for (i = 0; i < n; i++)
    s[i] = s[i] / area;
}


x86 assembly (clang, -O0):
<norm_area>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xed4(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    119e <norm_area+0x9e>
movss  -0x2c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    115d <norm_area+0x5d>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11de <norm_area+0xde>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a5 <norm_area+0xa5>
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<norm_area>:
movss  (%rdx),%xmm2
cvtss2sd %xmm2,%xmm0
mulsd  0xef0(%rip),%xmm0
movss  (%rdi),%xmm1
movslq %esi,%rax
movss  -0x4(%rdi,%rax,4),%xmm3
addss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
cmp    $0x3,%esi
jl     11d6 <norm_area+0xd6>
lea    -0x1(%rsi),%eax
mov    %eax,%ecx
lea    -0x1(%rcx),%rdx
add    $0xfffffffffffffffe,%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    115d <norm_area+0x5d>
mov    $0x1,%ecx
test   %rax,%rax
jne    11ba <norm_area+0xba>
jmp    11d6 <norm_area+0xd6>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x4(%rdi,%rcx,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
movss  0x8(%rdi,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm3,%xmm0
movss  0xc(%rdi,%rcx,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
movss  0x10(%rdi,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1170 <norm_area+0x70>
add    $0x1,%rcx
test   %rax,%rax
je     11d6 <norm_area+0xd6>
lea    (%rdi,%rcx,4),%rcx
xor    %edx,%edx
movss  (%rcx,%rdx,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11c0 <norm_area+0xc0>
test   %esi,%esi
jle    1287 <norm_area+0x187>
divss  %xmm0,%xmm1
movss  %xmm1,(%rdi)
cmp    $0x1,%esi
je     1287 <norm_area+0x187>
mov    %esi,%eax
lea    -0x1(%rax),%r8
mov    $0x1,%ecx
cmp    $0x4,%r8
jb     1270 <norm_area+0x170>
mov    %r8,%rcx
and    $0xfffffffffffffffc,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1288 <norm_area+0x188>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%edx
xchg   %ax,%ax
movups (%rdi,%rdx,4),%xmm2
movups 0x10(%rdi,%rdx,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rdi,%rdx,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rdi,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1230 <norm_area+0x130>
test   $0x1,%r9b
je     1263 <norm_area+0x163>
movups (%rdi,%rdx,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdi,%rdx,4)
cmp    %rcx,%r8
je     1287 <norm_area+0x187>
or     $0x1,%rcx
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1270 <norm_area+0x170>
ret
mov    $0x1,%edx
test   $0x1,%r9b
jne    1258 <norm_area+0x158>
jmp    1263 <norm_area+0x163>

LLVM IR (-O0):
define i32 @norm_area(float* %0, i32 %1, float* %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca i32
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
store float* %0, float** %5
store i32 %1, i32* %6
store float* %2, float** %7
%11 = load i32, i32* %6
%12 = sub nsw i32 %11, 1
store i32 %12, i32* %9
%13 = load float*, float** %7
%14 = load float, float* %13
%15 = fpext float %14 to double
%16 = fmul double 5.000000e-01, %15
%17 = load float*, float** %5
%18 = getelementptr inbounds float, float* %17, i64 0
%19 = load float, float* %18
%20 = load float*, float** %5
%21 = load i32, i32* %9
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
%24 = load float, float* %23
%25 = fadd float %19, %24
%26 = fpext float %25 to double
%27 = fmul double %16, %26
%28 = fptrunc double %27 to float
store float %28, float* %10
store i32 1, i32* %8
br label %29
29: ; preds = %43, %3
%30 = load i32, i32* %8
%31 = load i32, i32* %9
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %46
33: ; preds = %29
%34 = load float, float* %10
%35 = load float*, float** %7
%36 = load float, float* %35
%37 = load float*, float** %5
%38 = load i32, i32* %8
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %37, i64 %39
%41 = load float, float* %40
%42 = call float @llvm.fmuladd.f32(float %36, float %41, float %34)
store float %42, float* %10
br label %43
43: ; preds = %33
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %29
46: ; preds = %29
store i32 0, i32* %8
br label %47
47: ; preds = %63, %46
%48 = load i32, i32* %8
%49 = load i32, i32* %6
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %66
51: ; preds = %47
%52 = load float*, float** %5
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = load float, float* %10
%58 = fdiv float %56, %57
%59 = load float*, float** %5
%60 = load i32, i32* %8
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float %58, float* %62
br label %63
63: ; preds = %51
%64 = load i32, i32* %8
%65 = add nsw i32 %64, 1
store i32 %65, i32* %8
br label %47
66: ; preds = %47
%67 = load i32, i32* %4
ret i32 %67
}

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