void backup_fluxes(double *s, double *s_backup, int Nreact) {
  double *dummy1, *dummy2;
  dummy2 = s;
  for (dummy1 = s_backup; dummy1 < s_backup + Nreact; dummy1++) {
    *dummy1 = *dummy2;
    dummy2++;
  }
}


x86 assembly (clang, -O0):
<backup_fluxes>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1168 <backup_fluxes+0x68>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
jmp    111f <backup_fluxes+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<backup_fluxes>:
test   %edx,%edx
jle    1265 <backup_fluxes+0x165>
movslq %edx,%rax
lea    (%rsi,%rax,8),%r11
lea    0x8(%rsi),%rcx
cmp    %rcx,%r11
mov    %rcx,%r9
cmova  %r11,%r9
mov    %rsi,%rax
not    %rax
add    %rax,%r9
cmp    $0x18,%r9
jb     1250 <backup_fluxes+0x150>
cmp    %rcx,%r11
cmova  %r11,%rcx
add    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rdi,%rcx,1),%rax
add    $0x8,%rax
cmp    %rsi,%rax
jbe    115c <backup_fluxes+0x5c>
lea    (%rsi,%rcx,1),%rax
add    $0x8,%rax
cmp    %rdi,%rax
ja     1250 <backup_fluxes+0x150>
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0xc,%rax
jae    118b <backup_fluxes+0x8b>
xor    %ecx,%ecx
jmp    11f8 <backup_fluxes+0xf8>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rcx,8),%xmm0
movups 0x10(%rdi,%rcx,8),%xmm1
movups %xmm0,(%rsi,%rcx,8)
movups %xmm1,0x10(%rsi,%rcx,8)
movups 0x20(%rdi,%rcx,8),%xmm0
movups 0x30(%rdi,%rcx,8),%xmm1
movups %xmm0,0x20(%rsi,%rcx,8)
movups %xmm1,0x30(%rsi,%rcx,8)
movups 0x40(%rdi,%rcx,8),%xmm0
movups 0x50(%rdi,%rcx,8),%xmm1
movups %xmm0,0x40(%rsi,%rcx,8)
movups %xmm1,0x50(%rsi,%rcx,8)
movups 0x60(%rdi,%rcx,8),%xmm0
movups 0x70(%rdi,%rcx,8),%xmm1
movups %xmm0,0x60(%rsi,%rcx,8)
movups %xmm1,0x70(%rsi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    11a0 <backup_fluxes+0xa0>
test   %r10,%r10
je     123b <backup_fluxes+0x13b>
lea    (%rsi,%rcx,8),%rdx
add    $0x10,%rdx
lea    (%rdi,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%rdx,%rax,1)
movups %xmm1,(%rdx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    1220 <backup_fluxes+0x120>
cmp    %r8,%r9
je     1265 <backup_fluxes+0x165>
lea    (%rdi,%r8,8),%rdi
lea    (%rsi,%r8,8),%rsi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rsi)
add    $0x8,%rdi
add    $0x8,%rsi
cmp    %r11,%rsi
jb     1250 <backup_fluxes+0x150>
ret

LLVM IR (-O0):
define void @backup_fluxes(double* %0, double* %1, i32 %2) {
%4 = alloca double*
%5 = alloca double*
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
store double* %0, double** %4
store double* %1, double** %5
store i32 %2, i32* %6
%9 = load double*, double** %4
store double* %9, double** %8
%10 = load double*, double** %5
store double* %10, double** %7
br label %11
11: ; preds = %24, %3
%12 = load double*, double** %7
%13 = load double*, double** %5
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds double, double* %13, i64 %15
%17 = icmp ult double* %12, %16
br i1 %17, label %18, label %27
18: ; preds = %11
%19 = load double*, double** %8
%20 = load double, double* %19
%21 = load double*, double** %7
store double %20, double* %21
%22 = load double*, double** %8
%23 = getelementptr inbounds double, double* %22, i32 1
store double* %23, double** %8
br label %24
24: ; preds = %18
%25 = load double*, double** %7
%26 = getelementptr inbounds double, double* %25, i32 1
store double* %26, double** %7
br label %11
27: ; preds = %11
ret void
}

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