void dedisperse_kernel(float **in, float **out, int n, int m) {
  int npair = n / 2;
  for (int jj = 0; jj < npair; jj++) {
    for (int i = 0; i < m; i++)
      out[jj][i] = in[2 * jj][i] + in[2 * jj + 1][i];
    for (int i = 0; i < m - jj - 1; i++)
      out[jj + npair][i] = in[2 * jj][i + jj] + in[2 * jj + 1][i + jj + 1];
  }
}


x86 assembly (clang, -O0):
<dedisperse_kernel>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    123a <dedisperse_kernel+0x13a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11a0 <dedisperse_kernel+0xa0>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113a <dedisperse_kernel+0x3a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1227 <dedisperse_kernel+0x127>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%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    11a7 <dedisperse_kernel+0xa7>
jmp    122c <dedisperse_kernel+0x12c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1127 <dedisperse_kernel+0x27>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dedisperse_kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,-0x40(%rsp)
mov    %rdi,-0x48(%rsp)
cmp    $0x2,%edx
jl     1631 <dedisperse_kernel+0x531>
mov    %edx,%eax
shr    $0x1f,%eax
add    %edx,%eax
sar    %eax
movslq %eax,%rdx
mov    %rdx,%rax
mov    %rdx,-0x10(%rsp)
mov    %edx,%eax
mov    %rax,-0x8(%rsp)
mov    %ecx,%r12d
lea    -0x1(%rcx),%eax
mov    %r12d,%edx
and    $0xfffffff8,%edx
mov    %rdx,-0x20(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x28(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,-0x30(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x38(%rsp)
mov    %r12d,%edi
and    $0x3,%edi
mov    $0xd,%esi
mov    $0xc,%edx
mov    %rdx,-0x50(%rsp)
mov    $0x1,%r10d
mov    $0x2,%r14d
xor    %r13d,%r13d
mov    %eax,-0x64(%rsp)
mov    %eax,%r11d
mov    %rcx,-0x70(%rsp)
mov    %rdi,-0x78(%rsp)
jmp    11db <dedisperse_kernel+0xdb>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
addq   $0x1,-0x50(%rsp)
add    $0xffffffff,%r11d
add    $0x1,%r10
add    $0x1,%r14
cmp    -0x8(%rsp),%r13
mov    -0x70(%rsp),%rcx
mov    -0x78(%rsp),%rdi
je     1631 <dedisperse_kernel+0x531>
mov    %rsi,(%rsp)
mov    %r13,%r15
test   %ecx,%ecx
jle    13af <dedisperse_kernel+0x2af>
mov    %r15,%rax
shl    $0x4,%rax
mov    -0x48(%rsp),%rsi
mov    (%rsi,%rax,1),%rdx
mov    0x8(%rsi,%rax,1),%rbx
mov    -0x40(%rsp),%rax
mov    (%rax,%r15,8),%rbp
cmp    $0x8,%ecx
jae    1220 <dedisperse_kernel+0x120>
xor    %eax,%eax
jmp    1330 <dedisperse_kernel+0x230>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x0(,%r12,4),%rax
add    %rbp,%rax
lea    (%rdx,%r12,4),%rcx
lea    (%rbx,%r12,4),%rdi
cmp    %rcx,%rbp
setb   %r8b
cmp    %rax,%rdx
setb   %r9b
cmp    %rdi,%rbp
setb   %cl
cmp    %rax,%rbx
setb   %dil
test   %r9b,%r8b
jne    131b <dedisperse_kernel+0x21b>
mov    $0x0,%eax
and    %dil,%cl
mov    -0x70(%rsp),%rcx
mov    -0x78(%rsp),%rdi
jne    1330 <dedisperse_kernel+0x230>
cmpq   $0x0,-0x28(%rsp)
je     1549 <dedisperse_kernel+0x449>
mov    -0x38(%rsp),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups (%rbx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rax,4)
movups %xmm0,0x10(%rbp,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups 0x20(%rbx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x30(%rbx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x20(%rbp,%rax,4)
movups %xmm0,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rsi
jne    1290 <dedisperse_kernel+0x190>
testb  $0x1,-0x30(%rsp)
je     1309 <dedisperse_kernel+0x209>
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups (%rbx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rax,4)
movups %xmm0,0x10(%rbp,%rax,4)
mov    -0x20(%rsp),%rsi
mov    %rsi,%rax
cmp    %r12,%rsi
jne    1330 <dedisperse_kernel+0x230>
jmp    13af <dedisperse_kernel+0x2af>
xor    %eax,%eax
mov    -0x70(%rsp),%rcx
mov    -0x78(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    %rax,%rsi
not    %rsi
add    %r12,%rsi
test   %rdi,%rdi
je     135a <dedisperse_kernel+0x25a>
xchg   %ax,%ax
movss  (%rdx,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1340 <dedisperse_kernel+0x240>
cmp    $0x3,%rsi
jb     13af <dedisperse_kernel+0x2af>
movss  (%rdx,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
movss  0x8(%rdx,%rax,4),%xmm0
addss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rbp,%rax,4)
movss  0xc(%rdx,%rax,4),%xmm0
addss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r12
jne    1360 <dedisperse_kernel+0x260>
mov    %r11d,%r11d
lea    0x1(%r15),%r13
mov    %r15d,%eax
not    %eax
add    %ecx,%eax
test   %eax,%eax
mov    (%rsp),%rsi
jle    11b0 <dedisperse_kernel+0xb0>
mov    -0x64(%rsp),%eax
mov    %eax,%edi
sub    %r15d,%edi
mov    %r15,%rax
shl    $0x4,%rax
mov    -0x48(%rsp),%rcx
mov    (%rcx,%rax,1),%rbx
mov    0x8(%rcx,%rax,1),%rbp
mov    -0x10(%rsp),%rax
add    %r15,%rax
mov    -0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%r8
cmp    $0x8,%edi
jae    1410 <dedisperse_kernel+0x310>
xor    %r9d,%r9d
jmp    15b0 <dedisperse_kernel+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%rdi,1),%rax
lea    (%r15,%rdi,1),%r9
add    $0x1,%r9
lea    (%r8,%rdi,4),%rdx
mov    %rbp,%rcx
mov    %rbx,%rbp
lea    (%rbx,%r15,4),%rbx
mov    %rbp,-0x80(%rsp)
lea    0x0(%rbp,%rax,4),%rax
mov    %r13,-0x58(%rsp)
lea    (%rcx,%r13,4),%rbp
mov    %rcx,-0x60(%rsp)
lea    (%rcx,%r9,4),%rcx
cmp    %rax,%r8
setb   %r9b
cmp    %rdx,%rbx
setb   %bl
cmp    %rcx,%r8
setb   %al
cmp    %rdx,%rbp
setb   %cl
test   %bl,%r9b
jne    1535 <dedisperse_kernel+0x435>
mov    $0x0,%r9d
and    %cl,%al
mov    -0x58(%rsp),%r13
mov    -0x80(%rsp),%rbx
mov    -0x60(%rsp),%rbp
jne    15b0 <dedisperse_kernel+0x4b0>
mov    %edi,%eax
and    $0xfffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,-0x18(%rsp)
je     155b <dedisperse_kernel+0x45b>
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
lea    0x0(,%rsi,4),%rdx
add    %rbp,%rdx
mov    -0x50(%rsp),%rax
lea    (%rbx,%rax,4),%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rbx,%rax,4),%xmm0
movups -0x20(%rbx,%rax,4),%xmm1
movups -0x30(%rdx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rdx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%r8,%rax,4)
movups %xmm0,0x10(%r8,%rax,4)
movups -0x10(%rbx,%rax,4),%xmm0
movups (%rbx,%rax,4),%xmm1
movups -0x10(%rdx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups (%rdx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x20(%r8,%rax,4)
movups %xmm0,0x30(%r8,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    14e0 <dedisperse_kernel+0x3e0>
jmp    155d <dedisperse_kernel+0x45d>
xor    %r9d,%r9d
mov    -0x58(%rsp),%r13
mov    -0x80(%rsp),%rbx
mov    -0x60(%rsp),%rbp
jmp    15b0 <dedisperse_kernel+0x4b0>
xor    %eax,%eax
testb  $0x1,-0x30(%rsp)
jne    12e7 <dedisperse_kernel+0x1e7>
jmp    1309 <dedisperse_kernel+0x209>
xor    %eax,%eax
mov    %edi,%r9d
and    $0xfffffff8,%r9d
testb  $0x1,-0x18(%rsp)
mov    -0x80(%rsp),%rbx
je     1598 <dedisperse_kernel+0x498>
lea    (%rax,%r15,1),%rcx
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups 0x4(%rbp,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%rbp,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%r8,%rax,4)
movups %xmm0,0x10(%r8,%rax,4)
cmp    %rdi,%r9
je     11b0 <dedisperse_kernel+0xb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9,%rax
test   $0x1,%dil
je     15d6 <dedisperse_kernel+0x4d6>
add    %r9,%r15
movss  (%rbx,%r15,4),%xmm0
addss  0x4(%rbp,%r15,4),%xmm0
movss  %xmm0,(%r8,%r9,4)
mov    %r9,%rax
or     $0x1,%rax
not    %r9
add    %rdi,%r9
je     11b0 <dedisperse_kernel+0xb0>
lea    (%rbx,%r10,4),%rcx
lea    0x0(,%r14,4),%rdx
add    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rax,4),%xmm0
addss  -0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
movss  (%rcx,%rax,4),%xmm0
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%r8,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1600 <dedisperse_kernel+0x500>
jmp    11b0 <dedisperse_kernel+0xb0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dedisperse_kernel(float** %0, float** %1, i32 %2, i32 %3) {
%5 = alloca float**
%6 = alloca float**
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store float** %0, float*** %5
store float** %1, float*** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%13 = load i32, i32* %7
%14 = sdiv i32 %13, 2
store i32 %14, i32* %9
store i32 0, i32* %10
br label %15
15: ; preds = %108, %4
%16 = load i32, i32* %10
%17 = load i32, i32* %9
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %111
19: ; preds = %15
store i32 0, i32* %11
br label %20
20: ; preds = %55, %19
%21 = load i32, i32* %11
%22 = load i32, i32* %8
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %58
24: ; preds = %20
%25 = load float**, float*** %5
%26 = load i32, i32* %10
%27 = mul nsw i32 2, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float*, float** %25, i64 %28
%30 = load float*, float** %29
%31 = load i32, i32* %11
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = load float**, float*** %5
%36 = load i32, i32* %10
%37 = mul nsw i32 2, %36
%38 = add nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float*, float** %35, i64 %39
%41 = load float*, float** %40
%42 = load i32, i32* %11
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
%45 = load float, float* %44
%46 = fadd float %34, %45
%47 = load float**, float*** %6
%48 = load i32, i32* %10
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float*, float** %47, i64 %49
%51 = load float*, float** %50
%52 = load i32, i32* %11
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
store float %46, float* %54
br label %55
55: ; preds = %24
%56 = load i32, i32* %11
%57 = add nsw i32 %56, 1
store i32 %57, i32* %11
br label %20
58: ; preds = %20
store i32 0, i32* %12
br label %59
59: ; preds = %104, %58
%60 = load i32, i32* %12
%61 = load i32, i32* %8
%62 = load i32, i32* %10
%63 = sub nsw i32 %61, %62
%64 = sub nsw i32 %63, 1
%65 = icmp slt i32 %60, %64
br i1 %65, label %66, label %107
66: ; preds = %59
%67 = load float**, float*** %5
%68 = load i32, i32* %10
%69 = mul nsw i32 2, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float*, float** %67, i64 %70
%72 = load float*, float** %71
%73 = load i32, i32* %12
%74 = load i32, i32* %10
%75 = add nsw i32 %73, %74
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %72, i64 %76
%78 = load float, float* %77
%79 = load float**, float*** %5
%80 = load i32, i32* %10
%81 = mul nsw i32 2, %80
%82 = add nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float*, float** %79, i64 %83
%85 = load float*, float** %84
%86 = load i32, i32* %12
%87 = load i32, i32* %10
%88 = add nsw i32 %86, %87
%89 = add nsw i32 %88, 1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %85, i64 %90
%92 = load float, float* %91
%93 = fadd float %78, %92
%94 = load float**, float*** %6
%95 = load i32, i32* %10
%96 = load i32, i32* %9
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float*, float** %94, i64 %98
%100 = load float*, float** %99
%101 = load i32, i32* %12
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %100, i64 %102
store float %93, float* %103
br label %104
104: ; preds = %66
%105 = load i32, i32* %12
%106 = add nsw i32 %105, 1
store i32 %106, i32* %12
br label %59
107: ; preds = %59
br label %108
108: ; preds = %107
%109 = load i32, i32* %10
%110 = add nsw i32 %109, 1
store i32 %110, i32* %10
br label %15
111: ; preds = %15
ret void
}

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