#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 */
float M_PI;
float exp(float);
int /*<<< orphan*/ fgamma_set(int, float, float *);
int /*<<< orphan*/ naiA_1d(float *, int, int, float, float, float, float);
float nai(float x1, float y1, float z1, float norm1, int l1, int m1, int n1,
          float alpha1, float x2, float y2, float z2, float norm2, int l2,
          int m2, int n2, float alpha2, float x3, float y3, float z3) {
  float eta, xp, yp, zp, sum, rab2, rcp2;
  float Ax[2 * 8], Ay[2 * 8], Az[2 * 8];
  float F[2 * 8];
  int kX, kY, kZ;
  eta = 1.0 / (alpha1 + alpha2);
  xp = (alpha1 * x1 + alpha2 * x2) * eta;
  yp = (alpha1 * y1 + alpha2 * y2) * eta;
  zp = (alpha1 * z1 + alpha2 * z2) * eta;
  rab2 =
      ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
  rcp2 =
      ((x3 - xp) * (x3 - xp) + (y3 - yp) * (y3 - yp) + (z3 - zp) * (z3 - zp));
  naiA_1d(Ax, l1, l2, xp - x1, xp - x2, xp - x3, eta);
  naiA_1d(Ay, m1, m2, yp - y1, yp - y2, yp - y3, eta);
  naiA_1d(Az, n1, n2, zp - z1, zp - z2, zp - z3, eta);
  fgamma_set(l1 + l2 + m1 + m2 + n1 + n2, rcp2 / eta, F);
  sum = 0.0;
  for (kX = 0; kX < l1 + l2 + 1; kX++)
    for (kY = 0; kY < m1 + m2 + 1; kY++)
      for (kZ = 0; kZ < n1 + n2 + 1; kZ++)
        sum += Ax[kX] * Ay[kY] * Az[kZ] * F[kX + kY + kZ];
  return -norm1 * norm2 * 2 * M_PI * eta * exp(-alpha1 * alpha2 * rab2 * eta) *
         sum;
}


x86 assembly (clang, -O0):
<nai>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
movss  0x30(%rbp),%xmm8
movss  0x28(%rbp),%xmm8
movss  0x20(%rbp),%xmm8
movss  0x18(%rbp),%xmm8
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movss  %xmm4,-0x20(%rbp)
movss  %xmm5,-0x24(%rbp)
movss  %xmm6,-0x28(%rbp)
movss  %xmm7,-0x2c(%rbp)
mov    %ecx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
addss  0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe55(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x8(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x4(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
movss  -0x4(%rbp),%xmm2
subss  -0x24(%rbp),%xmm2
movss  -0x8(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  -0x8(%rbp),%xmm3
subss  -0x28(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
subss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0x20(%rbp),%xmm1
subss  -0x40(%rbp),%xmm1
movss  0x20(%rbp),%xmm2
subss  -0x40(%rbp),%xmm2
movss  0x28(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  0x28(%rbp),%xmm3
subss  -0x44(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  0x30(%rbp),%xmm2
subss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
lea    -0xa0(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%edx
movss  -0x40(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
subss  0x20(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
call   1040 <naiA_1d@plt>
lea    -0xe0(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x34(%rbp),%edx
movss  -0x44(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
subss  -0x28(%rbp),%xmm1
movss  -0x44(%rbp),%xmm2
subss  0x28(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
call   1040 <naiA_1d@plt>
lea    -0x120(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x38(%rbp),%edx
movss  -0x48(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
subss  -0x2c(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
subss  0x30(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
call   1040 <naiA_1d@plt>
mov    -0x14(%rbp),%edi
add    -0x30(%rbp),%edi
add    -0x18(%rbp),%edi
add    -0x34(%rbp),%edi
add    -0x1c(%rbp),%edi
add    -0x38(%rbp),%edi
movss  -0x54(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
lea    -0x160(%rbp),%rsi
call   1030 <fgamma_set@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x164(%rbp)
mov    -0x164(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14ab <nai+0x37b>
movl   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1492 <nai+0x362>
movl   $0x0,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1479 <nai+0x349>
movslq -0x164(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x168(%rbp),%rax
mulss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x16c(%rbp),%rax
mulss  -0x120(%rbp,%rax,4),%xmm0
ff ff
mov    -0x164(%rbp),%eax
add    -0x168(%rbp),%eax
add    -0x16c(%rbp),%eax
cltq
movss  -0x160(%rbp,%rax,4),%xmm2
ff ff
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    13ef <nai+0x2bf>
jmp    147e <nai+0x34e>
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    13ce <nai+0x29e>
jmp    1497 <nai+0x367>
mov    -0x164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    13ad <nai+0x27d>
movss  -0x10(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  0x10(%rbp),%xmm0
movss  0xb3e(%rip),%xmm1
mulss  %xmm1,%xmm0
mov    0x2b13(%rip),%rax
mulss  (%rax),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x170(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  0x18(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movss  -0x170(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mulss  -0x4c(%rbp),%xmm0
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nai>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9d,%r15d
mov    %r8d,%r14d
mov    %ecx,%r13d
movss  %xmm7,0x8(%rsp)
movss  %xmm6,0x10(%rsp)
mov    %edx,%r12d
mov    %esi,%ebx
mov    %edi,%ebp
movaps %xmm3,0x20(%rsp)
movaps %xmm2,%xmm10
movss  %xmm2,0x14(%rsp)
movss  %xmm1,0xc(%rsp)
movaps %xmm0,%xmm9
movss  0x1a8(%rsp),%xmm11
movss  0x1b8(%rsp),%xmm12
movss  0x1b0(%rsp),%xmm8
movaps %xmm4,%xmm0
addss  %xmm11,%xmm0
movss  0xe5c(%rip),%xmm3
divss  %xmm0,%xmm3
movaps %xmm5,%xmm0
mulss  %xmm11,%xmm0
movaps %xmm4,%xmm2
mulss  %xmm9,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm6,%xmm0
mulss  %xmm11,%xmm0
movaps %xmm4,%xmm6
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm3,%xmm6
movaps %xmm6,0x30(%rsp)
movaps %xmm7,%xmm0
mulss  %xmm11,%xmm0
movaps %xmm4,0x50(%rsp)
mulss  %xmm10,%xmm4
addss  %xmm0,%xmm4
movaps %xmm8,%xmm0
subss  %xmm2,%xmm0
movaps %xmm12,%xmm1
subss  %xmm6,%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm3,(%rsp)
mulss  %xmm3,%xmm4
movaps %xmm4,0x40(%rsp)
movss  0x1c0(%rsp),%xmm1
subss  %xmm4,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
movaps %xmm2,%xmm0
movaps %xmm2,%xmm1
subss  %xmm8,%xmm2
movss  %xmm9,0x1c(%rsp)
subss  %xmm9,%xmm0
movss  %xmm5,0x18(%rsp)
subss  %xmm5,%xmm1
lea    0x120(%rsp),%rdi
mov    %ebp,%esi
mov    %ecx,%edx
call   1040 <naiA_1d@plt>
movaps 0x30(%rsp),%xmm3
movaps %xmm3,%xmm0
subss  0xc(%rsp),%xmm0
movaps %xmm3,%xmm1
subss  0x10(%rsp),%xmm1
subss  0x1b8(%rsp),%xmm3
movaps %xmm3,%xmm2
lea    0xe0(%rsp),%rdi
mov    %ebx,%esi
mov    %r14d,%edx
movss  (%rsp),%xmm3
call   1040 <naiA_1d@plt>
movaps 0x40(%rsp),%xmm3
movaps %xmm3,%xmm0
subss  0x14(%rsp),%xmm0
movaps %xmm3,%xmm1
subss  0x8(%rsp),%xmm1
subss  0x1c0(%rsp),%xmm3
movaps %xmm3,%xmm2
lea    0x60(%rsp),%rdi
mov    %r12d,%esi
mov    %r15d,%edx
movss  (%rsp),%xmm3
call   1040 <naiA_1d@plt>
add    %ebp,%r13d
add    %ebx,%r14d
lea    (%r14,%r12,1),%edi
add    %r13d,%edi
add    %r15d,%edi
movss  0x4(%rsp),%xmm0
divss  (%rsp),%xmm0
lea    0xa0(%rsp),%rsi
call   1030 <fgamma_set@plt>
test   %r13d,%r13d
js     13f7 <nai+0x2c7>
lea    (%r15,%r12,1),%r10d
lea    (%r15,%r12,1),%r9d
add    $0x1,%r9d
lea    0x1(%r14),%edx
add    $0x1,%r13d
mov    %r9d,%esi
and    $0xfffffffe,%esi
lea    0xa4(%rsp),%r8
xorps  %xmm2,%xmm2
xor    %ebp,%ebp
jmp    1351 <nai+0x221>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
add    $0x4,%r8
cmp    %r13,%rbp
je     13fa <nai+0x2ca>
test   %r14d,%r14d
js     1340 <nai+0x210>
mov    %r8,%rdi
xor    %ebx,%ebx
jmp    136d <nai+0x23d>
nopl   (%rax)
add    $0x1,%rbx
add    $0x4,%rdi
cmp    %rdx,%rbx
je     1340 <nai+0x210>
test   %r10d,%r10d
js     1360 <nai+0x230>
movss  0x120(%rsp,%rbp,4),%xmm0
mulss  0xe0(%rsp,%rbx,4),%xmm0
je     13d0 <nai+0x2a0>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  0x60(%rsp,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
mulss  -0x4(%rdi,%rcx,4),%xmm1
addss  %xmm2,%xmm1
movss  0x64(%rsp,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
mulss  (%rdi,%rcx,4),%xmm2
addss  %xmm1,%xmm2
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1390 <nai+0x260>
test   $0x1,%r9b
je     1360 <nai+0x230>
jmp    13d8 <nai+0x2a8>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   $0x1,%r9b
je     1360 <nai+0x230>
lea    (%rbx,%rbp,1),%rax
mulss  0x60(%rsp,%rcx,4),%xmm0
add    %rcx,%rax
mulss  0xa0(%rsp,%rax,4),%xmm0
addss  %xmm0,%xmm2
jmp    1360 <nai+0x230>
xorps  %xmm2,%xmm2
movss  %xmm2,0x4(%rsp)
movss  0x14(%rsp),%xmm2
subss  0x8(%rsp),%xmm2
movss  0x1c(%rsp),%xmm0
subss  0x18(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
subss  0x10(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
movaps 0xbd1(%rip),%xmm1
movaps 0x20(%rsp),%xmm0
xorps  %xmm1,%xmm0
mulss  0x1a0(%rsp),%xmm0
addss  %xmm0,%xmm0
mov    0x2b8d(%rip),%rax
mulss  (%rax),%xmm0
movss  (%rsp),%xmm3
mulss  %xmm3,%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0x50(%rsp),%xmm0
xorps  %xmm1,%xmm0
mulss  0x1a8(%rsp),%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm3,%xmm0
call   1050 <exp@plt>
mulss  0x20(%rsp),%xmm0
mulss  0x4(%rsp),%xmm0
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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