#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(double *);
scalar_t__ malloc(int);
void reorder(double *u, int m, int n, double *w, double *v) {
  int i, j, k, s, inc = 1;
  double sw;
  double *su = (double *)malloc(m * sizeof(double));
  if (su == NULL) {
    return;
  }
  double *sv = (double *)malloc(n * sizeof(double));
  if (sv == NULL) {
    free(su);
    return;
  }
  do {
    inc *= 3;
    inc++;
  } while (inc <= n);
  do {
    inc /= 3;
    for (i = inc; i < n; i++) {
      sw = w[i];
      for (k = 0; k < m; k++)
        su[k] = u[k * n + i];
      for (k = 0; k < n; k++)
        sv[k] = v[k * n + i];
      j = i;
      while (w[j - inc] < sw) {
        w[j] = w[j - inc];
        for (k = 0; k < m; k++)
          u[k * n + j] = u[k * n + j - inc];
        for (k = 0; k < n; k++)
          v[k * n + j] = v[k * n + j - inc];
        j -= inc;
        if (j < inc)
          break;
      }
      w[j] = sw;
      for (k = 0; k < m; k++)
        u[k * n + j] = su[k];
      for (k = 0; k < n; k++)
        v[k * n + j] = sv[k];
    }
  } while (inc > 1);
  for (k = 0; k < n; k++) {
    s = 0;
    for (i = 0; i < m; i++)
      if (u[i * n + k] < 0.0)
        s++;
    for (j = 0; j < n; j++)
      if (v[j * n + k] < 0.0)
        s++;
    if (s > (m + n) / 2) {
      for (i = 0; i < m; i++)
        u[i * n + k] = -u[i * n + k];
      for (j = 0; j < n; j++)
        v[j * n + k] = -v[j * n + k];
    }
  }
  free(su);
  free(sv);
  return;
}


x86 assembly (clang, -O0):
<reorder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x1,-0x34(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    1164 <reorder+0x44>
jmp    15fc <reorder+0x4dc>
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    1190 <reorder+0x70>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
jmp    15fc <reorder+0x4dc>
jmp    1195 <reorder+0x75>
imul   $0x3,-0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1195 <reorder+0x75>
jmp    11b6 <reorder+0x96>
mov    -0x34(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1424 <reorder+0x304>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122c <reorder+0x10c>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ef <reorder+0xcf>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1270 <reorder+0x150>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1233 <reorder+0x113>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1377 <reorder+0x257>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1306 <reorder+0x1e6>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12bd <reorder+0x19d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1356 <reorder+0x236>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130d <reorder+0x1ed>
mov    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1372 <reorder+0x252>
jmp    1377 <reorder+0x257>
jmp    1276 <reorder+0x156>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13cd <reorder+0x2ad>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1390 <reorder+0x270>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1411 <reorder+0x2f1>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d4 <reorder+0x2b4>
jmp    1416 <reorder+0x2f6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ca <reorder+0xaa>
jmp    1429 <reorder+0x309>
cmpl   $0x1,-0x34(%rbp)
jg     11b6 <reorder+0x96>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15ea <reorder+0x4ca>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    149b <reorder+0x37b>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1488 <reorder+0x368>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    148d <reorder+0x36d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1454 <reorder+0x334>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14e9 <reorder+0x3c9>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    14d6 <reorder+0x3b6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14db <reorder+0x3bb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14a2 <reorder+0x382>
mov    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
cmp    %ecx,%eax
jle    15d7 <reorder+0x4b7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    156e <reorder+0x44e>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1511 <reorder+0x3f1>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15d2 <reorder+0x4b2>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1575 <reorder+0x455>
jmp    15d7 <reorder+0x4b7>
jmp    15dc <reorder+0x4bc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    143a <reorder+0x31a>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reorder>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r8,0x18(%rsp)
mov    %rcx,%r14
mov    %edx,%ebp
mov    %rdi,0x10(%rsp)
mov    %rsi,0x20(%rsp)
lea    0x0(,%rsi,8),%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     1b8e <reorder+0xa6e>
mov    %rax,%r12
lea    0x0(,%rbp,8),%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     1ba0 <reorder+0xa80>
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rsi,%rsi,2),%ecx
lea    (%rsi,%rsi,2),%esi
add    $0x1,%esi
cmp    %ebp,%ecx
jl     1180 <reorder+0x60>
movslq %ebp,%rcx
mov    0x20(%rsp),%r8d
mov    %ebp,%r11d
lea    -0x1(%r8),%rdx
mov    %rdx,0x48(%rsp)
lea    -0x1(%r11),%rdx
mov    %rdx,0x50(%rsp)
mov    %r8d,%r10d
and    $0x3,%r10d
mov    %r8d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x98(%rsp)
mov    %r11d,%edx
and    $0x3,%edx
mov    %rdx,0xb0(%rsp)
mov    %r11d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x90(%rsp)
mov    %r8,0x40(%rsp)
and    $0xfffffffe,%r8d
mov    %r11,0x28(%rsp)
and    $0xfffffffe,%r11d
mov    %rcx,%r13
shl    $0x4,%r13
mov    %rcx,%r15
shl    $0x5,%r15
mov    %rcx,0x8(%rsp)
lea    0x0(,%rcx,8),%rbx
lea    (%rbx,%rbx,2),%rcx
mov    %rcx,0x80(%rsp)
mov    %r12,0x30(%rsp)
mov    %rax,0x38(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rbx,0x88(%rsp)
mov    %r10,0xb8(%rsp)
mov    %r15,0x60(%rsp)
mov    %r14,0xe8(%rsp)
jmp    1263 <reorder+0x143>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x5,0xe0(%rsp)
05
mov    0x78(%rsp),%rsi
jle    18fa <reorder+0x7da>
mov    %rsi,0xe0(%rsp)
movslq %esi,%rcx
imul   $0x55555556,%rcx,%rdx
mov    %rdx,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rdx
add    %ecx,%edx
mov    %rdx,0x78(%rsp)
cmp    %ebp,%edx
jge    1250 <reorder+0x130>
movslq 0x78(%rsp),%rsi
lea    0x0(,%rsi,8),%r12
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
mov    %rcx,0xa0(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdi
mov    0x80(%rsp),%rdx
lea    (%rdx,%rsi,8),%r9
sub    %rsi,%rcx
mov    %rcx,0xf0(%rsp)
mov    %r12,%rdx
neg    %r12
mov    0x18(%rsp),%rcx
mov    %rcx,0xc8(%rsp)
mov    0x10(%rsp),%rcx
mov    %rcx,0xc0(%rsp)
mov    %rsi,0xd8(%rsp)
mov    %rdx,0xa8(%rsp)
mov    %r9,0x68(%rsp)
mov    %rdi,0xd0(%rsp)
jmp    1343 <reorder+0x223>
nopw   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rsi
add    $0x1,%rsi
addq   $0x8,0xc0(%rsp)
addq   $0x8,0xc8(%rsp)
cmp    0x8(%rsp),%rsi
mov    0x38(%rsp),%rax
mov    0xd0(%rsp),%rdi
je     1250 <reorder+0x130>
mov    %rsi,0x70(%rsp)
movsd  (%r14,%rsi,8),%xmm0
cmpl   $0x0,0x20(%rsp)
jle    1445 <reorder+0x325>
cmpq   $0x3,0x48(%rsp)
jae    1370 <reorder+0x250>
xor    %edx,%edx
mov    0x68(%rsp),%rbp
jmp    13e9 <reorder+0x2c9>
nopl   (%rax)
mov    %rdi,%rax
mov    0xc0(%rsp),%rcx
xor    %edx,%edx
mov    0x98(%rsp),%rsi
mov    0xa0(%rsp),%r9
mov    0x68(%rsp),%rbp
mov    0xa8(%rsp),%r10
mov    0x30(%rsp),%rdi
mov    0x60(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%r10,1),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
movsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rdx,8)
movsd  (%rcx,%r9,1),%xmm1
movsd  %xmm1,0x10(%rdi,%rdx,8)
movsd  (%rcx,%rbp,1),%xmm1
movsd  %xmm1,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
add    %r15,%rcx
cmp    %rdx,%rsi
jne    13b0 <reorder+0x290>
mov    0xb8(%rsp),%r10
test   %r10,%r10
mov    %rbp,%r9
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%rax
je     1445 <reorder+0x325>
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
imul   0x8(%rsp),%rdx
add    0x70(%rsp),%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rsi
add    %rbx,%rdx
cmp    %rsi,%r10
jne    1430 <reorder+0x310>
test   %ebp,%ebp
jle    1515 <reorder+0x3f5>
cmpq   $0x3,0x50(%rsp)
jae    1460 <reorder+0x340>
xor    %edx,%edx
jmp    14c9 <reorder+0x3a9>
nopl   0x0(%rax)
mov    0xc8(%rsp),%rcx
xor    %edx,%edx
mov    0x90(%rsp),%r10
mov    0xa0(%rsp),%r15
mov    0xd0(%rsp),%rbp
mov    0xa8(%rsp),%rsi
mov    0x60(%rsp),%rdi
nop
movsd  (%rcx,%rsi,1),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
movsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rax,%rdx,8)
movsd  (%rcx,%r15,1),%xmm1
movsd  %xmm1,0x10(%rax,%rdx,8)
movsd  (%rcx,%r9,1),%xmm1
movsd  %xmm1,0x18(%rax,%rdx,8)
add    $0x4,%rdx
add    %rdi,%rcx
cmp    %rdx,%r10
jne    1490 <reorder+0x370>
mov    0xb0(%rsp),%rdi
test   %rdi,%rdi
mov    0x58(%rsp),%rbp
je     1515 <reorder+0x3f5>
lea    (%rax,%rdx,8),%rcx
imul   0x8(%rsp),%rdx
add    0x70(%rsp),%rdx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rsi
add    %rbx,%rdx
cmp    %rsi,%rdi
jne    1500 <reorder+0x3e0>
mov    0x70(%rsp),%rax
mov    %eax,%r9d
mov    0x78(%rsp),%rcx
jmp    154e <reorder+0x42e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x78(%rsp),%rcx
cmp    %ecx,%r9d
mov    0xe8(%rsp),%r14
mov    0x88(%rsp),%rbx
jl     16c3 <reorder+0x5a3>
movslq %r9d,%rsi
mov    %esi,%r9d
sub    %ecx,%r9d
movslq %r9d,%rdi
movsd  (%r14,%rdi,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    16c0 <reorder+0x5a0>
mov    0x8(%rsp),%rax
lea    (%rax,%rsi,1),%rdx
mov    0xf0(%rsp),%rax
lea    (%rax,%rsi,1),%r10
movsd  %xmm1,(%r14,%rsi,8)
cmpl   $0x0,0x20(%rsp)
jle    1600 <reorder+0x4e0>
cmpq   $0x0,0x48(%rsp)
je     1670 <reorder+0x550>
mov    0x10(%rsp),%rbx
lea    (%rbx,%rdx,8),%r15
lea    (%rbx,%r10,8),%rcx
lea    (%rbx,%rsi,8),%rbx
xor    %r14d,%r14d
nopl   0x0(%rax)
movsd  (%rbx,%r12,1),%xmm1
movsd  %xmm1,(%rbx)
movsd  (%rcx),%xmm1
movsd  %xmm1,(%r15)
add    $0x2,%r14
add    %r13,%r15
add    %r13,%rcx
add    %r13,%rbx
cmp    %r14,%r8
jne    15b0 <reorder+0x490>
testb  $0x1,0x40(%rsp)
je     1600 <reorder+0x4e0>
imul   0x8(%rsp),%r14
add    %rsi,%r14
mov    %r14,%rcx
sub    0xd8(%rsp),%rcx
mov    0x10(%rsp),%rbx
movsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%r14,8)
test   %ebp,%ebp
jle    1530 <reorder+0x410>
cmpq   $0x0,0x50(%rsp)
je     1680 <reorder+0x560>
mov    0x18(%rsp),%rbp
lea    0x0(,%rdx,8),%rcx
add    %rbp,%rcx
lea    0x0(,%r10,8),%rbx
add    %rbp,%rbx
lea    0x0(%rbp,%rsi,8),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%r12,1),%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  (%rbx),%xmm1
movsd  %xmm1,(%rcx)
add    $0x2,%rdx
add    %r13,%rcx
add    %r13,%rbx
add    %r13,%rbp
cmp    %rdx,%r11
jne    1640 <reorder+0x520>
jmp    1682 <reorder+0x562>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
testb  $0x1,0x40(%rsp)
jne    15dc <reorder+0x4bc>
jmp    1600 <reorder+0x4e0>
xor    %edx,%edx
testb  $0x1,0x28(%rsp)
mov    0x58(%rsp),%rbp
je     1530 <reorder+0x410>
imul   0x8(%rsp),%rdx
add    %rsi,%rdx
mov    %rdx,%rcx
sub    0xd8(%rsp),%rcx
mov    0x18(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
jmp    1530 <reorder+0x410>
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rdi
movsd  %xmm0,(%r14,%rdi,8)
cmpl   $0x0,0x20(%rsp)
jle    17d5 <reorder+0x6b5>
cmpq   $0x3,0x48(%rsp)
jae    16f0 <reorder+0x5d0>
xor    %edx,%edx
jmp    177b <reorder+0x65b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rdi,8),%r9
lea    0x0(,%rdi,8),%r10
add    %r13,%r10
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,1),%r15
mov    0x80(%rsp),%rax
lea    (%rax,%rdi,8),%rbx
mov    0x10(%rsp),%rcx
xor    %edx,%edx
mov    0x98(%rsp),%rsi
mov    0x60(%rsp),%rax
mov    0x30(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%r9,1)
movsd  0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%r15,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%r10,1)
movsd  0x18(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
add    $0x4,%rdx
add    %rax,%rcx
cmp    %rdx,%rsi
jne    1740 <reorder+0x620>
testb  $0x3,0x40(%rsp)
mov    0x58(%rsp),%rbp
mov    0xb8(%rsp),%r10
mov    0x88(%rsp),%rbx
je     17d5 <reorder+0x6b5>
mov    0x8(%rsp),%rcx
imul   %rdx,%rcx
add    %rdi,%rcx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    0x30(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rsi
add    %rbx,%rcx
cmp    %rsi,%r10
jne    17c0 <reorder+0x6a0>
test   %ebp,%ebp
mov    0x68(%rsp),%r9
jle    1310 <reorder+0x1f0>
cmpq   $0x3,0x50(%rsp)
jae    1800 <reorder+0x6e0>
xor    %edx,%edx
jmp    1889 <reorder+0x769>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rdi,8),%r9
lea    0x0(,%rdi,8),%r10
add    %r13,%r10
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
mov    0x80(%rsp),%rax
lea    (%rax,%rdi,8),%rbx
mov    0x18(%rsp),%rcx
xor    %edx,%edx
mov    0x38(%rsp),%rax
mov    0x90(%rsp),%rsi
mov    0x60(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%r9,1)
movsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movsd  0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%r10,1)
movsd  0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
add    $0x4,%rdx
add    %r15,%rcx
cmp    %rdx,%rsi
jne    1850 <reorder+0x730>
testb  $0x3,0x28(%rsp)
mov    0x58(%rsp),%rbp
mov    0xb0(%rsp),%rax
mov    0x88(%rsp),%rbx
mov    0x68(%rsp),%r9
je     1310 <reorder+0x1f0>
mov    0x8(%rsp),%rcx
imul   %rdx,%rcx
add    %rcx,%rdi
mov    0x18(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rax,%rsi
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
mov    %rsi,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rsi
add    %rbx,%rcx
cmp    %rsi,%rax
jne    18e0 <reorder+0x7c0>
jmp    1310 <reorder+0x1f0>
test   %ebp,%ebp
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rdi
jle    1b82 <reorder+0xa62>
add    0x20(%rsp),%ebp
mov    %ebp,%r8d
shr    $0x1f,%r8d
add    %ebp,%r8d
sar    %r8d
mov    0x40(%rsp),%rdx
mov    %edx,%r14d
and    $0xfffffffe,%r14d
mov    0x28(%rsp),%rsi
and    $0xfffffffe,%esi
xor    %r11d,%r11d
xorpd  %xmm0,%xmm0
movapd 0x6c0(%rip),%xmm1
movapd 0x6b8(%rip),%xmm2
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%r9
jmp    1977 <reorder+0x857>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11
add    $0x8,%r9
add    $0x8,%r10
cmp    0x28(%rsp),%r11
je     1b82 <reorder+0xa62>
mov    $0x0,%ecx
cmpl   $0x0,0x20(%rsp)
jle    19e2 <reorder+0x8c2>
cmpq   $0x0,0x48(%rsp)
je     1b30 <reorder+0xa10>
xor    %ebp,%ebp
mov    %r9,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xor    %ebx,%ebx
ucomisd (%rdx),%xmm0
seta   %bl
add    %ecx,%ebx
xor    %ecx,%ecx
ucomisd (%rdx,%rax,8),%xmm0
seta   %cl
add    %ebx,%ecx
add    $0x2,%rbp
add    %r13,%rdx
cmp    %rbp,%r14
jne    19a0 <reorder+0x880>
testb  $0x1,0x40(%rsp)
je     19e2 <reorder+0x8c2>
imul   %rax,%rbp
add    %r11,%rbp
xor    %edx,%edx
mov    0x10(%rsp),%rbx
ucomisd (%rbx,%rbp,8),%xmm0
seta   %dl
add    %edx,%ecx
cmpq   $0x0,0x50(%rsp)
je     1b10 <reorder+0x9f0>
mov    %r10,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebx,%ebx
ucomisd (%rdx),%xmm0
seta   %bl
add    %ecx,%ebx
xor    %ecx,%ecx
ucomisd (%rdx,%rax,8),%xmm0
seta   %cl
add    %ebx,%ecx
add    $0x2,%rbp
add    %r13,%rdx
cmp    %rbp,%rsi
jne    1a00 <reorder+0x8e0>
testb  $0x1,0x28(%rsp)
je     1a42 <reorder+0x922>
imul   %rax,%rbp
add    %r11,%rbp
xor    %edx,%edx
mov    0x18(%rsp),%rbx
ucomisd (%rbx,%rbp,8),%xmm0
seta   %dl
add    %edx,%ecx
cmp    %r8d,%ecx
jle    1960 <reorder+0x840>
cmpl   $0x0,0x20(%rsp)
jle    1ab7 <reorder+0x997>
cmpq   $0x0,0x48(%rsp)
je     1b70 <reorder+0xa50>
mov    %r9,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdx)
movsd  (%rdx,%rax,8),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdx,%rax,8)
add    $0x2,%rcx
add    %r13,%rdx
cmp    %rcx,%r14
jne    1a70 <reorder+0x950>
testb  $0x1,0x40(%rsp)
je     1ab7 <reorder+0x997>
imul   %rax,%rcx
add    %r11,%rcx
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm3
xorpd  %xmm1,%xmm3
movlpd %xmm3,(%rdx,%rcx,8)
cmpq   $0x0,0x50(%rsp)
je     1b44 <reorder+0xa24>
mov    %r10,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdx)
movsd  (%rdx,%rax,8),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdx,%rax,8)
add    $0x2,%rcx
add    %r13,%rdx
cmp    %rcx,%rsi
jne    1ad0 <reorder+0x9b0>
testb  $0x1,0x28(%rsp)
je     1960 <reorder+0x840>
jmp    1b51 <reorder+0xa31>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebp,%ebp
testb  $0x1,0x28(%rsp)
jne    1a2a <reorder+0x90a>
jmp    1a42 <reorder+0x922>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebp,%ebp
xor    %ecx,%ecx
testb  $0x1,0x40(%rsp)
jne    19ca <reorder+0x8aa>
jmp    19e2 <reorder+0x8c2>
xor    %ecx,%ecx
testb  $0x1,0x28(%rsp)
je     1960 <reorder+0x840>
imul   %rax,%rcx
add    %r11,%rcx
mov    0x18(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm3
xorpd  %xmm1,%xmm3
movlpd %xmm3,(%rdx,%rcx,8)
jmp    1960 <reorder+0x840>
xor    %ecx,%ecx
testb  $0x1,0x40(%rsp)
jne    1a9d <reorder+0x97d>
jmp    1ab7 <reorder+0x997>
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
jmp    1ba3 <reorder+0xa83>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%rdi
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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