void dedisperse_blocked_cached(float **dat, float **dat2, int nchan, int ndat) {
  int nchan1 = 128;
  int chunk_size = 1024;
  int nchunk = ndat / chunk_size;
  int npass1 = get_npass(nchan1);
  int npass = get_npass(nchan);
  int npass2 = npass - npass1;
  int nchan2 = nchan / nchan1;
  int nblock = nchan / nchan1;
  int nblock2 = nchan / nchan2;
#pragma omp parallel
  {
    float **tmp1 = matrix(nchan1, chunk_size + nchan1);
    float **tmp2 = matrix(nchan1, chunk_size + nchan1);
#pragma omp for collapse(2) schedule(dynamic, 2)
    for (int i = 0; i < nblock; i++) {
      for (int j = 0; j < nchunk; j++) {
        int istart = j * chunk_size;
        int istop = (j + 1) * chunk_size + nchan1;
        if (istop > ndat) {
          istop = ndat;
          for (int k = 0; k < nchan1; k++)
            memset(tmp1[k] + chunk_size, 0, sizeof(float) * nchan1);
        }
        for (int k = 0; k < nchan1; k++)
          memcpy(tmp1[k], &(dat[i * nchan1 + k][istart]),
                 (istop - istart) * sizeof(float));
        dedisperse(tmp1, tmp2, nchan1, chunk_size + nchan1);
        for (int k = 0; k < nchan1; k++)
          memcpy(&(dat2[i * nchan1 + k][istart]), tmp1[k],
                 chunk_size * sizeof(float));
      }
    }
    free(tmp1[0]);
    free(tmp1);
    free(tmp2[0]);
    free(tmp2);
  }
  float **dat_shift = (float **)malloc(sizeof(float *) * nchan);
  for (int i = 0; i < nblock; i++)
    for (int j = 0; j < nchan1; j++)
      dat_shift[j * nblock + i] = dat2[i * nchan1 + j] + i * j;
  int nelem = nchan1 * chunk_size;
  chunk_size = nelem / nchan2;
  nchunk = ndat / chunk_size;
#pragma omp parallel
  {
    float **tmp1 = matrix(nchan2, chunk_size + nchan2);
    float **tmp2 = matrix(nchan2, chunk_size + nchan2);
#pragma omp for collapse(2) schedule(dynamic, 4)
    for (int i = 0; i < nblock2; i++) {
      for (int j = 0; j < nchunk; j++) {
        int istart = j * chunk_size;
        int istop = (j + 1) * chunk_size + nchan2;
        if (istop > ndat) {
          istop = ndat;
          for (int k = 0; k < nchan2; k++)
            memset(tmp1[k] + chunk_size, 0, sizeof(float) * nchan2);
        }
        for (int k = 0; k < nchan2; k++) {
          memcpy(tmp1[k], dat_shift[i * nchan2 + k] + istart,
                 (istop - istart) * sizeof(float));
        }
        dedisperse(tmp1, tmp2, nchan2, chunk_size + nchan2);
        for (int k = 0; k < nchan2; k++)
          memcpy(dat[i * nchan2 + k] + istart, tmp2[k],
                 chunk_size * sizeof(float));
      }
    }
    free(tmp1[0]);
    free(tmp1);
    free(tmp2[0]);
    free(tmp2);
  }
}


x86 assembly (clang, -O0):
<dedisperse_blocked_cached>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x80,-0x1c(%rbp)
movl   $0x400,-0x20(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x0,%al
call   1040 <get_npass@plt>
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x0,%al
call   1040 <get_npass@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
add    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <matrix@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
add    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <matrix@plt>
cltq
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13a3 <dedisperse_blocked_cached+0x233>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1390 <dedisperse_blocked_cached+0x220>
mov    -0x58(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
imul   -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    12ac <dedisperse_blocked_cached+0x13c>
mov    -0x18(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a7 <dedisperse_blocked_cached+0x137>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1267 <dedisperse_blocked_cached+0xf7>
jmp    12ac <dedisperse_blocked_cached+0x13c>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    130b <dedisperse_blocked_cached+0x19b>
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x5c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
movslq %eax,%rdx
shl    $0x2,%rdx
call   1060 <memcpy@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12b3 <dedisperse_blocked_cached+0x143>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    $0x0,%al
call   1090 <dedisperse@plt>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    137d <dedisperse_blocked_cached+0x20d>
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x5c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x20(%rbp),%rdx
shl    $0x2,%rdx
call   1060 <memcpy@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    132a <dedisperse_blocked_cached+0x1ba>
jmp    1382 <dedisperse_blocked_cached+0x212>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1228 <dedisperse_blocked_cached+0xb8>
jmp    1395 <dedisperse_blocked_cached+0x225>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1215 <dedisperse_blocked_cached+0xa5>
mov    -0x48(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    145f <dedisperse_blocked_cached+0x2ef>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    144c <dedisperse_blocked_cached+0x2dc>
mov    -0x10(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x7c(%rbp),%eax
imul   -0x80(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    13f8 <dedisperse_blocked_cached+0x288>
jmp    1451 <dedisperse_blocked_cached+0x2e1>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13e5 <dedisperse_blocked_cached+0x275>
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x20(%rbp),%esi
add    -0x34(%rbp),%esi
mov    $0x0,%al
call   1070 <matrix@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x20(%rbp),%esi
add    -0x34(%rbp),%esi
mov    $0x0,%al
call   1070 <matrix@plt>
cltq
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    16c8 <dedisperse_blocked_cached+0x558>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16af <dedisperse_blocked_cached+0x53f>
mov    -0xa0(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
imul   -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1583 <dedisperse_blocked_cached+0x413>
mov    -0x18(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    157e <dedisperse_blocked_cached+0x40e>
mov    -0x90(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x34(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    152f <dedisperse_blocked_cached+0x3bf>
jmp    1583 <dedisperse_blocked_cached+0x413>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1603 <dedisperse_blocked_cached+0x493>
mov    -0x90(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x78(%rbp),%rax
mov    -0x9c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0xb0(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0xa4(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0xa8(%rbp),%eax
sub    -0xa4(%rbp),%eax
movslq %eax,%rdx
shl    $0x2,%rdx
call   1060 <memcpy@plt>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    158d <dedisperse_blocked_cached+0x41d>
mov    -0x90(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    $0x0,%al
call   1090 <dedisperse@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1696 <dedisperse_blocked_cached+0x526>
mov    -0x8(%rbp),%rax
mov    -0x9c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0xb4(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0xa4(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x98(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x20(%rbp),%rdx
shl    $0x2,%rdx
call   1060 <memcpy@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    162b <dedisperse_blocked_cached+0x4bb>
jmp    169b <dedisperse_blocked_cached+0x52b>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    14d8 <dedisperse_blocked_cached+0x368>
jmp    16b4 <dedisperse_blocked_cached+0x544>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    14bf <dedisperse_blocked_cached+0x34f>
mov    -0x90(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dedisperse_blocked_cached>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %ecx,%r14d
mov    %edx,%r15d
mov    %rsi,0x28(%rsp)
mov    %rdi,0x60(%rsp)
mov    $0x80,%edi
xor    %eax,%eax
call   1040 <get_npass@plt>
mov    %r15d,%edi
xor    %eax,%eax
call   1040 <get_npass@plt>
lea    0x7f(%r15),%ebp
test   %r15d,%r15d
cmovns %r15d,%ebp
sar    $0x7,%ebp
mov    %r15d,%eax
cltd
idiv   %ebp
mov    %eax,0x20(%rsp)
mov    $0x80,%edi
mov    $0x480,%esi
xor    %eax,%eax
call   1070 <matrix@plt>
movslq %eax,%rbx
mov    $0x80,%edi
mov    $0x480,%esi
xor    %eax,%eax
call   1070 <matrix@plt>
cltq
mov    %rax,0x8(%rsp)
mov    %r14,0x10(%rsp)
movslq %r14d,%rax
mov    %rax,0x80(%rsp)
mov    %rbp,0x40(%rsp)
mov    %ebp,%eax
mov    %rax,0x18(%rsp)
mov    %r15,0x50(%rsp)
cmp    $0x80,%r15d
jl     145b <dedisperse_blocked_cached+0x2eb>
mov    0x10(%rsp),%rax
lea    0x3ff(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0xa,%ecx
mov    %rcx,0x88(%rsp)
mov    0x60(%rsp),%rax
lea    0x8(%rax),%rcx
mov    0x28(%rsp),%rax
lea    0x8(%rax),%r14
mov    $0x1000,%r15d
xor    %eax,%eax
jmp    1272 <dedisperse_blocked_cached+0x102>
mov    0x30(%rsp),%rax
add    $0x1,%rax
add    $0x400,%rcx
add    $0x400,%r14
cmp    0x18(%rsp),%rax
je     145b <dedisperse_blocked_cached+0x2eb>
mov    %rax,0x30(%rsp)
cmpl   $0x400,0x10(%rsp)
jl     1250 <dedisperse_blocked_cached+0xe0>
xor    %edx,%edx
mov    %rcx,(%rsp)
mov    %r14,0x90(%rsp)
nop
mov    %rdx,%r12
shl    $0xa,%r12
add    $0x1,%rdx
mov    %rdx,%rax
shl    $0xa,%rax
or     $0x80,%rax
cmp    0x80(%rsp),%rax
mov    %rdx,0x58(%rsp)
jle    1380 <dedisperse_blocked_cached+0x210>
xor    %ebp,%ebp
nopl   (%rax)
mov    (%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x8(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x10(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x18(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x20(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x28(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x30(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x38(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
add    $0x8,%rbp
cmp    $0x80,%rbp
jne    12c0 <dedisperse_blocked_cached+0x150>
mov    0x80(%rsp),%rbp
jmp    1383 <dedisperse_blocked_cached+0x213>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rbp
sub    %r12,%rbp
shl    $0x2,%rbp
xor    %r13d,%r13d
mov    (%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%r13,8),%rdi
lea    0x0(,%r12,4),%r15
mov    -0x8(%r14,%r13,8),%rsi
add    %r15,%rsi
mov    %rbp,%rdx
call   1060 <memcpy@plt>
mov    0x8(%rbx,%r13,8),%rdi
mov    (%r14,%r13,8),%rsi
add    %r15,%rsi
mov    %rbp,%rdx
call   1060 <memcpy@plt>
add    $0x2,%r13
cmp    $0x80,%r13
jne    13a0 <dedisperse_blocked_cached+0x230>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    $0x80,%edx
mov    $0x480,%ecx
xor    %eax,%eax
call   1090 <dedisperse@plt>
xor    %ebp,%ebp
mov    0x90(%rsp),%r14
mov    -0x8(%r14,%rbp,8),%rdi
add    %r15,%rdi
mov    (%rbx,%rbp,8),%rsi
mov    $0x1000,%edx
call   1060 <memcpy@plt>
mov    (%r14,%rbp,8),%rdi
add    %r15,%rdi
mov    0x8(%rbx,%rbp,8),%rsi
mov    $0x1000,%edx
call   1060 <memcpy@plt>
add    $0x2,%rbp
cmp    $0x80,%rbp
jne    1400 <dedisperse_blocked_cached+0x290>
mov    0x58(%rsp),%rdx
cmp    0x88(%rsp),%rdx
mov    (%rsp),%rcx
mov    $0x1000,%r15d
jne    1290 <dedisperse_blocked_cached+0x120>
jmp    1250 <dedisperse_blocked_cached+0xe0>
mov    (%rbx),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rbx
mov    (%rbx),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rbx
movslq %ebx,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,0x70(%rsp)
movslq 0x40(%rsp),%r13
cmp    $0x80,%ebx
mov    0x28(%rsp),%rax
jl     1519 <dedisperse_blocked_cached+0x3a9>
add    $0x8,%rax
mov    %r13,%r10
shl    $0x4,%r10
xor    %ecx,%ecx
mov    0x70(%rsp),%r8
xor    %esi,%esi
xor    %r9d,%r9d
nop
mov    %r8,%rdx
xor    %ebx,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rax,%rbp,8),%rdi
add    %rbx,%rdi
mov    %rdi,(%rdx)
mov    (%rax,%rbp,8),%rdi
add    %rsi,%rdi
add    %rbx,%rdi
mov    %rdi,(%rdx,%r13,8)
add    $0x2,%rbp
add    %rcx,%rbx
add    %r10,%rdx
cmp    $0x80,%rbp
jne    14d0 <dedisperse_blocked_cached+0x360>
add    $0x1,%r9
add    $0x400,%rax
add    $0x4,%rsi
add    $0x8,%rcx
add    $0x8,%r8
cmp    0x18(%rsp),%r9
jne    14c0 <dedisperse_blocked_cached+0x350>
mov    $0x20000,%eax
xor    %edx,%edx
mov    0x40(%rsp),%rbp
idiv   %ebp
mov    %eax,%r14d
mov    0x10(%rsp),%rax
cltd
idiv   %r14d
mov    %eax,0x38(%rsp)
lea    (%r14,%rbp,1),%ebx
mov    %ebp,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <matrix@plt>
movslq %eax,%r15
mov    %ebp,%edi
mov    %ebx,0x3c(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <matrix@plt>
movslq %eax,%rbx
mov    0x20(%rsp),%eax
test   %eax,%eax
jle    19a0 <dedisperse_blocked_cached+0x830>
movslq %r14d,%rcx
lea    0x0(,%r13,4),%r12
mov    %rcx,0x28(%rsp)
lea    0x0(,%rcx,4),%r14
mov    %eax,%eax
mov    %rax,0xb0(%rsp)
mov    0x38(%rsp),%eax
mov    %rax,0xd0(%rsp)
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x20(%rsp)
mov    %eax,%ebp
and    $0x7,%ebp
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x90(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x58(%rsp)
mov    0x70(%rsp),%rcx
add    $0x8,%rcx
lea    0x0(,%r13,8),%rax
mov    %rax,0xa8(%rsp)
mov    0x60(%rsp),%rax
add    $0x8,%rax
xor    %edx,%edx
mov    %rdx,0x68(%rsp)
mov    %r13,0x78(%rsp)
mov    %rbx,0x8(%rsp)
mov    %rbp,0xc8(%rsp)
mov    %r12,0xc0(%rsp)
mov    %r14,0xb8(%rsp)
mov    %r15,0x48(%rsp)
jmp    1648 <dedisperse_blocked_cached+0x4d8>
nop
mov    0x68(%rsp),%rsi
add    $0x1,%rsi
mov    0xa8(%rsp),%rax
add    %rax,%rcx
mov    0x98(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,%rax
mov    %rsi,%rdx
mov    %rsi,0x68(%rsp)
cmp    0xb0(%rsp),%rsi
je     19a0 <dedisperse_blocked_cached+0x830>
mov    %rax,0x98(%rsp)
cmpl   $0x0,0x38(%rsp)
jle    1610 <dedisperse_blocked_cached+0x4a0>
mov    0x68(%rsp),%rax
imul   %r13,%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rcx,0x30(%rsp)
jmp    16be <dedisperse_blocked_cached+0x54e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    0x8(%rsp),%rbx
mov    %rbx,%rsi
mov    0x40(%rsp),%rdx
mov    0x3c(%rsp),%ecx
xor    %eax,%eax
call   1090 <dedisperse@plt>
mov    0x88(%rsp),%rax
cmp    0xd0(%rsp),%rax
mov    0xc8(%rsp),%rbp
mov    0x30(%rsp),%rcx
je     1610 <dedisperse_blocked_cached+0x4a0>
mov    %rax,(%rsp)
add    $0x1,%rax
mov    %rax,0x88(%rsp)
imul   0x28(%rsp),%rax
add    %r13,%rax
cmp    0x80(%rsp),%rax
cmovg  0x10(%rsp),%eax
jle    1809 <dedisperse_blocked_cached+0x699>
cmpl   $0x80,0x50(%rsp)
jl     1809 <dedisperse_blocked_cached+0x699>
cmpq   $0x7,0x20(%rsp)
jae    1710 <dedisperse_blocked_cached+0x5a0>
xor    %ebx,%ebx
jmp    17c1 <dedisperse_blocked_cached+0x651>
nopw   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x8(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x10(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x18(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x20(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x28(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x30(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
mov    0x38(%r15,%rbx,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
add    $0x8,%rbx
cmp    %rbx,0x90(%rsp)
jne    1720 <dedisperse_blocked_cached+0x5b0>
mov    0x10(%rsp),%rax
test   %rbp,%rbp
mov    0x30(%rsp),%rcx
je     1809 <dedisperse_blocked_cached+0x699>
lea    (%r15,%rbx,8),%rbx
mov    %rbp,%r13
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%rbx,%rbp,8),%rdi
add    %r14,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    17e0 <dedisperse_blocked_cached+0x670>
mov    0x10(%rsp),%rax
mov    0x78(%rsp),%r13
mov    0x30(%rsp),%rcx
cmpl   $0x7f,0x50(%rsp)
jle    1680 <dedisperse_blocked_cached+0x510>
mov    (%rsp),%rbx
imul   0x28(%rsp),%rbx
movslq %eax,%r15
sub    %rbx,%r15
shl    $0x2,%r15
cmpq   $0x0,0x20(%rsp)
mov    %rbx,(%rsp)
je     1885 <dedisperse_blocked_cached+0x715>
xor    %ebp,%ebp
mov    %rcx,%r12
mov    0x48(%rsp),%r14
xchg   %ax,%ax
mov    (%r14,%rbp,8),%rdi
mov    (%rsp),%rax
lea    0x0(,%rax,4),%r13
mov    -0x8(%r12,%rbp,8),%rsi
add    %r13,%rsi
mov    %r15,%rdx
call   1060 <memcpy@plt>
mov    0x8(%r14,%rbp,8),%rdi
add    (%r12,%rbp,8),%r13
mov    %r13,%rsi
mov    (%rsp),%rbx
mov    %r15,%rdx
call   1060 <memcpy@plt>
add    $0x2,%rbp
cmp    %rbp,0x58(%rsp)
jne    1840 <dedisperse_blocked_cached+0x6d0>
jmp    1887 <dedisperse_blocked_cached+0x717>
xor    %ebp,%ebp
testb  $0x1,0x18(%rsp)
mov    0xc0(%rsp),%r12
je     18c0 <dedisperse_blocked_cached+0x750>
mov    0x48(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
add    0xa0(%rsp),%rbp
lea    0x0(,%rbx,4),%rsi
mov    0x70(%rsp),%rax
add    (%rax,%rbp,8),%rsi
mov    %r15,%rdx
call   1060 <memcpy@plt>
mov    0x48(%rsp),%r15
mov    %r15,%rdi
mov    0x8(%rsp),%rbx
mov    %rbx,%rsi
mov    0x40(%rsp),%rdx
mov    0x3c(%rsp),%ecx
xor    %eax,%eax
call   1090 <dedisperse@plt>
cmpl   $0x80,0x50(%rsp)
mov    0x78(%rsp),%r13
mov    0xb8(%rsp),%r14
jl     169b <dedisperse_blocked_cached+0x52b>
cmpq   $0x0,0x20(%rsp)
je     1957 <dedisperse_blocked_cached+0x7e7>
xor    %ebp,%ebp
mov    0x98(%rsp),%r13
nopl   (%rax)
mov    (%rsp),%rax
lea    0x0(,%rax,4),%rbx
mov    -0x8(%r13,%rbp,8),%rdi
add    %rbx,%rdi
mov    0x8(%rsp),%r15
mov    (%r15,%rbp,8),%rsi
mov    %r14,%rdx
call   1060 <memcpy@plt>
add    0x0(%r13,%rbp,8),%rbx
mov    0x8(%r15,%rbp,8),%rsi
mov    %rbx,%rdi
mov    %r14,%rdx
call   1060 <memcpy@plt>
add    $0x2,%rbp
cmp    %rbp,0x58(%rsp)
jne    1910 <dedisperse_blocked_cached+0x7a0>
jmp    1959 <dedisperse_blocked_cached+0x7e9>
xor    %ebp,%ebp
testb  $0x1,0x18(%rsp)
mov    0x8(%rsp),%rbx
mov    0x78(%rsp),%r13
mov    0x48(%rsp),%r15
je     169b <dedisperse_blocked_cached+0x52b>
mov    0xa0(%rsp),%rax
add    %rbp,%rax
mov    (%rsp),%rdi
shl    $0x2,%rdi
mov    0x60(%rsp),%rcx
add    (%rcx,%rax,8),%rdi
mov    (%rbx,%rbp,8),%rsi
mov    %r14,%rdx
call   1060 <memcpy@plt>
jmp    169b <dedisperse_blocked_cached+0x52b>
mov    (%r15),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    (%rbx),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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