#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 f3(double);
double fabs(double);
double sqrt(double);
double get_becke_w(const double *cx, const double *cy, const double *cz,
                   const double *rmid, double pa[], const int icent,
                   const int num_centers, const double x, const double y,
                   const double z) {
  double R_a, R_b;
  double u_ab, a_ab, mu_ab, nu_ab;
  double f;
  double dist_a, dist_b, dist_ab;
  double vx, vy, vz;
  int a, b;
  for (a = 0; a < num_centers; a++) {
    pa[a] = 1.0;
  }
  for (a = 0; a < num_centers; a++) {
    vx = cx[a] - x;
    vy = cy[a] - y;
    vz = cz[a] - z;
    dist_a = vx * vx + vy * vy + vz * vz;
    dist_a = sqrt(dist_a);
    if (a != icent && dist_a > 8.0 * 1.889726125453543) {
      pa[a] = 0.0;
      continue;
    }
    R_a = rmid[a];
    for (b = 0; b < a; b++) {
      if (a != b) {
        vx = cx[b] - x;
        vy = cy[b] - y;
        vz = cz[b] - z;
        dist_b = vx * vx + vy * vy + vz * vz;
        dist_b = sqrt(dist_b);
        R_b = rmid[b];
        vx = cx[b] - cx[a];
        vy = cy[b] - cy[a];
        vz = cz[b] - cz[a];
        dist_ab = vx * vx + vy * vy + vz * vz;
        dist_ab = sqrt(dist_ab);
        mu_ab = (dist_a - dist_b) / dist_ab;
        if (fabs(R_a - R_b) > 1.0e-14) {
          u_ab = (R_a + R_b) / (R_b - R_a);
          a_ab = u_ab / (u_ab * u_ab - 1.0);
          if (a_ab > 0.5)
            a_ab = 0.5;
          if (a_ab < -0.5)
            a_ab = -0.5;
          nu_ab = mu_ab + a_ab * (1.0 - mu_ab * mu_ab);
        } else {
          nu_ab = mu_ab;
        }
        f = f3(nu_ab);
        if (fabs(1.0 - f) < 1.0e-14) {
          pa[a] = 0.0;
        } else {
          pa[a] *= 0.5 * (1.0 - f);
          pa[b] *= 0.5 * (1.0 + f);
        }
      }
    }
  }
  double w = 0.0;
  for (a = 0; a < num_centers; a++) {
    w += pa[a];
  }
  if (fabs(w) > 1.0e-14) {
    return pa[icent] / w;
  } else {
    return 1.0;
  }
}


x86 assembly (clang, -O0):
<get_becke_w>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movsd  %xmm0,-0x40(%rbp)
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm2,-0x50(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    119a <get_becke_w+0x7a>
mov    -0x30(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  0xe87(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    115f <get_becke_w+0x3f>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    169d <get_becke_w+0x57d>
mov    -0x10(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xbc(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     12a8 <get_becke_w+0x188>
movsd  -0x90(%rbp),%xmm0
ff
movsd  0xd8a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12a8 <get_becke_w+0x188>
mov    -0x30(%rbp),%rax
movslq -0xbc(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1689 <get_becke_w+0x569>
mov    -0x28(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jge    1684 <get_becke_w+0x564>
mov    -0xbc(%rbp),%eax
cmp    -0xc0(%rbp),%eax
je     166b <get_becke_w+0x54b>
mov    -0x10(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xbc(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xbc(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movaps 0xb79(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xb3d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    15a3 <get_becke_w+0x483>
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xb1b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0xaf9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1536 <get_becke_w+0x416>
movsd  0xae7(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xaea(%rip),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1556 <get_becke_w+0x436>
movsd  0xad7(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
movsd  0xa7b(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    15ad <get_becke_w+0x48d>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
call   1030 <f3@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xa41(%rip),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
movaps 0xa5a(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xa1e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1604 <get_becke_w+0x4e4>
mov    -0x30(%rbp),%rax
movslq -0xbc(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1666 <get_becke_w+0x546>
movsd  0x9fc(%rip),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
movsd  0x9fc(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x9cb(%rip),%xmm1
addsd  -0x88(%rbp),%xmm1
ff
movsd  0x9cb(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    166b <get_becke_w+0x54b>
jmp    1670 <get_becke_w+0x550>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    12c7 <get_becke_w+0x1a7>
jmp    1689 <get_becke_w+0x569>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    11a4 <get_becke_w+0x84>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16f5 <get_becke_w+0x5d5>
mov    -0x30(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    16b2 <get_becke_w+0x592>
movsd  -0xc8(%rbp),%xmm0
ff
movaps 0x92c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x8f0(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1739 <get_becke_w+0x619>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
jmp    1746 <get_becke_w+0x626>
movsd  0x8c7(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_becke_w>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm2,0x30(%rsp)
movsd  %xmm1,0x28(%rsp)
movsd  %xmm0,0x20(%rsp)
mov    %r8,%r12
mov    %rcx,0x18(%rsp)
mov    0x90(%rsp),%r8d
xorpd  %xmm1,%xmm1
test   %r8d,%r8d
jle    160e <get_becke_w+0x4ee>
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    %r8d,%edi
cmp    $0x4,%r8d
jae    1176 <get_becke_w+0x56>
xor    %eax,%eax
jmp    1279 <get_becke_w+0x159>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%rsi
jae    119c <get_becke_w+0x7c>
xor    %esi,%esi
jmp    1245 <get_becke_w+0x125>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movapd 0xe56(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,(%r12,%rsi,8)
movupd %xmm0,0x10(%r12,%rsi,8)
movupd %xmm0,0x20(%r12,%rsi,8)
movupd %xmm0,0x30(%r12,%rsi,8)
movupd %xmm0,0x40(%r12,%rsi,8)
movupd %xmm0,0x50(%r12,%rsi,8)
movupd %xmm0,0x60(%r12,%rsi,8)
movupd %xmm0,0x70(%r12,%rsi,8)
movupd %xmm0,0x80(%r12,%rsi,8)
movupd %xmm0,0x90(%r12,%rsi,8)
movupd %xmm0,0xa0(%r12,%rsi,8)
movupd %xmm0,0xb0(%r12,%rsi,8)
movupd %xmm0,0xc0(%r12,%rsi,8)
movupd %xmm0,0xd0(%r12,%rsi,8)
movupd %xmm0,0xe0(%r12,%rsi,8)
movupd %xmm0,0xf0(%r12,%rsi,8)
add    $0x20,%rsi
add    $0xfffffffffffffff8,%rdx
jne    11b0 <get_becke_w+0x90>
test   %rcx,%rcx
je     1274 <get_becke_w+0x154>
lea    (%r12,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movapd 0xda0(%rip),%xmm0
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1260 <get_becke_w+0x140>
cmp    %rdi,%rax
je     129d <get_becke_w+0x17d>
movabs $0x3ff0000000000000,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1290 <get_becke_w+0x170>
test   %r8d,%r8d
jle    160e <get_becke_w+0x4ee>
mov    %r9d,0x4(%rsp)
mov    %r9d,%eax
mov    %rax,0x38(%rsp)
xor    %r14d,%r14d
mov    %rdi,0x40(%rsp)
jmp    12da <get_becke_w+0x1ba>
nopl   (%rax)
movq   $0x0,(%r12,%r14,8)
add    $0x1,%r14
mov    0x40(%rsp),%rdx
cmp    %rdx,%r14
je     156b <get_becke_w+0x44b>
movsd  0x0(%rbp,%r14,8),%xmm1
subsd  0x20(%rsp),%xmm1
movsd  (%rbx,%r14,8),%xmm2
subsd  0x28(%rsp),%xmm2
movsd  0x0(%r13,%r14,8),%xmm0
subsd  0x30(%rsp),%xmm0
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xd34(%rip),%xmm0
jb     1330 <get_becke_w+0x210>
sqrtsd %xmm0,%xmm0
jmp    1335 <get_becke_w+0x215>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1040 <sqrt@plt>
movsd  %xmm0,0x8(%rsp)
cmp    0x38(%rsp),%r14
je     1356 <get_becke_w+0x236>
movsd  0x8(%rsp),%xmm0
ucomisd 0xcd0(%rip),%xmm0
ja     12c0 <get_becke_w+0x1a0>
test   %r14,%r14
je     12c8 <get_becke_w+0x1a8>
mov    0x18(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
xor    %r15d,%r15d
movsd  %xmm0,0x10(%rsp)
jmp    13bd <get_becke_w+0x29d>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm4,%xmm3
movsd  0xcac(%rip),%xmm2
mulsd  %xmm2,%xmm1
mulsd  (%r12,%r14,8),%xmm1
movsd  %xmm1,(%r12,%r14,8)
addsd  %xmm4,%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%r12,%r15,8),%xmm0
movsd  %xmm0,(%r12,%r15,8)
add    $0x1,%r15
cmp    %r15,%r14
je     12c8 <get_becke_w+0x1a8>
movsd  0x0(%rbp,%r15,8),%xmm1
subsd  0x20(%rsp),%xmm1
movsd  (%rbx,%r15,8),%xmm2
subsd  0x28(%rsp),%xmm2
movsd  0x0(%r13,%r15,8),%xmm0
subsd  0x30(%rsp),%xmm0
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xc51(%rip),%xmm0
jb     1410 <get_becke_w+0x2f0>
xorps  %xmm3,%xmm3
sqrtsd %xmm0,%xmm3
jmp    1419 <get_becke_w+0x2f9>
nopw   0x0(%rax,%rax,1)
call   1040 <sqrt@plt>
movapd %xmm0,%xmm3
movsd  0x0(%rbp,%r15,8),%xmm1
subsd  0x0(%rbp,%r14,8),%xmm1
movsd  (%rbx,%r15,8),%xmm2
subsd  (%rbx,%r14,8),%xmm2
movsd  0x0(%r13,%r15,8),%xmm0
subsd  0x0(%r13,%r14,8),%xmm0
mov    0x18(%rsp),%rax
movsd  (%rax,%r15,8),%xmm5
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xbe8(%rip),%xmm0
jb     1480 <get_becke_w+0x360>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    14a1 <get_becke_w+0x381>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm3,0x50(%rsp)
movsd  %xmm5,0x48(%rsp)
call   1040 <sqrt@plt>
movsd  0x48(%rsp),%xmm5
movsd  0x50(%rsp),%xmm3
movapd %xmm0,%xmm1
movsd  0xb9f(%rip),%xmm4
movsd  0x10(%rsp),%xmm2
movsd  0x8(%rsp),%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm1,%xmm0
movapd %xmm2,%xmm1
subsd  %xmm5,%xmm1
andpd  0xb43(%rip),%xmm1
ucomisd 0xb53(%rip),%xmm1
jbe    152b <get_becke_w+0x40b>
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
subsd  %xmm2,%xmm5
divsd  %xmm5,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
addsd  0xb39(%rip),%xmm2
divsd  %xmm2,%xmm1
movsd  0xb35(%rip),%xmm2
minsd  %xmm1,%xmm2
movsd  0xb31(%rip),%xmm1
maxsd  %xmm2,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm4,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
call   1030 <f3@plt>
movsd  0xb10(%rip),%xmm4
movapd %xmm4,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm2
andpd  0xac4(%rip),%xmm2
movsd  0xad4(%rip),%xmm3
ucomisd %xmm2,%xmm3
jbe    1380 <get_becke_w+0x260>
movq   $0x0,(%r12,%r14,8)
jmp    13b0 <get_becke_w+0x290>
cmpl   $0x0,0x90(%rsp)
jle    1591 <get_becke_w+0x471>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
mov    0x4(%rsp),%r9d
jae    159c <get_becke_w+0x47c>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    15f0 <get_becke_w+0x4d0>
xorpd  %xmm1,%xmm1
mov    0x4(%rsp),%r9d
jmp    160e <get_becke_w+0x4ee>
and    $0xfffffff8,%edx
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
addsd  (%r12,%rcx,8),%xmm1
addsd  0x8(%r12,%rcx,8),%xmm1
addsd  0x10(%r12,%rcx,8),%xmm1
addsd  0x18(%r12,%rcx,8),%xmm1
addsd  0x20(%r12,%rcx,8),%xmm1
addsd  0x28(%r12,%rcx,8),%xmm1
addsd  0x30(%r12,%rcx,8),%xmm1
addsd  0x38(%r12,%rcx,8),%xmm1
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    15b0 <get_becke_w+0x490>
test   %rax,%rax
je     160e <get_becke_w+0x4ee>
lea    (%r12,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rdx,8),%xmm1
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1600 <get_becke_w+0x4e0>
movapd 0x9fa(%rip),%xmm0
andpd  %xmm1,%xmm0
ucomisd 0xa06(%rip),%xmm0
jbe    1633 <get_becke_w+0x513>
movslq %r9d,%rax
movsd  (%r12,%rax,8),%xmm0
divsd  %xmm1,%xmm0
jmp    163b <get_becke_w+0x51b>
movsd  0xa0d(%rip),%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @get_becke_w(double* %0, double* %1, double* %2, double* %3, double* %4, i32 %5, i32 %6, double %7, double %8, double %9) {
%11 = alloca double
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%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
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca i32
%36 = alloca i32
%37 = alloca double
store double* %0, double** %12
store double* %1, double** %13
store double* %2, double** %14
store double* %3, double** %15
store double* %4, double** %16
store i32 %5, i32* %17
store i32 %6, i32* %18
store double %7, double* %19
store double %8, double* %20
store double %9, double* %21
store i32 0, i32* %35
br label %38
38: ; preds = %47, %10
%39 = load i32, i32* %35
%40 = load i32, i32* %18
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %50
42: ; preds = %38
%43 = load double*, double** %16
%44 = load i32, i32* %35
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
store double 1.000000e+00, double* %46
br label %47
47: ; preds = %42
%48 = load i32, i32* %35
%49 = add nsw i32 %48, 1
store i32 %49, i32* %35
br label %38
50: ; preds = %38
store i32 0, i32* %35
br label %51
51: ; preds = %272, %50
%52 = load i32, i32* %35
%53 = load i32, i32* %18
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %275
55: ; preds = %51
%56 = load double*, double** %12
%57 = load i32, i32* %35
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
%60 = load double, double* %59
%61 = load double, double* %19
%62 = fsub double %60, %61
store double %62, double* %32
%63 = load double*, double** %13
%64 = load i32, i32* %35
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
%67 = load double, double* %66
%68 = load double, double* %20
%69 = fsub double %67, %68
store double %69, double* %33
%70 = load double*, double** %14
%71 = load i32, i32* %35
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
%75 = load double, double* %21
%76 = fsub double %74, %75
store double %76, double* %34
%77 = load double, double* %32
%78 = load double, double* %32
%79 = load double, double* %33
%80 = load double, double* %33
%81 = fmul double %79, %80
%82 = call double @llvm.fmuladd.f64(double %77, double %78, double %81)
%83 = load double, double* %34
%84 = load double, double* %34
%85 = call double @llvm.fmuladd.f64(double %83, double %84, double %82)
store double %85, double* %29
%86 = load double, double* %29
%87 = call double @sqrt(double %86)
store double %87, double* %29
%88 = load i32, i32* %35
%89 = load i32, i32* %17
%90 = icmp ne i32 %88, %89
br i1 %90, label %91, label %99
91: ; preds = %55
%92 = load double, double* %29
%93 = fcmp ogt double %92, 0x402E3C5176338423
br i1 %93, label %94, label %99
94: ; preds = %91
%95 = load double*, double** %16
%96 = load i32, i32* %35
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
store double 0.000000e+00, double* %98
br label %272
99: ; preds = %91, %55
%100 = load double*, double** %15
%101 = load i32, i32* %35
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
%104 = load double, double* %103
store double %104, double* %22
store i32 0, i32* %36
br label %105
105: ; preds = %268, %99
%106 = load i32, i32* %36
%107 = load i32, i32* %35
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %271
109: ; preds = %105
%110 = load i32, i32* %35
%111 = load i32, i32* %36
%112 = icmp ne i32 %110, %111
br i1 %112, label %113, label %267
113: ; preds = %109
%114 = load double*, double** %12
%115 = load i32, i32* %36
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %114, i64 %116
%118 = load double, double* %117
%119 = load double, double* %19
%120 = fsub double %118, %119
store double %120, double* %32
%121 = load double*, double** %13
%122 = load i32, i32* %36
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = load double, double* %20
%127 = fsub double %125, %126
store double %127, double* %33
%128 = load double*, double** %14
%129 = load i32, i32* %36
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %128, i64 %130
%132 = load double, double* %131
%133 = load double, double* %21
%134 = fsub double %132, %133
store double %134, double* %34
%135 = load double, double* %32
%136 = load double, double* %32
%137 = load double, double* %33
%138 = load double, double* %33
%139 = fmul double %137, %138
%140 = call double @llvm.fmuladd.f64(double %135, double %136, double %139)
%141 = load double, double* %34
%142 = load double, double* %34
%143 = call double @llvm.fmuladd.f64(double %141, double %142, double %140)
store double %143, double* %30
%144 = load double, double* %30
%145 = call double @sqrt(double %144)
store double %145, double* %30
%146 = load double*, double** %15
%147 = load i32, i32* %36
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
store double %150, double* %23
%151 = load double*, double** %12
%152 = load i32, i32* %36
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = load double*, double** %12
%157 = load i32, i32* %35
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = fsub double %155, %160
store double %161, double* %32
%162 = load double*, double** %13
%163 = load i32, i32* %36
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = load double*, double** %13
%168 = load i32, i32* %35
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
%171 = load double, double* %170
%172 = fsub double %166, %171
store double %172, double* %33
%173 = load double*, double** %14
%174 = load i32, i32* %36
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %173, i64 %175
%177 = load double, double* %176
%178 = load double*, double** %14
%179 = load i32, i32* %35
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = fsub double %177, %182
store double %183, double* %34
%184 = load double, double* %32
%185 = load double, double* %32
%186 = load double, double* %33
%187 = load double, double* %33
%188 = fmul double %186, %187
%189 = call double @llvm.fmuladd.f64(double %184, double %185, double %188)
%190 = load double, double* %34
%191 = load double, double* %34
%192 = call double @llvm.fmuladd.f64(double %190, double %191, double %189)
store double %192, double* %31
%193 = load double, double* %31
%194 = call double @sqrt(double %193)
store double %194, double* %31
%195 = load double, double* %29
%196 = load double, double* %30
%197 = fsub double %195, %196
%198 = load double, double* %31
%199 = fdiv double %197, %198
store double %199, double* %26
%200 = load double, double* %22
%201 = load double, double* %23
%202 = fsub double %200, %201
%203 = call double @llvm.fabs.f64(double %202)
%204 = fcmp ogt double %203, 0x3D06849B86A12B9B
br i1 %204, label %205, label %233
205: ; preds = %113
%206 = load double, double* %22
%207 = load double, double* %23
%208 = fadd double %206, %207
%209 = load double, double* %23
%210 = load double, double* %22
%211 = fsub double %209, %210
%212 = fdiv double %208, %211
store double %212, double* %24
%213 = load double, double* %24
%214 = load double, double* %24
%215 = load double, double* %24
%216 = call double @llvm.fmuladd.f64(double %214, double %215, double -1.000000e+00)
%217 = fdiv double %213, %216
store double %217, double* %25
%218 = load double, double* %25
%219 = fcmp ogt double %218, 5.000000e-01
br i1 %219, label %220, label %221
220: ; preds = %205
store double 5.000000e-01, double* %25
br label %221
221: ; preds = %220, %205
%222 = load double, double* %25
%223 = fcmp olt double %222, -5.000000e-01
br i1 %223, label %224, label %225
224: ; preds = %221
store double -5.000000e-01, double* %25
br label %225
225: ; preds = %224, %221
%226 = load double, double* %26
%227 = load double, double* %25
%228 = load double, double* %26
%229 = load double, double* %26
%230 = fneg double %228
%231 = call double @llvm.fmuladd.f64(double %230, double %229, double 1.000000e+00)
%232 = call double @llvm.fmuladd.f64(double %227, double %231, double %226)
store double %232, double* %27
br label %235
233: ; preds = %113
%234 = load double, double* %26
store double %234, double* %27
br label %235
235: ; preds = %233, %225
%236 = load double, double* %27
%237 = call double @f3(double %236)
store double %237, double* %28
%238 = load double, double* %28
%239 = fsub double 1.000000e+00, %238
%240 = call double @llvm.fabs.f64(double %239)
%241 = fcmp olt double %240, 0x3D06849B86A12B9B
br i1 %241, label %242, label %247
242: ; preds = %235
%243 = load double*, double** %16
%244 = load i32, i32* %35
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
store double 0.000000e+00, double* %246
br label %266
247: ; preds = %235
%248 = load double, double* %28
%249 = fsub double 1.000000e+00, %248
%250 = fmul double 5.000000e-01, %249
%251 = load double*, double** %16
%252 = load i32, i32* %35
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
%255 = load double, double* %254
%256 = fmul double %255, %250
store double %256, double* %254
%257 = load double, double* %28
%258 = fadd double 1.000000e+00, %257
%259 = fmul double 5.000000e-01, %258
%260 = load double*, double** %16
%261 = load i32, i32* %36
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %260, i64 %262
%264 = load double, double* %263
%265 = fmul double %264, %259
store double %265, double* %263
br label %266
266: ; preds = %247, %242
br label %267
267: ; preds = %266, %109
br label %268
268: ; preds = %267
%269 = load i32, i32* %36
%270 = add nsw i32 %269, 1
store i32 %270, i32* %36
br label %105
271: ; preds = %105
br label %272
272: ; preds = %271, %94
%273 = load i32, i32* %35
%274 = add nsw i32 %273, 1
store i32 %274, i32* %35
br label %51
275: ; preds = %51
store double 0.000000e+00, double* %37
store i32 0, i32* %35
br label %276
276: ; preds = %288, %275
%277 = load i32, i32* %35
%278 = load i32, i32* %18
%279 = icmp slt i32 %277, %278
br i1 %279, label %280, label %291
280: ; preds = %276
%281 = load double*, double** %16
%282 = load i32, i32* %35
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = load double, double* %37
%287 = fadd double %286, %285
store double %287, double* %37
br label %288
288: ; preds = %280
%289 = load i32, i32* %35
%290 = add nsw i32 %289, 1
store i32 %290, i32* %35
br label %276
291: ; preds = %276
%292 = load double, double* %37
%293 = call double @llvm.fabs.f64(double %292)
%294 = fcmp ogt double %293, 0x3D06849B86A12B9B
br i1 %294, label %295, label %303
295: ; preds = %291
%296 = load double*, double** %16
%297 = load i32, i32* %17
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %296, i64 %298
%300 = load double, double* %299
%301 = load double, double* %37
%302 = fdiv double %300, %301
store double %302, double* %11
br label %304
303: ; preds = %291
store double 1.000000e+00, double* %11
br label %304
304: ; preds = %303, %295
%305 = load double, double* %11
ret double %305
}

LLVM IR (-O2):
define double @get_becke_w(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, i32 %5, i32 %6, double %7, double %8, double %9) {
%11 = icmp sgt i32 %6, 0
br i1 %11, label %12, label %251
12: ; preds = %10
%13 = zext i32 %6 to i64
%14 = icmp ult i32 %6, 4
br i1 %14, label %84, label %15
15: ; preds = %12
%16 = and i64 %13, 4294967292
%17 = add nsw i64 %16, -4
%18 = lshr exact i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 7
%21 = icmp ult i64 %17, 28
br i1 %21, label %69, label %22
22: ; preds = %15
%23 = and i64 %19, 9223372036854775800
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %66, %24 ]
%26 = phi i64 [ 0, %22 ], [ %67, %24 ]
%27 = getelementptr inbounds double, double* %4, i64 %25
%28 = bitcast double* %27 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %28
%29 = getelementptr inbounds double, double* %27, i64 2
%30 = bitcast double* %29 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %30
%31 = or i64 %25, 4
%32 = getelementptr inbounds double, double* %4, i64 %31
%33 = bitcast double* %32 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %33
%34 = getelementptr inbounds double, double* %32, i64 2
%35 = bitcast double* %34 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %35
%36 = or i64 %25, 8
%37 = getelementptr inbounds double, double* %4, i64 %36
%38 = bitcast double* %37 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %38
%39 = getelementptr inbounds double, double* %37, i64 2
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %40
%41 = or i64 %25, 12
%42 = getelementptr inbounds double, double* %4, i64 %41
%43 = bitcast double* %42 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %43
%44 = getelementptr inbounds double, double* %42, i64 2
%45 = bitcast double* %44 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %45
%46 = or i64 %25, 16
%47 = getelementptr inbounds double, double* %4, i64 %46
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %48
%49 = getelementptr inbounds double, double* %47, i64 2
%50 = bitcast double* %49 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %50
%51 = or i64 %25, 20
%52 = getelementptr inbounds double, double* %4, i64 %51
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %53
%54 = getelementptr inbounds double, double* %52, i64 2
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %55
%56 = or i64 %25, 24
%57 = getelementptr inbounds double, double* %4, i64 %56
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %58
%59 = getelementptr inbounds double, double* %57, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %60
%61 = or i64 %25, 28
%62 = getelementptr inbounds double, double* %4, i64 %61
%63 = bitcast double* %62 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %63
%64 = getelementptr inbounds double, double* %62, i64 2
%65 = bitcast double* %64 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %65
%66 = add nuw i64 %25, 32
%67 = add i64 %26, 8
%68 = icmp eq i64 %67, %23
br i1 %68, label %69, label %24
69: ; preds = %24, %15
%70 = phi i64 [ 0, %15 ], [ %66, %24 ]
%71 = icmp eq i64 %20, 0
br i1 %71, label %82, label %72
72: ; preds = %69, %72
%73 = phi i64 [ %79, %72 ], [ %70, %69 ]
%74 = phi i64 [ %80, %72 ], [ 0, %69 ]
%75 = getelementptr inbounds double, double* %4, i64 %73
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %76
%77 = getelementptr inbounds double, double* %75, i64 2
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %78
%79 = add nuw i64 %73, 4
%80 = add i64 %74, 1
%81 = icmp eq i64 %80, %20
br i1 %81, label %82, label %72
82: ; preds = %72, %69
%83 = icmp eq i64 %16, %13
br i1 %83, label %86, label %84
84: ; preds = %12, %82
%85 = phi i64 [ 0, %12 ], [ %16, %82 ]
br label %90
86: ; preds = %90, %82
br i1 %11, label %87, label %251
87: ; preds = %86
%88 = zext i32 %5 to i64
%89 = zext i32 %6 to i64
br label %102
90: ; preds = %84, %90
%91 = phi i64 [ %93, %90 ], [ %85, %84 ]
%92 = getelementptr inbounds double, double* %4, i64 %91
store double 1.000000e+00, double* %92
%93 = add nuw nsw i64 %91, 1
%94 = icmp eq i64 %93, %13
br i1 %94, label %86, label %90
95: ; preds = %195
br i1 %11, label %96, label %251
96: ; preds = %95
%97 = add nsw i64 %89, -1
%98 = and i64 %89, 7
%99 = icmp ult i64 %97, 7
br i1 %99, label %236, label %100
100: ; preds = %96
%101 = and i64 %89, 4294967288
br label %198
102: ; preds = %87, %195
%103 = phi i64 [ 0, %87 ], [ %196, %195 ]
%104 = getelementptr inbounds double, double* %0, i64 %103
%105 = load double, double* %104
%106 = fsub double %105, %7
%107 = getelementptr inbounds double, double* %1, i64 %103
%108 = load double, double* %107
%109 = fsub double %108, %8
%110 = getelementptr inbounds double, double* %2, i64 %103
%111 = load double, double* %110
%112 = fsub double %111, %9
%113 = fmul double %109, %109
%114 = tail call double @llvm.fmuladd.f64(double %106, double %106, double %113)
%115 = tail call double @llvm.fmuladd.f64(double %112, double %112, double %114)
%116 = tail call double @sqrt(double %115)
%117 = icmp ne i64 %103, %88
%118 = fcmp ogt double %116, 0x402E3C5176338423
%119 = select i1 %117, i1 %118, i1 false
br i1 %119, label %120, label %122
120: ; preds = %102
%121 = getelementptr inbounds double, double* %4, i64 %103
store double 0.000000e+00, double* %121
br label %195
122: ; preds = %102
%123 = getelementptr inbounds double, double* %3, i64 %103
%124 = load double, double* %123
%125 = icmp eq i64 %103, 0
br i1 %125, label %195, label %126
126: ; preds = %122
%127 = getelementptr inbounds double, double* %4, i64 %103
br label %128
128: ; preds = %126, %192
%129 = phi i64 [ 0, %126 ], [ %193, %192 ]
%130 = getelementptr inbounds double, double* %0, i64 %129
%131 = load double, double* %130
%132 = fsub double %131, %7
%133 = getelementptr inbounds double, double* %1, i64 %129
%134 = load double, double* %133
%135 = fsub double %134, %8
%136 = getelementptr inbounds double, double* %2, i64 %129
%137 = load double, double* %136
%138 = fsub double %137, %9
%139 = fmul double %135, %135
%140 = tail call double @llvm.fmuladd.f64(double %132, double %132, double %139)
%141 = tail call double @llvm.fmuladd.f64(double %138, double %138, double %140)
%142 = tail call double @sqrt(double %141)
%143 = getelementptr inbounds double, double* %3, i64 %129
%144 = load double, double* %143
%145 = load double, double* %130
%146 = load double, double* %104
%147 = fsub double %145, %146
%148 = load double, double* %133
%149 = load double, double* %107
%150 = fsub double %148, %149
%151 = load double, double* %136
%152 = load double, double* %110
%153 = fsub double %151, %152
%154 = fmul double %150, %150
%155 = tail call double @llvm.fmuladd.f64(double %147, double %147, double %154)
%156 = tail call double @llvm.fmuladd.f64(double %153, double %153, double %155)
%157 = tail call double @sqrt(double %156)
%158 = fsub double %116, %142
%159 = fdiv double %158, %157
%160 = fsub double %124, %144
%161 = tail call double @llvm.fabs.f64(double %160)
%162 = fcmp ogt double %161, 0x3D06849B86A12B9B
br i1 %162, label %163, label %176
163: ; preds = %128
%164 = fadd double %124, %144
%165 = fsub double %144, %124
%166 = fdiv double %164, %165
%167 = tail call double @llvm.fmuladd.f64(double %166, double %166, double -1.000000e+00)
%168 = fdiv double %166, %167
%169 = fcmp ogt double %168, 5.000000e-01
%170 = select i1 %169, double 5.000000e-01, double %168
%171 = fcmp olt double %170, -5.000000e-01
%172 = select i1 %171, double -5.000000e-01, double %170
%173 = fneg double %159
%174 = tail call double @llvm.fmuladd.f64(double %173, double %159, double 1.000000e+00)
%175 = tail call double @llvm.fmuladd.f64(double %172, double %174, double %159)
br label %176
176: ; preds = %128, %163
%177 = phi double [ %175, %163 ], [ %159, %128 ]
%178 = tail call double @f3(double %177)
%179 = fsub double 1.000000e+00, %178
%180 = tail call double @llvm.fabs.f64(double %179)
%181 = fcmp olt double %180, 0x3D06849B86A12B9B
br i1 %181, label %182, label %183
182: ; preds = %176
store double 0.000000e+00, double* %127
br label %192
183: ; preds = %176
%184 = fmul double %179, 5.000000e-01
%185 = load double, double* %127
%186 = fmul double %184, %185
store double %186, double* %127
%187 = fadd double %178, 1.000000e+00
%188 = fmul double %187, 5.000000e-01
%189 = getelementptr inbounds double, double* %4, i64 %129
%190 = load double, double* %189
%191 = fmul double %188, %190
store double %191, double* %189
br label %192
192: ; preds = %183, %182
%193 = add nuw nsw i64 %129, 1
%194 = icmp eq i64 %193, %103
br i1 %194, label %195, label %128
195: ; preds = %192, %122, %120
%196 = add nuw nsw i64 %103, 1
%197 = icmp eq i64 %196, %89
br i1 %197, label %95, label %102
198: ; preds = %198, %100
%199 = phi i64 [ 0, %100 ], [ %233, %198 ]
%200 = phi double [ 0.000000e+00, %100 ], [ %232, %198 ]
%201 = phi i64 [ 0, %100 ], [ %234, %198 ]
%202 = getelementptr inbounds double, double* %4, i64 %199
%203 = load double, double* %202
%204 = fadd double %200, %203
%205 = or i64 %199, 1
%206 = getelementptr inbounds double, double* %4, i64 %205
%207 = load double, double* %206
%208 = fadd double %204, %207
%209 = or i64 %199, 2
%210 = getelementptr inbounds double, double* %4, i64 %209
%211 = load double, double* %210
%212 = fadd double %208, %211
%213 = or i64 %199, 3
%214 = getelementptr inbounds double, double* %4, i64 %213
%215 = load double, double* %214
%216 = fadd double %212, %215
%217 = or i64 %199, 4
%218 = getelementptr inbounds double, double* %4, i64 %217
%219 = load double, double* %218
%220 = fadd double %216, %219
%221 = or i64 %199, 5
%222 = getelementptr inbounds double, double* %4, i64 %221
%223 = load double, double* %222
%224 = fadd double %220, %223
%225 = or i64 %199, 6
%226 = getelementptr inbounds double, double* %4, i64 %225
%227 = load double, double* %226
%228 = fadd double %224, %227
%229 = or i64 %199, 7
%230 = getelementptr inbounds double, double* %4, i64 %229
%231 = load double, double* %230
%232 = fadd double %228, %231
%233 = add nuw nsw i64 %199, 8
%234 = add i64 %201, 8
%235 = icmp eq i64 %234, %101
br i1 %235, label %236, label %198
236: ; preds = %198, %96
%237 = phi double [ undef, %96 ], [ %232, %198 ]
%238 = phi i64 [ 0, %96 ], [ %233, %198 ]
%239 = phi double [ 0.000000e+00, %96 ], [ %232, %198 ]
%240 = icmp eq i64 %98, 0
br i1 %240, label %251, label %241
241: ; preds = %236, %241
%242 = phi i64 [ %248, %241 ], [ %238, %236 ]
%243 = phi double [ %247, %241 ], [ %239, %236 ]
%244 = phi i64 [ %249, %241 ], [ 0, %236 ]
%245 = getelementptr inbounds double, double* %4, i64 %242
%246 = load double, double* %245
%247 = fadd double %243, %246
%248 = add nuw nsw i64 %242, 1
%249 = add i64 %244, 1
%250 = icmp eq i64 %249, %98
br i1 %250, label %251, label %241
251: ; preds = %236, %241, %10, %86, %95
%252 = phi double [ 0.000000e+00, %95 ], [ 0.000000e+00, %86 ], [ 0.000000e+00, %10 ], [ %237, %236 ], [ %247, %241 ]
%253 = tail call double @llvm.fabs.f64(double %252)
%254 = fcmp ogt double %253, 0x3D06849B86A12B9B
br i1 %254, label %255, label %260
255: ; preds = %251
%256 = sext i32 %5 to i64
%257 = getelementptr inbounds double, double* %4, i64 %256
%258 = load double, double* %257
%259 = fdiv double %258, %252
br label %260
260: ; preds = %251, %255
%261 = phi double [ %259, %255 ], [ 1.000000e+00, %251 ]
ret double %261
}