#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*/ assert(double *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(size_t);
void dbl_move(double *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  double *src, *dst;
  double fxd[1024], *buf;
  assert(array);
  if ((pos >= off) && (pos < off + n))
    return;
  if (pos < off) {
    end = off + n;
    off = pos;
    pos = end - n;
  } else {
    end = pos + 1;
    pos = off + n;
  }
  buf = fxd;
  if (pos + pos > end + off) {
    while (pos > off) {
      n = pos - off;
      if (n > 1024) {
        buf = (double *)malloc(n * sizeof(double));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = array + pos - n;
      dst = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      dst = array + pos - n;
      for (i = end - pos; i > 0; i--)
        *dst++ = *src++;
      src = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      pos -= n;
      end -= n;
    }
  } else {
    while (end > pos) {
      n = end - pos;
      if (n > 1024) {
        buf = (double *)malloc(n * sizeof(double));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = array + pos + n;
      dst = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      dst = array + pos + n;
      for (i = pos - off; i > 0; i--)
        *--dst = *--src;
      src = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      pos += n;
      off += n;
    }
  }
  if (buf != fxd)
    free(buf);
}


x86 assembly (clang, -O0):
<dbl_move>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2050,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <assert@plt>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     117c <dbl_move+0x4c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    117c <dbl_move+0x4c>
jmp    15b7 <dbl_move+0x487>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11af <dbl_move+0x7f>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    11c7 <dbl_move+0x97>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
mov    -0x20(%rbp),%rax
add    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jbe    13b8 <dbl_move+0x288>
jmp    11f3 <dbl_move+0xc3>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    13b3 <dbl_move+0x283>
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1258 <dbl_move+0x128>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    1253 <dbl_move+0x123>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1258 <dbl_move+0x128>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2048(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    12cd <dbl_move+0x19d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    128b <dbl_move+0x15b>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    133b <dbl_move+0x20b>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    12f9 <dbl_move+0x1c9>
mov    -0x2048(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1390 <dbl_move+0x260>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    134e <dbl_move+0x21e>
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
jmp    11f3 <dbl_move+0xc3>
jmp    1594 <dbl_move+0x464>
jmp    13bd <dbl_move+0x28d>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    158f <dbl_move+0x45f>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1422 <dbl_move+0x2f2>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    141d <dbl_move+0x2ed>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1422 <dbl_move+0x2f2>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    14a2 <dbl_move+0x372>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  -0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    145e <dbl_move+0x32e>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1510 <dbl_move+0x3e0>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  -0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    14cc <dbl_move+0x39c>
mov    -0x2048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1572 <dbl_move+0x442>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  -0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    152e <dbl_move+0x3fe>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    13bd <dbl_move+0x28d>
jmp    1594 <dbl_move+0x464>
mov    -0x2048(%rbp),%rax
lea    -0x2040(%rbp),%rcx
cmp    %rcx,%rax
je     15b7 <dbl_move+0x487>
mov    -0x2048(%rbp),%rdi
call   1030 <free@plt>
add    $0x2050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dbl_move>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2018,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,(%rsp)
call   1040 <assert@plt>
add    %r15,%rbx
cmp    %r15,%r14
jb     1164 <dbl_move+0x34>
cmp    %r14,%rbx
ja     1d74 <dbl_move+0xc44>
lea    0x1(%r14),%r10
cmp    %r15,%r14
cmovae %r15,%r14
cmovae %rbx,%r15
cmovb  %rbx,%r10
lea    (%r15,%r15,1),%rax
lea    (%r10,%r14,1),%rcx
cmp    %rcx,%rax
jbe    1787 <dbl_move+0x657>
cmp    %r14,%r15
jbe    1d74 <dbl_move+0xc44>
lea    0x10(%rsp),%r13
mov    %r13,%r11
jmp    11af <dbl_move+0x7f>
nopl   0x0(%rax,%rax,1)
sub    %r12,%r15
sub    %r12,%r10
cmp    %r14,%r15
jbe    1d62 <dbl_move+0xc32>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     1200 <dbl_move+0xd0>
lea    0x0(,%r12,8),%rdi
mov    %r10,%rbx
call   1050 <malloc@plt>
mov    %rbx,%r10
mov    %rax,%r11
test   %rax,%rax
mov    $0x400,%eax
cmove  %rax,%r12
cmove  %r13,%r11
mov    (%rsp),%rax
lea    (%rax,%r15,8),%rax
lea    0x0(,%r12,8),%rcx
sub    %rcx,%rax
jmp    1218 <dbl_move+0xe8>
nopl   0x0(%rax)
mov    (%rsp),%rax
lea    (%rax,%r15,8),%rax
lea    0x0(,%r12,8),%rcx
sub    %rcx,%rax
test   %r12,%r12
je     1272 <dbl_move+0x142>
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    $0x4,%r12
jb     1350 <dbl_move+0x220>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    124a <dbl_move+0x11a>
lea    (%r11,%r12,8),%rsi
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    %rsi,%rax
jb     1350 <dbl_move+0x220>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdi
jae    1280 <dbl_move+0x150>
xor    %ebp,%ebp
jmp    12f0 <dbl_move+0x1c0>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rax,%rcx
jmp    13f6 <dbl_move+0x2c6>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %ebp,%ebp
nop
movups (%rax,%rbp,8),%xmm0
movups 0x10(%rax,%rbp,8),%xmm1
movups %xmm0,(%r11,%rbp,8)
movups %xmm1,0x10(%r11,%rbp,8)
movups 0x20(%rax,%rbp,8),%xmm0
movups 0x30(%rax,%rbp,8),%xmm1
movups %xmm0,0x20(%r11,%rbp,8)
movups %xmm1,0x30(%r11,%rbp,8)
movups 0x40(%rax,%rbp,8),%xmm0
movups 0x50(%rax,%rbp,8),%xmm1
movups %xmm0,0x40(%r11,%rbp,8)
movups %xmm1,0x50(%r11,%rbp,8)
movups 0x60(%rax,%rbp,8),%xmm0
movups 0x70(%rax,%rbp,8),%xmm1
movups %xmm0,0x60(%r11,%rbp,8)
movups %xmm1,0x70(%r11,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1290 <dbl_move+0x160>
test   %rcx,%rcx
je     132b <dbl_move+0x1fb>
lea    (%rax,%rbp,8),%rsi
add    $0x10,%rsi
lea    (%r11,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1310 <dbl_move+0x1e0>
lea    (%rax,%rdx,8),%rcx
cmp    %rdx,%r12
je     13f3 <dbl_move+0x2c3>
mov    %r12d,%ebx
and    $0x3,%ebx
lea    (%r11,%rdx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbx),%rbp
mov    %rbx,%rsi
and    $0x7,%rsi
je     137c <dbl_move+0x24c>
xor    %edi,%edi
nop
movsd  (%rcx),%xmm0
add    $0x8,%rcx
movsd  %xmm0,(%rdx)
add    $0x8,%rdx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1360 <dbl_move+0x230>
sub    %rdi,%rbx
cmp    $0x7,%rbp
jb     13f3 <dbl_move+0x2c3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x8(%rdx,%rbp,8)
movsd  0x10(%rcx),%xmm0
movsd  %xmm0,0x10(%rdx,%rbp,8)
movsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x18(%rdx,%rbp,8)
movsd  0x20(%rcx),%xmm0
movsd  %xmm0,0x20(%rdx,%rbp,8)
movsd  0x28(%rcx),%xmm0
movsd  %xmm0,0x28(%rdx,%rbp,8)
movsd  0x30(%rcx),%xmm0
movsd  %xmm0,0x30(%rdx,%rbp,8)
movsd  0x38(%rcx),%xmm0
add    $0x40,%rcx
movsd  %xmm0,0x38(%rdx,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    1390 <dbl_move+0x260>
xor    %r8d,%r8d
mov    %r10,%rsi
sub    %r15,%rsi
je     15b3 <dbl_move+0x483>
cmp    $0x4,%rsi
jb     1510 <dbl_move+0x3e0>
lea    (%rcx,%rsi,8),%rdx
cmp    %rdx,%rax
jae    1422 <dbl_move+0x2f2>
lea    (%rax,%rsi,8),%rdx
cmp    %rdx,%rcx
jb     1510 <dbl_move+0x3e0>
mov    %rsi,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdi
mov    %rdi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ebx,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1447 <dbl_move+0x317>
xor    %ebp,%ebp
jmp    14b8 <dbl_move+0x388>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups (%rcx,%rbp,8),%xmm0
movups 0x10(%rcx,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%rcx,%rbp,8),%xmm0
movups 0x30(%rcx,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%rcx,%rbp,8),%xmm0
movups 0x50(%rcx,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%rcx,%rbp,8),%xmm0
movups 0x70(%rcx,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1460 <dbl_move+0x330>
test   %rdx,%rdx
je     14fc <dbl_move+0x3cc>
lea    (%rcx,%rbp,8),%rdi
add    $0x10,%rdi
lea    (%rax,%rbp,8),%rbp
add    $0x10,%rbp
shl    $0x5,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    14e0 <dbl_move+0x3b0>
lea    (%rax,%r9,8),%rax
cmp    %r9,%rsi
je     15b3 <dbl_move+0x483>
and    $0x3,%esi
lea    (%rcx,%r9,8),%rcx
lea    -0x1(%rsi),%rbp
mov    %rsi,%rdx
and    $0x7,%rdx
je     153c <dbl_move+0x40c>
xor    %edi,%edi
nop
movsd  (%rcx),%xmm0
add    $0x8,%rcx
movsd  %xmm0,(%rax)
add    $0x8,%rax
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1520 <dbl_move+0x3f0>
sub    %rdi,%rsi
cmp    $0x7,%rbp
jb     15b3 <dbl_move+0x483>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rax)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rax)
movsd  0x20(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x20(%rax)
movsd  0x28(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x28(%rax)
movsd  0x30(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x30(%rax)
movsd  0x38(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x38(%rax)
add    $0x40,%rax
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1550 <dbl_move+0x420>
test   %r8b,%r8b
jne    11a0 <dbl_move+0x70>
cmp    $0x4,%r12
jb     15dc <dbl_move+0x4ac>
lea    (%r11,%r12,8),%rcx
cmp    %rcx,%rax
jae    169c <dbl_move+0x56c>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    169c <dbl_move+0x56c>
mov    %r11,%rdx
mov    %r12,%rbp
lea    -0x1(%rbp),%rsi
mov    %rbp,%rcx
and    $0x7,%rcx
je     161c <dbl_move+0x4ec>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm0
add    $0x8,%rdx
movsd  %xmm0,(%rax)
add    $0x8,%rax
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1600 <dbl_move+0x4d0>
sub    %rdi,%rbp
cmp    $0x7,%rsi
jb     11a0 <dbl_move+0x70>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
movsd  0x20(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x20(%rax,%rcx,8)
movsd  0x28(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x28(%rax,%rcx,8)
movsd  0x30(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x30(%rax,%rcx,8)
movsd  0x38(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x38(%rax,%rcx,8)
add    $0x8,%rcx
cmp    %rcx,%rbp
jne    1630 <dbl_move+0x500>
jmp    11a0 <dbl_move+0x70>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdi
jae    16c1 <dbl_move+0x591>
xor    %ebp,%ebp
jmp    1730 <dbl_move+0x600>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %ebp,%ebp
movups (%r11,%rbp,8),%xmm0
movups 0x10(%r11,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%r11,%rbp,8),%xmm0
movups 0x30(%r11,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%r11,%rbp,8),%xmm0
movups 0x50(%r11,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%r11,%rbp,8),%xmm0
movups 0x70(%r11,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    16d0 <dbl_move+0x5a0>
test   %rcx,%rcx
je     176b <dbl_move+0x63b>
lea    (%r11,%rbp,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1750 <dbl_move+0x620>
cmp    %rdx,%r12
je     11a0 <dbl_move+0x70>
mov    %r12d,%ebp
and    $0x3,%ebp
lea    (%rax,%rdx,8),%rax
lea    (%r11,%rdx,8),%rdx
jmp    15e2 <dbl_move+0x4b2>
cmp    %r15,%r10
jbe    1d74 <dbl_move+0xc44>
lea    0x10(%rsp),%r11
mov    (%rsp),%rax
lea    (%rax,%r10,8),%rax
mov    %rax,0x8(%rsp)
mov    %r10,%r12
jmp    17bf <dbl_move+0x68f>
nopw   0x0(%rax,%rax,1)
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r10
jbe    1d62 <dbl_move+0xc32>
mov    %r10,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     1810 <dbl_move+0x6e0>
lea    0x0(,%r13,8),%rdi
call   1050 <malloc@plt>
mov    %r12,%r10
mov    %rax,%r11
test   %rax,%rax
mov    $0x400,%eax
cmove  %rax,%r13
lea    0x10(%rsp),%rax
cmove  %rax,%r11
mov    (%rsp),%rax
lea    (%rax,%r15,8),%rax
lea    (%rax,%r13,8),%rbx
lea    (%r11,%r13,8),%rcx
jmp    1822 <dbl_move+0x6f2>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,8),%rcx
test   %r13,%r13
je     18c7 <dbl_move+0x797>
mov    0x8(%rsp),%rbx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%rdi
cmp    $0x4,%r13
jb     1930 <dbl_move+0x800>
lea    0x0(,%r13,8),%rax
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1860 <dbl_move+0x730>
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%rdi
cmp    %rcx,%rdx
jb     1930 <dbl_move+0x800>
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     18da <dbl_move+0x7aa>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
lea    0x2(%rsi),%rdi
and    %rdx,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movups -0x20(%rbx,%rsi,8),%xmm0
movups -0x10(%rbx,%rsi,8),%xmm1
movups %xmm1,-0x10(%rcx,%rsi,8)
movups %xmm0,-0x20(%rcx,%rsi,8)
movups -0x40(%rbx,%rsi,8),%xmm0
movups -0x30(%rbx,%rsi,8),%xmm1
movups %xmm1,-0x30(%rcx,%rsi,8)
movups %xmm0,-0x40(%rcx,%rsi,8)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1890 <dbl_move+0x760>
neg    %rsi
jmp    18dc <dbl_move+0x7ac>
mov    $0x1,%r8b
mov    0x8(%rsp),%rsi
mov    %rsi,%rbx
xor    %r13d,%r13d
jmp    19d8 <dbl_move+0x8a8>
xor    %esi,%esi
lea    0x0(,%rax,8),%rbp
test   $0x1,%dl
je     1909 <dbl_move+0x7d9>
shl    $0x3,%rsi
mov    %rcx,%rdx
sub    %rsi,%rdx
mov    %rbx,%rdi
sub    %rsi,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rdx)
movups %xmm0,-0x20(%rdx)
mov    %rbx,%rsi
sub    %rbp,%rsi
cmp    %rax,%r13
je     19d5 <dbl_move+0x8a5>
mov    %r13d,%edi
and    $0x3,%edi
mov    %rcx,%rax
sub    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rdi),%r8
mov    %rdi,%rdx
and    $0x7,%rdx
je     195e <dbl_move+0x82e>
xor    %ebp,%ebp
nop
movsd  -0x8(%rsi),%xmm0
add    $0xfffffffffffffff8,%rsi
movsd  %xmm0,-0x8(%rax)
add    $0xfffffffffffffff8,%rax
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1940 <dbl_move+0x810>
sub    %rbp,%rdi
cmp    $0x7,%r8
jb     19d5 <dbl_move+0x8a5>
neg    %rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  -0x8(%rsi),%xmm0
movsd  %xmm0,-0x8(%rax,%rbp,8)
movsd  -0x10(%rsi),%xmm0
movsd  %xmm0,-0x10(%rax,%rbp,8)
movsd  -0x18(%rsi),%xmm0
movsd  %xmm0,-0x18(%rax,%rbp,8)
movsd  -0x20(%rsi),%xmm0
movsd  %xmm0,-0x20(%rax,%rbp,8)
movsd  -0x28(%rsi),%xmm0
movsd  %xmm0,-0x28(%rax,%rbp,8)
movsd  -0x30(%rsi),%xmm0
movsd  %xmm0,-0x30(%rax,%rbp,8)
movsd  -0x38(%rsi),%xmm0
movsd  %xmm0,-0x38(%rax,%rbp,8)
movsd  -0x40(%rsi),%xmm0
add    $0xffffffffffffffc0,%rsi
movsd  %xmm0,-0x40(%rax,%rbp,8)
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%rdi
jne    1970 <dbl_move+0x840>
xor    %r8d,%r8d
mov    %r15,%rbp
sub    %r14,%rbp
je     1a95 <dbl_move+0x965>
cmp    $0x4,%rbp
jae    1b80 <dbl_move+0xa50>
lea    -0x1(%rbp),%rax
mov    %rbp,%rdx
and    $0x7,%rdx
je     1a1e <dbl_move+0x8ee>
xor    %edi,%edi
nopl   (%rax)
movsd  -0x8(%rsi),%xmm0
add    $0xfffffffffffffff8,%rsi
movsd  %xmm0,-0x8(%rbx)
add    $0xfffffffffffffff8,%rbx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1a00 <dbl_move+0x8d0>
sub    %rdi,%rbp
mov    %r12,%r10
cmp    $0x7,%rax
jb     1a95 <dbl_move+0x965>
neg    %rbp
xor    %eax,%eax
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbx)
movsd  -0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rbx)
movsd  -0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rbx)
movsd  -0x20(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x20(%rbx)
movsd  -0x28(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x28(%rbx)
movsd  -0x30(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbx)
movsd  -0x38(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x38(%rbx)
movsd  -0x40(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x40(%rbx)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffff8,%rax
cmp    %rax,%rbp
jne    1a30 <dbl_move+0x900>
test   %r8b,%r8b
jne    17b0 <dbl_move+0x680>
cmp    $0x4,%r13
jb     1aca <dbl_move+0x99a>
lea    0x0(,%r13,8),%rax
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
jae    1c5a <dbl_move+0xb2a>
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1c5a <dbl_move+0xb2a>
mov    %r13,%rax
lea    -0x1(%rax),%rdx
mov    %rax,%rsi
and    $0x7,%rsi
je     1afe <dbl_move+0x9ce>
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rcx),%xmm0
add    $0xfffffffffffffff8,%rcx
movsd  %xmm0,-0x8(%rbx)
add    $0xfffffffffffffff8,%rbx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1ae0 <dbl_move+0x9b0>
sub    %rdi,%rax
cmp    $0x7,%rdx
jb     17b0 <dbl_move+0x680>
neg    %rax
xor    %edx,%edx
nopl   (%rax)
movsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdx,8)
movsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rbx,%rdx,8)
movsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rbx,%rdx,8)
movsd  -0x20(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x20(%rbx,%rdx,8)
movsd  -0x28(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x28(%rbx,%rdx,8)
movsd  -0x30(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x30(%rbx,%rdx,8)
movsd  -0x38(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x38(%rbx,%rdx,8)
movsd  -0x40(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x40(%rbx,%rdx,8)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rax
jne    1b10 <dbl_move+0x9e0>
jmp    17b0 <dbl_move+0x680>
xchg   %ax,%ax
mov    %r14,%rax
not    %rax
add    %r15,%rax
mov    $0x8,%edx
mul    %rdx
lea    -0x8(%rbx),%rdx
seto   %r9b
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ee <dbl_move+0x8be>
test   %r9b,%r9b
jne    19ee <dbl_move+0x8be>
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ee <dbl_move+0x8be>
test   %r9b,%r9b
jne    19ee <dbl_move+0x8be>
mov    %r14,%rax
sub    %r15,%rax
lea    (%rbx,%rax,8),%rdx
cmp    %rsi,%rdx
jae    1be9 <dbl_move+0xab9>
lea    (%rsi,%rax,8),%rax
cmp    %rbx,%rax
jb     19ee <dbl_move+0x8be>
mov    %rbp,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1d0f <dbl_move+0xbdf>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
lea    0x2(%rax),%rdi
and    %rdx,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x20(%rsi,%rax,8),%xmm0
movups -0x10(%rsi,%rax,8),%xmm1
movups %xmm1,-0x10(%rbx,%rax,8)
movups %xmm0,-0x20(%rbx,%rax,8)
movups -0x40(%rsi,%rax,8),%xmm0
movups -0x30(%rsi,%rax,8),%xmm1
movups %xmm1,-0x30(%rbx,%rax,8)
movups %xmm0,-0x40(%rbx,%rax,8)
add    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1c20 <dbl_move+0xaf0>
neg    %rax
jmp    1d11 <dbl_move+0xbe1>
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     1d07 <dbl_move+0xbd7>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
lea    0x2(%rsi),%rdi
and    %rax,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x20(%rcx,%rsi,8),%xmm0
movups -0x10(%rcx,%rsi,8),%xmm1
movups %xmm1,-0x10(%rbx,%rsi,8)
movups %xmm0,-0x20(%rbx,%rsi,8)
movups -0x40(%rcx,%rsi,8),%xmm0
movups -0x30(%rcx,%rsi,8),%xmm1
movups %xmm1,-0x30(%rbx,%rsi,8)
movups %xmm0,-0x40(%rbx,%rsi,8)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1c90 <dbl_move+0xb60>
neg    %rsi
test   $0x1,%al
je     1ce9 <dbl_move+0xbb9>
shl    $0x3,%rsi
mov    %rbx,%rax
sub    %rsi,%rax
mov    %rcx,%rdi
sub    %rsi,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rax)
movups %xmm0,-0x20(%rax)
cmp    %rdx,%r13
je     17b0 <dbl_move+0x680>
shl    $0x3,%rdx
mov    %r13d,%eax
and    $0x3,%eax
sub    %rdx,%rbx
sub    %rdx,%rcx
jmp    1acd <dbl_move+0x99d>
xor    %esi,%esi
test   $0x1,%al
jne    1cc9 <dbl_move+0xb99>
jmp    1ce9 <dbl_move+0xbb9>
xor    %eax,%eax
lea    0x0(,%r9,8),%r10
test   $0x1,%dl
je     1d3e <dbl_move+0xc0e>
shl    $0x3,%rax
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rsi,%rdi
sub    %rax,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rdx)
movups %xmm0,-0x20(%rdx)
sub    %r10,%rbx
cmp    %r9,%rbp
jne    1d57 <dbl_move+0xc27>
mov    %r12,%r10
test   %r8b,%r8b
jne    17b0 <dbl_move+0x680>
jmp    1a9e <dbl_move+0x96e>
and    $0x3,%ebp
sub    %r10,%rsi
jmp    19ee <dbl_move+0x8be>
lea    0x10(%rsp),%rax
cmp    %rax,%r11
je     1d74 <dbl_move+0xc44>
mov    %r11,%rdi
call   1030 <free@plt>
add    $0x2018,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @dbl_move(double* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca [1024 x double]
%6 = bitcast [1024 x double]* %5 to i8*
%7 = tail call i32 @assert(double* %0)
%8 = icmp uge i64 %3, %1
%9 = add i64 %2, %1
%10 = icmp ugt i64 %9, %3
%11 = and i1 %8, %10
br i1 %11, label %990, label %12
12: ; preds = %4
%13 = icmp ult i64 %3, %1
%14 = add i64 %3, 1
%15 = select i1 %13, i64 %3, i64 %1
%16 = select i1 %13, i64 %1, i64 %9
%17 = select i1 %13, i64 %9, i64 %14
%18 = getelementptr inbounds [1024 x double], [1024 x double]* %5, i64 0, i64 0
%19 = shl i64 %16, 1
%20 = add i64 %17, %15
%21 = icmp ugt i64 %19, %20
br i1 %21, label %26, label %22
22: ; preds = %12
%23 = icmp ugt i64 %17, %16
br i1 %23, label %24, label %990
24: ; preds = %22
%25 = getelementptr double, double* %0, i64 %17
br label %497
26: ; preds = %12
%27 = icmp ugt i64 %16, %15
br i1 %27, label %28, label %990
28: ; preds = %26, %493
%29 = phi double* [ %199, %493 ], [ %18, %26 ]
%30 = phi i64 [ %495, %493 ], [ %17, %26 ]
%31 = phi i64 [ %494, %493 ], [ %16, %26 ]
%32 = sub i64 %31, %15
%33 = icmp ugt i64 %32, 1024
br i1 %33, label %34, label %44
34: ; preds = %28
%35 = shl i64 %32, 3
%36 = tail call i64 @malloc(i64 %35)
%37 = inttoptr i64 %36 to double*
%38 = icmp eq i64 %36, 0
%39 = select i1 %38, i64 1024, i64 %32
%40 = select i1 %38, double* %18, double* %37
%41 = getelementptr inbounds double, double* %0, i64 %31
%42 = sub i64 0, %39
%43 = getelementptr double, double* %41, i64 %42
br label %49
44: ; preds = %28
%45 = getelementptr inbounds double, double* %0, i64 %31
%46 = sub nsw i64 0, %32
%47 = getelementptr double, double* %45, i64 %46
%48 = icmp eq i64 %32, 0
br i1 %48, label %196, label %49
49: ; preds = %34, %44
%50 = phi double* [ %43, %34 ], [ %47, %44 ]
%51 = phi double* [ %40, %34 ], [ %29, %44 ]
%52 = phi i64 [ %39, %34 ], [ %32, %44 ]
%53 = icmp ult i64 %52, 4
br i1 %53, label %142, label %54
54: ; preds = %49
%55 = getelementptr double, double* %51, i64 %52
%56 = getelementptr double, double* %50, i64 %52
%57 = icmp ult double* %51, %56
%58 = icmp ult double* %50, %55
%59 = and i1 %57, %58
br i1 %59, label %142, label %60
60: ; preds = %54
%61 = and i64 %52, -4
%62 = getelementptr double, double* %51, i64 %61
%63 = getelementptr double, double* %50, i64 %61
%64 = and i64 %52, 3
%65 = add i64 %61, -4
%66 = lshr exact i64 %65, 2
%67 = add nuw nsw i64 %66, 1
%68 = and i64 %67, 3
%69 = icmp ult i64 %65, 12
br i1 %69, label %121, label %70
70: ; preds = %60
%71 = and i64 %67, 9223372036854775804
br label %72
72: ; preds = %72, %70
%73 = phi i64 [ 0, %70 ], [ %118, %72 ]
%74 = phi i64 [ 0, %70 ], [ %119, %72 ]
%75 = getelementptr double, double* %51, i64 %73
%76 = getelementptr double, double* %50, i64 %73
%77 = bitcast double* %76 to <2 x double>*
%78 = load <2 x double>, <2 x double>* %77
%79 = getelementptr double, double* %76, i64 2
%80 = bitcast double* %79 to <2 x double>*
%81 = load <2 x double>, <2 x double>* %80
%82 = bitcast double* %75 to <2 x double>*
store <2 x double> %78, <2 x double>* %82
%83 = getelementptr double, double* %75, i64 2
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %81, <2 x double>* %84
%85 = or i64 %73, 4
%86 = getelementptr double, double* %51, i64 %85
%87 = getelementptr double, double* %50, i64 %85
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = bitcast double* %86 to <2 x double>*
store <2 x double> %89, <2 x double>* %93
%94 = getelementptr double, double* %86, i64 2
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %92, <2 x double>* %95
%96 = or i64 %73, 8
%97 = getelementptr double, double* %51, i64 %96
%98 = getelementptr double, double* %50, i64 %96
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = getelementptr double, double* %98, i64 2
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = bitcast double* %97 to <2 x double>*
store <2 x double> %100, <2 x double>* %104
%105 = getelementptr double, double* %97, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %103, <2 x double>* %106
%107 = or i64 %73, 12
%108 = getelementptr double, double* %51, i64 %107
%109 = getelementptr double, double* %50, i64 %107
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr double, double* %109, i64 2
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = bitcast double* %108 to <2 x double>*
store <2 x double> %111, <2 x double>* %115
%116 = getelementptr double, double* %108, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %114, <2 x double>* %117
%118 = add nuw i64 %73, 16
%119 = add nuw i64 %74, 4
%120 = icmp eq i64 %119, %71
br i1 %120, label %121, label %72
121: ; preds = %72, %60
%122 = phi i64 [ 0, %60 ], [ %118, %72 ]
%123 = icmp eq i64 %68, 0
br i1 %123, label %140, label %124
124: ; preds = %121, %124
%125 = phi i64 [ %137, %124 ], [ %122, %121 ]
%126 = phi i64 [ %138, %124 ], [ 0, %121 ]
%127 = getelementptr double, double* %51, i64 %125
%128 = getelementptr double, double* %50, i64 %125
%129 = bitcast double* %128 to <2 x double>*
%130 = load <2 x double>, <2 x double>* %129
%131 = getelementptr double, double* %128, i64 2
%132 = bitcast double* %131 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = bitcast double* %127 to <2 x double>*
store <2 x double> %130, <2 x double>* %134
%135 = getelementptr double, double* %127, i64 2
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %133, <2 x double>* %136
%137 = add nuw i64 %125, 4
%138 = add i64 %126, 1
%139 = icmp eq i64 %138, %68
br i1 %139, label %140, label %124
140: ; preds = %124, %121
%141 = icmp eq i64 %52, %61
br i1 %141, label %196, label %142
142: ; preds = %54, %49, %140
%143 = phi double* [ %51, %54 ], [ %51, %49 ], [ %62, %140 ]
%144 = phi double* [ %50, %54 ], [ %50, %49 ], [ %63, %140 ]
%145 = phi i64 [ %52, %54 ], [ %52, %49 ], [ %64, %140 ]
%146 = add i64 %145, -1
%147 = and i64 %145, 7
%148 = icmp eq i64 %147, 0
br i1 %148, label %160, label %149
149: ; preds = %142, %149
%150 = phi double* [ %156, %149 ], [ %143, %142 ]
%151 = phi double* [ %154, %149 ], [ %144, %142 ]
%152 = phi i64 [ %157, %149 ], [ %145, %142 ]
%153 = phi i64 [ %158, %149 ], [ 0, %142 ]
%154 = getelementptr inbounds double, double* %151, i64 1
%155 = load double, double* %151
%156 = getelementptr inbounds double, double* %150, i64 1
store double %155, double* %150
%157 = add i64 %152, -1
%158 = add i64 %153, 1
%159 = icmp eq i64 %158, %147
br i1 %159, label %160, label %149
160: ; preds = %149, %142
%161 = phi double* [ undef, %142 ], [ %154, %149 ]
%162 = phi double* [ %143, %142 ], [ %156, %149 ]
%163 = phi double* [ %144, %142 ], [ %154, %149 ]
%164 = phi i64 [ %145, %142 ], [ %157, %149 ]
%165 = icmp ult i64 %146, 7
br i1 %165, label %196, label %166
166: ; preds = %160, %166
%167 = phi double* [ %193, %166 ], [ %162, %160 ]
%168 = phi double* [ %191, %166 ], [ %163, %160 ]
%169 = phi i64 [ %194, %166 ], [ %164, %160 ]
%170 = getelementptr inbounds double, double* %168, i64 1
%171 = load double, double* %168
%172 = getelementptr inbounds double, double* %167, i64 1
store double %171, double* %167
%173 = getelementptr inbounds double, double* %168, i64 2
%174 = load double, double* %170
%175 = getelementptr inbounds double, double* %167, i64 2
store double %174, double* %172
%176 = getelementptr inbounds double, double* %168, i64 3
%177 = load double, double* %173
%178 = getelementptr inbounds double, double* %167, i64 3
store double %177, double* %175
%179 = getelementptr inbounds double, double* %168, i64 4
%180 = load double, double* %176
%181 = getelementptr inbounds double, double* %167, i64 4
store double %180, double* %178
%182 = getelementptr inbounds double, double* %168, i64 5
%183 = load double, double* %179
%184 = getelementptr inbounds double, double* %167, i64 5
store double %183, double* %181
%185 = getelementptr inbounds double, double* %168, i64 6
%186 = load double, double* %182
%187 = getelementptr inbounds double, double* %167, i64 6
store double %186, double* %184
%188 = getelementptr inbounds double, double* %168, i64 7
%189 = load double, double* %185
%190 = getelementptr inbounds double, double* %167, i64 7
store double %189, double* %187
%191 = getelementptr inbounds double, double* %168, i64 8
%192 = load double, double* %188
%193 = getelementptr inbounds double, double* %167, i64 8
store double %192, double* %190
%194 = add i64 %169, -8
%195 = icmp eq i64 %194, 0
br i1 %195, label %196, label %166
196: ; preds = %160, %166, %140, %44
%197 = phi i1 [ true, %44 ], [ false, %140 ], [ false, %166 ], [ false, %160 ]
%198 = phi double* [ %47, %44 ], [ %50, %140 ], [ %50, %166 ], [ %50, %160 ]
%199 = phi double* [ %29, %44 ], [ %51, %140 ], [ %51, %166 ], [ %51, %160 ]
%200 = phi i64 [ 0, %44 ], [ %52, %140 ], [ %52, %166 ], [ %52, %160 ]
%201 = phi double* [ %47, %44 ], [ %63, %140 ], [ %161, %160 ], [ %191, %166 ]
%202 = sub i64 %30, %31
%203 = icmp eq i64 %202, 0
br i1 %203, label %318, label %204
204: ; preds = %196
%205 = icmp ult i64 %202, 4
br i1 %205, label %294, label %206
206: ; preds = %204
%207 = getelementptr double, double* %198, i64 %202
%208 = getelementptr double, double* %201, i64 %202
%209 = icmp ult double* %198, %208
%210 = icmp ult double* %201, %207
%211 = and i1 %209, %210
br i1 %211, label %294, label %212
212: ; preds = %206
%213 = and i64 %202, -4
%214 = getelementptr double, double* %198, i64 %213
%215 = getelementptr double, double* %201, i64 %213
%216 = and i64 %202, 3
%217 = add i64 %213, -4
%218 = lshr exact i64 %217, 2
%219 = add nuw nsw i64 %218, 1
%220 = and i64 %219, 3
%221 = icmp ult i64 %217, 12
br i1 %221, label %273, label %222
222: ; preds = %212
%223 = and i64 %219, 9223372036854775804
br label %224
224: ; preds = %224, %222
%225 = phi i64 [ 0, %222 ], [ %270, %224 ]
%226 = phi i64 [ 0, %222 ], [ %271, %224 ]
%227 = getelementptr double, double* %198, i64 %225
%228 = getelementptr double, double* %201, i64 %225
%229 = bitcast double* %228 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = getelementptr double, double* %228, i64 2
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = bitcast double* %227 to <2 x double>*
store <2 x double> %230, <2 x double>* %234
%235 = getelementptr double, double* %227, i64 2
%236 = bitcast double* %235 to <2 x double>*
store <2 x double> %233, <2 x double>* %236
%237 = or i64 %225, 4
%238 = getelementptr double, double* %198, i64 %237
%239 = getelementptr double, double* %201, i64 %237
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr double, double* %239, i64 2
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = bitcast double* %238 to <2 x double>*
store <2 x double> %241, <2 x double>* %245
%246 = getelementptr double, double* %238, i64 2
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> %244, <2 x double>* %247
%248 = or i64 %225, 8
%249 = getelementptr double, double* %198, i64 %248
%250 = getelementptr double, double* %201, i64 %248
%251 = bitcast double* %250 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = getelementptr double, double* %250, i64 2
%254 = bitcast double* %253 to <2 x double>*
%255 = load <2 x double>, <2 x double>* %254
%256 = bitcast double* %249 to <2 x double>*
store <2 x double> %252, <2 x double>* %256
%257 = getelementptr double, double* %249, i64 2
%258 = bitcast double* %257 to <2 x double>*
store <2 x double> %255, <2 x double>* %258
%259 = or i64 %225, 12
%260 = getelementptr double, double* %198, i64 %259
%261 = getelementptr double, double* %201, i64 %259
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = getelementptr double, double* %261, i64 2
%265 = bitcast double* %264 to <2 x double>*
%266 = load <2 x double>, <2 x double>* %265
%267 = bitcast double* %260 to <2 x double>*
store <2 x double> %263, <2 x double>* %267
%268 = getelementptr double, double* %260, i64 2
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> %266, <2 x double>* %269
%270 = add nuw i64 %225, 16
%271 = add nuw i64 %226, 4
%272 = icmp eq i64 %271, %223
br i1 %272, label %273, label %224
273: ; preds = %224, %212
%274 = phi i64 [ 0, %212 ], [ %270, %224 ]
%275 = icmp eq i64 %220, 0
br i1 %275, label %292, label %276
276: ; preds = %273, %276
%277 = phi i64 [ %289, %276 ], [ %274, %273 ]
%278 = phi i64 [ %290, %276 ], [ 0, %273 ]
%279 = getelementptr double, double* %198, i64 %277
%280 = getelementptr double, double* %201, i64 %277
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr double, double* %280, i64 2
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = bitcast double* %279 to <2 x double>*
store <2 x double> %282, <2 x double>* %286
%287 = getelementptr double, double* %279, i64 2
%288 = bitcast double* %287 to <2 x double>*
store <2 x double> %285, <2 x double>* %288
%289 = add nuw i64 %277, 4
%290 = add i64 %278, 1
%291 = icmp eq i64 %290, %220
br i1 %291, label %292, label %276
292: ; preds = %276, %273
%293 = icmp eq i64 %202, %213
br i1 %293, label %318, label %294
294: ; preds = %206, %204, %292
%295 = phi double* [ %198, %206 ], [ %198, %204 ], [ %214, %292 ]
%296 = phi double* [ %201, %206 ], [ %201, %204 ], [ %215, %292 ]
%297 = phi i64 [ %202, %206 ], [ %202, %204 ], [ %216, %292 ]
%298 = add i64 %297, -1
%299 = and i64 %297, 7
%300 = icmp eq i64 %299, 0
br i1 %300, label %312, label %301
301: ; preds = %294, %301
%302 = phi double* [ %308, %301 ], [ %295, %294 ]
%303 = phi double* [ %306, %301 ], [ %296, %294 ]
%304 = phi i64 [ %309, %301 ], [ %297, %294 ]
%305 = phi i64 [ %310, %301 ], [ 0, %294 ]
%306 = getelementptr inbounds double, double* %303, i64 1
%307 = load double, double* %303
%308 = getelementptr inbounds double, double* %302, i64 1
store double %307, double* %302
%309 = add i64 %304, -1
%310 = add i64 %305, 1
%311 = icmp eq i64 %310, %299
br i1 %311, label %312, label %301
312: ; preds = %301, %294
%313 = phi double* [ undef, %294 ], [ %308, %301 ]
%314 = phi double* [ %295, %294 ], [ %308, %301 ]
%315 = phi double* [ %296, %294 ], [ %306, %301 ]
%316 = phi i64 [ %297, %294 ], [ %309, %301 ]
%317 = icmp ult i64 %298, 7
br i1 %317, label %318, label %433
318: ; preds = %312, %433, %292, %196
%319 = phi double* [ %198, %196 ], [ %214, %292 ], [ %313, %312 ], [ %460, %433 ]
br i1 %197, label %493, label %320
320: ; preds = %318
%321 = icmp ult i64 %200, 4
br i1 %321, label %410, label %322
322: ; preds = %320
%323 = getelementptr double, double* %319, i64 %200
%324 = getelementptr double, double* %199, i64 %200
%325 = icmp ult double* %319, %324
%326 = icmp ult double* %199, %323
%327 = and i1 %325, %326
br i1 %327, label %410, label %328
328: ; preds = %322
%329 = and i64 %200, -4
%330 = getelementptr double, double* %319, i64 %329
%331 = getelementptr double, double* %199, i64 %329
%332 = and i64 %200, 3
%333 = add i64 %329, -4
%334 = lshr exact i64 %333, 2
%335 = add nuw nsw i64 %334, 1
%336 = and i64 %335, 3
%337 = icmp ult i64 %333, 12
br i1 %337, label %389, label %338
338: ; preds = %328
%339 = and i64 %335, 9223372036854775804
br label %340
340: ; preds = %340, %338
%341 = phi i64 [ 0, %338 ], [ %386, %340 ]
%342 = phi i64 [ 0, %338 ], [ %387, %340 ]
%343 = getelementptr double, double* %319, i64 %341
%344 = getelementptr double, double* %199, i64 %341
%345 = bitcast double* %344 to <2 x double>*
%346 = load <2 x double>, <2 x double>* %345
%347 = getelementptr double, double* %344, i64 2
%348 = bitcast double* %347 to <2 x double>*
%349 = load <2 x double>, <2 x double>* %348
%350 = bitcast double* %343 to <2 x double>*
store <2 x double> %346, <2 x double>* %350
%351 = getelementptr double, double* %343, i64 2
%352 = bitcast double* %351 to <2 x double>*
store <2 x double> %349, <2 x double>* %352
%353 = or i64 %341, 4
%354 = getelementptr double, double* %319, i64 %353
%355 = getelementptr double, double* %199, i64 %353
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = getelementptr double, double* %355, i64 2
%359 = bitcast double* %358 to <2 x double>*
%360 = load <2 x double>, <2 x double>* %359
%361 = bitcast double* %354 to <2 x double>*
store <2 x double> %357, <2 x double>* %361
%362 = getelementptr double, double* %354, i64 2
%363 = bitcast double* %362 to <2 x double>*
store <2 x double> %360, <2 x double>* %363
%364 = or i64 %341, 8
%365 = getelementptr double, double* %319, i64 %364
%366 = getelementptr double, double* %199, i64 %364
%367 = bitcast double* %366 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = getelementptr double, double* %366, i64 2
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = bitcast double* %365 to <2 x double>*
store <2 x double> %368, <2 x double>* %372
%373 = getelementptr double, double* %365, i64 2
%374 = bitcast double* %373 to <2 x double>*
store <2 x double> %371, <2 x double>* %374
%375 = or i64 %341, 12
%376 = getelementptr double, double* %319, i64 %375
%377 = getelementptr double, double* %199, i64 %375
%378 = bitcast double* %377 to <2 x double>*
%379 = load <2 x double>, <2 x double>* %378
%380 = getelementptr double, double* %377, i64 2
%381 = bitcast double* %380 to <2 x double>*
%382 = load <2 x double>, <2 x double>* %381
%383 = bitcast double* %376 to <2 x double>*
store <2 x double> %379, <2 x double>* %383
%384 = getelementptr double, double* %376, i64 2
%385 = bitcast double* %384 to <2 x double>*
store <2 x double> %382, <2 x double>* %385
%386 = add nuw i64 %341, 16
%387 = add nuw i64 %342, 4
%388 = icmp eq i64 %387, %339
br i1 %388, label %389, label %340
389: ; preds = %340, %328
%390 = phi i64 [ 0, %328 ], [ %386, %340 ]
%391 = icmp eq i64 %336, 0
br i1 %391, label %408, label %392
392: ; preds = %389, %392
%393 = phi i64 [ %405, %392 ], [ %390, %389 ]
%394 = phi i64 [ %406, %392 ], [ 0, %389 ]
%395 = getelementptr double, double* %319, i64 %393
%396 = getelementptr double, double* %199, i64 %393
%397 = bitcast double* %396 to <2 x double>*
%398 = load <2 x double>, <2 x double>* %397
%399 = getelementptr double, double* %396, i64 2
%400 = bitcast double* %399 to <2 x double>*
%401 = load <2 x double>, <2 x double>* %400
%402 = bitcast double* %395 to <2 x double>*
store <2 x double> %398, <2 x double>* %402
%403 = getelementptr double, double* %395, i64 2
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> %401, <2 x double>* %404
%405 = add nuw i64 %393, 4
%406 = add i64 %394, 1
%407 = icmp eq i64 %406, %336
br i1 %407, label %408, label %392
408: ; preds = %392, %389
%409 = icmp eq i64 %200, %329
br i1 %409, label %493, label %410
410: ; preds = %322, %320, %408
%411 = phi double* [ %319, %322 ], [ %319, %320 ], [ %330, %408 ]
%412 = phi double* [ %199, %322 ], [ %199, %320 ], [ %331, %408 ]
%413 = phi i64 [ %200, %322 ], [ %200, %320 ], [ %332, %408 ]
%414 = add i64 %413, -1
%415 = and i64 %413, 7
%416 = icmp eq i64 %415, 0
br i1 %416, label %428, label %417
417: ; preds = %410, %417
%418 = phi double* [ %424, %417 ], [ %411, %410 ]
%419 = phi double* [ %422, %417 ], [ %412, %410 ]
%420 = phi i64 [ %425, %417 ], [ %413, %410 ]
%421 = phi i64 [ %426, %417 ], [ 0, %410 ]
%422 = getelementptr inbounds double, double* %419, i64 1
%423 = load double, double* %419
%424 = getelementptr inbounds double, double* %418, i64 1
store double %423, double* %418
%425 = add i64 %420, -1
%426 = add i64 %421, 1
%427 = icmp eq i64 %426, %415
br i1 %427, label %428, label %417
428: ; preds = %417, %410
%429 = phi double* [ %411, %410 ], [ %424, %417 ]
%430 = phi double* [ %412, %410 ], [ %422, %417 ]
%431 = phi i64 [ %413, %410 ], [ %425, %417 ]
%432 = icmp ult i64 %414, 7
br i1 %432, label %493, label %463
433: ; preds = %312, %433
%434 = phi double* [ %460, %433 ], [ %314, %312 ]
%435 = phi double* [ %458, %433 ], [ %315, %312 ]
%436 = phi i64 [ %461, %433 ], [ %316, %312 ]
%437 = getelementptr inbounds double, double* %435, i64 1
%438 = load double, double* %435
%439 = getelementptr inbounds double, double* %434, i64 1
store double %438, double* %434
%440 = getelementptr inbounds double, double* %435, i64 2
%441 = load double, double* %437
%442 = getelementptr inbounds double, double* %434, i64 2
store double %441, double* %439
%443 = getelementptr inbounds double, double* %435, i64 3
%444 = load double, double* %440
%445 = getelementptr inbounds double, double* %434, i64 3
store double %444, double* %442
%446 = getelementptr inbounds double, double* %435, i64 4
%447 = load double, double* %443
%448 = getelementptr inbounds double, double* %434, i64 4
store double %447, double* %445
%449 = getelementptr inbounds double, double* %435, i64 5
%450 = load double, double* %446
%451 = getelementptr inbounds double, double* %434, i64 5
store double %450, double* %448
%452 = getelementptr inbounds double, double* %435, i64 6
%453 = load double, double* %449
%454 = getelementptr inbounds double, double* %434, i64 6
store double %453, double* %451
%455 = getelementptr inbounds double, double* %435, i64 7
%456 = load double, double* %452
%457 = getelementptr inbounds double, double* %434, i64 7
store double %456, double* %454
%458 = getelementptr inbounds double, double* %435, i64 8
%459 = load double, double* %455
%460 = getelementptr inbounds double, double* %434, i64 8
store double %459, double* %457
%461 = add i64 %436, -8
%462 = icmp eq i64 %461, 0
br i1 %462, label %318, label %433
463: ; preds = %428, %463
%464 = phi double* [ %490, %463 ], [ %429, %428 ]
%465 = phi double* [ %488, %463 ], [ %430, %428 ]
%466 = phi i64 [ %491, %463 ], [ %431, %428 ]
%467 = getelementptr inbounds double, double* %465, i64 1
%468 = load double, double* %465
%469 = getelementptr inbounds double, double* %464, i64 1
store double %468, double* %464
%470 = getelementptr inbounds double, double* %465, i64 2
%471 = load double, double* %467
%472 = getelementptr inbounds double, double* %464, i64 2
store double %471, double* %469
%473 = getelementptr inbounds double, double* %465, i64 3
%474 = load double, double* %470
%475 = getelementptr inbounds double, double* %464, i64 3
store double %474, double* %472
%476 = getelementptr inbounds double, double* %465, i64 4
%477 = load double, double* %473
%478 = getelementptr inbounds double, double* %464, i64 4
store double %477, double* %475
%479 = getelementptr inbounds double, double* %465, i64 5
%480 = load double, double* %476
%481 = getelementptr inbounds double, double* %464, i64 5
store double %480, double* %478
%482 = getelementptr inbounds double, double* %465, i64 6
%483 = load double, double* %479
%484 = getelementptr inbounds double, double* %464, i64 6
store double %483, double* %481
%485 = getelementptr inbounds double, double* %465, i64 7
%486 = load double, double* %482
%487 = getelementptr inbounds double, double* %464, i64 7
store double %486, double* %484
%488 = getelementptr inbounds double, double* %465, i64 8
%489 = load double, double* %485
%490 = getelementptr inbounds double, double* %464, i64 8
store double %489, double* %487
%491 = add i64 %466, -8
%492 = icmp eq i64 %491, 0
br i1 %492, label %493, label %463
493: ; preds = %428, %463, %408, %318
%494 = sub i64 %31, %200
%495 = sub i64 %30, %200
%496 = icmp ugt i64 %494, %15
br i1 %496, label %28, label %985
497: ; preds = %24, %981
%498 = phi double* [ %667, %981 ], [ %18, %24 ]
%499 = phi i64 [ %982, %981 ], [ %16, %24 ]
%500 = phi i64 [ %983, %981 ], [ %15, %24 ]
%501 = sub i64 %17, %499
%502 = icmp ugt i64 %501, 1024
br i1 %502, label %503, label %513
503: ; preds = %497
%504 = shl i64 %501, 3
%505 = tail call i64 @malloc(i64 %504)
%506 = inttoptr i64 %505 to double*
%507 = icmp eq i64 %505, 0
%508 = select i1 %507, i64 1024, i64 %501
%509 = select i1 %507, double* %18, double* %506
%510 = getelementptr double, double* %0, i64 %499
%511 = getelementptr inbounds double, double* %510, i64 %508
%512 = getelementptr inbounds double, double* %509, i64 %508
br label %516
513: ; preds = %497
%514 = getelementptr inbounds double, double* %498, i64 %501
%515 = icmp eq i64 %501, 0
br i1 %515, label %663, label %516
516: ; preds = %503, %513
%517 = phi double* [ %512, %503 ], [ %514, %513 ]
%518 = phi double* [ %511, %503 ], [ %25, %513 ]
%519 = phi double* [ %509, %503 ], [ %498, %513 ]
%520 = phi i64 [ %508, %503 ], [ %501, %513 ]
%521 = icmp ult i64 %520, 4
br i1 %521, label %609, label %522
522: ; preds = %516
%523 = sub i64 0, %520
%524 = getelementptr double, double* %517, i64 %523
%525 = getelementptr double, double* %518, i64 %523
%526 = icmp ult double* %524, %518
%527 = icmp ult double* %525, %517
%528 = and i1 %526, %527
br i1 %528, label %609, label %529
529: ; preds = %522
%530 = and i64 %520, -4
%531 = sub i64 0, %530
%532 = getelementptr double, double* %517, i64 %531
%533 = sub i64 0, %530
%534 = getelementptr double, double* %518, i64 %533
%535 = and i64 %520, 3
%536 = add i64 %530, -4
%537 = lshr exact i64 %536, 2
%538 = add nuw nsw i64 %537, 1
%539 = and i64 %538, 1
%540 = icmp eq i64 %536, 0
br i1 %540, label %585, label %541
541: ; preds = %529
%542 = and i64 %538, 9223372036854775806
%543 = getelementptr double, double* %517, i64 -1
%544 = getelementptr double, double* %518, i64 -1
%545 = getelementptr double, double* %517, i64 -1
%546 = getelementptr double, double* %518, i64 -1
br label %547
547: ; preds = %547, %541
%548 = phi i64 [ 0, %541 ], [ %582, %547 ]
%549 = phi i64 [ 0, %541 ], [ %583, %547 ]
%550 = sub i64 0, %548
%551 = sub i64 0, %548
%552 = getelementptr inbounds double, double* %544, i64 %551
%553 = getelementptr inbounds double, double* %552, i64 -1
%554 = bitcast double* %553 to <2 x double>*
%555 = load <2 x double>, <2 x double>* %554
%556 = getelementptr inbounds double, double* %552, i64 -2
%557 = getelementptr inbounds double, double* %556, i64 -1
%558 = bitcast double* %557 to <2 x double>*
%559 = load <2 x double>, <2 x double>* %558
%560 = getelementptr inbounds double, double* %543, i64 %550
%561 = getelementptr inbounds double, double* %560, i64 -1
%562 = bitcast double* %561 to <2 x double>*
store <2 x double> %555, <2 x double>* %562
%563 = getelementptr inbounds double, double* %560, i64 -2
%564 = getelementptr inbounds double, double* %563, i64 -1
%565 = bitcast double* %564 to <2 x double>*
store <2 x double> %559, <2 x double>* %565
%566 = sub nuw nsw i64 -4, %548
%567 = sub nuw nsw i64 -4, %548
%568 = getelementptr inbounds double, double* %546, i64 %567
%569 = getelementptr inbounds double, double* %568, i64 -1
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = getelementptr inbounds double, double* %568, i64 -2
%573 = getelementptr inbounds double, double* %572, i64 -1
%574 = bitcast double* %573 to <2 x double>*
%575 = load <2 x double>, <2 x double>* %574
%576 = getelementptr inbounds double, double* %545, i64 %566
%577 = getelementptr inbounds double, double* %576, i64 -1
%578 = bitcast double* %577 to <2 x double>*
store <2 x double> %571, <2 x double>* %578
%579 = getelementptr inbounds double, double* %576, i64 -2
%580 = getelementptr inbounds double, double* %579, i64 -1
%581 = bitcast double* %580 to <2 x double>*
store <2 x double> %575, <2 x double>* %581
%582 = add nuw i64 %548, 8
%583 = add i64 %549, 2
%584 = icmp eq i64 %583, %542
br i1 %584, label %585, label %547
585: ; preds = %547, %529
%586 = phi i64 [ 0, %529 ], [ %582, %547 ]
%587 = icmp eq i64 %539, 0
br i1 %587, label %607, label %588
588: ; preds = %585
%589 = sub i64 0, %586
%590 = getelementptr double, double* %517, i64 -1
%591 = sub i64 0, %586
%592 = getelementptr double, double* %518, i64 -1
%593 = getelementptr inbounds double, double* %592, i64 %591
%594 = getelementptr inbounds double, double* %593, i64 -1
%595 = bitcast double* %594 to <2 x double>*
%596 = load <2 x double>, <2 x double>* %595
%597 = getelementptr inbounds double, double* %593, i64 -2
%598 = getelementptr inbounds double, double* %597, i64 -1
%599 = bitcast double* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599
%601 = getelementptr inbounds double, double* %590, i64 %589
%602 = getelementptr inbounds double, double* %601, i64 -1
%603 = bitcast double* %602 to <2 x double>*
store <2 x double> %596, <2 x double>* %603
%604 = getelementptr inbounds double, double* %601, i64 -2
%605 = getelementptr inbounds double, double* %604, i64 -1
%606 = bitcast double* %605 to <2 x double>*
store <2 x double> %600, <2 x double>* %606
br label %607
607: ; preds = %585, %588
%608 = icmp eq i64 %520, %530
br i1 %608, label %663, label %609
609: ; preds = %522, %516, %607
%610 = phi double* [ %517, %522 ], [ %517, %516 ], [ %532, %607 ]
%611 = phi double* [ %518, %522 ], [ %518, %516 ], [ %534, %607 ]
%612 = phi i64 [ %520, %522 ], [ %520, %516 ], [ %535, %607 ]
%613 = add i64 %612, -1
%614 = and i64 %612, 7
%615 = icmp eq i64 %614, 0
br i1 %615, label %627, label %616
616: ; preds = %609, %616
%617 = phi double* [ %623, %616 ], [ %610, %609 ]
%618 = phi double* [ %621, %616 ], [ %611, %609 ]
%619 = phi i64 [ %624, %616 ], [ %612, %609 ]
%620 = phi i64 [ %625, %616 ], [ 0, %609 ]
%621 = getelementptr inbounds double, double* %618, i64 -1
%622 = load double, double* %621
%623 = getelementptr inbounds double, double* %617, i64 -1
store double %622, double* %623
%624 = add i64 %619, -1
%625 = add i64 %620, 1
%626 = icmp eq i64 %625, %614
br i1 %626, label %627, label %616
627: ; preds = %616, %609
%628 = phi double* [ undef, %609 ], [ %621, %616 ]
%629 = phi double* [ %610, %609 ], [ %623, %616 ]
%630 = phi double* [ %611, %609 ], [ %621, %616 ]
%631 = phi i64 [ %612, %609 ], [ %624, %616 ]
%632 = icmp ult i64 %613, 7
br i1 %632, label %663, label %633
633: ; preds = %627, %633
%634 = phi double* [ %660, %633 ], [ %629, %627 ]
%635 = phi double* [ %658, %633 ], [ %630, %627 ]
%636 = phi i64 [ %661, %633 ], [ %631, %627 ]
%637 = getelementptr inbounds double, double* %635, i64 -1
%638 = load double, double* %637
%639 = getelementptr inbounds double, double* %634, i64 -1
store double %638, double* %639
%640 = getelementptr inbounds double, double* %635, i64 -2
%641 = load double, double* %640
%642 = getelementptr inbounds double, double* %634, i64 -2
store double %641, double* %642
%643 = getelementptr inbounds double, double* %635, i64 -3
%644 = load double, double* %643
%645 = getelementptr inbounds double, double* %634, i64 -3
store double %644, double* %645
%646 = getelementptr inbounds double, double* %635, i64 -4
%647 = load double, double* %646
%648 = getelementptr inbounds double, double* %634, i64 -4
store double %647, double* %648
%649 = getelementptr inbounds double, double* %635, i64 -5
%650 = load double, double* %649
%651 = getelementptr inbounds double, double* %634, i64 -5
store double %650, double* %651
%652 = getelementptr inbounds double, double* %635, i64 -6
%653 = load double, double* %652
%654 = getelementptr inbounds double, double* %634, i64 -6
store double %653, double* %654
%655 = getelementptr inbounds double, double* %635, i64 -7
%656 = load double, double* %655
%657 = getelementptr inbounds double, double* %634, i64 -7
store double %656, double* %657
%658 = getelementptr inbounds double, double* %635, i64 -8
%659 = load double, double* %658
%660 = getelementptr inbounds double, double* %634, i64 -8
store double %659, double* %660
%661 = add i64 %636, -8
%662 = icmp eq i64 %661, 0
br i1 %662, label %663, label %633
663: ; preds = %627, %633, %607, %513
%664 = phi i1 [ true, %513 ], [ false, %607 ], [ false, %633 ], [ false, %627 ]
%665 = phi double* [ %514, %513 ], [ %517, %607 ], [ %517, %633 ], [ %517, %627 ]
%666 = phi double* [ %25, %513 ], [ %518, %607 ], [ %518, %633 ], [ %518, %627 ]
%667 = phi double* [ %498, %513 ], [ %519, %607 ], [ %519, %633 ], [ %519, %627 ]
%668 = phi i64 [ 0, %513 ], [ %520, %607 ], [ %520, %633 ], [ %520, %627 ]
%669 = phi double* [ %25, %513 ], [ %534, %607 ], [ %628, %627 ], [ %658, %633 ]
%670 = sub i64 %499, %500
%671 = icmp eq i64 %670, 0
br i1 %671, label %807, label %672
672: ; preds = %663
%673 = icmp ult i64 %670, 4
br i1 %673, label %783, label %674
674: ; preds = %672
%675 = xor i64 %500, -1
%676 = add i64 %499, %675
%677 = getelementptr double, double* %666, i64 -1
%678 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %676, i64 8)
%679 = extractvalue { i64, i1 } %678, 0
%680 = extractvalue { i64, i1 } %678, 1
%681 = bitcast double* %677 to i8*
%682 = sub i64 0, %679
%683 = getelementptr i8, i8* %681, i64 %682
%684 = icmp ugt i8* %683, %681
%685 = or i1 %684, %680
%686 = getelementptr double, double* %669, i64 -1
%687 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %676, i64 8)
%688 = extractvalue { i64, i1 } %687, 0
%689 = extractvalue { i64, i1 } %687, 1
%690 = bitcast double* %686 to i8*
%691 = sub i64 0, %688
%692 = getelementptr i8, i8* %690, i64 %691
%693 = icmp ugt i8* %692, %690
%694 = or i1 %693, %689
%695 = or i1 %685, %694
br i1 %695, label %783, label %696
696: ; preds = %674
%697 = sub i64 %500, %499
%698 = getelementptr double, double* %666, i64 %697
%699 = getelementptr double, double* %669, i64 %697
%700 = icmp ult double* %698, %669
%701 = icmp ult double* %699, %666
%702 = and i1 %700, %701
br i1 %702, label %783, label %703
703: ; preds = %696
%704 = and i64 %670, -4
%705 = sub i64 0, %704
%706 = getelementptr double, double* %666, i64 %705
%707 = sub i64 0, %704
%708 = getelementptr double, double* %669, i64 %707
%709 = and i64 %670, 3
%710 = add i64 %704, -4
%711 = lshr exact i64 %710, 2
%712 = add nuw nsw i64 %711, 1
%713 = and i64 %712, 1
%714 = icmp eq i64 %710, 0
br i1 %714, label %759, label %715
715: ; preds = %703
%716 = and i64 %712, 9223372036854775806
%717 = getelementptr double, double* %666, i64 -1
%718 = getelementptr double, double* %669, i64 -1
%719 = getelementptr double, double* %666, i64 -1
%720 = getelementptr double, double* %669, i64 -1
br label %721
721: ; preds = %721, %715
%722 = phi i64 [ 0, %715 ], [ %756, %721 ]
%723 = phi i64 [ 0, %715 ], [ %757, %721 ]
%724 = sub i64 0, %722
%725 = sub i64 0, %722
%726 = getelementptr inbounds double, double* %718, i64 %725
%727 = getelementptr inbounds double, double* %726, i64 -1
%728 = bitcast double* %727 to <2 x double>*
%729 = load <2 x double>, <2 x double>* %728
%730 = getelementptr inbounds double, double* %726, i64 -2
%731 = getelementptr inbounds double, double* %730, i64 -1
%732 = bitcast double* %731 to <2 x double>*
%733 = load <2 x double>, <2 x double>* %732
%734 = getelementptr inbounds double, double* %717, i64 %724
%735 = getelementptr inbounds double, double* %734, i64 -1
%736 = bitcast double* %735 to <2 x double>*
store <2 x double> %729, <2 x double>* %736
%737 = getelementptr inbounds double, double* %734, i64 -2
%738 = getelementptr inbounds double, double* %737, i64 -1
%739 = bitcast double* %738 to <2 x double>*
store <2 x double> %733, <2 x double>* %739
%740 = sub nuw nsw i64 -4, %722
%741 = sub nuw nsw i64 -4, %722
%742 = getelementptr inbounds double, double* %720, i64 %741
%743 = getelementptr inbounds double, double* %742, i64 -1
%744 = bitcast double* %743 to <2 x double>*
%745 = load <2 x double>, <2 x double>* %744
%746 = getelementptr inbounds double, double* %742, i64 -2
%747 = getelementptr inbounds double, double* %746, i64 -1
%748 = bitcast double* %747 to <2 x double>*
%749 = load <2 x double>, <2 x double>* %748
%750 = getelementptr inbounds double, double* %719, i64 %740
%751 = getelementptr inbounds double, double* %750, i64 -1
%752 = bitcast double* %751 to <2 x double>*
store <2 x double> %745, <2 x double>* %752
%753 = getelementptr inbounds double, double* %750, i64 -2
%754 = getelementptr inbounds double, double* %753, i64 -1
%755 = bitcast double* %754 to <2 x double>*
store <2 x double> %749, <2 x double>* %755
%756 = add nuw i64 %722, 8
%757 = add i64 %723, 2
%758 = icmp eq i64 %757, %716
br i1 %758, label %759, label %721
759: ; preds = %721, %703
%760 = phi i64 [ 0, %703 ], [ %756, %721 ]
%761 = icmp eq i64 %713, 0
br i1 %761, label %781, label %762
762: ; preds = %759
%763 = sub i64 0, %760
%764 = getelementptr double, double* %666, i64 -1
%765 = sub i64 0, %760
%766 = getelementptr double, double* %669, i64 -1
%767 = getelementptr inbounds double, double* %766, i64 %765
%768 = getelementptr inbounds double, double* %767, i64 -1
%769 = bitcast double* %768 to <2 x double>*
%770 = load <2 x double>, <2 x double>* %769
%771 = getelementptr inbounds double, double* %767, i64 -2
%772 = getelementptr inbounds double, double* %771, i64 -1
%773 = bitcast double* %772 to <2 x double>*
%774 = load <2 x double>, <2 x double>* %773
%775 = getelementptr inbounds double, double* %764, i64 %763
%776 = getelementptr inbounds double, double* %775, i64 -1
%777 = bitcast double* %776 to <2 x double>*
store <2 x double> %770, <2 x double>* %777
%778 = getelementptr inbounds double, double* %775, i64 -2
%779 = getelementptr inbounds double, double* %778, i64 -1
%780 = bitcast double* %779 to <2 x double>*
store <2 x double> %774, <2 x double>* %780
br label %781
781: ; preds = %759, %762
%782 = icmp eq i64 %670, %704
br i1 %782, label %807, label %783
783: ; preds = %696, %674, %672, %781
%784 = phi double* [ %666, %696 ], [ %666, %674 ], [ %666, %672 ], [ %706, %781 ]
%785 = phi double* [ %669, %696 ], [ %669, %674 ], [ %669, %672 ], [ %708, %781 ]
%786 = phi i64 [ %670, %696 ], [ %670, %674 ], [ %670, %672 ], [ %709, %781 ]
%787 = add i64 %786, -1
%788 = and i64 %786, 7
%789 = icmp eq i64 %788, 0
br i1 %789, label %801, label %790
790: ; preds = %783, %790
%791 = phi double* [ %797, %790 ], [ %784, %783 ]
%792 = phi double* [ %795, %790 ], [ %785, %783 ]
%793 = phi i64 [ %798, %790 ], [ %786, %783 ]
%794 = phi i64 [ %799, %790 ], [ 0, %783 ]
%795 = getelementptr inbounds double, double* %792, i64 -1
%796 = load double, double* %795
%797 = getelementptr inbounds double, double* %791, i64 -1
store double %796, double* %797
%798 = add i64 %793, -1
%799 = add i64 %794, 1
%800 = icmp eq i64 %799, %788
br i1 %800, label %801, label %790
801: ; preds = %790, %783
%802 = phi double* [ undef, %783 ], [ %797, %790 ]
%803 = phi double* [ %784, %783 ], [ %797, %790 ]
%804 = phi double* [ %785, %783 ], [ %795, %790 ]
%805 = phi i64 [ %786, %783 ], [ %798, %790 ]
%806 = icmp ult i64 %787, 7
br i1 %806, label %807, label %921
807: ; preds = %801, %921, %781, %663
%808 = phi double* [ %666, %663 ], [ %706, %781 ], [ %802, %801 ], [ %948, %921 ]
br i1 %664, label %981, label %809
809: ; preds = %807
%810 = icmp ult i64 %668, 4
br i1 %810, label %898, label %811
811: ; preds = %809
%812 = sub i64 0, %668
%813 = getelementptr double, double* %808, i64 %812
%814 = getelementptr double, double* %665, i64 %812
%815 = icmp ult double* %813, %665
%816 = icmp ult double* %814, %808
%817 = and i1 %815, %816
br i1 %817, label %898, label %818
818: ; preds = %811
%819 = and i64 %668, -4
%820 = sub i64 0, %819
%821 = getelementptr double, double* %808, i64 %820
%822 = sub i64 0, %819
%823 = getelementptr double, double* %665, i64 %822
%824 = and i64 %668, 3
%825 = add i64 %819, -4
%826 = lshr exact i64 %825, 2
%827 = add nuw nsw i64 %826, 1
%828 = and i64 %827, 1
%829 = icmp eq i64 %825, 0
br i1 %829, label %874, label %830
830: ; preds = %818
%831 = and i64 %827, 9223372036854775806
%832 = getelementptr double, double* %808, i64 -1
%833 = getelementptr double, double* %665, i64 -1
%834 = getelementptr double, double* %808, i64 -1
%835 = getelementptr double, double* %665, i64 -1
br label %836
836: ; preds = %836, %830
%837 = phi i64 [ 0, %830 ], [ %871, %836 ]
%838 = phi i64 [ 0, %830 ], [ %872, %836 ]
%839 = sub i64 0, %837
%840 = sub i64 0, %837
%841 = getelementptr inbounds double, double* %833, i64 %840
%842 = getelementptr inbounds double, double* %841, i64 -1
%843 = bitcast double* %842 to <2 x double>*
%844 = load <2 x double>, <2 x double>* %843
%845 = getelementptr inbounds double, double* %841, i64 -2
%846 = getelementptr inbounds double, double* %845, i64 -1
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = getelementptr inbounds double, double* %832, i64 %839
%850 = getelementptr inbounds double, double* %849, i64 -1
%851 = bitcast double* %850 to <2 x double>*
store <2 x double> %844, <2 x double>* %851
%852 = getelementptr inbounds double, double* %849, i64 -2
%853 = getelementptr inbounds double, double* %852, i64 -1
%854 = bitcast double* %853 to <2 x double>*
store <2 x double> %848, <2 x double>* %854
%855 = sub nuw nsw i64 -4, %837
%856 = sub nuw nsw i64 -4, %837
%857 = getelementptr inbounds double, double* %835, i64 %856
%858 = getelementptr inbounds double, double* %857, i64 -1
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = getelementptr inbounds double, double* %857, i64 -2
%862 = getelementptr inbounds double, double* %861, i64 -1
%863 = bitcast double* %862 to <2 x double>*
%864 = load <2 x double>, <2 x double>* %863
%865 = getelementptr inbounds double, double* %834, i64 %855
%866 = getelementptr inbounds double, double* %865, i64 -1
%867 = bitcast double* %866 to <2 x double>*
store <2 x double> %860, <2 x double>* %867
%868 = getelementptr inbounds double, double* %865, i64 -2
%869 = getelementptr inbounds double, double* %868, i64 -1
%870 = bitcast double* %869 to <2 x double>*
store <2 x double> %864, <2 x double>* %870
%871 = add nuw i64 %837, 8
%872 = add i64 %838, 2
%873 = icmp eq i64 %872, %831
br i1 %873, label %874, label %836
874: ; preds = %836, %818
%875 = phi i64 [ 0, %818 ], [ %871, %836 ]
%876 = icmp eq i64 %828, 0
br i1 %876, label %896, label %877
877: ; preds = %874
%878 = sub i64 0, %875
%879 = getelementptr double, double* %808, i64 -1
%880 = sub i64 0, %875
%881 = getelementptr double, double* %665, i64 -1
%882 = getelementptr inbounds double, double* %881, i64 %880
%883 = getelementptr inbounds double, double* %882, i64 -1
%884 = bitcast double* %883 to <2 x double>*
%885 = load <2 x double>, <2 x double>* %884
%886 = getelementptr inbounds double, double* %882, i64 -2
%887 = getelementptr inbounds double, double* %886, i64 -1
%888 = bitcast double* %887 to <2 x double>*
%889 = load <2 x double>, <2 x double>* %888
%890 = getelementptr inbounds double, double* %879, i64 %878
%891 = getelementptr inbounds double, double* %890, i64 -1
%892 = bitcast double* %891 to <2 x double>*
store <2 x double> %885, <2 x double>* %892
%893 = getelementptr inbounds double, double* %890, i64 -2
%894 = getelementptr inbounds double, double* %893, i64 -1
%895 = bitcast double* %894 to <2 x double>*
store <2 x double> %889, <2 x double>* %895
br label %896
896: ; preds = %874, %877
%897 = icmp eq i64 %668, %819
br i1 %897, label %981, label %898
898: ; preds = %811, %809, %896
%899 = phi double* [ %808, %811 ], [ %808, %809 ], [ %821, %896 ]
%900 = phi double* [ %665, %811 ], [ %665, %809 ], [ %823, %896 ]
%901 = phi i64 [ %668, %811 ], [ %668, %809 ], [ %824, %896 ]
%902 = add i64 %901, -1
%903 = and i64 %901, 7
%904 = icmp eq i64 %903, 0
br i1 %904, label %916, label %905
905: ; preds = %898, %905
%906 = phi double* [ %912, %905 ], [ %899, %898 ]
%907 = phi double* [ %910, %905 ], [ %900, %898 ]
%908 = phi i64 [ %913, %905 ], [ %901, %898 ]
%909 = phi i64 [ %914, %905 ], [ 0, %898 ]
%910 = getelementptr inbounds double, double* %907, i64 -1
%911 = load double, double* %910
%912 = getelementptr inbounds double, double* %906, i64 -1
store double %911, double* %912
%913 = add i64 %908, -1
%914 = add i64 %909, 1
%915 = icmp eq i64 %914, %903
br i1 %915, label %916, label %905
916: ; preds = %905, %898
%917 = phi double* [ %899, %898 ], [ %912, %905 ]
%918 = phi double* [ %900, %898 ], [ %910, %905 ]
%919 = phi i64 [ %901, %898 ], [ %913, %905 ]
%920 = icmp ult i64 %902, 7
br i1 %920, label %981, label %951
921: ; preds = %801, %921
%922 = phi double* [ %948, %921 ], [ %803, %801 ]
%923 = phi double* [ %946, %921 ], [ %804, %801 ]
%924 = phi i64 [ %949, %921 ], [ %805, %801 ]
%925 = getelementptr inbounds double, double* %923, i64 -1
%926 = load double, double* %925
%927 = getelementptr inbounds double, double* %922, i64 -1
store double %926, double* %927
%928 = getelementptr inbounds double, double* %923, i64 -2
%929 = load double, double* %928
%930 = getelementptr inbounds double, double* %922, i64 -2
store double %929, double* %930
%931 = getelementptr inbounds double, double* %923, i64 -3
%932 = load double, double* %931
%933 = getelementptr inbounds double, double* %922, i64 -3
store double %932, double* %933
%934 = getelementptr inbounds double, double* %923, i64 -4
%935 = load double, double* %934
%936 = getelementptr inbounds double, double* %922, i64 -4
store double %935, double* %936
%937 = getelementptr inbounds double, double* %923, i64 -5
%938 = load double, double* %937
%939 = getelementptr inbounds double, double* %922, i64 -5
store double %938, double* %939
%940 = getelementptr inbounds double, double* %923, i64 -6
%941 = load double, double* %940
%942 = getelementptr inbounds double, double* %922, i64 -6
store double %941, double* %942
%943 = getelementptr inbounds double, double* %923, i64 -7
%944 = load double, double* %943
%945 = getelementptr inbounds double, double* %922, i64 -7
store double %944, double* %945
%946 = getelementptr inbounds double, double* %923, i64 -8
%947 = load double, double* %946
%948 = getelementptr inbounds double, double* %922, i64 -8
store double %947, double* %948
%949 = add i64 %924, -8
%950 = icmp eq i64 %949, 0
br i1 %950, label %807, label %921
951: ; preds = %916, %951
%952 = phi double* [ %978, %951 ], [ %917, %916 ]
%953 = phi double* [ %976, %951 ], [ %918, %916 ]
%954 = phi i64 [ %979, %951 ], [ %919, %916 ]
%955 = getelementptr inbounds double, double* %953, i64 -1
%956 = load double, double* %955
%957 = getelementptr inbounds double, double* %952, i64 -1
store double %956, double* %957
%958 = getelementptr inbounds double, double* %953, i64 -2
%959 = load double, double* %958
%960 = getelementptr inbounds double, double* %952, i64 -2
store double %959, double* %960
%961 = getelementptr inbounds double, double* %953, i64 -3
%962 = load double, double* %961
%963 = getelementptr inbounds double, double* %952, i64 -3
store double %962, double* %963
%964 = getelementptr inbounds double, double* %953, i64 -4
%965 = load double, double* %964
%966 = getelementptr inbounds double, double* %952, i64 -4
store double %965, double* %966
%967 = getelementptr inbounds double, double* %953, i64 -5
%968 = load double, double* %967
%969 = getelementptr inbounds double, double* %952, i64 -5
store double %968, double* %969
%970 = getelementptr inbounds double, double* %953, i64 -6
%971 = load double, double* %970
%972 = getelementptr inbounds double, double* %952, i64 -6
store double %971, double* %972
%973 = getelementptr inbounds double, double* %953, i64 -7
%974 = load double, double* %973
%975 = getelementptr inbounds double, double* %952, i64 -7
store double %974, double* %975
%976 = getelementptr inbounds double, double* %953, i64 -8
%977 = load double, double* %976
%978 = getelementptr inbounds double, double* %952, i64 -8
store double %977, double* %978
%979 = add i64 %954, -8
%980 = icmp eq i64 %979, 0
br i1 %980, label %981, label %951
981: ; preds = %916, %951, %896, %807
%982 = add i64 %668, %499
%983 = add i64 %668, %500
%984 = icmp ugt i64 %17, %982
br i1 %984, label %497, label %985
985: ; preds = %981, %493
%986 = phi double* [ %199, %493 ], [ %667, %981 ]
%987 = icmp eq double* %986, %18
br i1 %987, label %990, label %988
988: ; preds = %985
%989 = call i32 @free(double* %986)
br label %990
990: ; preds = %22, %26, %985, %988, %4
ret void
}