#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 exp(float);
float pow(float, float);
int agbnp3_ogauss_soa(int n1, int n2, float *c1x, float *c1y, float *c1z,
                      float *a1, float *p1, float *c2x, float *c2y, float *c2z,
                      float *a2, float *p2, float volmina, float volminb,
                      float *gvol, float *gvolp, float *fp, float *fpp) {
  float d2, dx, dy, dz, a12t, p12t;
  float deltai;
  int i;
  float s, sp, spp;
  float swu, swd, swu2, swu3, swf, swfp;
#pragma ivdep
  for (i = n1; i < n2; i++) {
    dx = c2x[i] - c1x[i];
    dy = c2y[i] - c1y[i];
    dz = c2z[i] - c1z[i];
    d2 = dx * dx + dy * dy + dz * dz;
    a12t = a1[i] + a2[i];
    deltai = 1.f / (a12t);
    p12t = p1[i] * p2[i] * exp(-a1[i] * a2[i] * d2 * deltai);
    gvol[i] = p12t * pow((3.14159265359f) * deltai, 1.5f);
    c2x[i] = deltai * (a1[i] * c1x[i] + a2[i] * c2x[i]);
    c2y[i] = deltai * (a1[i] * c1y[i] + a2[i] * c2y[i]);
    c2z[i] = deltai * (a1[i] * c1z[i] + a2[i] * c2z[i]);
    a2[i] = a12t;
    p2[i] = p12t;
    swf = 0.0f;
    swfp = 1.0f;
    if (gvol[i] > volminb) {
      swf = 1.0f;
      swfp = 0.0f;
    } else if (gvol[i] < volmina) {
      swf = 0.0f;
      swfp = 0.0f;
    }
    swd = 1.f / (volminb - volmina);
    swu = (gvol[i] - volmina) * swd;
    swu2 = swu * swu;
    swu3 = swu * swu2;
    s = swf + swfp * swu3 * (10.f - 15.f * swu + 6.f * swu2);
    sp = swfp * swd * 30.f * swu2 * (1.f - 2.f * swu + swu2);
    spp = swfp * swd * swd * 60.f * swu * (1.f - 3.f * swu + 2.f * swu2);
    gvolp[i] = s * gvol[i];
    fp[i] = s + gvol[i] * sp;
    fpp[i] = 2.f * sp + gvol[i] * spp;
  }
  return n2 - n1;
}


x86 assembly (clang, -O0):
<agbnp3_ogauss_soa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1632 <agbnp3_ogauss_soa+0x512>
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xdc4(%rip),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  0xd4a(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  0xd39(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xbed(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    1449 <agbnp3_ogauss_soa+0x329>
movss  0xbc9(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    1479 <agbnp3_ogauss_soa+0x359>
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1474 <agbnp3_ogauss_soa+0x354>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    1479 <agbnp3_ogauss_soa+0x359>
movss  -0x30(%rbp),%xmm1
subss  -0x2c(%rbp),%xmm1
movss  0xb75(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x2c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x70(%rbp),%xmm1
movss  -0x74(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
movss  -0x60(%rbp),%xmm3
movss  0xb32(%rip),%xmm2
mulss  %xmm2,%xmm3
movss  0xb2a(%rip),%xmm2
addss  %xmm2,%xmm3
movss  -0x68(%rbp),%xmm2
movss  0xb11(%rip),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  0xae6(%rip),%xmm1
mulss  %xmm1,%xmm0
mulss  -0x68(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
addss  %xmm2,%xmm2
movss  0xab8(%rip),%xmm1
subss  %xmm2,%xmm1
addss  -0x68(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  0xa9f(%rip),%xmm1
mulss  %xmm1,%xmm0
mulss  -0x60(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  0xa85(%rip),%xmm1
mulss  %xmm1,%xmm2
movss  0xa6d(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x68(%rbp),%xmm1
addss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x5c(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1179 <agbnp3_ogauss_soa+0x59>
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<agbnp3_ogauss_soa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
movss  %xmm1,0x10(%rsp)
movss  %xmm0,0x8(%rsp)
mov    %esi,%eax
sub    %edi,%eax
mov    %eax,0x18(%rsp)
jle    151d <agbnp3_ogauss_soa+0x3fd>
mov    0x120(%rsp),%r12
mov    0x118(%rsp),%r11
mov    0x110(%rsp),%r15
mov    0x108(%rsp),%rbp
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r14
mov    0xf0(%rsp),%rbx
mov    0xe8(%rsp),%rax
mov    0xe0(%rsp),%r10
movslq %edi,%rdi
movslq %esi,%rsi
lea    (%rax,%rdi,4),%rax
mov    %rax,0x80(%rsp)
lea    (%rdx,%rdi,4),%rax
mov    %rax,0x40(%rsp)
lea    (%rbx,%rdi,4),%rax
mov    %rax,0x78(%rsp)
lea    (%rcx,%rdi,4),%rax
mov    %rax,0x38(%rsp)
lea    (%r14,%rdi,4),%rax
mov    %rax,0x30(%rsp)
lea    (%r8,%rdi,4),%rax
mov    %rax,0x28(%rsp)
lea    (%r9,%rdi,4),%rax
mov    %rax,0x70(%rsp)
lea    0x0(%r13,%rdi,4),%rax
mov    %rax,0x68(%rsp)
lea    (%r10,%rdi,4),%rax
mov    %rax,0x60(%rsp)
lea    0x0(%rbp,%rdi,4),%rax
mov    %rax,0x20(%rsp)
lea    (%r15,%rdi,4),%r13
lea    (%r11,%rdi,4),%rax
mov    %rax,0x58(%rsp)
lea    (%r12,%rdi,4),%rax
mov    %rax,0x50(%rsp)
mov    0x128(%rsp),%rax
lea    (%rax,%rdi,4),%rax
mov    %rax,0x48(%rsp)
sub    %rdi,%rsi
mov    %rsi,0x88(%rsp)
movss  0x10(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
movss  0xdc1(%rip),%xmm8
movaps %xmm8,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x1c(%rsp)
xor    %ebp,%ebp
mov    0x80(%rsp),%rbx
mov    0x78(%rsp),%r12
mov    0x70(%rsp),%r15
mov    0x68(%rsp),%r14
jmp    1364 <agbnp3_ogauss_soa+0x244>
nopl   0x0(%rax,%rax,1)
movaps %xmm0,%xmm3
subss  0x8(%rsp),%xmm3
movss  0x1c(%rsp),%xmm7
mulss  %xmm7,%xmm3
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm3,%xmm6
mulss  0xd77(%rip),%xmm6
addss  0xd73(%rip),%xmm6
movaps %xmm1,%xmm4
mulss  0xd6c(%rip),%xmm4
addss  %xmm6,%xmm4
movaps %xmm3,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm7,%xmm2
movaps %xmm3,%xmm6
addss  %xmm3,%xmm6
movaps %xmm8,%xmm5
subss  %xmm6,%xmm5
movaps %xmm7,%xmm6
mulss  %xmm2,%xmm6
mulss  0xd37(%rip),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm1,%xmm5
mulss  %xmm2,%xmm5
mulss  0xd27(%rip),%xmm6
mulss  %xmm3,%xmm6
mulss  0xd1f(%rip),%xmm3
addss  %xmm8,%xmm3
addss  %xmm1,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm6,%xmm1
mulss  %xmm4,%xmm0
mov    0x58(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
movss  0x0(%r13,%rbp,4),%xmm0
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
mov    0x50(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
mulss  0x0(%r13,%rbp,4),%xmm1
addss  %xmm5,%xmm5
addss  %xmm1,%xmm5
mov    0x48(%rsp),%rax
movss  %xmm5,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,0x88(%rsp)
je     151d <agbnp3_ogauss_soa+0x3fd>
movss  (%rbx,%rbp,4),%xmm0
mov    0x40(%rsp),%rax
subss  (%rax,%rbp,4),%xmm0
movss  (%r12,%rbp,4),%xmm1
mov    0x38(%rsp),%rax
subss  (%rax,%rbp,4),%xmm1
mov    0x30(%rsp),%rax
movss  (%rax,%rbp,4),%xmm2
mov    0x28(%rsp),%rax
subss  (%rax,%rbp,4),%xmm2
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
movss  (%r15,%rbp,4),%xmm0
movss  (%r14,%rbp,4),%xmm1
movaps %xmm0,%xmm3
addss  %xmm1,%xmm3
movaps %xmm3,0x90(%rsp)
divss  %xmm3,%xmm8
movss  %xmm8,0x14(%rsp)
mov    0x60(%rsp),%rax
movss  (%rax,%rbp,4),%xmm3
mov    0x20(%rsp),%rax
mulss  (%rax,%rbp,4),%xmm3
movss  %xmm3,0xc(%rsp)
xorps  0xc3d(%rip),%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm8,%xmm0
call   1030 <exp@plt>
mulss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movss  0x14(%rsp),%xmm0
mulss  0xbe5(%rip),%xmm0
movss  0xbe1(%rip),%xmm1
call   1040 <pow@plt>
movss  0xbcb(%rip),%xmm8
movss  0xc(%rsp),%xmm3
mulss  %xmm3,%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
movss  (%r15,%rbp,4),%xmm0
movss  (%r14,%rbp,4),%xmm1
mulss  (%rbx,%rbp,4),%xmm1
mov    0x40(%rsp),%rax
mulss  (%rax,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  0x14(%rsp),%xmm2
mulss  %xmm2,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
movss  (%r15,%rbp,4),%xmm0
movss  (%r14,%rbp,4),%xmm1
mulss  (%r12,%rbp,4),%xmm1
mov    0x38(%rsp),%rax
mulss  (%rax,%rbp,4),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,(%r12,%rbp,4)
movss  (%r14,%rbp,4),%xmm0
mov    0x30(%rsp),%rax
mulss  (%rax,%rbp,4),%xmm0
movss  (%r15,%rbp,4),%xmm1
mov    0x28(%rsp),%rdx
mulss  (%rdx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,(%rax,%rbp,4)
movaps 0x90(%rsp),%xmm0
movss  %xmm0,(%r14,%rbp,4)
mov    0x20(%rsp),%rax
movss  %xmm3,(%rax,%rbp,4)
movss  0x0(%r13,%rbp,4),%xmm0
xorps  %xmm2,%xmm2
ucomiss 0x10(%rsp),%xmm0
movaps %xmm8,%xmm5
ja     1270 <agbnp3_ogauss_soa+0x150>
xorps  %xmm5,%xmm5
movss  0x8(%rsp),%xmm1
ucomiss %xmm0,%xmm1
movaps %xmm8,%xmm2
jbe    1270 <agbnp3_ogauss_soa+0x150>
xorps  %xmm5,%xmm5
xorps  %xmm2,%xmm2
jmp    1270 <agbnp3_ogauss_soa+0x150>
mov    0x18(%rsp),%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @agbnp3_ogauss_soa(i32 %0, i32 %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7, float* nocapture %8, float* nocapture %9, float* nocapture %10, float* nocapture %11, float %12, float %13, float* nocapture %14, float* nocapture writeonly %15, float* nocapture writeonly %16, float* nocapture writeonly %17) {
%19 = icmp sgt i32 %1, %0
br i1 %19, label %20, label %126
20: ; preds = %18
%21 = fsub float %13, %12
%22 = fdiv float 1.000000e+00, %21
%23 = sext i32 %0 to i64
%24 = sext i32 %1 to i64
br label %25
25: ; preds = %20, %92
%26 = phi i64 [ %23, %20 ], [ %124, %92 ]
%27 = getelementptr inbounds float, float* %7, i64 %26
%28 = load float, float* %27
%29 = getelementptr inbounds float, float* %2, i64 %26
%30 = load float, float* %29
%31 = fsub float %28, %30
%32 = getelementptr inbounds float, float* %8, i64 %26
%33 = load float, float* %32
%34 = getelementptr inbounds float, float* %3, i64 %26
%35 = load float, float* %34
%36 = fsub float %33, %35
%37 = getelementptr inbounds float, float* %9, i64 %26
%38 = load float, float* %37
%39 = getelementptr inbounds float, float* %4, i64 %26
%40 = load float, float* %39
%41 = fsub float %38, %40
%42 = fmul float %36, %36
%43 = tail call float @llvm.fmuladd.f32(float %31, float %31, float %42)
%44 = tail call float @llvm.fmuladd.f32(float %41, float %41, float %43)
%45 = getelementptr inbounds float, float* %5, i64 %26
%46 = load float, float* %45
%47 = getelementptr inbounds float, float* %10, i64 %26
%48 = load float, float* %47
%49 = fadd float %46, %48
%50 = fdiv float 1.000000e+00, %49
%51 = getelementptr inbounds float, float* %6, i64 %26
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %11, i64 %26
%54 = load float, float* %53
%55 = fmul float %52, %54
%56 = fneg float %46
%57 = fmul float %48, %56
%58 = fmul float %44, %57
%59 = fmul float %58, %50
%60 = tail call float @exp(float %59)
%61 = fmul float %55, %60
%62 = fmul float %50, 0x400921FB60000000
%63 = tail call float @pow(float %62, float 1.500000e+00)
%64 = fmul float %61, %63
%65 = getelementptr inbounds float, float* %14, i64 %26
store float %64, float* %65
%66 = load float, float* %45
%67 = load float, float* %29
%68 = load float, float* %47
%69 = load float, float* %27
%70 = fmul float %68, %69
%71 = tail call float @llvm.fmuladd.f32(float %66, float %67, float %70)
%72 = fmul float %50, %71
store float %72, float* %27
%73 = load float, float* %45
%74 = load float, float* %34
%75 = load float, float* %47
%76 = load float, float* %32
%77 = fmul float %75, %76
%78 = tail call float @llvm.fmuladd.f32(float %73, float %74, float %77)
%79 = fmul float %50, %78
store float %79, float* %32
%80 = load float, float* %45
%81 = load float, float* %39
%82 = load float, float* %47
%83 = load float, float* %37
%84 = fmul float %82, %83
%85 = tail call float @llvm.fmuladd.f32(float %80, float %81, float %84)
%86 = fmul float %50, %85
store float %86, float* %37
store float %49, float* %47
store float %61, float* %53
%87 = load float, float* %65
%88 = fcmp ogt float %87, %13
br i1 %88, label %92, label %89
89: ; preds = %25
%90 = fcmp olt float %87, %12
br i1 %90, label %91, label %92
91: ; preds = %89
br label %92
92: ; preds = %25, %89, %91
%93 = phi float [ 0.000000e+00, %91 ], [ 0.000000e+00, %89 ], [ 1.000000e+00, %25 ]
%94 = phi float [ 0.000000e+00, %91 ], [ 1.000000e+00, %89 ], [ 0.000000e+00, %25 ]
%95 = fsub float %87, %12
%96 = fmul float %22, %95
%97 = fmul float %96, %96
%98 = fmul float %96, %97
%99 = fmul float %98, %94
%100 = tail call float @llvm.fmuladd.f32(float %96, float -1.500000e+01, float 1.000000e+01)
%101 = tail call float @llvm.fmuladd.f32(float %97, float 6.000000e+00, float %100)
%102 = tail call float @llvm.fmuladd.f32(float %99, float %101, float %93)
%103 = fmul float %22, %94
%104 = fmul float %103, 3.000000e+01
%105 = fmul float %97, %104
%106 = tail call float @llvm.fmuladd.f32(float %96, float -2.000000e+00, float 1.000000e+00)
%107 = fadd float %106, %97
%108 = fmul float %107, %105
%109 = fmul float %22, %103
%110 = fmul float %109, 6.000000e+01
%111 = fmul float %96, %110
%112 = tail call float @llvm.fmuladd.f32(float %96, float -3.000000e+00, float 1.000000e+00)
%113 = tail call float @llvm.fmuladd.f32(float %97, float 2.000000e+00, float %112)
%114 = fmul float %113, %111
%115 = fmul float %87, %102
%116 = getelementptr inbounds float, float* %15, i64 %26
store float %115, float* %116
%117 = load float, float* %65
%118 = tail call float @llvm.fmuladd.f32(float %117, float %108, float %102)
%119 = getelementptr inbounds float, float* %16, i64 %26
store float %118, float* %119
%120 = load float, float* %65
%121 = fmul float %120, %114
%122 = tail call float @llvm.fmuladd.f32(float %108, float 2.000000e+00, float %121)
%123 = getelementptr inbounds float, float* %17, i64 %26
store float %122, float* %123
%124 = add nsw i64 %26, 1
%125 = icmp eq i64 %124, %24
br i1 %125, label %126, label %25
126: ; preds = %92, %18
%127 = sub nsw i32 %1, %0
ret i32 %127
}