#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*/ memcpy(double *, double *, int);
void getPLU(double *A, int M, int N, int *ipiv, double *P, double *L,
            double *U) {
  int i, j, k;
  if (P) {
    for (i = 0; i < M * M; ++i) {
      P[i] = 0.0;
    }
    for (j = 0; j < M; ++j) {
      P[ipiv[j] * M + j] = 1.0;
    }
  }
  if (M == N) {
    if (L) {
      for (i = 0; i < M; ++i) {
        for (j = 0; j < i; ++j) {
          L[i * M + j] = A[i * M + j];
        }
        L[i * M + i] = 1.0;
        for (j = i + 1; j < M; ++j) {
          L[i * M + j] = 0.0;
        }
      }
    }
    if (U) {
      for (i = 0; i < M; ++i) {
        for (j = 0; j < i; ++j) {
          U[i * M + j] = 0.0;
        }
        for (j = i; j < M; ++j) {
          U[i * M + j] = A[i * M + j];
        }
      }
    }
  } else if (M > N) {
    if (L) {
      for (i = 0; i < N; ++i) {
        for (j = 0; j < i; ++j) {
          L[i * N + j] = A[i * N + j];
        }
        L[i * N + i] = 1.0;
        for (j = i + 1; j < N; ++j) {
          L[i * N + j] = 0.0;
        }
      }
      memcpy(L + N * N, A + N * N, sizeof(double) * (M - N) * N);
    }
    if (U) {
      for (i = 0; i < N; ++i) {
        for (j = 0; j < i; ++j) {
          U[i * N + j] = 0.0;
        }
        for (j = i; j < N; ++j) {
          U[i * N + j] = A[i * N + j];
        }
      }
    }
  } else if (M < N) {
    if (L) {
      for (i = 0; i < M; ++i) {
        for (j = 0; j < i; ++j) {
          L[i * M + j] = A[i * N + j];
        }
        L[i * M + i] = 1.0;
        for (j = i + 1; j < M; ++j) {
          L[i * M + j] = 0.0;
        }
      }
    }
    if (U) {
      for (i = 0; i < M; ++i) {
        for (j = 0; j < i; ++j) {
          U[i * N + j] = 0.0;
        }
        for (j = i; j < N; ++j) {
          U[i * N + j] = A[i * N + j];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<getPLU>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     11c0 <getPLU+0xb0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1174 <getPLU+0x64>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1144 <getPLU+0x34>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bb <getPLU+0xab>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xe58(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    117b <getPLU+0x6b>
jmp    11c0 <getPLU+0xb0>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    136a <getPLU+0x25a>
cmpq   $0x0,-0x28(%rbp)
je     12a9 <getPLU+0x199>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a4 <getPLU+0x194>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1237 <getPLU+0x127>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f1 <getPLU+0xe1>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xdb0(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1291 <getPLU+0x181>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    125e <getPLU+0x14e>
jmp    1296 <getPLU+0x186>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11de <getPLU+0xce>
jmp    12a9 <getPLU+0x199>
cmpq   $0x0,0x10(%rbp)
je     1365 <getPLU+0x255>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1360 <getPLU+0x250>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1301 <getPLU+0x1f1>
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ce <getPLU+0x1be>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    134d <getPLU+0x23d>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1307 <getPLU+0x1f7>
jmp    1352 <getPLU+0x242>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12bb <getPLU+0x1ab>
jmp    1365 <getPLU+0x255>
jmp    1706 <getPLU+0x5f6>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1552 <getPLU+0x442>
cmpq   $0x0,-0x28(%rbp)
je     1491 <getPLU+0x381>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    144e <getPLU+0x33e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13e1 <getPLU+0x2d1>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    139b <getPLU+0x28b>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xc06(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    143b <getPLU+0x32b>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1408 <getPLU+0x2f8>
jmp    1440 <getPLU+0x330>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1388 <getPLU+0x278>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
movslq -0x10(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
cmpq   $0x0,0x10(%rbp)
je     154d <getPLU+0x43d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1548 <getPLU+0x438>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14e9 <getPLU+0x3d9>
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14b6 <getPLU+0x3a6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1535 <getPLU+0x425>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14ef <getPLU+0x3df>
jmp    153a <getPLU+0x42a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14a3 <getPLU+0x393>
jmp    154d <getPLU+0x43d>
jmp    1701 <getPLU+0x5f1>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16fc <getPLU+0x5ec>
cmpq   $0x0,-0x28(%rbp)
je     163b <getPLU+0x52b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1636 <getPLU+0x526>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15c9 <getPLU+0x4b9>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1583 <getPLU+0x473>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xa1e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1623 <getPLU+0x513>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15f0 <getPLU+0x4e0>
jmp    1628 <getPLU+0x518>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1570 <getPLU+0x460>
jmp    163b <getPLU+0x52b>
cmpq   $0x0,0x10(%rbp)
je     16f7 <getPLU+0x5e7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16f2 <getPLU+0x5e2>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1693 <getPLU+0x583>
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1660 <getPLU+0x550>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16df <getPLU+0x5cf>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1699 <getPLU+0x589>
jmp    16e4 <getPLU+0x5d4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164d <getPLU+0x53d>
jmp    16f7 <getPLU+0x5e7>
jmp    16fc <getPLU+0x5ec>
jmp    1701 <getPLU+0x5f1>
jmp    1706 <getPLU+0x5f6>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getPLU>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,0x10(%rsp)
mov    %esi,%ebx
mov    %rdi,(%rsp)
test   %r8,%r8
mov    %r9,0x28(%rsp)
je     11d5 <getPLU+0xb5>
mov    %r8,%rbp
mov    %rcx,%r14
mov    %ebx,%eax
imul   %ebx,%eax
test   %eax,%eax
je     116b <getPLU+0x4b>
mov    %eax,%edx
shl    $0x3,%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x28(%rsp),%r9
test   %ebx,%ebx
jle    11d5 <getPLU+0xb5>
mov    %ebx,%ecx
movabs $0x3ff0000000000000,%rax
cmp    $0x1,%ebx
jne    1184 <getPLU+0x64>
xor    %edx,%edx
jmp    11bf <getPLU+0x9f>
mov    %ecx,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rdx,4),%edi
imul   %ebx,%edi
add    %edx,%edi
movslq %edi,%rdi
mov    %rax,0x0(%rbp,%rdi,8)
mov    0x4(%r14,%rdx,4),%edi
imul   %ebx,%edi
add    %edx,%edi
add    $0x1,%edi
movslq %edi,%rdi
mov    %rax,0x0(%rbp,%rdi,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1190 <getPLU+0x70>
test   $0x1,%cl
je     11d5 <getPLU+0xb5>
mov    (%r14,%rdx,4),%ecx
imul   %ebx,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    %rax,0x0(%rbp,%rcx,8)
mov    0x90(%rsp),%r8
mov    %ebx,%eax
sub    0x10(%rsp),%eax
jne    14b3 <getPLU+0x393>
mov    %rbx,0x8(%rsp)
test   %r9,%r9
je     1793 <getPLU+0x673>
cmpl   $0x0,0x8(%rsp)
jle    1793 <getPLU+0x673>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,0x38(%rsp)
lea    -0x2(%rax),%ecx
mov    %ecx,0x34(%rsp)
mov    %eax,%edi
lea    0x0(,%rdi,8),%rax
mov    %rax,0x10(%rsp)
lea    0x8(,%rdi,8),%rax
mov    %rax,0x40(%rsp)
lea    0x70(%r9),%rbp
mov    (%rsp),%r14
lea    0x70(%r14),%r15
lea    0x10(%r9),%r12
lea    0x10(%r14),%r11
xor    %ebx,%ebx
mov    %r9,%r13
mov    %rdi,0x18(%rsp)
jmp    1280 <getPLU+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
add    %rax,%rbp
add    %rax,%r15
add    %rax,%r12
add    %rax,%r11
add    %rax,%r13
add    %rax,%r14
cmp    %rdi,%rbx
je     1793 <getPLU+0x673>
mov    %ebx,%r8d
test   %rbx,%rbx
je     1350 <getPLU+0x230>
mov    %rbx,%r10
imul   %rdi,%r10
cmp    $0x4,%rbx
jb     12ca <getPLU+0x1aa>
lea    (%r9,%r10,8),%rcx
mov    0x40(%rsp),%rax
imul   %rbx,%rax
mov    (%rsp),%rdx
add    %rax,%rdx
cmp    %rcx,%rdx
jbe    13b1 <getPLU+0x291>
add    %r9,%rax
mov    (%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%rax
jbe    13b1 <getPLU+0x291>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %rbx,%rax
test   $0x3,%bl
je     12f7 <getPLU+0x1d7>
mov    %r8d,%esi
and    $0x3,%esi
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    12e0 <getPLU+0x1c0>
cmp    $0x3,%rax
jb     1353 <getPLU+0x233>
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%r12,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rdx,8)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  0x18(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1300 <getPLU+0x1e0>
jmp    1353 <getPLU+0x233>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
add    %rbx,%r10
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r9,%r10,8)
add    $0x1,%rbx
cmp    %rdi,%rbx
jae    1260 <getPLU+0x140>
mov    0x38(%rsp),%eax
imul   %r8d,%eax
add    $0x1,%eax
mov    %r11,0x20(%rsp)
mov    0x34(%rsp),%ecx
sub    %r8d,%ecx
cltq
lea    (%r9,%rax,8),%rdi
lea    0x8(,%rcx,8),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%r9
jmp    1260 <getPLU+0x140>
mov    %rbx,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rsi
shr    $0x2,%rsi
mov    %rbx,%rdx
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0xc,%rax
jae    13e9 <getPLU+0x2c9>
xor    %edi,%edi
jmp    1461 <getPLU+0x341>
lea    0x1(%rsi),%rax
and    $0xfffffffffffffffc,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%r15,%rdi,8),%xmm0
movups -0x60(%r15,%rdi,8),%xmm1
movups %xmm0,-0x70(%rbp,%rdi,8)
movups %xmm1,-0x60(%rbp,%rdi,8)
movups -0x50(%r15,%rdi,8),%xmm0
movups -0x40(%r15,%rdi,8),%xmm1
movups %xmm0,-0x50(%rbp,%rdi,8)
movups %xmm1,-0x40(%rbp,%rdi,8)
movups -0x30(%r15,%rdi,8),%xmm0
movups -0x20(%r15,%rdi,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,8)
movups %xmm1,-0x20(%rbp,%rdi,8)
movups -0x10(%r15,%rdi,8),%xmm0
movups (%r15,%rdi,8),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,8)
movups %xmm1,0x0(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rax
jne    1400 <getPLU+0x2e0>
test   $0x3,%r9b
je     149b <getPLU+0x37b>
add    $0x1,%sil
movzbl %sil,%eax
and    $0x3,%eax
shl    $0x5,%rax
lea    (%r12,%rdi,8),%rsi
lea    (%r11,%rdi,8),%rdi
xor    %ecx,%ecx
movups -0x10(%rdi,%rcx,1),%xmm0
movups (%rdi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1480 <getPLU+0x360>
cmp    %rdx,%rbx
mov    0x28(%rsp),%r9
mov    0x18(%rsp),%rdi
je     1353 <getPLU+0x233>
jmp    12cc <getPLU+0x1ac>
jle    19d5 <getPLU+0x8b5>
test   %r9,%r9
je     1ca1 <getPLU+0xb81>
mov    %eax,0x48(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    1c74 <getPLU+0xb54>
mov    0x10(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,0x38(%rsp)
lea    -0x2(%rax),%ecx
mov    %ecx,0x34(%rsp)
mov    %eax,%edi
lea    0x0(,%rdi,8),%rax
mov    %rax,0x20(%rsp)
lea    0x8(,%rdi,8),%rax
mov    %rax,0x40(%rsp)
lea    0x70(%r9),%r14
mov    (%rsp),%r12
lea    0x70(%r12),%rbp
lea    0x10(%r9),%r15
lea    0x10(%r12),%r11
xor    %r13d,%r13d
mov    %r9,%rbx
mov    %rdi,0x18(%rsp)
jmp    1550 <getPLU+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rax
add    %rax,%r14
add    %rax,%rbp
add    %rax,%r15
add    %rax,%r11
add    %rax,%rbx
add    %rax,%r12
cmp    %rdi,%r13
je     1c74 <getPLU+0xb54>
mov    %r13d,%r8d
test   %r13,%r13
je     1630 <getPLU+0x510>
mov    %r13,%r10
imul   %rdi,%r10
cmp    $0x4,%r13
jb     159a <getPLU+0x47a>
lea    (%r9,%r10,8),%rcx
mov    0x40(%rsp),%rax
imul   %r13,%rax
mov    (%rsp),%rdx
add    %rax,%rdx
cmp    %rcx,%rdx
jbe    1691 <getPLU+0x571>
add    %r9,%rax
mov    (%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%rax
jbe    1691 <getPLU+0x571>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r13,%rax
test   $0x3,%r13b
je     15d5 <getPLU+0x4b5>
mov    %r8d,%esi
and    $0x3,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    15c0 <getPLU+0x4a0>
cmp    $0x3,%rax
jb     1633 <getPLU+0x513>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rdx,8)
movsd  0x10(%r12,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  0x18(%r12,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    15e0 <getPLU+0x4c0>
jmp    1633 <getPLU+0x513>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
add    %r13,%r10
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r9,%r10,8)
add    $0x1,%r13
cmp    %rdi,%r13
jae    1530 <getPLU+0x410>
mov    0x38(%rsp),%eax
imul   %r8d,%eax
add    $0x1,%eax
mov    0x34(%rsp),%ecx
sub    %r8d,%ecx
cltq
lea    (%r9,%rax,8),%rdi
lea    0x8(,%rcx,8),%rdx
xor    %esi,%esi
mov    %r11,0x8(%rsp)
call   1030 <memset@plt>
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%r9
jmp    1530 <getPLU+0x410>
mov    %r13,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rsi
shr    $0x2,%rsi
mov    %r13,%rdx
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0xc,%rax
jae    16c9 <getPLU+0x5a9>
xor    %edi,%edi
jmp    1741 <getPLU+0x621>
lea    0x1(%rsi),%rax
and    $0xfffffffffffffffc,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%rbp,%rdi,8),%xmm0
movups -0x60(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x70(%r14,%rdi,8)
movups %xmm1,-0x60(%r14,%rdi,8)
movups -0x50(%rbp,%rdi,8),%xmm0
movups -0x40(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x50(%r14,%rdi,8)
movups %xmm1,-0x40(%r14,%rdi,8)
movups -0x30(%rbp,%rdi,8),%xmm0
movups -0x20(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x30(%r14,%rdi,8)
movups %xmm1,-0x20(%r14,%rdi,8)
movups -0x10(%rbp,%rdi,8),%xmm0
movups 0x0(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x10(%r14,%rdi,8)
movups %xmm1,(%r14,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rax
jne    16e0 <getPLU+0x5c0>
test   $0x3,%r9b
je     177b <getPLU+0x65b>
add    $0x1,%sil
movzbl %sil,%eax
and    $0x3,%eax
shl    $0x5,%rax
lea    (%r15,%rdi,8),%rsi
lea    (%r11,%rdi,8),%rdi
xor    %ecx,%ecx
movups -0x10(%rdi,%rcx,1),%xmm0
movups (%rdi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1760 <getPLU+0x640>
cmp    %rdx,%r13
mov    0x28(%rsp),%r9
mov    0x18(%rsp),%rdi
je     1633 <getPLU+0x513>
jmp    159c <getPLU+0x47c>
mov    0x90(%rsp),%r8
test   %r8,%r8
je     2134 <getPLU+0x1014>
cmpl   $0x0,0x8(%rsp)
jle    2134 <getPLU+0x1014>
mov    0x8(%rsp),%r12d
lea    0x0(,%r12,8),%rax
mov    %rax,0x20(%rsp)
lea    0x8(,%r12,8),%r9
lea    0x30(%r8),%rbp
mov    (%rsp),%r15
lea    0x30(%r15),%rbx
lea    -0x4(%r12),%r10
xor    %r14d,%r14d
mov    %r8,%r13
mov    %r9,0x18(%rsp)
jmp    1812 <getPLU+0x6f2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r9,%rbp
add    %r9,%rbx
add    $0xffffffffffffffff,%r10
mov    0x20(%rsp),%rax
add    %rax,%r13
add    %rax,%r15
cmp    %r12,%r14
je     2134 <getPLU+0x1014>
mov    %r12,%rcx
sub    %r14,%rcx
test   %r14,%r14
je     185b <getPLU+0x73b>
lea    0x0(,%r14,8),%rdx
mov    %r14d,%eax
imul   0x8(%rsp),%eax
cltq
lea    (%r8,%rax,8),%rdi
xor    %esi,%esi
mov    %r10,0x28(%rsp)
mov    %rcx,0x10(%rsp)
call   1030 <memset@plt>
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%r10
mov    0x18(%rsp),%r9
mov    0x90(%rsp),%r8
mov    %r14,%rax
cmp    $0x4,%rcx
jb     1940 <getPLU+0x820>
mov    %r14,%r11
imul   %r12,%r11
mov    %r9,%rdx
imul   %r14,%rdx
lea    (%r11,%r12,1),%rax
lea    (%r8,%rdx,1),%rsi
mov    (%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,%rsi
jae    189f <getPLU+0x77f>
lea    (%r8,%rax,8),%rsi
add    (%rsp),%rdx
mov    %r14,%rax
cmp    %rsi,%rdx
jb     1940 <getPLU+0x820>
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    $0x4,%rax
jae    18b8 <getPLU+0x798>
xor    %esi,%esi
jmp    1901 <getPLU+0x7e1>
mov    %r10,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x30(%rbx,%rsi,8),%xmm0
movups -0x20(%rbx,%rsi,8),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,8)
movups %xmm1,-0x20(%rbp,%rsi,8)
movups -0x10(%rbx,%rsi,8),%xmm0
movups (%rbx,%rsi,8),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,8)
movups %xmm1,0x0(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    18d0 <getPLU+0x7b0>
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%dl
je     192b <getPLU+0x80b>
add    %r14,%rsi
add    %r11,%rsi
mov    (%rsp),%rdx
movups (%rdx,%rsi,8),%xmm0
movups 0x10(%rdx,%rsi,8),%xmm1
movups %xmm0,(%r8,%rsi,8)
movups %xmm1,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     17f0 <getPLU+0x6d0>
add    %r14,%rax
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
and    $0x3,%rdx
je     1977 <getPLU+0x857>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1960 <getPLU+0x840>
cmp    $0x3,%rcx
jb     17f0 <getPLU+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1990 <getPLU+0x870>
jmp    17f0 <getPLU+0x6d0>
mov    %rbx,0x8(%rsp)
jge    2134 <getPLU+0x1014>
movslq 0x10(%rsp),%rax
mov    %rax,0x20(%rsp)
test   %r9,%r9
je     1ed5 <getPLU+0xdb5>
cmpl   $0x0,0x8(%rsp)
jle    1ed5 <getPLU+0xdb5>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,0x40(%rsp)
lea    -0x2(%rax),%ecx
mov    %ecx,0x34(%rsp)
mov    %eax,%r11d
lea    0x0(,%r11,8),%rax
mov    %rax,0x18(%rsp)
lea    0x8(,%r11,8),%rax
mov    %rax,0x50(%rsp)
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x38(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x48(%rsp)
mov    (%rsp),%rbp
lea    0x30(%rbp),%r15
lea    0x30(%r9),%r12
xor    %r13d,%r13d
mov    %r9,%r14
jmp    1a8f <getPLU+0x96f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
add    %rcx,%r15
mov    0x18(%rsp),%rax
add    %rax,%r12
add    %rax,%r14
add    %rcx,%rbp
cmp    %r11,%r13
je     1ed5 <getPLU+0xdb5>
mov    %r13d,%r8d
test   %r13,%r13
je     1b60 <getPLU+0xa40>
mov    %r13,%rcx
imul   %r11,%rcx
cmp    $0x4,%r13
jb     1ae8 <getPLU+0x9c8>
lea    (%r9,%rcx,8),%rax
mov    %r13,%rsi
imul   0x20(%rsp),%rsi
mov    0x48(%rsp),%rdx
imul   %r13,%rdx
add    (%rsp),%rdx
cmp    %rax,%rdx
jbe    1bb7 <getPLU+0xa97>
mov    0x50(%rsp),%rax
imul   %r13,%rax
add    %r9,%rax
mov    (%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
cmp    %rdx,%rax
jbe    1bb7 <getPLU+0xa97>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r13,%rax
test   $0x3,%r13b
je     1b16 <getPLU+0x9f6>
mov    %r8d,%esi
and    $0x3,%esi
nop
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1b00 <getPLU+0x9e0>
cmp    $0x3,%rax
jb     1b62 <getPLU+0xa42>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
movsd  0x18(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1b20 <getPLU+0xa00>
jmp    1b62 <getPLU+0xa42>
xchg   %ax,%ax
xor    %ecx,%ecx
add    %r13,%rcx
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r9,%rcx,8)
add    $0x1,%r13
cmp    %r11,%r13
jae    1a70 <getPLU+0x950>
mov    0x40(%rsp),%eax
imul   %r8d,%eax
add    $0x1,%eax
mov    0x34(%rsp),%ecx
sub    %r8d,%ecx
cltq
lea    (%r9,%rax,8),%rdi
lea    0x8(,%rcx,8),%rdx
xor    %esi,%esi
mov    %r11,%rbx
call   1030 <memset@plt>
mov    %rbx,%r11
mov    0x28(%rsp),%r9
jmp    1a70 <getPLU+0x950>
mov    %r13,%rdx
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rax,%rax
je     1c6a <getPLU+0xb4a>
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%r15,%rbx,8),%xmm0
movups -0x20(%r15,%rbx,8),%xmm1
movups %xmm0,-0x30(%r12,%rbx,8)
movups %xmm1,-0x20(%r12,%rbx,8)
movups -0x10(%r15,%rbx,8),%xmm0
movups (%r15,%rbx,8),%xmm1
movups %xmm0,-0x10(%r12,%rbx,8)
movups %xmm1,(%r12,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1c00 <getPLU+0xae0>
test   $0x1,%dil
je     1c5c <getPLU+0xb3c>
add    %rbx,%rsi
mov    (%rsp),%rax
movups (%rax,%rsi,8),%xmm0
movups 0x10(%rax,%rsi,8),%xmm1
add    %rcx,%rbx
movups %xmm0,(%r9,%rbx,8)
movups %xmm1,0x10(%r9,%rbx,8)
cmp    %rdx,%r13
je     1b62 <getPLU+0xa42>
jmp    1aea <getPLU+0x9ca>
xor    %ebx,%ebx
test   $0x1,%dil
jne    1c3e <getPLU+0xb1e>
jmp    1c5c <getPLU+0xb3c>
mov    0x10(%rsp),%rcx
mov    %ecx,%eax
imul   %eax,%eax
lea    (%r9,%rax,8),%rdi
mov    (%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
mov    0x48(%rsp),%edx
imul   %ecx,%edx
shl    $0x3,%edx
call   1040 <memcpy@plt>
mov    0x90(%rsp),%r8
test   %r8,%r8
je     2134 <getPLU+0x1014>
cmpl   $0x0,0x10(%rsp)
jle    2134 <getPLU+0x1014>
mov    0x10(%rsp),%r12d
lea    0x0(,%r12,8),%rax
mov    %rax,0x8(%rsp)
lea    0x8(,%r12,8),%r9
lea    0x30(%r8),%rbp
mov    (%rsp),%r15
lea    0x30(%r15),%rbx
lea    -0x4(%r12),%r10
xor    %r14d,%r14d
mov    %r8,%r13
mov    %r9,0x18(%rsp)
jmp    1d12 <getPLU+0xbf2>
nopl   (%rax)
add    $0x1,%r14
add    %r9,%rbp
add    %r9,%rbx
add    $0xffffffffffffffff,%r10
mov    0x8(%rsp),%rax
add    %rax,%r13
add    %rax,%r15
cmp    %r12,%r14
je     2134 <getPLU+0x1014>
mov    %r12,%rcx
sub    %r14,%rcx
test   %r14,%r14
je     1d5b <getPLU+0xc3b>
lea    0x0(,%r14,8),%rdx
mov    %r14d,%eax
imul   0x10(%rsp),%eax
cltq
lea    (%r8,%rax,8),%rdi
xor    %esi,%esi
mov    %r10,0x28(%rsp)
mov    %rcx,0x20(%rsp)
call   1030 <memset@plt>
mov    0x20(%rsp),%rcx
mov    0x28(%rsp),%r10
mov    0x18(%rsp),%r9
mov    0x90(%rsp),%r8
mov    %r14,%rax
cmp    $0x4,%rcx
jb     1e40 <getPLU+0xd20>
mov    %r14,%r11
imul   %r12,%r11
mov    %r9,%rdx
imul   %r14,%rdx
lea    (%r11,%r12,1),%rax
lea    (%r8,%rdx,1),%rsi
mov    (%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,%rsi
jae    1d9f <getPLU+0xc7f>
lea    (%r8,%rax,8),%rsi
add    (%rsp),%rdx
mov    %r14,%rax
cmp    %rsi,%rdx
jb     1e40 <getPLU+0xd20>
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    $0x4,%rax
jae    1db8 <getPLU+0xc98>
xor    %esi,%esi
jmp    1e01 <getPLU+0xce1>
mov    %r10,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x30(%rbx,%rsi,8),%xmm0
movups -0x20(%rbx,%rsi,8),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,8)
movups %xmm1,-0x20(%rbp,%rsi,8)
movups -0x10(%rbx,%rsi,8),%xmm0
movups (%rbx,%rsi,8),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,8)
movups %xmm1,0x0(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    1dd0 <getPLU+0xcb0>
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%dl
je     1e2b <getPLU+0xd0b>
add    %r14,%rsi
add    %r11,%rsi
mov    (%rsp),%rdx
movups (%rdx,%rsi,8),%xmm0
movups 0x10(%rdx,%rsi,8),%xmm1
movups %xmm0,(%r8,%rsi,8)
movups %xmm1,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     1cf0 <getPLU+0xbd0>
add    %r14,%rax
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
and    $0x3,%rdx
je     1e77 <getPLU+0xd57>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e60 <getPLU+0xd40>
cmp    $0x3,%rcx
jb     1cf0 <getPLU+0xbd0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1e90 <getPLU+0xd70>
jmp    1cf0 <getPLU+0xbd0>
mov    0x90(%rsp),%rsi
test   %rsi,%rsi
je     2134 <getPLU+0x1014>
cmpl   $0x0,0x8(%rsp)
jle    2134 <getPLU+0x1014>
mov    0x8(%rsp),%eax
mov    %rax,0x8(%rsp)
mov    0x10(%rsp),%r13d
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x18(%rsp)
lea    0x8(,%rax,8),%r9
lea    0x30(%rsi),%rbx
mov    (%rsp),%r12
lea    0x30(%r12),%rbp
lea    -0x4(%r13),%r11
xor    %r15d,%r15d
mov    %rsi,%r14
mov    %r9,0x38(%rsp)
jmp    1f64 <getPLU+0xe44>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
add    %r9,%rbx
add    %r9,%rbp
add    $0xffffffffffffffff,%r11
mov    0x18(%rsp),%rax
add    %rax,%r14
add    %rax,%r12
cmp    0x8(%rsp),%r15
je     2134 <getPLU+0x1014>
test   %r15,%r15
je     1f9d <getPLU+0xe7d>
lea    0x0(,%r15,8),%rdx
mov    %r15d,%eax
imul   0x10(%rsp),%eax
cltq
lea    (%rsi,%rax,8),%rdi
xor    %esi,%esi
mov    %r11,0x28(%rsp)
call   1030 <memset@plt>
mov    0x28(%rsp),%r11
mov    0x38(%rsp),%r9
mov    0x90(%rsp),%rsi
cmp    0x20(%rsp),%r15
jge    1f40 <getPLU+0xe20>
mov    %r13,%rax
sub    %r15,%rax
mov    %r15,%rcx
cmp    $0x4,%rax
jb     20b0 <getPLU+0xf90>
mov    %r15,%r8
imul   0x20(%rsp),%r8
mov    %r9,%rsi
imul   %r15,%rsi
lea    (%r8,%r13,1),%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rsi,1),%rdi
mov    (%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
cmp    %rdx,%rdi
jae    2000 <getPLU+0xee0>
mov    0x90(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
add    (%rsp),%rsi
mov    %r15,%rcx
cmp    %rdx,%rsi
jb     20b0 <getPLU+0xf90>
lea    -0x4(%rax),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    $0x4,%rcx
jae    2019 <getPLU+0xef9>
xor    %edi,%edi
jmp    2061 <getPLU+0xf41>
mov    %r11,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rbp,%rdi,8),%xmm0
movups -0x20(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,8)
movups %xmm1,-0x20(%rbx,%rdi,8)
movups -0x10(%rbp,%rdi,8),%xmm0
movups 0x0(%rbp,%rdi,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,8)
movups %xmm1,(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    2030 <getPLU+0xf10>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x1,%sil
je     2092 <getPLU+0xf72>
add    %r15,%rdi
add    %r8,%rdi
mov    (%rsp),%rdx
movups (%rdx,%rdi,8),%xmm0
movups 0x10(%rdx,%rdi,8),%xmm1
mov    0x90(%rsp),%rdx
movups %xmm0,(%rdx,%rdi,8)
movups %xmm1,0x10(%rdx,%rdi,8)
cmp    %rcx,%rax
mov    0x90(%rsp),%rsi
je     1f40 <getPLU+0xe20>
add    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%edx
sub    %ecx,%edx
mov    %rcx,%rax
not    %rax
add    %r13,%rax
mov    0x90(%rsp),%rsi
and    $0x3,%rdx
je     20e6 <getPLU+0xfc6>
nopl   0x0(%rax)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    20d0 <getPLU+0xfb0>
cmp    $0x3,%rax
jb     1f40 <getPLU+0xe20>
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
movsd  0x10(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    20f0 <getPLU+0xfd0>
jmp    1f40 <getPLU+0xe20>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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