#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 erf(double);
double exp(double);
double log(double);
int /*<<< orphan*/ printf(char *);
double sqrt(double);
double inverse_error_func(double y) {
  double x = 0.0;
  double z = 0.0;
  double y0 = 0.7;
  double a[4] = {0.886226899, -1.645349621, 0.914624893, -0.140543331};
  double b[4] = {-2.118377725, 1.442710462, -0.329097515, 0.012229801};
  double c[4] = {-1.970840454, -1.624906493, 3.429567803, 1.641345311};
  double d[2] = {3.543889200, 1.637067800};
  if ((y < -1.0) || (1.0 < y)) {
    printf("inverse_error_func: The value out of the range of the function");
    x = log(-1.0);
  } else if ((y == -1.0) || (1.0 == y)) {
    x = -y * log(0.0);
  } else if ((-1.0 < y) && (y < -y0)) {
    z = sqrt(-log((1.0 + y) / 2.0));
    x = -(((c[3] * z + c[2]) * z + c[1]) * z + c[0]) /
        ((d[1] * z + d[0]) * z + 1.0);
  } else {
    if ((-y0 < y) && (y < y0)) {
      z = y * y;
      x = y * (((a[3] * z + a[2]) * z + a[1]) * z + a[0]) /
          ((((b[3] * z + b[3]) * z + b[1]) * z + b[0]) * z + 1.0);
    } else if ((y0 < y) && (y < 1.0)) {
      z = sqrt(-log((1.0 - y) / 2.0));
      x = (((c[3] * z + c[2]) * z + c[1]) * z + c[0]) /
          ((d[1] * z + d[0]) * z + 1.0);
    }
    x = x - (erf(x) - y) / (2.0 / sqrt(3.14159265358979323846) * exp(-x * x));
    x = x - (erf(x) - y) / (2.0 / sqrt(3.14159265358979323846) * exp(-x * x));
  }
  return (x);
}


x86 assembly (clang, -O0):
<inverse_error_func>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movsd  %xmm0,-0x8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xe90(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    0xeac(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xea9(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xea6(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xea3(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0xea0(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xe9d(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xe9a(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xe97(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    0xe94(%rip),%rax
mov    %rax,-0x80(%rbp)
mov    0xe91(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    0xe8e(%rip),%rax
mov    %rax,-0x70(%rbp)
mov    0xe8b(%rip),%rax
mov    %rax,-0x68(%rbp)
mov    0xe88(%rip),%rax
mov    %rax,-0x90(%rbp)
mov    0xe82(%rip),%rax
mov    %rax,-0x88(%rbp)
movsd  0xddb(%rip),%xmm0
ucomisd -0x8(%rbp),%xmm0
ja     1247 <inverse_error_func+0xf7>
movsd  -0x8(%rbp),%xmm0
movsd  0xdd3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    126a <inverse_error_func+0x11a>
lea    0xe52(%rip),%rdi
call   1030 <printf@plt>
movsd  0xda5(%rip),%xmm0
call   1050 <log@plt>
movsd  %xmm0,-0x10(%rbp)
jmp    170c <inverse_error_func+0x5bc>
movsd  -0x8(%rbp),%xmm0
movsd  0xd89(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    128c <inverse_error_func+0x13c>
jp     128c <inverse_error_func+0x13c>
jmp    12a5 <inverse_error_func+0x155>
movsd  0xd7c(%rip),%xmm0
ucomisd -0x8(%rbp),%xmm0
jne    12ea <inverse_error_func+0x19a>
jp     12ea <inverse_error_func+0x19a>
movsd  -0x8(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
call   1050 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    1707 <inverse_error_func+0x5b7>
movsd  -0x8(%rbp),%xmm0
movsd  0xd09(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13fd <inverse_error_func+0x2ad>
movsd  -0x8(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    13fd <inverse_error_func+0x2ad>
movsd  0xcdc(%rip),%xmm0
addsd  -0x8(%rbp),%xmm0
movsd  0xcd7(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <log@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x18(%rbp),%xmm3
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xc25(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    1702 <inverse_error_func+0x5b2>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14ed <inverse_error_func+0x39d>
movsd  -0x8(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14ed <inverse_error_func+0x39d>
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm3
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xb35(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    15ce <inverse_error_func+0x47e>
movsd  -0x20(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15c9 <inverse_error_func+0x479>
movsd  0xb07(%rip),%xmm0
ucomisd -0x8(%rbp),%xmm0
jbe    15c9 <inverse_error_func+0x479>
movsd  0xaf4(%rip),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  0xaef(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <log@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x18(%rbp),%xmm3
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xa54(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    15ce <inverse_error_func+0x47e>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1070 <erf@plt>
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xa26(%rip),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xa0e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x10(%rbp),%xmm0
call   1040 <exp@plt>
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1070 <erf@plt>
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x98c(%rip),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x974(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x10(%rbp),%xmm0
call   1040 <exp@plt>
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    1707 <inverse_error_func+0x5b7>
jmp    170c <inverse_error_func+0x5bc>
movsd  -0x10(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inverse_error_func>:
sub    $0x28,%rsp
movapd %xmm0,%xmm3
movsd  0xea0(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     11fc <inverse_error_func+0xac>
ucomisd 0xe96(%rip),%xmm3
ja     11fc <inverse_error_func+0xac>
ucomisd 0xe80(%rip),%xmm3
jne    1188 <inverse_error_func+0x38>
jnp    1219 <inverse_error_func+0xc9>
ucomisd 0xe78(%rip),%xmm3
jne    1198 <inverse_error_func+0x48>
jnp    1219 <inverse_error_func+0xc9>
ucomisd 0xe60(%rip),%xmm3
jbe    123f <inverse_error_func+0xef>
movsd  0xe62(%rip),%xmm0
ucomisd %xmm3,%xmm0
jbe    123f <inverse_error_func+0xef>
addsd  0xe48(%rip),%xmm3
mulsd  0xe58(%rip),%xmm3
movapd %xmm3,%xmm0
call   1050 <log@plt>
movapd %xmm0,%xmm1
movapd 0xec3(%rip),%xmm0
xorpd  %xmm1,%xmm0
movsd  0xe3f(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1336 <inverse_error_func+0x1e6>
sqrtsd %xmm0,%xmm0
jmp    133b <inverse_error_func+0x1eb>
lea    0xedd(%rip),%rdi
call   1030 <printf@plt>
movsd  0xdf0(%rip),%xmm0
add    $0x28,%rsp
jmp    1050 <log@plt>
xorpd  0xe7f(%rip),%xmm3
movapd %xmm3,0x10(%rsp)
xorpd  %xmm0,%xmm0
call   1050 <log@plt>
movapd %xmm0,%xmm2
mulsd  0x10(%rsp),%xmm2
jmp    1486 <inverse_error_func+0x336>
ucomisd 0xdc9(%rip),%xmm3
movapd %xmm3,0x10(%rsp)
jbe    12da <inverse_error_func+0x18a>
movsd  0xdbd(%rip),%xmm0
ucomisd %xmm3,%xmm0
jbe    12da <inverse_error_func+0x18a>
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
movsd  0xdcf(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  0xdcb(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  0xdc7(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  0xdc3(%rip),%xmm4
movsd  0xdc3(%rip),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  0xdb3(%rip),%xmm2
mulsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm2
addsd  0xdab(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  0xd37(%rip),%xmm2
divsd  %xmm2,%xmm4
jmp    13ed <inverse_error_func+0x29d>
ucomisd 0xd36(%rip),%xmm3
xorpd  %xmm4,%xmm4
jbe    13ed <inverse_error_func+0x29d>
movsd  0xd14(%rip),%xmm0
ucomisd %xmm3,%xmm0
jbe    13ed <inverse_error_func+0x29d>
subsd  %xmm3,%xmm0
mulsd  0xd16(%rip),%xmm0
call   1050 <log@plt>
movapd %xmm0,%xmm1
movapd 0xd85(%rip),%xmm0
xorpd  %xmm1,%xmm0
movsd  0xd01(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1398 <inverse_error_func+0x248>
xorps  %xmm4,%xmm4
sqrtsd %xmm0,%xmm4
jmp    13a1 <inverse_error_func+0x251>
call   1060 <sqrt@plt>
movsd  0xced(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  0xce9(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  0xd25(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  0xd21(%rip),%xmm2
xorpd  0xd31(%rip),%xmm2
movsd  0xd19(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xd15(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xc79(%rip),%xmm1
divsd  %xmm1,%xmm2
jmp    1486 <inverse_error_func+0x336>
call   1060 <sqrt@plt>
movapd %xmm0,%xmm4
movsd  0xc87(%rip),%xmm0
mulsd  %xmm4,%xmm0
addsd  0xc83(%rip),%xmm0
unpcklpd %xmm4,%xmm0
movapd 0xcef(%rip),%xmm1
movsd  %xmm4,%xmm1
mulpd  %xmm0,%xmm1
addpd  0xcef(%rip),%xmm1
unpcklpd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
addpd  0xcef(%rip),%xmm4
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,(%rsp)
movapd %xmm4,%xmm0
call   1070 <erf@plt>
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movapd (%rsp),%xmm0
xorpd  0xc8c(%rip),%xmm0
mulsd  (%rsp),%xmm0
call   1040 <exp@plt>
mulsd  0xc52(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd (%rsp),%xmm0
subsd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
movapd (%rsp),%xmm0
call   1070 <erf@plt>
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movapd 0xc44(%rip),%xmm0
xorpd  (%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1040 <exp@plt>
movapd (%rsp),%xmm2
mulsd  0xc00(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
add    $0x28,%rsp
ret

LLVM IR (-O0):
@__const.inverse_error_func.a = [4 x double] [double 0x3FEC5BF883814BBC, double 0xBFFA535A1FCAE55B, double 0x3FED449B6C715C28, double 0xBFC1FD52E9286F82]
@__const.inverse_error_func.b = [4 x double] [double 0xC000F270054B995C, double 0x3FF7155790BE315C, double 0xBFD50FEF0607ABF1, double 0x3F890BF01AA717A9]
@__const.inverse_error_func.c = [4 x double] [double 0xBFFF888FFFF9054B, double 0xBFF9FF9DF367E38B, double 0x400B6FC13E8A6585, double 0x3FFA42F34D0301D7]
@__const.inverse_error_func.d = [2 x double] [double 0x400C59E294B52E4B, double 0x3FFA316E01655ACE]
@.str = [63 x i8] c"inverse_error_func: The value out of the range of the function\00"
define double @inverse_error_func(double %0) {
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca [4 x double]
%7 = alloca [4 x double]
%8 = alloca [4 x double]
%9 = alloca [2 x double]
store double %0, double* %2
store double 0.000000e+00, double* %3
store double 0.000000e+00, double* %4
store double 0x3FE6666666666666, double* %5
%10 = bitcast [4 x double]* %6 to i8*
%11 = bitcast [4 x double]* %7 to i8*
%12 = bitcast [4 x double]* %8 to i8*
%13 = bitcast [2 x double]* %9 to i8*
%14 = load double, double* %2
%15 = fcmp olt double %14, -1.000000e+00
br i1 %15, label %19, label %16
16: ; preds = %1
%17 = load double, double* %2
%18 = fcmp olt double 1.000000e+00, %17
br i1 %18, label %19, label %22
19: ; preds = %16, %1
%20 = call i32 @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0))
%21 = call double @log(double -1.000000e+00)
store double %21, double* %3
br label %189
22: ; preds = %16
%23 = load double, double* %2
%24 = fcmp oeq double %23, -1.000000e+00
br i1 %24, label %28, label %25
25: ; preds = %22
%26 = load double, double* %2
%27 = fcmp oeq double 1.000000e+00, %26
br i1 %27, label %28, label %33
28: ; preds = %25, %22
%29 = load double, double* %2
%30 = fneg double %29
%31 = call double @log(double 0.000000e+00)
%32 = fmul double %30, %31
store double %32, double* %3
br label %188
33: ; preds = %25
%34 = load double, double* %2
%35 = fcmp olt double -1.000000e+00, %34
br i1 %35, label %36, label %72
36: ; preds = %33
%37 = load double, double* %2
%38 = load double, double* %5
%39 = fneg double %38
%40 = fcmp olt double %37, %39
br i1 %40, label %41, label %72
41: ; preds = %36
%42 = load double, double* %2
%43 = fadd double 1.000000e+00, %42
%44 = fdiv double %43, 2.000000e+00
%45 = call double @log(double %44)
%46 = fneg double %45
%47 = call double @sqrt(double %46)
store double %47, double* %4
%48 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 3
%49 = load double, double* %48
%50 = load double, double* %4
%51 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 2
%52 = load double, double* %51
%53 = call double @llvm.fmuladd.f64(double %49, double %50, double %52)
%54 = load double, double* %4
%55 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 1
%56 = load double, double* %55
%57 = call double @llvm.fmuladd.f64(double %53, double %54, double %56)
%58 = load double, double* %4
%59 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 0
%60 = load double, double* %59
%61 = call double @llvm.fmuladd.f64(double %57, double %58, double %60)
%62 = fneg double %61
%63 = getelementptr inbounds [2 x double], [2 x double]* %9, i64 0, i64 1
%64 = load double, double* %63
%65 = load double, double* %4
%66 = getelementptr inbounds [2 x double], [2 x double]* %9, i64 0, i64 0
%67 = load double, double* %66
%68 = call double @llvm.fmuladd.f64(double %64, double %65, double %67)
%69 = load double, double* %4
%70 = call double @llvm.fmuladd.f64(double %68, double %69, double 1.000000e+00)
%71 = fdiv double %62, %70
store double %71, double* %3
br label %187
72: ; preds = %36, %33
%73 = load double, double* %5
%74 = fneg double %73
%75 = load double, double* %2
%76 = fcmp olt double %74, %75
br i1 %76, label %77, label %118
77: ; preds = %72
%78 = load double, double* %2
%79 = load double, double* %5
%80 = fcmp olt double %78, %79
br i1 %80, label %81, label %118
81: ; preds = %77
%82 = load double, double* %2
%83 = load double, double* %2
%84 = fmul double %82, %83
store double %84, double* %4
%85 = load double, double* %2
%86 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 3
%87 = load double, double* %86
%88 = load double, double* %4
%89 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 2
%90 = load double, double* %89
%91 = call double @llvm.fmuladd.f64(double %87, double %88, double %90)
%92 = load double, double* %4
%93 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 1
%94 = load double, double* %93
%95 = call double @llvm.fmuladd.f64(double %91, double %92, double %94)
%96 = load double, double* %4
%97 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 0
%98 = load double, double* %97
%99 = call double @llvm.fmuladd.f64(double %95, double %96, double %98)
%100 = fmul double %85, %99
%101 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 3
%102 = load double, double* %101
%103 = load double, double* %4
%104 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 3
%105 = load double, double* %104
%106 = call double @llvm.fmuladd.f64(double %102, double %103, double %105)
%107 = load double, double* %4
%108 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 1
%109 = load double, double* %108
%110 = call double @llvm.fmuladd.f64(double %106, double %107, double %109)
%111 = load double, double* %4
%112 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%113 = load double, double* %112
%114 = call double @llvm.fmuladd.f64(double %110, double %111, double %113)
%115 = load double, double* %4
%116 = call double @llvm.fmuladd.f64(double %114, double %115, double 1.000000e+00)
%117 = fdiv double %100, %116
store double %117, double* %3
br label %156
118: ; preds = %77, %72
%119 = load double, double* %5
%120 = load double, double* %2
%121 = fcmp olt double %119, %120
br i1 %121, label %122, label %155
122: ; preds = %118
%123 = load double, double* %2
%124 = fcmp olt double %123, 1.000000e+00
br i1 %124, label %125, label %155
125: ; preds = %122
%126 = load double, double* %2
%127 = fsub double 1.000000e+00, %126
%128 = fdiv double %127, 2.000000e+00
%129 = call double @log(double %128)
%130 = fneg double %129
%131 = call double @sqrt(double %130)
store double %131, double* %4
%132 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 3
%133 = load double, double* %132
%134 = load double, double* %4
%135 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 2
%136 = load double, double* %135
%137 = call double @llvm.fmuladd.f64(double %133, double %134, double %136)
%138 = load double, double* %4
%139 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 1
%140 = load double, double* %139
%141 = call double @llvm.fmuladd.f64(double %137, double %138, double %140)
%142 = load double, double* %4
%143 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 0
%144 = load double, double* %143
%145 = call double @llvm.fmuladd.f64(double %141, double %142, double %144)
%146 = getelementptr inbounds [2 x double], [2 x double]* %9, i64 0, i64 1
%147 = load double, double* %146
%148 = load double, double* %4
%149 = getelementptr inbounds [2 x double], [2 x double]* %9, i64 0, i64 0
%150 = load double, double* %149
%151 = call double @llvm.fmuladd.f64(double %147, double %148, double %150)
%152 = load double, double* %4
%153 = call double @llvm.fmuladd.f64(double %151, double %152, double 1.000000e+00)
%154 = fdiv double %145, %153
store double %154, double* %3
br label %155
155: ; preds = %125, %122, %118
br label %156
156: ; preds = %155, %81
%157 = load double, double* %3
%158 = load double, double* %3
%159 = call double @erf(double %158)
%160 = load double, double* %2
%161 = fsub double %159, %160
%162 = call double @sqrt(double 0x400921FB54442D18)
%163 = fdiv double 2.000000e+00, %162
%164 = load double, double* %3
%165 = fneg double %164
%166 = load double, double* %3
%167 = fmul double %165, %166
%168 = call double @exp(double %167)
%169 = fmul double %163, %168
%170 = fdiv double %161, %169
%171 = fsub double %157, %170
store double %171, double* %3
%172 = load double, double* %3
%173 = load double, double* %3
%174 = call double @erf(double %173)
%175 = load double, double* %2
%176 = fsub double %174, %175
%177 = call double @sqrt(double 0x400921FB54442D18)
%178 = fdiv double 2.000000e+00, %177
%179 = load double, double* %3
%180 = fneg double %179
%181 = load double, double* %3
%182 = fmul double %180, %181
%183 = call double @exp(double %182)
%184 = fmul double %178, %183
%185 = fdiv double %176, %184
%186 = fsub double %172, %185
store double %186, double* %3
br label %187
187: ; preds = %156, %41
br label %188
188: ; preds = %187, %28
br label %189
189: ; preds = %188, %19
%190 = load double, double* %3
ret double %190
}

LLVM IR (-O2):
@.str = [63 x i8] c"inverse_error_func: The value out of the range of the function\00"
define double @inverse_error_func(double %0) {
%2 = fcmp olt double %0, -1.000000e+00
%3 = fcmp ogt double %0, 1.000000e+00
%4 = or i1 %2, %3
br i1 %4, label %5, label %8
5: ; preds = %1
%6 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0))
%7 = tail call double @log(double -1.000000e+00)
br label %87
8: ; preds = %1
%9 = fcmp oeq double %0, -1.000000e+00
%10 = fcmp oeq double %0, 1.000000e+00
%11 = or i1 %9, %10
br i1 %11, label %12, label %16
12: ; preds = %8
%13 = fneg double %0
%14 = tail call double @log(double 0.000000e+00)
%15 = fmul double %14, %13
br label %87
16: ; preds = %8
%17 = fcmp ogt double %0, -1.000000e+00
%18 = fcmp olt double %0, 0xBFE6666666666666
%19 = and i1 %17, %18
br i1 %19, label %20, label %33
20: ; preds = %16
%21 = fadd double %0, 1.000000e+00
%22 = fmul double %21, 5.000000e-01
%23 = tail call double @log(double %22)
%24 = fneg double %23
%25 = tail call double @sqrt(double %24)
%26 = tail call double @llvm.fmuladd.f64(double %25, double 0x3FFA42F34D0301D7, double 0x400B6FC13E8A6585)
%27 = tail call double @llvm.fmuladd.f64(double %26, double %25, double 0xBFF9FF9DF367E38B)
%28 = tail call double @llvm.fmuladd.f64(double %27, double %25, double 0xBFFF888FFFF9054B)
%29 = fneg double %28
%30 = tail call double @llvm.fmuladd.f64(double %25, double 0x3FFA316E01655ACE, double 0x400C59E294B52E4B)
%31 = tail call double @llvm.fmuladd.f64(double %30, double %25, double 1.000000e+00)
%32 = fdiv double %29, %31
br label %87
33: ; preds = %16
%34 = fcmp ogt double %0, 0xBFE6666666666666
%35 = fcmp olt double %0, 0x3FE6666666666666
%36 = and i1 %34, %35
br i1 %36, label %37, label %48
37: ; preds = %33
%38 = fmul double %0, %0
%39 = tail call double @llvm.fmuladd.f64(double %38, double 0xBFC1FD52E9286F82, double 0x3FED449B6C715C28)
%40 = tail call double @llvm.fmuladd.f64(double %39, double %38, double 0xBFFA535A1FCAE55B)
%41 = tail call double @llvm.fmuladd.f64(double %40, double %38, double 0x3FEC5BF883814BBC)
%42 = fmul double %41, %0
%43 = tail call double @llvm.fmuladd.f64(double %38, double 0x3F890BF01AA717A9, double 0x3F890BF01AA717A9)
%44 = tail call double @llvm.fmuladd.f64(double %43, double %38, double 0x3FF7155790BE315C)
%45 = tail call double @llvm.fmuladd.f64(double %44, double %38, double 0xC000F270054B995C)
%46 = tail call double @llvm.fmuladd.f64(double %45, double %38, double 1.000000e+00)
%47 = fdiv double %42, %46
br label %69
48: ; preds = %33
%49 = fcmp ogt double %0, 0x3FE6666666666666
%50 = fcmp olt double %0, 1.000000e+00
%51 = and i1 %49, %50
br i1 %51, label %52, label %69
52: ; preds = %48
%53 = fsub double 1.000000e+00, %0
%54 = fmul double %53, 5.000000e-01
%55 = tail call double @log(double %54)
%56 = fneg double %55
%57 = tail call double @sqrt(double %56)
%58 = tail call double @llvm.fmuladd.f64(double %57, double 0x3FFA42F34D0301D7, double 0x400B6FC13E8A6585)
%59 = insertelement <2 x double> poison, double %58, i64 0
%60 = insertelement <2 x double> %59, double %57, i64 1
%61 = insertelement <2 x double> <double poison, double 0x3FFA316E01655ACE>, double %57, i64 0
%62 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %61, <2 x double> <double 0xBFF9FF9DF367E38B, double 0x400C59E294B52E4B>)
%63 = insertelement <2 x double> poison, double %57, 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> %62, <2 x double> %64, <2 x double> <double 0xBFFF888FFFF9054B, double 1.000000e+00>)
%66 = extractelement <2 x double> %65, i64 0
%67 = extractelement <2 x double> %65, i64 1
%68 = fdiv double %66, %67
br label %69
69: ; preds = %48, %52, %37
%70 = phi double [ %47, %37 ], [ %68, %52 ], [ 0.000000e+00, %48 ]
%71 = tail call double @erf(double %70)
%72 = fsub double %71, %0
%73 = fneg double %70
%74 = fmul double %70, %73
%75 = tail call double @exp(double %74)
%76 = fmul double %75, 0x3FF20DD750429B6D
%77 = fdiv double %72, %76
%78 = fsub double %70, %77
%79 = tail call double @erf(double %78)
%80 = fsub double %79, %0
%81 = fneg double %78
%82 = fmul double %78, %81
%83 = tail call double @exp(double %82)
%84 = fmul double %83, 0x3FF20DD750429B6D
%85 = fdiv double %80, %84
%86 = fsub double %78, %85
br label %87
87: ; preds = %12, %69, %20, %5
%88 = phi double [ %7, %5 ], [ %15, %12 ], [ %32, %20 ], [ %86, %69 ]
ret double %88
}