#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 */
typedef int /*<<< orphan*/ u;

/* Variables and functions */
float fabs(float);
int /*<<< orphan*/ memcpy(float *, float const *, unsigned int);
void frlufact(float *u, unsigned int *p, const float *a, unsigned int d) {
  unsigned int i, j, k, mu;
  float f1, f2;
  if (u != a)
    memcpy(u, a, d * d * sizeof(u[0]));
  for (k = 0; k < d - 1; k++) {
    for (f1 = 0, i = mu = k; i < d; i++) {
      f2 = fabs(u[i * d + k]);
      if (f2 > f1) {
        f1 = f2;
        mu = i;
      }
    }
    p[k] = mu;
    for (i = k; i < d; i++)
      do {
        float z;
        z = (u[k * d + i]);
        (u[k * d + i]) = (u[mu * d + i]);
        (u[mu * d + i]) = z;
      } while (0);
    f1 = u[k * d + k];
    if (f1 != 0) {
      f1 = 1 / f1;
      for (i = k + 1; i < d; i++)
        u[i * d + k] *= f1;
      for (i = k + 1; i < d; i++)
        for (j = k + 1; j < d; j++)
          u[i * d + j] -= u[i * d + k] * u[k * d + j];
    }
  }
}


x86 assembly (clang, -O0):
<frlufact>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x18(%rbp),%rax
je     1161 <frlufact+0x41>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,%eax
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    13c3 <frlufact+0x2a3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    11e7 <frlufact+0xc7>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    11d4 <frlufact+0xb4>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    11d9 <frlufact+0xb9>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118a <frlufact+0x6a>
mov    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    127c <frlufact+0x15c>
jmp    120b <frlufact+0xeb>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
jmp    126e <frlufact+0x14e>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11fa <frlufact+0xda>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12b2 <frlufact+0x192>
jp     12b2 <frlufact+0x192>
jmp    13b0 <frlufact+0x290>
movss  0xd46(%rip),%xmm0
divss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1306 <frlufact+0x1e6>
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12cd <frlufact+0x1ad>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    13ab <frlufact+0x28b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1398 <frlufact+0x278>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
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    1324 <frlufact+0x204>
jmp    139d <frlufact+0x27d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    130f <frlufact+0x1ef>
jmp    13b0 <frlufact+0x290>
jmp    13b5 <frlufact+0x295>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1168 <frlufact+0x48>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<frlufact>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%r14d
mov    %rsi,0x90(%rsp)
mov    %rdi,%rbx
cmp    %rdx,%rdi
je     114b <frlufact+0x3b>
mov    %r14d,%eax
imul   %r14d,%eax
shl    $0x2,%eax
mov    %rbx,%rdi
mov    %rdx,%rsi
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    %r14d,%eax
add    $0xffffffff,%eax
je     1aef <frlufact+0x9df>
mov    %r14d,%r13d
mov    %eax,%eax
mov    %rax,0xb0(%rsp)
lea    -0x2(%r14),%eax
lea    0x4(%rbx),%rcx
mov    %rcx,0x98(%rsp)
lea    0x1(%r14),%r8d
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0x78(%rsp)
mov    %r14d,%ecx
neg    %ecx
mov    %ecx,0x5c(%rsp)
lea    (%r14,%r14,1),%r11d
lea    (%r14,%r14,8),%r15d
mov    %r14d,%ecx
shl    $0x4,%ecx
mov    %ecx,0x34(%rsp)
mov    $0x1,%ebp
xor    %esi,%esi
movaps 0xe54(%rip),%xmm0
xorps  %xmm1,%xmm1
movss  0xe68(%rip),%xmm8
movaps 0xe51(%rip),%xmm3
mov    %r8d,0x58(%rsp)
mov    %r8d,0x54(%rsp)
mov    %eax,0x70(%rsp)
mov    %eax,%ecx
mov    %r14d,%eax
mov    %rax,0x60(%rsp)
xor    %edx,%edx
mov    %r8d,0xc(%rsp)
mov    %r11d,0x30(%rsp)
mov    %r13,0xa0(%rsp)
jmp    1244 <frlufact+0x134>
mov    0xa0(%rsp),%r13
mov    0xc(%rsp),%r8d
mov    0x30(%rsp),%r11d
mov    0x28(%rsp),%r15
mov    0x8(%rsp),%ecx
mov    0x68(%rsp),%rsi
mov    0x48(%rsp),%rdi
add    $0x1,%rbp
add    %r14d,%r15d
mov    0x60(%rsp),%rax
add    %r14d,%eax
mov    %rax,0x60(%rsp)
add    $0xffffffff,%ecx
add    %r8d,0x54(%rsp)
add    %r14d,0x58(%rsp)
mov    %rdi,%rdx
cmp    0xb0(%rsp),%rdi
je     1aef <frlufact+0x9df>
mov    %rbp,0x10(%rsp)
mov    %esi,%r10d
cmp    %r13,%rdx
mov    %rdx,0x18(%rsp)
jae    1410 <frlufact+0x300>
mov    %ecx,0x8(%rsp)
mov    %r13d,%ecx
sub    %edx,%ecx
xorps  %xmm4,%xmm4
mov    %rdx,%rax
mov    %edx,%ebp
test   $0x1,%cl
je     1294 <frlufact+0x184>
mov    %edx,%eax
imul   %r14d,%eax
add    %edx,%eax
movss  (%rbx,%rax,4),%xmm5
xorps  %xmm4,%xmm4
ucomiss %xmm5,%xmm4
mov    %edx,%ebp
cmovne %edx,%ebp
je     1290 <frlufact+0x180>
andps  %xmm0,%xmm5
movaps %xmm5,%xmm4
lea    0x1(%rdx),%rax
mov    %r10,0x20(%rsp)
mov    %r15,0x28(%rsp)
mov    %rdx,%r12
not    %r12
cmp    0x78(%rsp),%r12
je     130a <frlufact+0x1fa>
lea    0x1(%rax),%esi
imul   %r14d,%esi
mov    0x18(%rsp),%rcx
add    %ecx,%esi
mov    %r14d,%edi
imul   %eax,%edi
add    %ecx,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edi,%edx
movss  (%rbx,%rdx,4),%xmm5
andps  %xmm0,%xmm5
ucomiss %xmm4,%xmm5
cmova  %eax,%ebp
maxss  %xmm4,%xmm5
lea    0x1(%rax),%edx
mov    %esi,%ecx
movss  (%rbx,%rcx,4),%xmm4
andps  %xmm0,%xmm4
ucomiss %xmm5,%xmm4
cmova  %edx,%ebp
maxss  %xmm5,%xmm4
add    $0x2,%rax
add    %r11d,%esi
add    %r11d,%edi
cmp    %rax,%r13
jne    12d0 <frlufact+0x1c0>
mov    0x18(%rsp),%rdx
mov    0x90(%rsp),%rax
mov    %ebp,(%rax,%rdx,4)
cmp    %r13,%rdx
mov    0x28(%rsp),%r15
mov    0x8(%rsp),%ecx
mov    0x20(%rsp),%r10
jae    141b <frlufact+0x30b>
mov    %edx,%eax
imul   %r14d,%eax
mov    %rax,0x38(%rsp)
imul   %r14d,%ebp
mov    %r13,%r10
sub    %rdx,%r10
mov    %rdx,%r8
cmp    $0x8,%r10
jae    1610 <frlufact+0x500>
mov    %r13d,%eax
sub    %r8d,%eax
mov    %r8,%rdx
test   $0x1,%al
mov    0x38(%rsp),%r9
je     1385 <frlufact+0x275>
lea    (%r9,%r8,1),%eax
movss  (%rbx,%rax,4),%xmm4
lea    (%r8,%rbp,1),%ecx
movss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,(%rbx,%rax,4)
movss  %xmm4,(%rbx,%rcx,4)
lea    0x1(%r8),%rdx
not    %r8
cmp    0x78(%rsp),%r8
mov    0x30(%rsp),%r11d
mov    0x34(%rsp),%r12d
je     13ee <frlufact+0x2de>
lea    (%r9,%rdx,1),%eax
add    %edx,%ebp
mov    %r13,%rcx
sub    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%edx
movss  (%rbx,%rdx,4),%xmm4
mov    %ebp,%esi
movss  (%rbx,%rsi,4),%xmm5
movss  %xmm5,(%rbx,%rdx,4)
movss  %xmm4,(%rbx,%rsi,4)
lea    0x1(%rax),%edx
movss  (%rbx,%rdx,4),%xmm4
lea    0x1(%rbp),%esi
movss  (%rbx,%rsi,4),%xmm5
movss  %xmm5,(%rbx,%rdx,4)
movss  %xmm4,(%rbx,%rsi,4)
add    $0x2,%eax
add    $0x2,%ebp
add    $0xfffffffffffffffe,%rcx
jne    13b0 <frlufact+0x2a0>
mov    0xc(%rsp),%r8d
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%ecx
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%r10
jmp    142c <frlufact+0x31c>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rax
mov    %edx,(%rax,%rdx,4)
mov    %edx,%r9d
imul   %r14d,%r9d
mov    0x34(%rsp),%r12d
mov    0x10(%rsp),%rbp
lea    0x1(%r10),%esi
lea    (%r9,%rdx,1),%eax
movss  (%rbx,%rax,4),%xmm5
ucomiss %xmm1,%xmm5
jne    1444 <frlufact+0x334>
jnp    14d0 <frlufact+0x3c0>
mov    %rdx,%rax
add    $0x1,%rax
mov    %rax,0x48(%rsp)
cmp    %r13,%rax
jae    120d <frlufact+0xfd>
mov    %ecx,0x8(%rsp)
mov    %ecx,%ecx
add    $0x1,%rcx
mov    0x70(%rsp),%eax
mov    %eax,%edi
sub    %r10d,%edi
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0x80(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rcx
movabs $0x1fffffff8,%rax
and    %rax,%rcx
mov    %rcx,0x40(%rsp)
movaps %xmm8,%xmm4
divss  %xmm5,%xmm4
mov    %rbp,%rcx
mov    %rdi,0x20(%rsp)
cmp    $0x7,%edi
mov    %rsi,0x68(%rsp)
jae    14dc <frlufact+0x3cc>
mov    %r14d,%eax
sub    %ecx,%eax
test   $0x1,%al
jne    1599 <frlufact+0x489>
mov    %rcx,%rax
jmp    15b6 <frlufact+0x4a6>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%rdi
jmp    1212 <frlufact+0x102>
lea    (%rsi,%rdx,1),%eax
add    0x20(%rsp),%eax
setb   %al
mov    %rbp,%rcx
cmp    $0x1,%r14d
jne    14b3 <frlufact+0x3a3>
mov    %rbp,%rcx
test   %al,%al
jne    14b3 <frlufact+0x3a3>
mov    0x40(%rsp),%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
movaps %xmm4,%xmm5
shufps $0x0,%xmm4,%xmm5
test   %rcx,%rcx
mov    %r15,0x28(%rsp)
je     173a <frlufact+0x62a>
mov    %rdx,%rbp
mov    0x80(%rsp),%rcx
lea    -0x8(%rcx),%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
add    %r15d,%edx
mov    0x60(%rsp),%rcx
lea    (%rcx,%rbp,1),%edi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %edi,%ebp
movups (%rbx,%rbp,4),%xmm6
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm5,%xmm6
mulps  %xmm5,%xmm7
movups %xmm6,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
mov    %edx,%ebp
movups (%rbx,%rbp,4),%xmm6
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm5,%xmm6
mulps  %xmm5,%xmm7
movups %xmm6,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
add    $0x10,%rcx
add    %r12d,%edx
add    %r12d,%edi
add    $0xfffffffffffffffe,%rsi
jne    1550 <frlufact+0x440>
jmp    173c <frlufact+0x62c>
mov    %ecx,%eax
imul   %r14d,%eax
add    %edx,%eax
movss  (%rbx,%rax,4),%xmm5
mulss  %xmm4,%xmm5
movss  %xmm5,(%rbx,%rax,4)
mov    %rcx,%rax
add    $0x1,%rax
mov    0x48(%rsp),%rdi
not    %ecx
cmp    0x5c(%rsp),%ecx
je     1790 <frlufact+0x680>
lea    0x1(%rax),%ecx
imul   %r14d,%ecx
mov    0x18(%rsp),%rsi
add    %esi,%ecx
mov    %r14d,%edx
sub    %eax,%edx
imul   %r14d,%eax
add    %esi,%eax
mov    %eax,%esi
movss  (%rbx,%rsi,4),%xmm5
mulss  %xmm4,%xmm5
movss  %xmm5,(%rbx,%rsi,4)
mov    %ecx,%esi
movss  (%rbx,%rsi,4),%xmm5
mulss  %xmm4,%xmm5
movss  %xmm5,(%rbx,%rsi,4)
add    %r11d,%ecx
add    %r11d,%eax
add    $0xfffffffe,%edx
jne    15e0 <frlufact+0x4d0>
jmp    1790 <frlufact+0x680>
mov    %rdx,%r9
add    %r13,%r12
mov    0xc(%rsp),%eax
mov    %eax,%esi
imul   %r9d,%esi
lea    (%rdx,%rbp,1),%r11d
mov    %r11d,%ecx
add    %r12d,%ecx
setb   %dl
mov    %esi,%ecx
mov    %r9,%r8
add    %r12d,%ecx
jb     1353 <frlufact+0x243>
shr    $0x20,%r12
mov    %r9,%r8
jne    1353 <frlufact+0x243>
mov    %r9,%r8
test   %dl,%dl
jne    1353 <frlufact+0x243>
mov    %r9,%r8
test   %r12,%r12
jne    1353 <frlufact+0x243>
mov    0xc(%rsp),%eax
mov    %eax,%ecx
imul   %r9d,%ecx
lea    (%rbx,%rcx,4),%rax
lea    (%r9,%rbp,1),%edx
lea    (%rdx,%r13,1),%rdi
sub    %r9,%rdi
lea    (%rbx,%rdi,4),%rdi
cmp    %rdi,%rax
mov    0x28(%rsp),%r15
jae    16a0 <frlufact+0x590>
add    %r13,%rcx
sub    %r9,%rcx
lea    (%rbx,%rcx,4),%rcx
lea    (%rbx,%rdx,4),%rdx
mov    %r9,%r8
cmp    %rcx,%rdx
jb     1353 <frlufact+0x243>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1a7f <frlufact+0x96f>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    %esi,%edx
movups (%rbx,%rdx,4),%xmm4
movups 0x10(%rbx,%rdx,4),%xmm5
mov    %r11d,%eax
movups (%rbx,%rax,4),%xmm6
movups 0x10(%rbx,%rax,4),%xmm7
movups %xmm6,(%rbx,%rdx,4)
movups %xmm7,0x10(%rbx,%rdx,4)
movups %xmm4,(%rbx,%rax,4)
movups %xmm5,0x10(%rbx,%rax,4)
lea    0x8(%rsi),%eax
movups (%rbx,%rax,4),%xmm4
movups 0x10(%rbx,%rax,4),%xmm5
lea    0x8(%r11),%edx
movups (%rbx,%rdx,4),%xmm6
movups 0x10(%rbx,%rdx,4),%xmm7
movups %xmm6,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
movups %xmm4,(%rbx,%rdx,4)
movups %xmm5,0x10(%rbx,%rdx,4)
add    $0x10,%rcx
add    $0x10,%r11d
add    $0x10,%esi
add    $0xfffffffffffffffe,%rdi
jne    16d0 <frlufact+0x5c0>
jmp    1a81 <frlufact+0x971>
xor    %ecx,%ecx
test   $0x1,%al
mov    0x10(%rsp),%rbp
je     1767 <frlufact+0x657>
add    %ebp,%ecx
imul   %r14d,%ecx
add    0x18(%rsp),%ecx
movups (%rbx,%rcx,4),%xmm6
movups 0x10(%rbx,%rcx,4),%xmm7
mulps  %xmm5,%xmm6
mulps  %xmm5,%xmm7
movups %xmm6,(%rbx,%rcx,4)
movups %xmm7,0x10(%rbx,%rcx,4)
mov    0x40(%rsp),%rax
cmp    %rax,0x88(%rsp)
mov    0x28(%rsp),%r15
mov    0x48(%rsp),%rdi
jne    1a6c <frlufact+0x95c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r13,%rdi
jae    1a5e <frlufact+0x94e>
mov    %r15,0x28(%rsp)
lea    (%r10,%r10,1),%eax
add    $0x2,%eax
mov    %rax,0xe0(%rsp)
mov    0x68(%rsp),%rax
lea    (%r9,%rax,1),%edi
mov    0x98(%rsp),%rcx
mov    0x20(%rsp),%rsi
lea    (%rcx,%rsi,4),%rdx
mov    %rdx,0xd0(%rsp)
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,1),%eax
mov    %rax,0xc8(%rsp)
lea    (%rbx,%rdi,4),%rax
mov    %rax,0xc0(%rsp)
lea    (%rsi,%rdi,1),%rax
lea    (%rcx,%rax,4),%rax
mov    %rax,0xb8(%rsp)
not    %edi
mov    %rdi,0xd8(%rsp)
mov    0x40(%rsp),%rax
add    %rbp,%rax
mov    %rax,0xa8(%rsp)
mov    %r9,0x38(%rsp)
lea    (%r9,%rbp,1),%eax
mov    %eax,0x74(%rsp)
xor    %r12d,%r12d
mov    0x60(%rsp),%rax
mov    %eax,%r8d
mov    0x58(%rsp),%eax
mov    %eax,%r11d
mov    0x54(%rsp),%r10d
mov    %rbp,%r15
jmp    1864 <frlufact+0x754>
xchg   %ax,%ax
add    $0x1,%r15
add    $0x1,%r12d
add    %r14d,%r10d
add    %r14d,%r11d
add    %r14d,%r8d
cmp    %r14d,%r15d
mov    0x10(%rsp),%rbp
mov    0x18(%rsp),%rdx
je     11ed <frlufact+0xdd>
mov    %r15d,%edi
imul   %r14d,%edi
lea    (%rdi,%rdx,1),%r13d
mov    %rbp,%r9
cmpl   $0x7,0x20(%rsp)
jae    1890 <frlufact+0x780>
mov    %r14d,%ecx
sub    %r9d,%ecx
test   $0x1,%cl
jne    19c0 <frlufact+0x8b0>
mov    %r9,%rcx
jmp    19ec <frlufact+0x8dc>
mov    0xe0(%rsp),%rax
lea    (%rax,%r12,1),%ecx
mov    %ecx,%edx
add    0x20(%rsp),%edx
setb   %dl
mov    0x10(%rsp),%r9
cmp    $0x1,%r14d
jne    1879 <frlufact+0x769>
mov    0x10(%rsp),%r9
test   %dl,%dl
jne    1879 <frlufact+0x769>
mov    0x10(%rsp),%r9
mov    0xd8(%rsp),%rax
cmp    %eax,0x20(%rsp)
ja     1879 <frlufact+0x769>
mov    0xc8(%rsp),%rax
lea    (%rax,%r12,1),%edx
lea    (%rbx,%rcx,4),%rbp
mov    0xd0(%rsp),%rax
lea    (%rax,%rcx,4),%rcx
lea    (%rbx,%rdx,4),%r9
mov    0x98(%rsp),%rax
lea    (%rax,%rdx,4),%rdx
cmp    %rdx,%rbp
setb   %al
cmp    %rcx,%r9
mov    %r14,%rsi
setb   %r14b
cmp    0xb8(%rsp),%rbp
setb   %dl
cmp    %rcx,0xc0(%rsp)
setb   %cl
mov    0x10(%rsp),%r9
test   %r14b,%al
mov    %rsi,%r14
jne    1879 <frlufact+0x769>
mov    0x10(%rsp),%r9
and    %cl,%dl
jne    1879 <frlufact+0x769>
movss  (%rbx,%r13,4),%xmm4
shufps $0x0,%xmm4,%xmm4
xorps  %xmm3,%xmm4
mov    %r10d,%ecx
mov    0x74(%rsp),%edx
mov    0x80(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    %edx,%esi
movups (%rbx,%rsi,4),%xmm5
movups 0x10(%rbx,%rsi,4),%xmm6
mov    %ecx,%esi
movups (%rbx,%rsi,4),%xmm7
movups 0x10(%rbx,%rsi,4),%xmm2
mulps  %xmm4,%xmm5
addps  %xmm7,%xmm5
mulps  %xmm4,%xmm6
addps  %xmm2,%xmm6
movups %xmm5,(%rbx,%rsi,4)
movups %xmm6,0x10(%rbx,%rsi,4)
add    $0x8,%edx
add    $0x8,%ecx
add    $0xfffffffffffffff8,%rbp
jne    1960 <frlufact+0x850>
mov    0xa8(%rsp),%r9
mov    0x40(%rsp),%rax
cmp    %rax,0x88(%rsp)
je     1840 <frlufact+0x730>
jmp    1879 <frlufact+0x769>
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%r13,4),%xmm2
mov    0x38(%rsp),%rax
lea    (%rax,%r9,1),%ecx
add    %r9d,%edi
mulss  (%rbx,%rcx,4),%xmm2
movss  (%rbx,%rdi,4),%xmm4
subss  %xmm2,%xmm4
movss  %xmm4,(%rbx,%rdi,4)
mov    %r9,%rcx
add    $0x1,%rcx
not    %r9d
cmp    0x5c(%rsp),%r9d
je     1840 <frlufact+0x730>
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,1),%edi
lea    (%r11,%rcx,1),%ebp
mov    %r14d,%edx
sub    %ecx,%edx
add    %r8d,%ecx
xchg   %ax,%ax
movss  (%rbx,%r13,4),%xmm2
mov    %edi,%esi
mov    %ecx,%eax
movss  (%rbx,%rax,4),%xmm4
mulss  (%rbx,%rsi,4),%xmm2
subss  %xmm2,%xmm4
movss  %xmm4,(%rbx,%rax,4)
movss  (%rbx,%r13,4),%xmm2
lea    0x1(%rdi),%eax
mov    %ebp,%esi
movss  (%rbx,%rsi,4),%xmm4
mulss  (%rbx,%rax,4),%xmm2
subss  %xmm2,%xmm4
movss  %xmm4,(%rbx,%rsi,4)
add    $0x2,%edi
add    $0x2,%ebp
add    $0x2,%ecx
add    $0xfffffffe,%edx
jne    1a10 <frlufact+0x900>
jmp    1840 <frlufact+0x730>
mov    0x8(%rsp),%ecx
mov    0x68(%rsp),%rsi
jmp    1212 <frlufact+0x102>
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,1),%rcx
mov    0x18(%rsp),%rdx
jmp    14b3 <frlufact+0x3a3>
xor    %ecx,%ecx
test   $0x1,%r9b
mov    0x28(%rsp),%r15
mov    0x18(%rsp),%rdx
je     1ac0 <frlufact+0x9b0>
add    %edx,%ecx
mov    0x38(%rsp),%rax
add    %ecx,%eax
movups (%rbx,%rax,4),%xmm4
movups 0x10(%rbx,%rax,4),%xmm5
add    %ebp,%ecx
movups (%rbx,%rcx,4),%xmm6
movups 0x10(%rbx,%rcx,4),%xmm7
movups %xmm6,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
movups %xmm4,(%rbx,%rcx,4)
movups %xmm5,0x10(%rbx,%rcx,4)
cmp    %r8,%r10
jne    1ae7 <frlufact+0x9d7>
mov    0xc(%rsp),%r8d
mov    0x30(%rsp),%r11d
mov    0x34(%rsp),%r12d
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%ecx
mov    0x38(%rsp),%r9
jmp    1401 <frlufact+0x2f1>
add    %rdx,%r8
jmp    1353 <frlufact+0x243>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @frlufact(float* %0, i32* nocapture writeonly %1, float* %2, i32 %3) {
%5 = icmp eq float* %0, %2
br i1 %5, label %10, label %6
6: ; preds = %4
%7 = shl i32 %3, 2
%8 = mul i32 %7, %3
%9 = tail call i32 @memcpy(float* %0, float* %2, i32 %8)
br label %10
10: ; preds = %6, %4
%11 = add i32 %3, -1
%12 = icmp eq i32 %11, 0
br i1 %12, label %556, label %13
13: ; preds = %10
%14 = zext i32 %3 to i64
%15 = zext i32 %11 to i64
%16 = add i32 %3, -2
%17 = getelementptr float, float* %0, i64 1
%18 = getelementptr float, float* %0, i64 1
%19 = getelementptr float, float* %0, i64 1
%20 = add i32 %3, 1
%21 = sub nsw i64 0, %14
%22 = sub nsw i64 0, %14
%23 = icmp ne i32 %3, 1
%24 = sub i32 0, %3
%25 = icmp ne i32 %3, 1
%26 = sub i32 0, %3
br label %27
27: ; preds = %13, %551
%28 = phi i32 [ 0, %13 ], [ %555, %551 ]
%29 = phi i64 [ 1, %13 ], [ %553, %551 ]
%30 = phi i64 [ 0, %13 ], [ %552, %551 ]
%31 = sub i32 %16, %28
%32 = zext i32 %31 to i64
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 8589934584
%35 = add nsw i64 %34, -8
%36 = lshr exact i64 %35, 3
%37 = add nuw nsw i64 %36, 1
%38 = sub i32 %16, %28
%39 = zext i32 %38 to i64
%40 = add nuw nsw i64 %39, 1
%41 = sub i32 %16, %28
%42 = add i32 %28, 1
%43 = sub i32 %16, %28
%44 = zext i32 %43 to i64
%45 = add nuw nsw i64 %44, 1
%46 = shl i32 %28, 1
%47 = add i32 %46, 2
%48 = sub i32 %16, %28
%49 = zext i32 %48 to i64
%50 = add i32 %28, 1
%51 = sub i32 %16, %28
%52 = shl i32 %28, 1
%53 = add i32 %52, 2
%54 = add i32 %28, 1
%55 = icmp ult i64 %30, %14
%56 = trunc i64 %30 to i32
br i1 %55, label %57, label %80
57: ; preds = %27
%58 = sub i64 %14, %30
%59 = xor i64 %30, -1
%60 = and i64 %58, 1
%61 = icmp eq i64 %60, 0
br i1 %61, label %74, label %62
62: ; preds = %57
%63 = trunc i64 %30 to i32
%64 = mul i32 %63, %3
%65 = add i32 %64, %56
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds float, float* %0, i64 %66
%68 = load float, float* %67
%69 = tail call float @llvm.fabs.f32(float %68)
%70 = fcmp one float %68, 0.000000e+00
%71 = select i1 %70, i32 %63, i32 %56
%72 = select i1 %70, float %69, float 0.000000e+00
%73 = add nuw nsw i64 %30, 1
br label %74
74: ; preds = %62, %57
%75 = phi i32 [ undef, %57 ], [ %71, %62 ]
%76 = phi i64 [ %30, %57 ], [ %73, %62 ]
%77 = phi float [ 0.000000e+00, %57 ], [ %72, %62 ]
%78 = phi i32 [ %56, %57 ], [ %71, %62 ]
%79 = icmp eq i64 %59, %21
br i1 %79, label %109, label %82
80: ; preds = %27
%81 = getelementptr inbounds i32, i32* %1, i64 %30
store i32 %56, i32* %81
br label %112
82: ; preds = %74, %82
%83 = phi i64 [ %107, %82 ], [ %76, %74 ]
%84 = phi float [ %106, %82 ], [ %77, %74 ]
%85 = phi i32 [ %105, %82 ], [ %78, %74 ]
%86 = trunc i64 %83 to i32
%87 = mul i32 %86, %3
%88 = add i32 %87, %56
%89 = zext i32 %88 to i64
%90 = getelementptr inbounds float, float* %0, i64 %89
%91 = load float, float* %90
%92 = tail call float @llvm.fabs.f32(float %91)
%93 = fcmp ogt float %92, %84
%94 = select i1 %93, i32 %86, i32 %85
%95 = select i1 %93, float %92, float %84
%96 = trunc i64 %83 to i32
%97 = add i32 %96, 1
%98 = mul i32 %97, %3
%99 = add i32 %98, %56
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds float, float* %0, i64 %100
%102 = load float, float* %101
%103 = tail call float @llvm.fabs.f32(float %102)
%104 = fcmp ogt float %103, %95
%105 = select i1 %104, i32 %97, i32 %94
%106 = select i1 %104, float %103, float %95
%107 = add nuw nsw i64 %83, 2
%108 = icmp eq i64 %107, %14
br i1 %108, label %109, label %82
109: ; preds = %82, %74
%110 = phi i32 [ %75, %74 ], [ %105, %82 ]
%111 = getelementptr inbounds i32, i32* %1, i64 %30
store i32 %110, i32* %111
br i1 %55, label %114, label %112
112: ; preds = %80, %109
%113 = mul i32 %56, %3
br label %283
114: ; preds = %109
%115 = mul i32 %56, %3
%116 = mul i32 %110, %3
%117 = sub i64 %14, %30
%118 = icmp ult i64 %117, 8
br i1 %118, label %240, label %119
119: ; preds = %114
%120 = xor i64 %30, -1
%121 = add i64 %120, %14
%122 = mul i32 %20, %56
%123 = trunc i64 %121 to i32
%124 = xor i32 %122, -1
%125 = icmp ult i32 %124, %123
%126 = icmp ugt i64 %121, 4294967295
%127 = or i1 %125, %126
%128 = add i32 %116, %56
%129 = trunc i64 %121 to i32
%130 = xor i32 %128, -1
%131 = icmp ult i32 %130, %129
%132 = icmp ugt i64 %121, 4294967295
%133 = or i1 %131, %132
%134 = or i1 %127, %133
br i1 %134, label %240, label %135
135: ; preds = %119
%136 = mul i32 %20, %56
%137 = zext i32 %136 to i64
%138 = getelementptr float, float* %0, i64 %137
%139 = add nuw nsw i64 %14, %137
%140 = sub i64 %139, %30
%141 = getelementptr float, float* %0, i64 %140
%142 = add i32 %116, %56
%143 = zext i32 %142 to i64
%144 = getelementptr float, float* %0, i64 %143
%145 = add nuw nsw i64 %14, %143
%146 = sub i64 %145, %30
%147 = getelementptr float, float* %0, i64 %146
%148 = icmp ult float* %138, %147
%149 = icmp ult float* %144, %141
%150 = and i1 %148, %149
br i1 %150, label %240, label %151
151: ; preds = %135
%152 = and i64 %117, -8
%153 = add i64 %30, %152
%154 = add i64 %152, -8
%155 = lshr exact i64 %154, 3
%156 = add nuw nsw i64 %155, 1
%157 = and i64 %156, 1
%158 = icmp eq i64 %154, 0
br i1 %158, label %212, label %159
159: ; preds = %151
%160 = and i64 %156, 4611686018427387902
br label %161
161: ; preds = %161, %159
%162 = phi i64 [ 0, %159 ], [ %209, %161 ]
%163 = phi i64 [ 0, %159 ], [ %210, %161 ]
%164 = add i64 %30, %162
%165 = trunc i64 %164 to i32
%166 = add i32 %115, %165
%167 = zext i32 %166 to i64
%168 = getelementptr inbounds float, float* %0, i64 %167
%169 = bitcast float* %168 to <4 x float>*
%170 = load <4 x float>, <4 x float>* %169
%171 = getelementptr inbounds float, float* %168, i64 4
%172 = bitcast float* %171 to <4 x float>*
%173 = load <4 x float>, <4 x float>* %172
%174 = add i32 %116, %165
%175 = zext i32 %174 to i64
%176 = getelementptr inbounds float, float* %0, i64 %175
%177 = bitcast float* %176 to <4 x float>*
%178 = load <4 x float>, <4 x float>* %177
%179 = getelementptr inbounds float, float* %176, i64 4
%180 = bitcast float* %179 to <4 x float>*
%181 = load <4 x float>, <4 x float>* %180
%182 = bitcast float* %168 to <4 x float>*
store <4 x float> %178, <4 x float>* %182
%183 = bitcast float* %171 to <4 x float>*
store <4 x float> %181, <4 x float>* %183
%184 = bitcast float* %176 to <4 x float>*
store <4 x float> %170, <4 x float>* %184
%185 = bitcast float* %179 to <4 x float>*
store <4 x float> %173, <4 x float>* %185
%186 = or i64 %162, 8
%187 = add i64 %30, %186
%188 = trunc i64 %187 to i32
%189 = add i32 %115, %188
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds float, float* %0, i64 %190
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = getelementptr inbounds float, float* %191, i64 4
%195 = bitcast float* %194 to <4 x float>*
%196 = load <4 x float>, <4 x float>* %195
%197 = add i32 %116, %188
%198 = zext i32 %197 to i64
%199 = getelementptr inbounds float, float* %0, i64 %198
%200 = bitcast float* %199 to <4 x float>*
%201 = load <4 x float>, <4 x float>* %200
%202 = getelementptr inbounds float, float* %199, i64 4
%203 = bitcast float* %202 to <4 x float>*
%204 = load <4 x float>, <4 x float>* %203
%205 = bitcast float* %191 to <4 x float>*
store <4 x float> %201, <4 x float>* %205
%206 = bitcast float* %194 to <4 x float>*
store <4 x float> %204, <4 x float>* %206
%207 = bitcast float* %199 to <4 x float>*
store <4 x float> %193, <4 x float>* %207
%208 = bitcast float* %202 to <4 x float>*
store <4 x float> %196, <4 x float>* %208
%209 = add nuw i64 %162, 16
%210 = add i64 %163, 2
%211 = icmp eq i64 %210, %160
br i1 %211, label %212, label %161
212: ; preds = %161, %151
%213 = phi i64 [ 0, %151 ], [ %209, %161 ]
%214 = icmp eq i64 %157, 0
br i1 %214, label %238, label %215
215: ; preds = %212
%216 = add i64 %30, %213
%217 = trunc i64 %216 to i32
%218 = add i32 %115, %217
%219 = zext i32 %218 to i64
%220 = getelementptr inbounds float, float* %0, i64 %219
%221 = bitcast float* %220 to <4 x float>*
%222 = load <4 x float>, <4 x float>* %221
%223 = getelementptr inbounds float, float* %220, i64 4
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = add i32 %116, %217
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds float, float* %0, i64 %227
%229 = bitcast float* %228 to <4 x float>*
%230 = load <4 x float>, <4 x float>* %229
%231 = getelementptr inbounds float, float* %228, i64 4
%232 = bitcast float* %231 to <4 x float>*
%233 = load <4 x float>, <4 x float>* %232
%234 = bitcast float* %220 to <4 x float>*
store <4 x float> %230, <4 x float>* %234
%235 = bitcast float* %223 to <4 x float>*
store <4 x float> %233, <4 x float>* %235
%236 = bitcast float* %228 to <4 x float>*
store <4 x float> %222, <4 x float>* %236
%237 = bitcast float* %231 to <4 x float>*
store <4 x float> %225, <4 x float>* %237
br label %238
238: ; preds = %212, %215
%239 = icmp eq i64 %117, %152
br i1 %239, label %283, label %240
240: ; preds = %135, %119, %114, %238
%241 = phi i64 [ %30, %135 ], [ %30, %119 ], [ %30, %114 ], [ %153, %238 ]
%242 = sub i64 %14, %241
%243 = xor i64 %241, -1
%244 = and i64 %242, 1
%245 = icmp eq i64 %244, 0
br i1 %245, label %257, label %246
246: ; preds = %240
%247 = trunc i64 %241 to i32
%248 = add i32 %115, %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds float, float* %0, i64 %249
%251 = load float, float* %250
%252 = add i32 %116, %247
%253 = zext i32 %252 to i64
%254 = getelementptr inbounds float, float* %0, i64 %253
%255 = load float, float* %254
store float %255, float* %250
store float %251, float* %254
%256 = add nuw nsw i64 %241, 1
br label %257
257: ; preds = %246, %240
%258 = phi i64 [ %241, %240 ], [ %256, %246 ]
%259 = icmp eq i64 %243, %22
br i1 %259, label %283, label %260
260: ; preds = %257, %260
%261 = phi i64 [ %281, %260 ], [ %258, %257 ]
%262 = trunc i64 %261 to i32
%263 = add i32 %115, %262
%264 = zext i32 %263 to i64
%265 = getelementptr inbounds float, float* %0, i64 %264
%266 = load float, float* %265
%267 = add i32 %116, %262
%268 = zext i32 %267 to i64
%269 = getelementptr inbounds float, float* %0, i64 %268
%270 = load float, float* %269
store float %270, float* %265
store float %266, float* %269
%271 = trunc i64 %261 to i32
%272 = add i32 %271, 1
%273 = add i32 %115, %272
%274 = zext i32 %273 to i64
%275 = getelementptr inbounds float, float* %0, i64 %274
%276 = load float, float* %275
%277 = add i32 %116, %272
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds float, float* %0, i64 %278
%280 = load float, float* %279
store float %280, float* %275
store float %276, float* %279
%281 = add nuw nsw i64 %261, 2
%282 = icmp eq i64 %281, %14
br i1 %282, label %283, label %260
283: ; preds = %257, %260, %238, %112
%284 = phi i32 [ %113, %112 ], [ %115, %238 ], [ %115, %260 ], [ %115, %257 ]
%285 = add i32 %284, %56
%286 = zext i32 %285 to i64
%287 = getelementptr inbounds float, float* %0, i64 %286
%288 = load float, float* %287
%289 = fcmp une float %288, 0.000000e+00
br i1 %289, label %292, label %290
290: ; preds = %283
%291 = add nuw nsw i64 %30, 1
br label %551
292: ; preds = %283
%293 = fdiv float 1.000000e+00, %288
%294 = add nuw nsw i64 %30, 1
%295 = icmp ult i64 %294, %14
br i1 %295, label %296, label %551
296: ; preds = %292
%297 = icmp ult i32 %38, 7
br i1 %297, label %372, label %298
298: ; preds = %296
%299 = add i32 %42, %56
%300 = xor i32 %299, -1
%301 = icmp ugt i32 %41, %300
%302 = or i1 %23, %301
br i1 %302, label %372, label %303
303: ; preds = %298
%304 = and i64 %40, 8589934584
%305 = add nuw i64 %29, %304
%306 = insertelement <4 x float> poison, float %293, i64 0
%307 = shufflevector <4 x float> %306, <4 x float> poison, <4 x i32> zeroinitializer
%308 = insertelement <4 x float> poison, float %293, i64 0
%309 = shufflevector <4 x float> %308, <4 x float> poison, <4 x i32> zeroinitializer
%310 = and i64 %37, 1
%311 = icmp eq i64 %35, 0
br i1 %311, label %351, label %312
312: ; preds = %303
%313 = and i64 %37, 4611686018427387902
br label %314
314: ; preds = %314, %312
%315 = phi i64 [ 0, %312 ], [ %348, %314 ]
%316 = phi i64 [ 0, %312 ], [ %349, %314 ]
%317 = add i64 %29, %315
%318 = trunc i64 %317 to i32
%319 = mul i32 %318, %3
%320 = add i32 %319, %56
%321 = zext i32 %320 to i64
%322 = getelementptr inbounds float, float* %0, i64 %321
%323 = bitcast float* %322 to <4 x float>*
%324 = load <4 x float>, <4 x float>* %323
%325 = getelementptr inbounds float, float* %322, i64 4
%326 = bitcast float* %325 to <4 x float>*
%327 = load <4 x float>, <4 x float>* %326
%328 = fmul <4 x float> %307, %324
%329 = fmul <4 x float> %309, %327
%330 = bitcast float* %322 to <4 x float>*
store <4 x float> %328, <4 x float>* %330
%331 = bitcast float* %325 to <4 x float>*
store <4 x float> %329, <4 x float>* %331
%332 = or i64 %315, 8
%333 = add i64 %29, %332
%334 = trunc i64 %333 to i32
%335 = mul i32 %334, %3
%336 = add i32 %335, %56
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds float, float* %0, i64 %337
%339 = bitcast float* %338 to <4 x float>*
%340 = load <4 x float>, <4 x float>* %339
%341 = getelementptr inbounds float, float* %338, i64 4
%342 = bitcast float* %341 to <4 x float>*
%343 = load <4 x float>, <4 x float>* %342
%344 = fmul <4 x float> %307, %340
%345 = fmul <4 x float> %309, %343
%346 = bitcast float* %338 to <4 x float>*
store <4 x float> %344, <4 x float>* %346
%347 = bitcast float* %341 to <4 x float>*
store <4 x float> %345, <4 x float>* %347
%348 = add nuw i64 %315, 16
%349 = add i64 %316, 2
%350 = icmp eq i64 %349, %313
br i1 %350, label %351, label %314
351: ; preds = %314, %303
%352 = phi i64 [ 0, %303 ], [ %348, %314 ]
%353 = icmp eq i64 %310, 0
br i1 %353, label %370, label %354
354: ; preds = %351
%355 = add i64 %29, %352
%356 = trunc i64 %355 to i32
%357 = mul i32 %356, %3
%358 = add i32 %357, %56
%359 = zext i32 %358 to i64
%360 = getelementptr inbounds float, float* %0, i64 %359
%361 = bitcast float* %360 to <4 x float>*
%362 = load <4 x float>, <4 x float>* %361
%363 = getelementptr inbounds float, float* %360, i64 4
%364 = bitcast float* %363 to <4 x float>*
%365 = load <4 x float>, <4 x float>* %364
%366 = fmul <4 x float> %307, %362
%367 = fmul <4 x float> %309, %365
%368 = bitcast float* %360 to <4 x float>*
store <4 x float> %366, <4 x float>* %368
%369 = bitcast float* %363 to <4 x float>*
store <4 x float> %367, <4 x float>* %369
br label %370
370: ; preds = %351, %354
%371 = icmp eq i64 %40, %304
br i1 %371, label %391, label %372
372: ; preds = %298, %296, %370
%373 = phi i64 [ %29, %298 ], [ %29, %296 ], [ %305, %370 ]
%374 = trunc i64 %373 to i32
%375 = sub i32 %3, %374
%376 = xor i32 %374, -1
%377 = and i32 %375, 1
%378 = icmp eq i32 %377, 0
br i1 %378, label %388, label %379
379: ; preds = %372
%380 = trunc i64 %373 to i32
%381 = mul i32 %380, %3
%382 = add i32 %381, %56
%383 = zext i32 %382 to i64
%384 = getelementptr inbounds float, float* %0, i64 %383
%385 = load float, float* %384
%386 = fmul float %293, %385
store float %386, float* %384
%387 = add nuw nsw i64 %373, 1
br label %388
388: ; preds = %379, %372
%389 = phi i64 [ %373, %372 ], [ %387, %379 ]
%390 = icmp eq i32 %376, %24
br i1 %390, label %391, label %407
391: ; preds = %388, %407, %370
br i1 %295, label %392, label %551
392: ; preds = %391
%393 = add i32 %284, %54
%394 = getelementptr float, float* %17, i64 %49
%395 = add i32 %50, %56
%396 = add i32 %284, %50
%397 = zext i32 %396 to i64
%398 = getelementptr float, float* %0, i64 %397
%399 = add nuw nsw i64 %49, %397
%400 = getelementptr float, float* %19, i64 %399
%401 = icmp ult i32 %43, 7
%402 = xor i32 %393, -1
%403 = icmp ugt i32 %51, %402
%404 = and i64 %45, 8589934584
%405 = add nuw i64 %29, %404
%406 = icmp eq i64 %45, %404
br label %427
407: ; preds = %388, %407
%408 = phi i64 [ %424, %407 ], [ %389, %388 ]
%409 = trunc i64 %408 to i32
%410 = mul i32 %409, %3
%411 = add i32 %410, %56
%412 = zext i32 %411 to i64
%413 = getelementptr inbounds float, float* %0, i64 %412
%414 = load float, float* %413
%415 = fmul float %293, %414
store float %415, float* %413
%416 = trunc i64 %408 to i32
%417 = add i32 %416, 1
%418 = mul i32 %417, %3
%419 = add i32 %418, %56
%420 = zext i32 %419 to i64
%421 = getelementptr inbounds float, float* %0, i64 %420
%422 = load float, float* %421
%423 = fmul float %293, %422
store float %423, float* %421
%424 = add nuw nsw i64 %408, 2
%425 = trunc i64 %424 to i32
%426 = icmp eq i32 %425, %3
br i1 %426, label %391, label %407
427: ; preds = %392, %546
%428 = phi i32 [ 0, %392 ], [ %550, %546 ]
%429 = phi i64 [ %29, %392 ], [ %547, %546 ]
%430 = add i32 %47, %428
%431 = zext i32 %430 to i64
%432 = getelementptr float, float* %0, i64 %431
%433 = getelementptr float, float* %394, i64 %431
%434 = add i32 %395, %428
%435 = zext i32 %434 to i64
%436 = getelementptr float, float* %0, i64 %435
%437 = getelementptr float, float* %18, i64 %435
%438 = trunc i64 %429 to i32
%439 = mul i32 %438, %3
%440 = add i32 %439, %56
%441 = zext i32 %440 to i64
%442 = getelementptr inbounds float, float* %0, i64 %441
br i1 %401, label %492, label %443
443: ; preds = %427
%444 = add i32 %53, %428
%445 = xor i32 %444, -1
%446 = icmp ugt i32 %51, %445
%447 = or i1 %25, %446
%448 = or i1 %447, %403
br i1 %448, label %492, label %449
449: ; preds = %443
%450 = icmp ult float* %432, %437
%451 = icmp ult float* %436, %433
%452 = and i1 %450, %451
%453 = icmp ult float* %432, %400
%454 = icmp ult float* %398, %433
%455 = and i1 %453, %454
%456 = or i1 %452, %455
br i1 %456, label %492, label %457
457: ; preds = %449
%458 = load float, float* %442
%459 = insertelement <4 x float> poison, float %458, i64 0
%460 = shufflevector <4 x float> %459, <4 x float> poison, <4 x i32> zeroinitializer
%461 = insertelement <4 x float> poison, float %458, i64 0
%462 = shufflevector <4 x float> %461, <4 x float> poison, <4 x i32> zeroinitializer
%463 = fneg <4 x float> %460
%464 = fneg <4 x float> %462
br label %465
465: ; preds = %465, %457
%466 = phi i64 [ 0, %457 ], [ %489, %465 ]
%467 = add i64 %29, %466
%468 = trunc i64 %467 to i32
%469 = add i32 %284, %468
%470 = zext i32 %469 to i64
%471 = getelementptr inbounds float, float* %0, i64 %470
%472 = bitcast float* %471 to <4 x float>*
%473 = load <4 x float>, <4 x float>* %472
%474 = getelementptr inbounds float, float* %471, i64 4
%475 = bitcast float* %474 to <4 x float>*
%476 = load <4 x float>, <4 x float>* %475
%477 = add i32 %439, %468
%478 = zext i32 %477 to i64
%479 = getelementptr inbounds float, float* %0, i64 %478
%480 = bitcast float* %479 to <4 x float>*
%481 = load <4 x float>, <4 x float>* %480
%482 = getelementptr inbounds float, float* %479, i64 4
%483 = bitcast float* %482 to <4 x float>*
%484 = load <4 x float>, <4 x float>* %483
%485 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %463, <4 x float> %473, <4 x float> %481)
%486 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %464, <4 x float> %476, <4 x float> %484)
%487 = bitcast float* %479 to <4 x float>*
store <4 x float> %485, <4 x float>* %487
%488 = bitcast float* %482 to <4 x float>*
store <4 x float> %486, <4 x float>* %488
%489 = add nuw i64 %466, 8
%490 = icmp eq i64 %489, %404
br i1 %490, label %491, label %465
491: ; preds = %465
br i1 %406, label %546, label %492
492: ; preds = %449, %443, %427, %491
%493 = phi i64 [ %29, %449 ], [ %29, %443 ], [ %29, %427 ], [ %405, %491 ]
%494 = trunc i64 %493 to i32
%495 = sub i32 %3, %494
%496 = xor i32 %494, -1
%497 = and i32 %495, 1
%498 = icmp eq i32 %497, 0
br i1 %498, label %513, label %499
499: ; preds = %492
%500 = load float, float* %442
%501 = trunc i64 %493 to i32
%502 = add i32 %284, %501
%503 = zext i32 %502 to i64
%504 = getelementptr inbounds float, float* %0, i64 %503
%505 = load float, float* %504
%506 = add i32 %439, %501
%507 = zext i32 %506 to i64
%508 = getelementptr inbounds float, float* %0, i64 %507
%509 = load float, float* %508
%510 = fneg float %500
%511 = tail call float @llvm.fmuladd.f32(float %510, float %505, float %509)
store float %511, float* %508
%512 = add nuw nsw i64 %493, 1
br label %513
513: ; preds = %499, %492
%514 = phi i64 [ %493, %492 ], [ %512, %499 ]
%515 = icmp eq i32 %496, %26
br i1 %515, label %546, label %516
516: ; preds = %513, %516
%517 = phi i64 [ %543, %516 ], [ %514, %513 ]
%518 = load float, float* %442
%519 = trunc i64 %517 to i32
%520 = add i32 %284, %519
%521 = zext i32 %520 to i64
%522 = getelementptr inbounds float, float* %0, i64 %521
%523 = load float, float* %522
%524 = add i32 %439, %519
%525 = zext i32 %524 to i64
%526 = getelementptr inbounds float, float* %0, i64 %525
%527 = load float, float* %526
%528 = fneg float %518
%529 = tail call float @llvm.fmuladd.f32(float %528, float %523, float %527)
store float %529, float* %526
%530 = load float, float* %442
%531 = trunc i64 %517 to i32
%532 = add i32 %531, 1
%533 = add i32 %284, %532
%534 = zext i32 %533 to i64
%535 = getelementptr inbounds float, float* %0, i64 %534
%536 = load float, float* %535
%537 = add i32 %439, %532
%538 = zext i32 %537 to i64
%539 = getelementptr inbounds float, float* %0, i64 %538
%540 = load float, float* %539
%541 = fneg float %530
%542 = tail call float @llvm.fmuladd.f32(float %541, float %536, float %540)
store float %542, float* %539
%543 = add nuw nsw i64 %517, 2
%544 = trunc i64 %543 to i32
%545 = icmp eq i32 %544, %3
br i1 %545, label %546, label %516
546: ; preds = %513, %516, %491
%547 = add nuw nsw i64 %429, 1
%548 = trunc i64 %547 to i32
%549 = icmp eq i32 %548, %3
%550 = add i32 %428, 1
br i1 %549, label %551, label %427
551: ; preds = %546, %292, %290, %391
%552 = phi i64 [ %291, %290 ], [ %294, %391 ], [ %294, %292 ], [ %294, %546 ]
%553 = add nuw nsw i64 %29, 1
%554 = icmp eq i64 %552, %15
%555 = add i32 %28, 1
br i1 %554, label %556, label %27
556: ; preds = %551, %10
ret void
}