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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
void unshuffle(float **data, int *fmap, int nchan, int m) {
  float *tmp = (float *)malloc(sizeof(float *) * m);
  int send_ind = nchan / 2;
  int this_ind = 1;
  int sorted = 0;
  while (sorted == 0) {
    for (int j = 0; j < m; j++) {
      tmp[j] = data[send_ind][j];
    }
    for (int j = 0; j < m; j++) {
      data[send_ind][j] = data[this_ind][j];
    }
    for (int j = 0; j < m; j++) {
      data[this_ind][j] = tmp[j];
    }
    fmap[this_ind] = fmap[send_ind];
    fmap[send_ind] = send_ind;
    send_ind = fmap[this_ind];
    if (this_ind == send_ind) {
      int count = 0;
      while (fmap[this_ind % nchan] == this_ind % nchan) {
        this_ind++;
        count++;
        if (count == nchan) {
          sorted = 1;
          break;
        }
      }
      this_ind = this_ind % nchan;
      send_ind = fmap[this_ind];
    }
  }
  free(tmp);
}


x86 assembly (clang, -O0):
<unshuffle>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    12ff <unshuffle+0x1df>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11b2 <unshuffle+0x92>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1176 <unshuffle+0x56>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11fd <unshuffle+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b9 <unshuffle+0x99>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1240 <unshuffle+0x120>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1204 <unshuffle+0xe4>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    12fa <unshuffle+0x1da>
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    -0x48(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    -0x40(%rbp),%eax
cmp    %edx,%eax
jne    12e2 <unshuffle+0x1c2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    12dd <unshuffle+0x1bd>
movl   $0x1,-0x2c(%rbp)
jmp    12e2 <unshuffle+0x1c2>
jmp    1285 <unshuffle+0x165>
mov    -0x28(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
jmp    1165 <unshuffle+0x45>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unshuffle>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,%r15
mov    %rdi,%rbx
lea    0x0(,%r14,8),%edi
call   1040 <malloc@plt>
mov    %rax,%rdi
mov    %r12d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
sar    %eax
mov    %r14d,%esi
lea    (%rdi,%rsi,4),%rcx
mov    %rcx,0x28(%rsp)
mov    %esi,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x10(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x8(%rsp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x3,%r11d
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,(%rsp)
mov    %esi,%r10d
and    $0x3,%r10d
lea    0x10(%rdi),%rcx
mov    %rcx,0x18(%rsp)
mov    %r11,0x40(%rsp)
shl    $0x5,%r11
mov    $0x1,%r13d
mov    %rbx,0x38(%rsp)
mov    %r10,0x30(%rsp)
jmp    11df <unshuffle+0xbf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%r13d
mov    (%r15,%rax,4),%eax
test   %ebp,%ebp
jne    16d1 <unshuffle+0x5b1>
movslq %eax,%r8
test   %r14d,%r14d
jle    15a0 <unshuffle+0x480>
mov    (%rbx,%r8,8),%rax
cmp    $0x8,%r14d
jb     1205 <unshuffle+0xe5>
lea    (%rax,%rsi,4),%rcx
cmp    %rcx,%rdi
jae    127c <unshuffle+0x15c>
cmp    0x28(%rsp),%rax
jae    127c <unshuffle+0x15c>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rsi,%rcx
test   %r10,%r10
je     1234 <unshuffle+0x114>
mov    %r10,%rbp
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbp
jne    1220 <unshuffle+0x100>
cmp    $0x3,%rcx
jb     1340 <unshuffle+0x220>
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1240 <unshuffle+0x120>
jmp    1340 <unshuffle+0x220>
cmpq   $0x18,0x8(%rsp)
jae    1288 <unshuffle+0x168>
xor    %edx,%edx
jmp    12e8 <unshuffle+0x1c8>
mov    (%rsp),%rbp
xor    %edx,%edx
xchg   %ax,%ax
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups %xmm0,(%rdi,%rdx,4)
movups %xmm1,0x10(%rdi,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups %xmm0,0x20(%rdi,%rdx,4)
movups %xmm1,0x30(%rdi,%rdx,4)
movups 0x40(%rax,%rdx,4),%xmm0
movups 0x50(%rax,%rdx,4),%xmm1
movups %xmm0,0x40(%rdi,%rdx,4)
movups %xmm1,0x50(%rdi,%rdx,4)
movups 0x60(%rax,%rdx,4),%xmm0
movups 0x70(%rax,%rdx,4),%xmm1
movups %xmm0,0x60(%rdi,%rdx,4)
movups %xmm1,0x70(%rdi,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1290 <unshuffle+0x170>
cmpq   $0x0,0x40(%rsp)
je     132b <unshuffle+0x20b>
mov    0x18(%rsp),%rcx
lea    (%rcx,%rdx,4),%rcx
lea    (%rax,%rdx,4),%rdx
add    $0x10,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rbp,1),%xmm0
movups (%rdx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    1310 <unshuffle+0x1f0>
mov    0x10(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1207 <unshuffle+0xe7>
nopl   0x0(%rax)
test   %r14d,%r14d
jle    15a0 <unshuffle+0x480>
movslq %r13d,%r9
mov    (%rbx,%r9,8),%rbp
mov    (%rbx,%r8,8),%rax
cmp    $0x8,%r14d
jb     137b <unshuffle+0x25b>
lea    0x0(,%rsi,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    1415 <unshuffle+0x2f5>
lea    (%rax,%rsi,4),%rcx
cmp    %rcx,%rbp
jae    1415 <unshuffle+0x2f5>
xor    %r10d,%r10d
mov    %r10,%rcx
not    %rcx
add    %rsi,%rcx
test   $0x3,%sil
je     13b7 <unshuffle+0x297>
mov    0x30(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%r10,4),%xmm0
movss  %xmm0,(%rax,%r10,4)
add    $0x1,%r10
add    $0xffffffffffffffff,%rdx
jne    13a0 <unshuffle+0x280>
cmp    $0x3,%rcx
jb     14f0 <unshuffle+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%r10,4),%xmm0
movss  %xmm0,(%rax,%r10,4)
movss  0x4(%rbp,%r10,4),%xmm0
movss  %xmm0,0x4(%rax,%r10,4)
movss  0x8(%rbp,%r10,4),%xmm0
movss  %xmm0,0x8(%rax,%r10,4)
movss  0xc(%rbp,%r10,4),%xmm0
movss  %xmm0,0xc(%rax,%r10,4)
add    $0x4,%r10
cmp    %r10,%rsi
jne    13d0 <unshuffle+0x2b0>
jmp    14f0 <unshuffle+0x3d0>
cmpq   $0x18,0x8(%rsp)
jae    1421 <unshuffle+0x301>
xor    %edx,%edx
jmp    1489 <unshuffle+0x369>
mov    (%rsp),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,4),%xmm0
movups 0x10(%rbp,%rdx,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
movups 0x20(%rbp,%rdx,4),%xmm0
movups 0x30(%rbp,%rdx,4),%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
movups 0x40(%rbp,%rdx,4),%xmm0
movups 0x50(%rbp,%rdx,4),%xmm1
movups %xmm0,0x40(%rax,%rdx,4)
movups %xmm1,0x50(%rax,%rdx,4)
movups 0x60(%rbp,%rdx,4),%xmm0
movups 0x70(%rbp,%rdx,4),%xmm1
movups %xmm0,0x60(%rax,%rdx,4)
movups %xmm1,0x70(%rax,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1430 <unshuffle+0x310>
testb  $0x3,0x20(%rsp)
je     14cb <unshuffle+0x3ab>
lea    (%rax,%rdx,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rdx,4),%rdx
add    %rbp,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r11
jne    14b0 <unshuffle+0x390>
mov    0x10(%rsp),%rcx
mov    %rcx,%r10
cmp    %rsi,%rcx
mov    0x38(%rsp),%rbx
jne    137e <unshuffle+0x25e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r14d,%r14d
mov    0x30(%rsp),%r10
jle    15a0 <unshuffle+0x480>
mov    (%rbx,%r9,8),%rax
cmp    $0x8,%r14d
jb     1520 <unshuffle+0x400>
cmp    0x28(%rsp),%rax
jae    1604 <unshuffle+0x4e4>
lea    (%rax,%rsi,4),%rcx
cmp    %rcx,%rdi
jae    1604 <unshuffle+0x4e4>
xor    %ebp,%ebp
mov    %rbp,%rcx
not    %rcx
add    %rsi,%rcx
test   $0x3,%sil
je     1554 <unshuffle+0x434>
mov    %r10,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1540 <unshuffle+0x420>
cmp    $0x3,%rcx
jb     15a3 <unshuffle+0x483>
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
movss  0x4(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x4(%rax,%rbp,4)
movss  0x8(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x8(%rax,%rbp,4)
movss  0xc(%rdi,%rbp,4),%xmm0
movss  %xmm0,0xc(%rax,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    1560 <unshuffle+0x440>
jmp    15a3 <unshuffle+0x483>
nopl   0x0(%rax)
movslq %r13d,%r9
mov    (%r15,%r8,4),%eax
mov    %eax,(%r15,%r9,4)
mov    %r8d,(%r15,%r8,4)
mov    (%r15,%r9,4),%eax
xor    %ebp,%ebp
cmp    %eax,%r13d
jne    11d7 <unshuffle+0xb7>
lea    (%r12,%r13,1),%r8d
xor    %ebp,%ebp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%r13,1),%eax
cltd
idiv   %r12d
movslq %edx,%rax
cmp    %edx,(%r15,%rax,4)
jne    11d0 <unshuffle+0xb0>
add    $0x1,%ecx
cmp    %ecx,%r12d
jne    15d0 <unshuffle+0x4b0>
mov    %r8d,%eax
cltd
idiv   %r12d
mov    %edx,%r13d
movslq %edx,%rax
mov    $0x1,%ebp
jmp    11d3 <unshuffle+0xb3>
cmpq   $0x18,0x8(%rsp)
jae    1610 <unshuffle+0x4f0>
xor    %edx,%edx
jmp    1678 <unshuffle+0x558>
mov    (%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
movups 0x20(%rdi,%rdx,4),%xmm0
movups 0x30(%rdi,%rdx,4),%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
movups 0x40(%rdi,%rdx,4),%xmm0
movups 0x50(%rdi,%rdx,4),%xmm1
movups %xmm0,0x40(%rax,%rdx,4)
movups %xmm1,0x50(%rax,%rdx,4)
movups 0x60(%rdi,%rdx,4),%xmm0
movups 0x70(%rdi,%rdx,4),%xmm1
movups %xmm0,0x60(%rax,%rdx,4)
movups %xmm1,0x70(%rax,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1620 <unshuffle+0x500>
testb  $0x3,0x20(%rsp)
je     16bb <unshuffle+0x59b>
lea    (%rax,%rdx,4),%rcx
add    $0x10,%rcx
mov    0x18(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x10(%rdx,%rbp,1),%xmm0
movups (%rdx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    16a0 <unshuffle+0x580>
mov    0x10(%rsp),%rcx
mov    %rcx,%rbp
cmp    %rsi,%rcx
je     15a3 <unshuffle+0x483>
jmp    1522 <unshuffle+0x402>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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