void btrfly(j, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, a, b, c, d) int j;
double wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, *a, *b, *c, *d;
{
  double x0r = a[j] + b[j];
  double x0i = a[j + 1] + b[j + 1];
  double x1r = a[j] - b[j];
  double x1i = a[j + 1] - b[j + 1];
  double x2r = c[j] + d[j];
  double x2i = c[j + 1] + d[j + 1];
  double x3r = c[j] - d[j];
  double x3i = c[j + 1] - d[j + 1];
  printf("x0r, x2r are %lf %lf\n", x0r, x2r);
  a[j] = x0r + x2r;
  a[j + 1] = x0i + x2i;
  x0r -= x2r;
  x0i -= x2i;
  c[j] = wk2r * x0r - wk2i * x0i;
  c[j + 1] = wk2r * x0i + wk2i * x0r;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  b[j] = wk1r * x0r - wk1i * x0i;
  b[j + 1] = wk1r * x0i + wk1i * x0r;
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  d[j] = wk3r * x0r - wk3i * x0i;
  d[j + 1] = wk3r * x0i + wk3i * x0r;
}


x86 assembly (clang, -O0):
<btrfly>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
mov    %rsi,-0x40(%rbp)
mov    %rdx,-0x48(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
lea    0xd7a(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x60(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<btrfly>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa0,%rsp
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdx,%r15
mov    %rsi,%r13
movaps %xmm5,0x80(%rsp)
movaps %xmm4,0x90(%rsp)
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x50(%rsp)
movaps %xmm1,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movslq %edi,%rbx
movupd (%rsi,%rbx,8),%xmm1
movupd (%rdx,%rbx,8),%xmm3
movapd %xmm1,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm2,%xmm0
movapd %xmm2,0x10(%rsp)
subpd  %xmm3,%xmm1
movapd %xmm1,0x30(%rsp)
movupd (%rcx,%rbx,8),%xmm1
movupd (%r8,%rbx,8),%xmm3
movapd %xmm1,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm2,(%rsp)
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm1,0x20(%rsp)
lea    0xe69(%rip),%rdi
movapd %xmm2,%xmm1
mov    $0x2,%al
call   1030 <printf@plt>
movapd 0x10(%rsp),%xmm2
movapd %xmm2,%xmm0
movapd (%rsp),%xmm1
addpd  %xmm1,%xmm0
movupd %xmm0,0x0(%r13,%rbx,8)
subpd  %xmm1,%xmm2
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movapd 0xe20(%rip),%xmm0
xorpd  %xmm0,%xmm1
unpcklpd %xmm2,%xmm1
movapd %xmm2,%xmm3
movapd 0x40(%rsp),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
movapd 0x50(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%r12,%rbx,8)
movapd 0x30(%rsp),%xmm2
movapd %xmm2,%xmm1
movapd 0x20(%rsp),%xmm4
subpd  %xmm4,%xmm1
addpd  %xmm2,%xmm4
movapd %xmm4,%xmm2
movsd  %xmm1,%xmm2
movapd %xmm4,%xmm3
movapd %xmm4,%xmm5
unpckhpd %xmm4,%xmm3
xorpd  %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
movapd 0x60(%rsp),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm3,%xmm4
movapd 0x70(%rsp),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%r15,%rbx,8)
movapd %xmm1,%xmm2
movsd  %xmm5,%xmm2
unpckhpd %xmm1,%xmm1
xorpd  %xmm0,%xmm1
unpcklpd %xmm5,%xmm1
movapd 0x80(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm1,%xmm0
movapd 0x90(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r14,%rbx,8)
add    $0xa0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [22 x i8] c"x0r, x2r are %lf %lf\0A\00"
define void @btrfly(i32 %0, double %1, double %2, double %3, double %4, double %5, double %6, double* %7, double* %8, double* %9, double* %10) {
%12 = alloca i32
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
store i32 %0, i32* %12
store double %1, double* %13
store double %2, double* %14
store double %3, double* %15
store double %4, double* %16
store double %5, double* %17
store double %6, double* %18
store double* %7, double** %19
store double* %8, double** %20
store double* %9, double** %21
store double* %10, double** %22
%31 = load double*, double** %19
%32 = load i32, i32* %12
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %31, i64 %33
%35 = load double, double* %34
%36 = load double*, double** %20
%37 = load i32, i32* %12
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %36, i64 %38
%40 = load double, double* %39
%41 = fadd double %35, %40
store double %41, double* %23
%42 = load double*, double** %19
%43 = load i32, i32* %12
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %42, i64 %45
%47 = load double, double* %46
%48 = load double*, double** %20
%49 = load i32, i32* %12
%50 = add nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %48, i64 %51
%53 = load double, double* %52
%54 = fadd double %47, %53
store double %54, double* %24
%55 = load double*, double** %19
%56 = load i32, i32* %12
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
%60 = load double*, double** %20
%61 = load i32, i32* %12
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
%65 = fsub double %59, %64
store double %65, double* %25
%66 = load double*, double** %19
%67 = load i32, i32* %12
%68 = add nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %66, i64 %69
%71 = load double, double* %70
%72 = load double*, double** %20
%73 = load i32, i32* %12
%74 = add nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %72, i64 %75
%77 = load double, double* %76
%78 = fsub double %71, %77
store double %78, double* %26
%79 = load double*, double** %21
%80 = load i32, i32* %12
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
%83 = load double, double* %82
%84 = load double*, double** %22
%85 = load i32, i32* %12
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %84, i64 %86
%88 = load double, double* %87
%89 = fadd double %83, %88
store double %89, double* %27
%90 = load double*, double** %21
%91 = load i32, i32* %12
%92 = add nsw i32 %91, 1
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %90, i64 %93
%95 = load double, double* %94
%96 = load double*, double** %22
%97 = load i32, i32* %12
%98 = add nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %96, i64 %99
%101 = load double, double* %100
%102 = fadd double %95, %101
store double %102, double* %28
%103 = load double*, double** %21
%104 = load i32, i32* %12
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %103, i64 %105
%107 = load double, double* %106
%108 = load double*, double** %22
%109 = load i32, i32* %12
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %108, i64 %110
%112 = load double, double* %111
%113 = fsub double %107, %112
store double %113, double* %29
%114 = load double*, double** %21
%115 = load i32, i32* %12
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %114, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %22
%121 = load i32, i32* %12
%122 = add nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %120, i64 %123
%125 = load double, double* %124
%126 = fsub double %119, %125
store double %126, double* %30
%127 = load double, double* %23
%128 = load double, double* %27
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), double %127, double %128)
%130 = load double, double* %23
%131 = load double, double* %27
%132 = fadd double %130, %131
%133 = load double*, double** %19
%134 = load i32, i32* %12
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double %132, double* %136
%137 = load double, double* %24
%138 = load double, double* %28
%139 = fadd double %137, %138
%140 = load double*, double** %19
%141 = load i32, i32* %12
%142 = add nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %140, i64 %143
store double %139, double* %144
%145 = load double, double* %27
%146 = load double, double* %23
%147 = fsub double %146, %145
store double %147, double* %23
%148 = load double, double* %28
%149 = load double, double* %24
%150 = fsub double %149, %148
store double %150, double* %24
%151 = load double, double* %15
%152 = load double, double* %23
%153 = load double, double* %16
%154 = load double, double* %24
%155 = fmul double %153, %154
%156 = fneg double %155
%157 = call double @llvm.fmuladd.f64(double %151, double %152, double %156)
%158 = load double*, double** %21
%159 = load i32, i32* %12
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %158, i64 %160
store double %157, double* %161
%162 = load double, double* %15
%163 = load double, double* %24
%164 = load double, double* %16
%165 = load double, double* %23
%166 = fmul double %164, %165
%167 = call double @llvm.fmuladd.f64(double %162, double %163, double %166)
%168 = load double*, double** %21
%169 = load i32, i32* %12
%170 = add nsw i32 %169, 1
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %168, i64 %171
store double %167, double* %172
%173 = load double, double* %25
%174 = load double, double* %30
%175 = fsub double %173, %174
store double %175, double* %23
%176 = load double, double* %26
%177 = load double, double* %29
%178 = fadd double %176, %177
store double %178, double* %24
%179 = load double, double* %13
%180 = load double, double* %23
%181 = load double, double* %14
%182 = load double, double* %24
%183 = fmul double %181, %182
%184 = fneg double %183
%185 = call double @llvm.fmuladd.f64(double %179, double %180, double %184)
%186 = load double*, double** %20
%187 = load i32, i32* %12
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %186, i64 %188
store double %185, double* %189
%190 = load double, double* %13
%191 = load double, double* %24
%192 = load double, double* %14
%193 = load double, double* %23
%194 = fmul double %192, %193
%195 = call double @llvm.fmuladd.f64(double %190, double %191, double %194)
%196 = load double*, double** %20
%197 = load i32, i32* %12
%198 = add nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %196, i64 %199
store double %195, double* %200
%201 = load double, double* %25
%202 = load double, double* %30
%203 = fadd double %201, %202
store double %203, double* %23
%204 = load double, double* %26
%205 = load double, double* %29
%206 = fsub double %204, %205
store double %206, double* %24
%207 = load double, double* %17
%208 = load double, double* %23
%209 = load double, double* %18
%210 = load double, double* %24
%211 = fmul double %209, %210
%212 = fneg double %211
%213 = call double @llvm.fmuladd.f64(double %207, double %208, double %212)
%214 = load double*, double** %22
%215 = load i32, i32* %12
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
store double %213, double* %217
%218 = load double, double* %17
%219 = load double, double* %24
%220 = load double, double* %18
%221 = load double, double* %23
%222 = fmul double %220, %221
%223 = call double @llvm.fmuladd.f64(double %218, double %219, double %222)
%224 = load double*, double** %22
%225 = load i32, i32* %12
%226 = add nsw i32 %225, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %224, i64 %227
store double %223, double* %228
ret void
}

LLVM IR (-O2):
@.str = [22 x i8] c"x0r, x2r are %lf %lf\0A\00"
define void @btrfly(i32 %0, double %1, double %2, double %3, double %4, double %5, double %6, double* nocapture %7, double* nocapture %8, double* nocapture %9, double* nocapture %10) {
%12 = sext i32 %0 to i64
%13 = getelementptr inbounds double, double* %7, i64 %12
%14 = getelementptr inbounds double, double* %8, i64 %12
%15 = bitcast double* %13 to <2 x double>*
%16 = load <2 x double>, <2 x double>* %15
%17 = bitcast double* %14 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = fadd <2 x double> %16, %18
%20 = fsub <2 x double> %16, %18
%21 = getelementptr inbounds double, double* %9, i64 %12
%22 = getelementptr inbounds double, double* %10, i64 %12
%23 = bitcast double* %21 to <2 x double>*
%24 = load <2 x double>, <2 x double>* %23
%25 = bitcast double* %22 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = fadd <2 x double> %24, %26
%28 = fsub <2 x double> %24, %26
%29 = shufflevector <2 x double> %28, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%30 = extractelement <2 x double> %19, i64 0
%31 = extractelement <2 x double> %27, i64 0
%32 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), double %30, double %31)
%33 = fadd <2 x double> %19, %27
%34 = bitcast double* %13 to <2 x double>*
store <2 x double> %33, <2 x double>* %34
%35 = fsub <2 x double> %19, %27
%36 = extractelement <2 x double> %35, i64 1
%37 = fneg double %36
%38 = insertelement <2 x double> poison, double %37, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> %35, <2 x i32> <i32 0, i32 2>
%40 = insertelement <2 x double> poison, double %4, i64 0
%41 = shufflevector <2 x double> %40, <2 x double> poison, <2 x i32> zeroinitializer
%42 = fmul <2 x double> %39, %41
%43 = insertelement <2 x double> poison, double %3, i64 0
%44 = shufflevector <2 x double> %43, <2 x double> poison, <2 x i32> zeroinitializer
%45 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> %35, <2 x double> %42)
%46 = bitcast double* %21 to <2 x double>*
store <2 x double> %45, <2 x double>* %46
%47 = fsub <2 x double> %20, %29
%48 = fadd <2 x double> %20, %29
%49 = shufflevector <2 x double> %47, <2 x double> %48, <2 x i32> <i32 0, i32 3>
%50 = extractelement <2 x double> %48, i64 1
%51 = fneg double %50
%52 = insertelement <2 x double> poison, double %51, i64 0
%53 = shufflevector <2 x double> %52, <2 x double> %47, <2 x i32> <i32 0, i32 2>
%54 = insertelement <2 x double> poison, double %2, i64 0
%55 = shufflevector <2 x double> %54, <2 x double> poison, <2 x i32> zeroinitializer
%56 = fmul <2 x double> %53, %55
%57 = insertelement <2 x double> poison, double %1, i64 0
%58 = shufflevector <2 x double> %57, <2 x double> poison, <2 x i32> zeroinitializer
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %58, <2 x double> %49, <2 x double> %56)
%60 = bitcast double* %14 to <2 x double>*
store <2 x double> %59, <2 x double>* %60
%61 = shufflevector <2 x double> %48, <2 x double> %47, <2 x i32> <i32 0, i32 3>
%62 = extractelement <2 x double> %47, i64 1
%63 = fneg double %62
%64 = insertelement <2 x double> poison, double %63, i64 0
%65 = shufflevector <2 x double> %64, <2 x double> %48, <2 x i32> <i32 0, i32 2>
%66 = insertelement <2 x double> poison, double %6, i64 0
%67 = shufflevector <2 x double> %66, <2 x double> poison, <2 x i32> zeroinitializer
%68 = fmul <2 x double> %65, %67
%69 = insertelement <2 x double> poison, double %5, i64 0
%70 = shufflevector <2 x double> %69, <2 x double> poison, <2 x i32> zeroinitializer
%71 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %70, <2 x double> %61, <2 x double> %68)
%72 = bitcast double* %22 to <2 x double>*
store <2 x double> %71, <2 x double>* %72
ret void
}