#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 */
int /*<<< orphan*/ assert(int);
void l2project2Tensor(const int nSimplices, const int nPointsPerSimplex,
                      const int nSpace, double *dV, double *r) {
  int eN, k, I, J, nSpace2;
  double vol;
  double ravg[nSpace * nSpace];
  nSpace2 = nSpace * nSpace;
  for (eN = 0; eN < nSimplices; eN++) {
    vol = 0.0;
    for (I = 0; I < nSpace2; I++)
      ravg[I] = 0.0;
    for (k = 0; k < nPointsPerSimplex; k++) {
      vol += dV[eN * nPointsPerSimplex + k];
      for (I = 0; I < nSpace; I++)
        for (J = 0; J < nSpace; J++)
          ravg[I * nSpace + J] += r[eN * nPointsPerSimplex * nSpace2 +
                                    k * nSpace2 + I * nSpace + J] *
                                  dV[eN * nPointsPerSimplex + k];
    }
    assert(vol > 0.0);
    for (k = 0; k < nPointsPerSimplex; k++) {
      for (I = 0; I < nSpace; I++)
        for (J = 0; J < nSpace; J++)
          r[eN * nPointsPerSimplex * nSpace2 + k * nSpace2 + I * nSpace + J] =
              ravg[I * nSpace + J] / vol;
    }
  }
}


x86 assembly (clang, -O0):
<l2project2Tensor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
imul   %eax,%eax
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    137b <l2project2Tensor+0x26b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    11a9 <l2project2Tensor+0x99>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117f <l2project2Tensor+0x6f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    129b <l2project2Tensor+0x18b>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1288 <l2project2Tensor+0x178>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1275 <l2project2Tensor+0x165>
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
imul   -0x8(%rbp),%edx
imul   -0x34(%rbp),%edx
mov    -0x28(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
mov    -0x2c(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
add    -0x30(%rbp),%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
imul   -0x8(%rbp),%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f6 <l2project2Tensor+0xe6>
jmp    127a <l2project2Tensor+0x16a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e3 <l2project2Tensor+0xd3>
jmp    128d <l2project2Tensor+0x17d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b0 <l2project2Tensor+0xa0>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1368 <l2project2Tensor+0x258>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1355 <l2project2Tensor+0x245>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1342 <l2project2Tensor+0x232>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12e1 <l2project2Tensor+0x1d1>
jmp    1347 <l2project2Tensor+0x237>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ce <l2project2Tensor+0x1be>
jmp    135a <l2project2Tensor+0x24a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12bb <l2project2Tensor+0x1ab>
jmp    136d <l2project2Tensor+0x25d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1164 <l2project2Tensor+0x54>
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<l2project2Tensor>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rcx,-0x100(%rbp)
mov    %esi,-0x2c(%rbp)
mov    %edx,%eax
imul   %eax,%eax
mov    %rsp,%rcx
mov    %rax,-0x40(%rbp)
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
test   %edi,%edi
jle    17a6 <l2project2Tensor+0x686>
mov    %r8,%rbx
mov    %edx,%esi
mov    -0x40(%rbp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,-0xd8(%rbp)
movslq %edx,%r8
mov    %edi,%edx
mov    %rdx,-0xe0(%rbp)
mov    %esi,%r12d
lea    -0x1(%r12),%rdx
mov    %eax,%edi
mov    -0x2c(%rbp),%eax
imul   %eax,%edi
mov    %rdi,-0x88(%rbp)
mov    %r12d,%edi
and    $0xfffffffe,%edi
mov    %rdi,-0x120(%rbp)
add    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x118(%rbp)
mov    %rdi,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r12d,%edi
and    $0xfffffffc,%edi
mov    %rdi,-0x128(%rbp)
mov    %r12,%rdi
neg    %rdi
mov    %rdi,-0x80(%rbp)
mov    %rcx,%rdi
mov    %rcx,-0x110(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x108(%rbp)
mov    %rdx,%rdi
mov    %rdx,-0xb8(%rbp)
shr    $0x20,%rdx
mov    %rdx,-0xb0(%rbp)
cltq
mov    %rax,-0xd0(%rbp)
mov    %eax,%eax
mov    %rax,-0xf8(%rbp)
mov    -0x48(%rbp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,-0xa0(%rbp)
mov    %r8,-0xc0(%rbp)
lea    0x0(,%r8,8),%rcx
mov    %rcx,-0xc8(%rbp)
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    $0x1,%r14d
movl   $0x2,-0x54(%rbp)
xor    %r15d,%r15d
xor    %eax,%eax
mov    %rax,-0x68(%rbp)
mov    %esi,-0x30(%rbp)
jmp    12b4 <l2project2Tensor+0x194>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edi,%edi
call   1040 <assert@plt>
mov    -0x30(%rbp),%esi
mov    -0x68(%rbp),%rcx
add    $0x1,%rcx
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%r15
add    %rax,%r15
mov    -0x98(%rbp),%r14
add    %rax,%r14
add    %eax,-0x54(%rbp)
mov    %rcx,%rax
mov    %rcx,-0x68(%rbp)
cmp    -0xe0(%rbp),%rcx
je     17a6 <l2project2Tensor+0x686>
cmpq   $0x0,-0x40(%rbp)
je     12d0 <l2project2Tensor+0x1b0>
mov    -0x48(%rbp),%rdi
xor    %esi,%esi
mov    -0xd8(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x30(%rbp),%esi
cmpl   $0x0,-0x2c(%rbp)
mov    %r14,-0x98(%rbp)
mov    %r15,-0x90(%rbp)
jle    1270 <l2project2Tensor+0x150>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
imul   -0x88(%rbp),%rcx
ff
mov    %rcx,-0xa8(%rbp)
imul   -0xd0(%rbp),%rax
ff
mov    %rax,-0x70(%rbp)
xorpd  %xmm6,%xmm6
mov    %r14,-0x78(%rbp)
mov    %r15,-0x38(%rbp)
xor    %ecx,%ecx
jmp    1345 <l2project2Tensor+0x225>
cs nopw 0x0(%rax,%rax,1)
addsd  %xmm0,%xmm6
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
mov    -0x40(%rbp),%rax
add    %rax,-0x38(%rbp)
add    %rax,-0x78(%rbp)
cmp    -0xf8(%rbp),%rcx
je     1500 <l2project2Tensor+0x3e0>
mov    -0x70(%rbp),%rax
mov    %rcx,-0x50(%rbp)
lea    (%rcx,%rax,1),%r13
mov    -0x100(%rbp),%rax
movsd  (%rax,%r13,8),%xmm0
test   %esi,%esi
jle    1320 <l2project2Tensor+0x200>
mov    -0x50(%rbp),%r11
mov    -0x40(%rbp),%rax
imul   %rax,%r11
add    -0xa8(%rbp),%r11
imul   %eax,%r13d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    -0xf0(%rbp),%rcx
mov    -0x78(%rbp),%r15
mov    -0x38(%rbp),%rax
mov    -0xa0(%rbp),%r8
xor    %r9d,%r9d
jmp    13c3 <l2project2Tensor+0x2a3>
nopl   0x0(%rax)
add    $0x1,%r9
mov    -0xc8(%rbp),%rdx
add    %rdx,%r8
add    %r12,%rax
add    %r12,%r15
add    %rdx,%rcx
cmp    %r12,%r9
mov    -0x30(%rbp),%esi
je     1320 <l2project2Tensor+0x200>
cmp    $0x4,%esi
jb     1460 <l2project2Tensor+0x340>
mov    %r9d,%edi
imul   %r12d,%edi
add    %r11d,%edi
mov    -0xb8(%rbp),%rsi
add    %edi,%esi
cmp    %edi,%esi
jl     1460 <l2project2Tensor+0x340>
mov    $0x0,%r14d
cmpq   $0x0,-0xb0(%rbp)
jne    1463 <l2project2Tensor+0x343>
xor    %edi,%edi
mov    -0x128(%rbp),%rdx
nopl   0x0(%rax)
lea    (%rax,%rdi,1),%esi
movslq %esi,%rsi
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
movupd -0x10(%r8,%rdi,8),%xmm4
movupd (%r8,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%r8,%rdi,8)
movupd %xmm3,(%r8,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1400 <l2project2Tensor+0x2e0>
mov    %rdx,%r14
cmp    %r12,%rdx
je     13a0 <l2project2Tensor+0x280>
jmp    1463 <l2project2Tensor+0x343>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r14d,%r14d
mov    %r14,%r10
test   $0x1,%r12b
je     149f <l2project2Tensor+0x37f>
mov    %r9,%rsi
imul   -0xc0(%rbp),%rsi
ff
add    %r14,%rsi
lea    (%rsi,%r13,1),%edi
movslq %edi,%rdi
movsd  (%rbx,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mov    -0x48(%rbp),%rdi
addsd  (%rdi,%rsi,8),%xmm2
movsd  %xmm2,(%rdi,%rsi,8)
mov    %r14,%r10
or     $0x1,%r10
not    %r14
cmp    -0x80(%rbp),%r14
je     13a0 <l2project2Tensor+0x280>
nopl   0x0(%rax)
lea    (%rax,%r10,1),%esi
movslq %esi,%rsi
movsd  (%rbx,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  -0x8(%rcx,%r10,8),%xmm2
movsd  %xmm2,-0x8(%rcx,%r10,8)
lea    (%r15,%r10,1),%esi
movslq %esi,%rsi
movsd  (%rbx,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rcx,%r10,8),%xmm2
movsd  %xmm2,(%rcx,%r10,8)
add    $0x2,%r10
cmp    %r10,%r12
jne    14b0 <l2project2Tensor+0x390>
jmp    13a0 <l2project2Tensor+0x280>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
ucomisd 0xaf6(%rip),%xmm6
seta   %dil
movapd %xmm6,-0x140(%rbp)
ff
call   1040 <assert@plt>
movapd -0x140(%rbp),%xmm2
ff
mov    -0x30(%rbp),%esi
cmpl   $0x0,-0x2c(%rbp)
jle    127a <l2project2Tensor+0x15a>
mov    -0x68(%rbp),%rax
imul   -0x2c(%rbp),%eax
mov    %rax,-0xe8(%rbp)
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
mov    -0x98(%rbp),%rax
mov    %eax,-0x70(%rbp)
mov    -0x90(%rbp),%rax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
xor    %eax,%eax
mov    %rax,-0x38(%rbp)
jmp    1592 <l2project2Tensor+0x472>
nopl   0x0(%rax)
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x40(%rbp),%rax
add    %eax,-0x58(%rbp)
add    %eax,-0x5c(%rbp)
add    %eax,-0x70(%rbp)
mov    %rcx,-0x38(%rbp)
cmp    -0x2c(%rbp),%ecx
je     127a <l2project2Tensor+0x15a>
test   %esi,%esi
jle    1570 <l2project2Tensor+0x450>
mov    -0x38(%rbp),%rdx
mov    %rdx,%rcx
mov    -0x40(%rbp),%rax
imul   %rax,%rcx
add    -0xa8(%rbp),%rcx
mov    %rcx,-0x78(%rbp)
mov    -0xe8(%rbp),%rcx
add    %edx,%ecx
imul   %eax,%ecx
mov    %ecx,-0x50(%rbp)
mov    -0x70(%rbp),%r15d
mov    -0x5c(%rbp),%eax
mov    %eax,%r14d
mov    -0x48(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x58(%rbp),%r11d
xor    %r10d,%r10d
jmp    1606 <l2project2Tensor+0x4e6>
nopl   (%rax)
add    $0x1,%r10
mov    -0x30(%rbp),%esi
add    %esi,%r11d
mov    -0xc8(%rbp),%rax
add    %rax,%r9
add    %rax,%r8
add    %esi,%r14d
add    %esi,%r15d
cmp    %r12,%r10
je     1570 <l2project2Tensor+0x450>
mov    %r10,%rax
imul   -0xc0(%rbp),%rax
ff
cmp    $0x2,%esi
jb     16f0 <l2project2Tensor+0x5d0>
mov    %r10d,%edx
imul   %r12d,%edx
add    -0x78(%rbp),%edx
mov    -0xb8(%rbp),%rcx
lea    (%rdx,%rcx,1),%esi
cmp    %edx,%esi
jl     16f0 <l2project2Tensor+0x5d0>
mov    $0x0,%edx
cmpq   $0x0,-0xb0(%rbp)
jne    16f2 <l2project2Tensor+0x5d2>
cmpq   $0x0,-0x118(%rbp)
je     1792 <l2project2Tensor+0x672>
mov    -0x108(%rbp),%rdx
mov    %r11d,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%r9,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
lea    -0x2(%rsi),%ecx
movslq %ecx,%rcx
movupd %xmm1,(%rbx,%rcx,8)
movupd (%r9,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movslq %esi,%rsi
movupd %xmm1,(%rbx,%rsi,8)
add    $0x4,%rdi
add    $0x4,%esi
add    $0xfffffffffffffffe,%rdx
jne    1670 <l2project2Tensor+0x550>
testb  $0x1,-0x110(%rbp)
je     16cf <l2project2Tensor+0x5af>
mov    %rdi,%rcx
add    %rax,%rcx
mov    -0x48(%rbp),%rdx
movupd (%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
lea    (%rdi,%rax,1),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movupd %xmm1,(%rbx,%rcx,8)
mov    -0x120(%rbp),%rcx
mov    %rcx,%rdx
cmp    %r12,%rcx
je     15e0 <l2project2Tensor+0x4c0>
jmp    16f2 <l2project2Tensor+0x5d2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
mov    %rdx,%rdi
test   $0x1,%r12b
je     1721 <l2project2Tensor+0x601>
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x48(%rbp),%rsi
movsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm2,%xmm1
add    %edx,%eax
add    -0x50(%rbp),%eax
cltq
movsd  %xmm1,(%rbx,%rax,8)
mov    %rdx,%rdi
or     $0x1,%rdi
not    %rdx
cmp    -0x80(%rbp),%rdx
je     15e0 <l2project2Tensor+0x4c0>
mov    -0x80(%rbp),%rax
add    %rdi,%rax
lea    (%r8,%rdi,8),%rdx
lea    (%r14,%rdi,1),%esi
add    %r15d,%edi
mov    $0x1,%r13d
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%r13,8),%xmm1
divsd  %xmm2,%xmm1
movslq %esi,%rsi
movsd  %xmm1,(%rbx,%rsi,8)
movsd  (%rdx,%r13,8),%xmm1
divsd  %xmm2,%xmm1
movslq %edi,%rdi
movsd  %xmm1,(%rbx,%rdi,8)
lea    (%rax,%r13,1),%rcx
add    $0x2,%rcx
add    $0x2,%r13
add    $0x2,%esi
add    $0x2,%edi
cmp    $0x1,%rcx
jne    1750 <l2project2Tensor+0x630>
jmp    15e0 <l2project2Tensor+0x4c0>
xor    %edi,%edi
testb  $0x1,-0x110(%rbp)
jne    16ae <l2project2Tensor+0x58e>
jmp    16cf <l2project2Tensor+0x5af>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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