#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double sqrt(double);
double carlson_elliptic_rd(double x, double y, double z) {
  double alamb, ave, delx, dely, delz, ea, eb, ec, ed, ee, fac, sqrtx, sqrty,
      sqrtz, sum, xt, yt, zt, ans;
  xt = x;
  yt = y;
  zt = z;
  sum = 0.0;
  fac = 1.0;
  do {
    sqrtx = sqrt(xt);
    sqrty = sqrt(yt);
    sqrtz = sqrt(zt);
    alamb = sqrtx * (sqrty + sqrtz) + sqrty * sqrtz;
    sum += fac / (sqrtz * (zt + alamb));
    fac = 0.25 * fac;
    xt = 0.25 * (xt + alamb);
    yt = 0.25 * (yt + alamb);
    zt = 0.25 * (zt + alamb);
    ave = 0.2 * (xt + yt + 3.0 * zt);
    delx = (ave - xt) / ave;
    dely = (ave - yt) / ave;
    delz = (ave - zt) / ave;
  } while (fabs(delx) > 0.0015 || fabs(dely) > 0.0015 || fabs(delz) > 0.0015);
  ea = delx * dely;
  eb = delz * delz;
  ec = ea - eb;
  ed = ea - 6.0 * eb;
  ee = ed + ec + ec;
  ans = 3.0 * sum +
        fac *
            (1.0 +
             ed * (-(3.0 / 14.0) + (0.25 * (9.0 / 22.0)) * ed -
                   (1.5 * (3.0 / 26.0)) * delz * ee) +
             delz * ((1.0 / 6.0) * ee +
                     delz * (-(9.0 / 22.0) * ec + delz * (3.0 / 26.0) * ea))) /
            (ave * sqrt(ave));
  return (ans);
}


x86 assembly (clang, -O0):
<carlson_elliptic_rd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe9c(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
addsd  -0x88(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
addsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe10(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x20(%rbp),%xmm1
movsd  0xdf1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
addsd  -0x20(%rbp),%xmm1
movsd  0xdd0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
addsd  -0x20(%rbp),%xmm1
movsd  0xdaf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0xd7b(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd63(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x28(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
movaps 0xd61(%rip),%xmm1
pand   %xmm1,%xmm0
mov    $0x1,%al
movsd  0xd13(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0xb1(%rbp)
ja     136c <carlson_elliptic_rd+0x25c>
movsd  -0x38(%rbp),%xmm0
movaps 0xd37(%rip),%xmm1
pand   %xmm1,%xmm0
mov    $0x1,%al
movsd  0xce9(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0xb1(%rbp)
ja     136c <carlson_elliptic_rd+0x25c>
movsd  -0x40(%rbp),%xmm0
movaps 0xd0d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xcc1(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    1169 <carlson_elliptic_rd+0x59>
movsd  -0x30(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  0xc9f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
movsd  0xc47(%rip),%xmm1
mulsd  %xmm1,%xmm3
movsd  0xc43(%rip),%xmm1
addsd  %xmm1,%xmm3
movsd  0xc27(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm4
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm2
movsd  0xbb2(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  -0x40(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x58(%rbp),%xmm5
movsd  0xbca(%rip),%xmm6
mulsd  -0x40(%rbp),%xmm6
mulsd  -0x48(%rbp),%xmm6
movsd  0xbb0(%rip),%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
movsd  0xb94(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
movsd  0xb1e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<carlson_elliptic_rd>:
sub    $0x58,%rsp
movapd %xmm1,%xmm4
movapd %xmm0,%xmm6
unpcklpd %xmm2,%xmm6
movsd  0xed7(%rip),%xmm10
xorpd  %xmm8,%xmm8
xorpd  %xmm9,%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd %xmm8,%xmm6
movsd  %xmm4,0x10(%rsp)
movapd %xmm6,0x30(%rsp)
movsd  %xmm10,0x8(%rsp)
movsd  %xmm9,(%rsp)
jb     1170 <carlson_elliptic_rd+0x60>
xorps  %xmm0,%xmm0
sqrtsd %xmm6,%xmm0
jmp    1184 <carlson_elliptic_rd+0x74>
nopl   0x0(%rax)
movapd %xmm6,%xmm0
call   1030 <sqrt@plt>
xorpd  %xmm8,%xmm8
movsd  0x10(%rsp),%xmm4
movsd  %xmm0,0x28(%rsp)
ucomisd %xmm8,%xmm4
jb     11a0 <carlson_elliptic_rd+0x90>
xorps  %xmm3,%xmm3
sqrtsd %xmm4,%xmm3
jmp    11b2 <carlson_elliptic_rd+0xa2>
nopw   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
call   1030 <sqrt@plt>
xorpd  %xmm8,%xmm8
movapd %xmm0,%xmm3
movapd 0x30(%rsp),%xmm6
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
ucomisd %xmm8,%xmm0
jb     11d0 <carlson_elliptic_rd+0xc0>
sqrtsd %xmm0,%xmm0
jmp    11ec <carlson_elliptic_rd+0xdc>
nopl   (%rax)
movapd %xmm3,0x40(%rsp)
call   1030 <sqrt@plt>
movapd 0x40(%rsp),%xmm3
xorpd  %xmm8,%xmm8
movapd 0x30(%rsp),%xmm6
movsd  0x8(%rsp),%xmm10
movsd  (%rsp),%xmm9
movsd  0x10(%rsp),%xmm4
movapd 0xe69(%rip),%xmm7
movsd  0xe10(%rip),%xmm11
movapd %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  0x28(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
unpcklpd %xmm3,%xmm3
addpd  %xmm3,%xmm6
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm10,%xmm0
divsd  %xmm1,%xmm0
addsd  %xmm0,%xmm9
movsd  0xdb0(%rip),%xmm0
mulsd  %xmm0,%xmm10
mulsd  %xmm0,%xmm4
mulpd  0xdf7(%rip),%xmm6
movapd %xmm6,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
mulsd  0xd8f(%rip),%xmm5
addsd  %xmm0,%xmm5
mulsd  0xd8b(%rip),%xmm5
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm0,%xmm2
subpd  %xmm6,%xmm2
divpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
andpd  %xmm7,%xmm0
ucomisd %xmm11,%xmm0
ja     1140 <carlson_elliptic_rd+0x30>
movapd %xmm5,%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm5,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
ucomisd %xmm11,%xmm1
ja     1140 <carlson_elliptic_rd+0x30>
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm7,%xmm3
ucomisd %xmm11,%xmm3
ja     1140 <carlson_elliptic_rd+0x30>
shufpd $0x2,%xmm2,%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
movapd %xmm0,%xmm3
subsd  %xmm4,%xmm3
mulsd  0xd19(%rip),%xmm4
addsd  %xmm0,%xmm4
movapd %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0xd0c(%rip),%xmm8
mulsd  %xmm4,%xmm8
addsd  0xd06(%rip),%xmm8
addsd  %xmm3,%xmm2
movsd  0xd02(%rip),%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm8,%xmm6
mulsd  %xmm4,%xmm6
addsd  0xca9(%rip),%xmm6
movsd  0xce9(%rip),%xmm4
mulsd  %xmm1,%xmm4
mulsd  0xce5(%rip),%xmm3
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm3
mulsd  0xcdd(%rip),%xmm2
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm6,%xmm2
mulsd  %xmm2,%xmm10
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm5
jb     13a3 <carlson_elliptic_rd+0x293>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    13d2 <carlson_elliptic_rd+0x2c2>
movapd %xmm5,%xmm0
movsd  %xmm10,0x8(%rsp)
movsd  %xmm9,(%rsp)
movapd %xmm5,0x10(%rsp)
call   1030 <sqrt@plt>
movapd 0x10(%rsp),%xmm5
movsd  (%rsp),%xmm9
movsd  0x8(%rsp),%xmm10
mulsd  %xmm0,%xmm5
divsd  %xmm5,%xmm10
mulsd  0xc2c(%rip),%xmm9
addsd  %xmm10,%xmm9
movapd %xmm9,%xmm0
add    $0x58,%rsp
ret

LLVM IR (-O0):
define double @carlson_elliptic_rd(double %0, double %1, double %2) {
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%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
store double %0, double* %4
store double %1, double* %5
store double %2, double* %6
%26 = load double, double* %4
store double %26, double* %22
%27 = load double, double* %5
store double %27, double* %23
%28 = load double, double* %6
store double %28, double* %24
store double 0.000000e+00, double* %21
store double 1.000000e+00, double* %17
br label %29
29: ; preds = %100, %3
%30 = load double, double* %22
%31 = call double @sqrt(double %30)
store double %31, double* %18
%32 = load double, double* %23
%33 = call double @sqrt(double %32)
store double %33, double* %19
%34 = load double, double* %24
%35 = call double @sqrt(double %34)
store double %35, double* %20
%36 = load double, double* %18
%37 = load double, double* %19
%38 = load double, double* %20
%39 = fadd double %37, %38
%40 = load double, double* %19
%41 = load double, double* %20
%42 = fmul double %40, %41
%43 = call double @llvm.fmuladd.f64(double %36, double %39, double %42)
store double %43, double* %7
%44 = load double, double* %17
%45 = load double, double* %20
%46 = load double, double* %24
%47 = load double, double* %7
%48 = fadd double %46, %47
%49 = fmul double %45, %48
%50 = fdiv double %44, %49
%51 = load double, double* %21
%52 = fadd double %51, %50
store double %52, double* %21
%53 = load double, double* %17
%54 = fmul double 2.500000e-01, %53
store double %54, double* %17
%55 = load double, double* %22
%56 = load double, double* %7
%57 = fadd double %55, %56
%58 = fmul double 2.500000e-01, %57
store double %58, double* %22
%59 = load double, double* %23
%60 = load double, double* %7
%61 = fadd double %59, %60
%62 = fmul double 2.500000e-01, %61
store double %62, double* %23
%63 = load double, double* %24
%64 = load double, double* %7
%65 = fadd double %63, %64
%66 = fmul double 2.500000e-01, %65
store double %66, double* %24
%67 = load double, double* %22
%68 = load double, double* %23
%69 = fadd double %67, %68
%70 = load double, double* %24
%71 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %70, double %69)
%72 = fmul double 2.000000e-01, %71
store double %72, double* %8
%73 = load double, double* %8
%74 = load double, double* %22
%75 = fsub double %73, %74
%76 = load double, double* %8
%77 = fdiv double %75, %76
store double %77, double* %9
%78 = load double, double* %8
%79 = load double, double* %23
%80 = fsub double %78, %79
%81 = load double, double* %8
%82 = fdiv double %80, %81
store double %82, double* %10
%83 = load double, double* %8
%84 = load double, double* %24
%85 = fsub double %83, %84
%86 = load double, double* %8
%87 = fdiv double %85, %86
store double %87, double* %11
br label %88
88: ; preds = %29
%89 = load double, double* %9
%90 = call double @llvm.fabs.f64(double %89)
%91 = fcmp ogt double %90, 1.500000e-03
br i1 %91, label %100, label %92
92: ; preds = %88
%93 = load double, double* %10
%94 = call double @llvm.fabs.f64(double %93)
%95 = fcmp ogt double %94, 1.500000e-03
br i1 %95, label %100, label %96
96: ; preds = %92
%97 = load double, double* %11
%98 = call double @llvm.fabs.f64(double %97)
%99 = fcmp ogt double %98, 1.500000e-03
br label %100
100: ; preds = %96, %92, %88
%101 = phi i1 [ true, %92 ], [ true, %88 ], [ %99, %96 ]
br i1 %101, label %29, label %102
102: ; preds = %100
%103 = load double, double* %9
%104 = load double, double* %10
%105 = fmul double %103, %104
store double %105, double* %12
%106 = load double, double* %11
%107 = load double, double* %11
%108 = fmul double %106, %107
store double %108, double* %13
%109 = load double, double* %12
%110 = load double, double* %13
%111 = fsub double %109, %110
store double %111, double* %14
%112 = load double, double* %12
%113 = load double, double* %13
%114 = call double @llvm.fmuladd.f64(double -6.000000e+00, double %113, double %112)
store double %114, double* %15
%115 = load double, double* %15
%116 = load double, double* %14
%117 = fadd double %115, %116
%118 = load double, double* %14
%119 = fadd double %117, %118
store double %119, double* %16
%120 = load double, double* %21
%121 = load double, double* %17
%122 = load double, double* %15
%123 = load double, double* %15
%124 = call double @llvm.fmuladd.f64(double 0x3FBA2E8BA2E8BA2F, double %123, double 0xBFCB6DB6DB6DB6DB)
%125 = load double, double* %11
%126 = fmul double 0x3FC6276276276276, %125
%127 = load double, double* %16
%128 = fneg double %126
%129 = call double @llvm.fmuladd.f64(double %128, double %127, double %124)
%130 = call double @llvm.fmuladd.f64(double %122, double %129, double 1.000000e+00)
%131 = load double, double* %11
%132 = load double, double* %16
%133 = load double, double* %11
%134 = load double, double* %14
%135 = load double, double* %11
%136 = fmul double %135, 0x3FBD89D89D89D89E
%137 = load double, double* %12
%138 = fmul double %136, %137
%139 = call double @llvm.fmuladd.f64(double 0xBFDA2E8BA2E8BA2F, double %134, double %138)
%140 = fmul double %133, %139
%141 = call double @llvm.fmuladd.f64(double 0x3FC5555555555555, double %132, double %140)
%142 = call double @llvm.fmuladd.f64(double %131, double %141, double %130)
%143 = fmul double %121, %142
%144 = load double, double* %8
%145 = load double, double* %8
%146 = call double @sqrt(double %145)
%147 = fmul double %144, %146
%148 = fdiv double %143, %147
%149 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %120, double %148)
store double %149, double* %25
%150 = load double, double* %25
ret double %150
}

LLVM IR (-O2):
define double @carlson_elliptic_rd(double %0, double %1, double %2) {
%4 = insertelement <2 x double> poison, double %0, i64 0
%5 = insertelement <2 x double> %4, double %2, i64 1
br label %6
6: ; preds = %6, %3
%7 = phi double [ 0.000000e+00, %3 ], [ %25, %6 ]
%8 = phi double [ %1, %3 ], [ %28, %6 ]
%9 = phi double [ 1.000000e+00, %3 ], [ %26, %6 ]
%10 = phi <2 x double> [ %5, %3 ], [ %29, %6 ]
%11 = extractelement <2 x double> %10, i64 0
%12 = tail call double @sqrt(double %11)
%13 = tail call double @sqrt(double %8)
%14 = extractelement <2 x double> %10, i64 1
%15 = tail call double @sqrt(double %14)
%16 = fadd double %13, %15
%17 = fmul double %13, %15
%18 = tail call double @llvm.fmuladd.f64(double %12, double %16, double %17)
%19 = insertelement <2 x double> poison, double %18, i64 0
%20 = shufflevector <2 x double> %19, <2 x double> poison, <2 x i32> zeroinitializer
%21 = fadd <2 x double> %10, %20
%22 = extractelement <2 x double> %21, i64 1
%23 = fmul double %15, %22
%24 = fdiv double %9, %23
%25 = fadd double %7, %24
%26 = fmul double %9, 2.500000e-01
%27 = fadd double %8, %18
%28 = fmul double %27, 2.500000e-01
%29 = fmul <2 x double> %21, <double 2.500000e-01, double 2.500000e-01>
%30 = extractelement <2 x double> %29, i64 0
%31 = fadd double %30, %28
%32 = extractelement <2 x double> %29, i64 1
%33 = tail call double @llvm.fmuladd.f64(double %32, double 3.000000e+00, double %31)
%34 = fmul double %33, 2.000000e-01
%35 = fsub double %34, %28
%36 = fdiv double %35, %34
%37 = insertelement <2 x double> poison, double %34, i64 0
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> zeroinitializer
%39 = fsub <2 x double> %38, %29
%40 = fdiv <2 x double> %39, %38
%41 = extractelement <2 x double> %40, i64 0
%42 = tail call double @llvm.fabs.f64(double %41)
%43 = fcmp ogt double %42, 1.500000e-03
%44 = tail call double @llvm.fabs.f64(double %36)
%45 = fcmp ogt double %44, 1.500000e-03
%46 = select i1 %43, i1 true, i1 %45
%47 = extractelement <2 x double> %40, i64 1
%48 = tail call double @llvm.fabs.f64(double %47)
%49 = fcmp ogt double %48, 1.500000e-03
%50 = select i1 %46, i1 true, i1 %49
br i1 %50, label %6, label %51
51: ; preds = %6
%52 = insertelement <2 x double> %40, double %36, i64 0
%53 = fmul <2 x double> %40, %52
%54 = extractelement <2 x double> %53, i64 0
%55 = extractelement <2 x double> %53, i64 1
%56 = fsub double %54, %55
%57 = tail call double @llvm.fmuladd.f64(double %55, double -6.000000e+00, double %54)
%58 = fadd double %57, %56
%59 = fadd double %56, %58
%60 = tail call double @llvm.fmuladd.f64(double %57, double 0x3FBA2E8BA2E8BA2F, double 0xBFCB6DB6DB6DB6DB)
%61 = fmul double %47, 0xBFC6276276276276
%62 = tail call double @llvm.fmuladd.f64(double %61, double %59, double %60)
%63 = tail call double @llvm.fmuladd.f64(double %57, double %62, double 1.000000e+00)
%64 = fmul double %47, 0x3FBD89D89D89D89E
%65 = fmul double %64, %54
%66 = tail call double @llvm.fmuladd.f64(double %56, double 0xBFDA2E8BA2E8BA2F, double %65)
%67 = fmul double %47, %66
%68 = tail call double @llvm.fmuladd.f64(double %59, double 0x3FC5555555555555, double %67)
%69 = tail call double @llvm.fmuladd.f64(double %47, double %68, double %63)
%70 = fmul double %26, %69
%71 = tail call double @sqrt(double %34)
%72 = fmul double %34, %71
%73 = fdiv double %70, %72
%74 = tail call double @llvm.fmuladd.f64(double %25, double 3.000000e+00, double %73)
ret double %74
}