#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ fabs(float);
void elmhes(float **a, int n) {
  int m, i, j;
  float x, y;
  for (m = 2; m < n; m++) {
    x = 0.0;
    i = m;
    for (j = m; j <= n; j++) {
      if (fabs(a[j][m - 1]) > fabs(x)) {
        x = a[j][m - 1];
        i = j;
      }
    }
    if (i != m) {
      for (j = m - 1; j <= n; j++) {
        y = (a[i][j]);
        (a[i][j]) = (a[m][j]);
        (a[m][j]) = y;
      };
      for (j = 1; j <= n; j++) {
        y = (a[j][i]);
        (a[j][i]) = (a[j][m]);
        (a[j][m]) = y;
      };
    }
    if (x) {
      for (i = m + 1; i <= n; i++) {
        if ((y = a[i][m - 1]) != 0.0) {
          y /= x;
          a[i][m - 1] = y;
          for (j = m; j <= n; j++)
            a[i][j] -= y * a[m][j];
          for (j = 1; j <= n; j++)
            a[j][m] += y * a[j][i];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<elmhes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x2,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    146d <elmhes+0x35d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11c7 <elmhes+0xb7>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
cmp    %rcx,%rax
jle    11b4 <elmhes+0xa4>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    11b9 <elmhes+0xa9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1146 <elmhes+0x36>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     12d8 <elmhes+0x1c8>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1254 <elmhes+0x144>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11dc <elmhes+0xcc>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12d3 <elmhes+0x1c3>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    125b <elmhes+0x14b>
jmp    12d8 <elmhes+0x1c8>
movss  -0x1c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12f4 <elmhes+0x1e4>
jp     12f4 <elmhes+0x1e4>
jmp    145a <elmhes+0x34a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1455 <elmhes+0x345>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1344 <elmhes+0x234>
jp     1344 <elmhes+0x234>
jmp    1442 <elmhes+0x332>
movss  -0x1c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13e0 <elmhes+0x2d0>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    137c <elmhes+0x26c>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     143d <elmhes+0x32d>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13e7 <elmhes+0x2d7>
jmp    1442 <elmhes+0x332>
jmp    1447 <elmhes+0x337>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12fd <elmhes+0x1ed>
jmp    145a <elmhes+0x34a>
jmp    145f <elmhes+0x34f>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1126 <elmhes+0x16>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<elmhes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
cmp    $0x3,%esi
jl     1709 <elmhes+0x5f9>
mov    %rdi,%r15
mov    %rsi,%rax
mov    %eax,%r11d
lea    0x1(%r11),%r13
add    $0xffffffff,%eax
mov    %rax,0x40(%rsp)
lea    -0x1(%r11),%rbp
mov    %r11,%rbx
not    %rbx
lea    -0x8(%r11),%rax
mov    %r11d,%r12d
and    $0xfffffffe,%r12d
neg    %r12
lea    -0x9(%r11),%rcx
mov    $0x2,%r14d
mov    $0x1,%edx
mov    $0xd,%esi
mov    %rsi,0x18(%rsp)
mov    $0xe,%esi
mov    %rsi,0x28(%rsp)
xor    %esi,%esi
mov    %r11,0x38(%rsp)
mov    %rbp,0x8(%rsp)
mov    %rbx,0x30(%rsp)
jmp    11cf <elmhes+0xbf>
nopl   (%rax)
add    $0x1,%r14
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
mov    0x68(%rsp),%rsi
add    $0x1,%rsi
addq   $0x1,0x18(%rsp)
mov    0x78(%rsp),%rax
add    $0xffffffffffffffff,%rax
addq   $0x1,0x28(%rsp)
mov    0x70(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
cmp    0x40(%rsp),%rdx
je     1709 <elmhes+0x5f9>
mov    %rdx,0x20(%rsp)
mov    %rcx,0x70(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x80(%rsp)
mov    %rax,0x78(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x58(%rsp)
sub    %rsi,%rbp
mov    %rbp,0x10(%rsp)
lea    -0x8(%rbp),%rax
mov    %rax,0x90(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,0x88(%rsp)
mov    %rsi,0x68(%rsp)
not    %rsi
lea    (%rsi,%r13,1),%rax
add    $0xfffffffffffffff8,%rax
add    %r13,%rsi
mov    %rsi,0x60(%rsp)
mov    %rax,0x48(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,0x50(%rsp)
mov    %r14,%rbp
xorps  %xmm0,%xmm0
movss  %xmm0,(%rsp)
mov    %r14d,%eax
mov    %r14d,0x4(%rsp)
jmp    1279 <elmhes+0x169>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%r13
je     12c0 <elmhes+0x1b0>
mov    (%r15,%rbp,8),%rax
movss  -0x4(%rax,%r14,4),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbx
movss  (%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbx
jle    1270 <elmhes+0x160>
mov    (%r15,%rbp,8),%rax
movss  -0x4(%rax,%r14,4),%xmm0
movss  %xmm0,(%rsp)
mov    %ebp,%eax
mov    %ebp,0x4(%rsp)
jmp    1270 <elmhes+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
cmp    %rax,%r14
mov    0x38(%rsp),%r11
xorps  %xmm8,%xmm8
je     14b7 <elmhes+0x3a7>
movslq %ecx,%rax
mov    (%r15,%rax,8),%rcx
mov    (%r15,%r14,8),%rdx
mov    0x20(%rsp),%r9
mov    %r9,%rsi
mov    0x60(%rsp),%r8
cmp    $0x8,%r8
jb     13e0 <elmhes+0x2d0>
lea    (%rcx,%r9,4),%rsi
lea    (%rdx,%r13,4),%rdi
cmp    %rdi,%rsi
jae    131b <elmhes+0x20b>
lea    (%rcx,%r13,4),%rdi
lea    (%rdx,%r9,4),%rbp
mov    %r9,%rsi
cmp    %rdi,%rbp
jb     13e0 <elmhes+0x2d0>
cmpq   $0x8,0x48(%rsp)
mov    0x58(%rsp),%rbx
jae    132c <elmhes+0x21c>
xor    %edi,%edi
jmp    1398 <elmhes+0x288>
mov    0x18(%rsp),%rdi
lea    (%rdx,%rdi,4),%rsi
lea    (%rcx,%rdi,4),%rbp
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rbp,%rdi,4),%xmm0
movups -0x20(%rbp,%rdi,4),%xmm1
movups -0x30(%rsi,%rdi,4),%xmm2
movups -0x20(%rsi,%rdi,4),%xmm3
movups %xmm2,-0x30(%rbp,%rdi,4)
movups %xmm3,-0x20(%rbp,%rdi,4)
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm1,-0x20(%rsi,%rdi,4)
movups -0x10(%rbp,%rdi,4),%xmm0
movups 0x0(%rbp,%rdi,4),%xmm1
movups -0x10(%rsi,%rdi,4),%xmm2
movups (%rsi,%rdi,4),%xmm3
movups %xmm2,-0x10(%rbp,%rdi,4)
movups %xmm3,0x0(%rbp,%rdi,4)
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1340 <elmhes+0x230>
mov    %r8,%rsi
and    $0xfffffffffffffff8,%rsi
testb  $0x1,0x50(%rsp)
je     13cd <elmhes+0x2bd>
add    %r9,%rdi
movups (%rcx,%rdi,4),%xmm0
movups 0x10(%rcx,%rdi,4),%xmm1
movups (%rdx,%rdi,4),%xmm2
movups 0x10(%rdx,%rdi,4),%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
cmp    %rsi,%r8
mov    0x8(%rsp),%rbp
je     1445 <elmhes+0x335>
add    %r9,%rsi
nopw   0x0(%rax,%rax,1)
mov    %r13d,%ebp
sub    %esi,%ebp
mov    %rsi,%rdi
test   $0x1,%bpl
je     1406 <elmhes+0x2f6>
movss  (%rcx,%rsi,4),%xmm0
movss  (%rdx,%rsi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  %xmm0,(%rdx,%rsi,4)
lea    0x1(%rsi),%rdi
cmp    %rsi,%r11
mov    0x8(%rsp),%rbp
je     1445 <elmhes+0x335>
movss  (%rcx,%rdi,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm0
movss  0x4(%rdx,%rdi,4),%xmm1
movss  %xmm1,0x4(%rcx,%rdi,4)
movss  %xmm0,0x4(%rdx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1410 <elmhes+0x300>
mov    $0x1,%ecx
test   %rbp,%rbp
je     1497 <elmhes+0x387>
nop
mov    (%r15,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm0
movss  (%rdx,%r14,4),%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm0,(%rdx,%r14,4)
mov    0x8(%r15,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm0
movss  (%rdx,%r14,4),%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm0,(%rdx,%r14,4)
lea    (%r12,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    1450 <elmhes+0x340>
test   $0x1,%r11b
je     14b7 <elmhes+0x3a7>
mov    (%r15,%rcx,8),%rcx
movss  (%rcx,%rax,4),%xmm0
movss  (%rcx,%r14,4),%xmm1
movss  %xmm1,(%rcx,%rax,4)
movss  %xmm0,(%rcx,%r14,4)
movss  (%rsp),%xmm0
ucomiss %xmm8,%xmm0
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%rbx
movaps 0xb2e(%rip),%xmm9
jne    14da <elmhes+0x3ca>
jnp    1190 <elmhes+0x80>
mov    0x10(%rsp),%r9
and    $0xfffffffffffffff8,%r9
lea    (%r14,%r9,1),%r8
mov    %r14,%rdx
jmp    14f9 <elmhes+0x3e9>
nopl   0x0(%rax)
cmp    %r11,%rdx
je     1190 <elmhes+0x80>
mov    0x8(%r15,%rdx,8),%rsi
add    $0x1,%rdx
movss  -0x4(%rsi,%r14,4),%xmm0
ucomiss %xmm8,%xmm0
jne    1511 <elmhes+0x401>
jnp    14f0 <elmhes+0x3e0>
divss  (%rsp),%xmm0
movss  %xmm0,-0x4(%rsi,%r14,4)
mov    (%r15,%r14,8),%r10
movaps %xmm0,%xmm1
xorps  %xmm9,%xmm1
mov    %r14,%rax
cmpq   $0x8,0x10(%rsp)
jb     1630 <elmhes+0x520>
lea    (%rsi,%r14,4),%rax
lea    (%r10,%r13,4),%rcx
cmp    %rcx,%rax
jae    1558 <elmhes+0x448>
lea    (%rsi,%r13,4),%rcx
lea    (%r10,%r14,4),%rdi
mov    %r14,%rax
cmp    %rcx,%rdi
jb     1630 <elmhes+0x520>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
cmpq   $0x8,0x90(%rsp)
jae    156e <elmhes+0x45e>
xor    %ebx,%ebx
jmp    15eb <elmhes+0x4db>
mov    0x28(%rsp),%rax
lea    (%rsi,%rax,4),%rcx
lea    (%r10,%rax,4),%rax
mov    0x80(%rsp),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rax,%rbx,4),%xmm3
movups -0x20(%rax,%rbx,4),%xmm4
mulps  %xmm2,%xmm3
movups -0x30(%rcx,%rbx,4),%xmm5
addps  %xmm3,%xmm5
movups -0x20(%rcx,%rbx,4),%xmm3
movups -0x10(%rcx,%rbx,4),%xmm6
movups (%rcx,%rbx,4),%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm5,-0x30(%rcx,%rbx,4)
movups %xmm4,-0x20(%rcx,%rbx,4)
movups -0x10(%rax,%rbx,4),%xmm3
movups (%rax,%rbx,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm6,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movups %xmm3,-0x10(%rcx,%rbx,4)
movups %xmm4,(%rcx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1590 <elmhes+0x480>
testb  $0x1,0x88(%rsp)
01
je     1621 <elmhes+0x511>
add    %r14,%rbx
movups (%r10,%rbx,4),%xmm3
movups 0x10(%r10,%rbx,4),%xmm4
movups (%rsi,%rbx,4),%xmm5
movups 0x10(%rsi,%rbx,4),%xmm6
mulps  %xmm2,%xmm3
addps  %xmm5,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movups %xmm3,(%rsi,%rbx,4)
movups %xmm4,0x10(%rsi,%rbx,4)
mov    %r8,%rax
cmp    %r9,0x10(%rsp)
mov    0x30(%rsp),%rbx
je     1694 <elmhes+0x584>
mov    %r13d,%edi
sub    %eax,%edi
mov    %rax,%rcx
test   $0x1,%dil
je     1656 <elmhes+0x546>
movss  (%r10,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rsi,%rax,4),%xmm2
movss  %xmm2,(%rsi,%rax,4)
lea    0x1(%rax),%rcx
not    %rax
cmp    %rbx,%rax
je     1694 <elmhes+0x584>
xchg   %ax,%ax
movss  (%r10,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rsi,%rcx,4),%xmm2
movss  %xmm2,(%rsi,%rcx,4)
movss  0x4(%r10,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rsi,%rcx,4),%xmm2
movss  %xmm2,0x4(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1660 <elmhes+0x550>
mov    $0x1,%eax
test   %rbp,%rbp
je     16e5 <elmhes+0x5d5>
xchg   %ax,%ax
mov    (%r15,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r14,4),%xmm1
movss  %xmm1,(%rcx,%r14,4)
mov    0x8(%r15,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r14,4),%xmm1
movss  %xmm1,(%rcx,%r14,4)
lea    (%r12,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    16a0 <elmhes+0x590>
test   $0x1,%r11b
je     14f0 <elmhes+0x3e0>
mov    (%r15,%rax,8),%rax
mulss  (%rax,%rdx,4),%xmm0
addss  (%rax,%r14,4),%xmm0
movss  %xmm0,(%rax,%r14,4)
jmp    14f0 <elmhes+0x3e0>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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