#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 ranorm();
void cdistr2h(float part[], float vtx, float vty, float vtz, float vdx,
              float vdy, float vdz, int npx, int npy, int idimp, int nop,
              int nx, int ny, int ipbc) {
  int j, k, k1, npxy;
  float edgelx, edgely, at1, at2, at3, sum1, sum2, sum3;
  double dsum1, dsum2, dsum3;
  npxy = npx * npy;
  edgelx = 0.0;
  edgely = 0.0;
  at1 = (float)nx / (float)npx;
  at2 = (float)ny / (float)npy;
  if (ipbc == 2) {
    edgelx = 1.0;
    edgely = 1.0;
    at1 = (float)(nx - 2) / (float)npx;
    at2 = (float)(ny - 2) / (float)npy;
  } else if (ipbc == 3) {
    edgelx = 1.0;
    edgely = 0.0;
    at1 = (float)(nx - 2) / (float)npx;
    at2 = (float)ny / (float)npy;
  }
  for (k = 0; k < npy; k++) {
    k1 = idimp * npx * k;
    at3 = edgely + at2 * (((float)k) + 0.5);
    for (j = 0; j < npx; j++) {
      part[idimp * j + k1] = edgelx + at1 * (((float)j) + 0.5);
      part[1 + idimp * j + k1] = at3;
    }
  }
  for (j = 0; j < npxy; j++) {
    part[2 + idimp * j] = vtx * ranorm();
    part[3 + idimp * j] = vty * ranorm();
    part[4 + idimp * j] = vtz * ranorm();
  }
  dsum1 = 0.0;
  dsum2 = 0.0;
  dsum3 = 0.0;
  for (j = 0; j < npxy; j++) {
    dsum1 += part[2 + idimp * j];
    dsum2 += part[3 + idimp * j];
    dsum3 += part[4 + idimp * j];
  }
  sum1 = dsum1;
  sum2 = dsum2;
  sum3 = dsum3;
  at1 = 1.0 / (float)npxy;
  sum1 = at1 * sum1 - vdx;
  sum2 = at1 * sum2 - vdy;
  sum3 = at1 * sum3 - vdz;
  for (j = 0; j < npxy; j++) {
    part[2 + idimp * j] -= sum1;
    part[3 + idimp * j] -= sum2;
    part[4 + idimp * j] -= sum3;
  }
  return;
}


x86 assembly (clang, -O0):
<cdistr2h>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
mov    %edx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    %r8d,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm0
cvtsi2ssl -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
cmpl   $0x2,0x18(%rbp)
jne    11ed <cdistr2h+0xdd>
movss  0xe5a(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe4d(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x2,%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    0x10(%rbp),%eax
sub    $0x2,%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    123c <cdistr2h+0x12c>
cmpl   $0x3,0x18(%rbp)
jne    1237 <cdistr2h+0x127>
movss  0xe01(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x2,%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm0
cvtsi2ssl -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    123c <cdistr2h+0x12c>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1330 <cdistr2h+0x220>
mov    -0x2c(%rbp),%eax
imul   -0x24(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xd90(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    131d <cdistr2h+0x20d>
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2ssl -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xd45(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x1,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    129c <cdistr2h+0x18c>
jmp    1322 <cdistr2h+0x212>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1243 <cdistr2h+0x133>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    13fc <cdistr2h+0x2ec>
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    $0x0,%al
call   1030 <ranorm@plt>
movaps %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1030 <ranorm@plt>
movaps %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    $0x0,%al
call   1030 <ranorm@plt>
movaps %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1337 <cdistr2h+0x227>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14a1 <cdistr2h+0x391>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    141b <cdistr2h+0x30b>
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
cvtsi2ssl -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb2c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    15f1 <cdistr2h+0x4e1>
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    156b <cdistr2h+0x45b>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cdistr2h>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%r15
mov    0x68(%rsp),%edi
mov    0x60(%rsp),%eax
xorpd  %xmm8,%xmm8
cmp    $0x3,%edi
je     114f <cdistr2h+0x3f>
cmp    $0x2,%edi
jne    115e <cdistr2h+0x4e>
add    $0xfffffffe,%r9d
add    $0xfffffffe,%eax
movsd  0xeb8(%rip),%xmm11
movapd %xmm11,%xmm8
jmp    1163 <cdistr2h+0x53>
add    $0xfffffffe,%r9d
movsd  0xea4(%rip),%xmm11
jmp    1163 <cdistr2h+0x53>
xorpd  %xmm11,%xmm11
mov    %edx,%edi
imul   %esi,%edi
mov    %edi,0x4(%rsp)
movslq %ecx,%rcx
mov    %rcx,0x8(%rsp)
test   %edx,%edx
jle    1270 <cdistr2h+0x160>
cvtsi2ss %esi,%xmm10
cvtsi2ss %edx,%xmm9
cvtsi2ss %r9d,%xmm7
cvtsi2ss %eax,%xmm6
divss  %xmm10,%xmm7
divss  %xmm9,%xmm6
mov    0x8(%rsp),%rcx
mov    %ecx,%eax
imul   %esi,%eax
xorps  %xmm9,%xmm9
cvtss2sd %xmm6,%xmm9
cvtss2sd %xmm7,%xmm12
movslq %eax,%r9
mov    %edx,%r8d
mov    %esi,%edx
mov    %r9,%r10
shl    $0x20,%r10
mov    %rcx,%rbp
shl    $0x20,%rbp
shl    $0x2,%r9
lea    0x0(,%rcx,4),%rcx
movabs $0x100000000,%r14
xor    %r12d,%r12d
movsd  0xe1f(%rip),%xmm10
mov    %r15,%r13
jmp    11ff <cdistr2h+0xef>
xchg   %ax,%ax
add    $0x1,%r12
add    %r10,%r14
add    %r9,%r13
cmp    %r8,%r12
je     1270 <cdistr2h+0x160>
xorps  %xmm6,%xmm6
cvtsi2ss %r12d,%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm10,%xmm6
test   %esi,%esi
jle    11f0 <cdistr2h+0xe0>
mulsd  %xmm9,%xmm6
addsd  %xmm8,%xmm6
xorps  %xmm7,%xmm7
cvtsd2ss %xmm6,%xmm7
mov    %r13,%rax
mov    %r14,%r11
xor    %ebx,%ebx
nopl   (%rax)
xorps  %xmm6,%xmm6
cvtsi2ss %ebx,%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm10,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm11,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,(%rax)
mov    %r11,%rdi
sar    $0x1e,%rdi
movss  %xmm7,(%r15,%rdi,1)
add    $0x1,%rbx
add    %rbp,%r11
add    %rcx,%rax
cmp    %rbx,%rdx
jne    1230 <cdistr2h+0x120>
jmp    11f0 <cdistr2h+0xe0>
xorps  %xmm7,%xmm7
xorps  %xmm6,%xmm6
mov    0x4(%rsp),%edi
mov    %edi,%ebx
test   %edi,%edi
jle    1333 <cdistr2h+0x223>
movss  %xmm3,0x10(%rsp)
movss  %xmm4,0x14(%rsp)
movss  %xmm5,0x18(%rsp)
lea    0x10(%r15),%rbp
mov    0x8(%rsp),%r14
lea    0x0(,%r14,4),%r13
mov    %rbx,%r12
movss  %xmm1,0x20(%rsp)
movss  %xmm0,0x1c(%rsp)
movss  %xmm2,0x24(%rsp)
nopl   0x0(%rax)
xor    %eax,%eax
call   1030 <ranorm@plt>
mulss  0x1c(%rsp),%xmm0
movss  %xmm0,-0x8(%rbp)
xor    %eax,%eax
call   1030 <ranorm@plt>
mulss  0x20(%rsp),%xmm0
movss  %xmm0,-0x4(%rbp)
xor    %eax,%eax
call   1030 <ranorm@plt>
movss  0x24(%rsp),%xmm2
mulss  %xmm2,%xmm0
movss  %xmm0,0x0(%rbp)
add    %r13,%rbp
add    $0xffffffffffffffff,%r12
jne    12c0 <cdistr2h+0x1b0>
mov    0x4(%rsp),%edi
test   %edi,%edi
movss  0x18(%rsp),%xmm5
movss  0x14(%rsp),%xmm4
movss  0x10(%rsp),%xmm3
xorps  %xmm6,%xmm6
xorps  %xmm7,%xmm7
jle    1338 <cdistr2h+0x228>
cmp    $0x1,%edi
jne    1345 <cdistr2h+0x235>
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    139b <cdistr2h+0x28b>
mov    0x8(%rsp),%r14
test   %edi,%edi
jg     13cc <cdistr2h+0x2bc>
jmp    1447 <cdistr2h+0x337>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
lea    0xc(%r15),%rdx
lea    0x0(,%r14,8),%rsi
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
xor    %eax,%eax
nop
movss  -0x4(%rdx),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm1,%xmm2
cvtps2pd (%rdx),%xmm6
addpd  %xmm0,%xmm6
movss  -0x4(%rdx,%r14,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtps2pd (%rdx,%r14,4),%xmm0
addpd  %xmm6,%xmm0
add    $0x2,%rax
add    %rsi,%rdx
cmp    %rax,%rcx
jne    1360 <cdistr2h+0x250>
test   $0x1,%bl
je     13bd <cdistr2h+0x2ad>
imul   %r14,%rax
movss  0x8(%r15,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
cvtps2pd 0xc(%r15,%rax,4),%xmm2
addpd  %xmm2,%xmm0
xorps  %xmm6,%xmm6
cvtsd2ss %xmm1,%xmm6
cvtpd2ps %xmm0,%xmm7
test   %edi,%edi
jle    1447 <cdistr2h+0x337>
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  0xc35(%rip),%xmm1
divss  %xmm0,%xmm1
mulss  %xmm1,%xmm6
subss  %xmm3,%xmm6
movaps %xmm1,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm4,%xmm0
shufps $0x55,%xmm7,%xmm7
mulss  %xmm1,%xmm7
subss  %xmm5,%xmm7
add    $0x10,%r15
shl    $0x2,%r14
cs nopw 0x0(%rax,%rax,1)
movss  -0x8(%r15),%xmm1
subss  %xmm6,%xmm1
movss  -0x4(%r15),%xmm2
subss  %xmm0,%xmm2
movss  %xmm1,-0x8(%r15)
movss  %xmm2,-0x4(%r15)
movss  (%r15),%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%r15)
add    %r14,%r15
add    $0xffffffffffffffff,%rbx
jne    1410 <cdistr2h+0x300>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @cdistr2h(float* nocapture %0, float %1, float %2, float %3, float %4, float %5, float %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = mul i32 %8, %7
%16 = sitofp i32 %7 to float
%17 = sitofp i32 %8 to float
switch i32 %13, label %23 [
i32 2, label %18
i32 3, label %21
]
18: ; preds = %14
%19 = add nsw i32 %11, -2
%20 = add nsw i32 %12, -2
br label %23
21: ; preds = %14
%22 = add nsw i32 %11, -2
br label %23
23: ; preds = %14, %21, %18
%24 = phi double [ 1.000000e+00, %18 ], [ 1.000000e+00, %21 ], [ 0.000000e+00, %14 ]
%25 = phi double [ 1.000000e+00, %18 ], [ 0.000000e+00, %21 ], [ 0.000000e+00, %14 ]
%26 = phi i32 [ %19, %18 ], [ %22, %21 ], [ %11, %14 ]
%27 = phi i32 [ %20, %18 ], [ %12, %21 ], [ %12, %14 ]
%28 = icmp sgt i32 %8, 0
br i1 %28, label %29, label %42
29: ; preds = %23
%30 = sitofp i32 %26 to float
%31 = fdiv float %30, %16
%32 = sitofp i32 %27 to float
%33 = fdiv float %32, %17
%34 = mul nsw i32 %9, %7
%35 = fpext float %33 to double
%36 = icmp sgt i32 %7, 0
%37 = fpext float %31 to double
%38 = sext i32 %9 to i64
%39 = sext i32 %34 to i64
%40 = zext i32 %8 to i64
%41 = zext i32 %7 to i64
br label %47
42: ; preds = %73, %23
%43 = icmp sgt i32 %15, 0
br i1 %43, label %44, label %158
44: ; preds = %42
%45 = sext i32 %9 to i64
%46 = zext i32 %15 to i64
br label %83
47: ; preds = %29, %73
%48 = phi i64 [ 0, %29 ], [ %74, %73 ]
%49 = mul nsw i64 %48, %39
%50 = trunc i64 %48 to i32
%51 = sitofp i32 %50 to float
%52 = fpext float %51 to double
%53 = fadd double %52, 5.000000e-01
%54 = tail call double @llvm.fmuladd.f64(double %35, double %53, double %25)
%55 = fptrunc double %54 to float
br i1 %36, label %56, label %73
56: ; preds = %47, %56
%57 = phi i64 [ %71, %56 ], [ 0, %47 ]
%58 = trunc i64 %57 to i32
%59 = sitofp i32 %58 to float
%60 = fpext float %59 to double
%61 = fadd double %60, 5.000000e-01
%62 = tail call double @llvm.fmuladd.f64(double %37, double %61, double %24)
%63 = fptrunc double %62 to float
%64 = mul nsw i64 %57, %38
%65 = add nsw i64 %64, %49
%66 = getelementptr inbounds float, float* %0, i64 %65
store float %63, float* %66
%67 = shl i64 %65, 32
%68 = add i64 %67, 4294967296
%69 = ashr exact i64 %68, 32
%70 = getelementptr inbounds float, float* %0, i64 %69
store float %55, float* %70
%71 = add nuw nsw i64 %57, 1
%72 = icmp eq i64 %71, %41
br i1 %72, label %73, label %56
73: ; preds = %56, %47
%74 = add nuw nsw i64 %48, 1
%75 = icmp eq i64 %74, %40
br i1 %75, label %42, label %47
76: ; preds = %83
br i1 %43, label %77, label %158
77: ; preds = %76
%78 = sext i32 %9 to i64
%79 = and i64 %46, 1
%80 = icmp eq i32 %15, 1
br i1 %80, label %133, label %81
81: ; preds = %77
%82 = and i64 %46, 4294967294
br label %100
83: ; preds = %44, %83
%84 = phi i64 [ 0, %44 ], [ %98, %83 ]
%85 = tail call float (...) @ranorm()
%86 = fmul float %85, %1
%87 = mul nsw i64 %84, %45
%88 = add nsw i64 %87, 2
%89 = getelementptr inbounds float, float* %0, i64 %88
store float %86, float* %89
%90 = tail call float (...) @ranorm()
%91 = fmul float %90, %2
%92 = add nsw i64 %87, 3
%93 = getelementptr inbounds float, float* %0, i64 %92
store float %91, float* %93
%94 = tail call float (...) @ranorm()
%95 = fmul float %94, %3
%96 = add nsw i64 %87, 4
%97 = getelementptr inbounds float, float* %0, i64 %96
store float %95, float* %97
%98 = add nuw nsw i64 %84, 1
%99 = icmp eq i64 %98, %46
br i1 %99, label %76, label %83
100: ; preds = %100, %81
%101 = phi i64 [ 0, %81 ], [ %130, %100 ]
%102 = phi double [ 0.000000e+00, %81 ], [ %123, %100 ]
%103 = phi <2 x double> [ zeroinitializer, %81 ], [ %129, %100 ]
%104 = phi i64 [ 0, %81 ], [ %131, %100 ]
%105 = mul nsw i64 %101, %78
%106 = add nsw i64 %105, 2
%107 = getelementptr inbounds float, float* %0, i64 %106
%108 = load float, float* %107
%109 = fpext float %108 to double
%110 = fadd double %102, %109
%111 = add nsw i64 %105, 3
%112 = getelementptr inbounds float, float* %0, i64 %111
%113 = bitcast float* %112 to <2 x float>*
%114 = load <2 x float>, <2 x float>* %113
%115 = fpext <2 x float> %114 to <2 x double>
%116 = fadd <2 x double> %103, %115
%117 = or i64 %101, 1
%118 = mul nsw i64 %117, %78
%119 = add nsw i64 %118, 2
%120 = getelementptr inbounds float, float* %0, i64 %119
%121 = load float, float* %120
%122 = fpext float %121 to double
%123 = fadd double %110, %122
%124 = add nsw i64 %118, 3
%125 = getelementptr inbounds float, float* %0, i64 %124
%126 = bitcast float* %125 to <2 x float>*
%127 = load <2 x float>, <2 x float>* %126
%128 = fpext <2 x float> %127 to <2 x double>
%129 = fadd <2 x double> %116, %128
%130 = add nuw nsw i64 %101, 2
%131 = add i64 %104, 2
%132 = icmp eq i64 %131, %82
br i1 %132, label %133, label %100
133: ; preds = %100, %77
%134 = phi double [ undef, %77 ], [ %123, %100 ]
%135 = phi <2 x double> [ undef, %77 ], [ %129, %100 ]
%136 = phi i64 [ 0, %77 ], [ %130, %100 ]
%137 = phi double [ 0.000000e+00, %77 ], [ %123, %100 ]
%138 = phi <2 x double> [ zeroinitializer, %77 ], [ %129, %100 ]
%139 = icmp eq i64 %79, 0
br i1 %139, label %153, label %140
140: ; preds = %133
%141 = mul nsw i64 %136, %78
%142 = add nsw i64 %141, 2
%143 = getelementptr inbounds float, float* %0, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = fadd double %137, %145
%147 = add nsw i64 %141, 3
%148 = getelementptr inbounds float, float* %0, i64 %147
%149 = bitcast float* %148 to <2 x float>*
%150 = load <2 x float>, <2 x float>* %149
%151 = fpext <2 x float> %150 to <2 x double>
%152 = fadd <2 x double> %138, %151
br label %153
153: ; preds = %133, %140
%154 = phi double [ %134, %133 ], [ %146, %140 ]
%155 = phi <2 x double> [ %135, %133 ], [ %152, %140 ]
%156 = fptrunc double %154 to float
%157 = fptrunc <2 x double> %155 to <2 x float>
br label %158
158: ; preds = %42, %153, %76
%159 = phi float [ 0.000000e+00, %76 ], [ %156, %153 ], [ 0.000000e+00, %42 ]
%160 = phi <2 x float> [ zeroinitializer, %76 ], [ %157, %153 ], [ zeroinitializer, %42 ]
%161 = sitofp i32 %15 to float
%162 = fdiv float 1.000000e+00, %161
%163 = fneg float %4
%164 = tail call float @llvm.fmuladd.f32(float %162, float %159, float %163)
%165 = fneg float %5
%166 = extractelement <2 x float> %160, i64 0
%167 = tail call float @llvm.fmuladd.f32(float %162, float %166, float %165)
%168 = fneg float %6
%169 = extractelement <2 x float> %160, i64 1
%170 = tail call float @llvm.fmuladd.f32(float %162, float %169, float %168)
br i1 %43, label %171, label %191
171: ; preds = %158
%172 = sext i32 %9 to i64
%173 = zext i32 %15 to i64
br label %174
174: ; preds = %171, %174
%175 = phi i64 [ 0, %171 ], [ %189, %174 ]
%176 = mul nsw i64 %175, %172
%177 = add nsw i64 %176, 2
%178 = getelementptr inbounds float, float* %0, i64 %177
%179 = load float, float* %178
%180 = fsub float %179, %164
store float %180, float* %178
%181 = add nsw i64 %176, 3
%182 = getelementptr inbounds float, float* %0, i64 %181
%183 = load float, float* %182
%184 = fsub float %183, %167
store float %184, float* %182
%185 = add nsw i64 %176, 4
%186 = getelementptr inbounds float, float* %0, i64 %185
%187 = load float, float* %186
%188 = fsub float %187, %170
store float %188, float* %186
%189 = add nuw nsw i64 %175, 1
%190 = icmp eq i64 %189, %173
br i1 %190, label %191, label %174
191: ; preds = %174, %158
ret void
}