void differ(s, nt, dt, iv) float *s, *dt, *iv;
int nt;
{
  float c0, c1;
  float tot = 0.0;
  int it;
  c0 = 1.0 / (*dt);
  for (it = nt - 1; it > 0; it--)
    s[it] = (s[it] - s[it - 1]) * c0;
  s[0] = (s[0] - (*iv)) * c0;
}


x86 assembly (clang, -O0):
<differ>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xed1(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    118e <differ+0x8e>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1145 <differ+0x45>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<differ>:
push   %rbx
movss  0xef7(%rip),%xmm0
divss  (%rdx),%xmm0
cmp    $0x2,%esi
jl     116c <differ+0x6c>
mov    $0xfffffffe,%eax
mov    %esi,%ebx
xor    %r10d,%r10d
mov    %rbx,%rdx
sub    $0x2,%rdx
mov    $0x0,%r8d
cmovae %rdx,%r8
add    $0x1,%r8
cmp    $0x8,%r8
jae    117e <differ+0x7e>
add    %rbx,%rax
add    $0xffffffffffffffff,%rbx
xchg   %ax,%ax
mov    %ebx,%edx
movss  (%rdi,%rdx,4),%xmm1
mov    %eax,%esi
subss  (%rdi,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rdx,4)
add    $0xffffffffffffffff,%rax
lea    -0x1(%rbx),%rdx
add    $0x1,%rbx
cmp    $0x2,%rbx
mov    %rdx,%rbx
ja     1140 <differ+0x40>
movss  (%rdi),%xmm1
subss  (%rcx),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,(%rdi)
pop    %rbx
ret
mov    %ebx,%r11d
sub    $0x2,%r11d
cmovb  %r10d,%r11d
mov    %rbx,%rdx
sub    $0x2,%rdx
cmovae %rdx,%r10
lea    -0x1(%rsi),%r9d
cmp    %r11d,%r9d
jb     1137 <differ+0x37>
mov    %r10,%rdx
shr    $0x20,%rdx
jne    1137 <differ+0x37>
add    $0xfffffffe,%esi
cmp    %r11d,%esi
jb     1137 <differ+0x37>
test   %rdx,%rdx
jne    1137 <differ+0x37>
lea    (%rdi,%r9,4),%r11
shl    $0x2,%r10
mov    %r11,%rdx
sub    %r10,%rdx
cmp    %r11,%rdx
ja     1137 <differ+0x37>
xor    %edx,%edx
test   %dl,%dl
jne    1137 <differ+0x37>
lea    (%rdi,%rsi,4),%r11
mov    %r11,%rdx
sub    %r10,%rdx
cmp    %r11,%rdx
ja     1137 <differ+0x37>
xor    %edx,%edx
test   %dl,%dl
jne    1137 <differ+0x37>
cmp    $0x2,%rbx
mov    $0x2,%r10d
cmovb  %rbx,%r10
lea    (%r10,%r9,1),%rdx
sub    %rbx,%rdx
lea    (%rdi,%rdx,4),%r11
lea    (%rdi,%rsi,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%r11
jae    1232 <differ+0x132>
lea    (%rdi,%r9,4),%rdx
add    $0x4,%rdx
add    %rsi,%r10
sub    %rbx,%r10
lea    (%rdi,%r10,4),%rsi
cmp    %rdx,%rsi
jb     1137 <differ+0x37>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    (%rax,%rbx,1),%rsi
add    $0x1,%rsi
sub    %r9,%rbx
shufps $0x1b,%xmm1,%xmm1
mov    %r9,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%edx
movups -0x1c(%rdi,%rdx,4),%xmm2
movups -0xc(%rdi,%rdx,4),%xmm3
lea    -0x1(%rsi),%r11d
movups -0x1c(%rdi,%r11,4),%xmm4
subps  %xmm4,%xmm2
movups -0xc(%rdi,%r11,4),%xmm4
subps  %xmm4,%xmm3
mulps  %xmm1,%xmm3
movups %xmm3,-0xc(%rdi,%rdx,4)
mulps  %xmm1,%xmm2
movups %xmm2,-0x1c(%rdi,%rdx,4)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffff8,%r10
jne    1260 <differ+0x160>
cmp    %r9,%r8
jne    1137 <differ+0x37>
jmp    116c <differ+0x6c>

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

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