float *feature_update(const float *profa, const float *profb, float *newp,
                      int *path, int stride) {
  int i, c;
  c = 1;
  while (path[c] != 3) {
    if (!path[c]) {
      for (i = stride; i--;) {
        newp[i] = profa[i] + profb[i];
      }
      profa += stride;
      profb += stride;
    }
    if (path[c] & 1) {
      for (i = stride; i--;) {
        newp[i] = profb[i];
      }
      profb += stride;
    }
    if (path[c] & 2) {
      for (i = stride; i--;) {
        newp[i] = profa[i];
      }
      profa += stride;
    }
    newp += stride;
    c++;
  }
  for (i = stride; i--;) {
    newp[i] = profa[i] + profb[i];
  }
  newp -= path[0] * stride;
  return newp;
}


x86 assembly (clang, -O0):
<feature_update>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
je     12a0 <feature_update+0x1a0>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11b3 <feature_update+0xb3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
cmp    $0x0,%eax
je     1189 <feature_update+0x89>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1149 <feature_update+0x49>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1218 <feature_update+0x118>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
cmp    $0x0,%eax
je     1203 <feature_update+0x103>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    11d0 <feature_update+0xd0>
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     127d <feature_update+0x17d>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
cmp    $0x0,%eax
je     1268 <feature_update+0x168>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1235 <feature_update+0x135>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    111f <feature_update+0x1f>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
cmp    $0x0,%eax
je     12e6 <feature_update+0x1e6>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    12a6 <feature_update+0x1a6>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<feature_update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r10
movslq %r8d,%r9
lea    -0x1(%r9),%r13d
mov    %r13,%r11
not    %r11
add    %r9,%r11
lea    0x1(%r13),%rax
mov    %rax,-0x40(%rsp)
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,-0x60(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r9,%rbx
mov    %rax,-0x48(%rsp)
sub    %rax,%rbx
mov    %rbx,-0x50(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x70(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x58(%rsp)
lea    0x0(,%r9,4),%rax
mov    %rax,-0x10(%rsp)
lea    -0x4(%r9),%rax
mov    %rax,-0x68(%rsp)
lea    (%rdx,%r9,4),%r14
add    $0xfffffffffffffff0,%r14
mov    $0x1,%r12d
xor    %r15d,%r15d
mov    %rdx,-0x8(%rsp)
mov    %rdx,%rax
mov    %r10,-0x78(%rsp)
mov    %r11,-0x38(%rsp)
mov    %r13,-0x20(%rsp)
jmp    11b7 <feature_update+0xb7>
nopl   0x0(%rax)
lea    (%rdi,%r9,4),%rdi
mov    -0x10(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%r12
add    $0x1,%r15
add    %rcx,%r14
mov    %r15,%rbp
imul   %r9,%rbp
lea    (%r11,%rbp,1),%rdx
mov    -0x8(%rsp),%rcx
lea    (%rcx,%rdx,4),%rdx
mov    %rdx,-0x28(%rsp)
add    %r9,%rbp
lea    (%rcx,%rbp,4),%rcx
mov    %rcx,-0x30(%rsp)
mov    %r12,-0x18(%rsp)
mov    (%r10,%r12,4),%r12d
test   %r12d,%r12d
je     1210 <feature_update+0x110>
cmp    $0x3,%r12d
je     16d7 <feature_update+0x5d7>
test   $0x1,%r12b
jne    1405 <feature_update+0x305>
test   $0x2,%r12b
jne    1559 <feature_update+0x459>
mov    -0x18(%rsp),%r12
jmp    11a4 <feature_update+0xa4>
nop
test   %r8d,%r8d
je     13f3 <feature_update+0x2f3>
mov    %r9,%rbp
cmp    $0x7,%r13d
jae    1263 <feature_update+0x163>
lea    -0x1(%rbp),%r11d
mov    %ebp,%edx
and    $0x3,%edx
je     1391 <feature_update+0x291>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbp),%rbx
movss  -0x4(%rdi,%rbp,4),%xmm0
addss  -0x4(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
mov    %rbx,%rbp
add    $0xffffffff,%edx
jne    1240 <feature_update+0x140>
jmp    1394 <feature_update+0x294>
lea    (%rdi,%r11,4),%rdx
lea    (%rdi,%r9,4),%rbp
lea    (%rsi,%r11,4),%r10
lea    (%rsi,%r9,4),%rbx
mov    -0x28(%rsp),%rcx
cmp    %rbp,%rcx
setb   %r13b
mov    -0x30(%rsp),%rbp
cmp    %rbp,%rdx
setb   %r11b
cmp    %rbx,%rcx
setb   %dl
cmp    %rbp,%r10
mov    -0x78(%rsp),%r10
setb   %bl
mov    %r9,%rbp
test   %r11b,%r13b
mov    -0x38(%rsp),%r11
mov    -0x20(%rsp),%r13
jne    1222 <feature_update+0x122>
mov    %r9,%rbp
and    %bl,%dl
jne    1222 <feature_update+0x122>
cmpq   $0x0,-0x60(%rsp)
je     16a0 <feature_update+0x5a0>
mov    -0x68(%rsp),%rdx
lea    (%rsi,%rdx,4),%rbx
lea    (%rdi,%rdx,4),%rdx
mov    -0x58(%rsp),%rbp
xor    %r13d,%r13d
xchg   %ax,%ax
movups -0x10(%rdx,%r13,4),%xmm0
movups (%rdx,%r13,4),%xmm1
movups -0x10(%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups (%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%r14,%r13,4)
movups %xmm2,-0x10(%r14,%r13,4)
movups -0x30(%rdx,%r13,4),%xmm0
movups -0x20(%rdx,%r13,4),%xmm1
movups -0x30(%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,-0x20(%r14,%r13,4)
movups %xmm2,-0x30(%r14,%r13,4)
add    $0xfffffffffffffff0,%r13
add    $0xfffffffffffffffe,%rbp
jne    12e0 <feature_update+0x1e0>
neg    %r13
testb  $0x1,-0x70(%rsp)
je     1375 <feature_update+0x275>
not    %r13
add    %r9,%r13
movups -0x1c(%rdi,%r13,4),%xmm0
movups -0xc(%rdi,%r13,4),%xmm1
movups -0x1c(%rsi,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups -0xc(%rsi,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,-0xc(%rax,%r13,4)
movups %xmm2,-0x1c(%rax,%r13,4)
mov    -0x50(%rsp),%rbp
mov    -0x48(%rsp),%rdx
cmp    %rdx,-0x40(%rsp)
mov    -0x20(%rsp),%r13
jne    1222 <feature_update+0x122>
jmp    13f3 <feature_update+0x2f3>
mov    %rbp,%rbx
cmp    $0x3,%r11d
mov    -0x38(%rsp),%r11
jb     13f3 <feature_update+0x2f3>
nop
movss  -0x4(%rdi,%rbx,4),%xmm0
addss  -0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbx,4)
movss  -0x8(%rdi,%rbx,4),%xmm0
addss  -0x8(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rbx,4)
movss  -0xc(%rdi,%rbx,4),%xmm0
addss  -0xc(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rbx,4)
movss  -0x10(%rdi,%rbx,4),%xmm0
addss  -0x10(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0x10(%rax,%rbx,4)
lea    -0x4(%rbx),%rdx
mov    %rdx,%rbx
test   %edx,%edx
jne    13a0 <feature_update+0x2a0>
lea    (%rdi,%r9,4),%rdi
lea    (%rsi,%r9,4),%rsi
test   $0x1,%r12b
je     11fe <feature_update+0xfe>
test   %r8d,%r8d
je     154b <feature_update+0x44b>
mov    %r9,%rbx
cmp    $0x7,%r13d
jb     14d0 <feature_update+0x3d0>
lea    (%rsi,%r9,4),%rdx
cmp    %rdx,-0x28(%rsp)
jae    1438 <feature_update+0x338>
lea    (%rsi,%r11,4),%rdx
mov    %r9,%rbx
cmp    -0x30(%rsp),%rdx
jb     14d0 <feature_update+0x3d0>
cmpq   $0x0,-0x60(%rsp)
je     16b3 <feature_update+0x5b3>
mov    -0x68(%rsp),%rcx
lea    (%rsi,%rcx,4),%rdx
mov    -0x58(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups %xmm1,(%r14,%rbx,4)
movups %xmm0,-0x10(%r14,%rbx,4)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups %xmm1,-0x20(%r14,%rbx,4)
movups %xmm0,-0x30(%r14,%rbx,4)
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1460 <feature_update+0x360>
neg    %rbx
testb  $0x1,-0x70(%rsp)
je     14b8 <feature_update+0x3b8>
not    %rbx
add    %r9,%rbx
movups -0x1c(%rsi,%rbx,4),%xmm0
movups -0xc(%rsi,%rbx,4),%xmm1
movups %xmm1,-0xc(%rax,%rbx,4)
movups %xmm0,-0x1c(%rax,%rbx,4)
mov    -0x50(%rsp),%rbx
mov    -0x48(%rsp),%rcx
cmp    %rcx,-0x40(%rsp)
je     154b <feature_update+0x44b>
nopl   (%rax)
lea    -0x1(%rbx),%r11d
mov    %ebx,%edx
and    $0x3,%edx
je     14fa <feature_update+0x3fa>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%rbp
movss  -0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbx,4)
mov    %rbp,%rbx
add    $0xffffffff,%edx
jne    14e0 <feature_update+0x3e0>
jmp    14fd <feature_update+0x3fd>
mov    %rbx,%rbp
cmp    $0x3,%r11d
mov    -0x38(%rsp),%r11
jb     154b <feature_update+0x44b>
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
movss  -0x8(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x8(%rax,%rbp,4)
movss  -0xc(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0xc(%rax,%rbp,4)
movss  -0x10(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x10(%rax,%rbp,4)
lea    -0x4(%rbp),%rdx
mov    %rdx,%rbp
test   %edx,%edx
jne    1510 <feature_update+0x410>
lea    (%rsi,%r9,4),%rsi
test   $0x2,%r12b
je     1208 <feature_update+0x108>
test   %r8d,%r8d
mov    -0x18(%rsp),%r12
je     11a0 <feature_update+0xa0>
mov    %r9,%rbp
cmp    $0x7,%r13d
jb     1620 <feature_update+0x520>
lea    (%rdi,%r9,4),%rdx
cmp    %rdx,-0x28(%rsp)
jae    1591 <feature_update+0x491>
lea    (%rdi,%r11,4),%rdx
mov    %r9,%rbp
cmp    -0x30(%rsp),%rdx
jb     1620 <feature_update+0x520>
cmpq   $0x0,-0x60(%rsp)
je     16c5 <feature_update+0x5c5>
mov    -0x68(%rsp),%rcx
lea    (%rdi,%rcx,4),%rdx
mov    -0x58(%rsp),%rbp
xor    %ebx,%ebx
nopl   (%rax)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups %xmm1,(%r14,%rbx,4)
movups %xmm0,-0x10(%r14,%rbx,4)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups %xmm1,-0x20(%r14,%rbx,4)
movups %xmm0,-0x30(%r14,%rbx,4)
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rbp
jne    15b0 <feature_update+0x4b0>
neg    %rbx
testb  $0x1,-0x70(%rsp)
je     1608 <feature_update+0x508>
not    %rbx
add    %r9,%rbx
movups -0x1c(%rdi,%rbx,4),%xmm0
movups -0xc(%rdi,%rbx,4),%xmm1
movups %xmm1,-0xc(%rax,%rbx,4)
movups %xmm0,-0x1c(%rax,%rbx,4)
mov    -0x50(%rsp),%rbp
mov    -0x48(%rsp),%rcx
cmp    %rcx,-0x40(%rsp)
je     11a0 <feature_update+0xa0>
nopl   (%rax)
mov    %r10,%rcx
lea    -0x1(%rbp),%r10d
mov    %ebp,%ebx
and    $0x3,%ebx
je     164a <feature_update+0x54a>
xchg   %ax,%ax
lea    -0x1(%rbp),%rdx
movss  -0x4(%rdi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
mov    %rdx,%rbp
add    $0xffffffff,%ebx
jne    1630 <feature_update+0x530>
jmp    164d <feature_update+0x54d>
mov    %rbp,%rdx
cmp    $0x3,%r10d
mov    %rcx,%r10
jb     11a0 <feature_update+0xa0>
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rdi,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdx,4)
movss  -0x8(%rdi,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdx,4)
movss  -0xc(%rdi,%rdx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdx,4)
movss  -0x10(%rdi,%rdx,4),%xmm0
movss  %xmm0,-0x10(%rax,%rdx,4)
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdx
test   %ebp,%ebp
jne    1660 <feature_update+0x560>
jmp    11a0 <feature_update+0xa0>
xor    %r13d,%r13d
testb  $0x1,-0x70(%rsp)
jne    1345 <feature_update+0x245>
jmp    1375 <feature_update+0x275>
xor    %ebx,%ebx
testb  $0x1,-0x70(%rsp)
jne    149e <feature_update+0x39e>
jmp    14b8 <feature_update+0x3b8>
xor    %ebx,%ebx
testb  $0x1,-0x70(%rsp)
jne    15ee <feature_update+0x4ee>
jmp    1608 <feature_update+0x508>
test   %r8d,%r8d
je     18d3 <feature_update+0x7d3>
cmp    $0x7,%r13d
jb     1838 <feature_update+0x738>
mov    %r8d,%r14d
mov    %r13,%rcx
not    %rcx
add    %r9,%rcx
lea    (%rax,%rcx,4),%rdx
lea    (%rax,%r9,4),%rbp
lea    (%rdi,%rcx,4),%r8
lea    (%rdi,%r9,4),%rbx
lea    (%rsi,%rcx,4),%r10
lea    (%rsi,%r9,4),%rcx
cmp    %rbx,%rdx
setb   %r11b
cmp    %rbp,%r8
setb   %bl
cmp    %rcx,%rdx
setb   %cl
cmp    %rbp,%r10
setb   %dl
test   %bl,%r11b
jne    17d5 <feature_update+0x6d5>
and    %dl,%cl
jne    17d5 <feature_update+0x6d5>
add    $0x1,%r13
cmpq   $0x0,-0x60(%rsp)
je     17df <feature_update+0x6df>
movabs $0x3ffffffffffffffe,%rbp
ff ff 3f
and    -0x70(%rsp),%rbp
mov    $0xffffffffffffffff,%rdx
mov    %r14d,%r8d
mov    -0x78(%rsp),%r10
movabs $0x1fffffff8,%rcx
mov    -0x68(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rdi,%rbx,4),%xmm0
movups (%rdi,%rbx,4),%xmm1
movups -0x10(%rsi,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups (%rsi,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%rax,%rbx,4)
movups %xmm2,-0x10(%rax,%rbx,4)
movups -0x30(%rdi,%rbx,4),%xmm0
movups -0x20(%rdi,%rbx,4),%xmm1
movups -0x30(%rsi,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rsi,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,-0x20(%rax,%rbx,4)
movups %xmm2,-0x30(%rax,%rbx,4)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1780 <feature_update+0x680>
jmp    17f8 <feature_update+0x6f8>
mov    %r14d,%r8d
mov    -0x78(%rsp),%r10
jmp    1838 <feature_update+0x738>
mov    $0xffffffffffffffff,%rdx
mov    %r14d,%r8d
mov    -0x78(%rsp),%r10
movabs $0x1fffffff8,%rcx
and    %r13,%rcx
testb  $0x1,-0x70(%rsp)
je     1829 <feature_update+0x729>
add    %r9,%rdx
movups -0x1c(%rdi,%rdx,4),%xmm0
movups -0xc(%rdi,%rdx,4),%xmm1
movups -0x1c(%rsi,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups -0xc(%rsi,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,-0xc(%rax,%rdx,4)
movups %xmm2,-0x1c(%rax,%rdx,4)
cmp    %rcx,%r13
je     18d3 <feature_update+0x7d3>
mov    %rcx,%rdx
sub    %rcx,%r9
lea    -0x1(%r9),%ebx
mov    %r9d,%ebp
and    $0x3,%ebp
je     18ef <feature_update+0x7ef>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r9),%rdx
movss  -0x4(%rdi,%r9,4),%xmm0
addss  -0x4(%rsi,%r9,4),%xmm0
movss  %xmm0,-0x4(%rax,%r9,4)
mov    %rdx,%r9
add    $0xffffffff,%ebp
jne    1850 <feature_update+0x750>
cmp    $0x3,%ebx
jb     18d3 <feature_update+0x7d3>
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rdi,%rdx,4),%xmm0
addss  -0x4(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdx,4)
movss  -0x8(%rdi,%rdx,4),%xmm0
addss  -0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdx,4)
movss  -0xc(%rdi,%rdx,4),%xmm0
addss  -0xc(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdx,4)
movss  -0x10(%rdi,%rdx,4),%xmm0
addss  -0x10(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x10(%rax,%rdx,4)
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdx
test   %ebp,%ebp
jne    1880 <feature_update+0x780>
movslq (%r10),%rcx
movslq %r8d,%rdx
imul   %rcx,%rdx
shl    $0x2,%rdx
sub    %rdx,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r9,%rdx
cmp    $0x3,%ebx
jae    1880 <feature_update+0x780>
jmp    18d3 <feature_update+0x7d3>

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

LLVM IR (-O2):
define float* @feature_update(float* nocapture %0, float* nocapture %1, float* writeonly %2, i32* nocapture %3, i32 %4) {
%6 = icmp eq i32 %4, 0
%7 = sext i32 %4 to i64
%8 = add nsw i64 %7, -1
%9 = add i32 %4, -1
%10 = zext i32 %9 to i64
%11 = sub nsw i64 %8, %10
%12 = zext i32 %9 to i64
%13 = add nuw nsw i64 %12, 1
%14 = zext i32 %9 to i64
%15 = sub nsw i64 %8, %14
%16 = add i32 %4, -1
%17 = zext i32 %16 to i64
%18 = add nuw nsw i64 %17, 1
%19 = zext i32 %16 to i64
%20 = xor i64 %19, -1
%21 = add nsw i64 %20, %7
%22 = zext i32 %16 to i64
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 8589934584
%25 = add nsw i64 %24, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = icmp ult i32 %16, 7
%29 = and i64 %23, 8589934584
%30 = sub nsw i64 %7, %29
%31 = and i64 %27, 1
%32 = icmp eq i64 %25, 0
%33 = and i64 %27, 4611686018427387902
%34 = icmp eq i64 %31, 0
%35 = icmp eq i64 %23, %29
%36 = icmp ult i32 %16, 7
%37 = and i64 %18, 8589934584
%38 = sub nsw i64 %7, %37
%39 = and i64 %27, 1
%40 = icmp eq i64 %25, 0
%41 = and i64 %27, 4611686018427387902
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %18, %37
%44 = icmp ult i32 %9, 7
%45 = and i64 %13, 8589934584
%46 = sub nsw i64 %7, %45
%47 = and i64 %27, 1
%48 = icmp eq i64 %25, 0
%49 = and i64 %27, 4611686018427387902
%50 = icmp eq i64 %47, 0
%51 = icmp eq i64 %13, %45
br label %52
52: ; preds = %600, %5
%53 = phi i64 [ %604, %600 ], [ 0, %5 ]
%54 = phi i64 [ %603, %600 ], [ 1, %5 ]
%55 = phi float* [ %602, %600 ], [ %2, %5 ]
%56 = phi float* [ %490, %600 ], [ %1, %5 ]
%57 = phi float* [ %601, %600 ], [ %0, %5 ]
%58 = mul i64 %53, %7
%59 = add i64 %21, %58
%60 = getelementptr float, float* %2, i64 %59
%61 = add i64 %58, %7
%62 = getelementptr float, float* %2, i64 %61
%63 = mul i64 %53, %7
%64 = add i64 %15, %63
%65 = getelementptr float, float* %2, i64 %64
%66 = add i64 %63, %7
%67 = getelementptr float, float* %2, i64 %66
%68 = mul i64 %53, %7
%69 = add i64 %11, %68
%70 = getelementptr float, float* %2, i64 %69
%71 = add i64 %68, %7
%72 = getelementptr float, float* %2, i64 %71
%73 = getelementptr inbounds i32, i32* %3, i64 %54
%74 = load i32, i32* %73
switch i32 %74, label %377 [
i32 3, label %199
i32 0, label %75
]
75: ; preds = %52
br i1 %6, label %374, label %76
76: ; preds = %75
br i1 %28, label %178, label %77
77: ; preds = %76
%78 = getelementptr float, float* %57, i64 %21
%79 = getelementptr float, float* %57, i64 %7
%80 = getelementptr float, float* %56, i64 %21
%81 = getelementptr float, float* %56, i64 %7
%82 = icmp ult float* %60, %79
%83 = icmp ult float* %78, %62
%84 = and i1 %82, %83
%85 = icmp ult float* %60, %81
%86 = icmp ult float* %80, %62
%87 = and i1 %85, %86
%88 = or i1 %84, %87
br i1 %88, label %178, label %89
89: ; preds = %77
br i1 %32, label %148, label %90
90: ; preds = %89, %90
%91 = phi i64 [ %145, %90 ], [ 0, %89 ]
%92 = phi i64 [ %146, %90 ], [ 0, %89 ]
%93 = xor i64 %91, -1
%94 = add i64 %93, %7
%95 = getelementptr inbounds float, float* %57, i64 %94
%96 = getelementptr inbounds float, float* %95, i64 -3
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = getelementptr inbounds float, float* %95, i64 -4
%100 = getelementptr inbounds float, float* %99, i64 -3
%101 = bitcast float* %100 to <4 x float>*
%102 = load <4 x float>, <4 x float>* %101
%103 = getelementptr inbounds float, float* %56, i64 %94
%104 = getelementptr inbounds float, float* %103, i64 -3
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = getelementptr inbounds float, float* %103, i64 -4
%108 = getelementptr inbounds float, float* %107, i64 -3
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = fadd <4 x float> %98, %106
%112 = fadd <4 x float> %102, %110
%113 = getelementptr inbounds float, float* %55, i64 %94
%114 = getelementptr inbounds float, float* %113, i64 -3
%115 = bitcast float* %114 to <4 x float>*
store <4 x float> %111, <4 x float>* %115
%116 = getelementptr inbounds float, float* %113, i64 -4
%117 = getelementptr inbounds float, float* %116, i64 -3
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %112, <4 x float>* %118
%119 = sub nuw nsw i64 -9, %91
%120 = add i64 %119, %7
%121 = getelementptr inbounds float, float* %57, i64 %120
%122 = getelementptr inbounds float, float* %121, i64 -3
%123 = bitcast float* %122 to <4 x float>*
%124 = load <4 x float>, <4 x float>* %123
%125 = getelementptr inbounds float, float* %121, i64 -4
%126 = getelementptr inbounds float, float* %125, i64 -3
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = getelementptr inbounds float, float* %56, i64 %120
%130 = getelementptr inbounds float, float* %129, i64 -3
%131 = bitcast float* %130 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = getelementptr inbounds float, float* %129, i64 -4
%134 = getelementptr inbounds float, float* %133, i64 -3
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = fadd <4 x float> %124, %132
%138 = fadd <4 x float> %128, %136
%139 = getelementptr inbounds float, float* %55, i64 %120
%140 = getelementptr inbounds float, float* %139, i64 -3
%141 = bitcast float* %140 to <4 x float>*
store <4 x float> %137, <4 x float>* %141
%142 = getelementptr inbounds float, float* %139, i64 -4
%143 = getelementptr inbounds float, float* %142, i64 -3
%144 = bitcast float* %143 to <4 x float>*
store <4 x float> %138, <4 x float>* %144
%145 = add nuw i64 %91, 16
%146 = add i64 %92, 2
%147 = icmp eq i64 %146, %33
br i1 %147, label %148, label %90
148: ; preds = %90, %89
%149 = phi i64 [ 0, %89 ], [ %145, %90 ]
br i1 %34, label %177, label %150
150: ; preds = %148
%151 = xor i64 %149, -1
%152 = add i64 %151, %7
%153 = getelementptr inbounds float, float* %57, i64 %152
%154 = getelementptr inbounds float, float* %153, i64 -3
%155 = bitcast float* %154 to <4 x float>*
%156 = load <4 x float>, <4 x float>* %155
%157 = getelementptr inbounds float, float* %153, i64 -4
%158 = getelementptr inbounds float, float* %157, i64 -3
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %56, i64 %152
%162 = getelementptr inbounds float, float* %161, i64 -3
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = getelementptr inbounds float, float* %161, i64 -4
%166 = getelementptr inbounds float, float* %165, i64 -3
%167 = bitcast float* %166 to <4 x float>*
%168 = load <4 x float>, <4 x float>* %167
%169 = fadd <4 x float> %156, %164
%170 = fadd <4 x float> %160, %168
%171 = getelementptr inbounds float, float* %55, i64 %152
%172 = getelementptr inbounds float, float* %171, i64 -3
%173 = bitcast float* %172 to <4 x float>*
store <4 x float> %169, <4 x float>* %173
%174 = getelementptr inbounds float, float* %171, i64 -4
%175 = getelementptr inbounds float, float* %174, i64 -3
%176 = bitcast float* %175 to <4 x float>*
store <4 x float> %170, <4 x float>* %176
br label %177
177: ; preds = %148, %150
br i1 %35, label %374, label %178
178: ; preds = %77, %76, %177
%179 = phi i64 [ %7, %77 ], [ %7, %76 ], [ %30, %177 ]
%180 = trunc i64 %179 to i32
%181 = add i32 %180, -1
%182 = and i32 %180, 3
%183 = icmp eq i32 %182, 0
br i1 %183, label %196, label %184
184: ; preds = %178, %184
%185 = phi i64 [ %187, %184 ], [ %179, %178 ]
%186 = phi i32 [ %194, %184 ], [ 0, %178 ]
%187 = add nsw i64 %185, -1
%188 = getelementptr inbounds float, float* %57, i64 %187
%189 = load float, float* %188
%190 = getelementptr inbounds float, float* %56, i64 %187
%191 = load float, float* %190
%192 = fadd float %189, %191
%193 = getelementptr inbounds float, float* %55, i64 %187
store float %192, float* %193
%194 = add i32 %186, 1
%195 = icmp eq i32 %194, %182
br i1 %195, label %196, label %184
196: ; preds = %184, %178
%197 = phi i64 [ %179, %178 ], [ %187, %184 ]
%198 = icmp ult i32 %181, 3
br i1 %198, label %374, label %342
199: ; preds = %52
br i1 %6, label %637, label %200
200: ; preds = %199
%201 = add i32 %4, -1
%202 = zext i32 %201 to i64
%203 = add nuw nsw i64 %202, 1
%204 = icmp ult i32 %201, 7
br i1 %204, label %321, label %205
205: ; preds = %200
%206 = add i32 %4, -1
%207 = zext i32 %206 to i64
%208 = xor i64 %207, -1
%209 = add nsw i64 %208, %7
%210 = getelementptr float, float* %55, i64 %209
%211 = getelementptr float, float* %55, i64 %7
%212 = getelementptr float, float* %57, i64 %209
%213 = getelementptr float, float* %57, i64 %7
%214 = getelementptr float, float* %56, i64 %209
%215 = getelementptr float, float* %56, i64 %7
%216 = icmp ult float* %210, %213
%217 = icmp ult float* %212, %211
%218 = and i1 %216, %217
%219 = icmp ult float* %210, %215
%220 = icmp ult float* %214, %211
%221 = and i1 %219, %220
%222 = or i1 %218, %221
br i1 %222, label %321, label %223
223: ; preds = %205
%224 = and i64 %203, 8589934584
%225 = sub nsw i64 %7, %224
%226 = and i64 %27, 1
%227 = icmp eq i64 %25, 0
br i1 %227, label %290, label %228
228: ; preds = %223
%229 = and i64 %27, 4611686018427387902
br label %230
230: ; preds = %230, %228
%231 = phi i64 [ 0, %228 ], [ %285, %230 ]
%232 = phi i64 [ 0, %228 ], [ %286, %230 ]
%233 = xor i64 %231, -1
%234 = add i64 %233, %7
%235 = getelementptr inbounds float, float* %57, i64 %234
%236 = getelementptr inbounds float, float* %235, i64 -3
%237 = bitcast float* %236 to <4 x float>*
%238 = load <4 x float>, <4 x float>* %237
%239 = getelementptr inbounds float, float* %235, i64 -4
%240 = getelementptr inbounds float, float* %239, i64 -3
%241 = bitcast float* %240 to <4 x float>*
%242 = load <4 x float>, <4 x float>* %241
%243 = getelementptr inbounds float, float* %56, i64 %234
%244 = getelementptr inbounds float, float* %243, i64 -3
%245 = bitcast float* %244 to <4 x float>*
%246 = load <4 x float>, <4 x float>* %245
%247 = getelementptr inbounds float, float* %243, i64 -4
%248 = getelementptr inbounds float, float* %247, i64 -3
%249 = bitcast float* %248 to <4 x float>*
%250 = load <4 x float>, <4 x float>* %249
%251 = fadd <4 x float> %238, %246
%252 = fadd <4 x float> %242, %250
%253 = getelementptr inbounds float, float* %55, i64 %234
%254 = getelementptr inbounds float, float* %253, i64 -3
%255 = bitcast float* %254 to <4 x float>*
store <4 x float> %251, <4 x float>* %255
%256 = getelementptr inbounds float, float* %253, i64 -4
%257 = getelementptr inbounds float, float* %256, i64 -3
%258 = bitcast float* %257 to <4 x float>*
store <4 x float> %252, <4 x float>* %258
%259 = sub nuw nsw i64 -9, %231
%260 = add i64 %259, %7
%261 = getelementptr inbounds float, float* %57, i64 %260
%262 = getelementptr inbounds float, float* %261, i64 -3
%263 = bitcast float* %262 to <4 x float>*
%264 = load <4 x float>, <4 x float>* %263
%265 = getelementptr inbounds float, float* %261, i64 -4
%266 = getelementptr inbounds float, float* %265, i64 -3
%267 = bitcast float* %266 to <4 x float>*
%268 = load <4 x float>, <4 x float>* %267
%269 = getelementptr inbounds float, float* %56, i64 %260
%270 = getelementptr inbounds float, float* %269, i64 -3
%271 = bitcast float* %270 to <4 x float>*
%272 = load <4 x float>, <4 x float>* %271
%273 = getelementptr inbounds float, float* %269, i64 -4
%274 = getelementptr inbounds float, float* %273, i64 -3
%275 = bitcast float* %274 to <4 x float>*
%276 = load <4 x float>, <4 x float>* %275
%277 = fadd <4 x float> %264, %272
%278 = fadd <4 x float> %268, %276
%279 = getelementptr inbounds float, float* %55, i64 %260
%280 = getelementptr inbounds float, float* %279, i64 -3
%281 = bitcast float* %280 to <4 x float>*
store <4 x float> %277, <4 x float>* %281
%282 = getelementptr inbounds float, float* %279, i64 -4
%283 = getelementptr inbounds float, float* %282, i64 -3
%284 = bitcast float* %283 to <4 x float>*
store <4 x float> %278, <4 x float>* %284
%285 = add nuw i64 %231, 16
%286 = add i64 %232, 2
%287 = icmp eq i64 %286, %229
br i1 %287, label %288, label %230
288: ; preds = %230
%289 = sub i64 -17, %231
br label %290
290: ; preds = %288, %223
%291 = phi i64 [ -1, %223 ], [ %289, %288 ]
%292 = icmp eq i64 %226, 0
br i1 %292, label %319, label %293
293: ; preds = %290
%294 = add i64 %291, %7
%295 = getelementptr inbounds float, float* %57, i64 %294
%296 = getelementptr inbounds float, float* %295, i64 -3
%297 = bitcast float* %296 to <4 x float>*
%298 = load <4 x float>, <4 x float>* %297
%299 = getelementptr inbounds float, float* %295, i64 -4
%300 = getelementptr inbounds float, float* %299, i64 -3
%301 = bitcast float* %300 to <4 x float>*
%302 = load <4 x float>, <4 x float>* %301
%303 = getelementptr inbounds float, float* %56, i64 %294
%304 = getelementptr inbounds float, float* %303, i64 -3
%305 = bitcast float* %304 to <4 x float>*
%306 = load <4 x float>, <4 x float>* %305
%307 = getelementptr inbounds float, float* %303, i64 -4
%308 = getelementptr inbounds float, float* %307, i64 -3
%309 = bitcast float* %308 to <4 x float>*
%310 = load <4 x float>, <4 x float>* %309
%311 = fadd <4 x float> %298, %306
%312 = fadd <4 x float> %302, %310
%313 = getelementptr inbounds float, float* %55, i64 %294
%314 = getelementptr inbounds float, float* %313, i64 -3
%315 = bitcast float* %314 to <4 x float>*
store <4 x float> %311, <4 x float>* %315
%316 = getelementptr inbounds float, float* %313, i64 -4
%317 = getelementptr inbounds float, float* %316, i64 -3
%318 = bitcast float* %317 to <4 x float>*
store <4 x float> %312, <4 x float>* %318
br label %319
319: ; preds = %290, %293
%320 = icmp eq i64 %203, %224
br i1 %320, label %637, label %321
321: ; preds = %205, %200, %319
%322 = phi i64 [ %7, %205 ], [ %7, %200 ], [ %225, %319 ]
%323 = trunc i64 %322 to i32
%324 = add i32 %323, -1
%325 = and i32 %323, 3
%326 = icmp eq i32 %325, 0
br i1 %326, label %339, label %327
327: ; preds = %321, %327
%328 = phi i64 [ %330, %327 ], [ %322, %321 ]
%329 = phi i32 [ %337, %327 ], [ 0, %321 ]
%330 = add nsw i64 %328, -1
%331 = getelementptr inbounds float, float* %57, i64 %330
%332 = load float, float* %331
%333 = getelementptr inbounds float, float* %56, i64 %330
%334 = load float, float* %333
%335 = fadd float %332, %334
%336 = getelementptr inbounds float, float* %55, i64 %330
store float %335, float* %336
%337 = add i32 %329, 1
%338 = icmp eq i32 %337, %325
br i1 %338, label %339, label %327
339: ; preds = %327, %321
%340 = phi i64 [ %322, %321 ], [ %330, %327 ]
%341 = icmp ult i32 %324, 3
br i1 %341, label %637, label %605
342: ; preds = %196, %342
%343 = phi i64 [ %365, %342 ], [ %197, %196 ]
%344 = add nsw i64 %343, -1
%345 = getelementptr inbounds float, float* %57, i64 %344
%346 = load float, float* %345
%347 = getelementptr inbounds float, float* %56, i64 %344
%348 = load float, float* %347
%349 = fadd float %346, %348
%350 = getelementptr inbounds float, float* %55, i64 %344
store float %349, float* %350
%351 = add nsw i64 %343, -2
%352 = getelementptr inbounds float, float* %57, i64 %351
%353 = load float, float* %352
%354 = getelementptr inbounds float, float* %56, i64 %351
%355 = load float, float* %354
%356 = fadd float %353, %355
%357 = getelementptr inbounds float, float* %55, i64 %351
store float %356, float* %357
%358 = add nsw i64 %343, -3
%359 = getelementptr inbounds float, float* %57, i64 %358
%360 = load float, float* %359
%361 = getelementptr inbounds float, float* %56, i64 %358
%362 = load float, float* %361
%363 = fadd float %360, %362
%364 = getelementptr inbounds float, float* %55, i64 %358
store float %363, float* %364
%365 = add nsw i64 %343, -4
%366 = getelementptr inbounds float, float* %57, i64 %365
%367 = load float, float* %366
%368 = getelementptr inbounds float, float* %56, i64 %365
%369 = load float, float* %368
%370 = fadd float %367, %369
%371 = getelementptr inbounds float, float* %55, i64 %365
store float %370, float* %371
%372 = trunc i64 %365 to i32
%373 = icmp eq i32 %372, 0
br i1 %373, label %374, label %342
374: ; preds = %196, %342, %177, %75
%375 = getelementptr inbounds float, float* %57, i64 %7
%376 = getelementptr inbounds float, float* %56, i64 %7
br label %377
377: ; preds = %52, %374
%378 = phi float* [ %376, %374 ], [ %56, %52 ]
%379 = phi float* [ %375, %374 ], [ %57, %52 ]
%380 = and i32 %74, 1
%381 = icmp eq i32 %380, 0
br i1 %381, label %489, label %382
382: ; preds = %377
br i1 %6, label %487, label %383
383: ; preds = %382
br i1 %36, label %449, label %384
384: ; preds = %383
%385 = getelementptr float, float* %378, i64 %15
%386 = getelementptr float, float* %378, i64 %7
%387 = icmp ult float* %65, %386
%388 = icmp ult float* %385, %67
%389 = and i1 %387, %388
br i1 %389, label %449, label %390
390: ; preds = %384
br i1 %40, label %429, label %391
391: ; preds = %390, %391
%392 = phi i64 [ %426, %391 ], [ 0, %390 ]
%393 = phi i64 [ %427, %391 ], [ 0, %390 ]
%394 = xor i64 %392, -1
%395 = add i64 %394, %7
%396 = getelementptr inbounds float, float* %378, i64 %395
%397 = getelementptr inbounds float, float* %396, i64 -3
%398 = bitcast float* %397 to <4 x float>*
%399 = load <4 x float>, <4 x float>* %398
%400 = getelementptr inbounds float, float* %396, i64 -4
%401 = getelementptr inbounds float, float* %400, i64 -3
%402 = bitcast float* %401 to <4 x float>*
%403 = load <4 x float>, <4 x float>* %402
%404 = getelementptr inbounds float, float* %55, i64 %395
%405 = getelementptr inbounds float, float* %404, i64 -3
%406 = bitcast float* %405 to <4 x float>*
store <4 x float> %399, <4 x float>* %406
%407 = getelementptr inbounds float, float* %404, i64 -4
%408 = getelementptr inbounds float, float* %407, i64 -3
%409 = bitcast float* %408 to <4 x float>*
store <4 x float> %403, <4 x float>* %409
%410 = sub nuw nsw i64 -9, %392
%411 = add i64 %410, %7
%412 = getelementptr inbounds float, float* %378, i64 %411
%413 = getelementptr inbounds float, float* %412, i64 -3
%414 = bitcast float* %413 to <4 x float>*
%415 = load <4 x float>, <4 x float>* %414
%416 = getelementptr inbounds float, float* %412, i64 -4
%417 = getelementptr inbounds float, float* %416, i64 -3
%418 = bitcast float* %417 to <4 x float>*
%419 = load <4 x float>, <4 x float>* %418
%420 = getelementptr inbounds float, float* %55, i64 %411
%421 = getelementptr inbounds float, float* %420, i64 -3
%422 = bitcast float* %421 to <4 x float>*
store <4 x float> %415, <4 x float>* %422
%423 = getelementptr inbounds float, float* %420, i64 -4
%424 = getelementptr inbounds float, float* %423, i64 -3
%425 = bitcast float* %424 to <4 x float>*
store <4 x float> %419, <4 x float>* %425
%426 = add nuw i64 %392, 16
%427 = add i64 %393, 2
%428 = icmp eq i64 %427, %41
br i1 %428, label %429, label %391
429: ; preds = %391, %390
%430 = phi i64 [ 0, %390 ], [ %426, %391 ]
br i1 %42, label %448, label %431
431: ; preds = %429
%432 = xor i64 %430, -1
%433 = add i64 %432, %7
%434 = getelementptr inbounds float, float* %378, i64 %433
%435 = getelementptr inbounds float, float* %434, i64 -3
%436 = bitcast float* %435 to <4 x float>*
%437 = load <4 x float>, <4 x float>* %436
%438 = getelementptr inbounds float, float* %434, i64 -4
%439 = getelementptr inbounds float, float* %438, i64 -3
%440 = bitcast float* %439 to <4 x float>*
%441 = load <4 x float>, <4 x float>* %440
%442 = getelementptr inbounds float, float* %55, i64 %433
%443 = getelementptr inbounds float, float* %442, i64 -3
%444 = bitcast float* %443 to <4 x float>*
store <4 x float> %437, <4 x float>* %444
%445 = getelementptr inbounds float, float* %442, i64 -4
%446 = getelementptr inbounds float, float* %445, i64 -3
%447 = bitcast float* %446 to <4 x float>*
store <4 x float> %441, <4 x float>* %447
br label %448
448: ; preds = %429, %431
br i1 %43, label %487, label %449
449: ; preds = %384, %383, %448
%450 = phi i64 [ %7, %384 ], [ %7, %383 ], [ %38, %448 ]
%451 = trunc i64 %450 to i32
%452 = add i32 %451, -1
%453 = and i32 %451, 3
%454 = icmp eq i32 %453, 0
br i1 %454, label %464, label %455
455: ; preds = %449, %455
%456 = phi i64 [ %458, %455 ], [ %450, %449 ]
%457 = phi i32 [ %462, %455 ], [ 0, %449 ]
%458 = add nsw i64 %456, -1
%459 = getelementptr inbounds float, float* %378, i64 %458
%460 = load float, float* %459
%461 = getelementptr inbounds float, float* %55, i64 %458
store float %460, float* %461
%462 = add i32 %457, 1
%463 = icmp eq i32 %462, %453
br i1 %463, label %464, label %455
464: ; preds = %455, %449
%465 = phi i64 [ %450, %449 ], [ %458, %455 ]
%466 = icmp ult i32 %452, 3
br i1 %466, label %487, label %467
467: ; preds = %464, %467
%468 = phi i64 [ %481, %467 ], [ %465, %464 ]
%469 = add nsw i64 %468, -1
%470 = getelementptr inbounds float, float* %378, i64 %469
%471 = load float, float* %470
%472 = getelementptr inbounds float, float* %55, i64 %469
store float %471, float* %472
%473 = add nsw i64 %468, -2
%474 = getelementptr inbounds float, float* %378, i64 %473
%475 = load float, float* %474
%476 = getelementptr inbounds float, float* %55, i64 %473
store float %475, float* %476
%477 = add nsw i64 %468, -3
%478 = getelementptr inbounds float, float* %378, i64 %477
%479 = load float, float* %478
%480 = getelementptr inbounds float, float* %55, i64 %477
store float %479, float* %480
%481 = add nsw i64 %468, -4
%482 = getelementptr inbounds float, float* %378, i64 %481
%483 = load float, float* %482
%484 = getelementptr inbounds float, float* %55, i64 %481
store float %483, float* %484
%485 = trunc i64 %481 to i32
%486 = icmp eq i32 %485, 0
br i1 %486, label %487, label %467
487: ; preds = %464, %467, %448, %382
%488 = getelementptr inbounds float, float* %378, i64 %7
br label %489
489: ; preds = %487, %377
%490 = phi float* [ %488, %487 ], [ %378, %377 ]
%491 = and i32 %74, 2
%492 = icmp eq i32 %491, 0
br i1 %492, label %600, label %493
493: ; preds = %489
br i1 %6, label %598, label %494
494: ; preds = %493
br i1 %44, label %560, label %495
495: ; preds = %494
%496 = getelementptr float, float* %379, i64 %11
%497 = getelementptr float, float* %379, i64 %7
%498 = icmp ult float* %70, %497
%499 = icmp ult float* %496, %72
%500 = and i1 %498, %499
br i1 %500, label %560, label %501
501: ; preds = %495
br i1 %48, label %540, label %502
502: ; preds = %501, %502
%503 = phi i64 [ %537, %502 ], [ 0, %501 ]
%504 = phi i64 [ %538, %502 ], [ 0, %501 ]
%505 = xor i64 %503, -1
%506 = add i64 %505, %7
%507 = getelementptr inbounds float, float* %379, i64 %506
%508 = getelementptr inbounds float, float* %507, i64 -3
%509 = bitcast float* %508 to <4 x float>*
%510 = load <4 x float>, <4 x float>* %509
%511 = getelementptr inbounds float, float* %507, i64 -4
%512 = getelementptr inbounds float, float* %511, i64 -3
%513 = bitcast float* %512 to <4 x float>*
%514 = load <4 x float>, <4 x float>* %513
%515 = getelementptr inbounds float, float* %55, i64 %506
%516 = getelementptr inbounds float, float* %515, i64 -3
%517 = bitcast float* %516 to <4 x float>*
store <4 x float> %510, <4 x float>* %517
%518 = getelementptr inbounds float, float* %515, i64 -4
%519 = getelementptr inbounds float, float* %518, i64 -3
%520 = bitcast float* %519 to <4 x float>*
store <4 x float> %514, <4 x float>* %520
%521 = sub nuw nsw i64 -9, %503
%522 = add i64 %521, %7
%523 = getelementptr inbounds float, float* %379, i64 %522
%524 = getelementptr inbounds float, float* %523, i64 -3
%525 = bitcast float* %524 to <4 x float>*
%526 = load <4 x float>, <4 x float>* %525
%527 = getelementptr inbounds float, float* %523, i64 -4
%528 = getelementptr inbounds float, float* %527, i64 -3
%529 = bitcast float* %528 to <4 x float>*
%530 = load <4 x float>, <4 x float>* %529
%531 = getelementptr inbounds float, float* %55, i64 %522
%532 = getelementptr inbounds float, float* %531, i64 -3
%533 = bitcast float* %532 to <4 x float>*
store <4 x float> %526, <4 x float>* %533
%534 = getelementptr inbounds float, float* %531, i64 -4
%535 = getelementptr inbounds float, float* %534, i64 -3
%536 = bitcast float* %535 to <4 x float>*
store <4 x float> %530, <4 x float>* %536
%537 = add nuw i64 %503, 16
%538 = add i64 %504, 2
%539 = icmp eq i64 %538, %49
br i1 %539, label %540, label %502
540: ; preds = %502, %501
%541 = phi i64 [ 0, %501 ], [ %537, %502 ]
br i1 %50, label %559, label %542
542: ; preds = %540
%543 = xor i64 %541, -1
%544 = add i64 %543, %7
%545 = getelementptr inbounds float, float* %379, i64 %544
%546 = getelementptr inbounds float, float* %545, i64 -3
%547 = bitcast float* %546 to <4 x float>*
%548 = load <4 x float>, <4 x float>* %547
%549 = getelementptr inbounds float, float* %545, i64 -4
%550 = getelementptr inbounds float, float* %549, i64 -3
%551 = bitcast float* %550 to <4 x float>*
%552 = load <4 x float>, <4 x float>* %551
%553 = getelementptr inbounds float, float* %55, i64 %544
%554 = getelementptr inbounds float, float* %553, i64 -3
%555 = bitcast float* %554 to <4 x float>*
store <4 x float> %548, <4 x float>* %555
%556 = getelementptr inbounds float, float* %553, i64 -4
%557 = getelementptr inbounds float, float* %556, i64 -3
%558 = bitcast float* %557 to <4 x float>*
store <4 x float> %552, <4 x float>* %558
br label %559
559: ; preds = %540, %542
br i1 %51, label %598, label %560
560: ; preds = %495, %494, %559
%561 = phi i64 [ %7, %495 ], [ %7, %494 ], [ %46, %559 ]
%562 = trunc i64 %561 to i32
%563 = add i32 %562, -1
%564 = and i32 %562, 3
%565 = icmp eq i32 %564, 0
br i1 %565, label %575, label %566
566: ; preds = %560, %566
%567 = phi i64 [ %569, %566 ], [ %561, %560 ]
%568 = phi i32 [ %573, %566 ], [ 0, %560 ]
%569 = add nsw i64 %567, -1
%570 = getelementptr inbounds float, float* %379, i64 %569
%571 = load float, float* %570
%572 = getelementptr inbounds float, float* %55, i64 %569
store float %571, float* %572
%573 = add i32 %568, 1
%574 = icmp eq i32 %573, %564
br i1 %574, label %575, label %566
575: ; preds = %566, %560
%576 = phi i64 [ %561, %560 ], [ %569, %566 ]
%577 = icmp ult i32 %563, 3
br i1 %577, label %598, label %578
578: ; preds = %575, %578
%579 = phi i64 [ %592, %578 ], [ %576, %575 ]
%580 = add nsw i64 %579, -1
%581 = getelementptr inbounds float, float* %379, i64 %580
%582 = load float, float* %581
%583 = getelementptr inbounds float, float* %55, i64 %580
store float %582, float* %583
%584 = add nsw i64 %579, -2
%585 = getelementptr inbounds float, float* %379, i64 %584
%586 = load float, float* %585
%587 = getelementptr inbounds float, float* %55, i64 %584
store float %586, float* %587
%588 = add nsw i64 %579, -3
%589 = getelementptr inbounds float, float* %379, i64 %588
%590 = load float, float* %589
%591 = getelementptr inbounds float, float* %55, i64 %588
store float %590, float* %591
%592 = add nsw i64 %579, -4
%593 = getelementptr inbounds float, float* %379, i64 %592
%594 = load float, float* %593
%595 = getelementptr inbounds float, float* %55, i64 %592
store float %594, float* %595
%596 = trunc i64 %592 to i32
%597 = icmp eq i32 %596, 0
br i1 %597, label %598, label %578
598: ; preds = %575, %578, %559, %493
%599 = getelementptr inbounds float, float* %379, i64 %7
br label %600
600: ; preds = %598, %489
%601 = phi float* [ %599, %598 ], [ %379, %489 ]
%602 = getelementptr inbounds float, float* %55, i64 %7
%603 = add nuw i64 %54, 1
%604 = add i64 %53, 1
br label %52
605: ; preds = %339, %605
%606 = phi i64 [ %628, %605 ], [ %340, %339 ]
%607 = add nsw i64 %606, -1
%608 = getelementptr inbounds float, float* %57, i64 %607
%609 = load float, float* %608
%610 = getelementptr inbounds float, float* %56, i64 %607
%611 = load float, float* %610
%612 = fadd float %609, %611
%613 = getelementptr inbounds float, float* %55, i64 %607
store float %612, float* %613
%614 = add nsw i64 %606, -2
%615 = getelementptr inbounds float, float* %57, i64 %614
%616 = load float, float* %615
%617 = getelementptr inbounds float, float* %56, i64 %614
%618 = load float, float* %617
%619 = fadd float %616, %618
%620 = getelementptr inbounds float, float* %55, i64 %614
store float %619, float* %620
%621 = add nsw i64 %606, -3
%622 = getelementptr inbounds float, float* %57, i64 %621
%623 = load float, float* %622
%624 = getelementptr inbounds float, float* %56, i64 %621
%625 = load float, float* %624
%626 = fadd float %623, %625
%627 = getelementptr inbounds float, float* %55, i64 %621
store float %626, float* %627
%628 = add nsw i64 %606, -4
%629 = getelementptr inbounds float, float* %57, i64 %628
%630 = load float, float* %629
%631 = getelementptr inbounds float, float* %56, i64 %628
%632 = load float, float* %631
%633 = fadd float %630, %632
%634 = getelementptr inbounds float, float* %55, i64 %628
store float %633, float* %634
%635 = trunc i64 %628 to i32
%636 = icmp eq i32 %635, 0
br i1 %636, label %637, label %605
637: ; preds = %339, %605, %319, %199
%638 = load i32, i32* %3
%639 = mul nsw i32 %638, %4
%640 = sext i32 %639 to i64
%641 = sub nsw i64 0, %640
%642 = getelementptr inbounds float, float* %55, i64 %641
ret float* %642
}