#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 size_t int8_t;

/* Variables and functions */
float fabsf(float);
float sqrtf(float);
void eigencompute(float A[][10], float eigval[], float eigvec[][10], int8_t n) {
  float cot2phi, tanhalfphi, tanphi, sinphi, cosphi;
  float ftmp;
  float residue;
  int8_t ir, ic;
  int8_t j;
  int8_t ctr;
  for (ir = 0; ir < n; ir++) {
    for (ic = 0; ic < n; ic++) {
      eigvec[ir][ic] = 0.0F;
    }
    eigvec[ir][ir] = 1.0F;
    eigval[ir] = A[ir][ir];
  }
  ctr = 0;
  do {
    residue = 0.0F;
    for (ir = 0; ir < n - 1; ir++) {
      for (ic = ir + 1; ic < n; ic++) {
        residue += fabsf(A[ir][ic]);
      }
    }
    if (residue > 0.0F) {
      for (ir = 0; ir < n - 1; ir++) {
        for (ic = ir + 1; ic < n; ic++) {
          if (fabsf(A[ir][ic]) > 0.0F) {
            cot2phi = 0.5F * (eigval[ic] - eigval[ir]) / (A[ir][ic]);
            tanphi = 1.0F / (fabsf(cot2phi) + sqrtf(1.0F + cot2phi * cot2phi));
            if (cot2phi < 0.0F) {
              tanphi = -tanphi;
            }
            cosphi = 1.0F / sqrtf(1.0F + tanphi * tanphi);
            sinphi = tanphi * cosphi;
            tanhalfphi = sinphi / (1.0F + cosphi);
            ftmp = tanphi * A[ir][ic];
            eigval[ir] -= ftmp;
            eigval[ic] += ftmp;
            A[ir][ic] = 0.0F;
            for (j = 0; j < n; j++) {
              ftmp = eigvec[j][ir];
              eigvec[j][ir] =
                  ftmp - sinphi * (eigvec[j][ic] + tanhalfphi * ftmp);
              eigvec[j][ic] =
                  eigvec[j][ic] + sinphi * (ftmp - tanhalfphi * eigvec[j][ic]);
            }
            for (j = 0; j <= ir - 1; j++) {
              ftmp = A[j][ir];
              A[j][ir] = ftmp - sinphi * (A[j][ic] + tanhalfphi * ftmp);
              A[j][ic] = A[j][ic] + sinphi * (ftmp - tanhalfphi * A[j][ic]);
            }
            for (j = ir + 1; j <= ic - 1; j++) {
              ftmp = A[ir][j];
              A[ir][j] = ftmp - sinphi * (A[j][ic] + tanhalfphi * ftmp);
              A[j][ic] = A[j][ic] + sinphi * (ftmp - tanhalfphi * A[j][ic]);
            }
            for (j = ic + 1; j < n; j++) {
              ftmp = A[ir][j];
              A[ir][j] = ftmp - sinphi * (A[ic][j] + tanhalfphi * ftmp);
              A[ic][j] = A[ic][j] + sinphi * (ftmp - tanhalfphi * A[ic][j]);
            }
          }
        }
      }
    }
  } while ((residue > 0.0F) && (ctr++ < 15));
}


x86 assembly (clang, -O0):
<eigencompute>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11cd <eigencompute+0xbd>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    117d <eigencompute+0x6d>
mov    -0x18(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1146 <eigencompute+0x36>
mov    -0x18(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  0xe7b(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1130 <eigencompute+0x20>
movq   $0x0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    1265 <eigencompute+0x155>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    124f <eigencompute+0x13f>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xdd0(%rip),%xmm1
pand   %xmm1,%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1206 <eigencompute+0xf6>
jmp    1254 <eigencompute+0x144>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11e5 <eigencompute+0xd5>
movss  -0x3c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    18b9 <eigencompute+0x7a9>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    18b4 <eigencompute+0x7a4>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    189e <eigencompute+0x78e>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xd37(%rip),%xmm1
pand   %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1888 <eigencompute+0x778>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0xd19(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movaps 0xcdb(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xccc(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movss  -0x64(%rbp),%xmm1
addss  %xmm0,%xmm1
movss  0xcb2(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    138b <eigencompute+0x27b>
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc6f(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xc5b(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
movss  0xc36(%rip),%xmm1
addss  -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1558 <eigencompute+0x448>
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1459 <eigencompute+0x349>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
ja     1666 <eigencompute+0x556>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1560 <eigencompute+0x450>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
ja     1778 <eigencompute+0x668>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1672 <eigencompute+0x562>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1883 <eigencompute+0x773>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x48(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
imul   $0x28,-0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x28,-0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1784 <eigencompute+0x674>
jmp    1888 <eigencompute+0x778>
jmp    188d <eigencompute+0x77d>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    129f <eigencompute+0x18f>
jmp    18a3 <eigencompute+0x793>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    127e <eigencompute+0x16e>
jmp    18b9 <eigencompute+0x7a9>
jmp    18be <eigencompute+0x7ae>
movss  -0x3c(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
mov    %al,-0x65(%rbp)
jbe    18ed <eigencompute+0x7dd>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
cmp    $0xf,%rax
setb   %al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
test   $0x1,%al
jne    11d5 <eigencompute+0xc5>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eigencompute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rcx,%rbx
mov    %rdx,%r8
test   %rcx,%rcx
mov    %rcx,0x38(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x10(%rsp)
je     1240 <eigencompute+0x120>
lea    0x0(,%rbx,4),%r14
cmp    $0x1,%rbx
jne    116a <eigencompute+0x4a>
xor    %r13d,%r13d
jmp    11f3 <eigencompute+0xd3>
mov    %rbx,%r15
and    $0xfffffffffffffffe,%r15
xor    %ebp,%ebp
mov    %r8,%r12
xor    %r13d,%r13d
nopl   0x0(%rax)
mov    %r12,%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rax
movl   $0x3f800000,(%rax,%rbp,1)
mov    0x10(%rsp),%rax
movss  (%rax,%rbp,1),%xmm0
mov    0x18(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
lea    0x28(%r12),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%r8
movl   $0x3f800000,0x2c(%r8,%rbp,1)
80 3f
movss  0x2c(%rdi,%rbp,1),%xmm0
movss  %xmm0,0x4(%rsi,%r13,4)
add    $0x2,%r13
add    $0x50,%r12
add    $0x58,%rbp
cmp    %r13,%r15
jne    1180 <eigencompute+0x60>
test   $0x1,%bl
je     1240 <eigencompute+0x120>
lea    0x0(,%r13,8),%rax
lea    (%rax,%rax,4),%rbx
lea    (%r8,%rbx,1),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%r8
movl   $0x3f800000,(%r12,%r13,4)
3f
add    %rdi,%rbx
movss  (%rbx,%r13,4),%xmm0
mov    0x38(%rsp),%rbx
movss  %xmm0,(%rsi,%r13,4)
lea    -0x1(%rbx),%rax
lea    0x4(%rdi),%rcx
mov    %rcx,0x28(%rsp)
lea    (%rdi,%rbx,4),%rcx
mov    %rcx,0xe0(%rsp)
lea    -0x24(%rdi),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%rbx,%rbx,4),%rcx
mov    %rcx,0xa0(%rsp)
lea    (%r8,%rcx,8),%rcx
add    $0xffffffffffffffdc,%rcx
mov    %rcx,0xd8(%rsp)
mov    %rax,%r10
and    $0xfffffffffffffffe,%r10
mov    $0x28,%edx
mov    %rax,%rcx
mov    %rax,0x20(%rsp)
mul    %rdx
mov    %rax,0x58(%rsp)
seto   0x4(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
lea    0x28(%rdi),%rax
mov    %rax,0x88(%rsp)
xor    %r11d,%r11d
xorps  %xmm12,%xmm12
movaps 0xd37(%rip),%xmm13
movss  0xd52(%rip),%xmm14
movaps 0xd36(%rip),%xmm15
mov    %r10,0x90(%rsp)
jmp    130e <eigencompute+0x1ee>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x98(%rsp),%rcx
lea    0x1(%rcx),%r11
cmp    $0xf,%rcx
mov    0x90(%rsp),%r10
jae    1cb4 <eigencompute+0xb94>
cmpq   $0x0,0x20(%rsp)
je     1cb4 <eigencompute+0xb94>
mov    %r8,%r9
xorps  %xmm0,%xmm0
cmp    $0x2,%rbx
jne    1c20 <eigencompute+0xb00>
xor    %r8d,%r8d
testb  $0x1,0x20(%rsp)
je     1369 <eigencompute+0x249>
lea    0x1(%r8),%rcx
cmp    %rbx,%rcx
jae    1369 <eigencompute+0x249>
imul   $0x2c,%r8,%rax
add    0x28(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movss  (%rax),%xmm1
andps  %xmm13,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    $0x4,%rax
cmp    %rbx,%rcx
jb     1350 <eigencompute+0x230>
ucomiss %xmm12,%xmm0
jbe    1cb4 <eigencompute+0xb94>
mov    %r9,%r8
mov    %r11,0x98(%rsp)
cmpq   $0x0,0x20(%rsp)
je     12f0 <eigencompute+0x1d0>
mov    %rdi,%r12
mov    0x28(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x88(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    %rdi,%r13
xor    %r14d,%r14d
xor    %eax,%eax
jmp    13d8 <eigencompute+0x2b8>
xchg   %ax,%ax
add    $0x4,%r14
add    $0x2c,%r13
addq   $0x28,0x60(%rsp)
addq   $0x28,0x40(%rsp)
add    $0x28,%r12
mov    0x48(%rsp),%rax
cmp    0x20(%rsp),%rax
je     12f0 <eigencompute+0x1d0>
mov    %rax,%r11
cmp    $0x2,%rax
mov    $0x1,%ebp
cmovae %rax,%rbp
add    $0x1,%rax
mov    %rax,0x48(%rsp)
cmp    %rbx,%rax
jae    13b0 <eigencompute+0x290>
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb8(%rsp)
lea    (%r8,%r11,4),%r9
mov    0xa0(%rsp),%rax
lea    (%r8,%rax,8),%rax
lea    -0x24(%rax,%r11,4),%rax
mov    %rax,0xd0(%rsp)
lea    (%rdi,%r11,4),%r10
lea    0x0(%rbp,%rbp,1),%rax
lea    (%rax,%rax,4),%rcx
lea    -0x24(%r10,%rcx,4),%rax
mov    %rax,0xc8(%rsp)
lea    -0x1(%rbp),%rax
lea    (%r11,%r11,4),%rdx
lea    0x4(%rdi,%rdx,8),%rdx
mov    %rdx,0x30(%rsp)
lea    -0x4(%rdx,%rbx,4),%rdx
mov    %rdx,0xc0(%rsp)
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %rcx,0xe8(%rsp)
mov    0x58(%rsp),%rcx
add    %r9,%rcx
mov    %r9,0xf8(%rsp)
cmp    %r9,%rcx
setb   %cl
or     0x4(%rsp),%cl
mov    %cl,0x7(%rsp)
mov    $0x28,%ecx
mul    %rcx
seto   %cl
mov    %rax,0x100(%rsp)
add    %r10,%rax
mov    %r10,0xf0(%rsp)
cmp    %r10,%rax
setb   %al
mov    %cl,0x6(%rsp)
or     %cl,%al
mov    %al,0x5(%rsp)
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb0(%rsp)
mov    0x48(%rsp),%r15
mov    %r11,0x68(%rsp)
jmp    14f3 <eigencompute+0x3d3>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
mov    %r15,%r10
mov    %r10,%r15
cmp    %rbx,%r10
jae    13b0 <eigencompute+0x290>
mov    0x30(%rsp),%rax
movss  -0x4(%rax,%r15,4),%xmm0
ucomiss %xmm0,%xmm12
je     14e0 <eigencompute+0x3c0>
movss  (%rsi,%r15,4),%xmm2
subss  (%rsi,%r11,4),%xmm2
mulss  0xb07(%rip),%xmm2
divss  %xmm0,%xmm2
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm14,%xmm0
ucomiss %xmm12,%xmm0
jb     1540 <eigencompute+0x420>
sqrtss %xmm0,%xmm0
jmp    156c <eigencompute+0x44c>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm2,0x70(%rsp)
call   1040 <sqrtf@plt>
movaps 0x70(%rsp),%xmm2
movaps 0xab9(%rip),%xmm15
movss  0xac4(%rip),%xmm14
movaps 0xa98(%rip),%xmm13
xorps  %xmm12,%xmm12
movaps %xmm2,%xmm1
andps  %xmm13,%xmm1
addss  %xmm0,%xmm1
movaps %xmm14,%xmm3
divss  %xmm1,%xmm3
cmpltss %xmm12,%xmm2
movaps %xmm2,%xmm0
andnps %xmm3,%xmm0
xorps  %xmm15,%xmm3
andps  %xmm2,%xmm3
orps   %xmm0,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm14,%xmm0
ucomiss %xmm12,%xmm0
jb     15b0 <eigencompute+0x490>
sqrtss %xmm0,%xmm0
jmp    15dc <eigencompute+0x4bc>
nopl   (%rax)
movaps %xmm3,0x70(%rsp)
call   1040 <sqrtf@plt>
movaps 0x70(%rsp),%xmm3
movaps 0xa49(%rip),%xmm15
movss  0xa54(%rip),%xmm14
movaps 0xa28(%rip),%xmm13
xorps  %xmm12,%xmm12
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
mov    0x68(%rsp),%r11
mov    0x30(%rsp),%rax
lea    -0x4(%rax,%r15,4),%rax
movaps %xmm14,%xmm2
divss  %xmm0,%xmm2
movaps %xmm3,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm14,%xmm2
movaps %xmm0,%xmm1
divss  %xmm2,%xmm1
movss  (%rax),%xmm2
mulss  %xmm3,%xmm2
movss  (%rsi,%r11,4),%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%rsi,%r11,4)
addss  (%rsi,%r15,4),%xmm2
movss  %xmm2,(%rsi,%r15,4)
movl   $0x0,(%rax)
movaps %xmm0,%xmm2
xorps  %xmm15,%xmm2
movaps %xmm1,%xmm3
xorps  %xmm15,%xmm3
cmp    $0x4,%rbx
jb     16a0 <eigencompute+0x580>
lea    (%r8,%r15,4),%rax
mov    0x58(%rsp),%rcx
add    %rax,%rcx
cmp    %rax,%rcx
setb   %cl
or     0x4(%rsp),%cl
or     0x7(%rsp),%cl
jne    16a0 <eigencompute+0x580>
mov    0xd8(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
cmp    %rcx,0xf8(%rsp)
jae    1988 <eigencompute+0x868>
cmp    0xd0(%rsp),%rax
jae    1988 <eigencompute+0x868>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rbx,%rax
sub    %rcx,%rax
lea    (%rcx,%rcx,4),%rcx
lea    (%r8,%rcx,8),%rcx
movss  (%rcx,%r14,1),%xmm4
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
addss  (%rcx,%r15,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%rcx,%r14,1)
movss  (%rcx,%r15,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,(%rcx,%r15,4)
add    $0x28,%rcx
add    $0xffffffffffffffff,%rax
jne    16b0 <eigencompute+0x590>
cmp    $0x4,%rbp
jb     1750 <eigencompute+0x630>
lea    (%rdi,%r15,4),%rax
mov    0x100(%rsp),%rcx
add    %rax,%rcx
cmp    %rax,%rcx
setb   %cl
or     0x6(%rsp),%cl
or     0x5(%rsp),%cl
jne    1750 <eigencompute+0x630>
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
cmp    %rcx,0xf0(%rsp)
jae    1acf <eigencompute+0x9af>
cmp    0xc8(%rsp),%rax
jae    1acf <eigencompute+0x9af>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rbp,%rax
sub    %rcx,%rax
lea    (%rcx,%rcx,4),%rcx
lea    (%rdi,%rcx,8),%rcx
movss  (%rcx,%r14,1),%xmm4
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
addss  (%rcx,%r15,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%rcx,%r14,1)
movss  (%rcx,%r15,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,(%rcx,%r15,4)
add    $0x28,%rcx
add    $0xffffffffffffffff,%rax
jne    1760 <eigencompute+0x640>
mov    %rbp,%r9
lea    -0x1(%r15),%rax
cmp    %rax,%r11
jae    1821 <eigencompute+0x701>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%r13,%rdx,4),%xmm4
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
addss  (%rcx),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,0x0(%r13,%rdx,4)
movss  (%rcx),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,(%rcx)
lea    (%r11,%rdx,1),%rbp
add    $0x1,%rbp
add    $0x1,%rdx
add    $0x28,%rcx
cmp    %rax,%rbp
jbe    17d0 <eigencompute+0x6b0>
lea    0x1(%r15),%r10
cmp    %rbx,%r10
jae    1980 <eigencompute+0x860>
mov    %r15,%r8
not    %r8
add    %rbx,%r8
mov    %r10,%rcx
cmp    $0x4,%r8
jb     1910 <eigencompute+0x7f0>
mov    0x30(%rsp),%rax
lea    (%rax,%r15,4),%rcx
imul   $0x2c,%r15,%rax
add    0x28(%rsp),%rax
lea    (%r15,%r15,4),%rdx
mov    0xe0(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    1883 <eigencompute+0x763>
mov    %r10,%rcx
cmp    0xc0(%rsp),%rax
jb     1910 <eigencompute+0x7f0>
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
lea    (%r10,%rbp,1),%rcx
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm2,%xmm9
shufps $0x0,%xmm2,%xmm9
movaps %xmm3,%xmm10
shufps $0x0,%xmm3,%xmm10
movaps %xmm0,%xmm7
shufps $0x0,%xmm0,%xmm7
mov    0x40(%rsp),%rdx
lea    (%rdx,%r15,4),%rbx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdx,4),%xmm4
movups (%rax,%rdx,4),%xmm5
movaps %xmm8,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm5,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,(%rbx,%rdx,4)
movaps %xmm10,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm4,%xmm6
mulps  %xmm7,%xmm6
addps  %xmm5,%xmm6
movups %xmm6,(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    18c0 <eigencompute+0x7a0>
cmp    %rbp,%r8
mov    0x38(%rsp),%rbx
je     1966 <eigencompute+0x846>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r15,%r15,4),%rdx
lea    (%rdi,%rdx,8),%rdx
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm4
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
addss  (%rdx,%rcx,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%r12,%rcx,4)
movss  (%rdx,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rbx,%rcx
jb     1920 <eigencompute+0x800>
mov    %r9,%rbp
mov    0x8(%rsp),%r8
jmp    14e7 <eigencompute+0x3c7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9,%rbp
jmp    14e7 <eigencompute+0x3c7>
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm2,%xmm9
shufps $0x0,%xmm2,%xmm9
movaps %xmm3,%xmm10
shufps $0x0,%xmm3,%xmm10
movaps %xmm0,%xmm11
shufps $0x0,%xmm0,%xmm11
mov    0x50(%rsp),%rax
mov    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%r14,1),%xmm4
movss  0x28(%rcx,%r14,1),%xmm5
unpcklps %xmm5,%xmm4
movss  0x50(%rcx,%r14,1),%xmm5
movss  0x78(%rcx,%r14,1),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm5,%xmm4
movss  (%rcx,%r15,4),%xmm5
movss  0x28(%rcx,%r15,4),%xmm6
unpcklps %xmm6,%xmm5
movss  0x50(%rcx,%r15,4),%xmm6
movss  0x78(%rcx,%r15,4),%xmm7
unpcklps %xmm7,%xmm6
movlhps %xmm6,%xmm5
movaps %xmm8,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm5,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
movss  %xmm6,(%rcx,%r14,1)
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
movss  %xmm5,0x28(%rcx,%r14,1)
movaps %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
movss  %xmm5,0x50(%rcx,%r14,1)
shufps $0xff,%xmm6,%xmm6
movss  %xmm6,0x78(%rcx,%r14,1)
movss  (%rcx,%r15,4),%xmm5
movss  0x28(%rcx,%r15,4),%xmm6
unpcklps %xmm6,%xmm5
movss  0x50(%rcx,%r15,4),%xmm6
movss  0x78(%rcx,%r15,4),%xmm7
unpcklps %xmm7,%xmm6
movlhps %xmm6,%xmm5
movaps %xmm10,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm4,%xmm6
mulps  %xmm11,%xmm6
addps  %xmm5,%xmm6
movss  %xmm6,(%rcx,%r15,4)
movaps %xmm6,%xmm4
shufps $0x55,%xmm6,%xmm4
movss  %xmm4,0x28(%rcx,%r15,4)
movaps %xmm6,%xmm4
unpckhpd %xmm6,%xmm4
movss  %xmm4,0x50(%rcx,%r15,4)
shufps $0xff,%xmm6,%xmm6
movss  %xmm6,0x78(%rcx,%r15,4)
add    $0xa0,%rcx
add    $0xfffffffffffffffc,%rax
jne    19c0 <eigencompute+0x8a0>
mov    0x50(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     16fa <eigencompute+0x5da>
jmp    16a2 <eigencompute+0x582>
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm2,%xmm9
shufps $0x0,%xmm2,%xmm9
movaps %xmm3,%xmm10
shufps $0x0,%xmm3,%xmm10
movaps %xmm0,%xmm11
shufps $0x0,%xmm0,%xmm11
mov    0xb8(%rsp),%rax
mov    %rdi,%rcx
xchg   %ax,%ax
movss  (%rcx,%r14,1),%xmm4
movss  0x28(%rcx,%r14,1),%xmm5
unpcklps %xmm5,%xmm4
movss  0x50(%rcx,%r14,1),%xmm5
movss  0x78(%rcx,%r14,1),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm5,%xmm4
movss  (%rcx,%r15,4),%xmm5
movss  0x28(%rcx,%r15,4),%xmm6
unpcklps %xmm6,%xmm5
movss  0x50(%rcx,%r15,4),%xmm6
movss  0x78(%rcx,%r15,4),%xmm7
unpcklps %xmm7,%xmm6
movlhps %xmm6,%xmm5
movaps %xmm8,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm5,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
movss  %xmm6,(%rcx,%r14,1)
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
movss  %xmm5,0x28(%rcx,%r14,1)
movaps %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
movss  %xmm5,0x50(%rcx,%r14,1)
shufps $0xff,%xmm6,%xmm6
movss  %xmm6,0x78(%rcx,%r14,1)
movss  (%rcx,%r15,4),%xmm5
movss  0x28(%rcx,%r15,4),%xmm6
unpcklps %xmm6,%xmm5
movss  0x50(%rcx,%r15,4),%xmm6
movss  0x78(%rcx,%r15,4),%xmm7
unpcklps %xmm7,%xmm6
movlhps %xmm6,%xmm5
movaps %xmm10,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm4,%xmm6
mulps  %xmm11,%xmm6
addps  %xmm5,%xmm6
movss  %xmm6,(%rcx,%r15,4)
movaps %xmm6,%xmm4
shufps $0x55,%xmm6,%xmm4
movss  %xmm4,0x28(%rcx,%r15,4)
movaps %xmm6,%xmm4
unpckhpd %xmm6,%xmm4
movss  %xmm4,0x50(%rcx,%r15,4)
shufps $0xff,%xmm6,%xmm6
movss  %xmm6,0x78(%rcx,%r15,4)
add    $0xa0,%rcx
add    $0xfffffffffffffffc,%rax
jne    1b00 <eigencompute+0x9e0>
mov    0xb0(%rsp),%rax
mov    %rax,%rcx
cmp    %rax,%rbp
je     17aa <eigencompute+0x68a>
jmp    1752 <eigencompute+0x632>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x2,%ecx
mov    %rdi,%rdx
xor    %r8d,%r8d
jmp    1c41 <eigencompute+0xb21>
nopl   (%rax)
add    $0x58,%rdx
add    $0x2,%rcx
cmp    %r10,%r8
je     132d <eigencompute+0x20d>
mov    %r8,%rax
or     $0x1,%rax
cmp    %rbx,%rax
jae    1c7e <eigencompute+0xb5e>
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdx,%rbp,4),%xmm1
andps  %xmm13,%xmm1
addss  %xmm1,%xmm0
lea    (%r8,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    %rbx,%rax
jb     1c60 <eigencompute+0xb40>
add    $0x2,%r8
cmp    %rbx,%r8
jae    1c30 <eigencompute+0xb10>
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  0x30(%rdx,%rbp,4),%xmm1
andps  %xmm13,%xmm1
addss  %xmm1,%xmm0
lea    (%rcx,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    %rbx,%rax
jb     1c90 <eigencompute+0xb70>
jmp    1c30 <eigencompute+0xb10>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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