int qu2om(double *qu, double *om, int p) {
  double sign, qq, qo[4];
  int i;
  double epsijk;
  epsijk = (double)p;
  sign = ((qu[0] >= 0.0) ? 1.0 : -1.0);
  for (i = 0; i < 4; i++) {
    qo[i] = sign * qu[i];
  }
  qo[0] *= epsijk;
  qq = qo[0] * qo[0] - (qo[1] * qo[1] + qo[2] * qo[2] + qo[3] * qo[3]);
  *(om) = qq + 2.0 * qo[1] * qo[1];
  *(om + 1) = 2.0 * (qo[1] * qo[2] - qo[0] * qo[3]);
  *(om + 2) = 2.0 * (qo[1] * qo[3] + qo[0] * qo[2]);
  *(om + 3) = 2.0 * (qo[2] * qo[1] + qo[0] * qo[3]);
  *(om + 4) = qq + 2.0 * qo[2] * qo[2];
  *(om + 5) = 2.0 * (qo[2] * qo[3] - qo[0] * qo[1]);
  *(om + 6) = 2.0 * (qo[3] * qo[1] - qo[0] * qo[2]);
  *(om + 7) = 2.0 * (qo[3] * qo[2] + qo[0] * qo[1]);
  *(om + 8) = qq + 2.0 * qo[3] * qo[3];
  return 1;
}


x86 assembly (clang, -O0):
<qu2om>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0xed7(%rip),%xmm3
movsd  0xed7(%rip),%xmm2
xorps  %xmm0,%xmm0
cmplesd %xmm1,%xmm0
movaps %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x4,-0x54(%rbp)
jge    1188 <qu2om+0x88>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x54(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1154 <qu2om+0x54>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm4,%xmm3
addsd  %xmm1,%xmm3
movsd  -0x38(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm4
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm1
movsd  0xe10(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x48(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdbb(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd8a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x40(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd59(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x28(%rbp),%xmm1
movsd  0xd3f(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x40(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xce9(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x38(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xca1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc70(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x28(%rbp),%xmm1
movsd  0xc56(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<qu2om>:
movsd  (%rdi),%xmm15
xorpd  %xmm1,%xmm1
xor    %eax,%eax
ucomisd %xmm1,%xmm15
setae  %cl
movapd 0xee4(%rip),%xmm12
jae    1123 <qu2om+0x23>
xorpd  %xmm12,%xmm15
movsd  0x8(%rdi),%xmm14
jae    1130 <qu2om+0x30>
xorpd  %xmm12,%xmm14
movupd 0x10(%rdi),%xmm1
movapd %xmm1,%xmm4
xorpd  %xmm12,%xmm4
mov    %cl,%al
movd   %eax,%xmm3
pshufd $0x44,%xmm3,%xmm3
psllq  $0x3f,%xmm3
psrad  $0x1f,%xmm3
pshufd $0xf5,%xmm3,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm4,%xmm3
orpd   %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
mulsd  %xmm1,%xmm15
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm14,%xmm10
mulsd  %xmm14,%xmm10
addsd  %xmm1,%xmm10
pshufd $0xee,%xmm3,%xmm11
xorpd  %xmm15,%xmm12
movapd %xmm3,%xmm8
unpcklpd %xmm3,%xmm12
movapd %xmm14,%xmm7
unpcklpd %xmm14,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm15,%xmm9
mulsd  %xmm11,%xmm9
movapd %xmm3,%xmm6
movapd %xmm3,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm14,%xmm13
unpcklpd %xmm3,%xmm13
movapd %xmm3,%xmm1
shufpd $0x1,%xmm14,%xmm1
mulpd  %xmm3,%xmm1
mulsd  %xmm11,%xmm3
movapd %xmm11,%xmm5
addsd  %xmm11,%xmm5
mulsd  %xmm11,%xmm5
mulsd  %xmm11,%xmm11
addsd  %xmm10,%xmm11
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
subsd  %xmm11,%xmm0
movapd %xmm14,%xmm2
addsd  %xmm14,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi)
shufpd $0x1,%xmm15,%xmm8
mulpd  %xmm8,%xmm12
addpd  %xmm12,%xmm7
addpd  %xmm7,%xmm7
movupd %xmm7,0x8(%rsi)
mulsd  %xmm14,%xmm6
addsd  %xmm9,%xmm6
addsd  %xmm6,%xmm6
movsd  %xmm6,0x18(%rsi)
addsd  %xmm0,%xmm4
movsd  %xmm4,0x20(%rsi)
movapd %xmm15,%xmm2
unpcklpd %xmm15,%xmm2
mulpd  %xmm13,%xmm2
subpd  %xmm2,%xmm1
addpd  %xmm1,%xmm1
movupd %xmm1,0x28(%rsi)
mulsd  %xmm14,%xmm15
addsd  %xmm15,%xmm3
addsd  %xmm3,%xmm3
movsd  %xmm3,0x38(%rsi)
addsd  %xmm0,%xmm5
movsd  %xmm5,0x40(%rsi)
mov    $0x1,%eax
ret

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

LLVM IR (-O2):
define i32 @qu2om(double* nocapture %0, double* nocapture writeonly %1, i32 %2) {
%4 = load double, double* %0
%5 = fcmp oge double %4, 0.000000e+00
%6 = fneg double %4
%7 = select i1 %5, double %4, double %6
%8 = getelementptr inbounds double, double* %0, i64 1
%9 = load double, double* %8
%10 = fneg double %9
%11 = select i1 %5, double %9, double %10
%12 = getelementptr inbounds double, double* %0, i64 2
%13 = bitcast double* %12 to <2 x double>*
%14 = load <2 x double>, <2 x double>* %13
%15 = fneg <2 x double> %14
%16 = insertelement <2 x i1> poison, i1 %5, i64 0
%17 = shufflevector <2 x i1> %16, <2 x i1> poison, <2 x i32> zeroinitializer
%18 = select <2 x i1> %17, <2 x double> %14, <2 x double> %15
%19 = sitofp i32 %2 to double
%20 = fmul double %7, %19
%21 = extractelement <2 x double> %18, i64 0
%22 = fmul <2 x double> %18, %18
%23 = extractelement <2 x double> %22, i64 0
%24 = tail call double @llvm.fmuladd.f64(double %11, double %11, double %23)
%25 = extractelement <2 x double> %18, i64 1
%26 = tail call double @llvm.fmuladd.f64(double %25, double %25, double %24)
%27 = fneg double %26
%28 = tail call double @llvm.fmuladd.f64(double %20, double %20, double %27)
%29 = fmul double %11, 2.000000e+00
%30 = tail call double @llvm.fmuladd.f64(double %29, double %11, double %28)
store double %30, double* %1
%31 = fneg double %20
%32 = getelementptr inbounds double, double* %1, i64 1
%33 = shufflevector <2 x double> %18, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%34 = insertelement <2 x double> %33, double %20, i64 1
%35 = insertelement <2 x double> poison, double %31, i64 0
%36 = shufflevector <2 x double> %35, <2 x double> %18, <2 x i32> <i32 0, i32 2>
%37 = fmul <2 x double> %34, %36
%38 = insertelement <2 x double> poison, double %11, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %39, <2 x double> %18, <2 x double> %37)
%41 = fmul <2 x double> %40, <double 2.000000e+00, double 2.000000e+00>
%42 = bitcast double* %32 to <2 x double>*
store <2 x double> %41, <2 x double>* %42
%43 = fmul double %20, %25
%44 = tail call double @llvm.fmuladd.f64(double %21, double %11, double %43)
%45 = fmul double %44, 2.000000e+00
%46 = getelementptr inbounds double, double* %1, i64 3
store double %45, double* %46
%47 = fmul double %21, 2.000000e+00
%48 = tail call double @llvm.fmuladd.f64(double %47, double %21, double %28)
%49 = getelementptr inbounds double, double* %1, i64 4
store double %48, double* %49
%50 = getelementptr inbounds double, double* %1, i64 5
%51 = shufflevector <2 x double> %38, <2 x double> %18, <2 x i32> <i32 0, i32 2>
%52 = shufflevector <2 x double> %35, <2 x double> poison, <2 x i32> zeroinitializer
%53 = fmul <2 x double> %51, %52
%54 = insertelement <2 x double> %33, double %11, i64 1
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %18, <2 x double> %54, <2 x double> %53)
%56 = fmul <2 x double> %55, <double 2.000000e+00, double 2.000000e+00>
%57 = bitcast double* %50 to <2 x double>*
store <2 x double> %56, <2 x double>* %57
%58 = fmul double %20, %11
%59 = tail call double @llvm.fmuladd.f64(double %25, double %21, double %58)
%60 = fmul double %59, 2.000000e+00
%61 = getelementptr inbounds double, double* %1, i64 7
store double %60, double* %61
%62 = fmul double %25, 2.000000e+00
%63 = tail call double @llvm.fmuladd.f64(double %62, double %25, double %28)
%64 = getelementptr inbounds double, double* %1, i64 8
store double %63, double* %64
ret i32 1
}