#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 */
float fabs(float);
float fabsf(float);
int pludecomp(float *A, int N, int *ipiv) {
  int k, j, l, c1, c2, mind, tempi;
  float ld, mult, mval, temp;
  for (k = 0; k < N; ++k)
    ipiv[k] = k;
  for (k = 0; k < N - 1; ++k) {
    mval = fabsf(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
sub    $0x50,%rsp
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    1152 <pludecomp+0x42>
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    112a <pludecomp+0x1a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1406 <pludecomp+0x2f6>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xe79(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x40(%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    1212 <pludecomp+0x102>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  -0x48(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    11ff <pludecomp+0xef>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1204 <pludecomp+0xf4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119f <pludecomp+0x8f>
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     12ee <pludecomp+0x1de>
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    12e9 <pludecomp+0x1d9>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    126b <pludecomp+0x15b>
jmp    12ee <pludecomp+0x1de>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1330 <pludecomp+0x220>
jp     1330 <pludecomp+0x220>
jmp    13f3 <pludecomp+0x2e3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ee <pludecomp+0x2de>
mov    -0x20(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
movss  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  %xmm0,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13db <pludecomp+0x2cb>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    137d <pludecomp+0x26d>
jmp    13e0 <pludecomp+0x2d0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1339 <pludecomp+0x229>
jmp    13f3 <pludecomp+0x2e3>
jmp    13f8 <pludecomp+0x2e8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1159 <pludecomp+0x49>
xor    %eax,%eax
add    $0x50,%rsp
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    1891 <pludecomp+0x791>
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     1891 <pludecomp+0x791>
mov    -0x80(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x30(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x58(%rsp)
lea    0x4(,%rax,4),%rcx
mov    %rcx,0x20(%rsp)
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x18(%rsp)
lea    0x4(%r8),%rcx
mov    %rcx,-0x50(%rsp)
lea    (%r8,%rax,4),%rcx
mov    %rcx,0x10(%rsp)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x8(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    %rdx,-0x8(%rsp)
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
or     $0x2,%rsi
mov    %rcx,%rdx
mov    %rcx,(%rsp)
and    %rcx,%rsi
mov    %rsi,-0x10(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,-0x20(%rsp)
lea    (%r8,%rax,4),%rbp
lea    0x0(,%rax,4),%r14
lea    0x4(,%rax,4),%rcx
mov    %rcx,0x28(%rsp)
lea    0x30(%r8),%rcx
movaps 0xd3e(%rip),%xmm0
pxor   %xmm8,%xmm8
movaps 0xd41(%rip),%xmm9
lea    -0x1(%rax),%rdx
mov    %rdx,-0x38(%rsp)
lea    0x14(%r8),%rbx
lea    0x14(%r8,%rax,4),%rdx
mov    %rdx,-0x40(%rsp)
lea    0x4(%r8,%rax,4),%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>
nopl   0x0(%rax)
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     1891 <pludecomp+0x791>
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
movss  (%r8,%r11,4),%xmm3
lea    0x1(%r15),%rcx
cmp    %rax,%rcx
mov    %rbp,0x38(%rsp)
mov    %rsi,-0x30(%rsp)
mov    %rcx,-0x28(%rsp)
jae    1470 <pludecomp+0x370>
movaps %xmm3,%xmm5
andps  %xmm0,%xmm5
mov    -0x78(%rsp),%rcx
mov    %r15d,%esi
movaps %xmm5,%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp),%xmm6
movaps %xmm6,%xmm7
andps  %xmm0,%xmm7
ucomiss %xmm5,%xmm7
cmova  %ecx,%esi
cmpltss %xmm7,%xmm4
andps  %xmm4,%xmm6
andnps %xmm5,%xmm4
orps   %xmm6,%xmm4
add    $0x1,%rcx
add    %r14,%rbp
movaps %xmm4,%xmm5
cmp    %rcx,%rax
jne    1440 <pludecomp+0x340>
jmp    1473 <pludecomp+0x373>
mov    %r15d,%esi
lea    (%r8,%rdx,4),%r13
mov    %r15,%rcx
imul   %rax,%rcx
mov    %rcx,-0x68(%rsp)
mov    %esi,%ecx
cmp    %rcx,%r15
mov    %r15,-0x60(%rsp)
je     1686 <pludecomp+0x586>
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,4),%r12
mov    -0x68(%rsp),%rcx
lea    (%r8,%rcx,4),%r9
cmp    $0x8,%r15d
jae    1560 <pludecomp+0x460>
xor    %edx,%edx
mov    -0x60(%rsp),%r15
mov    %rdx,%rcx
test   $0x1,%al
je     1505 <pludecomp+0x405>
mov    -0x68(%rsp),%rcx
add    %rdx,%rcx
movss  (%r8,%rcx,4),%xmm3
movss  (%r12,%rdx,4),%xmm4
movss  %xmm4,(%r9,%rdx,4)
movss  %xmm3,(%r12,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    -0x20(%rsp),%rdx
je     1680 <pludecomp+0x580>
mov    -0x50(%rsp),%rdx
lea    (%rdx,%r10,4),%rdx
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm3
movss  -0x4(%rdx,%rcx,4),%xmm4
movss  %xmm4,(%rdi,%rcx,4)
movss  %xmm3,-0x4(%rdx,%rcx,4)
movss  0x4(%rdi,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rdi,%rcx,4)
movss  %xmm3,(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1520 <pludecomp+0x420>
jmp    1680 <pludecomp+0x580>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rcx
lea    (%r8,%rcx,4),%rdx
mov    0x10(%rsp),%rcx
lea    (%rcx,%r10,4),%rcx
cmp    %rcx,%rdx
setb   %bpl
cmp    %r13,%r12
setb   %cl
and    %bpl,%cl
jne    14d0 <pludecomp+0x3d0>
cmp    %r13,%rdx
mov    -0x60(%rsp),%r15
jb     188a <pludecomp+0x78a>
mov    $0x0,%edx
test   %cl,%cl
jne    14d7 <pludecomp+0x3d7>
cmpq   $0x0,0x8(%rsp)
mov    -0x30(%rsp),%rsi
je     1879 <pludecomp+0x779>
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r10,4),%rcx
mov    -0x10(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rsi,%rdx,4),%xmm3
movups -0x20(%rsi,%rdx,4),%xmm4
movups -0x30(%rcx,%rdx,4),%xmm5
movups -0x20(%rcx,%rdx,4),%xmm6
movups %xmm5,-0x30(%rsi,%rdx,4)
movups %xmm6,-0x20(%rsi,%rdx,4)
movups %xmm3,-0x30(%rcx,%rdx,4)
movups %xmm4,-0x20(%rcx,%rdx,4)
movups -0x10(%rsi,%rdx,4),%xmm3
movups (%rsi,%rdx,4),%xmm4
movups -0x10(%rcx,%rdx,4),%xmm5
movups (%rcx,%rdx,4),%xmm6
movups %xmm5,-0x10(%rsi,%rdx,4)
movups %xmm6,(%rsi,%rdx,4)
movups %xmm3,-0x10(%rcx,%rdx,4)
movups %xmm4,(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbp
jne    15d0 <pludecomp+0x4d0>
testb  $0x1,(%rsp)
je     1660 <pludecomp+0x560>
mov    -0x68(%rsp),%rcx
add    %rdx,%rcx
movups (%r8,%rcx,4),%xmm3
movups 0x10(%r8,%rcx,4),%xmm4
movups (%r12,%rdx,4),%xmm5
movups 0x10(%r12,%rdx,4),%xmm6
movups %xmm5,(%r9,%rdx,4)
movups %xmm6,0x10(%r9,%rdx,4)
movups %xmm3,(%r12,%rdx,4)
movups %xmm4,0x10(%r12,%rdx,4)
mov    -0x8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
jne    14d7 <pludecomp+0x3d7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r8,%r11,4),%xmm3
mov    %r13,0x68(%rsp)
ucomiss %xmm8,%xmm3
jne    1697 <pludecomp+0x597>
jnp    13a0 <pludecomp+0x2a0>
cmp    %rax,-0x28(%rsp)
jae    13a0 <pludecomp+0x2a0>
mov    0x20(%rsp),%rsi
imul   %r15,%rsi
mov    -0x38(%rsp),%rdx
and    $0xfffffffffffffff8,%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    $0xfffffffffffffff8,%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    172c <pludecomp+0x62c>
cs 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
movss  (%r8,%rcx,4),%xmm4
divss  %xmm3,%xmm4
movss  %xmm4,(%r8,%rcx,4)
xorps  %xmm9,%xmm4
mov    -0x78(%rsp),%r15
cmp    $0x8,%r13
jb     17f0 <pludecomp+0x6f0>
mov    %r10,%rcx
imul   %rax,%rcx
mov    0x58(%rsp),%rsi
add    %rcx,%rsi
lea    (%r8,%rsi,4),%rsi
add    0x60(%rsp),%rsi
cmp    0x68(%rsp),%rsi
jae    178e <pludecomp+0x68e>
add    -0x70(%rsp),%rcx
lea    (%r8,%rcx,4),%rcx
mov    -0x78(%rsp),%r15
cmp    %rcx,0x50(%rsp)
jb     17f0 <pludecomp+0x6f0>
movaps %xmm4,%xmm5
shufps $0x0,%xmm4,%xmm5
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rcx,4),%xmm6
movups (%rbx,%rcx,4),%xmm7
movups -0x10(%r12,%rcx,4),%xmm1
movups (%r12,%rcx,4),%xmm2
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
mulps  %xmm5,%xmm7
addps  %xmm2,%xmm7
movups %xmm6,-0x10(%r12,%rcx,4)
movups %xmm7,(%r12,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    17a0 <pludecomp+0x6a0>
mov    0x40(%rsp),%r15
cmp    0x48(%rsp),%r13
je     1710 <pludecomp+0x610>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%esi
sub    %r15d,%esi
mov    %r15,%rcx
test   $0x1,%sil
je     1823 <pludecomp+0x723>
mov    -0x68(%rsp),%rcx
add    %r15,%rcx
add    %r15,%r11
movss  (%r8,%rcx,4),%xmm1
mulss  %xmm4,%xmm1
addss  (%r8,%r11,4),%xmm1
movss  %xmm1,(%r8,%r11,4)
lea    0x1(%r15),%rcx
not    %r15
cmp    -0x20(%rsp),%r15
je     1710 <pludecomp+0x610>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm1
mulss  %xmm4,%xmm1
addss  -0x4(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0x4(%rbp,%rcx,4)
movss  0x4(%rdi,%rcx,4),%xmm1
mulss  %xmm4,%xmm1
addss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1840 <pludecomp+0x740>
jmp    1710 <pludecomp+0x610>
xor    %edx,%edx
testb  $0x1,(%rsp)
jne    162c <pludecomp+0x52c>
jmp    1660 <pludecomp+0x560>
xor    %edx,%edx
jmp    14d7 <pludecomp+0x3d7>
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(float* %0, i32 %1, i32* %2) {
%4 = alloca float*
%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 float
%15 = alloca float
%16 = alloca float
%17 = alloca float
store float* %0, float** %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 = %219, %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 %222
37: ; preds = %32
%38 = load float*, float** %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 float, float* %38, i64 %44
%46 = load float, float* %45
%47 = call float @llvm.fabs.f32(float %46)
store float %47, float* %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 float, float* %16
%57 = load float*, float** %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 float, float* %57, i64 %63
%65 = load float, float* %64
%66 = call float @fabs(float %65)
%67 = fcmp olt float %56, %66
br i1 %67, label %68, label %79
68: ; preds = %55
%69 = load float*, float** %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 float, float* %69, i64 %75
%77 = load float, float* %76
store float %77, float* %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 float*, float** %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 float, float* %118, i64 %122
%124 = load float, float* %123
store float %124, float* %17
%125 = load float*, float** %4
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
%129 = load i32, i32* %8
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %128, i64 %130
%132 = load float, float* %131
%133 = load float*, float** %4
%134 = load i32, i32* %10
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
%137 = load i32, i32* %8
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %136, i64 %138
store float %132, float* %139
%140 = load float, float* %17
%141 = load float*, float** %4
%142 = load i32, i32* %11
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %141, i64 %143
%145 = load i32, i32* %8
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
store float %140, float* %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 float*, float** %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 float, float* %156, i64 %160
%162 = load float, float* %161
store float %162, float* %14
%163 = load float, float* %14
%164 = fpext float %163 to double
%165 = fcmp une double %164, 0.000000e+00
br i1 %165, label %166, label %218
166: ; preds = %152
%167 = load i32, i32* %7
%168 = add nsw i32 %167, 1
store i32 %168, i32* %8
br label %169
169: ; preds = %214, %166
%170 = load i32, i32* %8
%171 = load i32, i32* %5
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %217
173: ; preds = %169
%174 = load i32, i32* %8
%175 = load i32, i32* %5
%176 = mul nsw i32 %174, %175
store i32 %176, i32* %10
%177 = load float, float* %14
%178 = load float*, float** %4
%179 = load i32, i32* %10
%180 = load i32, i32* %7
%181 = add nsw i32 %179, %180
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %178, i64 %182
%184 = load float, float* %183
%185 = fdiv float %184, %177
store float %185, float* %183
store float %185, float* %15
%186 = load i32, i32* %7
%187 = add nsw i32 %186, 1
store i32 %187, i32* %9
br label %188
188: ; preds = %210, %173
%189 = load i32, i32* %9
%190 = load i32, i32* %5
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %213
192: ; preds = %188
%193 = load float, float* %15
%194 = load float*, float** %4
%195 = load i32, i32* %11
%196 = load i32, i32* %9
%197 = add nsw i32 %195, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %194, i64 %198
%200 = load float, float* %199
%201 = load float*, float** %4
%202 = load i32, i32* %10
%203 = load i32, i32* %9
%204 = add nsw i32 %202, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %201, i64 %205
%207 = load float, float* %206
%208 = fneg float %193
%209 = call float @llvm.fmuladd.f32(float %208, float %200, float %207)
store float %209, float* %206
br label %210
210: ; preds = %192
%211 = load i32, i32* %9
%212 = add nsw i32 %211, 1
store i32 %212, i32* %9
br label %188
213: ; preds = %188
br label %214
214: ; preds = %213
%215 = load i32, i32* %8
%216 = add nsw i32 %215, 1
store i32 %216, i32* %8
br label %169
217: ; preds = %169
br label %218
218: ; preds = %217, %152
br label %219
219: ; preds = %218
%220 = load i32, i32* %7
%221 = add nsw i32 %220, 1
store i32 %221, i32* %7
br label %32
222: ; preds = %32
ret i32 0
}

LLVM IR (-O2):
define i32 @pludecomp(float* 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, 2
%83 = add nuw nsw i64 %82, 4
%84 = shl nuw nsw i64 %6, 1
%85 = getelementptr float, float* %0, i64 1
%86 = bitcast float* %85 to i8*
%87 = getelementptr float, float* %0, i64 %6
%88 = and i64 %76, 4294967288
%89 = add nsw i64 %88, -8
%90 = lshr exact i64 %89, 3
%91 = add nuw nsw i64 %90, 1
%92 = icmp ult i32 %1, 8
%93 = and i64 %6, 4294967288
%94 = and i64 %91, 1
%95 = icmp eq i64 %89, 0
%96 = and i64 %91, 4611686018427387902
%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 float, float* %0, i64 %112
%114 = add i64 %112, %6
%115 = getelementptr float, float* %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 float, float* %0, i64 %122
%124 = bitcast float* %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 float, float* %0, i64 %129
%131 = load float, float* %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 float @llvm.fabs.f32(float %131)
br label %136
136: ; preds = %134, %136
%137 = phi i64 [ %111, %134 ], [ %149, %136 ]
%138 = phi float [ %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 float, float* %0, i64 %141
%143 = load float, float* %142
%144 = tail call float @llvm.fabs.f32(float %143)
%145 = fcmp olt float %138, %144
%146 = trunc i64 %137 to i32
%147 = select i1 %145, i32 %146, i32 %139
%148 = select i1 %145, float %143, float %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 float, float* %0, i64 %162
%164 = getelementptr inbounds float, float* %0, i64 %126
br i1 %92, label %245, label %165
165: ; preds = %155
%166 = getelementptr float, float* %87, i64 %162
%167 = icmp ult float* %113, %166
%168 = icmp ult float* %163, %115
%169 = and i1 %167, %168
%170 = icmp ult float* %113, %115
%171 = or i1 %169, %170
%172 = icmp ult float* %163, %115
%173 = icmp ult float* %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 float, float* %0, i64 %180
%182 = bitcast float* %181 to <4 x float>*
%183 = load <4 x float>, <4 x float>* %182
%184 = getelementptr inbounds float, float* %181, i64 4
%185 = bitcast float* %184 to <4 x float>*
%186 = load <4 x float>, <4 x float>* %185
%187 = getelementptr inbounds float, float* %163, i64 %178
%188 = bitcast float* %187 to <4 x float>*
%189 = load <4 x float>, <4 x float>* %188
%190 = getelementptr inbounds float, float* %187, i64 4
%191 = bitcast float* %190 to <4 x float>*
%192 = load <4 x float>, <4 x float>* %191
%193 = getelementptr inbounds float, float* %164, i64 %178
%194 = bitcast float* %193 to <4 x float>*
store <4 x float> %189, <4 x float>* %194
%195 = getelementptr inbounds float, float* %193, i64 4
%196 = bitcast float* %195 to <4 x float>*
store <4 x float> %192, <4 x float>* %196
%197 = bitcast float* %187 to <4 x float>*
store <4 x float> %183, <4 x float>* %197
%198 = bitcast float* %190 to <4 x float>*
store <4 x float> %186, <4 x float>* %198
%199 = or i64 %178, 8
%200 = add nuw nsw i64 %199, %126
%201 = getelementptr inbounds float, float* %0, i64 %200
%202 = bitcast float* %201 to <4 x float>*
%203 = load <4 x float>, <4 x float>* %202
%204 = getelementptr inbounds float, float* %201, i64 4
%205 = bitcast float* %204 to <4 x float>*
%206 = load <4 x float>, <4 x float>* %205
%207 = getelementptr inbounds float, float* %163, i64 %199
%208 = bitcast float* %207 to <4 x float>*
%209 = load <4 x float>, <4 x float>* %208
%210 = getelementptr inbounds float, float* %207, i64 4
%211 = bitcast float* %210 to <4 x float>*
%212 = load <4 x float>, <4 x float>* %211
%213 = getelementptr inbounds float, float* %164, i64 %199
%214 = bitcast float* %213 to <4 x float>*
store <4 x float> %209, <4 x float>* %214
%215 = getelementptr inbounds float, float* %213, i64 4
%216 = bitcast float* %215 to <4 x float>*
store <4 x float> %212, <4 x float>* %216
%217 = bitcast float* %207 to <4 x float>*
store <4 x float> %203, <4 x float>* %217
%218 = bitcast float* %210 to <4 x float>*
store <4 x float> %206, <4 x float>* %218
%219 = add nuw i64 %178, 16
%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 float, float* %0, i64 %225
%227 = bitcast float* %226 to <4 x float>*
%228 = load <4 x float>, <4 x float>* %227
%229 = getelementptr inbounds float, float* %226, i64 4
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = getelementptr inbounds float, float* %163, i64 %223
%233 = bitcast float* %232 to <4 x float>*
%234 = load <4 x float>, <4 x float>* %233
%235 = getelementptr inbounds float, float* %232, i64 4
%236 = bitcast float* %235 to <4 x float>*
%237 = load <4 x float>, <4 x float>* %236
%238 = getelementptr inbounds float, float* %164, i64 %223
%239 = bitcast float* %238 to <4 x float>*
store <4 x float> %234, <4 x float>* %239
%240 = getelementptr inbounds float, float* %238, i64 4
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> %237, <4 x float>* %241
%242 = bitcast float* %232 to <4 x float>*
store <4 x float> %228, <4 x float>* %242
%243 = bitcast float* %235 to <4 x float>*
store <4 x float> %231, <4 x float>* %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 float, float* %0, i64 %249
%251 = load float, float* %250
%252 = getelementptr inbounds float, float* %163, i64 %246
%253 = load float, float* %252
%254 = getelementptr inbounds float, float* %164, i64 %246
store float %253, float* %254
store float %251, float* %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 float, float* %0, i64 %261
%263 = load float, float* %262
%264 = getelementptr inbounds float, float* %163, i64 %260
%265 = load float, float* %264
%266 = getelementptr inbounds float, float* %164, i64 %260
store float %265, float* %266
store float %263, float* %264
%267 = add nuw nsw i64 %260, 1
%268 = add nuw nsw i64 %267, %126
%269 = getelementptr inbounds float, float* %0, i64 %268
%270 = load float, float* %269
%271 = getelementptr inbounds float, float* %163, i64 %267
%272 = load float, float* %271
%273 = getelementptr inbounds float, float* %164, i64 %267
store float %272, float* %273
store float %270, float* %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 float, float* %130
br label %278
278: ; preds = %276, %151
%279 = phi float [ %277, %276 ], [ %131, %151 ]
%280 = fcmp une float %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, 8
%284 = and i64 %117, -8
%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 float, float* %0, i64 %292
%294 = load float, float* %293
%295 = fdiv float %294, %279
store float %295, float* %293
%296 = fneg float %295
br i1 %283, label %337, label %297
297: ; preds = %287
%298 = add i64 %120, %290
%299 = getelementptr float, float* %0, i64 %298
%300 = bitcast float* %299 to i8*
%301 = add i64 %81, %290
%302 = getelementptr float, float* %0, i64 %301
%303 = bitcast float* %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 <4 x float> poison, float %296, i64 0
%310 = shufflevector <4 x float> %309, <4 x float> poison, <4 x i32> zeroinitializer
%311 = insertelement <4 x float> poison, float %296, i64 0
%312 = shufflevector <4 x float> %311, <4 x float> poison, <4 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 float, float* %0, i64 %316
%318 = bitcast float* %317 to <4 x float>*
%319 = load <4 x float>, <4 x float>* %318
%320 = getelementptr inbounds float, float* %317, i64 4
%321 = bitcast float* %320 to <4 x float>*
%322 = load <4 x float>, <4 x float>* %321
%323 = add nuw nsw i64 %315, %291
%324 = getelementptr inbounds float, float* %0, i64 %323
%325 = bitcast float* %324 to <4 x float>*
%326 = load <4 x float>, <4 x float>* %325
%327 = getelementptr inbounds float, float* %324, i64 4
%328 = bitcast float* %327 to <4 x float>*
%329 = load <4 x float>, <4 x float>* %328
%330 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %310, <4 x float> %319, <4 x float> %326)
%331 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %312, <4 x float> %322, <4 x float> %329)
%332 = bitcast float* %324 to <4 x float>*
store <4 x float> %330, <4 x float>* %332
%333 = bitcast float* %327 to <4 x float>*
store <4 x float> %331, <4 x float>* %333
%334 = add nuw i64 %314, 8
%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 float, float* %0, i64 %344
%346 = load float, float* %345
%347 = add nuw nsw i64 %338, %291
%348 = getelementptr inbounds float, float* %0, i64 %347
%349 = load float, float* %348
%350 = tail call float @llvm.fmuladd.f32(float %296, float %346, float %349)
store float %350, float* %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 float, float* %0, i64 %357
%359 = load float, float* %358
%360 = add nuw nsw i64 %356, %291
%361 = getelementptr inbounds float, float* %0, i64 %360
%362 = load float, float* %361
%363 = tail call float @llvm.fmuladd.f32(float %296, float %359, float %362)
store float %363, float* %361
%364 = add nuw nsw i64 %356, 1
%365 = add nuw nsw i64 %364, %126
%366 = getelementptr inbounds float, float* %0, i64 %365
%367 = load float, float* %366
%368 = add nuw nsw i64 %364, %291
%369 = getelementptr inbounds float, float* %0, i64 %368
%370 = load float, float* %369
%371 = tail call float @llvm.fmuladd.f32(float %296, float %367, float %370)
store float %371, float* %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
}