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


x86 assembly (clang, -O0):
<dMonodip>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    11a3 <dMonodip+0xa3>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm3
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1129 <dMonodip+0x29>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dMonodip>:
test   %ecx,%ecx
jle    11e5 <dMonodip+0xe5>
mov    %ecx,%r8d
cmp    $0x1,%ecx
jne    1117 <dMonodip+0x17>
xor    %ecx,%ecx
jmp    11b0 <dMonodip+0xb0>
lea    (%rdi,%r8,8),%rcx
lea    (%rsi,%r8,8),%rax
cmp    %rdi,%rax
seta   %r10b
lea    (%rdx,%r8,8),%rax
cmp    %rsi,%rcx
seta   %r11b
cmp    %rdi,%rax
seta   %al
cmp    %rdx,%rcx
seta   %r9b
xor    %ecx,%ecx
test   %r11b,%r10b
jne    11b0 <dMonodip+0xb0>
and    %r9b,%al
jne    11b0 <dMonodip+0xb0>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
xor    %eax,%eax
xchg   %ax,%ax
movupd (%rdi,%rax,8),%xmm6
movupd (%rsi,%rax,8),%xmm7
subpd  %xmm8,%xmm7
mulpd  %xmm9,%xmm7
movupd (%rdx,%rax,8),%xmm4
movapd %xmm4,%xmm3
addpd  %xmm5,%xmm3
divpd  %xmm3,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm4,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1170 <dMonodip+0x70>
cmp    %r8,%rcx
je     11e5 <dMonodip+0xe5>
movsd  (%rsi,%rcx,8),%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm3
movsd  (%rdx,%rcx,8),%xmm4
movapd %xmm4,%xmm5
addsd  %xmm2,%xmm5
divsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rdi,%rcx,8),%xmm4
movsd  %xmm4,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    11b0 <dMonodip+0xb0>
ret

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

LLVM IR (-O2):
define void @dMonodip(double* nocapture %0, double* nocapture %1, double %2, double %3, double %4, double* nocapture %5, i32 %6) {
%8 = icmp sgt i32 %6, 0
br i1 %8, label %9, label %69
9: ; preds = %7
%10 = zext i32 %6 to i64
%11 = icmp eq i32 %6, 1
br i1 %11, label %52, label %12
12: ; preds = %9
%13 = getelementptr double, double* %0, i64 %10
%14 = getelementptr double, double* %1, i64 %10
%15 = getelementptr double, double* %5, i64 %10
%16 = icmp ugt double* %14, %0
%17 = icmp ugt double* %13, %1
%18 = and i1 %16, %17
%19 = icmp ugt double* %15, %0
%20 = icmp ugt double* %13, %5
%21 = and i1 %19, %20
%22 = or i1 %18, %21
br i1 %22, label %52, label %23
23: ; preds = %12
%24 = and i64 %10, 4294967294
%25 = insertelement <2 x double> poison, double %3, i64 0
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> zeroinitializer
%27 = insertelement <2 x double> poison, double %2, i64 0
%28 = shufflevector <2 x double> %27, <2 x double> poison, <2 x i32> zeroinitializer
%29 = insertelement <2 x double> poison, double %4, i64 0
%30 = shufflevector <2 x double> %29, <2 x double> poison, <2 x i32> zeroinitializer
br label %31
31: ; preds = %31, %23
%32 = phi i64 [ 0, %23 ], [ %48, %31 ]
%33 = getelementptr inbounds double, double* %0, i64 %32
%34 = bitcast double* %33 to <2 x double>*
%35 = load <2 x double>, <2 x double>* %34
%36 = getelementptr inbounds double, double* %1, i64 %32
%37 = bitcast double* %36 to <2 x double>*
%38 = load <2 x double>, <2 x double>* %37
%39 = fsub <2 x double> %38, %26
%40 = fmul <2 x double> %39, %28
%41 = getelementptr inbounds double, double* %5, i64 %32
%42 = bitcast double* %41 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = fadd <2 x double> %43, %30
%45 = fdiv <2 x double> %43, %44
%46 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %45, <2 x double> %35)
%47 = bitcast double* %33 to <2 x double>*
store <2 x double> %46, <2 x double>* %47
%48 = add nuw i64 %32, 2
%49 = icmp eq i64 %48, %24
br i1 %49, label %50, label %31
50: ; preds = %31
%51 = icmp eq i64 %24, %10
br i1 %51, label %69, label %52
52: ; preds = %12, %9, %50
%53 = phi i64 [ 0, %12 ], [ 0, %9 ], [ %24, %50 ]
br label %54
54: ; preds = %52, %54
%55 = phi i64 [ %67, %54 ], [ %53, %52 ]
%56 = getelementptr inbounds double, double* %0, i64 %55
%57 = load double, double* %56
%58 = getelementptr inbounds double, double* %1, i64 %55
%59 = load double, double* %58
%60 = fsub double %59, %3
%61 = fmul double %60, %2
%62 = getelementptr inbounds double, double* %5, i64 %55
%63 = load double, double* %62
%64 = fadd double %63, %4
%65 = fdiv double %63, %64
%66 = tail call double @llvm.fmuladd.f64(double %61, double %65, double %57)
store double %66, double* %56
%67 = add nuw nsw i64 %55, 1
%68 = icmp eq i64 %67, %10
br i1 %68, label %69, label %54
69: ; preds = %54, %50, %7
ret void
}