void sampnorm(int f, int i, int j, int n, int c, long u, long v, long w,
              const float *r, const float *p, float *q) {
  const float dr = r[1] - r[0];
  double vn[3];
  double vs[3];
  double ve[3];
  double vw[3];
  double vc[3];
  scm_get_sample_center(f, n * u + i, n * v + j, n * w, vc);
  scm_get_sample_center(f, n * u + i - 1, n * v + j, n * w, vn);
  scm_get_sample_center(f, n * u + i + 1, n * v + j, n * w, vs);
  scm_get_sample_center(f, n * u + i, n * v + j - 1, n * w, ve);
  scm_get_sample_center(f, n * u + i, n * v + j + 1, n * w, vw);
  double rc = p[((n + 2) * (i + 1) + (j + 1)) * c] * dr + r[0];
  double rn = p[((n + 2) * (i + 0) + (j + 1)) * c] * dr + r[0];
  double rs = p[((n + 2) * (i + 2) + (j + 1)) * c] * dr + r[0];
  double re = p[((n + 2) * (i + 1) + (j + 0)) * c] * dr + r[0];
  double rw = p[((n + 2) * (i + 1) + (j + 2)) * c] * dr + r[0];
  vn[0] *= rn;
  vn[1] *= rn;
  vn[2] *= rn;
  vs[0] *= rs;
  vs[1] *= rs;
  vs[2] *= rs;
  ve[0] *= re;
  ve[1] *= re;
  ve[2] *= re;
  vw[0] *= rw;
  vw[1] *= rw;
  vw[2] *= rw;
  vc[0] *= rc;
  vc[1] *= rc;
  vc[2] *= rc;
  double na[3];
  double nb[3];
  double nc[3];
  double nd[3];
  double nn[3];
  facenorm(vc, vn, ve, na);
  facenorm(vc, ve, vs, nb);
  facenorm(vc, vs, vw, nc);
  facenorm(vc, vw, vn, nd);
  nn[0] = na[0] + nb[0] + nc[0] + nd[0];
  nn[1] = na[1] + nb[1] + nc[1] + nd[1];
  nn[2] = na[2] + nb[2] + nc[2] + nd[2];
  normalize(nn);
  float *o = q + 3 * ((n + 2) * (i + 1) + (j + 1));
  o[0] = ((float)nn[0] + 1.f) / 2.f;
  o[1] = ((float)nn[1] + 1.f) / 2.f;
  o[2] = ((float)nn[2] + 1.f) / 2.f;
}


x86 assembly (clang, -O0):
<sampnorm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9,-0x20(%rbp)
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    0x20(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x4(%rbp),%edi
movslq -0x10(%rbp),%rsi
imul   -0x20(%rbp),%rsi
movslq -0x8(%rbp),%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rdx
imul   0x10(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
movslq -0x10(%rbp),%rcx
imul   0x18(%rbp),%rcx
lea    -0xc0(%rbp),%r8
mov    $0x0,%al
call   1030 <scm_get_sample_center@plt>
mov    -0x4(%rbp),%edi
movslq -0x10(%rbp),%rsi
imul   -0x20(%rbp),%rsi
movslq -0x8(%rbp),%rax
add    %rax,%rsi
sub    $0x1,%rsi
movslq -0x10(%rbp),%rdx
imul   0x10(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
movslq -0x10(%rbp),%rcx
imul   0x18(%rbp),%rcx
lea    -0x40(%rbp),%r8
mov    $0x0,%al
call   1030 <scm_get_sample_center@plt>
mov    -0x4(%rbp),%edi
movslq -0x10(%rbp),%rsi
imul   -0x20(%rbp),%rsi
movslq -0x8(%rbp),%rax
add    %rax,%rsi
add    $0x1,%rsi
movslq -0x10(%rbp),%rdx
imul   0x10(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
movslq -0x10(%rbp),%rcx
imul   0x18(%rbp),%rcx
lea    -0x60(%rbp),%r8
mov    $0x0,%al
call   1030 <scm_get_sample_center@plt>
mov    -0x4(%rbp),%edi
movslq -0x10(%rbp),%rsi
imul   -0x20(%rbp),%rsi
movslq -0x8(%rbp),%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rdx
imul   0x10(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
sub    $0x1,%rdx
movslq -0x10(%rbp),%rcx
imul   0x18(%rbp),%rcx
lea    -0x80(%rbp),%r8
mov    $0x0,%al
call   1030 <scm_get_sample_center@plt>
mov    -0x4(%rbp),%edi
movslq -0x10(%rbp),%rsi
imul   -0x20(%rbp),%rsi
movslq -0x8(%rbp),%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rdx
imul   0x10(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
add    $0x1,%rdx
movslq -0x10(%rbp),%rcx
imul   0x18(%rbp),%rcx
lea    -0xa0(%rbp),%r8
mov    $0x0,%al
call   1030 <scm_get_sample_center@plt>
mov    0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x0,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x0,%edx
add    %edx,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
add    %edx,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
lea    -0xc0(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x80(%rbp),%rdx
lea    -0x100(%rbp),%rcx
mov    $0x0,%al
call   1040 <facenorm@plt>
lea    -0xc0(%rbp),%rdi
lea    -0x80(%rbp),%rsi
lea    -0x60(%rbp),%rdx
lea    -0x120(%rbp),%rcx
mov    $0x0,%al
call   1040 <facenorm@plt>
lea    -0xc0(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0xa0(%rbp),%rdx
lea    -0x140(%rbp),%rcx
mov    $0x0,%al
call   1040 <facenorm@plt>
lea    -0xc0(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
lea    -0x40(%rbp),%rdx
lea    -0x160(%rbp),%rcx
mov    $0x0,%al
call   1040 <facenorm@plt>
movsd  -0x100(%rbp),%xmm0
ff
addsd  -0x120(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
addsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0x118(%rbp),%xmm0
ff
addsd  -0x138(%rbp),%xmm0
ff
addsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
addsd  -0x130(%rbp),%xmm0
ff
addsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
lea    -0x180(%rbp),%rdi
mov    $0x0,%al
call   1050 <normalize@plt>
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
movsd  -0x180(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  0x985(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x975(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x188(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0x178(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  0x956(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x946(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x188(%rbp),%rax
movss  %xmm0,0x4(%rax)
movsd  -0x170(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  0x926(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x916(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x188(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sampnorm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,%rbx
mov    %r8d,0xc(%rsp)
mov    0x1a0(%rsp),%rax
movss  0x4(%rax),%xmm0
subss  (%rax),%xmm0
movss  %xmm0,0x8(%rsp)
movslq %ecx,%rcx
mov    %rcx,0xb8(%rsp)
imul   %rcx,%rbx
movslq %esi,%rbp
lea    (%rbx,%rbp,1),%rsi
mov    %rsi,0xa8(%rsp)
mov    0x190(%rsp),%r14
imul   %rcx,%r14
movslq %edx,%rax
mov    %rax,0xb0(%rsp)
lea    (%r14,%rax,1),%r13
mov    0x198(%rsp),%r12
imul   %rcx,%r12
lea    0x30(%rsp),%r8
mov    %edi,%r15d
mov    %r13,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   1030 <scm_get_sample_center@plt>
lea    (%rbx,%rbp,1),%rsi
add    $0xffffffffffffffff,%rsi
lea    0x90(%rsp),%r8
mov    %r15d,%edi
mov    %r13,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   1030 <scm_get_sample_center@plt>
lea    (%rbx,%rbp,1),%rsi
add    $0x1,%rsi
lea    0x70(%rsp),%r8
mov    %r15d,%edi
mov    %r13,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   1030 <scm_get_sample_center@plt>
mov    0xb0(%rsp),%rbx
lea    (%r14,%rbx,1),%rdx
add    $0xffffffffffffffff,%rdx
lea    0x50(%rsp),%r8
mov    %r15d,%edi
mov    0xa8(%rsp),%r13
mov    %r13,%rsi
mov    %r12,%rcx
xor    %eax,%eax
call   1030 <scm_get_sample_center@plt>
lea    (%r14,%rbx,1),%rdx
add    $0x1,%rdx
lea    0xc0(%rsp),%r8
mov    %r15d,%edi
mov    %r13,%rsi
mov    %r12,%rcx
mov    %r8,%r12
xor    %eax,%eax
call   1030 <scm_get_sample_center@plt>
mov    0xb8(%rsp),%rdi
add    $0x2,%edi
lea    0x1(%rbp),%eax
imul   %edi,%eax
lea    (%rax,%rbx,1),%r14d
add    $0x1,%r14d
mov    %r14d,%ecx
mov    0xc(%rsp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
mov    0x1a0(%rsp),%rsi
movss  (%rsi),%xmm0
mov    0x1a8(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm1
movss  0x8(%rsp),%xmm6
mulss  %xmm6,%xmm1
mov    %edi,%ecx
imul   %ebp,%ecx
add    %ebx,%ecx
add    $0x1,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm2
mulss  %xmm6,%xmm2
addss  %xmm0,%xmm2
add    $0x2,%ebp
imul   %edi,%ebp
lea    (%rbx,%rbp,1),%ecx
add    $0x1,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm3
mulss  %xmm6,%xmm3
lea    (%rax,%rbx,1),%ecx
add    $0x2,%ecx
add    %ebx,%eax
imul   %edx,%eax
cltq
movss  (%rsi,%rax,4),%xmm4
mulss  %xmm6,%xmm4
imul   %edx,%ecx
movslq %ecx,%rax
mulss  (%rsi,%rax,4),%xmm6
cvtss2sd %xmm2,%xmm2
movaps %xmm2,%xmm5
movlhps %xmm2,%xmm5
mulpd  0x90(%rsp),%xmm5
movapd %xmm5,0x90(%rsp)
addss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
addss  %xmm0,%xmm3
cvtss2sd %xmm3,%xmm3
addss  %xmm0,%xmm4
mulsd  0xa0(%rsp),%xmm2
addss  %xmm0,%xmm6
movaps %xmm3,%xmm0
movlhps %xmm3,%xmm0
mulpd  0x70(%rsp),%xmm0
cvtss2sd %xmm4,%xmm4
movapd %xmm0,0x70(%rsp)
mulsd  0x80(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
movaps %xmm4,%xmm5
movlhps %xmm4,%xmm5
mulpd  0x50(%rsp),%xmm5
movsd  %xmm2,0xa0(%rsp)
movapd %xmm5,0x50(%rsp)
mulsd  0x60(%rsp),%xmm4
movsd  %xmm3,0x80(%rsp)
movaps %xmm0,%xmm2
movlhps %xmm0,%xmm2
mulpd  0xc0(%rsp),%xmm2
movsd  %xmm4,0x60(%rsp)
movapd %xmm2,0xc0(%rsp)
mulsd  0xd0(%rsp),%xmm0
movsd  %xmm0,0xd0(%rsp)
movaps %xmm1,%xmm0
movlhps %xmm1,%xmm0
mulpd  0x30(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
mulsd  0x40(%rsp),%xmm1
movsd  %xmm1,0x40(%rsp)
lea    0x140(%rsp),%rcx
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
lea    0x90(%rsp),%r15
mov    %r15,%rsi
lea    0x50(%rsp),%rbx
mov    %rbx,%rdx
xor    %eax,%eax
call   1040 <facenorm@plt>
lea    0x120(%rsp),%rcx
mov    %rbp,%rdi
mov    %rbx,%rsi
lea    0x70(%rsp),%rbx
mov    %rbx,%rdx
xor    %eax,%eax
call   1040 <facenorm@plt>
lea    0x100(%rsp),%rcx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1040 <facenorm@plt>
lea    0xe0(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1040 <facenorm@plt>
movapd 0x140(%rsp),%xmm0
addpd  0x120(%rsp),%xmm0
addpd  0x100(%rsp),%xmm0
addpd  0xe0(%rsp),%xmm0
movsd  0x150(%rsp),%xmm1
addsd  0x130(%rsp),%xmm1
addsd  0x110(%rsp),%xmm1
movapd %xmm0,0x10(%rsp)
addsd  0xf0(%rsp),%xmm1
movsd  %xmm1,0x20(%rsp)
lea    0x10(%rsp),%rdi
xor    %eax,%eax
call   1050 <normalize@plt>
lea    (%r14,%r14,2),%eax
cltq
movsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  0xb4d(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0xb45(%rip),%xmm2
mulss  %xmm2,%xmm0
mov    0x1b0(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
movsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
movsd  0x20(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,0x8(%rcx,%rax,4)
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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