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


x86 assembly (clang, -O0):
<pludecomp>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    113e <pludecomp+0x3e>
mov    -0x1c(%rbp),%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    1116 <pludecomp+0x16>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13f4 <pludecomp+0x2f4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe8d(%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    11fb <pludecomp+0xfb>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe47(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11e8 <pludecomp+0xe8>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%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    11ed <pludecomp+0xed>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118b <pludecomp+0x8b>
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     12d7 <pludecomp+0x1d7>
mov    -0x1c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
imul   -0xc(%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    -0xc(%rbp),%eax
jge    12d2 <pludecomp+0x1d2>
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    1254 <pludecomp+0x154>
jmp    12d7 <pludecomp+0x1d7>
mov    -0x1c(%rbp),%eax
imul   -0xc(%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    1315 <pludecomp+0x215>
jp     1315 <pludecomp+0x215>
jmp    13e1 <pludecomp+0x2e1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13dc <pludecomp+0x2dc>
mov    -0x20(%rbp),%eax
imul   -0xc(%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    -0xc(%rbp),%eax
jge    13c9 <pludecomp+0x2c9>
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    1362 <pludecomp+0x262>
jmp    13ce <pludecomp+0x2ce>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    131e <pludecomp+0x21e>
jmp    13e1 <pludecomp+0x2e1>
jmp    13e6 <pludecomp+0x2e6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1145 <pludecomp+0x45>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<pludecomp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x70,%rsp
mov    %rdx,-0x58(%rsp)
mov    %rsi,-0x80(%rsp)
test   %esi,%esi
jle    18b1 <pludecomp+0x7b1>
mov    %rdi,%r8
mov    -0x80(%rsp),%rcx
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    113b <pludecomp+0x3b>
xor    %ecx,%ecx
mov    -0x58(%rsp),%rbp
jmp    1290 <pludecomp+0x190>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
mov    -0x58(%rsp),%rbp
jae    116e <pludecomp+0x6e>
movdqa 0xe99(%rip),%xmm0
xor    %edi,%edi
jmp    1239 <pludecomp+0x139>
and    $0xfffffffffffffffc,%rsi
movdqa 0xe86(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe8b(%rip),%xmm8
movdqa 0xe92(%rip),%xmm9
movdqa 0xe99(%rip),%xmm10
movdqa 0xea1(%rip),%xmm4
movdqa 0xea9(%rip),%xmm5
movdqa 0xeb1(%rip),%xmm6
movdqa 0xeb9(%rip),%xmm7
movdqa 0xec1(%rip),%xmm1
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x0(%rbp,%rdi,4)
movdqu %xmm2,0x10(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbp,%rdi,4)
movdqu %xmm3,0x30(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbp,%rdi,4)
movdqu %xmm3,0x50(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbp,%rdi,4)
movdqu %xmm3,0x70(%rbp,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    11c0 <pludecomp+0xc0>
test   %rdx,%rdx
je     1280 <pludecomp+0x180>
lea    0x10(,%rdi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xdb9(%rip),%xmm1
movdqa 0xdc1(%rip),%xmm2
nop
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1260 <pludecomp+0x160>
cmp    %rax,%rcx
je     129d <pludecomp+0x19d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1290 <pludecomp+0x190>
cmpl   $0x2,-0x80(%rsp)
jl     18b1 <pludecomp+0x7b1>
mov    -0x80(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x30(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x58(%rsp)
lea    0x8(,%rax,8),%rcx
mov    %rcx,0x20(%rsp)
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x18(%rsp)
lea    0x8(%r8),%rcx
mov    %rcx,-0x50(%rsp)
lea    (%r8,%rax,8),%rcx
mov    %rcx,0x10(%rsp)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,-0x8(%rsp)
mov    %rdx,%rcx
mov    %rdx,(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x10(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,-0x20(%rsp)
lea    (%r8,%rax,8),%rbp
lea    0x0(,%rax,8),%r14
lea    0x8(,%rax,8),%rcx
mov    %rcx,0x28(%rsp)
lea    0x30(%r8),%rcx
movapd 0xd47(%rip),%xmm0
pxor   %xmm8,%xmm8
movapd 0xd49(%rip),%xmm9
lea    -0x1(%rax),%rdx
mov    %rdx,-0x38(%rsp)
lea    0x18(%r8),%rbx
lea    0x18(%r8,%rax,8),%rdx
mov    %rdx,-0x40(%rsp)
lea    0x8(%r8,%rax,8),%rdx
mov    %rdx,-0x48(%rsp)
mov    $0x1,%edx
mov    %rdx,-0x78(%rsp)
xor    %edx,%edx
mov    %r8,%rdi
mov    %rcx,-0x18(%rsp)
mov    %rcx,%rsi
jmp    13e1 <pludecomp+0x2e1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,-0x78(%rsp)
mov    0x38(%rsp),%rbp
mov    0x28(%rsp),%rcx
add    %rcx,%rbp
mov    -0x30(%rsp),%rsi
add    %r14,%rsi
add    %r14,%rdi
addq   $0xffffffffffffffff,-0x38(%rsp)
add    %rcx,%rbx
add    %rcx,-0x40(%rsp)
add    %r14,-0x48(%rsp)
mov    -0x28(%rsp),%rdx
cmp    0x30(%rsp),%rdx
je     18b1 <pludecomp+0x7b1>
mov    %rdx,%r15
mov    %rdx,%rcx
imul   %rax,%rcx
mov    %rcx,%rdx
mov    %rcx,-0x70(%rsp)
lea    (%rcx,%rax,1),%rdx
mov    %r15d,%ecx
imul   -0x80(%rsp),%ecx
movslq %ecx,%r11
add    %r15,%r11
movsd  (%r8,%r11,8),%xmm3
lea    0x1(%r15),%rcx
cmp    %rax,%rcx
mov    %rbp,0x38(%rsp)
mov    %rsi,-0x30(%rsp)
mov    %rcx,-0x28(%rsp)
jae    1480 <pludecomp+0x380>
movapd %xmm3,%xmm5
andpd  %xmm0,%xmm5
mov    -0x78(%rsp),%rcx
mov    %r15d,%esi
movapd %xmm5,%xmm4
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm6
movapd %xmm6,%xmm7
andpd  %xmm0,%xmm7
ucomisd %xmm5,%xmm7
cmova  %ecx,%esi
cmpltsd %xmm7,%xmm4
andpd  %xmm4,%xmm6
andnpd %xmm5,%xmm4
orpd   %xmm6,%xmm4
add    $0x1,%rcx
add    %r14,%rbp
movapd %xmm4,%xmm5
cmp    %rcx,%rax
jne    1440 <pludecomp+0x340>
jmp    1483 <pludecomp+0x383>
nopw   0x0(%rax,%rax,1)
mov    %r15d,%esi
lea    (%r8,%rdx,8),%r13
mov    %r15,%rcx
imul   %rax,%rcx
mov    %rcx,-0x68(%rsp)
mov    %esi,%ecx
cmp    %rcx,%r15
mov    %r15,-0x60(%rsp)
je     16a6 <pludecomp+0x5a6>
movslq %esi,%r10
mov    %r15,%rcx
mov    -0x80(%rsp),%r15
imul   %r15d,%esi
mov    -0x58(%rsp),%rdx
mov    (%rdx,%r10,4),%r9d
mov    (%rdx,%rcx,4),%ebp
mov    %ebp,(%rdx,%r10,4)
mov    %r9d,(%rdx,%rcx,4)
movslq %esi,%r10
lea    (%r8,%r10,8),%r12
mov    -0x68(%rsp),%rcx
lea    (%r8,%rcx,8),%r9
cmp    $0x4,%r15d
jae    1570 <pludecomp+0x470>
xor    %edx,%edx
mov    -0x60(%rsp),%r15
mov    %rdx,%rcx
test   $0x1,%al
je     1515 <pludecomp+0x415>
mov    -0x68(%rsp),%rcx
add    %rdx,%rcx
movsd  (%r8,%rcx,8),%xmm3
movsd  (%r12,%rdx,8),%xmm4
movsd  %xmm4,(%r9,%rdx,8)
movsd  %xmm3,(%r12,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    -0x20(%rsp),%rdx
je     16a0 <pludecomp+0x5a0>
mov    -0x50(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm3
movsd  -0x8(%rdx,%rcx,8),%xmm4
movsd  %xmm4,(%rdi,%rcx,8)
movsd  %xmm3,-0x8(%rdx,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm3
movsd  (%rdx,%rcx,8),%xmm4
movsd  %xmm4,0x8(%rdi,%rcx,8)
movsd  %xmm3,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1530 <pludecomp+0x430>
jmp    16a0 <pludecomp+0x5a0>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rcx
lea    (%r8,%rcx,8),%rdx
mov    0x10(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%rdx
setb   %bpl
cmp    %r13,%r12
setb   %cl
and    %bpl,%cl
jne    14e0 <pludecomp+0x3e0>
cmp    %r13,%rdx
mov    -0x60(%rsp),%r15
jb     18aa <pludecomp+0x7aa>
mov    $0x0,%edx
test   %cl,%cl
jne    14e7 <pludecomp+0x3e7>
cmpq   $0x0,0x8(%rsp)
mov    -0x30(%rsp),%rsi
je     1899 <pludecomp+0x799>
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
mov    -0x10(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rsi,%rdx,8),%xmm3
movups -0x20(%rsi,%rdx,8),%xmm4
movups -0x30(%rcx,%rdx,8),%xmm5
movups -0x20(%rcx,%rdx,8),%xmm6
movups %xmm5,-0x30(%rsi,%rdx,8)
movups %xmm6,-0x20(%rsi,%rdx,8)
movups %xmm3,-0x30(%rcx,%rdx,8)
movups %xmm4,-0x20(%rcx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm3
movupd (%rsi,%rdx,8),%xmm4
movupd -0x10(%rcx,%rdx,8),%xmm5
movupd (%rcx,%rdx,8),%xmm6
movupd %xmm5,-0x10(%rsi,%rdx,8)
movupd %xmm6,(%rsi,%rdx,8)
movupd %xmm3,-0x10(%rcx,%rdx,8)
movupd %xmm4,(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbp
jne    15e0 <pludecomp+0x4e0>
testb  $0x1,(%rsp)
je     1680 <pludecomp+0x580>
mov    -0x68(%rsp),%rcx
add    %rdx,%rcx
movupd (%r8,%rcx,8),%xmm3
movupd 0x10(%r8,%rcx,8),%xmm4
movupd (%r12,%rdx,8),%xmm5
movupd 0x10(%r12,%rdx,8),%xmm6
movupd %xmm5,(%r9,%rdx,8)
movupd %xmm6,0x10(%r9,%rdx,8)
movupd %xmm3,(%r12,%rdx,8)
movupd %xmm4,0x10(%r12,%rdx,8)
mov    -0x8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
jne    14e7 <pludecomp+0x3e7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%r11,8),%xmm3
mov    %r13,0x68(%rsp)
ucomisd %xmm8,%xmm3
jne    16b8 <pludecomp+0x5b8>
jnp    13a0 <pludecomp+0x2a0>
cmp    %rax,-0x28(%rsp)
jae    13a0 <pludecomp+0x2a0>
mov    0x20(%rsp),%rsi
imul   %r15,%rsi
mov    -0x38(%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r15,%r13
not    %r13
add    %rax,%r13
mov    -0x70(%rsp),%rcx
add    0x18(%rsp),%rcx
mov    %rcx,-0x70(%rsp)
mov    -0x50(%rsp),%rcx
mov    %rsi,0x60(%rsp)
add    %rsi,%rcx
mov    %rcx,0x50(%rsp)
mov    %r13,%rcx
and    $0xfffffffffffffffc,%rcx
mov    -0x78(%rsp),%r9
mov    %rcx,0x48(%rsp)
add    %r9,%rcx
mov    %rcx,0x40(%rsp)
mov    -0x48(%rsp),%rbp
mov    -0x40(%rsp),%r12
xor    %r10d,%r10d
jmp    174c <pludecomp+0x64c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x1,%r10
add    %r14,%r12
add    %r14,%rbp
cmp    %rax,%r9
mov    -0x60(%rsp),%r15
je     13a0 <pludecomp+0x2a0>
mov    %r9,%r11
imul   %rax,%r11
lea    (%r11,%r15,1),%rcx
movsd  (%r8,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%r8,%rcx,8)
xorpd  %xmm9,%xmm4
mov    -0x78(%rsp),%r15
cmp    $0x4,%r13
jb     1810 <pludecomp+0x710>
mov    %r10,%rcx
imul   %rax,%rcx
mov    0x58(%rsp),%rsi
add    %rcx,%rsi
lea    (%r8,%rsi,8),%rsi
add    0x60(%rsp),%rsi
cmp    0x68(%rsp),%rsi
jae    17af <pludecomp+0x6af>
add    -0x70(%rsp),%rcx
lea    (%r8,%rcx,8),%rcx
mov    -0x78(%rsp),%r15
cmp    %rcx,0x50(%rsp)
jb     1810 <pludecomp+0x710>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd -0x10(%rbx,%rcx,8),%xmm6
movupd (%rbx,%rcx,8),%xmm7
movupd -0x10(%r12,%rcx,8),%xmm1
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm5,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm5,%xmm7
addpd  %xmm2,%xmm7
movupd %xmm6,-0x10(%r12,%rcx,8)
movupd %xmm7,(%r12,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    17c0 <pludecomp+0x6c0>
mov    0x40(%rsp),%r15
cmp    0x48(%rsp),%r13
je     1730 <pludecomp+0x630>
xchg   %ax,%ax
mov    %eax,%esi
sub    %r15d,%esi
mov    %r15,%rcx
test   $0x1,%sil
je     1843 <pludecomp+0x743>
mov    -0x68(%rsp),%rcx
add    %r15,%rcx
add    %r15,%r11
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r8,%r11,8),%xmm1
movsd  %xmm1,(%r8,%r11,8)
lea    0x1(%r15),%rcx
not    %r15
cmp    -0x20(%rsp),%r15
je     1730 <pludecomp+0x630>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  -0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1860 <pludecomp+0x760>
jmp    1730 <pludecomp+0x630>
xor    %edx,%edx
testb  $0x1,(%rsp)
jne    1644 <pludecomp+0x544>
jmp    1680 <pludecomp+0x580>
xor    %edx,%edx
jmp    14e7 <pludecomp+0x3e7>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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