void computeTotal(float w[], float q[], float t[], float p[], float e[],
                  float total[]) {
  int i;
  for (i = 0; i < 100; i++) {
    total[i] = (w[i] * 0.30) + (q[i] * 0.15) + (t[i] * 0.20) + (p[i] * 0.15) +
               (e[i] * 0.20);
  }
}


x86 assembly (clang, -O0):
<computeTotal>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x64,-0x34(%rbp)
jge    11ed <computeTotal+0xed>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xeb1(%rip),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xead(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe7c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe63(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe3a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1123 <computeTotal+0x23>
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeTotal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    0x190(%rdi),%rax
cmp    %r9,%rax
seta   %r13b
lea    0x190(%r9),%rbp
cmp    %rdi,%rbp
seta   %r14b
lea    0x190(%rsi),%rax
cmp    %r9,%rax
seta   %bl
cmp    %rsi,%rbp
seta   %r12b
lea    0x190(%rdx),%rax
cmp    %r9,%rax
seta   %r15b
cmp    %rdx,%rbp
seta   -0x1(%rsp)
lea    0x190(%rcx),%rax
cmp    %r9,%rax
seta   %r11b
cmp    %rcx,%rbp
seta   -0x2(%rsp)
lea    0x190(%r8),%rax
cmp    %r9,%rax
seta   %r10b
cmp    %r8,%rbp
seta   %bpl
test   %r14b,%r13b
jne    126e <computeTotal+0x16e>
and    %r12b,%bl
jne    126e <computeTotal+0x16e>
and    -0x1(%rsp),%r15b
jne    126e <computeTotal+0x16e>
and    -0x2(%rsp),%r11b
jne    126e <computeTotal+0x16e>
and    %bpl,%r10b
jne    126e <computeTotal+0x16e>
xor    %eax,%eax
movapd 0xe4a(%rip),%xmm0
movapd 0xe52(%rip),%xmm1
movapd 0xe5a(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
cvtps2pd (%rdi,%rax,1),%xmm3
cvtps2pd 0x8(%rdi,%rax,1),%xmm4
cvtps2pd 0x8(%rsi,%rax,1),%xmm5
cvtps2pd (%rsi,%rax,1),%xmm6
mulpd  %xmm0,%xmm6
mulpd  %xmm0,%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm5,%xmm4
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
cvtps2pd 0x8(%rdx,%rax,1),%xmm5
cvtps2pd (%rdx,%rax,1),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm4,%xmm5
cvtps2pd (%rcx,%rax,1),%xmm3
cvtps2pd 0x8(%rcx,%rax,1),%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm5,%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm6,%xmm3
cvtps2pd 0x8(%r8,%rax,1),%xmm5
cvtps2pd (%r8,%rax,1),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm4,%xmm5
cvtpd2ps %xmm5,%xmm3
cvtpd2ps %xmm6,%xmm4
unpcklpd %xmm3,%xmm4
movupd %xmm4,(%r9,%rax,1)
add    $0x10,%rax
cmp    $0x190,%rax
jne    11d0 <computeTotal+0xd0>
jmp    12fb <computeTotal+0x1fb>
xor    %eax,%eax
movsd  0xdb8(%rip),%xmm0
movsd  0xdb8(%rip),%xmm1
movsd  0xdb8(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rax,1),%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%rsi,%rax,1),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
movss  (%rdx,%rax,1),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movss  (%rcx,%rax,1),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movss  (%r8,%rax,1),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,(%r9,%rax,1)
add    $0x4,%rax
cmp    $0x190,%rax
jne    1290 <computeTotal+0x190>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @computeTotal(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture writeonly %5) {
%7 = getelementptr float, float* %5, i64 100
%8 = getelementptr float, float* %0, i64 100
%9 = getelementptr float, float* %1, i64 100
%10 = getelementptr float, float* %2, i64 100
%11 = getelementptr float, float* %3, i64 100
%12 = getelementptr float, float* %4, i64 100
%13 = icmp ugt float* %8, %5
%14 = icmp ugt float* %7, %0
%15 = and i1 %13, %14
%16 = icmp ugt float* %9, %5
%17 = icmp ugt float* %7, %1
%18 = and i1 %16, %17
%19 = or i1 %15, %18
%20 = icmp ugt float* %10, %5
%21 = icmp ugt float* %7, %2
%22 = and i1 %20, %21
%23 = or i1 %19, %22
%24 = icmp ugt float* %11, %5
%25 = icmp ugt float* %7, %3
%26 = and i1 %24, %25
%27 = or i1 %23, %26
%28 = icmp ugt float* %12, %5
%29 = icmp ugt float* %7, %4
%30 = and i1 %28, %29
%31 = or i1 %27, %30
br i1 %31, label %64, label %32
32: ; preds = %6, %32
%33 = phi i64 [ %62, %32 ], [ 0, %6 ]
%34 = getelementptr inbounds float, float* %0, i64 %33
%35 = bitcast float* %34 to <4 x float>*
%36 = load <4 x float>, <4 x float>* %35
%37 = fpext <4 x float> %36 to <4 x double>
%38 = getelementptr inbounds float, float* %1, i64 %33
%39 = bitcast float* %38 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = fpext <4 x float> %40 to <4 x double>
%42 = fmul <4 x double> %41, <double 1.500000e-01, double 1.500000e-01, double 1.500000e-01, double 1.500000e-01>
%43 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %37, <4 x double> <double 3.000000e-01, double 3.000000e-01, double 3.000000e-01, double 3.000000e-01>, <4 x double> %42)
%44 = getelementptr inbounds float, float* %2, i64 %33
%45 = bitcast float* %44 to <4 x float>*
%46 = load <4 x float>, <4 x float>* %45
%47 = fpext <4 x float> %46 to <4 x double>
%48 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %47, <4 x double> <double 2.000000e-01, double 2.000000e-01, double 2.000000e-01, double 2.000000e-01>, <4 x double> %43)
%49 = getelementptr inbounds float, float* %3, i64 %33
%50 = bitcast float* %49 to <4 x float>*
%51 = load <4 x float>, <4 x float>* %50
%52 = fpext <4 x float> %51 to <4 x double>
%53 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %52, <4 x double> <double 1.500000e-01, double 1.500000e-01, double 1.500000e-01, double 1.500000e-01>, <4 x double> %48)
%54 = getelementptr inbounds float, float* %4, i64 %33
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = fpext <4 x float> %56 to <4 x double>
%58 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %57, <4 x double> <double 2.000000e-01, double 2.000000e-01, double 2.000000e-01, double 2.000000e-01>, <4 x double> %53)
%59 = fptrunc <4 x double> %58 to <4 x float>
%60 = getelementptr inbounds float, float* %5, i64 %33
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %59, <4 x float>* %61
%62 = add nuw i64 %33, 4
%63 = icmp eq i64 %62, 100
br i1 %63, label %90, label %32
64: ; preds = %6, %64
%65 = phi i64 [ %88, %64 ], [ 0, %6 ]
%66 = getelementptr inbounds float, float* %0, i64 %65
%67 = load float, float* %66
%68 = fpext float %67 to double
%69 = getelementptr inbounds float, float* %1, i64 %65
%70 = load float, float* %69
%71 = fpext float %70 to double
%72 = fmul double %71, 1.500000e-01
%73 = tail call double @llvm.fmuladd.f64(double %68, double 3.000000e-01, double %72)
%74 = getelementptr inbounds float, float* %2, i64 %65
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = tail call double @llvm.fmuladd.f64(double %76, double 2.000000e-01, double %73)
%78 = getelementptr inbounds float, float* %3, i64 %65
%79 = load float, float* %78
%80 = fpext float %79 to double
%81 = tail call double @llvm.fmuladd.f64(double %80, double 1.500000e-01, double %77)
%82 = getelementptr inbounds float, float* %4, i64 %65
%83 = load float, float* %82
%84 = fpext float %83 to double
%85 = tail call double @llvm.fmuladd.f64(double %84, double 2.000000e-01, double %81)
%86 = fptrunc double %85 to float
%87 = getelementptr inbounds float, float* %5, i64 %65
store float %86, float* %87
%88 = add nuw nsw i64 %65, 1
%89 = icmp eq i64 %88, 100
br i1 %89, label %90, label %64
90: ; preds = %32, %64
ret void
}