void dReactionI(double sys[], double x[], double K, int NumCel) {
  int i;
  for (i = 0; i < NumCel; i++) {
    sys[i] = sys[i] + K * x[NumCel - 1 - i];
  }
}


x86 assembly (clang, -O0):
<dReactionI>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1171 <dReactionI+0x71>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111b <dReactionI+0x1b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dReactionI>:
test   %edx,%edx
jle    119d <dReactionI+0x9d>
mov    %edx,%r10d
cmp    $0x4,%edx
jae    119e <dReactionI+0x9e>
xor    %r8d,%r8d
mov    %r8,%rax
not    %rax
test   $0x1,%r10b
je     1146 <dReactionI+0x46>
mov    %r8d,%ecx
not    %ecx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%r8,8),%xmm1
movsd  %xmm1,(%rdi,%r8,8)
or     $0x1,%r8
add    %r10,%rax
je     119d <dReactionI+0x9d>
sub    %r8,%r10
mov    %r8d,%ecx
not    %ecx
add    %edx,%ecx
lea    (%rdi,%r8,8),%rax
add    $0x8,%rax
xor    %edx,%edx
nop
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rax,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rdx,8)
lea    -0x1(%rcx),%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
add    $0x2,%rdx
add    $0xfffffffe,%ecx
cmp    %rdx,%r10
jne    1160 <dReactionI+0x60>
ret
lea    -0x1(%r10),%r9
lea    -0x1(%rdx),%ecx
mov    %ecx,%eax
sub    %r9d,%eax
xor    %r8d,%r8d
cmp    %ecx,%eax
jg     1117 <dReactionI+0x17>
shr    $0x20,%r9
jne    1117 <dReactionI+0x17>
lea    -0x1(%rdx),%eax
movslq %eax,%r8
lea    (%rsi,%r8,8),%rax
add    $0x8,%rax
cmp    %rdi,%rax
jbe    11ea <dReactionI+0xea>
lea    (%rdi,%r10,8),%r9
add    $0x1,%r8
sub    %r10,%r8
lea    (%rsi,%r8,8),%rax
cmp    %r9,%rax
jb     1114 <dReactionI+0x14>
mov    %r10d,%r8d
and    $0xfffffffc,%r8d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    0x0(,%r10,8),%r9
and    $0xffffffffffffffe0,%r9
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rdi,%rax,1),%xmm2
movupd 0x10(%rdi,%rax,1),%xmm3
movslq %ecx,%rcx
movupd -0x18(%rsi,%rcx,8),%xmm4
movupd -0x8(%rsi,%rcx,8),%xmm5
shufpd $0x1,%xmm5,%xmm5
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,(%rdi,%rax,1)
movupd %xmm4,0x10(%rdi,%rax,1)
add    $0x20,%rax
add    $0xfffffffc,%ecx
cmp    %rax,%r9
jne    1210 <dReactionI+0x110>
cmp    %r10,%r8
je     119d <dReactionI+0x9d>
jmp    1117 <dReactionI+0x17>

LLVM IR (-O0):
define void @dReactionI(double* %0, double* %1, double %2, i32 %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca double
%8 = alloca i32
%9 = alloca i32
store double* %0, double** %5
store double* %1, double** %6
store double %2, double* %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %34, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %8
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %37
14: ; preds = %10
%15 = load double*, double** %5
%16 = load i32, i32* %9
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds double, double* %15, i64 %17
%19 = load double, double* %18
%20 = load double, double* %7
%21 = load double*, double** %6
%22 = load i32, i32* %8
%23 = sub nsw i32 %22, 1
%24 = load i32, i32* %9
%25 = sub nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %21, i64 %26
%28 = load double, double* %27
%29 = call double @llvm.fmuladd.f64(double %20, double %28, double %19)
%30 = load double*, double** %5
%31 = load i32, i32* %9
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %30, i64 %32
store double %29, double* %33
br label %34
34: ; preds = %14
%35 = load i32, i32* %9
%36 = add nsw i32 %35, 1
store i32 %36, i32* %9
br label %10
37: ; preds = %10
ret void
}

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