void TkBezierPoints(control, numSteps, coordPtr) double control[];
int numSteps;
register double *coordPtr;
{
  int i;
  double u, u2, u3, t, t2, t3;
  for (i = 1; i <= numSteps; i++, coordPtr += 2) {
    t = ((double)i) / ((double)numSteps);
    t2 = t * t;
    t3 = t2 * t;
    u = 1.0 - t;
    u2 = u * u;
    u3 = u2 * u;
    coordPtr[0] = control[0] * u3 +
                  3.0 * (control[2] * t * u2 + control[4] * t2 * u) +
                  control[6] * t3;
    coordPtr[1] = control[1] * u3 +
                  3.0 * (control[3] * t * u2 + control[5] * t2 * u) +
                  control[7] * t3;
  }
}


x86 assembly (clang, -O0):
<TkBezierPoints>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1279 <TkBezierPoints+0x179>
cvtsi2sdl -0x1c(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xead(%rip),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x38(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm3
mulsd  -0x40(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm4
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  %xmm4,%xmm3
addsd  %xmm0,%xmm3
movsd  0xe3a(%rip),%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x38(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm3
mulsd  -0x40(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm4
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  %xmm4,%xmm3
addsd  %xmm0,%xmm3
movsd  0xdcc(%rip),%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
jmp    1116 <TkBezierPoints+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<TkBezierPoints>:
test   %esi,%esi
jle    1356 <TkBezierPoints+0x256>
cvtsi2sd %esi,%xmm11
mov    %esi,%r8d
mov    $0x1,%eax
add    $0xffffffff,%r8d
je     1137 <TkBezierPoints+0x37>
lea    0x40(%rdi),%rcx
cmp    %rdx,%rcx
jbe    113f <TkBezierPoints+0x3f>
mov    %r8,%rcx
shl    $0x4,%rcx
add    %rdx,%rcx
add    $0x10,%rcx
cmp    %rdi,%rcx
jbe    113f <TkBezierPoints+0x3f>
mov    %rdx,%rcx
jmp    1287 <TkBezierPoints+0x187>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
mov    %r9,%rcx
shl    $0x4,%rcx
add    %rdx,%rcx
mov    %r8d,%eax
or     $0x1,%eax
movapd %xmm11,%xmm12
unpcklpd %xmm11,%xmm12
movdqa 0xe93(%rip),%xmm13
movapd 0xe9a(%rip),%xmm8
movapd 0xea1(%rip),%xmm10
movdqa 0xea8(%rip),%xmm9
mov    %r9,%r10
nopl   0x0(%rax,%rax,1)
cvtdq2pd %xmm13,%xmm6
divpd  %xmm12,%xmm6
movapd %xmm8,%xmm3
movapd %xmm6,%xmm14
movsd  0x10(%rdi),%xmm5
movsd  0x18(%rdi),%xmm7
unpcklpd %xmm5,%xmm5
subpd  %xmm6,%xmm3
mulpd  %xmm6,%xmm5
unpcklpd %xmm7,%xmm7
mulpd  %xmm6,%xmm7
mulpd  %xmm6,%xmm6
mulpd  %xmm6,%xmm14
movapd %xmm3,%xmm0
movsd  0x20(%rdi),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm6,%xmm1
movsd  0x28(%rdi),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm6,%xmm2
mulpd  %xmm3,%xmm1
mulpd  %xmm3,%xmm2
mulpd  %xmm3,%xmm3
movsd  (%rdi),%xmm6
mulpd  %xmm3,%xmm0
movsd  0x8(%rdi),%xmm4
unpcklpd %xmm6,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm0,%xmm6
movsd  0x30(%rdi),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm10,%xmm5
mulpd  %xmm14,%xmm1
unpcklpd %xmm4,%xmm4
mulpd  %xmm3,%xmm7
addpd  %xmm5,%xmm6
addpd  %xmm2,%xmm7
mulpd  %xmm10,%xmm7
mulpd  %xmm0,%xmm4
addpd  %xmm7,%xmm4
movsd  0x38(%rdi),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm14,%xmm0
addpd  %xmm6,%xmm1
addpd  %xmm4,%xmm0
movapd %xmm1,%xmm2
unpcklpd %xmm0,%xmm2
movhlps %xmm1,%xmm0
movups %xmm0,0x10(%rdx)
movupd %xmm2,(%rdx)
paddd  %xmm9,%xmm13
add    $0x20,%rdx
add    $0xfffffffffffffffe,%r10
jne    1190 <TkBezierPoints+0x90>
cmp    %r9,%r8
je     1356 <TkBezierPoints+0x256>
add    $0x1,%esi
movsd  0xdad(%rip),%xmm8
movsd  0xdac(%rip),%xmm9
nopl   0x0(%rax)
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
divsd  %xmm11,%xmm3
movapd %xmm3,%xmm6
mulsd  %xmm3,%xmm6
movapd %xmm3,%xmm4
mulsd  %xmm6,%xmm4
movapd %xmm8,%xmm7
subsd  %xmm3,%xmm7
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm7,%xmm5
mulsd  %xmm0,%xmm5
movsd  0x10(%rdi),%xmm1
mulsd  %xmm3,%xmm1
movsd  0x20(%rdi),%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm7,%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm9,%xmm1
movsd  (%rdi),%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
movsd  0x30(%rdi),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx)
mulsd  0x18(%rdi),%xmm3
mulsd  0x28(%rdi),%xmm6
mulsd  %xmm7,%xmm6
mulsd  %xmm0,%xmm3
addsd  %xmm6,%xmm3
mulsd  %xmm9,%xmm3
mulsd  0x8(%rdi),%xmm5
addsd  %xmm3,%xmm5
mulsd  0x38(%rdi),%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,0x8(%rcx)
add    $0x1,%eax
add    $0x10,%rcx
cmp    %eax,%esi
jne    12a0 <TkBezierPoints+0x1a0>
ret

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

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