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


x86 assembly (clang, -O0):
<dReactionIi>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1182 <dReactionIi+0x82>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    111f <dReactionIi+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dReactionIi>:
push   %rbp
push   %r14
push   %rbx
test   %ecx,%ecx
jle    12c8 <dReactionIi+0x1c8>
mov    %ecx,%r8d
cmp    $0x4,%ecx
jae    111c <dReactionIi+0x1c>
xor    %r10d,%r10d
jmp    121a <dReactionIi+0x11a>
lea    -0x1(%r8),%r11
lea    -0x1(%rcx),%r9d
mov    %r9d,%eax
sub    %r11d,%eax
xor    %r10d,%r10d
cmp    %r9d,%eax
jg     121a <dReactionIi+0x11a>
shr    $0x20,%r11
jne    121a <dReactionIi+0x11a>
lea    (%rdi,%r8,8),%r11
lea    (%rdx,%r8,8),%r10
lea    -0x1(%rcx),%ebx
movslq %ebx,%rbx
lea    0x1(%rbx),%rax
sub    %r8,%rax
cmp    %rdi,%r10
seta   %bpl
lea    (%rsi,%rax,8),%rax
cmp    %rdx,%r11
seta   %r14b
lea    (%rsi,%rbx,8),%rbx
add    $0x8,%rbx
cmp    %rdi,%rbx
seta   %bl
cmp    %r11,%rax
setb   %r11b
xor    %r10d,%r10d
test   %r14b,%bpl
jne    121a <dReactionIi+0x11a>
and    %r11b,%bl
jne    121a <dReactionIi+0x11a>
mov    %r8d,%r10d
and    $0xfffffffc,%r10d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    0x0(,%r8,8),%r11
and    $0xffffffffffffffe0,%r11
xor    %eax,%eax
xchg   %ax,%ax
movupd (%rdi,%rax,1),%xmm2
movupd 0x10(%rdi,%rax,1),%xmm3
movupd (%rdx,%rax,1),%xmm4
movupd 0x10(%rdx,%rax,1),%xmm5
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movslq %r9d,%r9
movupd -0x18(%rsi,%r9,8),%xmm6
movupd -0x8(%rsi,%r9,8),%xmm7
shufpd $0x1,%xmm7,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm2,%xmm7
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm7,(%rdi,%rax,1)
movupd %xmm6,0x10(%rdi,%rax,1)
add    $0x20,%rax
add    $0xfffffffc,%r9d
cmp    %rax,%r11
jne    11b0 <dReactionIi+0xb0>
cmp    %r8,%r10
je     12c8 <dReactionIi+0x1c8>
mov    %r10,%rax
not    %rax
test   $0x1,%r8b
je     124f <dReactionIi+0x14f>
movsd  (%rdx,%r10,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %r10d,%ebp
not    %ebp
add    %ecx,%ebp
movslq %ebp,%rcx
mulsd  (%rsi,%rcx,8),%xmm1
addsd  (%rdi,%r10,8),%xmm1
movsd  %xmm1,(%rdi,%r10,8)
or     $0x1,%r10
add    %r8,%rax
je     12c8 <dReactionIi+0x1c8>
mov    %r10d,%ecx
not    %ecx
mov    $0xfffffffe,%eax
sub    %r10d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%r10,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%r8,%rcx,1),%ebp
movslq %ebp,%rbp
mulsd  (%rsi,%rbp,8),%xmm1
addsd  (%rdi,%r10,8),%xmm1
movsd  %xmm1,(%rdi,%r10,8)
movsd  0x8(%rdx,%r10,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%rax,%r8,1),%ebp
movslq %ebp,%rbp
mulsd  (%rsi,%rbp,8),%xmm1
addsd  0x8(%rdi,%r10,8),%xmm1
movsd  %xmm1,0x8(%rdi,%r10,8)
add    $0x2,%r10
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffffffffffe,%rax
cmp    %r10,%r8
jne    1270 <dReactionIi+0x170>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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