void ComputeFirstMoment4D(float *ima, float *atlas, float *means, float *Ameans,
                          const int *dims, int f) {
  int indice = 0;
  int i, j, k, t;
  int ii, jj, kk;
  int ni, nj, nk;
  float mean = 0.0;
  float Amean = 0.0;
  for (k = 0; k < dims[2]; k++) {
    for (i = 0; i < dims[1]; i++) {
      for (j = 0; j < dims[0]; j++) {
        Amean = 0;
        indice = 0;
        for (ii = -f; ii <= f; ii++) {
          for (jj = -f; jj <= f; jj++) {
            for (kk = -f; kk <= f; kk++) {
              ni = i + ii;
              nj = j + jj;
              nk = k + kk;
              if (ni < 0)
                ni = -ni;
              if (nj < 0)
                nj = -nj;
              if (nk < 0)
                nk = -nk;
              if (ni >= dims[1])
                ni = 2 * dims[1] - ni - 1;
              if (nj >= dims[0])
                nj = 2 * dims[0] - nj - 1;
              if (nk >= dims[2])
                nk = 2 * dims[2] - nk - 1;
              Amean =
                  Amean + atlas[nk * (dims[0] * dims[1]) + (ni * dims[0]) + nj];
              indice = indice + 1;
            }
          }
        }
        Amean = Amean / indice;
        Ameans[k * (dims[0] * dims[1]) + (i * dims[0]) + j] = Amean;
      }
    }
  }
  for (t = 0; t < dims[3]; t++) {
    for (k = 0; k < dims[2]; k++) {
      for (i = 0; i < dims[1]; i++) {
        for (j = 0; j < dims[0]; j++) {
          mean = 0;
          indice = 0;
          for (ii = -f; ii <= f; ii++) {
            for (jj = -f; jj <= f; jj++) {
              for (kk = -f; kk <= f; kk++) {
                ni = i + ii;
                nj = j + jj;
                nk = k + kk;
                if (ni < 0)
                  ni = -ni;
                if (nj < 0)
                  nj = -nj;
                if (nk < 0)
                  nk = -nk;
                if (ni >= dims[1])
                  ni = 2 * dims[1] - ni - 1;
                if (nj >= dims[0])
                  nj = 2 * dims[0] - nj - 1;
                if (nk >= dims[2])
                  nk = 2 * dims[2] - nk - 1;
                mean = mean +
                       ima[t * (dims[0] * dims[1] * dims[2]) +
                           (nk * (dims[0] * dims[1]) + (ni * dims[0]) + nj)];
                indice = indice + 1;
              }
            }
          }
          mean = mean / indice;
          means[t * (dims[0] * dims[1] * dims[2]) +
                (k * (dims[0] * dims[1]) + (i * dims[0]) + j)] = mean;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<ComputeFirstMoment4D>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    136b <ComputeFirstMoment4D+0x26b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1358 <ComputeFirstMoment4D+0x258>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1345 <ComputeFirstMoment4D+0x245>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x30(%rbp)
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12f0 <ComputeFirstMoment4D+0x1f0>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12dd <ComputeFirstMoment4D+0x1dd>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12ca <ComputeFirstMoment4D+0x1ca>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x50(%rbp)
jge    11ef <ComputeFirstMoment4D+0xef>
xor    %eax,%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x54(%rbp)
jge    1201 <ComputeFirstMoment4D+0x101>
xor    %eax,%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x58(%rbp)
jge    1213 <ComputeFirstMoment4D+0x113>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jl     1236 <ComputeFirstMoment4D+0x136>
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x1,%eax
sub    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jl     1257 <ComputeFirstMoment4D+0x157>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x8(%rcx),%eax
jl     127a <ComputeFirstMoment4D+0x17a>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x1,%eax
sub    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x28(%rbp),%rsi
imul   0x4(%rsi),%edx
imul   %edx,%ecx
mov    -0x50(%rbp),%edx
mov    -0x28(%rbp),%rsi
imul   (%rsi),%edx
add    %edx,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11b6 <ComputeFirstMoment4D+0xb6>
jmp    12cf <ComputeFirstMoment4D+0x1cf>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11a2 <ComputeFirstMoment4D+0xa2>
jmp    12e2 <ComputeFirstMoment4D+0x1e2>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    118e <ComputeFirstMoment4D+0x8e>
movss  -0x60(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x28(%rbp),%rsi
imul   0x4(%rsi),%edx
imul   %edx,%ecx
mov    -0x34(%rbp),%edx
mov    -0x28(%rbp),%rsi
imul   (%rsi),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1168 <ComputeFirstMoment4D+0x68>
jmp    134a <ComputeFirstMoment4D+0x24a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1151 <ComputeFirstMoment4D+0x51>
jmp    135d <ComputeFirstMoment4D+0x25d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    113a <ComputeFirstMoment4D+0x3a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0xc(%rcx),%eax
jge    1609 <ComputeFirstMoment4D+0x509>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    15f6 <ComputeFirstMoment4D+0x4f6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    15e3 <ComputeFirstMoment4D+0x4e3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    15d0 <ComputeFirstMoment4D+0x4d0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x30(%rbp)
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     155d <ComputeFirstMoment4D+0x45d>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     154a <ComputeFirstMoment4D+0x44a>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1537 <ComputeFirstMoment4D+0x437>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x50(%rbp)
jge    143e <ComputeFirstMoment4D+0x33e>
xor    %eax,%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x54(%rbp)
jge    1450 <ComputeFirstMoment4D+0x350>
xor    %eax,%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x58(%rbp)
jge    1462 <ComputeFirstMoment4D+0x362>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jl     1485 <ComputeFirstMoment4D+0x385>
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x1,%eax
sub    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jl     14a6 <ComputeFirstMoment4D+0x3a6>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x8(%rcx),%eax
jl     14c9 <ComputeFirstMoment4D+0x3c9>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x1,%eax
sub    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x28(%rbp),%rsi
imul   0x4(%rsi),%edx
mov    -0x28(%rbp),%rsi
imul   0x8(%rsi),%edx
imul   %edx,%ecx
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    (%rsi),%esi
mov    -0x28(%rbp),%rdi
imul   0x4(%rdi),%esi
imul   %esi,%edx
mov    -0x50(%rbp),%esi
mov    -0x28(%rbp),%rdi
imul   (%rdi),%esi
add    %esi,%edx
add    -0x54(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1405 <ComputeFirstMoment4D+0x305>
jmp    153c <ComputeFirstMoment4D+0x43c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13f1 <ComputeFirstMoment4D+0x2f1>
jmp    154f <ComputeFirstMoment4D+0x44f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13dd <ComputeFirstMoment4D+0x2dd>
movss  -0x5c(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x28(%rbp),%rsi
imul   0x4(%rsi),%edx
mov    -0x28(%rbp),%rsi
imul   0x8(%rsi),%edx
imul   %edx,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    (%rsi),%esi
mov    -0x28(%rbp),%rdi
imul   0x4(%rdi),%esi
imul   %esi,%edx
mov    -0x34(%rbp),%esi
mov    -0x28(%rbp),%rdi
imul   (%rdi),%esi
add    %esi,%edx
add    -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13b7 <ComputeFirstMoment4D+0x2b7>
jmp    15d5 <ComputeFirstMoment4D+0x4d5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a0 <ComputeFirstMoment4D+0x2a0>
jmp    15e8 <ComputeFirstMoment4D+0x4e8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1389 <ComputeFirstMoment4D+0x289>
jmp    15fb <ComputeFirstMoment4D+0x4fb>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1372 <ComputeFirstMoment4D+0x272>
pop    %rbp
ret

x86 assembly (clang, -O2):
<ComputeFirstMoment4D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x30(%rsp)
mov    %rcx,-0x28(%rsp)
mov    %rdx,-0x8(%rsp)
mov    %r8,-0x48(%rsp)
mov    0x8(%r8),%r8d
test   %r8d,%r8d
jle    131c <ComputeFirstMoment4D+0x21c>
mov    -0x48(%rsp),%rax
mov    0x4(%rax),%r15d
lea    (%r15,%r15,1),%eax
mov    %eax,-0x50(%rsp)
mov    -0x30(%rsp),%rbp
mov    %ebp,%edx
neg    %edx
mov    %ebp,%ecx
cmovns %edx,%ecx
lea    (%r8,%r8,1),%eax
mov    %rcx,-0x38(%rsp)
lea    (%rcx,%rbp,1),%ebx
not    %ebx
xor    %ecx,%ecx
mov    %rcx,-0x60(%rsp)
mov    %edx,-0x70(%rsp)
mov    %edx,-0x6c(%rsp)
jmp    118b <ComputeFirstMoment4D+0x8b>
nopl   0x0(%rax)
mov    -0x60(%rsp),%rcx
add    $0x1,%ecx
addl   $0x1,-0x6c(%rsp)
mov    %rcx,-0x60(%rsp)
cmp    %r8d,%ecx
je     131c <ComputeFirstMoment4D+0x21c>
test   %r15d,%r15d
jle    1170 <ComputeFirstMoment4D+0x70>
mov    -0x48(%rsp),%rcx
mov    (%rcx),%ebp
lea    0x0(%rbp,%rbp,1),%ecx
mov    %ecx,-0x4c(%rsp)
mov    %r15d,%ecx
imul   -0x60(%rsp),%ecx
mov    %rcx,-0x40(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x68(%rsp)
jmp    11d5 <ComputeFirstMoment4D+0xd5>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x68(%rsp),%rdx
add    $0x1,%edx
mov    %rdx,%rcx
mov    %rdx,-0x68(%rsp)
cmp    %r15d,%edx
je     1170 <ComputeFirstMoment4D+0x70>
test   %ebp,%ebp
jle    11c0 <ComputeFirstMoment4D+0xc0>
mov    -0x40(%rsp),%rcx
mov    -0x68(%rsp),%rdx
add    %edx,%ecx
imul   %ebp,%ecx
mov    %rcx,-0x20(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x58(%rsp)
jmp    123a <ComputeFirstMoment4D+0x13a>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xor    %r13d,%r13d
xorps  %xmm1,%xmm1
cvtsi2ss %r13d,%xmm1
divss  %xmm1,%xmm0
mov    -0x20(%rsp),%rcx
mov    -0x58(%rsp),%r9
add    %r9d,%ecx
movslq %ecx,%rcx
mov    -0x28(%rsp),%rdx
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%r9
mov    %r9,-0x58(%rsp)
cmp    %rbp,%r9
je     11c0 <ComputeFirstMoment4D+0xc0>
cmpl   $0x0,-0x30(%rsp)
js     1200 <ComputeFirstMoment4D+0x100>
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
mov    -0x70(%rsp),%edx
mov    %edx,%r10d
nopl   (%rax)
mov    -0x68(%rsp),%rdx
mov    %r10,-0x18(%rsp)
lea    (%r10,%rdx,1),%r9d
mov    %r9d,%edx
neg    %edx
cmovs  %r9d,%edx
mov    %edx,%r11d
not    %r11d
add    -0x50(%rsp),%r11d
cmp    %r15d,%edx
cmovl  %edx,%r11d
mov    -0x70(%rsp),%edx
mov    %edx,%r10d
mov    %ecx,%r13d
mov    -0x58(%rsp),%rcx
add    %r10d,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
mov    %edx,%r14d
not    %r14d
add    -0x4c(%rsp),%r14d
cmp    %ebp,%edx
cmovl  %edx,%r14d
xor    %r9d,%r9d
mov    -0x6c(%rsp),%r12d
nopl   0x0(%rax,%rax,1)
mov    %r12d,%ecx
neg    %ecx
cmovs  %r12d,%ecx
mov    %ecx,%edx
not    %edx
add    %eax,%edx
cmp    %r8d,%ecx
cmovl  %ecx,%edx
imul   %r15d,%edx
add    %r11d,%edx
imul   %ebp,%edx
add    %r14d,%edx
movslq %edx,%rcx
addss  (%rsi,%rcx,4),%xmm0
add    $0xffffffff,%r9d
add    $0x1,%r12d
cmp    %r9d,%ebx
jne    12b0 <ComputeFirstMoment4D+0x1b0>
lea    0x1(%r10),%edx
mov    %r13d,%ecx
sub    %r9d,%ecx
cmp    -0x38(%rsp),%r10d
mov    %edx,%r10d
jne    1280 <ComputeFirstMoment4D+0x180>
mov    -0x18(%rsp),%rdx
lea    0x1(%rdx),%r10d
mov    %r13d,%ecx
sub    %r9d,%ecx
cmp    -0x38(%rsp),%edx
jne    1250 <ComputeFirstMoment4D+0x150>
sub    %r9d,%r13d
jmp    1206 <ComputeFirstMoment4D+0x106>
mov    -0x48(%rsp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0xc(%rsp)
test   %eax,%eax
jle    156d <ComputeFirstMoment4D+0x46d>
mov    -0x30(%rsp),%rax
mov    %eax,%ecx
neg    %ecx
mov    %eax,%edx
mov    %ecx,-0x70(%rsp)
cmovns %ecx,%edx
lea    (%r8,%r8,1),%esi
mov    %rdx,-0x38(%rsp)
lea    (%rax,%rdx,1),%ebx
not    %ebx
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
jmp    1377 <ComputeFirstMoment4D+0x277>
nopl   0x0(%rax)
mov    -0x60(%rsp),%rax
add    $0x1,%eax
mov    %rax,-0x60(%rsp)
cmp    -0xc(%rsp),%eax
je     156d <ComputeFirstMoment4D+0x46d>
test   %r8d,%r8d
jle    1360 <ComputeFirstMoment4D+0x260>
mov    -0x48(%rsp),%rax
mov    0x4(%rax),%ecx
lea    (%rcx,%rcx,1),%eax
mov    %eax,-0x50(%rsp)
mov    -0x60(%rsp),%rbp
imul   %r8d,%ebp
xor    %eax,%eax
mov    %rax,-0x40(%rsp)
mov    -0x70(%rsp),%eax
mov    %eax,-0x6c(%rsp)
jmp    13ca <ComputeFirstMoment4D+0x2ca>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x40(%rsp),%rdx
add    $0x1,%edx
addl   $0x1,-0x6c(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x40(%rsp)
cmp    %r8d,%edx
je     1360 <ComputeFirstMoment4D+0x260>
test   %ecx,%ecx
jle    13b0 <ComputeFirstMoment4D+0x2b0>
mov    -0x48(%rsp),%rax
mov    (%rax),%r14d
lea    (%r14,%r14,1),%eax
mov    %eax,-0x4c(%rsp)
mov    -0x40(%rsp),%rax
add    %ebp,%eax
imul   %ecx,%eax
mov    %rax,-0x28(%rsp)
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
jmp    1414 <ComputeFirstMoment4D+0x314>
cs nopw 0x0(%rax,%rax,1)
mov    -0x68(%rsp),%rdx
add    $0x1,%edx
mov    %rdx,%rax
mov    %rdx,-0x68(%rsp)
cmp    %ecx,%edx
je     13b0 <ComputeFirstMoment4D+0x2b0>
test   %r14d,%r14d
jle    1400 <ComputeFirstMoment4D+0x300>
mov    -0x28(%rsp),%rax
mov    -0x68(%rsp),%rdx
add    %edx,%eax
imul   %r14d,%eax
mov    %rax,-0x20(%rsp)
xor    %eax,%eax
mov    %rax,-0x58(%rsp)
jmp    1479 <ComputeFirstMoment4D+0x379>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xor    %r10d,%r10d
xorps  %xmm1,%xmm1
cvtsi2ss %r10d,%xmm1
divss  %xmm1,%xmm0
mov    -0x20(%rsp),%rax
mov    -0x58(%rsp),%r9
add    %r9d,%eax
cltq
mov    -0x8(%rsp),%rdx
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%r9
mov    %r9,-0x58(%rsp)
cmp    %r14,%r9
je     1400 <ComputeFirstMoment4D+0x300>
cmpl   $0x0,-0x30(%rsp)
js     1440 <ComputeFirstMoment4D+0x340>
xor    %edx,%edx
xorps  %xmm0,%xmm0
mov    -0x70(%rsp),%eax
mov    %eax,%r11d
nopl   0x0(%rax)
mov    -0x68(%rsp),%rax
mov    %r11,-0x18(%rsp)
lea    (%r11,%rax,1),%r9d
mov    %r9d,%r10d
neg    %r10d
cmovs  %r9d,%r10d
mov    %r10d,%r12d
not    %r12d
add    -0x50(%rsp),%r12d
cmp    %ecx,%r10d
cmovl  %r10d,%r12d
mov    -0x70(%rsp),%eax
mov    %eax,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%r10d
mov    -0x58(%rsp),%rax
add    %r13d,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
mov    %edx,%r15d
not    %r15d
add    -0x4c(%rsp),%r15d
cmp    %r14d,%edx
cmovl  %edx,%r15d
xor    %r9d,%r9d
mov    -0x6c(%rsp),%r11d
nopl   0x0(%rax)
mov    %r11d,%edx
neg    %edx
cmovs  %r11d,%edx
mov    %edx,%eax
not    %eax
add    %esi,%eax
cmp    %r8d,%edx
cmovl  %edx,%eax
add    %ebp,%eax
imul   %ecx,%eax
add    %r12d,%eax
imul   %r14d,%eax
add    %r15d,%eax
cltq
addss  (%rdi,%rax,4),%xmm0
add    $0xffffffff,%r9d
add    $0x1,%r11d
cmp    %r9d,%ebx
jne    1500 <ComputeFirstMoment4D+0x400>
lea    0x1(%r13),%eax
mov    %r10d,%edx
sub    %r9d,%edx
cmp    -0x38(%rsp),%r13d
mov    %eax,%r13d
jne    14d0 <ComputeFirstMoment4D+0x3d0>
mov    -0x18(%rsp),%rax
lea    0x1(%rax),%r11d
mov    %r10d,%edx
sub    %r9d,%edx
cmp    -0x38(%rsp),%eax
jne    1490 <ComputeFirstMoment4D+0x390>
sub    %r9d,%r10d
jmp    1446 <ComputeFirstMoment4D+0x346>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @ComputeFirstMoment4D(float* %0, float* %1, float* %2, float* %3, i32* %4, i32 %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca float
%25 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store float* %2, float** %9
store float* %3, float** %10
store i32* %4, i32** %11
store i32 %5, i32* %12
store i32 0, i32* %13
store float 0.000000e+00, float* %24
store float 0.000000e+00, float* %25
store i32 0, i32* %16
br label %26
26: ; preds = %207, %6
%27 = load i32, i32* %16
%28 = load i32*, i32** %11
%29 = getelementptr inbounds i32, i32* %28, i64 2
%30 = load i32, i32* %29
%31 = icmp slt i32 %27, %30
br i1 %31, label %32, label %210
32: ; preds = %26
store i32 0, i32* %14
br label %33
33: ; preds = %203, %32
%34 = load i32, i32* %14
%35 = load i32*, i32** %11
%36 = getelementptr inbounds i32, i32* %35, i64 1
%37 = load i32, i32* %36
%38 = icmp slt i32 %34, %37
br i1 %38, label %39, label %206
39: ; preds = %33
store i32 0, i32* %15
br label %40
40: ; preds = %199, %39
%41 = load i32, i32* %15
%42 = load i32*, i32** %11
%43 = getelementptr inbounds i32, i32* %42, i64 0
%44 = load i32, i32* %43
%45 = icmp slt i32 %41, %44
br i1 %45, label %46, label %202
46: ; preds = %40
store float 0.000000e+00, float* %25
store i32 0, i32* %13
%47 = load i32, i32* %12
%48 = sub nsw i32 0, %47
store i32 %48, i32* %18
br label %49
49: ; preds = %170, %46
%50 = load i32, i32* %18
%51 = load i32, i32* %12
%52 = icmp sle i32 %50, %51
br i1 %52, label %53, label %173
53: ; preds = %49
%54 = load i32, i32* %12
%55 = sub nsw i32 0, %54
store i32 %55, i32* %19
br label %56
56: ; preds = %166, %53
%57 = load i32, i32* %19
%58 = load i32, i32* %12
%59 = icmp sle i32 %57, %58
br i1 %59, label %60, label %169
60: ; preds = %56
%61 = load i32, i32* %12
%62 = sub nsw i32 0, %61
store i32 %62, i32* %20
br label %63
63: ; preds = %162, %60
%64 = load i32, i32* %20
%65 = load i32, i32* %12
%66 = icmp sle i32 %64, %65
br i1 %66, label %67, label %165
67: ; preds = %63
%68 = load i32, i32* %14
%69 = load i32, i32* %18
%70 = add nsw i32 %68, %69
store i32 %70, i32* %21
%71 = load i32, i32* %15
%72 = load i32, i32* %19
%73 = add nsw i32 %71, %72
store i32 %73, i32* %22
%74 = load i32, i32* %16
%75 = load i32, i32* %20
%76 = add nsw i32 %74, %75
store i32 %76, i32* %23
%77 = load i32, i32* %21
%78 = icmp slt i32 %77, 0
br i1 %78, label %79, label %82
79: ; preds = %67
%80 = load i32, i32* %21
%81 = sub nsw i32 0, %80
store i32 %81, i32* %21
br label %82
82: ; preds = %79, %67
%83 = load i32, i32* %22
%84 = icmp slt i32 %83, 0
br i1 %84, label %85, label %88
85: ; preds = %82
%86 = load i32, i32* %22
%87 = sub nsw i32 0, %86
store i32 %87, i32* %22
br label %88
88: ; preds = %85, %82
%89 = load i32, i32* %23
%90 = icmp slt i32 %89, 0
br i1 %90, label %91, label %94
91: ; preds = %88
%92 = load i32, i32* %23
%93 = sub nsw i32 0, %92
store i32 %93, i32* %23
br label %94
94: ; preds = %91, %88
%95 = load i32, i32* %21
%96 = load i32*, i32** %11
%97 = getelementptr inbounds i32, i32* %96, i64 1
%98 = load i32, i32* %97
%99 = icmp sge i32 %95, %98
br i1 %99, label %100, label %108
100: ; preds = %94
%101 = load i32*, i32** %11
%102 = getelementptr inbounds i32, i32* %101, i64 1
%103 = load i32, i32* %102
%104 = mul nsw i32 2, %103
%105 = load i32, i32* %21
%106 = sub nsw i32 %104, %105
%107 = sub nsw i32 %106, 1
store i32 %107, i32* %21
br label %108
108: ; preds = %100, %94
%109 = load i32, i32* %22
%110 = load i32*, i32** %11
%111 = getelementptr inbounds i32, i32* %110, i64 0
%112 = load i32, i32* %111
%113 = icmp sge i32 %109, %112
br i1 %113, label %114, label %122
114: ; preds = %108
%115 = load i32*, i32** %11
%116 = getelementptr inbounds i32, i32* %115, i64 0
%117 = load i32, i32* %116
%118 = mul nsw i32 2, %117
%119 = load i32, i32* %22
%120 = sub nsw i32 %118, %119
%121 = sub nsw i32 %120, 1
store i32 %121, i32* %22
br label %122
122: ; preds = %114, %108
%123 = load i32, i32* %23
%124 = load i32*, i32** %11
%125 = getelementptr inbounds i32, i32* %124, i64 2
%126 = load i32, i32* %125
%127 = icmp sge i32 %123, %126
br i1 %127, label %128, label %136
128: ; preds = %122
%129 = load i32*, i32** %11
%130 = getelementptr inbounds i32, i32* %129, i64 2
%131 = load i32, i32* %130
%132 = mul nsw i32 2, %131
%133 = load i32, i32* %23
%134 = sub nsw i32 %132, %133
%135 = sub nsw i32 %134, 1
store i32 %135, i32* %23
br label %136
136: ; preds = %128, %122
%137 = load float, float* %25
%138 = load float*, float** %8
%139 = load i32, i32* %23
%140 = load i32*, i32** %11
%141 = getelementptr inbounds i32, i32* %140, i64 0
%142 = load i32, i32* %141
%143 = load i32*, i32** %11
%144 = getelementptr inbounds i32, i32* %143, i64 1
%145 = load i32, i32* %144
%146 = mul nsw i32 %142, %145
%147 = mul nsw i32 %139, %146
%148 = load i32, i32* %21
%149 = load i32*, i32** %11
%150 = getelementptr inbounds i32, i32* %149, i64 0
%151 = load i32, i32* %150
%152 = mul nsw i32 %148, %151
%153 = add nsw i32 %147, %152
%154 = load i32, i32* %22
%155 = add nsw i32 %153, %154
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %138, i64 %156
%158 = load float, float* %157
%159 = fadd float %137, %158
store float %159, float* %25
%160 = load i32, i32* %13
%161 = add nsw i32 %160, 1
store i32 %161, i32* %13
br label %162
162: ; preds = %136
%163 = load i32, i32* %20
%164 = add nsw i32 %163, 1
store i32 %164, i32* %20
br label %63
165: ; preds = %63
br label %166
166: ; preds = %165
%167 = load i32, i32* %19
%168 = add nsw i32 %167, 1
store i32 %168, i32* %19
br label %56
169: ; preds = %56
br label %170
170: ; preds = %169
%171 = load i32, i32* %18
%172 = add nsw i32 %171, 1
store i32 %172, i32* %18
br label %49
173: ; preds = %49
%174 = load float, float* %25
%175 = load i32, i32* %13
%176 = sitofp i32 %175 to float
%177 = fdiv float %174, %176
store float %177, float* %25
%178 = load float, float* %25
%179 = load float*, float** %10
%180 = load i32, i32* %16
%181 = load i32*, i32** %11
%182 = getelementptr inbounds i32, i32* %181, i64 0
%183 = load i32, i32* %182
%184 = load i32*, i32** %11
%185 = getelementptr inbounds i32, i32* %184, i64 1
%186 = load i32, i32* %185
%187 = mul nsw i32 %183, %186
%188 = mul nsw i32 %180, %187
%189 = load i32, i32* %14
%190 = load i32*, i32** %11
%191 = getelementptr inbounds i32, i32* %190, i64 0
%192 = load i32, i32* %191
%193 = mul nsw i32 %189, %192
%194 = add nsw i32 %188, %193
%195 = load i32, i32* %15
%196 = add nsw i32 %194, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %179, i64 %197
store float %178, float* %198
br label %199
199: ; preds = %173
%200 = load i32, i32* %15
%201 = add nsw i32 %200, 1
store i32 %201, i32* %15
br label %40
202: ; preds = %40
br label %203
203: ; preds = %202
%204 = load i32, i32* %14
%205 = add nsw i32 %204, 1
store i32 %205, i32* %14
br label %33
206: ; preds = %33
br label %207
207: ; preds = %206
%208 = load i32, i32* %16
%209 = add nsw i32 %208, 1
store i32 %209, i32* %16
br label %26
210: ; preds = %26
store i32 0, i32* %17
br label %211
211: ; preds = %431, %210
%212 = load i32, i32* %17
%213 = load i32*, i32** %11
%214 = getelementptr inbounds i32, i32* %213, i64 3
%215 = load i32, i32* %214
%216 = icmp slt i32 %212, %215
br i1 %216, label %217, label %434
217: ; preds = %211
store i32 0, i32* %16
br label %218
218: ; preds = %427, %217
%219 = load i32, i32* %16
%220 = load i32*, i32** %11
%221 = getelementptr inbounds i32, i32* %220, i64 2
%222 = load i32, i32* %221
%223 = icmp slt i32 %219, %222
br i1 %223, label %224, label %430
224: ; preds = %218
store i32 0, i32* %14
br label %225
225: ; preds = %423, %224
%226 = load i32, i32* %14
%227 = load i32*, i32** %11
%228 = getelementptr inbounds i32, i32* %227, i64 1
%229 = load i32, i32* %228
%230 = icmp slt i32 %226, %229
br i1 %230, label %231, label %426
231: ; preds = %225
store i32 0, i32* %15
br label %232
232: ; preds = %419, %231
%233 = load i32, i32* %15
%234 = load i32*, i32** %11
%235 = getelementptr inbounds i32, i32* %234, i64 0
%236 = load i32, i32* %235
%237 = icmp slt i32 %233, %236
br i1 %237, label %238, label %422
238: ; preds = %232
store float 0.000000e+00, float* %24
store i32 0, i32* %13
%239 = load i32, i32* %12
%240 = sub nsw i32 0, %239
store i32 %240, i32* %18
br label %241
241: ; preds = %376, %238
%242 = load i32, i32* %18
%243 = load i32, i32* %12
%244 = icmp sle i32 %242, %243
br i1 %244, label %245, label %379
245: ; preds = %241
%246 = load i32, i32* %12
%247 = sub nsw i32 0, %246
store i32 %247, i32* %19
br label %248
248: ; preds = %372, %245
%249 = load i32, i32* %19
%250 = load i32, i32* %12
%251 = icmp sle i32 %249, %250
br i1 %251, label %252, label %375
252: ; preds = %248
%253 = load i32, i32* %12
%254 = sub nsw i32 0, %253
store i32 %254, i32* %20
br label %255
255: ; preds = %368, %252
%256 = load i32, i32* %20
%257 = load i32, i32* %12
%258 = icmp sle i32 %256, %257
br i1 %258, label %259, label %371
259: ; preds = %255
%260 = load i32, i32* %14
%261 = load i32, i32* %18
%262 = add nsw i32 %260, %261
store i32 %262, i32* %21
%263 = load i32, i32* %15
%264 = load i32, i32* %19
%265 = add nsw i32 %263, %264
store i32 %265, i32* %22
%266 = load i32, i32* %16
%267 = load i32, i32* %20
%268 = add nsw i32 %266, %267
store i32 %268, i32* %23
%269 = load i32, i32* %21
%270 = icmp slt i32 %269, 0
br i1 %270, label %271, label %274
271: ; preds = %259
%272 = load i32, i32* %21
%273 = sub nsw i32 0, %272
store i32 %273, i32* %21
br label %274
274: ; preds = %271, %259
%275 = load i32, i32* %22
%276 = icmp slt i32 %275, 0
br i1 %276, label %277, label %280
277: ; preds = %274
%278 = load i32, i32* %22
%279 = sub nsw i32 0, %278
store i32 %279, i32* %22
br label %280
280: ; preds = %277, %274
%281 = load i32, i32* %23
%282 = icmp slt i32 %281, 0
br i1 %282, label %283, label %286
283: ; preds = %280
%284 = load i32, i32* %23
%285 = sub nsw i32 0, %284
store i32 %285, i32* %23
br label %286
286: ; preds = %283, %280
%287 = load i32, i32* %21
%288 = load i32*, i32** %11
%289 = getelementptr inbounds i32, i32* %288, i64 1
%290 = load i32, i32* %289
%291 = icmp sge i32 %287, %290
br i1 %291, label %292, label %300
292: ; preds = %286
%293 = load i32*, i32** %11
%294 = getelementptr inbounds i32, i32* %293, i64 1
%295 = load i32, i32* %294
%296 = mul nsw i32 2, %295
%297 = load i32, i32* %21
%298 = sub nsw i32 %296, %297
%299 = sub nsw i32 %298, 1
store i32 %299, i32* %21
br label %300
300: ; preds = %292, %286
%301 = load i32, i32* %22
%302 = load i32*, i32** %11
%303 = getelementptr inbounds i32, i32* %302, i64 0
%304 = load i32, i32* %303
%305 = icmp sge i32 %301, %304
br i1 %305, label %306, label %314
306: ; preds = %300
%307 = load i32*, i32** %11
%308 = getelementptr inbounds i32, i32* %307, i64 0
%309 = load i32, i32* %308
%310 = mul nsw i32 2, %309
%311 = load i32, i32* %22
%312 = sub nsw i32 %310, %311
%313 = sub nsw i32 %312, 1
store i32 %313, i32* %22
br label %314
314: ; preds = %306, %300
%315 = load i32, i32* %23
%316 = load i32*, i32** %11
%317 = getelementptr inbounds i32, i32* %316, i64 2
%318 = load i32, i32* %317
%319 = icmp sge i32 %315, %318
br i1 %319, label %320, label %328
320: ; preds = %314
%321 = load i32*, i32** %11
%322 = getelementptr inbounds i32, i32* %321, i64 2
%323 = load i32, i32* %322
%324 = mul nsw i32 2, %323
%325 = load i32, i32* %23
%326 = sub nsw i32 %324, %325
%327 = sub nsw i32 %326, 1
store i32 %327, i32* %23
br label %328
328: ; preds = %320, %314
%329 = load float, float* %24
%330 = load float*, float** %7
%331 = load i32, i32* %17
%332 = load i32*, i32** %11
%333 = getelementptr inbounds i32, i32* %332, i64 0
%334 = load i32, i32* %333
%335 = load i32*, i32** %11
%336 = getelementptr inbounds i32, i32* %335, i64 1
%337 = load i32, i32* %336
%338 = mul nsw i32 %334, %337
%339 = load i32*, i32** %11
%340 = getelementptr inbounds i32, i32* %339, i64 2
%341 = load i32, i32* %340
%342 = mul nsw i32 %338, %341
%343 = mul nsw i32 %331, %342
%344 = load i32, i32* %23
%345 = load i32*, i32** %11
%346 = getelementptr inbounds i32, i32* %345, i64 0
%347 = load i32, i32* %346
%348 = load i32*, i32** %11
%349 = getelementptr inbounds i32, i32* %348, i64 1
%350 = load i32, i32* %349
%351 = mul nsw i32 %347, %350
%352 = mul nsw i32 %344, %351
%353 = load i32, i32* %21
%354 = load i32*, i32** %11
%355 = getelementptr inbounds i32, i32* %354, i64 0
%356 = load i32, i32* %355
%357 = mul nsw i32 %353, %356
%358 = add nsw i32 %352, %357
%359 = load i32, i32* %22
%360 = add nsw i32 %358, %359
%361 = add nsw i32 %343, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %330, i64 %362
%364 = load float, float* %363
%365 = fadd float %329, %364
store float %365, float* %24
%366 = load i32, i32* %13
%367 = add nsw i32 %366, 1
store i32 %367, i32* %13
br label %368
368: ; preds = %328
%369 = load i32, i32* %20
%370 = add nsw i32 %369, 1
store i32 %370, i32* %20
br label %255
371: ; preds = %255
br label %372
372: ; preds = %371
%373 = load i32, i32* %19
%374 = add nsw i32 %373, 1
store i32 %374, i32* %19
br label %248
375: ; preds = %248
br label %376
376: ; preds = %375
%377 = load i32, i32* %18
%378 = add nsw i32 %377, 1
store i32 %378, i32* %18
br label %241
379: ; preds = %241
%380 = load float, float* %24
%381 = load i32, i32* %13
%382 = sitofp i32 %381 to float
%383 = fdiv float %380, %382
store float %383, float* %24
%384 = load float, float* %24
%385 = load float*, float** %9
%386 = load i32, i32* %17
%387 = load i32*, i32** %11
%388 = getelementptr inbounds i32, i32* %387, i64 0
%389 = load i32, i32* %388
%390 = load i32*, i32** %11
%391 = getelementptr inbounds i32, i32* %390, i64 1
%392 = load i32, i32* %391
%393 = mul nsw i32 %389, %392
%394 = load i32*, i32** %11
%395 = getelementptr inbounds i32, i32* %394, i64 2
%396 = load i32, i32* %395
%397 = mul nsw i32 %393, %396
%398 = mul nsw i32 %386, %397
%399 = load i32, i32* %16
%400 = load i32*, i32** %11
%401 = getelementptr inbounds i32, i32* %400, i64 0
%402 = load i32, i32* %401
%403 = load i32*, i32** %11
%404 = getelementptr inbounds i32, i32* %403, i64 1
%405 = load i32, i32* %404
%406 = mul nsw i32 %402, %405
%407 = mul nsw i32 %399, %406
%408 = load i32, i32* %14
%409 = load i32*, i32** %11
%410 = getelementptr inbounds i32, i32* %409, i64 0
%411 = load i32, i32* %410
%412 = mul nsw i32 %408, %411
%413 = add nsw i32 %407, %412
%414 = load i32, i32* %15
%415 = add nsw i32 %413, %414
%416 = add nsw i32 %398, %415
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds float, float* %385, i64 %417
store float %384, float* %418
br label %419
419: ; preds = %379
%420 = load i32, i32* %15
%421 = add nsw i32 %420, 1
store i32 %421, i32* %15
br label %232
422: ; preds = %232
br label %423
423: ; preds = %422
%424 = load i32, i32* %14
%425 = add nsw i32 %424, 1
store i32 %425, i32* %14
br label %225
426: ; preds = %225
br label %427
427: ; preds = %426
%428 = load i32, i32* %16
%429 = add nsw i32 %428, 1
store i32 %429, i32* %16
br label %218
430: ; preds = %218
br label %431
431: ; preds = %430
%432 = load i32, i32* %17
%433 = add nsw i32 %432, 1
store i32 %433, i32* %17
br label %211
434: ; preds = %211
ret void
}

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