void chder(float a, float b, float c[], float cder[], int n) {
  int j;
  float con;
  cder[n - 1] = 0.0;
  cder[n - 2] = 2 * (n - 1) * c[n - 1];
  for (j = n - 3; j >= 0; j--)
    cder[j] = cder[j + 2] + 2 * (j + 1) * c[j + 1];
  con = 2.0 / (b - a);
  for (j = 0; j < n; j++)
    cder[j] *= con;
}


x86 assembly (clang, -O0):
<chder>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     11c6 <chder+0xc6>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%eax
add    $0x1,%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1168 <chder+0x68>
movss  -0x8(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe24(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1221 <chder+0x121>
movss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11f0 <chder+0xf0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<chder>:
movslq %edx,%rax
movl   $0x0,-0x4(%rsi,%rax,4)
lea    (%rax,%rax,1),%ecx
add    $0xfffffffe,%ecx
cvtsi2ss %ecx,%xmm2
mulss  -0x4(%rdi,%rax,4),%xmm2
movss  %xmm2,-0x8(%rsi,%rax,4)
cmp    $0x3,%eax
jl     1243 <chder+0x143>
mov    %edx,%ecx
add    $0xfffffffd,%ecx
je     1157 <chder+0x57>
lea    (%rdi,%rcx,4),%rax
add    $0x8,%rax
cmp    %rsi,%rax
jbe    11e5 <chder+0xe5>
lea    (%rsi,%rcx,4),%r8
add    $0xc,%r8
lea    0x4(%rdi),%rax
cmp    %r8,%rax
jae    11e5 <chder+0xe5>
mov    %rcx,%r10
mov    %r10,%rcx
test   $0x1,%r10b
jne    1188 <chder+0x88>
lea    0x1(%r10),%rax
add    %eax,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  0x4(%rdi,%r10,4),%xmm2
addss  0x8(%rsi,%r10,4),%xmm2
movss  %xmm2,(%rsi,%r10,4)
lea    -0x1(%r10),%rcx
test   %r10,%r10
je     1243 <chder+0x143>
lea    (%rcx,%rcx,1),%r8d
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x2(%r8),%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  0x4(%rdi,%rcx,4),%xmm2
addss  0x8(%rsi,%rcx,4),%xmm2
movss  %xmm2,(%rsi,%rcx,4)
xorps  %xmm2,%xmm2
cvtsi2ss %r8d,%xmm2
mulss  (%rdi,%rcx,4),%xmm2
addss  0x4(%rsi,%rcx,4),%xmm2
movss  %xmm2,-0x4(%rsi,%rcx,4)
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffc,%r8d
cmp    $0xffffffffffffffff,%rcx
jne    11a0 <chder+0xa0>
jmp    1243 <chder+0x143>
lea    0x1(%rcx),%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
mov    %rcx,%r10
sub    %r9,%r10
mov    %r9,%r11
nopl   0x0(%rax)
movsd  0x4(%rsi,%rcx,4),%xmm2
movd   %ecx,%xmm3
lea    0x1(%rcx),%eax
movd   %eax,%xmm4
punpckldq %xmm3,%xmm4
paddd  %xmm4,%xmm4
cvtdq2ps %xmm4,%xmm3
movsd  (%rdi,%rcx,4),%xmm4
shufps $0xe1,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm2,%xmm3
movlps %xmm3,-0x4(%rsi,%rcx,4)
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffffffffffe,%r11
jne    1200 <chder+0x100>
cmp    %r9,%r8
jne    115a <chder+0x5a>
test   %edx,%edx
jle    1317 <chder+0x217>
subss  %xmm0,%xmm1
movss  0xda9(%rip),%xmm0
divss  %xmm1,%xmm0
mov    %edx,%eax
cmp    $0x8,%edx
jae    1269 <chder+0x169>
xor    %ecx,%ecx
jmp    1300 <chder+0x200>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1318 <chder+0x218>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
movups 0x20(%rsi,%rdx,4),%xmm4
movups 0x30(%rsi,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rsi,%rdx,4)
movups %xmm3,0x10(%rsi,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rsi,%rdx,4)
movups %xmm5,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12a0 <chder+0x1a0>
test   $0x1,%r8b
je     12fa <chder+0x1fa>
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rsi,%rdx,4)
movups %xmm3,0x10(%rsi,%rdx,4)
cmp    %rax,%rcx
je     1317 <chder+0x217>
nop
movss  (%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1300 <chder+0x200>
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    12e2 <chder+0x1e2>
jmp    12fa <chder+0x1fa>

LLVM IR (-O0):
define void @chder(float %0, float %1, float* %2, float* %3, i32 %4) {
%6 = alloca float
%7 = alloca float
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
store float %0, float* %6
store float %1, float* %7
store float* %2, float** %8
store float* %3, float** %9
store i32 %4, i32* %10
%13 = load float*, float** %9
%14 = load i32, i32* %10
%15 = sub nsw i32 %14, 1
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds float, float* %13, i64 %16
store float 0.000000e+00, float* %17
%18 = load i32, i32* %10
%19 = sub nsw i32 %18, 1
%20 = mul nsw i32 2, %19
%21 = sitofp i32 %20 to float
%22 = load float*, float** %8
%23 = load i32, i32* %10
%24 = sub nsw i32 %23, 1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds float, float* %22, i64 %25
%27 = load float, float* %26
%28 = fmul float %21, %27
%29 = load float*, float** %9
%30 = load i32, i32* %10
%31 = sub nsw i32 %30, 2
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %29, i64 %32
store float %28, float* %33
%34 = load i32, i32* %10
%35 = sub nsw i32 %34, 3
store i32 %35, i32* %11
br label %36
36: ; preds = %61, %5
%37 = load i32, i32* %11
%38 = icmp sge i32 %37, 0
br i1 %38, label %39, label %64
39: ; preds = %36
%40 = load float*, float** %9
%41 = load i32, i32* %11
%42 = add nsw i32 %41, 2
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %40, i64 %43
%45 = load float, float* %44
%46 = load i32, i32* %11
%47 = add nsw i32 %46, 1
%48 = mul nsw i32 2, %47
%49 = sitofp i32 %48 to float
%50 = load float*, float** %8
%51 = load i32, i32* %11
%52 = add nsw i32 %51, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %50, i64 %53
%55 = load float, float* %54
%56 = call float @llvm.fmuladd.f32(float %49, float %55, float %45)
%57 = load float*, float** %9
%58 = load i32, i32* %11
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
store float %56, float* %60
br label %61
61: ; preds = %39
%62 = load i32, i32* %11
%63 = add nsw i32 %62, -1
store i32 %63, i32* %11
br label %36
64: ; preds = %36
%65 = load float, float* %7
%66 = load float, float* %6
%67 = fsub float %65, %66
%68 = fpext float %67 to double
%69 = fdiv double 2.000000e+00, %68
%70 = fptrunc double %69 to float
store float %70, float* %12
store i32 0, i32* %11
br label %71
71: ; preds = %83, %64
%72 = load i32, i32* %11
%73 = load i32, i32* %10
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %86
75: ; preds = %71
%76 = load float, float* %12
%77 = load float*, float** %9
%78 = load i32, i32* %11
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %77, i64 %79
%81 = load float, float* %80
%82 = fmul float %81, %76
store float %82, float* %80
br label %83
83: ; preds = %75
%84 = load i32, i32* %11
%85 = add nsw i32 %84, 1
store i32 %85, i32* %11
br label %71
86: ; preds = %71
ret void
}

LLVM IR (-O2):
define void @chder(float %0, float %1, float* nocapture %2, float* nocapture %3, i32 %4) {
%6 = add nsw i32 %4, -1
%7 = sext i32 %6 to i64
%8 = getelementptr inbounds float, float* %3, i64 %7
store float 0.000000e+00, float* %8
%9 = shl nsw i32 %6, 1
%10 = sitofp i32 %9 to float
%11 = getelementptr inbounds float, float* %2, i64 %7
%12 = load float, float* %11
%13 = fmul float %12, %10
%14 = add nsw i32 %4, -2
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds float, float* %3, i64 %15
store float %13, float* %16
%17 = icmp sgt i32 %4, 2
br i1 %17, label %18, label %109
18: ; preds = %5
%19 = add nsw i32 %4, -3
%20 = zext i32 %19 to i64
%21 = add nuw nsw i64 %20, 1
%22 = icmp eq i32 %19, 0
br i1 %22, label %63, label %23
23: ; preds = %18
%24 = add nuw nsw i64 %20, 3
%25 = getelementptr float, float* %3, i64 %24
%26 = getelementptr float, float* %2, i64 1
%27 = add nuw nsw i64 %20, 2
%28 = getelementptr float, float* %2, i64 %27
%29 = icmp ugt float* %28, %3
%30 = icmp ult float* %26, %25
%31 = and i1 %29, %30
br i1 %31, label %63, label %32
32: ; preds = %23
%33 = and i64 %21, 8589934590
%34 = sub nsw i64 %20, %33
%35 = getelementptr inbounds float, float* %3, i64 -1
%36 = getelementptr inbounds float, float* %3, i64 -1
br label %37
37: ; preds = %37, %32
%38 = phi i64 [ 0, %32 ], [ %59, %37 ]
%39 = sub i64 %20, %38
%40 = add nuw nsw i64 %39, 2
%41 = getelementptr inbounds float, float* %35, i64 %40
%42 = bitcast float* %41 to <2 x float>*
%43 = load <2 x float>, <2 x float>* %42
%44 = shufflevector <2 x float> %43, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%45 = add nuw nsw i64 %39, 1
%46 = insertelement <2 x i64> poison, i64 %45, i64 0
%47 = insertelement <2 x i64> %46, i64 %39, i64 1
%48 = trunc <2 x i64> %47 to <2 x i32>
%49 = shl nuw nsw <2 x i32> %48, <i32 1, i32 1>
%50 = sitofp <2 x i32> %49 to <2 x float>
%51 = getelementptr inbounds float, float* %2, i64 %39
%52 = bitcast float* %51 to <2 x float>*
%53 = load <2 x float>, <2 x float>* %52
%54 = shufflevector <2 x float> %53, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%55 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %50, <2 x float> %54, <2 x float> %44)
%56 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%57 = getelementptr inbounds float, float* %36, i64 %39
%58 = bitcast float* %57 to <2 x float>*
store <2 x float> %56, <2 x float>* %58
%59 = add nuw i64 %38, 2
%60 = icmp eq i64 %59, %33
br i1 %60, label %61, label %37
61: ; preds = %37
%62 = icmp eq i64 %21, %33
br i1 %62, label %109, label %63
63: ; preds = %23, %18, %61
%64 = phi i64 [ %20, %23 ], [ %20, %18 ], [ %34, %61 ]
%65 = and i64 %64, 1
%66 = icmp eq i64 %65, 0
br i1 %66, label %67, label %80
67: ; preds = %63
%68 = add nuw nsw i64 %64, 2
%69 = getelementptr inbounds float, float* %3, i64 %68
%70 = load float, float* %69
%71 = add nuw nsw i64 %64, 1
%72 = trunc i64 %71 to i32
%73 = shl nuw nsw i32 %72, 1
%74 = sitofp i32 %73 to float
%75 = getelementptr inbounds float, float* %2, i64 %71
%76 = load float, float* %75
%77 = tail call float @llvm.fmuladd.f32(float %74, float %76, float %70)
%78 = getelementptr inbounds float, float* %3, i64 %64
store float %77, float* %78
%79 = add nsw i64 %64, -1
br label %80
80: ; preds = %67, %63
%81 = phi i64 [ %64, %63 ], [ %79, %67 ]
%82 = icmp eq i64 %64, 0
br i1 %82, label %109, label %83
83: ; preds = %80, %83
%84 = phi i64 [ %107, %83 ], [ %81, %80 ]
%85 = add nuw nsw i64 %84, 2
%86 = getelementptr inbounds float, float* %3, i64 %85
%87 = load float, float* %86
%88 = add nuw nsw i64 %84, 1
%89 = trunc i64 %88 to i32
%90 = shl nuw nsw i32 %89, 1
%91 = sitofp i32 %90 to float
%92 = getelementptr inbounds float, float* %2, i64 %88
%93 = load float, float* %92
%94 = tail call float @llvm.fmuladd.f32(float %91, float %93, float %87)
%95 = getelementptr inbounds float, float* %3, i64 %84
store float %94, float* %95
%96 = add nsw i64 %84, -1
%97 = add nsw i64 %84, 1
%98 = getelementptr inbounds float, float* %3, i64 %97
%99 = load float, float* %98
%100 = trunc i64 %84 to i32
%101 = shl nuw nsw i32 %100, 1
%102 = sitofp i32 %101 to float
%103 = getelementptr inbounds float, float* %2, i64 %84
%104 = load float, float* %103
%105 = tail call float @llvm.fmuladd.f32(float %102, float %104, float %99)
%106 = getelementptr inbounds float, float* %3, i64 %96
store float %105, float* %106
%107 = add nsw i64 %84, -2
%108 = icmp eq i64 %96, 0
br i1 %108, label %109, label %83
109: ; preds = %80, %83, %61, %5
%110 = fsub float %1, %0
%111 = fdiv float 2.000000e+00, %110
%112 = icmp sgt i32 %4, 0
br i1 %112, label %113, label %181
113: ; preds = %109
%114 = zext i32 %4 to i64
%115 = icmp ult i32 %4, 8
br i1 %115, label %172, label %116
116: ; preds = %113
%117 = and i64 %114, 4294967288
%118 = insertelement <4 x float> poison, float %111, i64 0
%119 = shufflevector <4 x float> %118, <4 x float> poison, <4 x i32> zeroinitializer
%120 = insertelement <4 x float> poison, float %111, i64 0
%121 = shufflevector <4 x float> %120, <4 x float> poison, <4 x i32> zeroinitializer
%122 = add nsw i64 %117, -8
%123 = lshr exact i64 %122, 3
%124 = add nuw nsw i64 %123, 1
%125 = and i64 %124, 1
%126 = icmp eq i64 %122, 0
br i1 %126, label %156, label %127
127: ; preds = %116
%128 = and i64 %124, 4611686018427387902
br label %129
129: ; preds = %129, %127
%130 = phi i64 [ 0, %127 ], [ %153, %129 ]
%131 = phi i64 [ 0, %127 ], [ %154, %129 ]
%132 = getelementptr inbounds float, float* %3, i64 %130
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %132, i64 4
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = fmul <4 x float> %119, %134
%139 = fmul <4 x float> %121, %137
%140 = bitcast float* %132 to <4 x float>*
store <4 x float> %138, <4 x float>* %140
%141 = bitcast float* %135 to <4 x float>*
store <4 x float> %139, <4 x float>* %141
%142 = or i64 %130, 8
%143 = getelementptr inbounds float, float* %3, i64 %142
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %143, i64 4
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fmul <4 x float> %119, %145
%150 = fmul <4 x float> %121, %148
%151 = bitcast float* %143 to <4 x float>*
store <4 x float> %149, <4 x float>* %151
%152 = bitcast float* %146 to <4 x float>*
store <4 x float> %150, <4 x float>* %152
%153 = add nuw i64 %130, 16
%154 = add i64 %131, 2
%155 = icmp eq i64 %154, %128
br i1 %155, label %156, label %129
156: ; preds = %129, %116
%157 = phi i64 [ 0, %116 ], [ %153, %129 ]
%158 = icmp eq i64 %125, 0
br i1 %158, label %170, label %159
159: ; preds = %156
%160 = getelementptr inbounds float, float* %3, i64 %157
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = getelementptr inbounds float, float* %160, i64 4
%164 = bitcast float* %163 to <4 x float>*
%165 = load <4 x float>, <4 x float>* %164
%166 = fmul <4 x float> %119, %162
%167 = fmul <4 x float> %121, %165
%168 = bitcast float* %160 to <4 x float>*
store <4 x float> %166, <4 x float>* %168
%169 = bitcast float* %163 to <4 x float>*
store <4 x float> %167, <4 x float>* %169
br label %170
170: ; preds = %156, %159
%171 = icmp eq i64 %117, %114
br i1 %171, label %181, label %172
172: ; preds = %113, %170
%173 = phi i64 [ 0, %113 ], [ %117, %170 ]
br label %174
174: ; preds = %172, %174
%175 = phi i64 [ %179, %174 ], [ %173, %172 ]
%176 = getelementptr inbounds float, float* %3, i64 %175
%177 = load float, float* %176
%178 = fmul float %111, %177
store float %178, float* %176
%179 = add nuw nsw i64 %175, 1
%180 = icmp eq i64 %179, %114
br i1 %180, label %181, label %174
181: ; preds = %174, %170, %109
ret void
}