void update_test_point_dense_SVRG(double *x, double *w, double *wold,
                                  double *gold, double sigmoid,
                                  double sigmoidold, long d, double stepSize,
                                  double lambda) {
  for (long j = 0; j < d; j++) {
    w[j] -= stepSize * (gold[j] + x[j] * (sigmoid - sigmoidold) +
                        lambda * (w[j] - wold[j]));
  }
}


x86 assembly (clang, -O0):
<update_test_point_dense_SVRG>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
movsd  %xmm3,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    11dc <update_test_point_dense_SVRG+0xdc>
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm3
subsd  -0x30(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1134 <update_test_point_dense_SVRG+0x34>
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_test_point_dense_SVRG>:
push   %rbp
push   %r14
push   %rbx
test   %r8,%r8
jle    115a <update_test_point_dense_SVRG+0x5a>
subsd  %xmm1,%xmm0
xorpd  0xeeb(%rip),%xmm2
cmp    $0x1,%r8
jne    115f <update_test_point_dense_SVRG+0x5f>
xor    %eax,%eax
nopl   (%rax)
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rax,8),%xmm1
movsd  (%rsi,%rax,8),%xmm4
movapd %xmm4,%xmm5
subsd  (%rdx,%rax,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm1,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r8
jne    1120 <update_test_point_dense_SVRG+0x20>
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    (%rcx,%r8,8),%rax
cmp    %rsi,%rax
seta   %r14b
lea    (%rsi,%r8,8),%rax
cmp    %rcx,%rax
seta   %bl
lea    (%rdi,%r8,8),%rbp
cmp    %rsi,%rbp
seta   %r9b
lea    (%rdx,%r8,8),%rbp
cmp    %rdi,%rax
seta   %r11b
cmp    %rsi,%rbp
seta   %r10b
cmp    %rdx,%rax
seta   %bpl
xor    %eax,%eax
test   %bl,%r14b
jne    1120 <update_test_point_dense_SVRG+0x20>
and    %r11b,%r9b
jne    1120 <update_test_point_dense_SVRG+0x20>
and    %bpl,%r10b
jne    1120 <update_test_point_dense_SVRG+0x20>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
movapd %xmm0,%xmm10
unpcklpd %xmm0,%xmm10
movapd %xmm3,%xmm9
unpcklpd %xmm3,%xmm9
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
lea    -0x2(%rax),%rbp
mov    %rbp,%r10
shr    %r10
add    $0x1,%r10
test   %rbp,%rbp
je     12ec <update_test_point_dense_SVRG+0x1ec>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %r9d,%r9d
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%r9,8),%xmm6
movupd (%rdi,%r9,8),%xmm7
mulpd  %xmm10,%xmm7
addpd  %xmm6,%xmm7
movupd (%rdx,%r9,8),%xmm6
movupd (%rsi,%r9,8),%xmm5
movupd 0x10(%rsi,%r9,8),%xmm4
movapd %xmm5,%xmm1
subpd  %xmm6,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,(%rsi,%r9,8)
movupd 0x10(%rcx,%r9,8),%xmm1
movupd 0x10(%rdi,%r9,8),%xmm5
mulpd  %xmm10,%xmm5
addpd  %xmm1,%xmm5
movupd 0x10(%rdx,%r9,8),%xmm1
movapd %xmm4,%xmm6
subpd  %xmm1,%xmm6
mulpd  %xmm9,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,0x10(%rsi,%r9,8)
add    $0x4,%r9
add    $0xfffffffffffffffe,%r11
jne    1200 <update_test_point_dense_SVRG+0x100>
test   $0x1,%r10b
je     12de <update_test_point_dense_SVRG+0x1de>
movupd (%rcx,%r9,8),%xmm1
movupd (%rdi,%r9,8),%xmm4
mulpd  %xmm10,%xmm4
addpd  %xmm1,%xmm4
movupd (%rsi,%r9,8),%xmm1
movupd (%rdx,%r9,8),%xmm5
movapd %xmm1,%xmm6
subpd  %xmm5,%xmm6
mulpd  %xmm6,%xmm9
addpd  %xmm4,%xmm9
mulpd  %xmm9,%xmm8
addpd  %xmm1,%xmm8
movupd %xmm8,(%rsi,%r9,8)
cmp    %r8,%rax
jne    1120 <update_test_point_dense_SVRG+0x20>
jmp    115a <update_test_point_dense_SVRG+0x5a>
xor    %r9d,%r9d
test   $0x1,%r10b
jne    129b <update_test_point_dense_SVRG+0x19b>
jmp    12de <update_test_point_dense_SVRG+0x1de>

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

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