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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float sqrt(float);
int h12(int mode, int *lpivot, int *l1, int m, float *u, int *iue, float *up,
        float *c__, int *ice, int *icv, int *ncv) {
  int u_dim1, u_offset, idx1, idx2;
  float d, d2;
  int incr;
  float b;
  int i__, j;
  float clinv;
  int i2, i3, i4;
  float cl, sm;
  u_dim1 = *iue;
  u_offset = u_dim1 + 1;
  u -= u_offset;
  --c__;
  if (0 >= *lpivot || *lpivot >= *l1 || *l1 > m) {
    return 0;
  }
  cl = (d = u[*lpivot * u_dim1 + 1], ((d) >= 0 ? (d) : -(d)));
  if (mode == 2) {
    goto L60;
  }
  idx1 = m;
  for (j = *l1; j <= idx1; ++j) {
    d2 = (d = u[j * u_dim1 + 1], ((d) >= 0 ? (d) : -(d)));
    cl = ((d2) >= (cl) ? (d2) : (cl));
  }
  if (cl <= 0.) {
    goto L130;
  } else {
    goto L20;
  }
L20:
  clinv = 1. / cl;
  d = u[*lpivot * u_dim1 + 1] * clinv;
  sm = d * d;
  idx1 = m;
  for (j = *l1; j <= idx1; ++j) {
    d = u[j * u_dim1 + 1] * clinv;
    sm += d * d;
  }
  cl *= sqrt(sm);
  if (u[*lpivot * u_dim1 + 1] <= 0.) {
    goto L50;
  } else {
    goto L40;
  }
L40:
  cl = -cl;
L50:
  *up = u[*lpivot * u_dim1 + 1] - cl;
  u[*lpivot * u_dim1 + 1] = cl;
  goto L70;
L60:
  if (cl <= 0.) {
    goto L130;
  } else {
    goto L70;
  }
L70:
  if (*ncv <= 0) {
    return 0;
  }
  b = *up * u[*lpivot * u_dim1 + 1];
  if (b >= 0.) {
    goto L130;
  } else {
    goto L80;
  }
L80:
  b = 1. / b;
  i2 = 1 - *icv + *ice * (*lpivot - 1);
  incr = *ice * (*l1 - *lpivot);
  idx1 = *ncv;
  for (j = 1; j <= idx1; ++j) {
    i2 += *icv;
    i3 = i2 + incr;
    i4 = i3;
    sm = c__[i2] * *up;
    idx2 = m;
    for (i__ = *l1; i__ <= idx2; ++i__) {
      sm += c__[i3] * u[i__ * u_dim1 + 1];
      i3 += *ice;
    }
    if (sm != 0.) {
      goto L100;
    } else {
      goto L120;
    }
  L100:
    sm *= b;
    c__[i2] += sm * *up;
    idx2 = m;
    for (i__ = *l1; i__ <= idx2; ++i__) {
      c__[i4] += sm * u[i__ * u_dim1 + 1];
      i4 += *ice;
    }
  L120:;
  }
L130:
  return 0;
}


x86 assembly (clang, -O0):
<h12>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
cmp    (%rcx),%eax
jge    11ac <h12+0x9c>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    11ac <h12+0x9c>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    -0x1c(%rbp),%eax
jle    11b8 <h12+0xa8>
movl   $0x0,-0x4(%rbp)
jmp    16db <h12+0x5cb>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     11f6 <h12+0xe6>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    120d <h12+0xfd>
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
cmpl   $0x2,-0x8(%rbp)
jne    1226 <h12+0x116>
jmp    145a <h12+0x34a>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     12dd <h12+0x1cd>
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     127c <h12+0x16c>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1293 <h12+0x183>
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x6c(%rbp),%xmm0
jb     12bb <h12+0x1ab>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    12c5 <h12+0x1b5>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1235 <h12+0x125>
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     12f8 <h12+0x1e8>
jmp    16d4 <h12+0x5c4>
jmp    12fd <h12+0x1ed>
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcf2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     13b2 <h12+0x2a2>
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    135c <h12+0x24c>
movss  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
mulss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     13f5 <h12+0x2e5>
jmp    1411 <h12+0x301>
jmp    13fa <h12+0x2ea>
movss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x6c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    147a <h12+0x36a>
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1475 <h12+0x365>
jmp    16d4 <h12+0x5c4>
jmp    147a <h12+0x36a>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jg     1493 <h12+0x383>
movl   $0x0,-0x4(%rbp)
jmp    16db <h12+0x5cb>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14d4 <h12+0x3c4>
jmp    16d4 <h12+0x5c4>
jmp    14d9 <h12+0x3c9>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb16(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    0x28(%rbp),%rcx
mov    $0x1,%eax
sub    (%rcx),%eax
mov    0x20(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x10(%rbp),%rdx
sub    (%rdx),%ecx
imul   %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     16cf <h12+0x5bf>
mov    0x28(%rbp),%rax
mov    (%rax),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     15ec <h12+0x4dc>
mov    0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1591 <h12+0x481>
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    160d <h12+0x4fd>
jp     160d <h12+0x4fd>
jmp    1612 <h12+0x502>
jmp    1617 <h12+0x507>
jmp    16bc <h12+0x5ac>
movss  -0x50(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     16b7 <h12+0x5a7>
movss  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    165c <h12+0x54c>
jmp    16bc <h12+0x5ac>
jmp    16c1 <h12+0x5b1>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1541 <h12+0x431>
jmp    16d4 <h12+0x5c4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<h12>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rcx,(%rsp)
mov    (%rsi),%eax
test   %eax,%eax
jle    16fd <h12+0x5ed>
mov    %rdx,%r15
mov    (%rdx),%edx
cmp    %edx,%eax
jge    16fd <h12+0x5ed>
cmp    (%rsp),%edx
jg     16fd <h12+0x5ed>
mov    %r8,%rbp
mov    %rsi,%r14
movslq (%r9),%r12
mov    %r12,%r13
not    %r13
lea    (%r8,%r13,4),%rsi
mov    %eax,%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
mov    %rsi,0x8(%rsp)
movss  0x4(%rsi,%rcx,4),%xmm1
movaps 0xe90(%rip),%xmm3
xorps  %xmm1,%xmm3
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
cmpless %xmm1,%xmm0
movaps %xmm0,%xmm4
andps  %xmm1,%xmm4
andnps %xmm3,%xmm0
orps   %xmm4,%xmm0
cmp    $0x2,%edi
jne    119d <h12+0x8d>
ucomiss %xmm0,%xmm2
jb     13d6 <h12+0x2c6>
jmp    16fd <h12+0x5ed>
movslq %edx,%rcx
mov    (%rsp),%rax
mov    %eax,%r9d
sub    %ecx,%r9d
add    $0x1,%r9d
mov    %eax,%r8d
sub    %edx,%r8d
test   $0x1,%r9b
jne    11c7 <h12+0xb7>
mov    %rcx,%rax
test   %r8d,%r8d
jne    1218 <h12+0x108>
jmp    12b8 <h12+0x1a8>
mov    %rcx,%rax
imul   %r12,%rax
mov    0x8(%rsp),%rdx
movss  0x4(%rdx,%rax,4),%xmm2
movaps 0xe20(%rip),%xmm3
xorps  %xmm2,%xmm3
xorps  %xmm4,%xmm4
cmpless %xmm2,%xmm4
andps  %xmm4,%xmm2
andnps %xmm3,%xmm4
orps   %xmm2,%xmm4
movaps %xmm0,%xmm6
cmpless %xmm4,%xmm6
movaps %xmm6,%xmm2
andps  %xmm4,%xmm2
andnps %xmm0,%xmm6
orps   %xmm2,%xmm6
lea    0x1(%rcx),%rax
movaps %xmm6,%xmm0
test   %r8d,%r8d
je     12b8 <h12+0x1a8>
mov    (%rsp),%rdx
mov    %edx,%edi
sub    %eax,%edi
add    $0x1,%edi
mov    %rax,%rsi
imul   %r12,%rsi
lea    0x4(,%r13,4),%rdx
add    %rbp,%rdx
lea    0x0(,%r12,8),%rbx
add    $0x1,%rax
imul   %r12,%rax
movaps 0xdb4(%rip),%xmm2
movaps %xmm0,%xmm6
nop
movss  (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm3
xorps  %xmm2,%xmm3
xorps  %xmm4,%xmm4
cmpless %xmm0,%xmm4
andps  %xmm4,%xmm0
andnps %xmm3,%xmm4
orps   %xmm0,%xmm4
movaps %xmm6,%xmm0
cmpless %xmm4,%xmm0
movaps %xmm0,%xmm3
andps  %xmm4,%xmm3
andnps %xmm6,%xmm0
orps   %xmm3,%xmm0
movss  (%rdx,%rax,4),%xmm3
movaps %xmm3,%xmm4
xorps  %xmm2,%xmm4
xorps  %xmm5,%xmm5
cmpless %xmm3,%xmm5
andps  %xmm5,%xmm3
andnps %xmm4,%xmm5
orps   %xmm3,%xmm5
movaps %xmm0,%xmm6
cmpless %xmm5,%xmm6
movaps %xmm6,%xmm3
andnps %xmm0,%xmm3
andps  %xmm5,%xmm6
orps   %xmm3,%xmm6
add    %rbx,%rdx
add    $0xfffffffe,%edi
jne    1250 <h12+0x140>
xorps  %xmm0,%xmm0
ucomiss %xmm6,%xmm0
jae    16fd <h12+0x5ed>
movss  0xd44(%rip),%xmm2
divss  %xmm6,%xmm2
mulss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
test   $0x1,%r9b
jne    12e0 <h12+0x1d0>
jmp    1305 <h12+0x1f5>
mov    %rcx,%rax
imul   %r12,%rax
mov    0x8(%rsp),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x1,%rcx
movaps %xmm0,%xmm1
test   %r8d,%r8d
je     136a <h12+0x25a>
mov    (%rsp),%rax
sub    %ecx,%eax
add    $0x1,%eax
mov    %rcx,%rdx
imul   %r12,%rdx
lea    0x4(,%r13,4),%rsi
add    %rbp,%rsi
lea    0x0(,%r12,8),%rdi
add    $0x1,%rcx
imul   %r12,%rcx
movaps %xmm1,%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rsi,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    %rdi,%rsi
add    $0xfffffffe,%eax
jne    1340 <h12+0x230>
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jb     1378 <h12+0x268>
sqrtss %xmm0,%xmm0
jmp    138a <h12+0x27a>
movaps %xmm6,0x30(%rsp)
call   1030 <sqrt@plt>
xorps  %xmm3,%xmm3
movaps 0x30(%rsp),%xmm6
mulss  %xmm0,%xmm6
mov    (%r14),%eax
mov    %eax,%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
mov    0x8(%rsp),%rsi
movss  0x4(%rsi,%rcx,4),%xmm0
movaps 0xc54(%rip),%xmm1
xorps  %xmm6,%xmm1
movaps %xmm0,%xmm2
cmpnless %xmm3,%xmm2
andps  %xmm2,%xmm1
andnps %xmm6,%xmm2
orps   %xmm1,%xmm2
subss  %xmm2,%xmm0
mov    0xb0(%rsp),%rdx
movss  %xmm0,(%rdx)
movss  %xmm2,0x4(%rsi,%rcx,4)
mov    0xd0(%rsp),%rcx
mov    (%rcx),%r14d
test   %r14d,%r14d
jle    16fd <h12+0x5ed>
mov    0xb0(%rsp),%rcx
movss  (%rcx),%xmm2
mov    %eax,%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
mov    0x8(%rsp),%rdx
movss  0x4(%rdx,%rcx,4),%xmm3
mulss  %xmm2,%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jae    16fd <h12+0x5ed>
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rdx
mov    0xb8(%rsp),%rsi
add    $0xfffffffffffffffc,%rsi
movss  0xbd2(%rip),%xmm1
divss  %xmm3,%xmm1
movslq (%rcx),%rdi
movslq (%rdx),%rdx
movslq (%r15),%rbx
mov    %rsi,%r15
add    $0xffffffff,%eax
imul   %edx,%eax
sub    %edi,%eax
add    $0x1,%eax
lea    -0x1(%rbx),%r8d
imul   %edx,%r8d
add    $0x1,%r8d
mov    (%rsp),%rcx
lea    0x1(%rcx),%esi
movslq %eax,%r9
mov    %esi,0x14(%rsp)
sub    %ebx,%esi
mov    %esi,0x1c(%rsp)
mov    %ecx,%eax
sub    %ebx,%eax
mov    %eax,0x18(%rsp)
mov    %rbx,%rax
imul   %r12,%rax
mov    %rax,0x50(%rsp)
mov    %rbx,0x30(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%r12,4),%rax
mov    %rax,0x60(%rsp)
lea    0x4(,%r13,4),%rax
add    %rbp,%rax
mov    %rax,0x58(%rsp)
mov    %rdi,%r13
shl    $0x3,%r12
mov    %rdx,0x20(%rsp)
lea    0x0(,%rdx,8),%rax
mov    $0x1,%r10d
mov    %r14d,0x2c(%rsp)
mov    %r15,0x68(%rsp)
mov    %rdi,0x70(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r13,%r9
movss  (%r15,%r9,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
mov    0x30(%rsp),%rcx
cmp    (%rsp),%ecx
jle    1530 <h12+0x420>
ucomiss %xmm0,%xmm5
jne    1515 <h12+0x405>
jnp    16e0 <h12+0x5d0>
mulss  %xmm1,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%r15,%r9,4)
jmp    16e0 <h12+0x5d0>
nopl   0x0(%rax)
movslq %r8d,%r11
testb  $0x1,0x1c(%rsp)
jne    1550 <h12+0x440>
mov    0x30(%rsp),%r14
mov    %r11,%r13
cmpl   $0x0,0x18(%rsp)
jne    1582 <h12+0x472>
jmp    15ea <h12+0x4da>
xchg   %ax,%ax
movss  (%r15,%r11,4),%xmm3
mov    0x8(%rsp),%rcx
mov    0x50(%rsp),%rdx
mulss  0x4(%rcx,%rdx,4),%xmm3
addss  %xmm5,%xmm3
mov    0x20(%rsp),%rcx
lea    (%r11,%rcx,1),%r13
mov    0x48(%rsp),%r14
movaps %xmm3,%xmm5
cmpl   $0x0,0x18(%rsp)
je     15ea <h12+0x4da>
mov    0x14(%rsp),%edx
sub    %r14d,%edx
mov    0x60(%rsp),%rcx
mov    %rcx,%r15
imul   %r14,%r15
add    $0x1,%r14
imul   %rcx,%r14
mov    0x20(%rsp),%rcx
add    %r13,%rcx
mov    0x68(%rsp),%rbx
mov    0x58(%rsp),%rdi
movaps %xmm5,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rbx,%r13,4),%xmm5
mulss  (%rdi,%r15,1),%xmm5
addss  %xmm3,%xmm5
movss  (%rbx,%rcx,4),%xmm3
mulss  (%rdi,%r14,1),%xmm3
addss  %xmm5,%xmm3
add    %r12,%rdi
add    %rax,%rbx
add    $0xfffffffe,%edx
jne    15c0 <h12+0x4b0>
ucomiss %xmm0,%xmm3
mov    0x2c(%rsp),%r14d
mov    0x68(%rsp),%r15
mov    0x70(%rsp),%r13
jne    1604 <h12+0x4f4>
jnp    16e0 <h12+0x5d0>
mulss  %xmm1,%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%r15,%r9,4)
mov    0x30(%rsp),%rcx
cmp    (%rsp),%ecx
jg     16e0 <h12+0x5d0>
testb  $0x1,0x1c(%rsp)
jne    163c <h12+0x52c>
mov    0x30(%rsp),%rdx
cmpl   $0x0,0x18(%rsp)
jne    166d <h12+0x55d>
jmp    16e0 <h12+0x5d0>
mov    0x8(%rsp),%rcx
mov    0x50(%rsp),%rdx
movss  0x4(%rcx,%rdx,4),%xmm2
mulss  %xmm3,%xmm2
addss  (%r15,%r11,4),%xmm2
movss  %xmm2,(%r15,%r11,4)
add    0x20(%rsp),%r11
mov    0x48(%rsp),%rdx
cmpl   $0x0,0x18(%rsp)
je     16e0 <h12+0x5d0>
mov    0x14(%rsp),%ecx
sub    %edx,%ecx
mov    0x60(%rsp),%rsi
mov    %rsi,%rbx
imul   %rdx,%rbx
add    $0x1,%rdx
imul   %rsi,%rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%r11,1),%rdi
mov    %r15,%rsi
mov    0x58(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rbx,1),%xmm2
mulss  %xmm3,%xmm2
addss  (%rsi,%r11,4),%xmm2
movss  %xmm2,(%rsi,%r11,4)
movss  0x0(%rbp,%rdx,1),%xmm2
mulss  %xmm3,%xmm2
addss  (%rsi,%rdi,4),%xmm2
movss  %xmm2,(%rsi,%rdi,4)
add    %r12,%rbp
add    %rax,%rsi
add    $0xfffffffe,%ecx
jne    16a0 <h12+0x590>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r14d,%r10d
je     16fd <h12+0x5ed>
add    $0x1,%r10d
add    %r13d,%r8d
mov    0xb0(%rsp),%rcx
movss  (%rcx),%xmm2
jmp    14f0 <h12+0x3e0>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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