void dedisperse_inplace(float **inin, int nchan, int m) {
  omp_set_dynamic(0);
  omp_set_num_threads(8);
  int npass = get_npass(nchan);
  float **in = inin;
  int radix = 1;
  int pairs = nchan / 2;
  int threads = 8;
  int *fmap = malloc(sizeof(int) * nchan);
  for (int i = 0; i < nchan; i++) {
    fmap[i] = i;
  }
  float **tmp = matrix(8, m);
  for (int i = 0; i < npass; i++) {
    generate_shift_group(fmap, radix, nchan);
#pragma omp parallel for
    for (int j = 0; j < pairs; j++) {
      int zero = 2 * j;
      int zero_ind = 0;
      int id = omp_get_thread_num();
      while (fmap[zero_ind] != zero - (zero % (nchan / radix))) {
        zero_ind++;
      }
      zero_ind += radix * (zero % (nchan / radix));
      int comp_ind = zero_ind + radix;
      int jeff = j % (nchan / (radix * 2));
      for (int k = 0; k < m; k++) {
        tmp[id][k] = in[zero_ind][k];
      }
      for (int k = 0; k < m; k++) {
        in[zero_ind][k] = in[zero_ind][k] + in[comp_ind][k];
      }
      for (int k = 0; k < m - jeff - 1; k++) {
        in[comp_ind][k] = tmp[id][k + jeff] + in[comp_ind][k + jeff + 1];
      }
    }
    radix *= 2;
  }
  fast_unshuffle(in, fmap, nchan, m);
  free(fmap);
  free(tmp);
  free(tmp[0]);
}


x86 assembly (clang, -O0):
<dedisperse_inplace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xor    %edi,%edi
mov    $0x0,%al
call   1070 <omp_set_dynamic@plt>
mov    $0x8,%edi
mov    $0x0,%al
call   10a0 <omp_set_num_threads@plt>
mov    -0xc(%rbp),%edi
mov    $0x0,%al
call   1060 <get_npass@plt>
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
movl   $0x8,-0x2c(%rbp)
movslq -0xc(%rbp),%rdi
shl    $0x2,%rdi
call   1090 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122b <dedisperse_inplace+0x9b>
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1203 <dedisperse_inplace+0x73>
mov    -0x10(%rbp),%esi
mov    $0x8,%edi
mov    $0x0,%al
call   1080 <matrix@plt>
cltq
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    146f <dedisperse_inplace+0x2df>
mov    -0x38(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    $0x0,%al
call   1040 <generate_shift_group@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1458 <dedisperse_inplace+0x2c8>
mov    -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    $0x0,%al
call   1050 <omp_get_thread_num@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x54(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %eax,%esi
mov    -0x78(%rbp),%eax
cltd
idiv   %esi
mov    -0x74(%rbp),%eax
sub    %edx,%ecx
cmp    %ecx,%eax
je     12d2 <dedisperse_inplace+0x142>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1291 <dedisperse_inplace+0x101>
mov    -0x24(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
cltd
idiv   %ecx
mov    -0x80(%rbp),%eax
imul   %edx,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1370 <dedisperse_inplace+0x1e0>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    132c <dedisperse_inplace+0x19c>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13d0 <dedisperse_inplace+0x240>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1377 <dedisperse_inplace+0x1e7>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1445 <dedisperse_inplace+0x2b5>
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%ecx
add    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13d7 <dedisperse_inplace+0x247>
jmp    144a <dedisperse_inplace+0x2ba>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    126b <dedisperse_inplace+0xdb>
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1247 <dedisperse_inplace+0xb7>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    $0x0,%al
call   10b0 <fast_unshuffle@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dedisperse_inplace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %edx,%r13d
mov    %esi,%ebx
mov    %rdi,0x18(%rsp)
xor    %edi,%edi
xor    %eax,%eax
call   1070 <omp_set_dynamic@plt>
mov    $0x8,%edi
xor    %eax,%eax
call   10a0 <omp_set_num_threads@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <get_npass@plt>
mov    %eax,0x10(%rsp)
movslq %ebx,%rdi
shl    $0x2,%rdi
call   1090 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,0xc(%rsp)
test   %ebx,%ebx
jle    135d <dedisperse_inplace+0x1cd>
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    11f7 <dedisperse_inplace+0x67>
xor    %ecx,%ecx
jmp    1350 <dedisperse_inplace+0x1c0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1225 <dedisperse_inplace+0x95>
movdqa 0xde2(%rip),%xmm0
xor    %edi,%edi
jmp    12f9 <dedisperse_inplace+0x169>
and    $0xfffffffffffffffc,%rsi
movdqa 0xdcf(%rip),%xmm0
xor    %edi,%edi
movdqa 0xdd4(%rip),%xmm8
movdqa 0xddb(%rip),%xmm9
movdqa 0xde2(%rip),%xmm10
movdqa 0xdea(%rip),%xmm4
movdqa 0xdf2(%rip),%xmm5
movdqa 0xdfa(%rip),%xmm6
movdqa 0xe02(%rip),%xmm7
movdqa 0xe0a(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x0(%rbp,%rdi,4)
movdqu %xmm2,0x10(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbp,%rdi,4)
movdqu %xmm3,0x30(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbp,%rdi,4)
movdqu %xmm3,0x50(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbp,%rdi,4)
movdqu %xmm3,0x70(%rbp,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1280 <dedisperse_inplace+0xf0>
test   %rdx,%rdx
je     1340 <dedisperse_inplace+0x1b0>
lea    0x10(,%rdi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xcf9(%rip),%xmm1
movdqa 0xd01(%rip),%xmm2
nop
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1320 <dedisperse_inplace+0x190>
cmp    %rax,%rcx
je     135d <dedisperse_inplace+0x1cd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1350 <dedisperse_inplace+0x1c0>
mov    $0x8,%edi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <matrix@plt>
cltq
mov    %rax,0x20(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    19c2 <dedisperse_inplace+0x832>
mov    0xc(%rsp),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
mov    %ecx,0x2c(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %r13d,%r14d
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x38(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x30(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x3,%edx
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x58(%rsp)
mov    %r14d,%esi
and    $0x3,%esi
mov    %rsi,0x40(%rsp)
lea    0x2(%rax),%rsi
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
and    %rcx,%rsi
mov    %rsi,0x50(%rsp)
mov    %rdx,0x68(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x70(%rsp)
mov    $0x1,%r12d
xor    %eax,%eax
mov    %rbp,0x48(%rsp)
jmp    142d <dedisperse_inplace+0x29d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%eax
add    $0x1,%eax
mov    0x14(%rsp),%ecx
mov    %ecx,%r12d
cmp    0x10(%rsp),%eax
mov    0x48(%rsp),%rbp
je     19c2 <dedisperse_inplace+0x832>
mov    %eax,0x28(%rsp)
mov    %rbp,%rdi
mov    %r12d,%esi
mov    0xc(%rsp),%ebx
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <generate_shift_group@plt>
lea    (%r12,%r12,1),%eax
mov    %eax,0x14(%rsp)
cmp    $0x2,%ebx
jl     1410 <dedisperse_inplace+0x280>
xor    %r15d,%r15d
jmp    146b <dedisperse_inplace+0x2db>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15d
cmp    0x2c(%rsp),%r15d
je     1410 <dedisperse_inplace+0x280>
mov    %r13d,%ebx
lea    (%r15,%r15,1),%r13d
xor    %eax,%eax
call   1050 <omp_get_thread_num@plt>
mov    %eax,%ecx
mov    0xc(%rsp),%eax
cltd
idiv   %r12d
mov    %eax,%esi
mov    %r13d,%eax
cltd
idiv   %esi
mov    %edx,%esi
sub    %edx,%r13d
mov    %r12d,%ebp
imul   %edx,%ebp
add    $0xffffffff,%ebp
add    $0x1,%esi
imul   %r12d,%esi
add    $0xffffffff,%esi
mov    0x48(%rsp),%rax
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
add    $0x1,%esi
lea    0x4(%rax),%rdx
cmp    %r13d,(%rax)
mov    %rdx,%rax
jne    14b0 <dedisperse_inplace+0x320>
mov    0xc(%rsp),%eax
cltd
idivl  0x14(%rsp)
mov    %eax,%edi
mov    %r15d,%eax
cltd
idiv   %edi
movslq %ecx,%r8
movslq %esi,%r9
mov    %ebx,%r13d
test   %ebx,%ebx
mov    0x70(%rsp),%rsi
jle    17d0 <dedisperse_inplace+0x640>
movslq %ebp,%r10
mov    0x18(%rsp),%rax
mov    (%rax,%r10,8),%rdi
mov    0x20(%rsp),%rax
mov    (%rax,%r8,8),%rbx
cmp    $0x8,%r13d
jb     151a <dedisperse_inplace+0x38a>
lea    (%rdi,%r14,4),%rax
cmp    %rax,%rbx
jae    158c <dedisperse_inplace+0x3fc>
lea    (%rbx,%r14,4),%rax
cmp    %rax,%rdi
jae    158c <dedisperse_inplace+0x3fc>
xor    %ebp,%ebp
mov    %rbp,%rcx
not    %rcx
add    %r14,%rcx
mov    0x40(%rsp),%rax
test   %rax,%rax
je     1544 <dedisperse_inplace+0x3b4>
nop
movd   (%rdi,%rbp,4),%xmm0
movd   %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rax
jne    1530 <dedisperse_inplace+0x3a0>
cmp    $0x3,%rcx
jb     1650 <dedisperse_inplace+0x4c0>
xchg   %ax,%ax
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
movss  0x4(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x4(%rbx,%rbp,4)
movss  0x8(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x8(%rbx,%rbp,4)
movd   0xc(%rdi,%rbp,4),%xmm0
movd   %xmm0,0xc(%rbx,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r14
jne    1550 <dedisperse_inplace+0x3c0>
jmp    1650 <dedisperse_inplace+0x4c0>
cmpq   $0x18,0x30(%rsp)
jae    1598 <dedisperse_inplace+0x408>
xor    %ebp,%ebp
jmp    15fc <dedisperse_inplace+0x46c>
mov    0x58(%rsp),%rcx
xor    %ebp,%ebp
nop
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rbp,4)
movups %xmm1,0x10(%rbx,%rbp,4)
movups 0x20(%rdi,%rbp,4),%xmm0
movups 0x30(%rdi,%rbp,4),%xmm1
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm1,0x30(%rbx,%rbp,4)
movups 0x40(%rdi,%rbp,4),%xmm0
movups 0x50(%rdi,%rbp,4),%xmm1
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm1,0x50(%rbx,%rbp,4)
movdqu 0x60(%rdi,%rbp,4),%xmm0
movdqu 0x70(%rdi,%rbp,4),%xmm1
movdqu %xmm0,0x60(%rbx,%rbp,4)
movdqu %xmm1,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rcx
jne    15a0 <dedisperse_inplace+0x410>
cmpq   $0x0,0x68(%rsp)
je     163f <dedisperse_inplace+0x4af>
lea    (%rbx,%rbp,4),%rcx
add    $0x10,%rcx
lea    (%rdi,%rbp,4),%rax
add    $0x10,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rbp,1),%xmm0
movdqu (%rax,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rbp,1)
movdqu %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1620 <dedisperse_inplace+0x490>
mov    0x38(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
jne    151c <dedisperse_inplace+0x38c>
test   %r13d,%r13d
jle    17d0 <dedisperse_inplace+0x640>
mov    0x18(%rsp),%rax
mov    (%rax,%r10,8),%rsi
mov    (%rax,%r9,8),%rdi
cmp    $0x8,%r13d
jb     1686 <dedisperse_inplace+0x4f6>
lea    (%rdi,%r14,4),%rax
cmp    %rax,%rsi
jae    1723 <dedisperse_inplace+0x593>
lea    (%rsi,%r14,4),%rax
cmp    %rax,%rdi
jae    1723 <dedisperse_inplace+0x593>
xor    %ebx,%ebx
mov    %rbx,%rbp
not    %rbp
add    %r14,%rbp
test   $0x3,%r14b
je     16b9 <dedisperse_inplace+0x529>
mov    0x40(%rsp),%rcx
nopl   0x0(%rax)
movss  (%rsi,%rbx,4),%xmm0
addss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    16a0 <dedisperse_inplace+0x510>
cmp    $0x3,%rbp
jb     17d0 <dedisperse_inplace+0x640>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rsi,%rbx,4),%xmm0
addss  (%rdi,%rbx,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%rbx,4)
addss  0x4(%rdi,%rbx,4),%xmm1
movss  %xmm1,0x4(%rsi,%rbx,4)
movss  0x8(%rsi,%rbx,4),%xmm0
addss  0x8(%rdi,%rbx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rbx,4)
movss  0xc(%rsi,%rbx,4),%xmm0
addss  0xc(%rdi,%rbx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r14
jne    16d0 <dedisperse_inplace+0x540>
jmp    17d0 <dedisperse_inplace+0x640>
cmpq   $0x0,0x30(%rsp)
je     19b0 <dedisperse_inplace+0x820>
mov    0x50(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups (%rsi,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rsi,%rbp,4),%xmm1
movups 0x30(%rsi,%rbp,4),%xmm3
movups %xmm2,(%rsi,%rbp,4)
movups %xmm0,0x10(%rsi,%rbp,4)
movups 0x20(%rdi,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rdi,%rbp,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rsi,%rbp,4)
movups %xmm1,0x30(%rsi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1740 <dedisperse_inplace+0x5b0>
testb  $0x1,0x60(%rsp)
je     17b7 <dedisperse_inplace+0x627>
movups (%rsi,%rbp,4),%xmm0
movups 0x10(%rsi,%rbp,4),%xmm1
movups (%rdi,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rbp,4)
movups %xmm0,0x10(%rsi,%rbp,4)
mov    0x38(%rsp),%rax
mov    %rax,%rbx
cmp    %r14,%rax
jne    1688 <dedisperse_inplace+0x4f8>
nopl   0x0(%rax,%rax,1)
mov    %edx,%esi
not    %esi
add    %r13d,%esi
test   %esi,%esi
jle    1460 <dedisperse_inplace+0x2d0>
mov    0x20(%rsp),%rax
mov    (%rax,%r8,8),%r8
mov    0x18(%rsp),%rax
mov    (%rax,%r9,8),%rax
mov    %edx,%r10d
mov    %esi,%ecx
cmp    $0x8,%esi
jb     1920 <dedisperse_inplace+0x790>
lea    (%rax,%rcx,4),%rsi
lea    (%r8,%r10,4),%rdx
lea    (%r10,%rcx,1),%rdi
lea    (%r8,%rdi,4),%rbp
lea    (%rax,%r10,4),%r11
add    $0x4,%r11
lea    (%rax,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rbp,%rax
setb   %r9b
cmp    %rsi,%rdx
setb   %bl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r11
setb   %sil
test   %bl,%r9b
jne    1920 <dedisperse_inplace+0x790>
mov    $0x0,%edi
and    %sil,%dl
jne    1922 <dedisperse_inplace+0x792>
mov    %ecx,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     199f <dedisperse_inplace+0x80f>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
lea    0x2(%rdx),%rsi
and    %r9,%rsi
lea    (%rax,%r10,4),%rbp
add    $0x34,%rbp
lea    (%r8,%r10,4),%rdx
add    $0x30,%rdx
xor    %ebx,%ebx
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups -0x30(%rbp,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rbp,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rax,%rbx,4)
movups %xmm0,0x10(%rax,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups -0x10(%rbp,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x0(%rbp,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x20(%rax,%rbx,4)
movups %xmm0,0x30(%rax,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1890 <dedisperse_inplace+0x700>
test   $0x1,%r9b
je     190e <dedisperse_inplace+0x77e>
lea    (%rbx,%r10,1),%rdx
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
movups 0x4(%rax,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%rax,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rax,%rbx,4)
movups %xmm0,0x10(%rax,%rbx,4)
cmp    %rcx,%rdi
je     1460 <dedisperse_inplace+0x2d0>
jmp    1922 <dedisperse_inplace+0x792>
nopl   0x0(%rax)
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%cl
je     1946 <dedisperse_inplace+0x7b6>
lea    (%rdi,%r10,1),%rdx
movss  (%r8,%rdx,4),%xmm0
addss  0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
mov    %rdi,%rdx
or     $0x1,%rdx
not    %rdi
add    %rcx,%rdi
je     1460 <dedisperse_inplace+0x2d0>
lea    (%r8,%r10,4),%rsi
add    $0x4,%rsi
lea    (%rax,%r10,4),%rdi
add    $0x8,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rsi,%rdx,4),%xmm0
addss  -0x4(%rdi,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  (%rsi,%rdx,4),%xmm0
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1970 <dedisperse_inplace+0x7e0>
jmp    1460 <dedisperse_inplace+0x2d0>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    18e6 <dedisperse_inplace+0x756>
jmp    190e <dedisperse_inplace+0x77e>
xor    %ebp,%ebp
testb  $0x1,0x60(%rsp)
jne    1796 <dedisperse_inplace+0x606>
jmp    17b7 <dedisperse_inplace+0x627>
mov    0x18(%rsp),%rdi
mov    %rbp,%rsi
mov    0xc(%rsp),%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   10b0 <fast_unshuffle@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <free@plt>
mov    (%rbx),%rdi
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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