void dMonod(double sys[], double K, double KMonod, double xMonod[],
            int NumCel) {
  int i;
  for (i = 0; i < NumCel; i++) {
    sys[i] = sys[i] + K * (xMonod[i] / (KMonod + xMonod[i]));
  }
}


x86 assembly (clang, -O0):
<dMonod>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1184 <dMonod+0x84>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x18(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
divsd  %xmm3,%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    1120 <dMonod+0x20>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dMonod>:
test   %edx,%edx
jle    1281 <dMonod+0x181>
mov    %edx,%r9d
cmp    $0x1,%edx
je     112a <dMonod+0x2a>
lea    (%rsi,%r9,8),%rax
cmp    %rdi,%rax
jbe    11bf <dMonod+0xbf>
lea    (%rdi,%r9,8),%rax
cmp    %rsi,%rax
jbe    11bf <dMonod+0xbf>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     115b <dMonod+0x5b>
movsd  (%rsi,%rcx,8),%xmm2
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdi,%rcx,8),%xmm2
movsd  %xmm2,(%rdi,%rcx,8)
or     $0x1,%rcx
add    %r9,%rax
je     1281 <dMonod+0x181>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rcx,8),%xmm2
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdi,%rcx,8),%xmm2
movsd  %xmm2,(%rdi,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm2
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rdi,%rcx,8),%xmm2
movsd  %xmm2,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1170 <dMonod+0x70>
jmp    1281 <dMonod+0x181>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
lea    -0x2(%rcx),%rax
mov    %rax,%r8
shr    %r8
add    $0x1,%r8
test   %rax,%rax
je     1282 <dMonod+0x182>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rsi,%rdx,8),%xmm4
movapd %xmm4,%xmm5
addpd  %xmm3,%xmm5
divpd  %xmm5,%xmm4
mulpd  %xmm2,%xmm4
movupd (%rdi,%rdx,8),%xmm5
addpd  %xmm4,%xmm5
movupd 0x10(%rdi,%rdx,8),%xmm4
movupd %xmm5,(%rdi,%rdx,8)
movupd 0x10(%rsi,%rdx,8),%xmm5
movapd %xmm5,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm6,%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,0x10(%rdi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rax
jne    1200 <dMonod+0x100>
test   $0x1,%r8b
je     1278 <dMonod+0x178>
movupd (%rdi,%rdx,8),%xmm4
movupd (%rsi,%rdx,8),%xmm5
addpd  %xmm5,%xmm3
divpd  %xmm3,%xmm5
mulpd  %xmm5,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rdi,%rdx,8)
cmp    %r9,%rcx
jne    112c <dMonod+0x2c>
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    1259 <dMonod+0x159>
jmp    1278 <dMonod+0x178>

LLVM IR (-O0):
define void @dMonod(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 = %41, %5
%13 = load i32, i32* %11
%14 = load i32, i32* %10
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %44
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* %7
%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 = load double, double* %8
%29 = load double*, double** %9
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = fadd double %28, %33
%35 = fdiv double %27, %34
%36 = call double @llvm.fmuladd.f64(double %22, double %35, double %21)
%37 = load double*, double** %6
%38 = load i32, i32* %11
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %37, i64 %39
store double %36, double* %40
br label %41
41: ; preds = %16
%42 = load i32, i32* %11
%43 = add nsw i32 %42, 1
store i32 %43, i32* %11
br label %12
44: ; preds = %12
ret void
}

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