#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void dedisperse_kernel_lagged(float **in, float **out, int n, int m, int s) {
  assert(n % 2 == 0);
  int npair = n / 2;
  for (int jj = 0; jj < npair; jj++) {
    for (int i = 0; i < s; i++)
      out[jj][i] = in[2 * jj + 1][i];
    for (int i = s; i < m; i++)
      out[jj][i] = in[2 * jj][i - s] + in[2 * jj + 1][i];
    for (int i = m; i < m + s; i++)
      out[jj][i] = in[2 * jj][i - s];
    for (int i = 0; i < s + 1; i++)
      out[jj + npair][i] = in[2 * jj + 1][i];
    for (int i = s + 1; i < m; i++)
      out[jj + npair][i] = in[2 * jj][i - s - 1] + in[2 * jj + 1][i];
    for (int i = m; i < m + s + 1; i++)
      out[jj + npair][i] = in[2 * jj][i - s - 1];
  }
}


x86 assembly (clang, -O0):
<dedisperse_kernel_lagged>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13d3 <dedisperse_kernel_lagged+0x2c3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11b9 <dedisperse_kernel_lagged+0xa9>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116d <dedisperse_kernel_lagged+0x5d>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    122a <dedisperse_kernel_lagged+0x11a>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bf <dedisperse_kernel_lagged+0xaf>
mov    -0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1283 <dedisperse_kernel_lagged+0x173>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1230 <dedisperse_kernel_lagged+0x120>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12e0 <dedisperse_kernel_lagged+0x1d0>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128a <dedisperse_kernel_lagged+0x17a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    135c <dedisperse_kernel_lagged+0x24c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e9 <dedisperse_kernel_lagged+0x1d9>
mov    -0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13c0 <dedisperse_kernel_lagged+0x2b0>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1362 <dedisperse_kernel_lagged+0x252>
jmp    13c5 <dedisperse_kernel_lagged+0x2b5>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    115a <dedisperse_kernel_lagged+0x4a>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dedisperse_kernel_lagged>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %r8d,%r12d
mov    %rcx,0x20(%rsp)
mov    %edx,%ebp
mov    %rsi,%r15
mov    %rdi,%r13
mov    %edx,%edi
not    %edi
and    $0x1,%edi
call   1030 <assert@plt>
cmp    $0x2,%ebp
jl     2097 <dedisperse_kernel_lagged+0xf87>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
mov    %eax,0x10(%rsp)
mov    0x20(%rsp),%rdx
lea    (%r12,%rdx,1),%eax
mov    %r12d,%ecx
not    %ecx
mov    %rcx,0x58(%rsp)
movslq %edx,%rbx
movslq %eax,%r10
cmp    %r10d,%ebx
mov    %r10d,%eax
cmovg  %edx,%eax
mov    %rax,0xd0(%rsp)
movslq %r12d,%rcx
mov    %ecx,%r8d
mov    %eax,%edx
sub    %ebx,%edx
mov    %rdx,%r14
mov    %rdx,0x28(%rsp)
mov    %ebx,%edx
mov    %rcx,%rax
sub    %eax,%edx
mov    %rdx,%rbp
mov    %rdx,0x60(%rsp)
lea    0x1(%rbx),%rcx
cmp    %r10,%rcx
cmovle %r10,%rcx
mov    %rbx,%r9
sub    %rax,%r9
mov    %rax,%rdx
mov    %rax,0x18(%rsp)
mov    %rcx,%rax
sub    %rdx,%rax
mov    %rax,0x200(%rsp)
mov    %rcx,%rax
mov    %rcx,0x1e0(%rsp)
sub    %rbx,%rcx
mov    %rcx,%rdx
mov    %rcx,0x68(%rsp)
mov    %r8d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x1c0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x1b8(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
lea    -0x8(%r9),%rsi
mov    %rsi,0x150(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
lea    -0x8(%rcx),%rdi
mov    %rdi,0x1b0(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
lea    0x1(%r12),%edx
mov    %rdx,0x70(%rsp)
and    $0xfffffff8,%edx
mov    %rdx,0x1a0(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x198(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
lea    -0x2(%rbp),%ecx
mov    %rcx,0xc8(%rsp)
add    $0x1,%rcx
mov    %rcx,%rbp
mov    %rcx,0xc0(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0xa0(%rsp)
lea    -0x8(%rcx),%r11
mov    %r11,0x140(%rsp)
shr    $0x3,%r11
add    $0x1,%r11
lea    0x1(%r14),%rcx
mov    %rcx,0x190(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0xb8(%rsp)
lea    -0x8(%rcx),%r14
mov    %r14,0x188(%rsp)
shr    $0x3,%r14
add    $0x1,%r14
mov    %eax,%ebp
and    $0x3,%ebp
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
mov    %rax,0x110(%rsp)
mov    %r8,%rax
mov    %r8,0x30(%rsp)
and    $0x3,%eax
mov    %rax,0x220(%rsp)
mov    %r9,%rax
mov    %r9,0x48(%rsp)
and    $0xfffffffffffffff8,%r9
mov    %r9,0x98(%rsp)
mov    %rsi,%rax
mov    %rsi,0x148(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xe0(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x208(%rsp)
mov    0x68(%rsp),%r9
and    $0xfffffffffffffff8,%r9
mov    %rdi,%rax
mov    %rdi,0x1a8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x100(%rsp)
and    %rdx,%rcx
mov    %rcx,0x108(%rsp)
and    $0x3,%edx
mov    0x70(%rsp),%rax
and    $0x3,%eax
mov    %rax,0x218(%rsp)
mov    %r11,%rax
mov    %r11,0x138(%rsp)
and    $0xfffffffffffffffe,%r11
mov    %r11,0xf0(%rsp)
mov    %ebx,%eax
neg    %eax
mov    %eax,0x94(%rsp)
mov    0x28(%rsp),%rax
cmp    $0x7,%eax
setb   %r11b
mov    0x58(%rsp),%rsi
mov    0x20(%rsp),%rcx
add    %esi,%ecx
mov    %rcx,0x120(%rsp)
movslq %ecx,%rdi
mov    0xd0(%rsp),%r8
lea    (%r8,%rsi,1),%ecx
cmp    %edi,%ecx
setl   %cl
or     %r11b,%cl
mov    %cl,0xf(%rsp)
movslq 0x10(%rsp),%rcx
mov    %rax,%rsi
add    %rbx,%rax
add    $0x1,%rax
mov    %rax,0x1d0(%rsp)
mov    %rdi,%rax
mov    %rdi,0x1d8(%rsp)
lea    0x1(%rdi,%rsi,1),%rax
mov    %rax,0x1f8(%rsp)
mov    %r14,%rax
mov    %r14,0x180(%rsp)
and    $0xfffffffffffffffe,%r14
mov    %r14,0x118(%rsp)
mov    %rbp,0x178(%rsp)
shl    $0x5,%rbp
mov    $0x1,%eax
mov    0x18(%rsp),%rsi
sub    %rsi,%rax
mov    %rax,0x1c8(%rsp)
lea    0xc(%rbx),%rdi
mov    %rdi,%rax
mov    %rdi,0xb0(%rsp)
sub    %rsi,%rdi
mov    %rdi,0xf8(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0x210(%rsp)
mov    %rdx,0x168(%rsp)
shl    $0x5,%rdx
mov    %rdx,0xa8(%rsp)
mov    %esi,%r11d
neg    %r11d
mov    0x60(%rsp),%rax
add    $0x7,%eax
mov    %rax,0x60(%rsp)
mov    0x70(%rsp),%rax
movslq %eax,%rdx
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
mov    %ecx,%eax
mov    %rax,0x228(%rsp)
mov    0xc8(%rsp),%rax
lea    0x1(%rdx,%rax,1),%rax
mov    %rax,0x1e8(%rsp)
lea    0x1(%r8),%eax
mov    %eax,0x3c(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%rsi,1),%rax
mov    %rax,0x130(%rsp)
mov    %r9,0x170(%rsp)
lea    (%r9,%rbx,1),%rax
mov    %rax,0x160(%rsp)
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rdx,1),%rax
mov    %rax,0x128(%rsp)
lea    (%rcx,%r12,1),%eax
mov    %eax,0x90(%rsp)
mov    0xb8(%rsp),%rax
add    %rbx,%rax
mov    %rax,0x158(%rsp)
lea    0xc(%rsi),%rax
mov    %rax,0xd8(%rsp)
mov    %rdx,0x40(%rsp)
lea    0xc(%rdx),%rax
mov    %rax,0xe8(%rsp)
mov    %ebx,%eax
mov    %rax,0x78(%rsp)
xor    %r14d,%r14d
mov    %r15,0x28(%rsp)
mov    %r13,0x88(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x50(%rsp)
mov    %r12,0x1f0(%rsp)
mov    %rbp,0x230(%rsp)
jmp    1584 <dedisperse_kernel_lagged+0x474>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    0x228(%rsp),%r14
mov    0x10(%rsp),%rbx
mov    0x230(%rsp),%rbp
mov    0x50(%rsp),%r11
je     2097 <dedisperse_kernel_lagged+0xf87>
test   %r12d,%r12d
jle    1730 <dedisperse_kernel_lagged+0x620>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x8(%r13,%rax,1),%rsi
mov    (%r15,%r14,8),%rdi
cmp    $0x8,%r12d
jb     15c7 <dedisperse_kernel_lagged+0x4b7>
mov    0x30(%rsp),%rax
lea    (%rsi,%rax,4),%rax
cmp    %rax,%rdi
jae    164e <dedisperse_kernel_lagged+0x53e>
mov    0x30(%rsp),%rax
lea    (%rdi,%rax,4),%rax
cmp    %rax,%rsi
jae    164e <dedisperse_kernel_lagged+0x53e>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    0x30(%rsp),%rax
mov    0x220(%rsp),%rdx
test   %rdx,%rdx
je     1604 <dedisperse_kernel_lagged+0x4f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    15f0 <dedisperse_kernel_lagged+0x4e0>
cmp    $0x3,%rax
jb     1730 <dedisperse_kernel_lagged+0x620>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,0x30(%rsp)
jne    1610 <dedisperse_kernel_lagged+0x500>
jmp    1730 <dedisperse_kernel_lagged+0x620>
cmpq   $0x18,0x1b8(%rsp)
jae    165d <dedisperse_kernel_lagged+0x54d>
xor    %eax,%eax
jmp    16c8 <dedisperse_kernel_lagged+0x5b8>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdi,%rax,4)
movups %xmm1,0x30(%rdi,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdi,%rax,4)
movups %xmm1,0x50(%rdi,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdi,%rax,4)
movups %xmm1,0x70(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1670 <dedisperse_kernel_lagged+0x560>
cmpq   $0x0,0x178(%rsp)
je     170b <dedisperse_kernel_lagged+0x5fb>
lea    (%rdi,%rax,4),%rcx
add    $0x10,%rcx
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    16f0 <dedisperse_kernel_lagged+0x5e0>
mov    0x1c0(%rsp),%rax
mov    %rax,%rcx
cmp    0x30(%rsp),%rax
jne    15c9 <dedisperse_kernel_lagged+0x4b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    0x20(%rsp),%r12d
jge    1940 <dedisperse_kernel_lagged+0x830>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x0(%r13,%rax,1),%rbp
mov    0x8(%r13,%rax,1),%rsi
mov    (%r15,%r14,8),%rdi
mov    0x18(%rsp),%rax
cmpq   $0x8,0x48(%rsp)
jae    17e0 <dedisperse_kernel_lagged+0x6d0>
mov    0x20(%rsp),%rdx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     178c <dedisperse_kernel_lagged+0x67c>
mov    %rax,%rcx
sub    0x18(%rsp),%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x208(%rsp),%rax
je     1940 <dedisperse_kernel_lagged+0x830>
mov    0x1c8(%rsp),%rax
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
movss  -0x4(%rax,%rcx,4),%xmm0
addss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  (%rax,%rcx,4),%xmm0
addss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    17b0 <dedisperse_kernel_lagged+0x6a0>
jmp    1940 <dedisperse_kernel_lagged+0x830>
nop
mov    0x18(%rsp),%rax
lea    (%rdi,%rax,4),%r8
lea    (%rdi,%rbx,4),%rdx
mov    0x48(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
lea    (%rsi,%rax,4),%r11
mov    0x10(%rsp),%rbx
lea    (%rsi,%rbx,4),%rbx
cmp    %rcx,%r8
setb   %r15b
cmp    %rdx,%rbp
setb   %r13b
cmp    %rbx,%r8
mov    0x1f0(%rsp),%r12
mov    0x10(%rsp),%rbx
setb   %cl
cmp    %rdx,%r11
mov    0x50(%rsp),%r11
setb   %dl
test   %r13b,%r15b
mov    0x88(%rsp),%r13
mov    0x28(%rsp),%r15
jne    1761 <dedisperse_kernel_lagged+0x651>
mov    0x18(%rsp),%rax
and    %dl,%cl
jne    1761 <dedisperse_kernel_lagged+0x651>
cmpq   $0x8,0x150(%rsp)
jae    1868 <dedisperse_kernel_lagged+0x758>
xor    %ecx,%ecx
jmp    18e0 <dedisperse_kernel_lagged+0x7d0>
mov    0xd8(%rsp),%rcx
lea    (%rdi,%rcx,4),%rax
lea    (%rsi,%rcx,4),%rbx
mov    0xe0(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
movups -0x30(%rbx,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rbx,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x30(%rax,%rcx,4)
movups %xmm0,-0x20(%rax,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm0
movups 0x30(%rbp,%rcx,4),%xmm1
movups -0x10(%rbx,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups (%rbx,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x10(%rax,%rcx,4)
movups %xmm0,(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1890 <dedisperse_kernel_lagged+0x780>
testb  $0x1,0x148(%rsp)
01
mov    0x10(%rsp),%rbx
je     1919 <dedisperse_kernel_lagged+0x809>
mov    0x18(%rsp),%rax
add    %rcx,%rax
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
movups (%rsi,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdi,%rax,4)
movups %xmm0,0x10(%rdi,%rax,4)
mov    0x130(%rsp),%rax
mov    0x98(%rsp),%rcx
cmp    %rcx,0x48(%rsp)
jne    1761 <dedisperse_kernel_lagged+0x651>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r12d,%r12d
jle    1a63 <dedisperse_kernel_lagged+0x953>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x0(%r13,%rax,1),%rdi
mov    (%r15,%r14,8),%rsi
mov    %rbx,%rax
cmpq   $0x8,0x68(%rsp)
jb     1a40 <dedisperse_kernel_lagged+0x930>
lea    (%rsi,%rbx,4),%rax
mov    0x200(%rsp),%rcx
lea    (%rdi,%rcx,4),%rcx
cmp    %rcx,%rax
jae    199e <dedisperse_kernel_lagged+0x88e>
mov    0x1e0(%rsp),%rax
lea    (%rsi,%rax,4),%rcx
mov    0x48(%rsp),%rax
lea    (%rdi,%rax,4),%rdx
mov    %rbx,%rax
cmp    %rcx,%rdx
jb     1a40 <dedisperse_kernel_lagged+0x930>
cmpq   $0x8,0x1b0(%rsp)
jae    19ad <dedisperse_kernel_lagged+0x89d>
xor    %eax,%eax
jmp    1a00 <dedisperse_kernel_lagged+0x8f0>
mov    0xb0(%rsp),%rax
lea    (%rsi,%rax,4),%rcx
mov    0xf8(%rsp),%rax
lea    (%rdi,%rax,4),%rdx
mov    0x100(%rsp),%rbp
xor    %eax,%eax
nop
movups -0x30(%rdx,%rax,4),%xmm0
movups -0x20(%rdx,%rax,4),%xmm1
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movups -0x10(%rdx,%rax,4),%xmm0
movups (%rdx,%rax,4),%xmm1
movups %xmm0,-0x10(%rcx,%rax,4)
movups %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    19d0 <dedisperse_kernel_lagged+0x8c0>
testb  $0x1,0x1a8(%rsp)
01
je     1a27 <dedisperse_kernel_lagged+0x917>
add    %rbx,%rax
mov    %rax,%rcx
sub    0x18(%rsp),%rcx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
mov    0x160(%rsp),%rax
mov    0x170(%rsp),%rcx
cmp    %rcx,0x68(%rsp)
je     1a63 <dedisperse_kernel_lagged+0x953>
xchg   %ax,%ax
mov    0x210(%rsp),%rcx
lea    (%rdi,%rcx,4),%rcx
nopl   0x0(%rax)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %r10,%rax
jl     1a50 <dedisperse_kernel_lagged+0x940>
test   %r12d,%r12d
mov    0x70(%rsp),%rbp
mov    0x78(%rsp),%rbx
js     1c10 <dedisperse_kernel_lagged+0xb00>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x80(%rsp),%rcx
add    %r14,%rcx
mov    0x8(%r13,%rax,1),%rsi
mov    (%r15,%rcx,8),%rdi
cmp    $0x8,%ebp
jb     1aa8 <dedisperse_kernel_lagged+0x998>
lea    (%rsi,%rbp,4),%rax
cmp    %rax,%rdi
jae    1b1c <dedisperse_kernel_lagged+0xa0c>
lea    (%rdi,%rbp,4),%rax
cmp    %rax,%rsi
jae    1b1c <dedisperse_kernel_lagged+0xa0c>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %rbp,%rax
mov    0x218(%rsp),%rdx
test   %rdx,%rdx
je     1ad4 <dedisperse_kernel_lagged+0x9c4>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1ac0 <dedisperse_kernel_lagged+0x9b0>
cmp    $0x3,%rax
jb     1c10 <dedisperse_kernel_lagged+0xb00>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1ae0 <dedisperse_kernel_lagged+0x9d0>
jmp    1c10 <dedisperse_kernel_lagged+0xb00>
cmpq   $0x18,0x198(%rsp)
jae    1b33 <dedisperse_kernel_lagged+0xa23>
xor    %eax,%eax
mov    0xa8(%rsp),%rbx
jmp    1ba8 <dedisperse_kernel_lagged+0xa98>
mov    0x108(%rsp),%rcx
xor    %eax,%eax
mov    0xa8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdi,%rax,4)
movups %xmm1,0x30(%rdi,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdi,%rax,4)
movups %xmm1,0x50(%rdi,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdi,%rax,4)
movups %xmm1,0x70(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1b50 <dedisperse_kernel_lagged+0xa40>
cmpq   $0x0,0x168(%rsp)
je     1beb <dedisperse_kernel_lagged+0xadb>
lea    (%rdi,%rax,4),%rcx
add    $0x10,%rcx
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbx
jne    1bd0 <dedisperse_kernel_lagged+0xac0>
mov    0x1a0(%rsp),%rax
mov    %rax,%rcx
cmp    %rbp,%rax
mov    0x78(%rsp),%rbx
jne    1aaa <dedisperse_kernel_lagged+0x99a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    0x20(%rsp),%ebp
jge    1e70 <dedisperse_kernel_lagged+0xd60>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x80(%rsp),%rcx
add    %r14,%rcx
mov    0x88(%rsp),%rdx
mov    (%rdx,%rax,1),%rsi
mov    0x8(%rdx,%rax,1),%r15
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,8),%r13
mov    0x40(%rsp),%r9
mov    %r12d,%ecx
cmpl   $0x7,0xc8(%rsp)
07
jge    1c70 <dedisperse_kernel_lagged+0xb60>
mov    0x20(%rsp),%rax
sub    %r9d,%eax
test   $0x1,%al
jne    1d90 <dedisperse_kernel_lagged+0xc80>
mov    %r9,%rdi
jmp    1daf <dedisperse_kernel_lagged+0xc9f>
mov    0x40(%rsp),%r9
lea    0x0(,%r9,4),%rax
add    %r13,%rax
mov    0x1e8(%rsp),%rdi
lea    0x0(%r13,%rdi,4),%rcx
lea    (%r15,%r9,4),%rdx
lea    (%r15,%rdi,4),%rdi
mov    0xc0(%rsp),%rbp
lea    (%rsi,%rbp,4),%rbp
cmp    %rdi,%rax
setb   %bl
cmp    %rcx,%rdx
setb   %dl
cmp    %rbp,%rax
setb   %al
cmp    %rcx,%rsi
setb   %dil
movabs $0x1000000000,%r8
mov    %r12d,%ecx
test   %dl,%bl
mov    0x78(%rsp),%rbx
jne    1c58 <dedisperse_kernel_lagged+0xb48>
mov    0x40(%rsp),%r9
mov    %r12d,%ecx
and    %dil,%al
jne    1c58 <dedisperse_kernel_lagged+0xb48>
cmpq   $0x0,0x140(%rsp)
je     1e04 <dedisperse_kernel_lagged+0xcf4>
mov    0xe8(%rsp),%rax
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
lea    (%r15,%rax,4),%rbp
mov    0xf0(%rsp),%r11
xor    %eax,%eax
xor    %ecx,%ecx
movabs $0x800000000,%r9
nopl   (%rax)
mov    %rax,%rdx
sar    $0x1e,%rdx
movups (%rsi,%rdx,1),%xmm0
movups 0x10(%rsi,%rdx,1),%xmm1
movups -0x30(%rbp,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rbp,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x30(%rdi,%rcx,4)
movups %xmm0,-0x20(%rdi,%rcx,4)
lea    (%rax,%r9,1),%rdx
sar    $0x1e,%rdx
movups (%rsi,%rdx,1),%xmm0
movups 0x10(%rsi,%rdx,1),%xmm1
movups -0x10(%rbp,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x0(%rbp,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x10(%rdi,%rcx,4)
movups %xmm0,(%rdi,%rcx,4)
add    $0x10,%rcx
add    %r8,%rax
add    $0xfffffffffffffffe,%r11
jne    1d20 <dedisperse_kernel_lagged+0xc10>
jmp    1e06 <dedisperse_kernel_lagged+0xcf6>
cs nopw 0x0(%rax,%rax,1)
sub    %r12d,%ecx
movslq %ecx,%rax
movss  (%rsi,%rax,4),%xmm0
addss  (%r15,%r9,4),%xmm0
movss  %xmm0,0x0(%r13,%r9,4)
lea    0x1(%r9),%rdi
mov    %r9d,%ecx
not    %r9d
cmp    0x94(%rsp),%r9d
je     1e70 <dedisperse_kernel_lagged+0xd60>
sub    %r12d,%ecx
movslq %ecx,%rax
movss  (%rsi,%rax,4),%xmm0
addss  (%r15,%rdi,4),%xmm0
movss  %xmm0,0x0(%r13,%rdi,4)
lea    (%r11,%rdi,1),%eax
cltq
movss  (%rsi,%rax,4),%xmm0
addss  0x4(%r15,%rdi,4),%xmm0
movss  %xmm0,0x4(%r13,%rdi,4)
lea    0x1(%rdi),%ecx
mov    %rdi,%rax
add    $0x2,%rax
mov    %rax,%rdi
cmp    %eax,%ebx
jne    1dc0 <dedisperse_kernel_lagged+0xcb0>
jmp    1e70 <dedisperse_kernel_lagged+0xd60>
xor    %ecx,%ecx
testb  $0x1,0x138(%rsp)
01
mov    0x50(%rsp),%r11
je     1e46 <dedisperse_kernel_lagged+0xd36>
mov    0x40(%rsp),%rax
add    %rcx,%rax
movslq %ecx,%rcx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups (%r15,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x0(%r13,%rax,4)
movups %xmm0,0x10(%r13,%rax,4)
mov    0x128(%rsp),%r9
mov    0x90(%rsp),%ecx
mov    0xa0(%rsp),%rax
cmp    %rax,0xc0(%rsp)
jne    1c58 <dedisperse_kernel_lagged+0xb48>
nopl   0x0(%rax,%rax,1)
test   %r12d,%r12d
mov    0x28(%rsp),%r15
mov    0x88(%rsp),%r13
js     1560 <dedisperse_kernel_lagged+0x450>
mov    %r14,%rax
shl    $0x4,%rax
mov    0x0(%r13,%rax,1),%rsi
mov    0x80(%rsp),%rax
add    %r14,%rax
mov    (%r15,%rax,8),%rdi
mov    0x10(%rsp),%rcx
cmpb   $0x0,0xf(%rsp)
jne    1fc0 <dedisperse_kernel_lagged+0xeb0>
mov    0x10(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    0x1f8(%rsp),%rcx
lea    (%rsi,%rcx,4),%rcx
cmp    %rcx,%rax
jae    1ef1 <dedisperse_kernel_lagged+0xde1>
mov    0x1d0(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    0x1d8(%rsp),%rcx
lea    (%rsi,%rcx,4),%rdx
mov    0x10(%rsp),%rcx
cmp    %rax,%rdx
jb     1fc0 <dedisperse_kernel_lagged+0xeb0>
cmpq   $0x0,0x188(%rsp)
je     2082 <dedisperse_kernel_lagged+0xf72>
mov    0xb0(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    0x118(%rsp),%rdx
xor    %ecx,%ecx
mov    0x60(%rsp),%r11
mov    0x120(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%rcx,1),%ebp
movslq %ebp,%rbp
movups (%rsi,%rbp,4),%xmm0
movups 0x10(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x30(%rax,%rcx,4)
movups %xmm1,-0x20(%rax,%rcx,4)
lea    (%r11,%rcx,1),%ebp
movslq %ebp,%rbp
movups (%rsi,%rbp,4),%xmm0
movups 0x10(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x10(%rax,%rcx,4)
movups %xmm1,(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1f30 <dedisperse_kernel_lagged+0xe20>
testb  $0x1,0x180(%rsp)
01
je     1f9b <dedisperse_kernel_lagged+0xe8b>
mov    0x10(%rsp),%rax
add    %rcx,%rax
add    0x20(%rsp),%ecx
add    0x58(%rsp),%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
mov    0x158(%rsp),%rcx
mov    0xb8(%rsp),%rax
cmp    %rax,0x190(%rsp)
je     1560 <dedisperse_kernel_lagged+0x450>
nopl   0x0(%rax)
mov    0x3c(%rsp),%edx
sub    %ecx,%edx
mov    0xd0(%rsp),%rax
sub    %ecx,%eax
and    $0x3,%edx
je     1ffd <dedisperse_kernel_lagged+0xeed>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x58(%rsp),%rbp
add    %ecx,%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    1fe0 <dedisperse_kernel_lagged+0xed0>
cmp    $0x3,%eax
jb     1560 <dedisperse_kernel_lagged+0x450>
mov    0x3c(%rsp),%eax
mov    %eax,%r11d
sub    %ecx,%r11d
lea    (%rdi,%rcx,4),%rdi
add    $0xc,%rdi
mov    0x50(%rsp),%rax
add    %ecx,%eax
mov    0x58(%rsp),%rdx
add    %edx,%ecx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbx,1),%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,-0xc(%rdi,%rbx,4)
lea    (%rax,%rbx,1),%rdx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rdi,%rbx,4)
lea    0x1(%rdx),%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rbx,4)
add    $0x2,%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
add    $0x4,%rbx
cmp    %ebx,%r11d
jne    2030 <dedisperse_kernel_lagged+0xf20>
jmp    1560 <dedisperse_kernel_lagged+0x450>
xor    %ecx,%ecx
testb  $0x1,0x180(%rsp)
01
jne    1f76 <dedisperse_kernel_lagged+0xe66>
jmp    1f9b <dedisperse_kernel_lagged+0xe8b>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dedisperse_kernel_lagged(float** %0, float** %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca float**
%7 = alloca float**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
store float** %0, float*** %6
store float** %1, float*** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%19 = load i32, i32* %8
%20 = srem i32 %19, 2
%21 = icmp eq i32 %20, 0
%22 = zext i1 %21 to i32
%23 = call i32 @assert(i32 %22)
%24 = load i32, i32* %8
%25 = sdiv i32 %24, 2
store i32 %25, i32* %11
store i32 0, i32* %12
br label %26
26: ; preds = %246, %5
%27 = load i32, i32* %12
%28 = load i32, i32* %11
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %249
30: ; preds = %26
store i32 0, i32* %13
br label %31
31: ; preds = %55, %30
%32 = load i32, i32* %13
%33 = load i32, i32* %10
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %58
35: ; preds = %31
%36 = load float**, float*** %6
%37 = load i32, i32* %12
%38 = mul nsw i32 2, %37
%39 = add nsw i32 %38, 1
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float*, float** %36, i64 %40
%42 = load float*, float** %41
%43 = load i32, i32* %13
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
%46 = load float, float* %45
%47 = load float**, float*** %7
%48 = load i32, i32* %12
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float*, float** %47, i64 %49
%51 = load float*, float** %50
%52 = load i32, i32* %13
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
store float %46, float* %54
br label %55
55: ; preds = %35
%56 = load i32, i32* %13
%57 = add nsw i32 %56, 1
store i32 %57, i32* %13
br label %31
58: ; preds = %31
%59 = load i32, i32* %10
store i32 %59, i32* %14
br label %60
60: ; preds = %97, %58
%61 = load i32, i32* %14
%62 = load i32, i32* %9
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %100
64: ; preds = %60
%65 = load float**, float*** %6
%66 = load i32, i32* %12
%67 = mul nsw i32 2, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float*, float** %65, i64 %68
%70 = load float*, float** %69
%71 = load i32, i32* %14
%72 = load i32, i32* %10
%73 = sub nsw i32 %71, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %70, i64 %74
%76 = load float, float* %75
%77 = load float**, float*** %6
%78 = load i32, i32* %12
%79 = mul nsw i32 2, %78
%80 = add nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float*, float** %77, i64 %81
%83 = load float*, float** %82
%84 = load i32, i32* %14
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
%87 = load float, float* %86
%88 = fadd float %76, %87
%89 = load float**, float*** %7
%90 = load i32, i32* %12
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float*, float** %89, i64 %91
%93 = load float*, float** %92
%94 = load i32, i32* %14
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %93, i64 %95
store float %88, float* %96
br label %97
97: ; preds = %64
%98 = load i32, i32* %14
%99 = add nsw i32 %98, 1
store i32 %99, i32* %14
br label %60
100: ; preds = %60
%101 = load i32, i32* %9
store i32 %101, i32* %15
br label %102
102: ; preds = %129, %100
%103 = load i32, i32* %15
%104 = load i32, i32* %9
%105 = load i32, i32* %10
%106 = add nsw i32 %104, %105
%107 = icmp slt i32 %103, %106
br i1 %107, label %108, label %132
108: ; preds = %102
%109 = load float**, float*** %6
%110 = load i32, i32* %12
%111 = mul nsw i32 2, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float*, float** %109, i64 %112
%114 = load float*, float** %113
%115 = load i32, i32* %15
%116 = load i32, i32* %10
%117 = sub nsw i32 %115, %116
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %114, i64 %118
%120 = load float, float* %119
%121 = load float**, float*** %7
%122 = load i32, i32* %12
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float*, float** %121, i64 %123
%125 = load float*, float** %124
%126 = load i32, i32* %15
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
store float %120, float* %128
br label %129
129: ; preds = %108
%130 = load i32, i32* %15
%131 = add nsw i32 %130, 1
store i32 %131, i32* %15
br label %102
132: ; preds = %102
store i32 0, i32* %16
br label %133
133: ; preds = %160, %132
%134 = load i32, i32* %16
%135 = load i32, i32* %10
%136 = add nsw i32 %135, 1
%137 = icmp slt i32 %134, %136
br i1 %137, label %138, label %163
138: ; preds = %133
%139 = load float**, float*** %6
%140 = load i32, i32* %12
%141 = mul nsw i32 2, %140
%142 = add nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float*, float** %139, i64 %143
%145 = load float*, float** %144
%146 = load i32, i32* %16
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %145, i64 %147
%149 = load float, float* %148
%150 = load float**, float*** %7
%151 = load i32, i32* %12
%152 = load i32, i32* %11
%153 = add nsw i32 %151, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float*, float** %150, i64 %154
%156 = load float*, float** %155
%157 = load i32, i32* %16
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %156, i64 %158
store float %149, float* %159
br label %160
160: ; preds = %138
%161 = load i32, i32* %16
%162 = add nsw i32 %161, 1
store i32 %162, i32* %16
br label %133
163: ; preds = %133
%164 = load i32, i32* %10
%165 = add nsw i32 %164, 1
store i32 %165, i32* %17
br label %166
166: ; preds = %206, %163
%167 = load i32, i32* %17
%168 = load i32, i32* %9
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %209
170: ; preds = %166
%171 = load float**, float*** %6
%172 = load i32, i32* %12
%173 = mul nsw i32 2, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float*, float** %171, i64 %174
%176 = load float*, float** %175
%177 = load i32, i32* %17
%178 = load i32, i32* %10
%179 = sub nsw i32 %177, %178
%180 = sub nsw i32 %179, 1
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %176, i64 %181
%183 = load float, float* %182
%184 = load float**, float*** %6
%185 = load i32, i32* %12
%186 = mul nsw i32 2, %185
%187 = add nsw i32 %186, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float*, float** %184, i64 %188
%190 = load float*, float** %189
%191 = load i32, i32* %17
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %190, i64 %192
%194 = load float, float* %193
%195 = fadd float %183, %194
%196 = load float**, float*** %7
%197 = load i32, i32* %12
%198 = load i32, i32* %11
%199 = add nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float*, float** %196, i64 %200
%202 = load float*, float** %201
%203 = load i32, i32* %17
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %202, i64 %204
store float %195, float* %205
br label %206
206: ; preds = %170
%207 = load i32, i32* %17
%208 = add nsw i32 %207, 1
store i32 %208, i32* %17
br label %166
209: ; preds = %166
%210 = load i32, i32* %9
store i32 %210, i32* %18
br label %211
211: ; preds = %242, %209
%212 = load i32, i32* %18
%213 = load i32, i32* %9
%214 = load i32, i32* %10
%215 = add nsw i32 %213, %214
%216 = add nsw i32 %215, 1
%217 = icmp slt i32 %212, %216
br i1 %217, label %218, label %245
218: ; preds = %211
%219 = load float**, float*** %6
%220 = load i32, i32* %12
%221 = mul nsw i32 2, %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float*, float** %219, i64 %222
%224 = load float*, float** %223
%225 = load i32, i32* %18
%226 = load i32, i32* %10
%227 = sub nsw i32 %225, %226
%228 = sub nsw i32 %227, 1
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %224, i64 %229
%231 = load float, float* %230
%232 = load float**, float*** %7
%233 = load i32, i32* %12
%234 = load i32, i32* %11
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float*, float** %232, i64 %236
%238 = load float*, float** %237
%239 = load i32, i32* %18
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %238, i64 %240
store float %231, float* %241
br label %242
242: ; preds = %218
%243 = load i32, i32* %18
%244 = add nsw i32 %243, 1
store i32 %244, i32* %18
br label %211
245: ; preds = %211
br label %246
246: ; preds = %245
%247 = load i32, i32* %12
%248 = add nsw i32 %247, 1
store i32 %248, i32* %12
br label %26
249: ; preds = %26
ret void
}

LLVM IR (-O2):
define void @dedisperse_kernel_lagged(float** nocapture %0, float** nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = and i32 %2, 1
%7 = xor i32 %6, 1
%8 = tail call i32 @assert(i32 %7)
%9 = sdiv i32 %2, 2
%10 = icmp sgt i32 %2, 1
br i1 %10, label %11, label %236
11: ; preds = %5
%12 = icmp sgt i32 %4, 0
%13 = icmp slt i32 %4, %3
%14 = add i32 %4, %3
%15 = icmp slt i32 %4, 0
%16 = add i32 %4, 1
%17 = icmp slt i32 %16, %3
%18 = xor i32 %4, -1
%19 = sext i32 %4 to i64
%20 = sext i32 %3 to i64
%21 = sext i32 %14 to i64
%22 = sext i32 %16 to i64
%23 = call i32 @llvm.smax.i32(i32 %3, i32 %14)
%24 = add i32 %23, 1
%25 = sext i32 %9 to i64
%26 = zext i32 %9 to i64
%27 = zext i32 %4 to i64
%28 = zext i32 %16 to i64
%29 = sub i32 %23, %3
%30 = xor i32 %4, -1
%31 = add i32 %30, %3
%32 = zext i32 %29 to i64
%33 = add nsw i64 %20, %32
%34 = add nsw i64 %33, 1
%35 = sext i32 %31 to i64
%36 = add nsw i64 %35, %32
%37 = add nsw i64 %36, 1
%38 = sub i32 %23, %3
%39 = zext i32 %38 to i64
%40 = add nuw nsw i64 %39, 1
%41 = add i32 %3, -2
%42 = sub i32 %41, %4
%43 = zext i32 %42 to i64
%44 = add nsw i64 %22, %43
%45 = add nsw i64 %44, 1
%46 = add nuw nsw i64 %43, 1
%47 = zext i32 %42 to i64
%48 = add nuw nsw i64 %47, 1
%49 = add nsw i64 %20, 1
%50 = call i64 @llvm.smax.i64(i64 %49, i64 %21)
%51 = sub nsw i64 %20, %19
%52 = sub i64 %50, %19
%53 = add nsw i64 %20, 1
%54 = call i64 @llvm.smax.i64(i64 %53, i64 %21)
%55 = sub i64 %54, %20
%56 = and i64 %27, 4294967288
%57 = add nsw i64 %56, -8
%58 = lshr exact i64 %57, 3
%59 = add nuw nsw i64 %58, 1
%60 = add nsw i64 %51, -8
%61 = lshr i64 %60, 3
%62 = add nuw nsw i64 %61, 1
%63 = add i64 %55, -8
%64 = lshr i64 %63, 3
%65 = add nuw nsw i64 %64, 1
%66 = and i64 %28, 4294967288
%67 = add nsw i64 %66, -8
%68 = lshr exact i64 %67, 3
%69 = add nuw nsw i64 %68, 1
%70 = and i64 %48, 8589934584
%71 = add nsw i64 %70, -8
%72 = lshr exact i64 %71, 3
%73 = add nuw nsw i64 %72, 1
%74 = and i64 %40, 8589934584
%75 = add nsw i64 %74, -8
%76 = lshr exact i64 %75, 3
%77 = add nuw nsw i64 %76, 1
%78 = add i32 %23, 1
%79 = icmp ult i32 %4, 8
%80 = and i64 %27, 4294967288
%81 = and i64 %59, 3
%82 = icmp ult i64 %57, 24
%83 = and i64 %59, 4611686018427387900
%84 = icmp eq i64 %81, 0
%85 = icmp eq i64 %80, %27
%86 = and i64 %27, 3
%87 = icmp eq i64 %86, 0
%88 = icmp ult i64 %51, 8
%89 = and i64 %51, -8
%90 = add nsw i64 %89, %19
%91 = and i64 %62, 1
%92 = icmp ult i64 %60, 8
%93 = and i64 %62, 4611686018427387902
%94 = icmp eq i64 %91, 0
%95 = icmp eq i64 %51, %89
%96 = sub nsw i64 0, %20
%97 = icmp ult i64 %55, 8
%98 = and i64 %55, -8
%99 = add i64 %98, %20
%100 = and i64 %65, 1
%101 = icmp ult i64 %63, 8
%102 = and i64 %65, 4611686018427387902
%103 = icmp eq i64 %100, 0
%104 = icmp eq i64 %55, %98
%105 = icmp ult i32 %16, 8
%106 = and i64 %28, 4294967288
%107 = and i64 %69, 3
%108 = icmp ult i64 %67, 24
%109 = and i64 %69, 4611686018427387900
%110 = icmp eq i64 %107, 0
%111 = icmp eq i64 %106, %28
%112 = and i64 %28, 3
%113 = icmp eq i64 %112, 0
%114 = icmp slt i32 %42, 7
%115 = and i64 %48, 8589934584
%116 = add nsw i64 %115, %22
%117 = trunc i64 %115 to i32
%118 = add i32 %117, %4
%119 = and i64 %73, 1
%120 = icmp eq i64 %71, 0
%121 = and i64 %73, 4611686018427387902
%122 = icmp eq i64 %119, 0
%123 = icmp eq i64 %48, %115
%124 = sub i32 0, %3
%125 = icmp ult i32 %38, 7
%126 = add i32 %23, %30
%127 = icmp slt i32 %126, %31
%128 = or i1 %125, %127
%129 = and i64 %40, 8589934584
%130 = add nsw i64 %129, %20
%131 = and i64 %77, 1
%132 = icmp eq i64 %75, 0
%133 = and i64 %77, 4611686018427387902
%134 = icmp eq i64 %131, 0
%135 = icmp eq i64 %40, %129
br label %136
136: ; preds = %11, %819
%137 = phi i64 [ 0, %11 ], [ %820, %819 ]
br i1 %12, label %138, label %237
138: ; preds = %136
%139 = shl nuw nsw i64 %137, 1
%140 = or i64 %139, 1
%141 = getelementptr inbounds float*, float** %0, i64 %140
%142 = load float*, float** %141
%143 = getelementptr inbounds float*, float** %1, i64 %137
%144 = load float*, float** %143
br i1 %79, label %220, label %145
145: ; preds = %138
%146 = getelementptr float, float* %144, i64 %27
%147 = getelementptr float, float* %142, i64 %27
%148 = icmp ult float* %144, %147
%149 = icmp ult float* %142, %146
%150 = and i1 %148, %149
br i1 %150, label %220, label %151
151: ; preds = %145
br i1 %82, label %201, label %152
152: ; preds = %151, %152
%153 = phi i64 [ %198, %152 ], [ 0, %151 ]
%154 = phi i64 [ %199, %152 ], [ 0, %151 ]
%155 = getelementptr inbounds float, float* %142, i64 %153
%156 = bitcast float* %155 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = getelementptr inbounds float, float* %155, i64 4
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %144, i64 %153
%162 = bitcast float* %161 to <4 x float>*
store <4 x float> %157, <4 x float>* %162
%163 = getelementptr inbounds float, float* %161, i64 4
%164 = bitcast float* %163 to <4 x float>*
store <4 x float> %160, <4 x float>* %164
%165 = or i64 %153, 8
%166 = getelementptr inbounds float, float* %142, 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 = getelementptr inbounds float, float* %144, i64 %165
%173 = bitcast float* %172 to <4 x float>*
store <4 x float> %168, <4 x float>* %173
%174 = getelementptr inbounds float, float* %172, i64 4
%175 = bitcast float* %174 to <4 x float>*
store <4 x float> %171, <4 x float>* %175
%176 = or i64 %153, 16
%177 = getelementptr inbounds float, float* %142, i64 %176
%178 = bitcast float* %177 to <4 x float>*
%179 = load <4 x float>, <4 x float>* %178
%180 = getelementptr inbounds float, float* %177, i64 4
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = getelementptr inbounds float, float* %144, i64 %176
%184 = bitcast float* %183 to <4 x float>*
store <4 x float> %179, <4 x float>* %184
%185 = getelementptr inbounds float, float* %183, i64 4
%186 = bitcast float* %185 to <4 x float>*
store <4 x float> %182, <4 x float>* %186
%187 = or i64 %153, 24
%188 = getelementptr inbounds float, float* %142, i64 %187
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = getelementptr inbounds float, float* %188, i64 4
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = getelementptr inbounds float, float* %144, i64 %187
%195 = bitcast float* %194 to <4 x float>*
store <4 x float> %190, <4 x float>* %195
%196 = getelementptr inbounds float, float* %194, i64 4
%197 = bitcast float* %196 to <4 x float>*
store <4 x float> %193, <4 x float>* %197
%198 = add nuw i64 %153, 32
%199 = add i64 %154, 4
%200 = icmp eq i64 %199, %83
br i1 %200, label %201, label %152
201: ; preds = %152, %151
%202 = phi i64 [ 0, %151 ], [ %198, %152 ]
br i1 %84, label %219, label %203
203: ; preds = %201, %203
%204 = phi i64 [ %216, %203 ], [ %202, %201 ]
%205 = phi i64 [ %217, %203 ], [ 0, %201 ]
%206 = getelementptr inbounds float, float* %142, i64 %204
%207 = bitcast float* %206 to <4 x float>*
%208 = load <4 x float>, <4 x float>* %207
%209 = getelementptr inbounds float, float* %206, i64 4
%210 = bitcast float* %209 to <4 x float>*
%211 = load <4 x float>, <4 x float>* %210
%212 = getelementptr inbounds float, float* %144, i64 %204
%213 = bitcast float* %212 to <4 x float>*
store <4 x float> %208, <4 x float>* %213
%214 = getelementptr inbounds float, float* %212, i64 4
%215 = bitcast float* %214 to <4 x float>*
store <4 x float> %211, <4 x float>* %215
%216 = add nuw i64 %204, 8
%217 = add i64 %205, 1
%218 = icmp eq i64 %217, %81
br i1 %218, label %219, label %203
219: ; preds = %203, %201
br i1 %85, label %237, label %220
220: ; preds = %145, %138, %219
%221 = phi i64 [ 0, %145 ], [ 0, %138 ], [ %80, %219 ]
%222 = xor i64 %221, -1
%223 = add nsw i64 %222, %27
br i1 %87, label %233, label %224
224: ; preds = %220, %224
%225 = phi i64 [ %230, %224 ], [ %221, %220 ]
%226 = phi i64 [ %231, %224 ], [ 0, %220 ]
%227 = getelementptr inbounds float, float* %142, i64 %225
%228 = load float, float* %227
%229 = getelementptr inbounds float, float* %144, i64 %225
store float %228, float* %229
%230 = add nuw nsw i64 %225, 1
%231 = add i64 %226, 1
%232 = icmp eq i64 %231, %86
br i1 %232, label %233, label %224
233: ; preds = %224, %220
%234 = phi i64 [ %221, %220 ], [ %230, %224 ]
%235 = icmp ult i64 %223, 3
br i1 %235, label %237, label %347
236: ; preds = %819, %5
ret void
237: ; preds = %233, %347, %219, %136
br i1 %13, label %238, label %366
238: ; preds = %237
%239 = shl nuw nsw i64 %137, 1
%240 = getelementptr inbounds float*, float** %0, i64 %239
%241 = load float*, float** %240
%242 = or i64 %239, 1
%243 = getelementptr inbounds float*, float** %0, i64 %242
%244 = load float*, float** %243
%245 = getelementptr inbounds float*, float** %1, i64 %137
%246 = load float*, float** %245
br i1 %88, label %329, label %247
247: ; preds = %238
%248 = getelementptr float, float* %246, i64 %19
%249 = getelementptr float, float* %246, i64 %20
%250 = getelementptr float, float* %241, i64 %51
%251 = getelementptr float, float* %244, i64 %19
%252 = getelementptr float, float* %244, i64 %20
%253 = icmp ult float* %248, %250
%254 = icmp ult float* %241, %249
%255 = and i1 %253, %254
%256 = icmp ult float* %248, %252
%257 = icmp ult float* %251, %249
%258 = and i1 %256, %257
%259 = or i1 %255, %258
br i1 %259, label %329, label %260
260: ; preds = %247
br i1 %92, label %306, label %261
261: ; preds = %260, %261
%262 = phi i64 [ %303, %261 ], [ 0, %260 ]
%263 = phi i64 [ %304, %261 ], [ 0, %260 ]
%264 = add i64 %262, %19
%265 = getelementptr inbounds float, float* %241, i64 %262
%266 = bitcast float* %265 to <4 x float>*
%267 = load <4 x float>, <4 x float>* %266
%268 = getelementptr inbounds float, float* %265, i64 4
%269 = bitcast float* %268 to <4 x float>*
%270 = load <4 x float>, <4 x float>* %269
%271 = getelementptr inbounds float, float* %244, i64 %264
%272 = bitcast float* %271 to <4 x float>*
%273 = load <4 x float>, <4 x float>* %272
%274 = getelementptr inbounds float, float* %271, i64 4
%275 = bitcast float* %274 to <4 x float>*
%276 = load <4 x float>, <4 x float>* %275
%277 = fadd <4 x float> %267, %273
%278 = fadd <4 x float> %270, %276
%279 = getelementptr inbounds float, float* %246, i64 %264
%280 = bitcast float* %279 to <4 x float>*
store <4 x float> %277, <4 x float>* %280
%281 = getelementptr inbounds float, float* %279, i64 4
%282 = bitcast float* %281 to <4 x float>*
store <4 x float> %278, <4 x float>* %282
%283 = or i64 %262, 8
%284 = add i64 %283, %19
%285 = getelementptr inbounds float, float* %241, i64 %283
%286 = bitcast float* %285 to <4 x float>*
%287 = load <4 x float>, <4 x float>* %286
%288 = getelementptr inbounds float, float* %285, i64 4
%289 = bitcast float* %288 to <4 x float>*
%290 = load <4 x float>, <4 x float>* %289
%291 = getelementptr inbounds float, float* %244, i64 %284
%292 = bitcast float* %291 to <4 x float>*
%293 = load <4 x float>, <4 x float>* %292
%294 = getelementptr inbounds float, float* %291, i64 4
%295 = bitcast float* %294 to <4 x float>*
%296 = load <4 x float>, <4 x float>* %295
%297 = fadd <4 x float> %287, %293
%298 = fadd <4 x float> %290, %296
%299 = getelementptr inbounds float, float* %246, i64 %284
%300 = bitcast float* %299 to <4 x float>*
store <4 x float> %297, <4 x float>* %300
%301 = getelementptr inbounds float, float* %299, i64 4
%302 = bitcast float* %301 to <4 x float>*
store <4 x float> %298, <4 x float>* %302
%303 = add nuw i64 %262, 16
%304 = add i64 %263, 2
%305 = icmp eq i64 %304, %93
br i1 %305, label %306, label %261
306: ; preds = %261, %260
%307 = phi i64 [ 0, %260 ], [ %303, %261 ]
br i1 %94, label %328, label %308
308: ; preds = %306
%309 = add i64 %307, %19
%310 = getelementptr inbounds float, float* %241, i64 %307
%311 = bitcast float* %310 to <4 x float>*
%312 = load <4 x float>, <4 x float>* %311
%313 = getelementptr inbounds float, float* %310, i64 4
%314 = bitcast float* %313 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = getelementptr inbounds float, float* %244, i64 %309
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = getelementptr inbounds float, float* %316, i64 4
%320 = bitcast float* %319 to <4 x float>*
%321 = load <4 x float>, <4 x float>* %320
%322 = fadd <4 x float> %312, %318
%323 = fadd <4 x float> %315, %321
%324 = getelementptr inbounds float, float* %246, i64 %309
%325 = bitcast float* %324 to <4 x float>*
store <4 x float> %322, <4 x float>* %325
%326 = getelementptr inbounds float, float* %324, i64 4
%327 = bitcast float* %326 to <4 x float>*
store <4 x float> %323, <4 x float>* %327
br label %328
328: ; preds = %306, %308
br i1 %95, label %366, label %329
329: ; preds = %247, %238, %328
%330 = phi i64 [ %19, %247 ], [ %19, %238 ], [ %90, %328 ]
%331 = sub nsw i64 %20, %330
%332 = xor i64 %330, -1
%333 = and i64 %331, 1
%334 = icmp eq i64 %333, 0
br i1 %334, label %344, label %335
335: ; preds = %329
%336 = sub nsw i64 %330, %19
%337 = getelementptr inbounds float, float* %241, i64 %336
%338 = load float, float* %337
%339 = getelementptr inbounds float, float* %244, i64 %330
%340 = load float, float* %339
%341 = fadd float %338, %340
%342 = getelementptr inbounds float, float* %246, i64 %330
store float %341, float* %342
%343 = add nsw i64 %330, 1
br label %344
344: ; preds = %335, %329
%345 = phi i64 [ %330, %329 ], [ %343, %335 ]
%346 = icmp eq i64 %332, %96
br i1 %346, label %366, label %431
347: ; preds = %233, %347
%348 = phi i64 [ %364, %347 ], [ %234, %233 ]
%349 = getelementptr inbounds float, float* %142, i64 %348
%350 = load float, float* %349
%351 = getelementptr inbounds float, float* %144, i64 %348
store float %350, float* %351
%352 = add nuw nsw i64 %348, 1
%353 = getelementptr inbounds float, float* %142, i64 %352
%354 = load float, float* %353
%355 = getelementptr inbounds float, float* %144, i64 %352
store float %354, float* %355
%356 = add nuw nsw i64 %348, 2
%357 = getelementptr inbounds float, float* %142, i64 %356
%358 = load float, float* %357
%359 = getelementptr inbounds float, float* %144, i64 %356
store float %358, float* %359
%360 = add nuw nsw i64 %348, 3
%361 = getelementptr inbounds float, float* %142, i64 %360
%362 = load float, float* %361
%363 = getelementptr inbounds float, float* %144, i64 %360
store float %362, float* %363
%364 = add nuw nsw i64 %348, 4
%365 = icmp eq i64 %364, %27
br i1 %365, label %237, label %347
366: ; preds = %344, %431, %328, %237
br i1 %12, label %367, label %450
367: ; preds = %366
%368 = shl nuw nsw i64 %137, 1
%369 = getelementptr inbounds float*, float** %0, i64 %368
%370 = load float*, float** %369
%371 = getelementptr inbounds float*, float** %1, i64 %137
%372 = load float*, float** %371
br i1 %97, label %429, label %373
373: ; preds = %367
%374 = getelementptr float, float* %372, i64 %20
%375 = getelementptr float, float* %372, i64 %50
%376 = getelementptr float, float* %370, i64 %51
%377 = getelementptr float, float* %370, i64 %52
%378 = icmp ult float* %374, %377
%379 = icmp ult float* %376, %375
%380 = and i1 %378, %379
br i1 %380, label %429, label %381
381: ; preds = %373
br i1 %101, label %413, label %382
382: ; preds = %381, %382
%383 = phi i64 [ %410, %382 ], [ 0, %381 ]
%384 = phi i64 [ %411, %382 ], [ 0, %381 ]
%385 = add i64 %383, %20
%386 = sub nsw i64 %385, %19
%387 = getelementptr inbounds float, float* %370, i64 %386
%388 = bitcast float* %387 to <4 x float>*
%389 = load <4 x float>, <4 x float>* %388
%390 = getelementptr inbounds float, float* %387, i64 4
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = getelementptr inbounds float, float* %372, i64 %385
%394 = bitcast float* %393 to <4 x float>*
store <4 x float> %389, <4 x float>* %394
%395 = getelementptr inbounds float, float* %393, i64 4
%396 = bitcast float* %395 to <4 x float>*
store <4 x float> %392, <4 x float>* %396
%397 = or i64 %383, 8
%398 = add i64 %397, %20
%399 = sub nsw i64 %398, %19
%400 = getelementptr inbounds float, float* %370, i64 %399
%401 = bitcast float* %400 to <4 x float>*
%402 = load <4 x float>, <4 x float>* %401
%403 = getelementptr inbounds float, float* %400, i64 4
%404 = bitcast float* %403 to <4 x float>*
%405 = load <4 x float>, <4 x float>* %404
%406 = getelementptr inbounds float, float* %372, i64 %398
%407 = bitcast float* %406 to <4 x float>*
store <4 x float> %402, <4 x float>* %407
%408 = getelementptr inbounds float, float* %406, i64 4
%409 = bitcast float* %408 to <4 x float>*
store <4 x float> %405, <4 x float>* %409
%410 = add nuw i64 %383, 16
%411 = add i64 %384, 2
%412 = icmp eq i64 %411, %102
br i1 %412, label %413, label %382
413: ; preds = %382, %381
%414 = phi i64 [ 0, %381 ], [ %410, %382 ]
br i1 %103, label %428, label %415
415: ; preds = %413
%416 = add i64 %414, %20
%417 = sub nsw i64 %416, %19
%418 = getelementptr inbounds float, float* %370, i64 %417
%419 = bitcast float* %418 to <4 x float>*
%420 = load <4 x float>, <4 x float>* %419
%421 = getelementptr inbounds float, float* %418, i64 4
%422 = bitcast float* %421 to <4 x float>*
%423 = load <4 x float>, <4 x float>* %422
%424 = getelementptr inbounds float, float* %372, i64 %416
%425 = bitcast float* %424 to <4 x float>*
store <4 x float> %420, <4 x float>* %425
%426 = getelementptr inbounds float, float* %424, i64 4
%427 = bitcast float* %426 to <4 x float>*
store <4 x float> %423, <4 x float>* %427
br label %428
428: ; preds = %413, %415
br i1 %104, label %450, label %429
429: ; preds = %373, %367, %428
%430 = phi i64 [ %20, %373 ], [ %20, %367 ], [ %99, %428 ]
br label %550
431: ; preds = %344, %431
%432 = phi i64 [ %448, %431 ], [ %345, %344 ]
%433 = sub nsw i64 %432, %19
%434 = getelementptr inbounds float, float* %241, i64 %433
%435 = load float, float* %434
%436 = getelementptr inbounds float, float* %244, i64 %432
%437 = load float, float* %436
%438 = fadd float %435, %437
%439 = getelementptr inbounds float, float* %246, i64 %432
store float %438, float* %439
%440 = add nsw i64 %432, 1
%441 = sub nsw i64 %440, %19
%442 = getelementptr inbounds float, float* %241, i64 %441
%443 = load float, float* %442
%444 = getelementptr inbounds float, float* %244, i64 %440
%445 = load float, float* %444
%446 = fadd float %443, %445
%447 = getelementptr inbounds float, float* %246, i64 %440
store float %446, float* %447
%448 = add nsw i64 %432, 2
%449 = icmp eq i64 %448, %20
br i1 %449, label %366, label %431
450: ; preds = %550, %428, %366
br i1 %15, label %558, label %451
451: ; preds = %450
%452 = shl nuw nsw i64 %137, 1
%453 = or i64 %452, 1
%454 = getelementptr inbounds float*, float** %0, i64 %453
%455 = load float*, float** %454
%456 = add nsw i64 %137, %25
%457 = getelementptr inbounds float*, float** %1, i64 %456
%458 = load float*, float** %457
br i1 %105, label %534, label %459
459: ; preds = %451
%460 = getelementptr float, float* %458, i64 %28
%461 = getelementptr float, float* %455, i64 %28
%462 = icmp ult float* %458, %461
%463 = icmp ult float* %455, %460
%464 = and i1 %462, %463
br i1 %464, label %534, label %465
465: ; preds = %459
br i1 %108, label %515, label %466
466: ; preds = %465, %466
%467 = phi i64 [ %512, %466 ], [ 0, %465 ]
%468 = phi i64 [ %513, %466 ], [ 0, %465 ]
%469 = getelementptr inbounds float, float* %455, i64 %467
%470 = bitcast float* %469 to <4 x float>*
%471 = load <4 x float>, <4 x float>* %470
%472 = getelementptr inbounds float, float* %469, i64 4
%473 = bitcast float* %472 to <4 x float>*
%474 = load <4 x float>, <4 x float>* %473
%475 = getelementptr inbounds float, float* %458, i64 %467
%476 = bitcast float* %475 to <4 x float>*
store <4 x float> %471, <4 x float>* %476
%477 = getelementptr inbounds float, float* %475, i64 4
%478 = bitcast float* %477 to <4 x float>*
store <4 x float> %474, <4 x float>* %478
%479 = or i64 %467, 8
%480 = getelementptr inbounds float, float* %455, i64 %479
%481 = bitcast float* %480 to <4 x float>*
%482 = load <4 x float>, <4 x float>* %481
%483 = getelementptr inbounds float, float* %480, i64 4
%484 = bitcast float* %483 to <4 x float>*
%485 = load <4 x float>, <4 x float>* %484
%486 = getelementptr inbounds float, float* %458, i64 %479
%487 = bitcast float* %486 to <4 x float>*
store <4 x float> %482, <4 x float>* %487
%488 = getelementptr inbounds float, float* %486, i64 4
%489 = bitcast float* %488 to <4 x float>*
store <4 x float> %485, <4 x float>* %489
%490 = or i64 %467, 16
%491 = getelementptr inbounds float, float* %455, i64 %490
%492 = bitcast float* %491 to <4 x float>*
%493 = load <4 x float>, <4 x float>* %492
%494 = getelementptr inbounds float, float* %491, i64 4
%495 = bitcast float* %494 to <4 x float>*
%496 = load <4 x float>, <4 x float>* %495
%497 = getelementptr inbounds float, float* %458, i64 %490
%498 = bitcast float* %497 to <4 x float>*
store <4 x float> %493, <4 x float>* %498
%499 = getelementptr inbounds float, float* %497, i64 4
%500 = bitcast float* %499 to <4 x float>*
store <4 x float> %496, <4 x float>* %500
%501 = or i64 %467, 24
%502 = getelementptr inbounds float, float* %455, i64 %501
%503 = bitcast float* %502 to <4 x float>*
%504 = load <4 x float>, <4 x float>* %503
%505 = getelementptr inbounds float, float* %502, i64 4
%506 = bitcast float* %505 to <4 x float>*
%507 = load <4 x float>, <4 x float>* %506
%508 = getelementptr inbounds float, float* %458, i64 %501
%509 = bitcast float* %508 to <4 x float>*
store <4 x float> %504, <4 x float>* %509
%510 = getelementptr inbounds float, float* %508, i64 4
%511 = bitcast float* %510 to <4 x float>*
store <4 x float> %507, <4 x float>* %511
%512 = add nuw i64 %467, 32
%513 = add i64 %468, 4
%514 = icmp eq i64 %513, %109
br i1 %514, label %515, label %466
515: ; preds = %466, %465
%516 = phi i64 [ 0, %465 ], [ %512, %466 ]
br i1 %110, label %533, label %517
517: ; preds = %515, %517
%518 = phi i64 [ %530, %517 ], [ %516, %515 ]
%519 = phi i64 [ %531, %517 ], [ 0, %515 ]
%520 = getelementptr inbounds float, float* %455, i64 %518
%521 = bitcast float* %520 to <4 x float>*
%522 = load <4 x float>, <4 x float>* %521
%523 = getelementptr inbounds float, float* %520, i64 4
%524 = bitcast float* %523 to <4 x float>*
%525 = load <4 x float>, <4 x float>* %524
%526 = getelementptr inbounds float, float* %458, i64 %518
%527 = bitcast float* %526 to <4 x float>*
store <4 x float> %522, <4 x float>* %527
%528 = getelementptr inbounds float, float* %526, i64 4
%529 = bitcast float* %528 to <4 x float>*
store <4 x float> %525, <4 x float>* %529
%530 = add nuw i64 %518, 8
%531 = add i64 %519, 1
%532 = icmp eq i64 %531, %107
br i1 %532, label %533, label %517
533: ; preds = %517, %515
br i1 %111, label %558, label %534
534: ; preds = %459, %451, %533
%535 = phi i64 [ 0, %459 ], [ 0, %451 ], [ %106, %533 ]
%536 = xor i64 %535, -1
%537 = add nsw i64 %536, %28
br i1 %113, label %547, label %538
538: ; preds = %534, %538
%539 = phi i64 [ %544, %538 ], [ %535, %534 ]
%540 = phi i64 [ %545, %538 ], [ 0, %534 ]
%541 = getelementptr inbounds float, float* %455, i64 %539
%542 = load float, float* %541
%543 = getelementptr inbounds float, float* %458, i64 %539
store float %542, float* %543
%544 = add nuw nsw i64 %539, 1
%545 = add i64 %540, 1
%546 = icmp eq i64 %545, %112
br i1 %546, label %547, label %538
547: ; preds = %538, %534
%548 = phi i64 [ %535, %534 ], [ %544, %538 ]
%549 = icmp ult i64 %537, 3
br i1 %549, label %558, label %680
550: ; preds = %429, %550
%551 = phi i64 [ %556, %550 ], [ %430, %429 ]
%552 = sub nsw i64 %551, %19
%553 = getelementptr inbounds float, float* %370, i64 %552
%554 = load float, float* %553
%555 = getelementptr inbounds float, float* %372, i64 %551
store float %554, float* %555
%556 = add nsw i64 %551, 1
%557 = icmp slt i64 %556, %21
br i1 %557, label %550, label %450
558: ; preds = %547, %680, %533, %450
br i1 %17, label %559, label %699
559: ; preds = %558
%560 = shl nuw nsw i64 %137, 1
%561 = getelementptr inbounds float*, float** %0, i64 %560
%562 = load float*, float** %561
%563 = or i64 %560, 1
%564 = getelementptr inbounds float*, float** %0, i64 %563
%565 = load float*, float** %564
%566 = add nsw i64 %137, %25
%567 = getelementptr inbounds float*, float** %1, i64 %566
%568 = load float*, float** %567
br i1 %114, label %657, label %569
569: ; preds = %559
%570 = getelementptr float, float* %568, i64 %22
%571 = getelementptr float, float* %568, i64 %45
%572 = getelementptr float, float* %565, i64 %22
%573 = getelementptr float, float* %565, i64 %45
%574 = getelementptr float, float* %562, i64 %46
%575 = icmp ult float* %570, %573
%576 = icmp ult float* %572, %571
%577 = and i1 %575, %576
%578 = icmp ult float* %570, %574
%579 = icmp ult float* %562, %571
%580 = and i1 %578, %579
%581 = or i1 %577, %580
br i1 %581, label %657, label %582
582: ; preds = %569
br i1 %120, label %632, label %583
583: ; preds = %582, %583
%584 = phi i64 [ %629, %583 ], [ 0, %582 ]
%585 = phi i64 [ %630, %583 ], [ 0, %582 ]
%586 = add i64 %584, %22
%587 = shl i64 %584, 32
%588 = ashr exact i64 %587, 32
%589 = getelementptr inbounds float, float* %562, i64 %588
%590 = bitcast float* %589 to <4 x float>*
%591 = load <4 x float>, <4 x float>* %590
%592 = getelementptr inbounds float, float* %589, i64 4
%593 = bitcast float* %592 to <4 x float>*
%594 = load <4 x float>, <4 x float>* %593
%595 = getelementptr inbounds float, float* %565, i64 %586
%596 = bitcast float* %595 to <4 x float>*
%597 = load <4 x float>, <4 x float>* %596
%598 = getelementptr inbounds float, float* %595, i64 4
%599 = bitcast float* %598 to <4 x float>*
%600 = load <4 x float>, <4 x float>* %599
%601 = fadd <4 x float> %591, %597
%602 = fadd <4 x float> %594, %600
%603 = getelementptr inbounds float, float* %568, i64 %586
%604 = bitcast float* %603 to <4 x float>*
store <4 x float> %601, <4 x float>* %604
%605 = getelementptr inbounds float, float* %603, i64 4
%606 = bitcast float* %605 to <4 x float>*
store <4 x float> %602, <4 x float>* %606
%607 = or i64 %584, 8
%608 = add i64 %607, %22
%609 = shl i64 %607, 32
%610 = ashr exact i64 %609, 32
%611 = getelementptr inbounds float, float* %562, i64 %610
%612 = bitcast float* %611 to <4 x float>*
%613 = load <4 x float>, <4 x float>* %612
%614 = getelementptr inbounds float, float* %611, i64 4
%615 = bitcast float* %614 to <4 x float>*
%616 = load <4 x float>, <4 x float>* %615
%617 = getelementptr inbounds float, float* %565, i64 %608
%618 = bitcast float* %617 to <4 x float>*
%619 = load <4 x float>, <4 x float>* %618
%620 = getelementptr inbounds float, float* %617, i64 4
%621 = bitcast float* %620 to <4 x float>*
%622 = load <4 x float>, <4 x float>* %621
%623 = fadd <4 x float> %613, %619
%624 = fadd <4 x float> %616, %622
%625 = getelementptr inbounds float, float* %568, i64 %608
%626 = bitcast float* %625 to <4 x float>*
store <4 x float> %623, <4 x float>* %626
%627 = getelementptr inbounds float, float* %625, i64 4
%628 = bitcast float* %627 to <4 x float>*
store <4 x float> %624, <4 x float>* %628
%629 = add nuw i64 %584, 16
%630 = add i64 %585, 2
%631 = icmp eq i64 %630, %121
br i1 %631, label %632, label %583
632: ; preds = %583, %582
%633 = phi i64 [ 0, %582 ], [ %629, %583 ]
br i1 %122, label %656, label %634
634: ; preds = %632
%635 = add i64 %633, %22
%636 = shl i64 %633, 32
%637 = ashr exact i64 %636, 32
%638 = getelementptr inbounds float, float* %562, i64 %637
%639 = bitcast float* %638 to <4 x float>*
%640 = load <4 x float>, <4 x float>* %639
%641 = getelementptr inbounds float, float* %638, i64 4
%642 = bitcast float* %641 to <4 x float>*
%643 = load <4 x float>, <4 x float>* %642
%644 = getelementptr inbounds float, float* %565, i64 %635
%645 = bitcast float* %644 to <4 x float>*
%646 = load <4 x float>, <4 x float>* %645
%647 = getelementptr inbounds float, float* %644, i64 4
%648 = bitcast float* %647 to <4 x float>*
%649 = load <4 x float>, <4 x float>* %648
%650 = fadd <4 x float> %640, %646
%651 = fadd <4 x float> %643, %649
%652 = getelementptr inbounds float, float* %568, i64 %635
%653 = bitcast float* %652 to <4 x float>*
store <4 x float> %650, <4 x float>* %653
%654 = getelementptr inbounds float, float* %652, i64 4
%655 = bitcast float* %654 to <4 x float>*
store <4 x float> %651, <4 x float>* %655
br label %656
656: ; preds = %632, %634
br i1 %123, label %699, label %657
657: ; preds = %569, %559, %656
%658 = phi i64 [ %22, %569 ], [ %22, %559 ], [ %116, %656 ]
%659 = phi i32 [ %4, %569 ], [ %4, %559 ], [ %118, %656 ]
%660 = trunc i64 %658 to i32
%661 = sub i32 %3, %660
%662 = xor i32 %660, -1
%663 = and i32 %661, 1
%664 = icmp eq i32 %663, 0
br i1 %664, label %676, label %665
665: ; preds = %657
%666 = sub i32 %659, %4
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds float, float* %562, i64 %667
%669 = load float, float* %668
%670 = getelementptr inbounds float, float* %565, i64 %658
%671 = load float, float* %670
%672 = fadd float %669, %671
%673 = getelementptr inbounds float, float* %568, i64 %658
store float %672, float* %673
%674 = add nsw i64 %658, 1
%675 = trunc i64 %658 to i32
br label %676
676: ; preds = %665, %657
%677 = phi i64 [ %658, %657 ], [ %674, %665 ]
%678 = phi i32 [ %659, %657 ], [ %675, %665 ]
%679 = icmp eq i32 %662, %124
br i1 %679, label %699, label %794
680: ; preds = %547, %680
%681 = phi i64 [ %697, %680 ], [ %548, %547 ]
%682 = getelementptr inbounds float, float* %455, i64 %681
%683 = load float, float* %682
%684 = getelementptr inbounds float, float* %458, i64 %681
store float %683, float* %684
%685 = add nuw nsw i64 %681, 1
%686 = getelementptr inbounds float, float* %455, i64 %685
%687 = load float, float* %686
%688 = getelementptr inbounds float, float* %458, i64 %685
store float %687, float* %688
%689 = add nuw nsw i64 %681, 2
%690 = getelementptr inbounds float, float* %455, i64 %689
%691 = load float, float* %690
%692 = getelementptr inbounds float, float* %458, i64 %689
store float %691, float* %692
%693 = add nuw nsw i64 %681, 3
%694 = getelementptr inbounds float, float* %455, i64 %693
%695 = load float, float* %694
%696 = getelementptr inbounds float, float* %458, i64 %693
store float %695, float* %696
%697 = add nuw nsw i64 %681, 4
%698 = icmp eq i64 %697, %28
br i1 %698, label %558, label %680
699: ; preds = %676, %794, %656, %558
br i1 %15, label %819, label %700
700: ; preds = %699
%701 = shl nuw nsw i64 %137, 1
%702 = getelementptr inbounds float*, float** %0, i64 %701
%703 = load float*, float** %702
%704 = add nsw i64 %137, %25
%705 = getelementptr inbounds float*, float** %1, i64 %704
%706 = load float*, float** %705
br i1 %128, label %772, label %707
707: ; preds = %700
%708 = getelementptr float, float* %706, i64 %20
%709 = getelementptr float, float* %706, i64 %34
%710 = getelementptr float, float* %703, i64 %35
%711 = getelementptr float, float* %703, i64 %37
%712 = icmp ult float* %708, %711
%713 = icmp ult float* %710, %709
%714 = and i1 %712, %713
br i1 %714, label %772, label %715
715: ; preds = %707
br i1 %132, label %753, label %716
716: ; preds = %715, %716
%717 = phi i64 [ %750, %716 ], [ 0, %715 ]
%718 = phi i64 [ %751, %716 ], [ 0, %715 ]
%719 = add i64 %717, %20
%720 = trunc i64 %717 to i32
%721 = add i32 %720, %3
%722 = add i32 %721, %18
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds float, float* %703, i64 %723
%725 = bitcast float* %724 to <4 x float>*
%726 = load <4 x float>, <4 x float>* %725
%727 = getelementptr inbounds float, float* %724, i64 4
%728 = bitcast float* %727 to <4 x float>*
%729 = load <4 x float>, <4 x float>* %728
%730 = getelementptr inbounds float, float* %706, i64 %719
%731 = bitcast float* %730 to <4 x float>*
store <4 x float> %726, <4 x float>* %731
%732 = getelementptr inbounds float, float* %730, i64 4
%733 = bitcast float* %732 to <4 x float>*
store <4 x float> %729, <4 x float>* %733
%734 = or i64 %717, 8
%735 = add i64 %734, %20
%736 = trunc i64 %734 to i32
%737 = add i32 %736, %3
%738 = add i32 %737, %18
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %703, i64 %739
%741 = bitcast float* %740 to <4 x float>*
%742 = load <4 x float>, <4 x float>* %741
%743 = getelementptr inbounds float, float* %740, i64 4
%744 = bitcast float* %743 to <4 x float>*
%745 = load <4 x float>, <4 x float>* %744
%746 = getelementptr inbounds float, float* %706, i64 %735
%747 = bitcast float* %746 to <4 x float>*
store <4 x float> %742, <4 x float>* %747
%748 = getelementptr inbounds float, float* %746, i64 4
%749 = bitcast float* %748 to <4 x float>*
store <4 x float> %745, <4 x float>* %749
%750 = add nuw i64 %717, 16
%751 = add i64 %718, 2
%752 = icmp eq i64 %751, %133
br i1 %752, label %753, label %716
753: ; preds = %716, %715
%754 = phi i64 [ 0, %715 ], [ %750, %716 ]
br i1 %134, label %771, label %755
755: ; preds = %753
%756 = add i64 %754, %20
%757 = trunc i64 %754 to i32
%758 = add i32 %757, %3
%759 = add i32 %758, %18
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %703, i64 %760
%762 = bitcast float* %761 to <4 x float>*
%763 = load <4 x float>, <4 x float>* %762
%764 = getelementptr inbounds float, float* %761, i64 4
%765 = bitcast float* %764 to <4 x float>*
%766 = load <4 x float>, <4 x float>* %765
%767 = getelementptr inbounds float, float* %706, i64 %756
%768 = bitcast float* %767 to <4 x float>*
store <4 x float> %763, <4 x float>* %768
%769 = getelementptr inbounds float, float* %767, i64 4
%770 = bitcast float* %769 to <4 x float>*
store <4 x float> %766, <4 x float>* %770
br label %771
771: ; preds = %753, %755
br i1 %135, label %819, label %772
772: ; preds = %707, %700, %771
%773 = phi i64 [ %20, %707 ], [ %20, %700 ], [ %130, %771 ]
%774 = trunc i64 %773 to i32
%775 = sub i32 %78, %774
%776 = sub i32 %23, %774
%777 = and i32 %775, 3
%778 = icmp eq i32 %777, 0
br i1 %778, label %791, label %779
779: ; preds = %772, %779
%780 = phi i64 [ %788, %779 ], [ %773, %772 ]
%781 = phi i32 [ %789, %779 ], [ 0, %772 ]
%782 = trunc i64 %780 to i32
%783 = add i32 %782, %18
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds float, float* %703, i64 %784
%786 = load float, float* %785
%787 = getelementptr inbounds float, float* %706, i64 %780
store float %786, float* %787
%788 = add nsw i64 %780, 1
%789 = add i32 %781, 1
%790 = icmp eq i32 %789, %777
br i1 %790, label %791, label %779
791: ; preds = %779, %772
%792 = phi i64 [ %773, %772 ], [ %788, %779 ]
%793 = icmp ult i32 %776, 3
br i1 %793, label %819, label %822
794: ; preds = %676, %794
%795 = phi i64 [ %815, %794 ], [ %677, %676 ]
%796 = phi i32 [ %816, %794 ], [ %678, %676 ]
%797 = sub i32 %796, %4
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds float, float* %562, i64 %798
%800 = load float, float* %799
%801 = getelementptr inbounds float, float* %565, i64 %795
%802 = load float, float* %801
%803 = fadd float %800, %802
%804 = getelementptr inbounds float, float* %568, i64 %795
store float %803, float* %804
%805 = add nsw i64 %795, 1
%806 = trunc i64 %795 to i32
%807 = sub i32 %806, %4
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds float, float* %562, i64 %808
%810 = load float, float* %809
%811 = getelementptr inbounds float, float* %565, i64 %805
%812 = load float, float* %811
%813 = fadd float %810, %812
%814 = getelementptr inbounds float, float* %568, i64 %805
store float %813, float* %814
%815 = add nsw i64 %795, 2
%816 = trunc i64 %805 to i32
%817 = trunc i64 %815 to i32
%818 = icmp eq i32 %817, %3
br i1 %818, label %699, label %794
819: ; preds = %791, %822, %771, %699
%820 = add nuw nsw i64 %137, 1
%821 = icmp eq i64 %820, %26
br i1 %821, label %236, label %136
822: ; preds = %791, %822
%823 = phi i64 [ %851, %822 ], [ %792, %791 ]
%824 = trunc i64 %823 to i32
%825 = add i32 %824, %18
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds float, float* %703, i64 %826
%828 = load float, float* %827
%829 = getelementptr inbounds float, float* %706, i64 %823
store float %828, float* %829
%830 = add nsw i64 %823, 1
%831 = trunc i64 %830 to i32
%832 = add i32 %831, %18
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %703, i64 %833
%835 = load float, float* %834
%836 = getelementptr inbounds float, float* %706, i64 %830
store float %835, float* %836
%837 = add nsw i64 %823, 2
%838 = trunc i64 %837 to i32
%839 = add i32 %838, %18
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds float, float* %703, i64 %840
%842 = load float, float* %841
%843 = getelementptr inbounds float, float* %706, i64 %837
store float %842, float* %843
%844 = add nsw i64 %823, 3
%845 = trunc i64 %844 to i32
%846 = add i32 %845, %18
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds float, float* %703, i64 %847
%849 = load float, float* %848
%850 = getelementptr inbounds float, float* %706, i64 %844
store float %849, float* %850
%851 = add nsw i64 %823, 4
%852 = trunc i64 %851 to i32
%853 = icmp eq i32 %24, %852
br i1 %853, label %819, label %822
}