#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 */
double fabs(double);
int /*<<< orphan*/ pludecomp(double *, int, int *);
int rludecomp(double *A, int M, int N, int *ipiv) {
  int k, j, l, c1, c2, mind, tempi;
  double ld, mult, mval, temp;
  for (k = 0; k < M; ++k)
    ipiv[k] = (double)k;
  if (M > N) {
    for (k = 0; k < N; ++k) {
      mval = fabs(A[k * N + k]);
      mind = k;
      for (j = k + 1; j < M; ++j) {
        if (mval < fabs(A[j * N + k])) {
          mval = A[j * N + k];
          mind = j;
        }
      }
      if (mind != k) {
        c1 = k * N;
        c2 = mind * N;
        tempi = ipiv[mind];
        ipiv[mind] = ipiv[k];
        ipiv[k] = tempi;
        for (j = 0; j < N; j++) {
          temp = A[c1 + j];
          *(A + c1 + j) = *(A + c2 + j);
          *(A + c2 + j) = temp;
        }
      }
      c2 = k * N;
      ld = A[c2 + k];
      if (ld != 0. && k < N) {
        for (j = k + 1; j < M; ++j) {
          c1 = j * N;
          mult = A[c1 + k] /= ld;
          for (l = k + 1; l < N; ++l) {
            A[c1 + l] -= mult * A[c2 + l];
          }
        }
      }
    }
  } else if (M < N) {
    for (k = 0; k < M - 1; ++k) {
      mval = fabs(A[k * N + k]);
      mind = k;
      for (j = k + 1; j < M; ++j) {
        if (mval < fabs(A[j * N + k])) {
          mval = A[j * N + k];
          mind = j;
        }
      }
      if (mind != k) {
        c1 = k * N;
        c2 = mind * N;
        tempi = ipiv[mind];
        ipiv[mind] = ipiv[k];
        ipiv[k] = tempi;
        for (j = 0; j < N; j++) {
          temp = A[c1 + j];
          *(A + c1 + j) = *(A + c2 + j);
          *(A + c2 + j) = temp;
        }
      }
      c2 = k * N;
      ld = A[c2 + k];
      if (ld != 0.) {
        for (j = k + 1; j < M; ++j) {
          c1 = j * N;
          mult = A[c1 + k] /= ld;
          for (l = k + 1; l < N; ++l) {
            A[c1 + l] -= mult * A[c2 + l];
          }
        }
      }
    }
  } else if (M == N) {
    pludecomp(A, N, ipiv);
  }
  return 0;
}


x86 assembly (clang, -O0):
<rludecomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    115b <rludecomp+0x4b>
cvtsi2sdl -0x1c(%rbp),%xmm0
cvttsd2si %xmm0,%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112d <rludecomp+0x1d>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1429 <rludecomp+0x319>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1424 <rludecomp+0x314>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe69(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    121f <rludecomp+0x10f>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe23(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    120c <rludecomp+0xfc>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1211 <rludecomp+0x101>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11af <rludecomp+0x9f>
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     12fb <rludecomp+0x1eb>
mov    -0x1c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12f6 <rludecomp+0x1e6>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1278 <rludecomp+0x168>
jmp    12fb <rludecomp+0x1eb>
mov    -0x1c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1339 <rludecomp+0x229>
jp     1339 <rludecomp+0x229>
jmp    1411 <rludecomp+0x301>
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1411 <rludecomp+0x301>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    140c <rludecomp+0x2fc>
mov    -0x20(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13f9 <rludecomp+0x2e9>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1392 <rludecomp+0x282>
jmp    13fe <rludecomp+0x2ee>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    134e <rludecomp+0x23e>
jmp    1411 <rludecomp+0x301>
jmp    1416 <rludecomp+0x306>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    116e <rludecomp+0x5e>
jmp    1716 <rludecomp+0x606>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16f0 <rludecomp+0x5e0>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16eb <rludecomp+0x5db>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb96(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14f2 <rludecomp+0x3e2>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb50(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    14df <rludecomp+0x3cf>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    14e4 <rludecomp+0x3d4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1482 <rludecomp+0x372>
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     15ce <rludecomp+0x4be>
mov    -0x1c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15c9 <rludecomp+0x4b9>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    154b <rludecomp+0x43b>
jmp    15ce <rludecomp+0x4be>
mov    -0x1c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    160c <rludecomp+0x4fc>
jp     160c <rludecomp+0x4fc>
jmp    16d8 <rludecomp+0x5c8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16d3 <rludecomp+0x5c3>
mov    -0x20(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16c0 <rludecomp+0x5b0>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1659 <rludecomp+0x549>
jmp    16c5 <rludecomp+0x5b5>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1615 <rludecomp+0x505>
jmp    16d8 <rludecomp+0x5c8>
jmp    16dd <rludecomp+0x5cd>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    143c <rludecomp+0x32c>
jmp    1711 <rludecomp+0x601>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    170c <rludecomp+0x5fc>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%esi
mov    -0x18(%rbp),%rdx
call   1030 <pludecomp@plt>
jmp    1711 <rludecomp+0x601>
jmp    1716 <rludecomp+0x606>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rludecomp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %esi,%eax
mov    %rdi,0x10(%rsp)
mov    %rax,%rsi
test   %eax,%eax
jle    12ac <rludecomp+0x19c>
mov    %rsi,%rax
mov    %eax,%ebp
cmp    $0x8,%eax
jae    1144 <rludecomp+0x34>
xor    %eax,%eax
jmp    12a0 <rludecomp+0x190>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdi
jae    1174 <rludecomp+0x64>
movdqa 0x1e93(%rip),%xmm0
xor    %edi,%edi
jmp    1248 <rludecomp+0x138>
and    $0xfffffffffffffffc,%rbx
movdqa 0x1e80(%rip),%xmm0
xor    %edi,%edi
movdqa 0x1e85(%rip),%xmm8
movdqa 0x1e8c(%rip),%xmm9
movdqa 0x1e93(%rip),%xmm10
movdqa 0x1e9b(%rip),%xmm4
movdqa 0x1ea3(%rip),%xmm5
movdqa 0x1eab(%rip),%xmm6
movdqa 0x1eb3(%rip),%xmm7
movdqa 0x1ebb(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rcx,%rdi,4)
movdqu %xmm2,0x10(%rcx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rcx,%rdi,4)
movdqu %xmm3,0x30(%rcx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rcx,%rdi,4)
movdqu %xmm3,0x50(%rcx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rcx,%rdi,4)
movdqu %xmm3,0x70(%rcx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rbx
jne    11d0 <rludecomp+0xc0>
test   %r8,%r8
je     1290 <rludecomp+0x180>
lea    (%rcx,%rdi,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r8
xor    %edi,%edi
movdqa 0x1dad(%rip),%xmm1
movdqa 0x1db5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rbx,%rdi,1)
movdqu %xmm3,(%rbx,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1270 <rludecomp+0x160>
cmp    %rbp,%rax
je     12ac <rludecomp+0x19c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    12a0 <rludecomp+0x190>
cmp    %edx,%esi
mov    %rcx,0xd0(%rsp)
mov    %edx,0x64(%rsp)
jle    1934 <rludecomp+0x824>
test   %edx,%edx
mov    0x10(%rsp),%r8
jle    2006 <rludecomp+0xef6>
mov    %edx,%eax
movslq %esi,%rcx
mov    %rcx,0x78(%rsp)
mov    %esi,%ebx
lea    0x1(%rax),%rcx
mov    %rcx,0xf8(%rsp)
lea    0x0(,%rax,8),%r11
lea    0x8(,%rax,8),%rcx
mov    %rcx,0x38(%rsp)
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x68(%rsp)
lea    0x8(%r8),%rcx
mov    %rcx,0x70(%rsp)
lea    (%r8,%rax,8),%rcx
mov    %eax,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc0(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rsi
mov    %rdi,0xb0(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xa8(%rsp)
mov    %rax,%rsi
neg    %rsi
mov    %rsi,0x40(%rsp)
lea    0x30(%r8),%rsi
movapd 0x1d2e(%rip),%xmm0
pxor   %xmm8,%xmm8
movapd 0x1d30(%rip),%xmm9
lea    -0x1(%rax),%rdi
mov    %rdi,0x30(%rsp)
lea    0x18(%r8),%r14
lea    0x18(%r8,%rax,8),%rdi
mov    %rdi,0x28(%rsp)
lea    0x8(%r8,%rax,8),%rdi
mov    %rdi,0x20(%rsp)
mov    $0x1,%edi
mov    %rdi,0x8(%rsp)
xor    %ebp,%ebp
mov    %r8,%r9
mov    %rsi,0xa0(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %rcx,%rdi
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
jmp    1409 <rludecomp+0x2f9>
nop
addq   $0x1,0x8(%rsp)
mov    0x38(%rsp),%rcx
mov    0x80(%rsp),%rdi
add    %rcx,%rdi
mov    0x88(%rsp),%rsi
mov    0x58(%rsp),%r11
add    %r11,%rsi
add    %r11,%r9
addq   $0xffffffffffffffff,0x30(%rsp)
add    %rcx,%r14
add    %rcx,0x28(%rsp)
add    %r11,0x20(%rsp)
cmp    %rax,%rbp
mov    0x64(%rsp),%edx
je     2006 <rludecomp+0xef6>
mov    %rsi,0x88(%rsp)
mov    %rbp,%r12
mov    %rbp,%rcx
imul   %rax,%rcx
mov    %rcx,%rsi
mov    %rcx,(%rsp)
lea    (%rcx,%rax,1),%r10
mov    %r12d,%ecx
imul   %edx,%ecx
movslq %ecx,%r15
add    %rbp,%r15
movsd  (%r8,%r15,8),%xmm3
lea    0x1(%rbp),%rcx
mov    %rcx,0x18(%rsp)
cmp    0x78(%rsp),%rcx
mov    %rdi,0x80(%rsp)
jge    14b0 <rludecomp+0x3a0>
movapd %xmm3,%xmm5
andpd  %xmm0,%xmm5
mov    %rdi,%rcx
mov    0x8(%rsp),%rsi
mov    %r12d,%edi
movapd %xmm5,%xmm4
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm6
movapd %xmm6,%xmm7
andpd  %xmm0,%xmm7
ucomisd %xmm5,%xmm7
cmova  %esi,%edi
cmpltsd %xmm7,%xmm4
andpd  %xmm4,%xmm6
andnpd %xmm5,%xmm4
orpd   %xmm6,%xmm4
add    $0x1,%rsi
add    %r11,%rcx
movapd %xmm4,%xmm5
cmp    %rsi,%rbx
jne    1470 <rludecomp+0x360>
jmp    14b3 <rludecomp+0x3a3>
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%edi
lea    (%r8,%r10,8),%r13
mov    %edi,%ecx
cmp    %rcx,%r12
je     16cb <rludecomp+0x5bb>
mov    (%rsp),%rcx
lea    (%r8,%rcx,8),%rbx
movslq %edi,%rcx
imul   %edx,%edi
mov    0xd0(%rsp),%rbp
mov    0x0(%rbp,%rcx,4),%r10d
mov    0x0(%rbp,%r12,4),%esi
mov    %esi,0x0(%rbp,%rcx,4)
mov    %r10d,0x0(%rbp,%r12,4)
mov    0x10(%rsp),%r8
movslq %edi,%r11
lea    (%r8,%r11,8),%r10
cmp    $0x4,%edx
jae    1590 <rludecomp+0x480>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%al
je     152e <rludecomp+0x41e>
mov    (%rsp),%rcx
add    %rsi,%rcx
movsd  (%r8,%rcx,8),%xmm3
movsd  (%r10,%rsi,8),%xmm4
movsd  %xmm4,(%rbx,%rsi,8)
movsd  %xmm3,(%r10,%rsi,8)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x40(%rsp),%rsi
je     16c0 <rludecomp+0x5b0>
mov    0x70(%rsp),%rdx
lea    (%rdx,%r11,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r9,%rcx,8),%xmm3
movsd  -0x8(%rsi,%rcx,8),%xmm4
movsd  %xmm4,(%r9,%rcx,8)
movsd  %xmm3,-0x8(%rsi,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm3
movsd  (%rsi,%rcx,8),%xmm4
movsd  %xmm4,0x8(%r9,%rcx,8)
movsd  %xmm3,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1550 <rludecomp+0x440>
jmp    16c0 <rludecomp+0x5b0>
xchg   %ax,%ax
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r11,8),%rcx
cmp    %rcx,%rbx
setb   %sil
cmp    %r13,%r10
setb   %cl
and    %sil,%cl
jne    1500 <rludecomp+0x3f0>
cmp    %r13,%rbx
jb     1500 <rludecomp+0x3f0>
mov    $0x0,%esi
test   %cl,%cl
jne    1502 <rludecomp+0x3f2>
cmpq   $0x0,0xb8(%rsp)
mov    0x88(%rsp),%rdx
je     191f <rludecomp+0x80f>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%r11,8),%rsi
mov    0xa8(%rsp),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rdx,%rcx,8),%xmm3
movups -0x20(%rdx,%rcx,8),%xmm4
movups -0x30(%rsi,%rcx,8),%xmm5
movups -0x20(%rsi,%rcx,8),%xmm6
movups %xmm5,-0x30(%rdx,%rcx,8)
movups %xmm6,-0x20(%rdx,%rcx,8)
movups %xmm3,-0x30(%rsi,%rcx,8)
movups %xmm4,-0x20(%rsi,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm3
movupd (%rdx,%rcx,8),%xmm4
movupd -0x10(%rsi,%rcx,8),%xmm5
movupd (%rsi,%rcx,8),%xmm6
movupd %xmm5,-0x10(%rdx,%rcx,8)
movupd %xmm6,(%rdx,%rcx,8)
movupd %xmm3,-0x10(%rsi,%rcx,8)
movupd %xmm4,(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1600 <rludecomp+0x4f0>
testb  $0x1,0xb0(%rsp)
01
je     16a2 <rludecomp+0x592>
mov    (%rsp),%rdx
lea    (%rcx,%rdx,1),%rsi
movupd (%r8,%rsi,8),%xmm3
movupd 0x10(%r8,%rsi,8),%xmm4
movupd (%r10,%rcx,8),%xmm5
movupd 0x10(%r10,%rcx,8),%xmm6
movupd %xmm5,(%rbx,%rcx,8)
movupd %xmm6,0x10(%rbx,%rcx,8)
movupd %xmm3,(%r10,%rcx,8)
movupd %xmm4,0x10(%r10,%rcx,8)
mov    0xc0(%rsp),%rcx
mov    %rcx,%rsi
cmp    %rax,%rcx
jne    1502 <rludecomp+0x3f2>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r8,%r15,8),%xmm3
mov    0x50(%rsp),%rbx
mov    %r13,0x98(%rsp)
ucomisd %xmm8,%xmm3
mov    0x18(%rsp),%rbp
jne    16e5 <rludecomp+0x5d5>
jnp    13c0 <rludecomp+0x2b0>
cmp    0x78(%rsp),%rbp
jge    13c0 <rludecomp+0x2b0>
mov    %r12,%rdx
mov    0x38(%rsp),%r10
mov    %r12,%rcx
imul   %rdx,%r10
mov    0x30(%rsp),%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rbx
not    %rbx
add    %rax,%rbx
mov    0x68(%rsp),%rcx
mov    (%rsp),%rsi
add    %rsi,%rcx
mov    %rcx,0xf0(%rsp)
mov    0x70(%rsp),%rcx
mov    %r10,0x90(%rsp)
add    %r10,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rbx,0x48(%rsp)
and    $0xfffffffffffffffc,%rbx
mov    0x8(%rsp),%r11
mov    %rbx,0xe0(%rsp)
lea    (%r11,%rbx,1),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%r12
xor    %r15d,%r15d
jmp    1796 <rludecomp+0x686>
xchg   %ax,%ax
add    $0x1,%r11
add    $0x1,%r15
mov    0x58(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%r13
mov    0x50(%rsp),%rbx
cmp    %rbx,%r11
mov    0x18(%rsp),%rbp
je     13c0 <rludecomp+0x2b0>
mov    %r11,%rcx
imul   %rax,%rcx
lea    (%rcx,%rdx,1),%rsi
movsd  (%r8,%rsi,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%r8,%rsi,8)
cmp    %rax,%rbp
jae    1770 <rludecomp+0x660>
xorpd  %xmm9,%xmm4
mov    0x8(%rsp),%r10
cmpq   $0x4,0x48(%rsp)
jb     1890 <rludecomp+0x780>
mov    %r15,%rsi
imul   %rax,%rsi
mov    0xf8(%rsp),%rbp
add    %rsi,%rbp
mov    0x10(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
add    0x90(%rsp),%rbp
cmp    0x98(%rsp),%rbp
mov    0x10(%rsp),%r8
jae    1819 <rludecomp+0x709>
add    0xf0(%rsp),%rsi
lea    (%r8,%rsi,8),%rsi
mov    0x8(%rsp),%r10
cmp    %rsi,0xe8(%rsp)
jb     1890 <rludecomp+0x780>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%r14,%rsi,8),%xmm6
movupd (%r14,%rsi,8),%xmm7
movupd -0x10(%r12,%rsi,8),%xmm1
movupd (%r12,%rsi,8),%xmm2
mulpd  %xmm5,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm5,%xmm7
addpd  %xmm2,%xmm7
movupd %xmm6,-0x10(%r12,%rsi,8)
movupd %xmm7,(%r12,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1830 <rludecomp+0x720>
mov    0xd8(%rsp),%r10
mov    0xe0(%rsp),%rsi
cmp    %rsi,0x48(%rsp)
je     1770 <rludecomp+0x660>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ebp
sub    %r10d,%ebp
mov    %r10,%rsi
test   $0x1,%bpl
mov    0x10(%rsp),%r8
je     18c7 <rludecomp+0x7b7>
mov    (%rsp),%rsi
add    %r10,%rsi
add    %r10,%rcx
movsd  (%r8,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r8,%rcx,8),%xmm1
movsd  %xmm1,(%r8,%rcx,8)
lea    0x1(%r10),%rsi
not    %r10
cmp    0x40(%rsp),%r10
je     1770 <rludecomp+0x660>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r9,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  -0x8(%r13,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rsi,8)
movsd  0x8(%r9,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%r13,%rsi,8),%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    18e0 <rludecomp+0x7d0>
jmp    1770 <rludecomp+0x660>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    1668 <rludecomp+0x558>
jmp    16a2 <rludecomp+0x592>
jge    1ff2 <rludecomp+0xee2>
cmp    $0x2,%esi
mov    0x10(%rsp),%rbp
jl     2006 <rludecomp+0xef6>
movslq %edx,%rax
mov    %esi,%r13d
add    $0xffffffff,%esi
mov    %rsi,0x70(%rsp)
mov    %edx,%r9d
lea    0x1(%rax),%rcx
mov    %rcx,0xf0(%rsp)
lea    0x0(,%rax,8),%r8
lea    0x8(,%rax,8),%rcx
mov    %rcx,0x38(%rsp)
lea    (%rax,%r9,1),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x8(%rbp),%rcx
mov    %rcx,0x68(%rsp)
lea    0x0(,%r9,8),%rcx
add    %rbp,%rcx
mov    %rcx,0xc0(%rsp)
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xb8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xb0(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rcx
mov    %rsi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xa0(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0x40(%rsp)
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
movapd 0x1694(%rip),%xmm0
pxor   %xmm8,%xmm8
movapd 0x1696(%rip),%xmm9
lea    0x30(%rbp),%rcx
lea    -0x1(%r9),%rdi
mov    %rdi,0x30(%rsp)
lea    0x18(%rbp),%r14
lea    0x18(%rbp,%rax,8),%rdi
mov    %rdi,0x28(%rsp)
lea    0x8(%rbp,%rax,8),%rdi
mov    %rdi,0x20(%rsp)
mov    $0x1,%edi
mov    %rdi,0x8(%rsp)
xor    %ebx,%ebx
mov    %rbp,%rdi
mov    %rcx,0x100(%rsp)
mov    %rcx,%r10
mov    %r8,0x50(%rsp)
mov    %rax,0x90(%rsp)
jmp    1aa8 <rludecomp+0x998>
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x8(%rsp)
mov    0x38(%rsp),%rcx
mov    0x78(%rsp),%rsi
add    %rcx,%rsi
mov    0x80(%rsp),%r10
add    %r8,%r10
add    %r8,%rdi
addq   $0xffffffffffffffff,0x30(%rsp)
add    %rcx,%r14
add    %rcx,0x28(%rsp)
add    %r8,0x20(%rsp)
mov    0x18(%rsp),%rbx
cmp    0x70(%rsp),%rbx
mov    0x64(%rsp),%edx
je     2006 <rludecomp+0xef6>
mov    %rbx,%r12
mov    %rbx,%rcx
imul   %rax,%rcx
mov    %rcx,%rax
mov    %rcx,(%rsp)
add    %r9,%rcx
mov    %r12d,%eax
imul   %edx,%eax
movslq %eax,%r15
add    %rbx,%r15
movsd  0x0(%rbp,%r15,8),%xmm3
lea    0x1(%rbx),%r11
cmp    %r13,%r11
mov    %rsi,0x78(%rsp)
jae    1b40 <rludecomp+0xa30>
movapd %xmm3,%xmm5
andpd  %xmm0,%xmm5
mov    0x8(%rsp),%rbx
mov    %r12d,%eax
movapd %xmm5,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm6
movapd %xmm6,%xmm7
andpd  %xmm0,%xmm7
ucomisd %xmm5,%xmm7
cmova  %ebx,%eax
cmpltsd %xmm7,%xmm4
andpd  %xmm4,%xmm6
andnpd %xmm5,%xmm4
orpd   %xmm6,%xmm4
add    $0x1,%rbx
add    %r8,%rsi
movapd %xmm4,%xmm5
cmp    %rbx,%r13
jne    1b00 <rludecomp+0x9f0>
jmp    1b43 <rludecomp+0xa33>
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%eax
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x98(%rsp)
mov    %eax,%ecx
cmp    %rcx,%r12
mov    %r10,0x80(%rsp)
mov    %r11,0x18(%rsp)
je     1d8c <rludecomp+0xc7c>
movslq %eax,%rcx
mov    0xd0(%rsp),%rbx
mov    (%rbx,%rcx,4),%esi
mov    (%rbx,%r12,4),%ebp
mov    %ebp,(%rbx,%rcx,4)
mov    0x10(%rsp),%rbp
mov    %esi,(%rbx,%r12,4)
test   %edx,%edx
jle    1d8c <rludecomp+0xc7c>
mov    (%rsp),%rcx
lea    0x0(,%rcx,8),%r10
add    %rbp,%r10
imul   %edx,%eax
movslq %eax,%r8
lea    0x0(,%r8,8),%r11
add    %rbp,%r11
cmp    $0x4,%edx
jae    1c4a <rludecomp+0xb3a>
xor    %ebx,%ebx
mov    %rbx,%rdx
test   $0x1,%r9b
je     1bef <rludecomp+0xadf>
mov    (%rsp),%rax
lea    (%rbx,%rax,1),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm3
movsd  (%r11,%rbx,8),%xmm4
movsd  %xmm4,(%r10,%rbx,8)
movsd  %xmm3,(%r11,%rbx,8)
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
cmp    0x40(%rsp),%rbx
je     1d80 <rludecomp+0xc70>
mov    0x68(%rsp),%rax
lea    (%rax,%r8,8),%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm3
movsd  -0x8(%rcx,%rdx,8),%xmm4
movsd  %xmm4,(%rdi,%rdx,8)
movsd  %xmm3,-0x8(%rcx,%rdx,8)
movsd  0x8(%rdi,%rdx,8),%xmm3
movsd  (%rcx,%rdx,8),%xmm4
movsd  %xmm4,0x8(%rdi,%rdx,8)
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    1c10 <rludecomp+0xb00>
jmp    1d80 <rludecomp+0xc70>
mov    0xc0(%rsp),%rax
lea    (%rax,%r8,8),%rcx
cmp    %rcx,%r10
setb   %dl
mov    0x98(%rsp),%rax
cmp    %rax,%r11
setb   %cl
and    %dl,%cl
jne    1bbd <rludecomp+0xaad>
cmp    %rax,%r10
jb     1bbd <rludecomp+0xaad>
mov    $0x0,%ebx
test   %cl,%cl
jne    1bbf <rludecomp+0xaaf>
cmpq   $0x0,0xb0(%rsp)
mov    0x80(%rsp),%rsi
je     1fdd <rludecomp+0xecd>
mov    0x100(%rsp),%rax
lea    (%rax,%r8,8),%rbx
mov    0xa0(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rsi,%rdx,8),%xmm3
movups -0x20(%rsi,%rdx,8),%xmm4
movups -0x30(%rbx,%rdx,8),%xmm5
movups -0x20(%rbx,%rdx,8),%xmm6
movups %xmm5,-0x30(%rsi,%rdx,8)
movups %xmm6,-0x20(%rsi,%rdx,8)
movups %xmm3,-0x30(%rbx,%rdx,8)
movups %xmm4,-0x20(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm3
movupd (%rsi,%rdx,8),%xmm4
movupd -0x10(%rbx,%rdx,8),%xmm5
movupd (%rbx,%rdx,8),%xmm6
movupd %xmm5,-0x10(%rsi,%rdx,8)
movupd %xmm6,(%rsi,%rdx,8)
movupd %xmm3,-0x10(%rbx,%rdx,8)
movupd %xmm4,(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1cc0 <rludecomp+0xbb0>
testb  $0x1,0xa8(%rsp)
01
je     1d63 <rludecomp+0xc53>
mov    (%rsp),%rax
lea    (%rdx,%rax,1),%rcx
movupd 0x0(%rbp,%rcx,8),%xmm3
movupd 0x10(%rbp,%rcx,8),%xmm4
movupd (%r11,%rdx,8),%xmm5
movupd 0x10(%r11,%rdx,8),%xmm6
movupd %xmm5,(%r10,%rdx,8)
movupd %xmm6,0x10(%r10,%rdx,8)
movupd %xmm3,(%r11,%rdx,8)
movupd %xmm4,0x10(%r11,%rdx,8)
mov    0xb8(%rsp),%rax
mov    %rax,%rbx
cmp    %r9,%rax
jne    1bbf <rludecomp+0xaaf>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r15,8),%xmm3
mov    0x50(%rsp),%r8
mov    %r12,0x58(%rsp)
ucomisd %xmm8,%xmm3
mov    0x90(%rsp),%rax
jne    1da6 <rludecomp+0xc96>
jnp    1a60 <rludecomp+0x950>
cmp    %r13,0x18(%rsp)
jae    1a60 <rludecomp+0x950>
mov    0x38(%rsp),%rsi
mov    0x58(%rsp),%rcx
imul   %rcx,%rsi
mov    0x30(%rsp),%r15
and    $0xfffffffffffffffc,%r15
mov    %rcx,%rbx
not    %rbx
add    %r9,%rbx
mov    0xc8(%rsp),%rcx
mov    (%rsp),%rdx
add    %rdx,%rcx
mov    %rcx,0xe8(%rsp)
mov    0x68(%rsp),%rcx
mov    %rsi,0xf8(%rsp)
add    %rsi,%rcx
mov    %rcx,0xe0(%rsp)
mov    %rbx,0x48(%rsp)
and    $0xfffffffffffffffc,%rbx
mov    0x8(%rsp),%r10
mov    %rbx,0xd8(%rsp)
lea    (%r10,%rbx,1),%rcx
mov    %rcx,0x88(%rsp)
mov    0x20(%rsp),%r12
mov    0x28(%rsp),%rbx
xor    %esi,%esi
jmp    1e4f <rludecomp+0xd3f>
add    $0x1,%r10
add    $0x1,%rsi
mov    0x50(%rsp),%r8
add    %r8,%rbx
add    %r8,%r12
mov    %r11,%r13
cmp    %r11,%r10
je     1a60 <rludecomp+0x950>
mov    %r13,%r11
mov    %r10,%rdx
imul   %rax,%rdx
mov    0x58(%rsp),%rcx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,0x0(%rbp,%rcx,8)
cmp    %rax,0x18(%rsp)
jge    1e30 <rludecomp+0xd20>
xorpd  %xmm9,%xmm4
mov    0x8(%rsp),%r8
cmpq   $0x4,0x48(%rsp)
jb     1f60 <rludecomp+0xe50>
mov    %rsi,%rcx
imul   %rax,%rcx
mov    0xf0(%rsp),%rax
lea    (%rax,%rcx,1),%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
mov    0x90(%rsp),%rax
add    0xf8(%rsp),%rbp
cmp    0x98(%rsp),%rbp
mov    0x10(%rsp),%rbp
jae    1eeb <rludecomp+0xddb>
add    0xe8(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    0x8(%rsp),%r8
cmp    %rcx,0xe0(%rsp)
jb     1f60 <rludecomp+0xe50>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%r14,%rcx,8),%xmm6
movupd (%r14,%rcx,8),%xmm7
movupd -0x10(%rbx,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm5,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm5,%xmm7
addpd  %xmm2,%xmm7
movupd %xmm6,-0x10(%rbx,%rcx,8)
movupd %xmm7,(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1f00 <rludecomp+0xdf0>
mov    0x88(%rsp),%r8
mov    0xd8(%rsp),%rcx
cmp    %rcx,0x48(%rsp)
je     1e30 <rludecomp+0xd20>
nopw   0x0(%rax,%rax,1)
mov    %r9d,%ecx
sub    %r8d,%ecx
mov    %r8,%r13
test   $0x1,%cl
je     1f92 <rludecomp+0xe82>
mov    (%rsp),%rcx
add    %r8,%rcx
add    %r8,%rdx
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
lea    0x1(%r8),%r13
not    %r8
cmp    0x40(%rsp),%r8
je     1e30 <rludecomp+0xd20>
movsd  (%rdi,%r13,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  -0x8(%r12,%r13,8),%xmm1
movsd  %xmm1,-0x8(%r12,%r13,8)
movsd  0x8(%rdi,%r13,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r12,%r13,8),%xmm1
movsd  %xmm1,(%r12,%r13,8)
add    $0x2,%r13
cmp    %r13,%r9
jne    1fa0 <rludecomp+0xe90>
jmp    1e30 <rludecomp+0xd20>
xor    %edx,%edx
testb  $0x1,0xa8(%rsp)
01
jne    1d28 <rludecomp+0xc18>
jmp    1d63 <rludecomp+0xc53>
mov    0x10(%rsp),%rdi
jne    2006 <rludecomp+0xef6>
mov    0xd0(%rsp),%rdx
call   1030 <pludecomp@plt>
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @rludecomp(double* %0, i32 %1, i32 %2, i32* %3) {
%5 = icmp sgt i32 %1, 0
br i1 %5, label %6, label %79
6: ; preds = %4
%7 = zext i32 %1 to i64
%8 = icmp ult i32 %1, 8
br i1 %8, label %71, label %9
9: ; preds = %6
%10 = and i64 %7, 4294967288
%11 = add nsw i64 %10, -8
%12 = lshr exact i64 %11, 3
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 3
%15 = icmp ult i64 %11, 24
br i1 %15, label %52, label %16
16: ; preds = %9
%17 = and i64 %13, 4611686018427387900
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %48, %18 ]
%20 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %16 ], [ %49, %18 ]
%21 = phi i64 [ 0, %16 ], [ %50, %18 ]
%22 = add <4 x i32> %20, <i32 4, i32 4, i32 4, i32 4>
%23 = getelementptr inbounds i32, i32* %3, i64 %19
%24 = bitcast i32* %23 to <4 x i32>*
store <4 x i32> %20, <4 x i32>* %24
%25 = getelementptr inbounds i32, i32* %23, i64 4
%26 = bitcast i32* %25 to <4 x i32>*
store <4 x i32> %22, <4 x i32>* %26
%27 = or i64 %19, 8
%28 = add <4 x i32> %20, <i32 8, i32 8, i32 8, i32 8>
%29 = add <4 x i32> %20, <i32 12, i32 12, i32 12, i32 12>
%30 = getelementptr inbounds i32, i32* %3, i64 %27
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %28, <4 x i32>* %31
%32 = getelementptr inbounds i32, i32* %30, i64 4
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %33
%34 = or i64 %19, 16
%35 = add <4 x i32> %20, <i32 16, i32 16, i32 16, i32 16>
%36 = add <4 x i32> %20, <i32 20, i32 20, i32 20, i32 20>
%37 = getelementptr inbounds i32, i32* %3, i64 %34
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> %35, <4 x i32>* %38
%39 = getelementptr inbounds i32, i32* %37, i64 4
%40 = bitcast i32* %39 to <4 x i32>*
store <4 x i32> %36, <4 x i32>* %40
%41 = or i64 %19, 24
%42 = add <4 x i32> %20, <i32 24, i32 24, i32 24, i32 24>
%43 = add <4 x i32> %20, <i32 28, i32 28, i32 28, i32 28>
%44 = getelementptr inbounds i32, i32* %3, i64 %41
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %42, <4 x i32>* %45
%46 = getelementptr inbounds i32, i32* %44, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> %43, <4 x i32>* %47
%48 = add nuw i64 %19, 32
%49 = add <4 x i32> %20, <i32 32, i32 32, i32 32, i32 32>
%50 = add i64 %21, 4
%51 = icmp eq i64 %50, %17
br i1 %51, label %52, label %18
52: ; preds = %18, %9
%53 = phi i64 [ 0, %9 ], [ %48, %18 ]
%54 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %9 ], [ %49, %18 ]
%55 = icmp eq i64 %14, 0
br i1 %55, label %69, label %56
56: ; preds = %52, %56
%57 = phi i64 [ %65, %56 ], [ %53, %52 ]
%58 = phi <4 x i32> [ %66, %56 ], [ %54, %52 ]
%59 = phi i64 [ %67, %56 ], [ 0, %52 ]
%60 = add <4 x i32> %58, <i32 4, i32 4, i32 4, i32 4>
%61 = getelementptr inbounds i32, i32* %3, i64 %57
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %62
%63 = getelementptr inbounds i32, i32* %61, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %64
%65 = add nuw i64 %57, 8
%66 = add <4 x i32> %58, <i32 8, i32 8, i32 8, i32 8>
%67 = add i64 %59, 1
%68 = icmp eq i64 %67, %14
br i1 %68, label %69, label %56
69: ; preds = %56, %52
%70 = icmp eq i64 %10, %7
br i1 %70, label %79, label %71
71: ; preds = %6, %69
%72 = phi i64 [ 0, %6 ], [ %10, %69 ]
br label %73
73: ; preds = %71, %73
%74 = phi i64 [ %77, %73 ], [ %72, %71 ]
%75 = getelementptr inbounds i32, i32* %3, i64 %74
%76 = trunc i64 %74 to i32
store i32 %76, i32* %75
%77 = add nuw nsw i64 %74, 1
%78 = icmp eq i64 %77, %7
br i1 %78, label %79, label %73
79: ; preds = %73, %69, %4
%80 = icmp sgt i32 %1, %2
br i1 %80, label %81, label %385
81: ; preds = %79
%82 = icmp sgt i32 %2, 0
br i1 %82, label %83, label %700
83: ; preds = %81
%84 = zext i32 %2 to i64
%85 = sext i32 %1 to i64
%86 = zext i32 %2 to i64
%87 = zext i32 %1 to i64
%88 = zext i32 %1 to i64
%89 = add nuw nsw i64 %86, 1
%90 = shl nuw nsw i64 %86, 3
%91 = add nuw nsw i64 %90, 8
%92 = shl nuw nsw i64 %86, 1
%93 = getelementptr double, double* %0, i64 1
%94 = bitcast double* %93 to i8*
%95 = getelementptr double, double* %0, i64 %86
%96 = and i64 %84, 4294967292
%97 = add nsw i64 %96, -4
%98 = lshr exact i64 %97, 2
%99 = add nuw nsw i64 %98, 1
%100 = icmp ult i32 %2, 4
%101 = and i64 %86, 4294967292
%102 = and i64 %99, 1
%103 = icmp eq i64 %97, 0
%104 = and i64 %99, 9223372036854775806
%105 = icmp eq i64 %102, 0
%106 = icmp eq i64 %101, %86
%107 = and i64 %84, 1
%108 = icmp eq i64 %107, 0
%109 = sub nsw i64 0, %84
%110 = sub nsw i64 0, %84
br label %111
111: ; preds = %83, %382
%112 = phi i64 [ 0, %83 ], [ %134, %382 ]
%113 = phi i64 [ 1, %83 ], [ %383, %382 ]
%114 = mul i64 %112, %86
%115 = getelementptr double, double* %0, i64 %114
%116 = add i64 %114, %86
%117 = getelementptr double, double* %0, i64 %116
%118 = xor i64 %112, -1
%119 = add nsw i64 %118, %86
%120 = mul i64 %91, %112
%121 = mul i64 %112, %86
%122 = add i64 %92, %121
%123 = getelementptr i8, i8* %94, i64 %120
%124 = add i64 %121, %86
%125 = getelementptr double, double* %0, i64 %124
%126 = bitcast double* %125 to i8*
%127 = trunc i64 %112 to i32
%128 = mul nsw i64 %112, %84
%129 = mul nsw i32 %127, %2
%130 = sext i32 %129 to i64
%131 = add nsw i64 %112, %130
%132 = getelementptr inbounds double, double* %0, i64 %131
%133 = load double, double* %132
%134 = add nuw nsw i64 %112, 1
%135 = icmp slt i64 %134, %85
br i1 %135, label %136, label %153
136: ; preds = %111
%137 = tail call double @llvm.fabs.f64(double %133)
br label %138
138: ; preds = %136, %138
%139 = phi i64 [ %113, %136 ], [ %151, %138 ]
%140 = phi double [ %137, %136 ], [ %150, %138 ]
%141 = phi i32 [ %127, %136 ], [ %149, %138 ]
%142 = mul nsw i64 %139, %84
%143 = add nuw nsw i64 %142, %112
%144 = getelementptr inbounds double, double* %0, i64 %143
%145 = load double, double* %144
%146 = tail call double @llvm.fabs.f64(double %145)
%147 = fcmp olt double %140, %146
%148 = trunc i64 %139 to i32
%149 = select i1 %147, i32 %148, i32 %141
%150 = select i1 %147, double %145, double %140
%151 = add nuw nsw i64 %139, 1
%152 = icmp eq i64 %151, %87
br i1 %152, label %153, label %138
153: ; preds = %138, %111
%154 = phi i32 [ %127, %111 ], [ %149, %138 ]
%155 = zext i32 %154 to i64
%156 = icmp eq i64 %112, %155
br i1 %156, label %280, label %157
157: ; preds = %153
%158 = sext i32 %154 to i64
%159 = getelementptr inbounds i32, i32* %3, i64 %158
%160 = load i32, i32* %159
%161 = getelementptr inbounds i32, i32* %3, i64 %112
%162 = load i32, i32* %161
store i32 %162, i32* %159
store i32 %160, i32* %161
%163 = mul nsw i32 %154, %2
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %0, i64 %164
%166 = getelementptr inbounds double, double* %0, i64 %128
br i1 %100, label %247, label %167
167: ; preds = %157
%168 = getelementptr double, double* %95, i64 %164
%169 = icmp ult double* %115, %168
%170 = icmp ult double* %165, %117
%171 = and i1 %169, %170
%172 = icmp ult double* %115, %117
%173 = or i1 %171, %172
%174 = icmp ult double* %165, %117
%175 = icmp ult double* %115, %168
%176 = and i1 %174, %175
%177 = or i1 %173, %176
br i1 %177, label %247, label %178
178: ; preds = %167
br i1 %103, label %224, label %179
179: ; preds = %178, %179
%180 = phi i64 [ %221, %179 ], [ 0, %178 ]
%181 = phi i64 [ %222, %179 ], [ 0, %178 ]
%182 = add nuw nsw i64 %180, %128
%183 = getelementptr inbounds double, double* %0, i64 %182
%184 = bitcast double* %183 to <2 x double>*
%185 = load <2 x double>, <2 x double>* %184
%186 = getelementptr inbounds double, double* %183, i64 2
%187 = bitcast double* %186 to <2 x double>*
%188 = load <2 x double>, <2 x double>* %187
%189 = getelementptr inbounds double, double* %165, i64 %180
%190 = bitcast double* %189 to <2 x double>*
%191 = load <2 x double>, <2 x double>* %190
%192 = getelementptr inbounds double, double* %189, i64 2
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = getelementptr inbounds double, double* %166, i64 %180
%196 = bitcast double* %195 to <2 x double>*
store <2 x double> %191, <2 x double>* %196
%197 = getelementptr inbounds double, double* %195, i64 2
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> %194, <2 x double>* %198
%199 = bitcast double* %189 to <2 x double>*
store <2 x double> %185, <2 x double>* %199
%200 = bitcast double* %192 to <2 x double>*
store <2 x double> %188, <2 x double>* %200
%201 = or i64 %180, 4
%202 = add nuw nsw i64 %201, %128
%203 = getelementptr inbounds double, double* %0, i64 %202
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = getelementptr inbounds double, double* %203, i64 2
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = getelementptr inbounds double, double* %165, i64 %201
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = getelementptr inbounds double, double* %209, i64 2
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = getelementptr inbounds double, double* %166, i64 %201
%216 = bitcast double* %215 to <2 x double>*
store <2 x double> %211, <2 x double>* %216
%217 = getelementptr inbounds double, double* %215, i64 2
%218 = bitcast double* %217 to <2 x double>*
store <2 x double> %214, <2 x double>* %218
%219 = bitcast double* %209 to <2 x double>*
store <2 x double> %205, <2 x double>* %219
%220 = bitcast double* %212 to <2 x double>*
store <2 x double> %208, <2 x double>* %220
%221 = add nuw i64 %180, 8
%222 = add i64 %181, 2
%223 = icmp eq i64 %222, %104
br i1 %223, label %224, label %179
224: ; preds = %179, %178
%225 = phi i64 [ 0, %178 ], [ %221, %179 ]
br i1 %105, label %246, label %226
226: ; preds = %224
%227 = add nuw nsw i64 %225, %128
%228 = getelementptr inbounds double, double* %0, i64 %227
%229 = bitcast double* %228 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = getelementptr inbounds double, double* %228, i64 2
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = getelementptr inbounds double, double* %165, i64 %225
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = getelementptr inbounds double, double* %234, i64 2
%238 = bitcast double* %237 to <2 x double>*
%239 = load <2 x double>, <2 x double>* %238
%240 = getelementptr inbounds double, double* %166, i64 %225
%241 = bitcast double* %240 to <2 x double>*
store <2 x double> %236, <2 x double>* %241
%242 = getelementptr inbounds double, double* %240, i64 2
%243 = bitcast double* %242 to <2 x double>*
store <2 x double> %239, <2 x double>* %243
%244 = bitcast double* %234 to <2 x double>*
store <2 x double> %230, <2 x double>* %244
%245 = bitcast double* %237 to <2 x double>*
store <2 x double> %233, <2 x double>* %245
br label %246
246: ; preds = %224, %226
br i1 %106, label %278, label %247
247: ; preds = %167, %157, %246
%248 = phi i64 [ 0, %167 ], [ 0, %157 ], [ %101, %246 ]
%249 = xor i64 %248, -1
br i1 %108, label %258, label %250
250: ; preds = %247
%251 = add nuw nsw i64 %248, %128
%252 = getelementptr inbounds double, double* %0, i64 %251
%253 = load double, double* %252
%254 = getelementptr inbounds double, double* %165, i64 %248
%255 = load double, double* %254
%256 = getelementptr inbounds double, double* %166, i64 %248
store double %255, double* %256
store double %253, double* %254
%257 = or i64 %248, 1
br label %258
258: ; preds = %250, %247
%259 = phi i64 [ %248, %247 ], [ %257, %250 ]
%260 = icmp eq i64 %249, %109
br i1 %260, label %278, label %261
261: ; preds = %258, %261
%262 = phi i64 [ %276, %261 ], [ %259, %258 ]
%263 = add nuw nsw i64 %262, %128
%264 = getelementptr inbounds double, double* %0, i64 %263
%265 = load double, double* %264
%266 = getelementptr inbounds double, double* %165, i64 %262
%267 = load double, double* %266
%268 = getelementptr inbounds double, double* %166, i64 %262
store double %267, double* %268
store double %265, double* %266
%269 = add nuw nsw i64 %262, 1
%270 = add nuw nsw i64 %269, %128
%271 = getelementptr inbounds double, double* %0, i64 %270
%272 = load double, double* %271
%273 = getelementptr inbounds double, double* %165, i64 %269
%274 = load double, double* %273
%275 = getelementptr inbounds double, double* %166, i64 %269
store double %274, double* %275
store double %272, double* %273
%276 = add nuw nsw i64 %262, 2
%277 = icmp eq i64 %276, %86
br i1 %277, label %278, label %261
278: ; preds = %258, %261, %246
%279 = load double, double* %132
br label %280
280: ; preds = %278, %153
%281 = phi double [ %279, %278 ], [ %133, %153 ]
%282 = fcmp une double %281, 0.000000e+00
%283 = select i1 %282, i1 %135, i1 false
br i1 %283, label %284, label %382
284: ; preds = %280
%285 = icmp ult i64 %134, %84
%286 = icmp ult i64 %119, 4
%287 = and i64 %119, -4
%288 = add i64 %113, %287
%289 = icmp eq i64 %119, %287
br label %290
290: ; preds = %284, %378
%291 = phi i64 [ 0, %284 ], [ %381, %378 ]
%292 = phi i64 [ %113, %284 ], [ %379, %378 ]
%293 = mul i64 %291, %86
%294 = add i64 %89, %293
%295 = getelementptr double, double* %0, i64 %294
%296 = bitcast double* %295 to i8*
%297 = getelementptr i8, i8* %296, i64 %120
%298 = add i64 %122, %293
%299 = getelementptr double, double* %0, i64 %298
%300 = bitcast double* %299 to i8*
%301 = mul nsw i64 %292, %84
%302 = add nuw nsw i64 %301, %112
%303 = getelementptr inbounds double, double* %0, i64 %302
%304 = load double, double* %303
%305 = fdiv double %304, %281
store double %305, double* %303
br i1 %285, label %306, label %378
306: ; preds = %290
%307 = fneg double %305
br i1 %286, label %341, label %308
308: ; preds = %306
%309 = icmp ult i8* %297, %126
%310 = icmp ult i8* %123, %300
%311 = and i1 %309, %310
br i1 %311, label %341, label %312
312: ; preds = %308
%313 = insertelement <2 x double> poison, double %307, i64 0
%314 = shufflevector <2 x double> %313, <2 x double> poison, <2 x i32> zeroinitializer
%315 = insertelement <2 x double> poison, double %307, i64 0
%316 = shufflevector <2 x double> %315, <2 x double> poison, <2 x i32> zeroinitializer
br label %317
317: ; preds = %317, %312
%318 = phi i64 [ 0, %312 ], [ %338, %317 ]
%319 = add i64 %113, %318
%320 = add nuw nsw i64 %319, %128
%321 = getelementptr inbounds double, double* %0, i64 %320
%322 = bitcast double* %321 to <2 x double>*
%323 = load <2 x double>, <2 x double>* %322
%324 = getelementptr inbounds double, double* %321, i64 2
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = add nuw nsw i64 %319, %301
%328 = getelementptr inbounds double, double* %0, i64 %327
%329 = bitcast double* %328 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329
%331 = getelementptr inbounds double, double* %328, i64 2
%332 = bitcast double* %331 to <2 x double>*
%333 = load <2 x double>, <2 x double>* %332
%334 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %314, <2 x double> %323, <2 x double> %330)
%335 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %316, <2 x double> %326, <2 x double> %333)
%336 = bitcast double* %328 to <2 x double>*
store <2 x double> %334, <2 x double>* %336
%337 = bitcast double* %331 to <2 x double>*
store <2 x double> %335, <2 x double>* %337
%338 = add nuw i64 %318, 4
%339 = icmp eq i64 %338, %287
br i1 %339, label %340, label %317
340: ; preds = %317
br i1 %289, label %378, label %341
341: ; preds = %308, %306, %340
%342 = phi i64 [ %113, %308 ], [ %113, %306 ], [ %288, %340 ]
%343 = sub i64 %84, %342
%344 = xor i64 %342, -1
%345 = and i64 %343, 1
%346 = icmp eq i64 %345, 0
br i1 %346, label %356, label %347
347: ; preds = %341
%348 = add nuw nsw i64 %342, %128
%349 = getelementptr inbounds double, double* %0, i64 %348
%350 = load double, double* %349
%351 = add nuw nsw i64 %342, %301
%352 = getelementptr inbounds double, double* %0, i64 %351
%353 = load double, double* %352
%354 = tail call double @llvm.fmuladd.f64(double %307, double %350, double %353)
store double %354, double* %352
%355 = add nuw nsw i64 %342, 1
br label %356
356: ; preds = %347, %341
%357 = phi i64 [ %342, %341 ], [ %355, %347 ]
%358 = icmp eq i64 %344, %110
br i1 %358, label %378, label %359
359: ; preds = %356, %359
%360 = phi i64 [ %376, %359 ], [ %357, %356 ]
%361 = add nuw nsw i64 %360, %128
%362 = getelementptr inbounds double, double* %0, i64 %361
%363 = load double, double* %362
%364 = add nuw nsw i64 %360, %301
%365 = getelementptr inbounds double, double* %0, i64 %364
%366 = load double, double* %365
%367 = tail call double @llvm.fmuladd.f64(double %307, double %363, double %366)
store double %367, double* %365
%368 = add nuw nsw i64 %360, 1
%369 = add nuw nsw i64 %368, %128
%370 = getelementptr inbounds double, double* %0, i64 %369
%371 = load double, double* %370
%372 = add nuw nsw i64 %368, %301
%373 = getelementptr inbounds double, double* %0, i64 %372
%374 = load double, double* %373
%375 = tail call double @llvm.fmuladd.f64(double %307, double %371, double %374)
store double %375, double* %373
%376 = add nuw nsw i64 %360, 2
%377 = icmp eq i64 %376, %86
br i1 %377, label %378, label %359
378: ; preds = %356, %359, %340, %290
%379 = add nuw nsw i64 %292, 1
%380 = icmp eq i64 %379, %88
%381 = add i64 %291, 1
br i1 %380, label %382, label %290
382: ; preds = %378, %280
%383 = add nuw nsw i64 %113, 1
%384 = icmp eq i64 %134, %86
br i1 %384, label %700, label %111
385: ; preds = %79
%386 = icmp slt i32 %1, %2
br i1 %386, label %387, label %696
387: ; preds = %385
%388 = icmp sgt i32 %1, 1
br i1 %388, label %389, label %700
389: ; preds = %387
%390 = add nsw i32 %1, -1
%391 = icmp sgt i32 %2, 0
%392 = sext i32 %2 to i64
%393 = zext i32 %1 to i64
%394 = zext i32 %390 to i64
%395 = zext i32 %1 to i64
%396 = zext i32 %2 to i64
%397 = zext i32 %1 to i64
%398 = zext i32 %2 to i64
%399 = add nsw i64 %392, 1
%400 = shl nsw i64 %392, 3
%401 = add nsw i64 %400, 8
%402 = add nsw i64 %392, %396
%403 = getelementptr double, double* %0, i64 1
%404 = bitcast double* %403 to i8*
%405 = getelementptr double, double* %0, i64 %396
%406 = and i64 %396, 4294967292
%407 = add nsw i64 %406, -4
%408 = lshr exact i64 %407, 2
%409 = add nuw nsw i64 %408, 1
%410 = icmp ult i32 %2, 4
%411 = and i64 %396, 4294967292
%412 = and i64 %409, 1
%413 = icmp eq i64 %407, 0
%414 = and i64 %409, 9223372036854775806
%415 = icmp eq i64 %412, 0
%416 = icmp eq i64 %411, %396
%417 = and i64 %396, 1
%418 = icmp eq i64 %417, 0
%419 = sub nsw i64 0, %396
%420 = sub nsw i64 0, %396
br label %421
421: ; preds = %389, %693
%422 = phi i64 [ 0, %389 ], [ %444, %693 ]
%423 = phi i64 [ 1, %389 ], [ %694, %693 ]
%424 = mul i64 %422, %392
%425 = getelementptr double, double* %0, i64 %424
%426 = add i64 %424, %396
%427 = getelementptr double, double* %0, i64 %426
%428 = xor i64 %422, -1
%429 = add nsw i64 %428, %396
%430 = mul i64 %401, %422
%431 = mul i64 %422, %392
%432 = add i64 %402, %431
%433 = getelementptr i8, i8* %404, i64 %430
%434 = add i64 %431, %396
%435 = getelementptr double, double* %0, i64 %434
%436 = bitcast double* %435 to i8*
%437 = trunc i64 %422 to i32
%438 = mul nsw i64 %422, %392
%439 = mul nsw i32 %437, %2
%440 = sext i32 %439 to i64
%441 = add nsw i64 %422, %440
%442 = getelementptr inbounds double, double* %0, i64 %441
%443 = load double, double* %442
%444 = add nuw nsw i64 %422, 1
%445 = icmp ult i64 %444, %393
br i1 %445, label %446, label %463
446: ; preds = %421
%447 = tail call double @llvm.fabs.f64(double %443)
br label %448
448: ; preds = %446, %448
%449 = phi i64 [ %423, %446 ], [ %461, %448 ]
%450 = phi double [ %447, %446 ], [ %460, %448 ]
%451 = phi i32 [ %437, %446 ], [ %459, %448 ]
%452 = mul nsw i64 %449, %392
%453 = add nsw i64 %452, %422
%454 = getelementptr inbounds double, double* %0, i64 %453
%455 = load double, double* %454
%456 = tail call double @llvm.fabs.f64(double %455)
%457 = fcmp olt double %450, %456
%458 = trunc i64 %449 to i32
%459 = select i1 %457, i32 %458, i32 %451
%460 = select i1 %457, double %455, double %450
%461 = add nuw nsw i64 %449, 1
%462 = icmp eq i64 %461, %395
br i1 %462, label %463, label %448
463: ; preds = %448, %421
%464 = phi i32 [ %437, %421 ], [ %459, %448 ]
%465 = zext i32 %464 to i64
%466 = icmp eq i64 %422, %465
br i1 %466, label %591, label %467
467: ; preds = %463
%468 = sext i32 %464 to i64
%469 = getelementptr inbounds i32, i32* %3, i64 %468
%470 = load i32, i32* %469
%471 = getelementptr inbounds i32, i32* %3, i64 %422
%472 = load i32, i32* %471
store i32 %472, i32* %469
store i32 %470, i32* %471
br i1 %391, label %473, label %591
473: ; preds = %467
%474 = mul nsw i32 %464, %2
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %0, i64 %475
%477 = getelementptr inbounds double, double* %0, i64 %438
br i1 %410, label %558, label %478
478: ; preds = %473
%479 = getelementptr double, double* %405, i64 %475
%480 = icmp ult double* %425, %479
%481 = icmp ult double* %476, %427
%482 = and i1 %480, %481
%483 = icmp ult double* %425, %427
%484 = or i1 %482, %483
%485 = icmp ult double* %476, %427
%486 = icmp ult double* %425, %479
%487 = and i1 %485, %486
%488 = or i1 %484, %487
br i1 %488, label %558, label %489
489: ; preds = %478
br i1 %413, label %535, label %490
490: ; preds = %489, %490
%491 = phi i64 [ %532, %490 ], [ 0, %489 ]
%492 = phi i64 [ %533, %490 ], [ 0, %489 ]
%493 = add nsw i64 %491, %438
%494 = getelementptr inbounds double, double* %0, i64 %493
%495 = bitcast double* %494 to <2 x double>*
%496 = load <2 x double>, <2 x double>* %495
%497 = getelementptr inbounds double, double* %494, i64 2
%498 = bitcast double* %497 to <2 x double>*
%499 = load <2 x double>, <2 x double>* %498
%500 = getelementptr inbounds double, double* %476, i64 %491
%501 = bitcast double* %500 to <2 x double>*
%502 = load <2 x double>, <2 x double>* %501
%503 = getelementptr inbounds double, double* %500, i64 2
%504 = bitcast double* %503 to <2 x double>*
%505 = load <2 x double>, <2 x double>* %504
%506 = getelementptr inbounds double, double* %477, i64 %491
%507 = bitcast double* %506 to <2 x double>*
store <2 x double> %502, <2 x double>* %507
%508 = getelementptr inbounds double, double* %506, i64 2
%509 = bitcast double* %508 to <2 x double>*
store <2 x double> %505, <2 x double>* %509
%510 = bitcast double* %500 to <2 x double>*
store <2 x double> %496, <2 x double>* %510
%511 = bitcast double* %503 to <2 x double>*
store <2 x double> %499, <2 x double>* %511
%512 = or i64 %491, 4
%513 = add nsw i64 %512, %438
%514 = getelementptr inbounds double, double* %0, i64 %513
%515 = bitcast double* %514 to <2 x double>*
%516 = load <2 x double>, <2 x double>* %515
%517 = getelementptr inbounds double, double* %514, i64 2
%518 = bitcast double* %517 to <2 x double>*
%519 = load <2 x double>, <2 x double>* %518
%520 = getelementptr inbounds double, double* %476, i64 %512
%521 = bitcast double* %520 to <2 x double>*
%522 = load <2 x double>, <2 x double>* %521
%523 = getelementptr inbounds double, double* %520, i64 2
%524 = bitcast double* %523 to <2 x double>*
%525 = load <2 x double>, <2 x double>* %524
%526 = getelementptr inbounds double, double* %477, i64 %512
%527 = bitcast double* %526 to <2 x double>*
store <2 x double> %522, <2 x double>* %527
%528 = getelementptr inbounds double, double* %526, i64 2
%529 = bitcast double* %528 to <2 x double>*
store <2 x double> %525, <2 x double>* %529
%530 = bitcast double* %520 to <2 x double>*
store <2 x double> %516, <2 x double>* %530
%531 = bitcast double* %523 to <2 x double>*
store <2 x double> %519, <2 x double>* %531
%532 = add nuw i64 %491, 8
%533 = add i64 %492, 2
%534 = icmp eq i64 %533, %414
br i1 %534, label %535, label %490
535: ; preds = %490, %489
%536 = phi i64 [ 0, %489 ], [ %532, %490 ]
br i1 %415, label %557, label %537
537: ; preds = %535
%538 = add nsw i64 %536, %438
%539 = getelementptr inbounds double, double* %0, i64 %538
%540 = bitcast double* %539 to <2 x double>*
%541 = load <2 x double>, <2 x double>* %540
%542 = getelementptr inbounds double, double* %539, i64 2
%543 = bitcast double* %542 to <2 x double>*
%544 = load <2 x double>, <2 x double>* %543
%545 = getelementptr inbounds double, double* %476, i64 %536
%546 = bitcast double* %545 to <2 x double>*
%547 = load <2 x double>, <2 x double>* %546
%548 = getelementptr inbounds double, double* %545, i64 2
%549 = bitcast double* %548 to <2 x double>*
%550 = load <2 x double>, <2 x double>* %549
%551 = getelementptr inbounds double, double* %477, i64 %536
%552 = bitcast double* %551 to <2 x double>*
store <2 x double> %547, <2 x double>* %552
%553 = getelementptr inbounds double, double* %551, i64 2
%554 = bitcast double* %553 to <2 x double>*
store <2 x double> %550, <2 x double>* %554
%555 = bitcast double* %545 to <2 x double>*
store <2 x double> %541, <2 x double>* %555
%556 = bitcast double* %548 to <2 x double>*
store <2 x double> %544, <2 x double>* %556
br label %557
557: ; preds = %535, %537
br i1 %416, label %589, label %558
558: ; preds = %478, %473, %557
%559 = phi i64 [ 0, %478 ], [ 0, %473 ], [ %411, %557 ]
%560 = xor i64 %559, -1
br i1 %418, label %569, label %561
561: ; preds = %558
%562 = add nsw i64 %559, %438
%563 = getelementptr inbounds double, double* %0, i64 %562
%564 = load double, double* %563
%565 = getelementptr inbounds double, double* %476, i64 %559
%566 = load double, double* %565
%567 = getelementptr inbounds double, double* %477, i64 %559
store double %566, double* %567
store double %564, double* %565
%568 = or i64 %559, 1
br label %569
569: ; preds = %561, %558
%570 = phi i64 [ %559, %558 ], [ %568, %561 ]
%571 = icmp eq i64 %560, %419
br i1 %571, label %589, label %572
572: ; preds = %569, %572
%573 = phi i64 [ %587, %572 ], [ %570, %569 ]
%574 = add nsw i64 %573, %438
%575 = getelementptr inbounds double, double* %0, i64 %574
%576 = load double, double* %575
%577 = getelementptr inbounds double, double* %476, i64 %573
%578 = load double, double* %577
%579 = getelementptr inbounds double, double* %477, i64 %573
store double %578, double* %579
store double %576, double* %577
%580 = add nuw nsw i64 %573, 1
%581 = add nsw i64 %580, %438
%582 = getelementptr inbounds double, double* %0, i64 %581
%583 = load double, double* %582
%584 = getelementptr inbounds double, double* %476, i64 %580
%585 = load double, double* %584
%586 = getelementptr inbounds double, double* %477, i64 %580
store double %585, double* %586
store double %583, double* %584
%587 = add nuw nsw i64 %573, 2
%588 = icmp eq i64 %587, %396
br i1 %588, label %589, label %572
589: ; preds = %569, %572, %557
%590 = load double, double* %442
br label %591
591: ; preds = %589, %467, %463
%592 = phi double [ %590, %589 ], [ %443, %467 ], [ %443, %463 ]
%593 = fcmp une double %592, 0.000000e+00
%594 = select i1 %593, i1 %445, i1 false
br i1 %594, label %595, label %693
595: ; preds = %591
%596 = icmp slt i64 %444, %392
%597 = icmp ult i64 %429, 4
%598 = and i64 %429, -4
%599 = add i64 %423, %598
%600 = icmp eq i64 %429, %598
br label %601
601: ; preds = %595, %689
%602 = phi i64 [ 0, %595 ], [ %692, %689 ]
%603 = phi i64 [ %423, %595 ], [ %690, %689 ]
%604 = mul i64 %602, %392
%605 = add i64 %399, %604
%606 = getelementptr double, double* %0, i64 %605
%607 = bitcast double* %606 to i8*
%608 = getelementptr i8, i8* %607, i64 %430
%609 = add i64 %432, %604
%610 = getelementptr double, double* %0, i64 %609
%611 = bitcast double* %610 to i8*
%612 = mul nsw i64 %603, %392
%613 = add nsw i64 %612, %422
%614 = getelementptr inbounds double, double* %0, i64 %613
%615 = load double, double* %614
%616 = fdiv double %615, %592
store double %616, double* %614
br i1 %596, label %617, label %689
617: ; preds = %601
%618 = fneg double %616
br i1 %597, label %652, label %619
619: ; preds = %617
%620 = icmp ult i8* %608, %436
%621 = icmp ult i8* %433, %611
%622 = and i1 %620, %621
br i1 %622, label %652, label %623
623: ; preds = %619
%624 = insertelement <2 x double> poison, double %618, i64 0
%625 = shufflevector <2 x double> %624, <2 x double> poison, <2 x i32> zeroinitializer
%626 = insertelement <2 x double> poison, double %618, i64 0
%627 = shufflevector <2 x double> %626, <2 x double> poison, <2 x i32> zeroinitializer
br label %628
628: ; preds = %628, %623
%629 = phi i64 [ 0, %623 ], [ %649, %628 ]
%630 = add i64 %423, %629
%631 = add nsw i64 %630, %438
%632 = getelementptr inbounds double, double* %0, i64 %631
%633 = bitcast double* %632 to <2 x double>*
%634 = load <2 x double>, <2 x double>* %633
%635 = getelementptr inbounds double, double* %632, i64 2
%636 = bitcast double* %635 to <2 x double>*
%637 = load <2 x double>, <2 x double>* %636
%638 = add nsw i64 %630, %612
%639 = getelementptr inbounds double, double* %0, i64 %638
%640 = bitcast double* %639 to <2 x double>*
%641 = load <2 x double>, <2 x double>* %640
%642 = getelementptr inbounds double, double* %639, i64 2
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %625, <2 x double> %634, <2 x double> %641)
%646 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %627, <2 x double> %637, <2 x double> %644)
%647 = bitcast double* %639 to <2 x double>*
store <2 x double> %645, <2 x double>* %647
%648 = bitcast double* %642 to <2 x double>*
store <2 x double> %646, <2 x double>* %648
%649 = add nuw i64 %629, 4
%650 = icmp eq i64 %649, %598
br i1 %650, label %651, label %628
651: ; preds = %628
br i1 %600, label %689, label %652
652: ; preds = %619, %617, %651
%653 = phi i64 [ %423, %619 ], [ %423, %617 ], [ %599, %651 ]
%654 = sub i64 %396, %653
%655 = xor i64 %653, -1
%656 = and i64 %654, 1
%657 = icmp eq i64 %656, 0
br i1 %657, label %667, label %658
658: ; preds = %652
%659 = add nsw i64 %653, %438
%660 = getelementptr inbounds double, double* %0, i64 %659
%661 = load double, double* %660
%662 = add nsw i64 %653, %612
%663 = getelementptr inbounds double, double* %0, i64 %662
%664 = load double, double* %663
%665 = tail call double @llvm.fmuladd.f64(double %618, double %661, double %664)
store double %665, double* %663
%666 = add nuw nsw i64 %653, 1
br label %667
667: ; preds = %658, %652
%668 = phi i64 [ %653, %652 ], [ %666, %658 ]
%669 = icmp eq i64 %655, %420
br i1 %669, label %689, label %670
670: ; preds = %667, %670
%671 = phi i64 [ %687, %670 ], [ %668, %667 ]
%672 = add nsw i64 %671, %438
%673 = getelementptr inbounds double, double* %0, i64 %672
%674 = load double, double* %673
%675 = add nsw i64 %671, %612
%676 = getelementptr inbounds double, double* %0, i64 %675
%677 = load double, double* %676
%678 = tail call double @llvm.fmuladd.f64(double %618, double %674, double %677)
store double %678, double* %676
%679 = add nuw nsw i64 %671, 1
%680 = add nsw i64 %679, %438
%681 = getelementptr inbounds double, double* %0, i64 %680
%682 = load double, double* %681
%683 = add nsw i64 %679, %612
%684 = getelementptr inbounds double, double* %0, i64 %683
%685 = load double, double* %684
%686 = tail call double @llvm.fmuladd.f64(double %618, double %682, double %685)
store double %686, double* %684
%687 = add nuw nsw i64 %671, 2
%688 = icmp eq i64 %687, %398
br i1 %688, label %689, label %670
689: ; preds = %667, %670, %651, %601
%690 = add nuw nsw i64 %603, 1
%691 = icmp eq i64 %690, %397
%692 = add i64 %602, 1
br i1 %691, label %693, label %601
693: ; preds = %689, %591
%694 = add nuw nsw i64 %423, 1
%695 = icmp eq i64 %444, %394
br i1 %695, label %700, label %421
696: ; preds = %385
%697 = icmp eq i32 %1, %2
br i1 %697, label %698, label %700
698: ; preds = %696
%699 = tail call i32 @pludecomp(double* %0, i32 %1, i32* %3)
br label %700
700: ; preds = %693, %382, %387, %81, %698, %696
ret i32 0
}