#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 */
double fabs(double);
int /*<<< orphan*/ free(double *);
double macheps();
scalar_t__ malloc(int);
int /*<<< orphan*/ minfit(double *, int, int, int, double *);
int /*<<< orphan*/ mmult(double *, double *, double *, int, int, int);
int lls_svd2(double *Ai, double *bi, int M, int N, double *xo) {
  int retcode, P, mnmax, np, i, j, t, t2;
  double *AB, *q, *V, *C;
  double eps;
  if (M > N) {
    mnmax = M;
  } else {
    mnmax = N;
  }
  retcode = 0;
  P = 1;
  np = N + P;
  eps = macheps();
  AB = (double *)malloc(sizeof(double) * mnmax * np);
  q = (double *)malloc(sizeof(double) * N);
  C = (double *)malloc(sizeof(double) * N);
  V = (double *)malloc(sizeof(double) * N * N);
  for (i = 0; i < M; ++i) {
    t = i * N;
    t2 = i * np;
    for (j = 0; j < N; ++j) {
      AB[t2 + j] = Ai[t + j];
    }
  }
  for (i = 0; i < M; ++i) {
    t2 = i * np;
    AB[t2 + N] = bi[i];
  }
  minfit(AB, M, N, P, q);
  for (i = 0; i < N; ++i) {
    t = i * N;
    t2 = i * np;
    for (j = 0; j < N; ++j) {
      V[t + j] = AB[t2 + j];
    }
  }
  for (i = 0; i < N; ++i) {
    t = i * N;
    for (j = 0; j < N; ++j) {
      if (fabs(q[j]) > eps) {
        V[t + j] /= q[j];
      } else {
        V[t + j] = 0.0;
      }
    }
  }
  for (i = 0; i < N; ++i) {
    t2 = i * np;
    C[i] = AB[t2 + N];
  }
  mmult(V, C, xo, N, N, 1);
  free(AB);
  free(q);
  free(V);
  free(C);
  return retcode;
}


x86 assembly (clang, -O0):
<lls_svd2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1181 <lls_svd2+0x31>
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1187 <lls_svd2+0x37>
mov    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    $0x0,%al
call   1070 <macheps@plt>
movsd  %xmm0,-0x68(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
movslq -0x30(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
movslq -0x18(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1285 <lls_svd2+0x135>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1272 <lls_svd2+0x122>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1234 <lls_svd2+0xe4>
jmp    1277 <lls_svd2+0x127>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120d <lls_svd2+0xbd>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12cf <lls_svd2+0x17f>
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128c <lls_svd2+0x13c>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x50(%rbp),%r8
call   1050 <minfit@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1364 <lls_svd2+0x214>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1351 <lls_svd2+0x201>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1313 <lls_svd2+0x1c3>
jmp    1356 <lls_svd2+0x206>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ec <lls_svd2+0x19c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    141f <lls_svd2+0x2cf>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    140c <lls_svd2+0x2bc>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc58(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    13e4 <lls_svd2+0x294>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    13f9 <lls_svd2+0x2a9>
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    13fe <lls_svd2+0x2ae>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1388 <lls_svd2+0x238>
jmp    1411 <lls_svd2+0x2c1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    136b <lls_svd2+0x21b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1469 <lls_svd2+0x319>
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1426 <lls_svd2+0x2d6>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lls_svd2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,0x80(%rsp)
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,0x60(%rsp)
mov    %rdi,0x20(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x70(%rsp)
cmp    %ecx,%edx
mov    %ecx,%ebx
cmovg  %edx,%ebx
lea    0x1(%r14),%r15d
xor    %eax,%eax
call   1070 <macheps@plt>
movsd  %xmm0,0x78(%rsp)
imul   %r15d,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,0x8(%rsp)
lea    0x0(,%r14,8),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x68(%rsp)
imul   %r14d,%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %r14,%rdx
mov    %rax,0x38(%rsp)
movslq %r15d,%rax
mov    %rax,0x10(%rsp)
mov    %edx,%ebp
test   %r12d,%r12d
mov    %r14,0x30(%rsp)
jle    1525 <lls_svd2+0x3d5>
movslq %edx,%rsi
mov    %r12d,0x5c(%rsp)
mov    %r12d,%ecx
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x90(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
mov    %rdi,0x88(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%r11
lea    0x30(%r11),%r10
mov    %rsi,0x18(%rsp)
lea    0x0(,%rsi,8),%rsi
mov    0x8(%rsp),%r15
lea    0x30(%r15),%r8
mov    0x10(%rsp),%rax
lea    0x0(,%rax,8),%r14
xor    %r9d,%r9d
mov    %r11,%r12
mov    %r14,0x28(%rsp)
jmp    12a9 <lls_svd2+0x159>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %rsi,%r10
add    %r14,%r8
add    %r14,%r15
add    %rsi,%r12
cmp    %rcx,%r9
je     1449 <lls_svd2+0x2f9>
test   %edx,%edx
jle    1290 <lls_svd2+0x140>
cmp    $0x4,%edx
jae    12c0 <lls_svd2+0x170>
xor    %edi,%edi
jmp    13b0 <lls_svd2+0x260>
nopl   0x0(%rax)
mov    %r9,%r14
imul   0x10(%rsp),%r14
mov    %r9,%rdi
imul   0x18(%rsp),%rdi
lea    (%rdi,%rbp,1),%rax
mov    0x8(%rsp),%rbx
lea    (%rbx,%r14,8),%rdx
lea    (%r11,%rax,8),%rax
cmp    %rax,%rdx
jae    130a <lls_svd2+0x1ba>
lea    (%r14,%rbp,1),%rax
lea    (%rbx,%rax,8),%rax
lea    (%r11,%rdi,8),%rdx
cmp    %rax,%rdx
jae    130a <lls_svd2+0x1ba>
xor    %edi,%edi
mov    0x30(%rsp),%rdx
mov    0x28(%rsp),%r14
jmp    13b0 <lls_svd2+0x260>
cmpq   $0x0,0x48(%rsp)
je     1434 <lls_svd2+0x2e4>
mov    0x88(%rsp),%rdx
xor    %ebx,%ebx
movups -0x30(%r10,%rbx,8),%xmm0
movups -0x20(%r10,%rbx,8),%xmm1
movups %xmm0,-0x30(%r8,%rbx,8)
movups %xmm1,-0x20(%r8,%rbx,8)
movupd -0x10(%r10,%rbx,8),%xmm0
movupd (%r10,%rbx,8),%xmm1
movupd %xmm0,-0x10(%r8,%rbx,8)
movupd %xmm1,(%r8,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1320 <lls_svd2+0x1d0>
testb  $0x1,0x90(%rsp)
01
je     138e <lls_svd2+0x23e>
add    %rbx,%rdi
mov    0x20(%rsp),%rax
movupd (%rax,%rdi,8),%xmm0
movupd 0x10(%rax,%rdi,8),%xmm1
add    %rbx,%r14
mov    0x8(%rsp),%rax
movupd %xmm0,(%rax,%r14,8)
movupd %xmm1,0x10(%rax,%r14,8)
mov    0x50(%rsp),%rax
mov    %rax,%rdi
cmp    %rbp,%rax
mov    0x30(%rsp),%rdx
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%r14
je     1290 <lls_svd2+0x140>
xchg   %ax,%ax
mov    %rdi,%rbx
not    %rbx
add    %rbp,%rbx
mov    0x40(%rsp),%rax
test   %rax,%rax
je     13e6 <lls_svd2+0x296>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rdi,8),%xmm0
movsd  %xmm0,(%r15,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
jne    13d0 <lls_svd2+0x280>
cmp    $0x3,%rbx
jb     1290 <lls_svd2+0x140>
movsd  (%r12,%rdi,8),%xmm0
movsd  %xmm0,(%r15,%rdi,8)
movsd  0x8(%r12,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r15,%rdi,8)
movsd  0x10(%r12,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r15,%rdi,8)
movsd  0x18(%r12,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r15,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    13f0 <lls_svd2+0x2a0>
jmp    1290 <lls_svd2+0x140>
xor    %ebx,%ebx
testb  $0x1,0x90(%rsp)
01
jne    1366 <lls_svd2+0x216>
jmp    138e <lls_svd2+0x23e>
mov    0x5c(%rsp),%r12d
test   %r12d,%r12d
jle    1525 <lls_svd2+0x3d5>
lea    -0x1(%rcx),%rax
mov    %ecx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    146c <lls_svd2+0x31c>
xor    %edi,%edi
jmp    14ea <lls_svd2+0x39a>
and    $0xfffffffc,%ecx
mov    0x10(%rsp),%rdi
mov    %rdi,%rax
shl    $0x4,%rax
mov    0x18(%rsp),%rbx
lea    (%rax,%rbx,8),%r9
mov    %rdi,%r11
shl    $0x5,%r11
lea    (%rbx,%rdi,1),%r10
lea    (%rdi,%rdi,2),%rax
lea    (%rsi,%rax,8),%r15
xor    %edi,%edi
mov    0x8(%rsp),%rax
mov    0x60(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,1)
movsd  0x8(%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%r10,8)
movsd  0x10(%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%r9,1)
movsd  0x18(%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%r15,1)
add    $0x4,%rdi
add    %r11,%rax
cmp    %rdi,%rcx
jne    14b0 <lls_svd2+0x360>
test   %r8,%r8
je     1525 <lls_svd2+0x3d5>
mov    0x60(%rsp),%rax
lea    (%rax,%rdi,8),%rax
imul   0x10(%rsp),%rdi
add    0x18(%rsp),%rdi
mov    0x8(%rsp),%rsi
lea    (%rsi,%rdi,8),%rdi
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rdi)
add    $0x1,%rsi
add    %r14,%rdi
cmp    %rsi,%r8
jne    1510 <lls_svd2+0x3c0>
mov    0x8(%rsp),%rdi
mov    %r12d,%esi
mov    $0x1,%ecx
mov    %r13,%r8
call   1050 <minfit@plt>
mov    0x30(%rsp),%rcx
test   %ecx,%ecx
mov    0x68(%rsp),%rbx
movsd  0x78(%rsp),%xmm4
jle    1895 <lls_svd2+0x745>
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x1(%rbp),%rax
mov    %rax,0x40(%rsp)
mov    %rdx,%rax
mov    %rdx,0x48(%rsp)
and    %rdx,0x70(%rsp)
mov    %ebp,%r11d
and    $0x3,%r11d
mov    0x8(%rsp),%r10
lea    0x30(%r10),%rsi
mov    0x10(%rsp),%rax
lea    0x0(,%rax,8),%r14
mov    0x38(%rsp),%r15
lea    0x30(%r15),%rdx
lea    0x0(,%rbp,8),%r12
xor    %r8d,%r8d
mov    %r10,%rdi
mov    %r12,0x18(%rsp)
mov    %r11,0x28(%rsp)
jmp    15e9 <lls_svd2+0x499>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r14,%rsi
add    %r12,%rdx
add    %r12,%r15
add    %r14,%rdi
cmp    %rbp,%r8
je     1770 <lls_svd2+0x620>
cmp    $0x4,%ecx
jae    1600 <lls_svd2+0x4b0>
xor    %ebx,%ebx
jmp    1700 <lls_svd2+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%r12
mov    %r8,%r11
imul   %rbp,%r11
mov    %r8,%r14
imul   0x10(%rsp),%r14
lea    (%r14,%rbp,1),%rax
lea    (%r10,%rax,8),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%r11,8),%rbx
cmp    %rax,%rbx
jae    1660 <lls_svd2+0x510>
lea    (%r10,%r14,8),%rax
lea    (%r11,%rbp,1),%rbx
lea    (%rcx,%rbx,8),%rbx
cmp    %rbx,%rax
jae    1660 <lls_svd2+0x510>
xor    %ebx,%ebx
mov    0x30(%rsp),%rcx
mov    %r12,%r14
mov    0x18(%rsp),%r12
mov    0x28(%rsp),%r11
jmp    1700 <lls_svd2+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,0x50(%rsp)
je     16ae <lls_svd2+0x55e>
mov    0x70(%rsp),%r10
xor    %r9d,%r9d
movups -0x30(%rsi,%r9,8),%xmm0
movups -0x20(%rsi,%r9,8),%xmm1
movups %xmm0,-0x30(%rdx,%r9,8)
movups %xmm1,-0x20(%rdx,%r9,8)
movupd -0x10(%rsi,%r9,8),%xmm0
movupd (%rsi,%r9,8),%xmm1
movupd %xmm0,-0x10(%rdx,%r9,8)
movupd %xmm1,(%rdx,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%r10
jne    1670 <lls_svd2+0x520>
jmp    16b1 <lls_svd2+0x561>
xor    %r9d,%r9d
testb  $0x1,0x48(%rsp)
mov    0x8(%rsp),%r10
je     16dd <lls_svd2+0x58d>
add    %r9,%r14
movupd (%r10,%r14,8),%xmm0
movupd 0x10(%r10,%r14,8),%xmm1
add    %r9,%r11
movupd %xmm0,(%rcx,%r11,8)
movupd %xmm1,0x10(%rcx,%r11,8)
mov    0x20(%rsp),%rax
mov    %rax,%rbx
cmp    %rbp,%rax
mov    0x30(%rsp),%rcx
mov    %r12,%r14
mov    0x18(%rsp),%r12
mov    0x28(%rsp),%r11
je     15d0 <lls_svd2+0x480>
mov    0x40(%rsp),%r9
sub    %rbx,%r9
test   %r11,%r11
je     1725 <lls_svd2+0x5d5>
mov    %r11,%rax
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1710 <lls_svd2+0x5c0>
cmp    $0x3,%r9
jb     15d0 <lls_svd2+0x480>
nop
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rbx,8)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rbx,8)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1730 <lls_svd2+0x5e0>
jmp    15d0 <lls_svd2+0x480>
test   %ecx,%ecx
mov    0x68(%rsp),%rbx
jle    1895 <lls_svd2+0x745>
xor    %eax,%eax
movapd 0x879(%rip),%xmm0
mov    0x38(%rsp),%rsi
jmp    179c <lls_svd2+0x64c>
xchg   %ax,%ax
add    $0x1,%rax
add    %r12,%rsi
cmp    %rbp,%rax
je     17d2 <lls_svd2+0x682>
xor    %edx,%edx
jmp    17ae <lls_svd2+0x65e>
movsd  %xmm2,(%rsi,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
je     1790 <lls_svd2+0x640>
movsd  0x0(%r13,%rdx,8),%xmm1
movapd %xmm1,%xmm3
andpd  %xmm0,%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm4,%xmm3
jbe    17a0 <lls_svd2+0x650>
movsd  (%rsi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
jmp    17a0 <lls_svd2+0x650>
test   %ecx,%ecx
jle    1895 <lls_svd2+0x745>
mov    %ebp,%r8d
and    $0x3,%r8d
cmpq   $0x3,0x40(%rsp)
jae    17ed <lls_svd2+0x69d>
xor    %esi,%esi
jmp    185a <lls_svd2+0x70a>
mov    %ebp,%r9d
and    $0xfffffffc,%r9d
mov    0x10(%rsp),%rdx
mov    %rdx,%rax
shl    $0x4,%rax
lea    (%rax,%rbp,8),%r10
mov    %rdx,%rdi
shl    $0x5,%rdi
lea    (%rdx,%rbp,1),%r11
lea    (%rdx,%rdx,2),%rax
lea    (%r12,%rax,8),%rax
xor    %esi,%esi
mov    0x8(%rsp),%rdx
xchg   %ax,%ax
movsd  (%rdx,%r12,1),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rsi,8)
movsd  (%rdx,%r10,1),%xmm0
movsd  %xmm0,0x10(%rbx,%rsi,8)
movsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
add    %rdi,%rdx
cmp    %rsi,%r9
jne    1820 <lls_svd2+0x6d0>
test   %r8,%r8
je     1895 <lls_svd2+0x745>
lea    (%rbx,%rsi,8),%rax
mov    0x10(%rsp),%rdi
imul   %rsi,%rdi
add    %rbp,%rdi
mov    0x8(%rsp),%rdx
lea    (%rdx,%rdi,8),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r14,%rsi
cmp    %rdx,%r8
jne    1880 <lls_svd2+0x730>
mov    0x38(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x80(%rsp),%rdx
mov    %ecx,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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