void boundarymultiply(float *vector, int xlength, int ylength, int zlength,
                      float factor) {
  int k;
  int j;
  for (k = 0; k < ylength; k++)
    for (j = 0; j < xlength; j++)
      vector[k * xlength + j] *= factor;
  for (k = 0; k < zlength; k++) {
    for (j = 0; j < xlength; j++)
      vector[xlength * k * ylength + j] *= factor;
    for (j = 0; j < ylength; j++) {
      vector[xlength * (k * ylength + j)] *= factor;
      vector[xlength * (k * ylength + j + 1) - 1] *= factor;
    }
    for (j = 0; j < xlength; j++)
      vector[xlength * ((k + 1) * ylength - 1) + j] *= factor;
  }
  for (k = 0; k < ylength; k++)
    for (j = 0; j < xlength; j++)
      vector[((zlength - 1) * ylength + k) * xlength + j] *= factor;
}


x86 assembly (clang, -O0):
<boundarymultiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    117d <boundarymultiply+0x7d>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    116a <boundarymultiply+0x6a>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1130 <boundarymultiply+0x30>
jmp    116f <boundarymultiply+0x6f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111d <boundarymultiply+0x1d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a8 <boundarymultiply+0x1a8>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11d5 <boundarymultiply+0xd5>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1197 <boundarymultiply+0x97>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1248 <boundarymultiply+0x148>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x20(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11dc <boundarymultiply+0xdc>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1295 <boundarymultiply+0x195>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    124f <boundarymultiply+0x14f>
jmp    129a <boundarymultiply+0x19a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1184 <boundarymultiply+0x84>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1319 <boundarymultiply+0x219>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1306 <boundarymultiply+0x206>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12c2 <boundarymultiply+0x1c2>
jmp    130b <boundarymultiply+0x20b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12af <boundarymultiply+0x1af>
pop    %rbp
ret

x86 assembly (clang, -O2):
<boundarymultiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,-0x58(%rsp)
mov    %rdi,%r10
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
movslq %esi,%rax
mov    %rax,-0x50(%rsp)
mov    %edx,%r13d
mov    %esi,%eax
mov    %edx,-0x54(%rsp)
test   %edx,%edx
mov    %r13,-0x48(%rsp)
jle    1266 <boundarymultiply+0x166>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%r11
mov    %r11,%r14
shr    $0x3,%r14
add    $0x1,%r14
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %r14,%r9
and    %rcx,%r9
lea    0x30(%r10),%rbx
mov    -0x50(%rsp),%rcx
lea    0x0(,%rcx,4),%r12
xor    %r15d,%r15d
mov    %r10,%rdi
jmp    1193 <boundarymultiply+0x93>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
add    %r12,%rbx
add    %r12,%rdi
cmp    %r13,%r15
je     1266 <boundarymultiply+0x166>
test   %esi,%esi
jle    1180 <boundarymultiply+0x80>
cmp    $0x8,%esi
jae    11b0 <boundarymultiply+0xb0>
xor    %ecx,%ecx
jmp    1240 <boundarymultiply+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r11,%r11
je     125c <boundarymultiply+0x15c>
mov    %r9,%rbp
xor    %ecx,%ecx
xchg   %ax,%ax
movups -0x30(%rbx,%rcx,4),%xmm2
movups -0x20(%rbx,%rcx,4),%xmm3
movups -0x10(%rbx,%rcx,4),%xmm4
movups (%rbx,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbx,%rcx,4)
movups %xmm3,-0x20(%rbx,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbx,%rcx,4)
movups %xmm5,(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbp
jne    11c0 <boundarymultiply+0xc0>
test   $0x1,%r14b
je     122f <boundarymultiply+0x12f>
mov    %r15,%rdx
imul   -0x50(%rsp),%rdx
add    %rdx,%rcx
mov    -0x48(%rsp),%r13
movups (%r10,%rcx,4),%xmm2
movups 0x10(%r10,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r10,%rcx,4)
movups %xmm3,0x10(%r10,%rcx,4)
mov    %r8,%rcx
cmp    %rax,%r8
je     1180 <boundarymultiply+0x80>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1240 <boundarymultiply+0x140>
jmp    1180 <boundarymultiply+0x80>
xor    %ecx,%ecx
test   $0x1,%r14b
jne    1202 <boundarymultiply+0x102>
jmp    122f <boundarymultiply+0x12f>
cmpl   $0x0,-0x58(%rsp)
mov    -0x54(%rsp),%r14d
jle    1550 <boundarymultiply+0x450>
movslq %r14d,%rdx
mov    -0x58(%rsp),%ecx
mov    %rcx,-0x8(%rsp)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x20(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x28(%rsp)
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %rdi,%rcx
mov    %rdi,-0x30(%rsp)
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%rdi
mov    %rdi,-0x38(%rsp)
lea    0x30(%r10),%rcx
mov    %rcx,-0x10(%rsp)
mov    %r14d,%ecx
imul   %esi,%ecx
mov    %ecx,-0x3c(%rsp)
mov    -0x50(%rsp),%rdi
lea    0x0(,%rdi,4),%rcx
mov    %rdx,%r11
imul   %rdi,%r11
shl    $0x2,%r11
mov    %rdx,-0x18(%rsp)
add    $0xffffffffffffffff,%rdx
imul   %rdi,%rdx
lea    (%r10,%rdx,4),%rbp
add    $0x30,%rbp
lea    (%r10,%rdx,4),%r9
xor    %r13d,%r13d
mov    %r10,%r15
xor    %r12d,%r12d
jmp    1329 <boundarymultiply+0x229>
add    -0x3c(%rsp),%r13d
add    %r11,%r15
add    %r11,%rbp
add    %r11,%r9
cmp    -0x8(%rsp),%r12
je     1550 <boundarymultiply+0x450>
test   %esi,%esi
jle    1407 <boundarymultiply+0x307>
movslq %r13d,%r8
cmp    $0x8,%esi
jae    1340 <boundarymultiply+0x240>
xor    %edx,%edx
jmp    13ea <boundarymultiply+0x2ea>
cmpq   $0x0,-0x28(%rsp)
je     152e <boundarymultiply+0x42e>
mov    -0x10(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
mov    -0x38(%rsp),%rbx
xor    %r14d,%r14d
nopl   (%rax)
movups -0x30(%rdx,%r14,4),%xmm2
movups -0x20(%rdx,%r14,4),%xmm3
movups -0x10(%rdx,%r14,4),%xmm4
movups (%rdx,%r14,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rdx,%r14,4)
movups %xmm3,-0x20(%rdx,%r14,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rdx,%r14,4)
movups %xmm5,(%rdx,%r14,4)
add    $0x10,%r14
add    $0xfffffffffffffffe,%rbx
jne    1360 <boundarymultiply+0x260>
testb  $0x1,-0x30(%rsp)
je     13d8 <boundarymultiply+0x2d8>
mov    %r12d,%edx
imul   -0x54(%rsp),%edx
imul   %esi,%edx
movslq %edx,%rdx
add    %rdx,%r14
movups (%r10,%r14,4),%xmm2
movups 0x10(%r10,%r14,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r10,%r14,4)
movups %xmm3,0x10(%r10,%r14,4)
mov    -0x20(%rsp),%rdi
mov    %rdi,%rdx
cmp    %rax,%rdi
mov    -0x54(%rsp),%r14d
je     1407 <boundarymultiply+0x307>
lea    (%r10,%r8,4),%rdi
xchg   %ax,%ax
movss  (%rdi,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    13f0 <boundarymultiply+0x2f0>
mov    -0x48(%rsp),%rdx
mov    %r15,%rdi
test   %r14d,%r14d
jle    1445 <boundarymultiply+0x345>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdi),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi)
movss  -0x4(%rdi,%rcx,1),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rdi,%rcx,1)
add    %rcx,%rdi
add    $0xffffffffffffffff,%rdx
jne    1420 <boundarymultiply+0x320>
add    $0x1,%r12
test   %esi,%esi
jle    1310 <boundarymultiply+0x210>
cmp    $0x8,%esi
jae    1460 <boundarymultiply+0x360>
xor    %edx,%edx
jmp    1510 <boundarymultiply+0x410>
nopl   (%rax)
cmpq   $0x0,-0x28(%rsp)
je     1541 <boundarymultiply+0x441>
mov    -0x38(%rsp),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rbp,%rdx,4),%xmm2
movups -0x20(%rbp,%rdx,4),%xmm3
movups -0x10(%rbp,%rdx,4),%xmm4
movups 0x0(%rbp,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbp,%rdx,4)
movups %xmm3,-0x20(%rbp,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbp,%rdx,4)
movups %xmm5,0x0(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    1480 <boundarymultiply+0x380>
testb  $0x1,-0x30(%rsp)
je     14f7 <boundarymultiply+0x3f7>
mov    %r12,%rdi
imul   -0x18(%rsp),%rdi
add    $0xffffffffffffffff,%rdi
imul   -0x50(%rsp),%rdi
add    %rdi,%rdx
movups (%r10,%rdx,4),%xmm2
movups 0x10(%r10,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r10,%rdx,4)
movups %xmm3,0x10(%r10,%rdx,4)
mov    -0x20(%rsp),%rdi
mov    %rdi,%rdx
cmp    %rax,%rdi
je     1310 <boundarymultiply+0x210>
nopl   0x0(%rax,%rax,1)
movss  (%r9,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%r9,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1510 <boundarymultiply+0x410>
jmp    1310 <boundarymultiply+0x210>
xor    %r14d,%r14d
testb  $0x1,-0x30(%rsp)
jne    13ab <boundarymultiply+0x2ab>
jmp    13d8 <boundarymultiply+0x2d8>
xor    %edx,%edx
testb  $0x1,-0x30(%rsp)
jne    14c5 <boundarymultiply+0x3c5>
jmp    14f7 <boundarymultiply+0x3f7>
test   %r14d,%r14d
movabs $0x3ffffffffffffffe,%r15
ff ff 3f
mov    -0x50(%rsp),%r13
mov    -0x48(%rsp),%rdx
jle    16a8 <boundarymultiply+0x5a8>
mov    -0x58(%rsp),%ecx
add    $0xffffffff,%ecx
imul   %r14d,%ecx
movslq %ecx,%r8
mov    %eax,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%r9
mov    %r9,%r11
shr    $0x3,%r11
add    $0x1,%r11
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
and    %r11,%r15
mov    %r13,%rcx
imul   %r8,%rcx
lea    (%r10,%rcx,4),%rbx
add    $0x30,%rbx
lea    0x0(,%r13,4),%r12
lea    (%r10,%rcx,4),%rbp
xor    %edi,%edi
jmp    15d3 <boundarymultiply+0x4d3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    %r12,%rbx
add    %r12,%rbp
cmp    %rdx,%rdi
je     16a8 <boundarymultiply+0x5a8>
test   %esi,%esi
jle    15c0 <boundarymultiply+0x4c0>
cmp    $0x8,%esi
jae    15f0 <boundarymultiply+0x4f0>
xor    %ecx,%ecx
jmp    1680 <boundarymultiply+0x580>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r9,%r9
je     169e <boundarymultiply+0x59e>
mov    %r15,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movups -0x30(%rbx,%rdx,4),%xmm2
movups -0x20(%rbx,%rdx,4),%xmm3
movups -0x10(%rbx,%rdx,4),%xmm4
movups (%rbx,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbx,%rdx,4)
movups %xmm3,-0x20(%rbx,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbx,%rdx,4)
movups %xmm5,(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1600 <boundarymultiply+0x500>
test   $0x1,%r11b
je     1669 <boundarymultiply+0x569>
lea    (%rdi,%r8,1),%rcx
imul   %r13,%rcx
add    %rcx,%rdx
movups (%r10,%rdx,4),%xmm2
movups 0x10(%r10,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r10,%rdx,4)
movups %xmm3,0x10(%r10,%rdx,4)
mov    %r14,%rcx
cmp    %rax,%r14
mov    -0x48(%rsp),%rdx
je     15c0 <boundarymultiply+0x4c0>
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1680 <boundarymultiply+0x580>
jmp    15c0 <boundarymultiply+0x4c0>
xor    %edx,%edx
test   $0x1,%r11b
jne    1642 <boundarymultiply+0x542>
jmp    1669 <boundarymultiply+0x569>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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