void convertTTTfR44d(float *ttt, double *homo) {
  register double ttt_3 = (double)ttt[3];
  register double ttt_7 = (double)ttt[7];
  register double ttt_11 = (double)ttt[11];
  register double ttt_12 = (double)ttt[12];
  register double ttt_13 = (double)ttt[13];
  register double ttt_14 = (double)ttt[14];
  homo[0] = (double)ttt[0];
  homo[1] = (double)ttt[1];
  homo[2] = (double)ttt[2];
  homo[4] = (double)ttt[4];
  homo[5] = (double)ttt[5];
  homo[6] = (double)ttt[6];
  homo[8] = (double)ttt[8];
  homo[9] = (double)ttt[9];
  homo[10] = (double)ttt[10];
  homo[3] =
      (homo[0] * ttt_12) + (homo[1] * ttt_13) + (homo[2] * ttt_14) + ttt_3;
  homo[7] =
      (homo[4] * ttt_12) + (homo[5] * ttt_13) + (homo[6] * ttt_14) + ttt_7;
  homo[11] =
      (homo[8] * ttt_12) + (homo[9] * ttt_13) + (homo[10] * ttt_14) + ttt_11;
  homo[12] = 0.0;
  homo[13] = 0.0;
  homo[14] = 0.0;
  homo[15] = 1.0;
}


x86 assembly (clang, -O0):
<convertTTTfR44d>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x60(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x70(%rax)
mov    -0x10(%rbp),%rax
movsd  0xcbd(%rip),%xmm0
movsd  %xmm0,0x78(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<convertTTTfR44d>:
movss  0xc(%rdi),%xmm0
movss  0x1c(%rdi),%xmm1
cvtss2sd %xmm0,%xmm10
cvtss2sd %xmm1,%xmm9
movss  0x2c(%rdi),%xmm0
cvtss2sd %xmm0,%xmm8
movss  0x30(%rdi),%xmm0
cvtss2sd %xmm0,%xmm11
movss  0x34(%rdi),%xmm0
cvtss2sd %xmm0,%xmm12
movss  0x38(%rdi),%xmm2
cvtps2pd (%rdi),%xmm3
movupd %xmm3,(%rsi)
movss  0x8(%rdi),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi)
cvtps2pd 0x10(%rdi),%xmm0
cvtss2sd %xmm2,%xmm4
movupd %xmm0,0x20(%rsi)
movss  0x18(%rdi),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  %xmm2,0x30(%rsi)
cvtps2pd 0x20(%rdi),%xmm5
movupd %xmm5,0x40(%rsi)
movss  0x28(%rdi),%xmm6
cvtss2sd %xmm6,%xmm6
movsd  %xmm6,0x50(%rsi)
movapd %xmm3,%xmm7
unpckhpd %xmm3,%xmm7
mulsd  %xmm12,%xmm7
mulsd  %xmm11,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm10,%xmm1
movsd  %xmm1,0x18(%rsi)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
mulsd  %xmm12,%xmm1
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm9,%xmm2
movsd  %xmm2,0x38(%rsi)
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm11,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
addsd  %xmm8,%xmm6
movsd  %xmm6,0x58(%rsi)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x60(%rsi)
movq   $0x0,0x70(%rsi)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x78(%rsi)
ret

LLVM IR (-O0):
define void @convertTTTfR44d(float* %0, double* %1) {
%3 = alloca float*
%4 = alloca double*
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
store float* %0, float** %3
store double* %1, double** %4
%11 = load float*, float** %3
%12 = getelementptr inbounds float, float* %11, i64 3
%13 = load float, float* %12
%14 = fpext float %13 to double
store double %14, double* %5
%15 = load float*, float** %3
%16 = getelementptr inbounds float, float* %15, i64 7
%17 = load float, float* %16
%18 = fpext float %17 to double
store double %18, double* %6
%19 = load float*, float** %3
%20 = getelementptr inbounds float, float* %19, i64 11
%21 = load float, float* %20
%22 = fpext float %21 to double
store double %22, double* %7
%23 = load float*, float** %3
%24 = getelementptr inbounds float, float* %23, i64 12
%25 = load float, float* %24
%26 = fpext float %25 to double
store double %26, double* %8
%27 = load float*, float** %3
%28 = getelementptr inbounds float, float* %27, i64 13
%29 = load float, float* %28
%30 = fpext float %29 to double
store double %30, double* %9
%31 = load float*, float** %3
%32 = getelementptr inbounds float, float* %31, i64 14
%33 = load float, float* %32
%34 = fpext float %33 to double
store double %34, double* %10
%35 = load float*, float** %3
%36 = getelementptr inbounds float, float* %35, i64 0
%37 = load float, float* %36
%38 = fpext float %37 to double
%39 = load double*, double** %4
%40 = getelementptr inbounds double, double* %39, i64 0
store double %38, double* %40
%41 = load float*, float** %3
%42 = getelementptr inbounds float, float* %41, i64 1
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = load double*, double** %4
%46 = getelementptr inbounds double, double* %45, i64 1
store double %44, double* %46
%47 = load float*, float** %3
%48 = getelementptr inbounds float, float* %47, i64 2
%49 = load float, float* %48
%50 = fpext float %49 to double
%51 = load double*, double** %4
%52 = getelementptr inbounds double, double* %51, i64 2
store double %50, double* %52
%53 = load float*, float** %3
%54 = getelementptr inbounds float, float* %53, i64 4
%55 = load float, float* %54
%56 = fpext float %55 to double
%57 = load double*, double** %4
%58 = getelementptr inbounds double, double* %57, i64 4
store double %56, double* %58
%59 = load float*, float** %3
%60 = getelementptr inbounds float, float* %59, i64 5
%61 = load float, float* %60
%62 = fpext float %61 to double
%63 = load double*, double** %4
%64 = getelementptr inbounds double, double* %63, i64 5
store double %62, double* %64
%65 = load float*, float** %3
%66 = getelementptr inbounds float, float* %65, i64 6
%67 = load float, float* %66
%68 = fpext float %67 to double
%69 = load double*, double** %4
%70 = getelementptr inbounds double, double* %69, i64 6
store double %68, double* %70
%71 = load float*, float** %3
%72 = getelementptr inbounds float, float* %71, i64 8
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = load double*, double** %4
%76 = getelementptr inbounds double, double* %75, i64 8
store double %74, double* %76
%77 = load float*, float** %3
%78 = getelementptr inbounds float, float* %77, i64 9
%79 = load float, float* %78
%80 = fpext float %79 to double
%81 = load double*, double** %4
%82 = getelementptr inbounds double, double* %81, i64 9
store double %80, double* %82
%83 = load float*, float** %3
%84 = getelementptr inbounds float, float* %83, i64 10
%85 = load float, float* %84
%86 = fpext float %85 to double
%87 = load double*, double** %4
%88 = getelementptr inbounds double, double* %87, i64 10
store double %86, double* %88
%89 = load double*, double** %4
%90 = getelementptr inbounds double, double* %89, i64 0
%91 = load double, double* %90
%92 = load double, double* %8
%93 = load double*, double** %4
%94 = getelementptr inbounds double, double* %93, i64 1
%95 = load double, double* %94
%96 = load double, double* %9
%97 = fmul double %95, %96
%98 = call double @llvm.fmuladd.f64(double %91, double %92, double %97)
%99 = load double*, double** %4
%100 = getelementptr inbounds double, double* %99, i64 2
%101 = load double, double* %100
%102 = load double, double* %10
%103 = call double @llvm.fmuladd.f64(double %101, double %102, double %98)
%104 = load double, double* %5
%105 = fadd double %103, %104
%106 = load double*, double** %4
%107 = getelementptr inbounds double, double* %106, i64 3
store double %105, double* %107
%108 = load double*, double** %4
%109 = getelementptr inbounds double, double* %108, i64 4
%110 = load double, double* %109
%111 = load double, double* %8
%112 = load double*, double** %4
%113 = getelementptr inbounds double, double* %112, i64 5
%114 = load double, double* %113
%115 = load double, double* %9
%116 = fmul double %114, %115
%117 = call double @llvm.fmuladd.f64(double %110, double %111, double %116)
%118 = load double*, double** %4
%119 = getelementptr inbounds double, double* %118, i64 6
%120 = load double, double* %119
%121 = load double, double* %10
%122 = call double @llvm.fmuladd.f64(double %120, double %121, double %117)
%123 = load double, double* %6
%124 = fadd double %122, %123
%125 = load double*, double** %4
%126 = getelementptr inbounds double, double* %125, i64 7
store double %124, double* %126
%127 = load double*, double** %4
%128 = getelementptr inbounds double, double* %127, i64 8
%129 = load double, double* %128
%130 = load double, double* %8
%131 = load double*, double** %4
%132 = getelementptr inbounds double, double* %131, i64 9
%133 = load double, double* %132
%134 = load double, double* %9
%135 = fmul double %133, %134
%136 = call double @llvm.fmuladd.f64(double %129, double %130, double %135)
%137 = load double*, double** %4
%138 = getelementptr inbounds double, double* %137, i64 10
%139 = load double, double* %138
%140 = load double, double* %10
%141 = call double @llvm.fmuladd.f64(double %139, double %140, double %136)
%142 = load double, double* %7
%143 = fadd double %141, %142
%144 = load double*, double** %4
%145 = getelementptr inbounds double, double* %144, i64 11
store double %143, double* %145
%146 = load double*, double** %4
%147 = getelementptr inbounds double, double* %146, i64 12
store double 0.000000e+00, double* %147
%148 = load double*, double** %4
%149 = getelementptr inbounds double, double* %148, i64 13
store double 0.000000e+00, double* %149
%150 = load double*, double** %4
%151 = getelementptr inbounds double, double* %150, i64 14
store double 0.000000e+00, double* %151
%152 = load double*, double** %4
%153 = getelementptr inbounds double, double* %152, i64 15
store double 1.000000e+00, double* %153
ret void
}

LLVM IR (-O2):
define void @convertTTTfR44d(float* nocapture %0, double* nocapture %1) {
%3 = getelementptr inbounds float, float* %0, i64 3
%4 = load float, float* %3
%5 = fpext float %4 to double
%6 = getelementptr inbounds float, float* %0, i64 7
%7 = load float, float* %6
%8 = fpext float %7 to double
%9 = getelementptr inbounds float, float* %0, i64 11
%10 = load float, float* %9
%11 = fpext float %10 to double
%12 = getelementptr inbounds float, float* %0, i64 12
%13 = load float, float* %12
%14 = fpext float %13 to double
%15 = getelementptr inbounds float, float* %0, i64 13
%16 = load float, float* %15
%17 = fpext float %16 to double
%18 = getelementptr inbounds float, float* %0, i64 14
%19 = load float, float* %18
%20 = fpext float %19 to double
%21 = bitcast float* %0 to <2 x float>*
%22 = load <2 x float>, <2 x float>* %21
%23 = fpext <2 x float> %22 to <2 x double>
%24 = bitcast double* %1 to <2 x double>*
store <2 x double> %23, <2 x double>* %24
%25 = getelementptr inbounds float, float* %0, i64 2
%26 = load float, float* %25
%27 = fpext float %26 to double
%28 = getelementptr inbounds double, double* %1, i64 2
store double %27, double* %28
%29 = getelementptr inbounds float, float* %0, i64 4
%30 = getelementptr inbounds double, double* %1, i64 4
%31 = bitcast float* %29 to <2 x float>*
%32 = load <2 x float>, <2 x float>* %31
%33 = fpext <2 x float> %32 to <2 x double>
%34 = bitcast double* %30 to <2 x double>*
store <2 x double> %33, <2 x double>* %34
%35 = getelementptr inbounds float, float* %0, i64 6
%36 = load float, float* %35
%37 = fpext float %36 to double
%38 = getelementptr inbounds double, double* %1, i64 6
store double %37, double* %38
%39 = getelementptr inbounds float, float* %0, i64 8
%40 = getelementptr inbounds double, double* %1, i64 8
%41 = bitcast float* %39 to <2 x float>*
%42 = load <2 x float>, <2 x float>* %41
%43 = fpext <2 x float> %42 to <2 x double>
%44 = bitcast double* %40 to <2 x double>*
store <2 x double> %43, <2 x double>* %44
%45 = getelementptr inbounds float, float* %0, i64 10
%46 = load float, float* %45
%47 = fpext float %46 to double
%48 = getelementptr inbounds double, double* %1, i64 10
store double %47, double* %48
%49 = extractelement <2 x double> %23, i64 1
%50 = fmul double %49, %17
%51 = extractelement <2 x double> %23, i64 0
%52 = tail call double @llvm.fmuladd.f64(double %51, double %14, double %50)
%53 = tail call double @llvm.fmuladd.f64(double %27, double %20, double %52)
%54 = fadd double %53, %5
%55 = getelementptr inbounds double, double* %1, i64 3
store double %54, double* %55
%56 = extractelement <2 x double> %33, i64 1
%57 = fmul double %56, %17
%58 = extractelement <2 x double> %33, i64 0
%59 = tail call double @llvm.fmuladd.f64(double %58, double %14, double %57)
%60 = tail call double @llvm.fmuladd.f64(double %37, double %20, double %59)
%61 = fadd double %60, %8
%62 = getelementptr inbounds double, double* %1, i64 7
store double %61, double* %62
%63 = extractelement <2 x double> %43, i64 1
%64 = fmul double %63, %17
%65 = extractelement <2 x double> %43, i64 0
%66 = tail call double @llvm.fmuladd.f64(double %65, double %14, double %64)
%67 = tail call double @llvm.fmuladd.f64(double %47, double %20, double %66)
%68 = fadd double %67, %11
%69 = getelementptr inbounds double, double* %1, i64 11
store double %68, double* %69
%70 = getelementptr inbounds double, double* %1, i64 12
%71 = getelementptr inbounds double, double* %1, i64 15
%72 = bitcast double* %70 to i8*
store double 1.000000e+00, double* %71
ret void
}