void simplex_reflect(pt, rf, n, worst, wait) float (*pt)[], (*rf)[], wait;
int n, worst;
{
  int i, j;
  for (j = 0; j < n; j++)
    (*rf)[j] = 0.;
  for (i = 0; i < worst; i++) {
    for (j = 0; j < n; j++)
      (*rf)[j] += (*pt)[i * n + j];
  }
  for (i = worst + 1; i < n + 1; i++) {
    for (j = 0; j < n; j++)
      (*rf)[j] += (*pt)[i * n + j];
  }
  for (j = 0; j < n; j++) {
    (*rf)[j] /= n;
    (*rf)[j] = (*rf)[j] + wait * ((*rf)[j] - (*pt)[worst * n + j]);
  }
}


x86 assembly (clang, -O0):
<simplex_reflect>:
push   %rbp
mov    %rsp,%rbp
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    114c <simplex_reflect+0x4c>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1122 <simplex_reflect+0x22>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11bb <simplex_reflect+0xbb>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a8 <simplex_reflect+0xa8>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1166 <simplex_reflect+0x66>
jmp    11ad <simplex_reflect+0xad>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1153 <simplex_reflect+0x53>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1231 <simplex_reflect+0x131>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121e <simplex_reflect+0x11e>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11dc <simplex_reflect+0xdc>
jmp    1223 <simplex_reflect+0x123>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c4 <simplex_reflect+0xc4>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b7 <simplex_reflect+0x1b7>
cvtsi2ssl -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1238 <simplex_reflect+0x138>
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplex_reflect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movaps %xmm0,%xmm4
mov    %ecx,0xc(%rsp)
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %edx,%ebp
test   %edx,%edx
mov    %rdi,0x10(%rsp)
jle    1159 <simplex_reflect+0x49>
lea    0x0(,%rbp,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
movsd  %xmm4,0x18(%rsp)
call   1030 <memset@plt>
movsd  0x18(%rsp),%xmm4
mov    0x10(%rsp),%rdi
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rax,0x48(%rsp)
movslq %r12d,%r14
cmpl   $0x0,0xc(%rsp)
jle    1341 <simplex_reflect+0x231>
mov    0xc(%rsp),%r15d
lea    (%rbx,%rbp,4),%rax
mov    %rax,0x18(%rsp)
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x20(%rsp)
mov    %rbp,%r10
neg    %r10
lea    0x30(%rdi),%r13
lea    0x0(,%r14,4),%rsi
lea    0x4(%rdi),%rdx
xor    %r9d,%r9d
mov    %r10,0x28(%rsp)
jmp    11f3 <simplex_reflect+0xe3>
nopl   0x0(%rax)
add    $0x1,%r9
add    %rsi,%r13
add    %rsi,%rdx
cmp    %r15,%r9
je     1341 <simplex_reflect+0x231>
test   %r12d,%r12d
jle    11e0 <simplex_reflect+0xd0>
mov    %r9,%r8
imul   %r14,%r8
cmp    $0x8,%r12d
jb     121d <simplex_reflect+0x10d>
lea    (%r8,%rbp,1),%rax
lea    (%rdi,%rax,4),%rax
cmp    %rbx,%rax
jbe    127f <simplex_reflect+0x16f>
lea    (%rdi,%r8,4),%rax
cmp    0x18(%rsp),%rax
jae    127f <simplex_reflect+0x16f>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%bpl
je     1242 <simplex_reflect+0x132>
add    %rcx,%r8
movss  (%rdi,%r8,4),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r10,%rcx
je     11e0 <simplex_reflect+0xd0>
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rdx,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%rdx,%rax,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1250 <simplex_reflect+0x140>
jmp    11e0 <simplex_reflect+0xd0>
cmpq   $0x0,0x38(%rsp)
je     12ee <simplex_reflect+0x1de>
mov    0x20(%rsp),%r11
xor    %r10d,%r10d
nop
movups -0x30(%r13,%r10,4),%xmm0
movups -0x20(%r13,%r10,4),%xmm1
movups (%rbx,%r10,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rbx,%r10,4),%xmm1
movups 0x30(%rbx,%r10,4),%xmm3
movups %xmm2,(%rbx,%r10,4)
movups %xmm0,0x10(%rbx,%r10,4)
movups -0x10(%r13,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups 0x0(%r13,%r10,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rbx,%r10,4)
movups %xmm1,0x30(%rbx,%r10,4)
add    $0x10,%r10
add    $0xfffffffffffffffe,%r11
jne    1290 <simplex_reflect+0x180>
jmp    12f1 <simplex_reflect+0x1e1>
xor    %r10d,%r10d
testb  $0x1,0x30(%rsp)
mov    0x10(%rsp),%rdi
je     1326 <simplex_reflect+0x216>
lea    (%r10,%r8,1),%rax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups (%rbx,%r10,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rbx,%r10,4)
movups %xmm0,0x10(%rbx,%r10,4)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %rbp,%rax
mov    0x28(%rsp),%r10
je     11e0 <simplex_reflect+0xd0>
jmp    121f <simplex_reflect+0x10f>
cmp    %r12d,0xc(%rsp)
jge    156c <simplex_reflect+0x45c>
movslq 0xc(%rsp),%r11
lea    (%rbx,%rbp,4),%rax
mov    %rax,0x18(%rsp)
lea    0x1(%r11),%rdx
imul   %r14,%rdx
lea    (%rdx,%rbp,1),%r13
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x30(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x28(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rsi
mov    %rcx,0x20(%rsp)
and    %rcx,0x48(%rsp)
mov    %rbp,%rax
neg    %rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rdx,4),%r8
add    $0x30,%r8
lea    0x0(,%r14,4),%r15
mov    %rdx,0x40(%rsp)
lea    (%rcx,%rdx,4),%r10
add    $0x4,%r10
xor    %r9d,%r9d
mov    %r13,0x38(%rsp)
mov    %rax,0x50(%rsp)
jmp    13e3 <simplex_reflect+0x2d3>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    %r15,%r8
add    %r15,%r10
cmp    %r14,%r11
je     156c <simplex_reflect+0x45c>
add    $0x1,%r11
test   %r12d,%r12d
jle    13d0 <simplex_reflect+0x2c0>
mov    %r11,%rdx
imul   %r14,%rdx
cmp    $0x8,%r12d
jb     1422 <simplex_reflect+0x312>
mov    %r9,%rcx
imul   %r14,%rcx
lea    (%rcx,%r13,1),%rdi
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdi,4),%rdi
cmp    %rbx,%rdi
jbe    1491 <simplex_reflect+0x381>
add    0x40(%rsp),%rcx
lea    (%rsi,%rcx,4),%rcx
cmp    0x18(%rsp),%rcx
jae    1491 <simplex_reflect+0x381>
xor    %ecx,%ecx
mov    %rcx,%rdi
test   $0x1,%bpl
je     144b <simplex_reflect+0x33b>
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
movss  (%rsi,%rdx,4),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
mov    %rcx,%rdi
or     $0x1,%rdi
not    %rcx
cmp    %rax,%rcx
je     13d0 <simplex_reflect+0x2c0>
nopw   0x0(%rax,%rax,1)
movss  -0x4(%r10,%rdi,4),%xmm0
addss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
movss  (%r10,%rdi,4),%xmm0
addss  0x4(%rbx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rbx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rbp
jne    1460 <simplex_reflect+0x350>
jmp    13d0 <simplex_reflect+0x2c0>
cmpq   $0x0,0x28(%rsp)
je     1560 <simplex_reflect+0x450>
mov    0x48(%rsp),%rdi
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r8,%r13,4),%xmm0
movups -0x20(%r8,%r13,4),%xmm1
movups (%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rbx,%r13,4),%xmm1
movups 0x30(%rbx,%r13,4),%xmm3
movups %xmm2,(%rbx,%r13,4)
movups %xmm0,0x10(%rbx,%r13,4)
movups -0x10(%r8,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups (%r8,%r13,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rbx,%r13,4)
movups %xmm1,0x30(%rbx,%r13,4)
add    $0x10,%r13
add    $0xfffffffffffffffe,%rdi
jne    14b0 <simplex_reflect+0x3a0>
testb  $0x1,0x20(%rsp)
je     1540 <simplex_reflect+0x430>
lea    (%rdx,%r13,1),%rcx
mov    0x10(%rsp),%rsi
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups (%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rbx,%r13,4)
movups %xmm0,0x10(%rbx,%r13,4)
mov    0x30(%rsp),%rax
mov    %rax,%rcx
cmp    %rbp,%rax
mov    0x38(%rsp),%r13
mov    0x50(%rsp),%rax
je     13d0 <simplex_reflect+0x2c0>
jmp    1424 <simplex_reflect+0x314>
xor    %r13d,%r13d
testb  $0x1,0x20(%rsp)
jne    1512 <simplex_reflect+0x402>
jmp    1540 <simplex_reflect+0x430>
test   %r12d,%r12d
mov    0x10(%rsp),%rcx
jle    15ec <simplex_reflect+0x4dc>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %r12d,%xmm1
mov    0xc(%rsp),%eax
imul   %r12d,%eax
movslq %eax,%r9
cmp    $0x4,%r12d
jb     15b0 <simplex_reflect+0x4a0>
lea    (%r9,%rbp,1),%rax
lea    (%rcx,%rax,4),%rax
cmp    %rbx,%rax
jbe    15fb <simplex_reflect+0x4eb>
lea    (%rbx,%rbp,4),%rax
lea    (%rcx,%r9,4),%rdx
cmp    %rax,%rdx
jae    15fb <simplex_reflect+0x4eb>
xor    %eax,%eax
lea    (%rcx,%r9,4),%rcx
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rax,4)
movaps %xmm2,%xmm3
subss  (%rcx,%rax,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    15c0 <simplex_reflect+0x4b0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebp,%eax
and    $0xfffffffc,%eax
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     16c3 <simplex_reflect+0x5b3>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rcx,%r9,4),%rsi
add    $0x10,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdx,4),%xmm4
movups 0x10(%rbx,%rdx,4),%xmm5
divps  %xmm3,%xmm4
movups %xmm4,(%rbx,%rdx,4)
movups -0x10(%rsi,%rdx,4),%xmm6
movaps %xmm4,%xmm7
subps  %xmm6,%xmm7
mulps  %xmm2,%xmm7
addps  %xmm4,%xmm7
movups %xmm7,(%rbx,%rdx,4)
divps  %xmm3,%xmm5
movups %xmm5,0x10(%rbx,%rdx,4)
movups (%rsi,%rdx,4),%xmm4
movaps %xmm5,%xmm6
subps  %xmm4,%xmm6
mulps  %xmm2,%xmm6
addps  %xmm5,%xmm6
movups %xmm6,0x10(%rbx,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1640 <simplex_reflect+0x530>
test   $0x1,%r8b
je     16b5 <simplex_reflect+0x5a5>
movups (%rbx,%rdx,4),%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rbx,%rdx,4)
lea    (%rdx,%r9,1),%rsi
movups (%rcx,%rsi,4),%xmm3
movaps %xmm4,%xmm5
subps  %xmm3,%xmm5
mulps  %xmm5,%xmm2
addps  %xmm4,%xmm2
movups %xmm2,(%rbx,%rdx,4)
cmp    %rbp,%rax
je     15ec <simplex_reflect+0x4dc>
jmp    15b2 <simplex_reflect+0x4a2>
xor    %edx,%edx
test   $0x1,%r8b
jne    1692 <simplex_reflect+0x582>
jmp    16b5 <simplex_reflect+0x5a5>

LLVM IR (-O0):
define void @simplex_reflect([0 x float]* %0, [0 x float]* %1, i32 %2, i32 %3, double %4) {
%6 = alloca [0 x float]*
%7 = alloca [0 x float]*
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
%11 = alloca i32
%12 = alloca i32
%13 = fptrunc double %4 to float
store [0 x float]* %0, [0 x float]** %6
store [0 x float]* %1, [0 x float]** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store float %13, float* %10
store i32 0, i32* %12
br label %14
14: ; preds = %23, %5
%15 = load i32, i32* %12
%16 = load i32, i32* %8
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %26
18: ; preds = %14
%19 = load [0 x float]*, [0 x float]** %7
%20 = load i32, i32* %12
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [0 x float], [0 x float]* %19, i64 0, i64 %21
store float 0.000000e+00, float* %22
br label %23
23: ; preds = %18
%24 = load i32, i32* %12
%25 = add nsw i32 %24, 1
store i32 %25, i32* %12
br label %14
26: ; preds = %14
store i32 0, i32* %11
br label %27
27: ; preds = %56, %26
%28 = load i32, i32* %11
%29 = load i32, i32* %9
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %59
31: ; preds = %27
store i32 0, i32* %12
br label %32
32: ; preds = %52, %31
%33 = load i32, i32* %12
%34 = load i32, i32* %8
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %55
36: ; preds = %32
%37 = load [0 x float]*, [0 x float]** %6
%38 = load i32, i32* %11
%39 = load i32, i32* %8
%40 = mul nsw i32 %38, %39
%41 = load i32, i32* %12
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [0 x float], [0 x float]* %37, i64 0, i64 %43
%45 = load float, float* %44
%46 = load [0 x float]*, [0 x float]** %7
%47 = load i32, i32* %12
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [0 x float], [0 x float]* %46, i64 0, i64 %48
%50 = load float, float* %49
%51 = fadd float %50, %45
store float %51, float* %49
br label %52
52: ; preds = %36
%53 = load i32, i32* %12
%54 = add nsw i32 %53, 1
store i32 %54, i32* %12
br label %32
55: ; preds = %32
br label %56
56: ; preds = %55
%57 = load i32, i32* %11
%58 = add nsw i32 %57, 1
store i32 %58, i32* %11
br label %27
59: ; preds = %27
%60 = load i32, i32* %9
%61 = add nsw i32 %60, 1
store i32 %61, i32* %11
br label %62
62: ; preds = %92, %59
%63 = load i32, i32* %11
%64 = load i32, i32* %8
%65 = add nsw i32 %64, 1
%66 = icmp slt i32 %63, %65
br i1 %66, label %67, label %95
67: ; preds = %62
store i32 0, i32* %12
br label %68
68: ; preds = %88, %67
%69 = load i32, i32* %12
%70 = load i32, i32* %8
%71 = icmp slt i32 %69, %70
br i1 %71, label %72, label %91
72: ; preds = %68
%73 = load [0 x float]*, [0 x float]** %6
%74 = load i32, i32* %11
%75 = load i32, i32* %8
%76 = mul nsw i32 %74, %75
%77 = load i32, i32* %12
%78 = add nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [0 x float], [0 x float]* %73, i64 0, i64 %79
%81 = load float, float* %80
%82 = load [0 x float]*, [0 x float]** %7
%83 = load i32, i32* %12
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [0 x float], [0 x float]* %82, i64 0, i64 %84
%86 = load float, float* %85
%87 = fadd float %86, %81
store float %87, float* %85
br label %88
88: ; preds = %72
%89 = load i32, i32* %12
%90 = add nsw i32 %89, 1
store i32 %90, i32* %12
br label %68
91: ; preds = %68
br label %92
92: ; preds = %91
%93 = load i32, i32* %11
%94 = add nsw i32 %93, 1
store i32 %94, i32* %11
br label %62
95: ; preds = %62
store i32 0, i32* %12
br label %96
96: ; preds = %135, %95
%97 = load i32, i32* %12
%98 = load i32, i32* %8
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %138
100: ; preds = %96
%101 = load i32, i32* %8
%102 = sitofp i32 %101 to float
%103 = load [0 x float]*, [0 x float]** %7
%104 = load i32, i32* %12
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [0 x float], [0 x float]* %103, i64 0, i64 %105
%107 = load float, float* %106
%108 = fdiv float %107, %102
store float %108, float* %106
%109 = load [0 x float]*, [0 x float]** %7
%110 = load i32, i32* %12
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [0 x float], [0 x float]* %109, i64 0, i64 %111
%113 = load float, float* %112
%114 = load float, float* %10
%115 = load [0 x float]*, [0 x float]** %7
%116 = load i32, i32* %12
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [0 x float], [0 x float]* %115, i64 0, i64 %117
%119 = load float, float* %118
%120 = load [0 x float]*, [0 x float]** %6
%121 = load i32, i32* %9
%122 = load i32, i32* %8
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %12
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [0 x float], [0 x float]* %120, i64 0, i64 %126
%128 = load float, float* %127
%129 = fsub float %119, %128
%130 = call float @llvm.fmuladd.f32(float %114, float %129, float %113)
%131 = load [0 x float]*, [0 x float]** %7
%132 = load i32, i32* %12
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [0 x float], [0 x float]* %131, i64 0, i64 %133
store float %130, float* %134
br label %135
135: ; preds = %100
%136 = load i32, i32* %12
%137 = add nsw i32 %136, 1
store i32 %137, i32* %12
br label %96
138: ; preds = %96
ret void
}

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