#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 */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ sgeqrf_(int *, int *, float *, int *, float *, float *,
                           int *, int *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strtrs_(char *, char *, char *, int *, int *, float *, int *,
                           float *, int *, int *);
int sAx_eq_b_QRLS(float *A, float *B, float *x, int m, int n) {
  static float *buf = NULL;
  static int buf_sz = 0;
  static int nb = 0;
  float *a, *tau, *r, *work;
  int a_sz, tau_sz, r_sz, tot_sz;
  register int i, j;
  int info, worksz, nrhs = 1;
  register float sum;
  if (!A) {
    if (buf)
      free(buf);
    buf = NULL;
    buf_sz = 0;
    return 1;
  }
  if (m < n) {
    fprintf(stderr,
            "Normal equations require that the number of rows is greater than "
            "number of columns in "
            "sAx_eq_b_QRLS"
            "() [%d x %d]! -- try transposing\n",
            m, n);
    exit(1);
  }
  a_sz = m * n;
  tau_sz = n;
  r_sz = n * n;
  if (!nb) {
    float tmp;
    worksz = -1;
    sgeqrf_((int *)&m, (int *)&m, NULL, (int *)&m, NULL, (float *)&tmp,
            (int *)&worksz, (int *)&info);
    nb = ((int)tmp) / m;
  }
  worksz = nb * m;
  tot_sz = a_sz + tau_sz + r_sz + worksz;
  if (tot_sz > buf_sz) {
    if (buf)
      free(buf);
    buf_sz = tot_sz;
    buf = (float *)malloc(buf_sz * sizeof(float));
    if (!buf) {
      fprintf(stderr, "memory allocation in "
                      "sAx_eq_b_QRLS"
                      "() failed!\n");
      exit(1);
    }
  }
  a = buf;
  tau = a + a_sz;
  r = tau + tau_sz;
  work = r + r_sz;
  for (i = 0; i < m; i++)
    for (j = 0; j < n; j++)
      a[i + j * m] = A[i * n + j];
  for (i = 0; i < n; i++) {
    for (j = 0, sum = 0.0; j < m; j++)
      sum += A[j * n + i] * B[j];
    x[i] = sum;
  }
  sgeqrf_((int *)&m, (int *)&n, a, (int *)&m, tau, work, (int *)&worksz,
          (int *)&info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "sgeqrf_"
              " in "
              "sAx_eq_b_QRLS"
              "()\n",
              -info);
      exit(1);
    } else {
      fprintf(stderr,
              "Unknown LAPACK error %d for "
              "sgeqrf_"
              " in "
              "sAx_eq_b_QRLS"
              "()\n",
              info);
      return 0;
    }
  }
  for (j = 0; j < n; j++) {
    for (i = 0; i <= j; i++)
      r[i + j * n] = a[i + j * m];
    for (i = j + 1; i < n; i++)
      r[i + j * n] = 0.0;
  }
  strtrs_("U", "T", "N", (int *)&n, (int *)&nrhs, r, (int *)&n, x, (int *)&n,
          &info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "strtrs_"
              " in "
              "sAx_eq_b_QRLS"
              "()\n",
              -info);
      exit(1);
    } else {
      fprintf(stderr,
              "LAPACK error: the %d-th diagonal element of A is zero (singular "
              "matrix) in "
              "sAx_eq_b_QRLS"
              "()\n",
              info);
      return 0;
    }
  }
  strtrs_("U", "N", "N", (int *)&n, (int *)&nrhs, r, (int *)&n, x, (int *)&n,
          &info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "strtrs_"
              " in "
              "sAx_eq_b_QRLS"
              "()\n",
              -info);
      exit(1);
    } else {
      fprintf(stderr,
              "LAPACK error: the %d-th diagonal element of A is zero (singular "
              "matrix) in "
              "sAx_eq_b_QRLS"
              "()\n",
              info);
      return 0;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<sAx_eq_b_QRLS>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movl   $0x1,-0x6c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    11cb <sAx_eq_b_QRLS+0x6b>
cmpq   $0x0,0x2ec0(%rip)
je     11aa <sAx_eq_b_QRLS+0x4a>
mov    0x2eb3(%rip),%rdi
call   1030 <free@plt>
movq   $0x0,0x2ea3(%rip)
movl   $0x0,0x2ea1(%rip)
movl   $0x1,-0x4(%rbp)
jmp    16d9 <sAx_eq_b_QRLS+0x579>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11fe <sAx_eq_b_QRLS+0x9e>
mov    0x2e02(%rip),%rax
mov    (%rax),%edi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0xe13(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,0x2e45(%rip)
jne    1267 <sAx_eq_b_QRLS+0x107>
movl   $0xffffffff,-0x68(%rbp)
lea    -0x24(%rbp),%rcx
xor    %eax,%eax
mov    %eax,%r8d
lea    -0x74(%rbp),%r9
lea    -0x68(%rbp),%r10
lea    -0x64(%rbp),%rax
mov    %rcx,%rdi
mov    %rcx,%rsi
mov    %r8,%rdx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1080 <sgeqrf_@plt>
cvttss2si -0x74(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %eax,0x2dfd(%rip)
mov    0x2df7(%rip),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x2dd4(%rip),%eax
jle    1302 <sAx_eq_b_QRLS+0x1a2>
cmpq   $0x0,0x2dbe(%rip)
je     12ac <sAx_eq_b_QRLS+0x14c>
mov    0x2db1(%rip),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%eax
mov    %eax,0x2dab(%rip)
movslq 0x2da4(%rip),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,0x2d8a(%rip)
cmpq   $0x0,0x2d82(%rip)
jne    12fd <sAx_eq_b_QRLS+0x19d>
mov    0x2cfd(%rip),%rax
mov    (%rax),%edi
lea    0xd99(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    1302 <sAx_eq_b_QRLS+0x1a2>
mov    0x2d4f(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13bb <sAx_eq_b_QRLS+0x25b>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13a8 <sAx_eq_b_QRLS+0x248>
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1360 <sAx_eq_b_QRLS+0x200>
jmp    13ad <sAx_eq_b_QRLS+0x24d>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    134d <sAx_eq_b_QRLS+0x1ed>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    144c <sAx_eq_b_QRLS+0x2ec>
movl   $0x0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    142c <sAx_eq_b_QRLS+0x2cc>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13dd <sAx_eq_b_QRLS+0x27d>
movss  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13c2 <sAx_eq_b_QRLS+0x262>
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%r8
mov    -0x48(%rbp),%r9
lea    -0x24(%rbp),%rcx
lea    -0x28(%rbp),%rsi
lea    -0x68(%rbp),%r10
lea    -0x64(%rbp),%rax
mov    %rcx,%rdi
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1080 <sgeqrf_@plt>
cmpl   $0x0,-0x64(%rbp)
je     14d9 <sAx_eq_b_QRLS+0x379>
cmpl   $0x0,-0x64(%rbp)
jge    14b3 <sAx_eq_b_QRLS+0x353>
mov    0x2b4c(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x64(%rbp),%edx
lea    0xc11(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    0x2b26(%rip),%rax
mov    (%rax),%edi
mov    -0x64(%rbp),%edx
lea    0xc38(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    16d9 <sAx_eq_b_QRLS+0x579>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    158e <sAx_eq_b_QRLS+0x42e>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     153d <sAx_eq_b_QRLS+0x3dd>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    14f3 <sAx_eq_b_QRLS+0x393>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    157b <sAx_eq_b_QRLS+0x41b>
mov    -0x40(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1546 <sAx_eq_b_QRLS+0x3e6>
jmp    1580 <sAx_eq_b_QRLS+0x420>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14e0 <sAx_eq_b_QRLS+0x380>
mov    -0x40(%rbp),%r9
mov    -0x20(%rbp),%r11
lea    0xb99(%rip),%rdi
lea    0xb94(%rip),%rsi
lea    0xb8f(%rip),%rdx
lea    -0x28(%rbp),%r10
lea    -0x6c(%rbp),%r8
lea    -0x64(%rbp),%rax
mov    %r10,%rcx
mov    %r10,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1040 <strtrs_@plt>
cmpl   $0x0,-0x64(%rbp)
je     1632 <sAx_eq_b_QRLS+0x4d2>
cmpl   $0x0,-0x64(%rbp)
jge    160c <sAx_eq_b_QRLS+0x4ac>
mov    0x29f3(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x64(%rbp),%edx
lea    0xb41(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    0x29cd(%rip),%rax
mov    (%rax),%edi
mov    -0x64(%rbp),%edx
lea    0xb68(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    16d9 <sAx_eq_b_QRLS+0x579>
mov    -0x40(%rbp),%r9
mov    -0x20(%rbp),%r11
lea    0xaf5(%rip),%rdi
lea    0xaf2(%rip),%rdx
lea    -0x28(%rbp),%r10
lea    -0x6c(%rbp),%r8
lea    -0x64(%rbp),%rax
mov    %rdx,%rsi
mov    %r10,%rcx
mov    %r10,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1040 <strtrs_@plt>
cmpl   $0x0,-0x64(%rbp)
je     16d2 <sAx_eq_b_QRLS+0x572>
cmpl   $0x0,-0x64(%rbp)
jge    16ac <sAx_eq_b_QRLS+0x54c>
mov    0x2953(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x64(%rbp),%edx
lea    0xaa1(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    0x292d(%rip),%rax
mov    (%rax),%edi
mov    -0x64(%rbp),%edx
lea    0xac8(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    16d9 <sAx_eq_b_QRLS+0x579>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sAx_eq_b_QRLS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %ecx,0x8(%rsp)
mov    %r8d,0xc(%rsp)
movl   $0x1,0x1c(%rsp)
test   %rdi,%rdi
je     144f <sAx_eq_b_QRLS+0x2df>
mov    %r8d,%r14d
mov    %rdx,0x50(%rsp)
cmp    %r8d,%ecx
jl     1888 <sAx_eq_b_QRLS+0x718>
mov    %rsi,%rbx
mov    %rdi,%r12
mov    %r14d,%r13d
imul   %ecx,%r13d
mov    %r14d,%r15d
imul   %r14d,%r15d
mov    0x2ea6(%rip),%eax
test   %eax,%eax
jne    120f <sAx_eq_b_QRLS+0x9f>
movl   $0xffffffff,0x18(%rsp)
ff
lea    0x4(%rsp),%rax
lea    0x18(%rsp),%rbp
lea    0x8(%rsp),%rcx
lea    0x4c(%rsp),%r9
mov    %rcx,%rdi
mov    %rcx,%rsi
xor    %edx,%edx
xor    %r8d,%r8d
push   %rax
push   %rbp
call   1090 <sgeqrf_@plt>
add    $0x10,%rsp
cvttss2si 0x4c(%rsp),%eax
mov    0x8(%rsp),%ecx
cltd
idiv   %ecx
mov    %eax,0x2e5d(%rip)
imul   %ecx,%eax
mov    %eax,0x18(%rsp)
lea    (%r14,%r13,1),%ebp
add    %r15d,%ebp
add    %eax,%ebp
mov    0x2e3a(%rip),%rax
cmp    0x2e3c(%rip),%ebp
jle    125f <sAx_eq_b_QRLS+0xef>
test   %rax,%rax
je     123b <sAx_eq_b_QRLS+0xcb>
mov    %rax,%rdi
call   1030 <free@plt>
mov    %ebp,0x2e27(%rip)
shl    $0x2,%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x2e0e(%rip)
test   %rax,%rax
je     18b9 <sAx_eq_b_QRLS+0x749>
mov    0x8(%rsp),%ecx
movslq %r13d,%rdx
mov    %rax,0x30(%rsp)
mov    %rdx,0x28(%rsp)
lea    (%rax,%rdx,4),%rdx
movslq %r14d,%rax
mov    %rax,0x38(%rsp)
mov    %rdx,0x10(%rsp)
lea    (%rdx,%rax,4),%rax
mov    %rax,0x20(%rsp)
mov    %r15d,%r8d
movslq 0xc(%rsp),%r14
mov    %r14d,%r15d
mov    %ecx,%r11d
test   %ecx,%ecx
jle    133e <sAx_eq_b_QRLS+0x1ce>
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    0x4(%r12),%rbp
lea    0x0(,%r14,4),%r10
lea    0x0(,%r11,8),%rsi
xor    %edi,%edi
mov    0x30(%rsp),%r9
jmp    12d0 <sAx_eq_b_QRLS+0x160>
add    $0x1,%rdi
add    %r10,%rbp
add    $0x4,%r9
cmp    %r11,%rdi
je     133e <sAx_eq_b_QRLS+0x1ce>
test   %r14d,%r14d
jle    12c0 <sAx_eq_b_QRLS+0x150>
cmp    $0x1,%r15d
jne    12e0 <sAx_eq_b_QRLS+0x170>
xor    %r13d,%r13d
jmp    1314 <sAx_eq_b_QRLS+0x1a4>
mov    %r9,%rdx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rbp,%r13,4),%xmm0
movss  %xmm0,(%rdx)
movss  0x0(%rbp,%r13,4),%xmm0
movss  %xmm0,(%rdx,%r11,4)
add    $0x2,%r13
add    %rsi,%rdx
cmp    %r13,%rax
jne    12f0 <sAx_eq_b_QRLS+0x180>
test   $0x1,%r15b
je     12c0 <sAx_eq_b_QRLS+0x150>
mov    %rdi,%rdx
imul   %r14,%rdx
add    %r13,%rdx
movss  (%r12,%rdx,4),%xmm0
imul   %r11,%r13
add    %rdi,%r13
mov    0x30(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
jmp    12c0 <sAx_eq_b_QRLS+0x150>
mov    0x20(%rsp),%rax
lea    (%rax,%r8,4),%r9
test   %r15d,%r15d
mov    0x50(%rsp),%r8
jle    13fd <sAx_eq_b_QRLS+0x28d>
mov    %r11d,%esi
and    $0xfffffffe,%esi
lea    0x0(,%r15,8),%rdi
xor    %ebp,%ebp
mov    %r12,%r10
jmp    1383 <sAx_eq_b_QRLS+0x213>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%r8,%rbp,4)
add    $0x1,%rbp
add    $0x4,%r10
cmp    %r15,%rbp
je     13fd <sAx_eq_b_QRLS+0x28d>
xorps  %xmm0,%xmm0
test   %ecx,%ecx
jle    1370 <sAx_eq_b_QRLS+0x200>
cmp    $0x1,%ecx
jne    13a0 <sAx_eq_b_QRLS+0x230>
xor    %eax,%eax
jmp    13d9 <sAx_eq_b_QRLS+0x269>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdx),%xmm1
mulss  (%rbx,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  (%rdx,%r15,4),%xmm0
mulss  0x4(%rbx,%rax,4),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%rax
add    %rdi,%rdx
cmp    %rax,%rsi
jne    13b0 <sAx_eq_b_QRLS+0x240>
test   $0x1,%r11b
je     1370 <sAx_eq_b_QRLS+0x200>
mov    %rax,%rdx
imul   %r15,%rdx
add    %rbp,%rdx
movss  (%r12,%rdx,4),%xmm1
mulss  (%rbx,%rax,4),%xmm1
addss  %xmm1,%xmm0
jmp    1370 <sAx_eq_b_QRLS+0x200>
lea    0x4(%rsp),%rbp
lea    0x18(%rsp),%rax
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rcx
mov    %rcx,%rdi
mov    0x30(%rsp),%rbx
mov    %rbx,%rdx
mov    0x10(%rsp),%r8
push   %rbp
push   %rax
call   1090 <sgeqrf_@plt>
add    $0x10,%rsp
mov    0x4(%rsp),%edx
test   %edx,%edx
je     147f <sAx_eq_b_QRLS+0x30f>
mov    0x2ba5(%rip),%rax
mov    (%rax),%edi
js     18ae <sAx_eq_b_QRLS+0x73e>
lea    0xcb4(%rip),%rsi
jmp    1864 <sAx_eq_b_QRLS+0x6f4>
mov    0x2c0a(%rip),%rdi
test   %rdi,%rdi
je     1460 <sAx_eq_b_QRLS+0x2f0>
call   1030 <free@plt>
movq   $0x0,0x2bf5(%rip)
movl   $0x0,0x2bf3(%rip)
mov    $0x1,%ebx
jmp    186d <sAx_eq_b_QRLS+0x6fd>
mov    0xc(%rsp),%r10d
test   %r10d,%r10d
jle    17d2 <sAx_eq_b_QRLS+0x662>
mov    %rbx,%r9
movslq 0x8(%rsp),%r11
mov    0x38(%rsp),%rax
add    0x28(%rsp),%rax
lea    (%rbx,%rax,4),%rcx
mov    %rcx,0x58(%rsp)
lea    0x1(%r10),%ecx
mov    %ecx,0x48(%rsp)
lea    -0x2(%r10),%ecx
mov    %ecx,0x44(%rsp)
lea    0x4(%rbx,%rax,4),%rcx
mov    %rcx,0x78(%rsp)
lea    0x0(,%r10,4),%rcx
mov    %rcx,0xa0(%rsp)
lea    0x4(,%r10,4),%rcx
mov    %rcx,0x70(%rsp)
lea    0x4(%rbx),%rcx
mov    %rcx,0x88(%rsp)
lea    0x0(,%r11,4),%rcx
mov    %rcx,0x98(%rsp)
lea    0x4(,%r11,4),%rcx
mov    %rcx,0x80(%rsp)
lea    0x30(%rbx),%r15
mov    %rax,0x38(%rsp)
lea    0x30(%rbx,%rax,4),%r12
mov    $0x1,%r13d
mov    $0xfffffffffffffff9,%rbx
mov    $0x2,%r14d
mov    $0x3,%eax
mov    %rax,0x60(%rsp)
xor    %ebp,%ebp
mov    %r9,0x68(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,0x28(%rsp)
jmp    1589 <sAx_eq_b_QRLS+0x419>
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x98(%rsp),%rcx
add    %rcx,%r15
mov    0xa0(%rsp),%rax
add    %rax,%r12
add    $0x1,%rbx
add    %rax,0x28(%rsp)
add    %rcx,0x68(%rsp)
add    %r10,%r14
add    %r11,0x60(%rsp)
cmp    %r10,%rbp
je     17d2 <sAx_eq_b_QRLS+0x662>
mov    %rbp,%rax
lea    -0x7(%rbp),%r8
add    $0x1,%rbp
mov    %rax,%rsi
sub    $0x7,%rsi
mov    %rbp,0x10(%rsp)
jae    15b0 <sAx_eq_b_QRLS+0x440>
xor    %edi,%edi
jmp    16b0 <sAx_eq_b_QRLS+0x540>
nopl   0x0(%rax)
mov    %rax,%rdx
imul   %r11,%rdx
mov    %rax,%rcx
imul   %r10,%rcx
mov    0x80(%rsp),%rdi
imul   %rax,%rdi
add    0x88(%rsp),%rdi
mov    0x38(%rsp),%rbp
add    %rcx,%rbp
lea    (%r9,%rbp,4),%rbp
cmp    %rbp,%rdi
jbe    1610 <sAx_eq_b_QRLS+0x4a0>
lea    (%r9,%rdx,4),%rdi
mov    0x70(%rsp),%rbp
imul   %rax,%rbp
add    0x78(%rsp),%rbp
cmp    %rdi,%rbp
jbe    1610 <sAx_eq_b_QRLS+0x4a0>
xor    %edi,%edi
mov    0x10(%rsp),%rbp
jmp    16b0 <sAx_eq_b_QRLS+0x540>
cs nopw 0x0(%rax,%rax,1)
shr    $0x3,%r8
add    $0x1,%r8
cmp    $0x8,%rsi
jae    1627 <sAx_eq_b_QRLS+0x4b7>
xor    %esi,%esi
mov    0x10(%rsp),%rbp
jmp    1678 <sAx_eq_b_QRLS+0x508>
mov    %rbx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rbp
nopl   (%rax)
movups -0x30(%r15,%rsi,4),%xmm0
movups -0x20(%r15,%rsi,4),%xmm1
movups %xmm0,-0x30(%r12,%rsi,4)
movups %xmm1,-0x20(%r12,%rsi,4)
movups -0x10(%r15,%rsi,4),%xmm0
movups (%r15,%rsi,4),%xmm1
movups %xmm0,-0x10(%r12,%rsi,4)
movups %xmm1,(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1640 <sAx_eq_b_QRLS+0x4d0>
mov    %rbp,%rdi
and    $0xfffffffffffffff8,%rdi
test   $0x1,%r8b
je     16a4 <sAx_eq_b_QRLS+0x534>
add    %rsi,%rdx
movups (%r9,%rdx,4),%xmm0
movups 0x10(%r9,%rdx,4),%xmm1
add    %rsi,%rcx
mov    0x20(%rsp),%rdx
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
cmp    %rdi,%rbp
je     1767 <sAx_eq_b_QRLS+0x5f7>
nopl   (%rax)
mov    %rax,%rcx
sub    %rdi,%rcx
test   $0x3,%r13b
je     16ff <sAx_eq_b_QRLS+0x58f>
mov    %rbx,%r8
mov    %r13d,%edx
and    $0x3,%edx
mov    0x28(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
mov    0x68(%rsp),%rbx
lea    (%rbx,%rdi,4),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    16e0 <sAx_eq_b_QRLS+0x570>
add    %rbx,%rdi
mov    %r8,%rbx
mov    0x10(%rsp),%rbp
cmp    $0x3,%rcx
jb     1767 <sAx_eq_b_QRLS+0x5f7>
mov    %rax,%rcx
sub    %rdi,%rcx
lea    (%rdi,%r14,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
add    0x60(%rsp),%rdi
lea    (%r9,%rdi,4),%rsi
mov    $0xffffffffffffffff,%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rdi,4)
movss  -0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rdi,4)
movss  0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1730 <sAx_eq_b_QRLS+0x5c0>
cmp    %r10,%rbp
jae    1550 <sAx_eq_b_QRLS+0x3e0>
mov    0x48(%rsp),%ecx
imul   %eax,%ecx
add    $0x1,%ecx
mov    0x44(%rsp),%edx
sub    %eax,%edx
movslq %ecx,%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
lea    0x4(,%rdx,4),%rdx
xor    %esi,%esi
mov    %r13,0x90(%rsp)
mov    %r14,%r13
mov    %rbx,%r14
mov    %r10,%rbx
mov    %r11,%rbp
call   1050 <memset@plt>
mov    %rbp,%r11
mov    0x10(%rsp),%rbp
mov    %rbx,%r10
mov    %r14,%rbx
mov    %r13,%r14
mov    0x90(%rsp),%r13
mov    0x30(%rsp),%r9
jmp    1550 <sAx_eq_b_QRLS+0x3e0>
lea    0x95d(%rip),%rdi
lea    0x958(%rip),%rsi
lea    0x953(%rip),%rdx
lea    0x1c(%rsp),%r8
lea    0xc(%rsp),%r14
mov    %r14,%rcx
mov    0x20(%rsp),%rbp
mov    %rbp,%r9
lea    0x4(%rsp),%r15
push   %r15
push   %r14
mov    0x60(%rsp),%rbx
push   %rbx
push   %r14
call   1040 <strtrs_@plt>
add    $0x20,%rsp
mov    0x4(%rsp),%edx
test   %edx,%edx
jne    1852 <sAx_eq_b_QRLS+0x6e2>
lea    0x911(%rip),%rdi
lea    0x90e(%rip),%rdx
lea    0x1c(%rsp),%r8
mov    %rdx,%rsi
mov    %r14,%rcx
mov    %rbp,%r9
push   %r15
push   %r14
push   %rbx
push   %r14
call   1040 <strtrs_@plt>
add    $0x20,%rsp
mov    0x4(%rsp),%edx
test   %edx,%edx
je     1881 <sAx_eq_b_QRLS+0x711>
mov    0x2787(%rip),%rax
mov    (%rax),%edi
js     18da <sAx_eq_b_QRLS+0x76a>
lea    0x923(%rip),%rsi
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    %ebx,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebx
jmp    186d <sAx_eq_b_QRLS+0x6fd>
mov    0x2751(%rip),%rax
mov    (%rax),%edi
lea    0x768(%rip),%rsi
mov    %ecx,%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
neg    %edx
lea    0x7fc(%rip),%rsi
jmp    18e3 <sAx_eq_b_QRLS+0x773>
mov    0x2720(%rip),%rax
mov    (%rax),%edi
lea    0x7bc(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
neg    %edx
lea    0x859(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@sAx_eq_b_QRLS.buf = internal global float* null
@sAx_eq_b_QRLS.buf_sz = internal global i32 0
@sAx_eq_b_QRLS.nb = internal global i32 0
@stderr = global i32 0
@.str = [133 x i8] c"Normal equations require that the number of rows is greater than number of columns in sAx_eq_b_QRLS() [%d x %d]! -- try transposing\0A\00"
@.str.1 = [46 x i8] c"memory allocation in sAx_eq_b_QRLS() failed!\0A\00"
@.str.2 = [75 x i8] c"LAPACK error: illegal value for argument %d of sgeqrf_ in sAx_eq_b_QRLS()\0A\00"
@.str.3 = [56 x i8] c"Unknown LAPACK error %d for sgeqrf_ in sAx_eq_b_QRLS()\0A\00"
@.str.4 = [2 x i8] c"U\00"
@.str.5 = [2 x i8] c"T\00"
@.str.6 = [2 x i8] c"N\00"
@.str.7 = [75 x i8] c"LAPACK error: illegal value for argument %d of strtrs_ in sAx_eq_b_QRLS()\0A\00"
@.str.8 = [92 x i8] c"LAPACK error: the %d-th diagonal element of A is zero (singular matrix) in sAx_eq_b_QRLS()\0A\00"
define i32 @sAx_eq_b_QRLS(float* %0, float* %1, float* %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca float
%26 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store float* %2, float** %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 1, i32* %24
%27 = load float*, float** %7
%28 = icmp ne float* %27, null
br i1 %28, label %36, label %29
29: ; preds = %5
%30 = load float*, float** @sAx_eq_b_QRLS.buf
%31 = icmp ne float* %30, null
br i1 %31, label %32, label %35
32: ; preds = %29
%33 = load float*, float** @sAx_eq_b_QRLS.buf
%34 = call i32 @free(float* %33)
br label %35
35: ; preds = %32, %29
store float* null, float** @sAx_eq_b_QRLS.buf
store i32 0, i32* @sAx_eq_b_QRLS.buf_sz
store i32 1, i32* %6
br label %297
36: ; preds = %5
%37 = load i32, i32* %10
%38 = load i32, i32* %11
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %46
40: ; preds = %36
%41 = load i32, i32* @stderr
%42 = load i32, i32* %10
%43 = load i32, i32* %11
%44 = call i32 (i32, i8*, ...) @fprintf(i32 %41, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 %42, i32 %43)
%45 = call i32 @exit(i32 1)
unreachable
46: ; preds = %36
%47 = load i32, i32* %10
%48 = load i32, i32* %11
%49 = mul nsw i32 %47, %48
store i32 %49, i32* %16
%50 = load i32, i32* %11
store i32 %50, i32* %17
%51 = load i32, i32* %11
%52 = load i32, i32* %11
%53 = mul nsw i32 %51, %52
store i32 %53, i32* %18
%54 = load i32, i32* @sAx_eq_b_QRLS.nb
%55 = icmp ne i32 %54, 0
br i1 %55, label %62, label %56
56: ; preds = %46
store i32 -1, i32* %23
%57 = call i32 @sgeqrf_(i32* %10, i32* %10, float* null, i32* %10, float* null, float* %26, i32* %23, i32* %22)
%58 = load float, float* %26
%59 = fptosi float %58 to i32
%60 = load i32, i32* %10
%61 = sdiv i32 %59, %60
store i32 %61, i32* @sAx_eq_b_QRLS.nb
br label %62
62: ; preds = %56, %46
%63 = load i32, i32* @sAx_eq_b_QRLS.nb
%64 = load i32, i32* %10
%65 = mul nsw i32 %63, %64
store i32 %65, i32* %23
%66 = load i32, i32* %16
%67 = load i32, i32* %17
%68 = add nsw i32 %66, %67
%69 = load i32, i32* %18
%70 = add nsw i32 %68, %69
%71 = load i32, i32* %23
%72 = add nsw i32 %70, %71
store i32 %72, i32* %19
%73 = load i32, i32* %19
%74 = load i32, i32* @sAx_eq_b_QRLS.buf_sz
%75 = icmp sgt i32 %73, %74
br i1 %75, label %76, label %97
76: ; preds = %62
%77 = load float*, float** @sAx_eq_b_QRLS.buf
%78 = icmp ne float* %77, null
br i1 %78, label %79, label %82
79: ; preds = %76
%80 = load float*, float** @sAx_eq_b_QRLS.buf
%81 = call i32 @free(float* %80)
br label %82
82: ; preds = %79, %76
%83 = load i32, i32* %19
store i32 %83, i32* @sAx_eq_b_QRLS.buf_sz
%84 = load i32, i32* @sAx_eq_b_QRLS.buf_sz
%85 = sext i32 %84 to i64
%86 = mul i64 %85, 4
%87 = trunc i64 %86 to i32
%88 = call i64 @malloc(i32 %87)
%89 = inttoptr i64 %88 to float*
store float* %89, float** @sAx_eq_b_QRLS.buf
%90 = load float*, float** @sAx_eq_b_QRLS.buf
%91 = icmp ne float* %90, null
br i1 %91, label %96, label %92
92: ; preds = %82
%93 = load i32, i32* @stderr
%94 = call i32 (i32, i8*, ...) @fprintf(i32 %93, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0))
%95 = call i32 @exit(i32 1)
unreachable
96: ; preds = %82
br label %97
97: ; preds = %96, %62
%98 = load float*, float** @sAx_eq_b_QRLS.buf
store float* %98, float** %12
%99 = load float*, float** %12
%100 = load i32, i32* %16
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %99, i64 %101
store float* %102, float** %13
%103 = load float*, float** %13
%104 = load i32, i32* %17
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %103, i64 %105
store float* %106, float** %14
%107 = load float*, float** %14
%108 = load i32, i32* %18
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
store float* %110, float** %15
store i32 0, i32* %20
br label %111
111: ; preds = %142, %97
%112 = load i32, i32* %20
%113 = load i32, i32* %10
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %145
115: ; preds = %111
store i32 0, i32* %21
br label %116
116: ; preds = %138, %115
%117 = load i32, i32* %21
%118 = load i32, i32* %11
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %141
120: ; preds = %116
%121 = load float*, float** %7
%122 = load i32, i32* %20
%123 = load i32, i32* %11
%124 = mul nsw i32 %122, %123
%125 = load i32, i32* %21
%126 = add nsw i32 %124, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %121, i64 %127
%129 = load float, float* %128
%130 = load float*, float** %12
%131 = load i32, i32* %20
%132 = load i32, i32* %21
%133 = load i32, i32* %10
%134 = mul nsw i32 %132, %133
%135 = add nsw i32 %131, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %130, i64 %136
store float %129, float* %137
br label %138
138: ; preds = %120
%139 = load i32, i32* %21
%140 = add nsw i32 %139, 1
store i32 %140, i32* %21
br label %116
141: ; preds = %116
br label %142
142: ; preds = %141
%143 = load i32, i32* %20
%144 = add nsw i32 %143, 1
store i32 %144, i32* %20
br label %111
145: ; preds = %111
store i32 0, i32* %20
br label %146
146: ; preds = %181, %145
%147 = load i32, i32* %20
%148 = load i32, i32* %11
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %184
150: ; preds = %146
store i32 0, i32* %21
store float 0.000000e+00, float* %25
br label %151
151: ; preds = %172, %150
%152 = load i32, i32* %21
%153 = load i32, i32* %10
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %175
155: ; preds = %151
%156 = load float*, float** %7
%157 = load i32, i32* %21
%158 = load i32, i32* %11
%159 = mul nsw i32 %157, %158
%160 = load i32, i32* %20
%161 = add nsw i32 %159, %160
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %156, i64 %162
%164 = load float, float* %163
%165 = load float*, float** %8
%166 = load i32, i32* %21
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %165, i64 %167
%169 = load float, float* %168
%170 = load float, float* %25
%171 = call float @llvm.fmuladd.f32(float %164, float %169, float %170)
store float %171, float* %25
br label %172
172: ; preds = %155
%173 = load i32, i32* %21
%174 = add nsw i32 %173, 1
store i32 %174, i32* %21
br label %151
175: ; preds = %151
%176 = load float, float* %25
%177 = load float*, float** %9
%178 = load i32, i32* %20
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %177, i64 %179
store float %176, float* %180
br label %181
181: ; preds = %175
%182 = load i32, i32* %20
%183 = add nsw i32 %182, 1
store i32 %183, i32* %20
br label %146
184: ; preds = %146
%185 = load float*, float** %12
%186 = load float*, float** %13
%187 = load float*, float** %15
%188 = call i32 @sgeqrf_(i32* %10, i32* %11, float* %185, i32* %10, float* %186, float* %187, i32* %23, i32* %22)
%189 = load i32, i32* %22
%190 = icmp ne i32 %189, 0
br i1 %190, label %191, label %204
191: ; preds = %184
%192 = load i32, i32* %22
%193 = icmp slt i32 %192, 0
br i1 %193, label %194, label %200
194: ; preds = %191
%195 = load i32, i32* @stderr
%196 = load i32, i32* %22
%197 = sub nsw i32 0, %196
%198 = call i32 (i32, i8*, ...) @fprintf(i32 %195, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.2, i64 0, i64 0), i32 %197)
%199 = call i32 @exit(i32 1)
unreachable
200: ; preds = %191
%201 = load i32, i32* @stderr
%202 = load i32, i32* %22
%203 = call i32 (i32, i8*, ...) @fprintf(i32 %201, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.3, i64 0, i64 0), i32 %202)
store i32 0, i32* %6
br label %297
204: ; preds = %184
store i32 0, i32* %21
br label %205
205: ; preds = %255, %204
%206 = load i32, i32* %21
%207 = load i32, i32* %11
%208 = icmp slt i32 %206, %207
br i1 %208, label %209, label %258
209: ; preds = %205
store i32 0, i32* %20
br label %210
210: ; preds = %232, %209
%211 = load i32, i32* %20
%212 = load i32, i32* %21
%213 = icmp sle i32 %211, %212
br i1 %213, label %214, label %235
214: ; preds = %210
%215 = load float*, float** %12
%216 = load i32, i32* %20
%217 = load i32, i32* %21
%218 = load i32, i32* %10
%219 = mul nsw i32 %217, %218
%220 = add nsw i32 %216, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %215, i64 %221
%223 = load float, float* %222
%224 = load float*, float** %14
%225 = load i32, i32* %20
%226 = load i32, i32* %21
%227 = load i32, i32* %11
%228 = mul nsw i32 %226, %227
%229 = add nsw i32 %225, %228
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %224, i64 %230
store float %223, float* %231
br label %232
232: ; preds = %214
%233 = load i32, i32* %20
%234 = add nsw i32 %233, 1
store i32 %234, i32* %20
br label %210
235: ; preds = %210
%236 = load i32, i32* %21
%237 = add nsw i32 %236, 1
store i32 %237, i32* %20
br label %238
238: ; preds = %251, %235
%239 = load i32, i32* %20
%240 = load i32, i32* %11
%241 = icmp slt i32 %239, %240
br i1 %241, label %242, label %254
242: ; preds = %238
%243 = load float*, float** %14
%244 = load i32, i32* %20
%245 = load i32, i32* %21
%246 = load i32, i32* %11
%247 = mul nsw i32 %245, %246
%248 = add nsw i32 %244, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %243, i64 %249
store float 0.000000e+00, float* %250
br label %251
251: ; preds = %242
%252 = load i32, i32* %20
%253 = add nsw i32 %252, 1
store i32 %253, i32* %20
br label %238
254: ; preds = %238
br label %255
255: ; preds = %254
%256 = load i32, i32* %21
%257 = add nsw i32 %256, 1
store i32 %257, i32* %21
br label %205
258: ; preds = %205
%259 = load float*, float** %14
%260 = load float*, float** %9
%261 = call i32 @strtrs_(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i32* %11, i32* %24, float* %259, i32* %11, float* %260, i32* %11, i32* %22)
%262 = load i32, i32* %22
%263 = icmp ne i32 %262, 0
br i1 %263, label %264, label %277
264: ; preds = %258
%265 = load i32, i32* %22
%266 = icmp slt i32 %265, 0
br i1 %266, label %267, label %273
267: ; preds = %264
%268 = load i32, i32* @stderr
%269 = load i32, i32* %22
%270 = sub nsw i32 0, %269
%271 = call i32 (i32, i8*, ...) @fprintf(i32 %268, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.7, i64 0, i64 0), i32 %270)
%272 = call i32 @exit(i32 1)
unreachable
273: ; preds = %264
%274 = load i32, i32* @stderr
%275 = load i32, i32* %22
%276 = call i32 (i32, i8*, ...) @fprintf(i32 %274, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.8, i64 0, i64 0), i32 %275)
store i32 0, i32* %6
br label %297
277: ; preds = %258
%278 = load float*, float** %14
%279 = load float*, float** %9
%280 = call i32 @strtrs_(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i32* %11, i32* %24, float* %278, i32* %11, float* %279, i32* %11, i32* %22)
%281 = load i32, i32* %22
%282 = icmp ne i32 %281, 0
br i1 %282, label %283, label %296
283: ; preds = %277
%284 = load i32, i32* %22
%285 = icmp slt i32 %284, 0
br i1 %285, label %286, label %292
286: ; preds = %283
%287 = load i32, i32* @stderr
%288 = load i32, i32* %22
%289 = sub nsw i32 0, %288
%290 = call i32 (i32, i8*, ...) @fprintf(i32 %287, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.7, i64 0, i64 0), i32 %289)
%291 = call i32 @exit(i32 1)
unreachable
292: ; preds = %283
%293 = load i32, i32* @stderr
%294 = load i32, i32* %22
%295 = call i32 (i32, i8*, ...) @fprintf(i32 %293, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.8, i64 0, i64 0), i32 %294)
store i32 0, i32* %6
br label %297
296: ; preds = %277
store i32 1, i32* %6
br label %297
297: ; preds = %296, %292, %273, %200, %35
%298 = load i32, i32* %6
ret i32 %298
}

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