#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 **dmatrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
double *dvector(int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dmatrix(double **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_ivector(int *, int /*<<< orphan*/, int);
int *ivector(int /*<<< orphan*/, int);
int /*<<< orphan*/ svdbacksub(double **, double *, double **, double *,
                              double *, int, int);
scalar_t__ svdecomp(double **, double *, double **, int, int);
int svdsolve_s(double **a, double b[], int m, int n, int s) {
  int i, j;
  double *w, W[8];
  int *sw, SW[8];
  double **v, *VP[8], V[8][8];
  double maxw;
  if (n <= 8) {
    w = W;
    sw = SW;
    VP[0] = V[0];
    VP[1] = V[1];
    VP[2] = V[2];
    VP[3] = V[3];
    VP[4] = V[4];
    VP[5] = V[5];
    VP[6] = V[6];
    VP[7] = V[7];
    v = VP;
  } else {
    w = dvector(0, n - 1);
    sw = ivector(0, n - 1);
    v = dmatrix(0, n - 1, 0, n - 1);
  }
  if (svdecomp(a, w, v, m, n)) {
    if (w != W) {
      free_dvector(w, 0, n - 1);
      free_dmatrix(v, 0, n - 1, 0, n - 1);
    }
    return 1;
  }
  for (maxw = 0.0, i = 0; i < n; i++) {
    sw[i] = i;
    if (w[i] > maxw)
      maxw = w[i];
  }
  maxw *= 1.0e-12;
  for (i = 0; i < (n - 1); i++) {
    for (j = i + 1; j < n; j++) {
      if (w[sw[i]] > w[sw[j]]) {
        int tt = sw[i];
        sw[i] = sw[j];
        sw[j] = tt;
      }
    }
  }
  s = n - s;
  if (s < 0)
    s = 0;
  if (s > n)
    s = n;
  for (i = 0; i < s; i++)
    w[sw[i]] = 0.0;
  for (maxw = 0.0, i = 0; i < n; i++) {
    if (w[i] < maxw)
      w[i] = 0.0;
  }
  svdbacksub(a, w, v, b, b, m, n);
  if (w != W) {
    free_dvector(w, 0, n - 1);
    free_ivector(sw, 0, n - 1);
    free_dmatrix(v, 0, n - 1, 0, n - 1);
  }
  return 0;
}


x86 assembly (clang, -O0):
<svdsolve_s>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x8,-0x20(%rbp)
jg     1268 <svdsolve_s+0xe8>
lea    -0x80(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    -0xb0(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x300(%rbp),%rax
mov    %rax,-0x100(%rbp)
lea    -0x300(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xf8(%rbp)
lea    -0x300(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xf0(%rbp)
lea    -0x300(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xe8(%rbp)
lea    -0x300(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0xe0(%rbp)
lea    -0x300(%rbp),%rax
add    $0x140,%rax
mov    %rax,-0xd8(%rbp)
lea    -0x300(%rbp),%rax
add    $0x180,%rax
mov    %rax,-0xd0(%rbp)
lea    -0x300(%rbp),%rax
add    $0x1c0,%rax
mov    %rax,-0xc8(%rbp)
lea    -0x100(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    12a9 <svdsolve_s+0x129>
mov    -0x20(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <dvector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1090 <ivector@plt>
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%esi
sub    $0x1,%esi
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1030 <dmatrix@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
call   1050 <svdecomp@plt>
cmp    $0x0,%rax
je     131a <svdsolve_s+0x19a>
mov    -0x38(%rbp),%rax
lea    -0x80(%rbp),%rcx
cmp    %rcx,%rax
je     130e <svdsolve_s+0x18e>
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1080 <free_dvector@plt>
mov    -0xb8(%rbp),%rdi
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%r8d
sub    $0x1,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   10a0 <free_dmatrix@plt>
movl   $0x1,-0x4(%rbp)
jmp    15ba <svdsolve_s+0x43a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    138c <svdsolve_s+0x20c>
mov    -0x28(%rbp),%edx
mov    -0x88(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x308(%rbp),%xmm0
ff
jbe    1379 <svdsolve_s+0x1f9>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
jmp    137e <svdsolve_s+0x1fe>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    132c <svdsolve_s+0x1ac>
movsd  0xc6c(%rip),%xmm0
mulsd  -0x308(%rbp),%xmm0
ff
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1471 <svdsolve_s+0x2f1>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    145e <svdsolve_s+0x2de>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    144b <svdsolve_s+0x2cb>
mov    -0x88(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30c(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30c(%rbp),%edx
mov    -0x88(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1450 <svdsolve_s+0x2d0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13c5 <svdsolve_s+0x245>
jmp    1463 <svdsolve_s+0x2e3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ab <svdsolve_s+0x22b>
mov    -0x20(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    148b <svdsolve_s+0x30b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    149d <svdsolve_s+0x31d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14d9 <svdsolve_s+0x359>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14a4 <svdsolve_s+0x324>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1539 <svdsolve_s+0x3b9>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x308(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1526 <svdsolve_s+0x3a6>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    152b <svdsolve_s+0x3ab>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14eb <svdsolve_s+0x36b>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x18(%rbp),%r8
mov    -0x1c(%rbp),%r9d
mov    -0x20(%rbp),%eax
mov    %eax,(%rsp)
call   1070 <svdbacksub@plt>
mov    -0x38(%rbp),%rax
lea    -0x80(%rbp),%rcx
cmp    %rcx,%rax
je     15b3 <svdsolve_s+0x433>
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1080 <free_dvector@plt>
mov    -0x88(%rbp),%rdi
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1060 <free_ivector@plt>
mov    -0xb8(%rbp),%rdi
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%r8d
sub    $0x1,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   10a0 <free_dmatrix@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svdsolve_s>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2d8,%rsp
mov    %r8d,0x24(%rsp)
mov    %ecx,%ebp
mov    %edx,%ecx
mov    %rdi,%r15
cmp    $0x8,%ebp
mov    %rsi,0x18(%rsp)
jg     1223 <svdsolve_s+0xa3>
lea    0x70(%rsp),%rbx
lea    0xb0(%rsp),%r12
lea    0x30(%rsp),%rdx
lea    0xd0(%rsp),%rax
mov    %rax,0x30(%rsp)
lea    0x110(%rsp),%rax
mov    %rax,0x38(%rsp)
lea    0x150(%rsp),%rax
mov    %rax,0x40(%rsp)
lea    0x190(%rsp),%rax
mov    %rax,0x48(%rsp)
lea    0x1d0(%rsp),%rax
mov    %rax,0x50(%rsp)
lea    0x210(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x250(%rsp),%rax
mov    %rax,0x60(%rsp)
lea    0x290(%rsp),%rax
mov    %rax,0x68(%rsp)
jmp    125a <svdsolve_s+0xda>
mov    %rbp,%r13
add    $0xffffffff,%ebp
xor    %edi,%edi
mov    %ebp,%esi
mov    %ecx,%r14d
call   1040 <dvector@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %ebp,%esi
call   1090 <ivector@plt>
mov    %rax,%r12
xor    %edi,%edi
mov    %ebp,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%rbp
call   1030 <dmatrix@plt>
mov    %r14d,%ecx
mov    %rax,%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %rdx,%r13
mov    %r15,%r14
mov    %ebp,%r8d
mov    %ecx,%r15d
call   1050 <svdecomp@plt>
test   %rax,%rax
je     12aa <svdsolve_s+0x12a>
mov    $0x1,%r14d
lea    0x70(%rsp),%rax
cmp    %rax,%rbx
je     15e5 <svdsolve_s+0x465>
add    $0xffffffff,%ebp
mov    %rbx,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1080 <free_dvector@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %ebp,%r8d
jmp    15e0 <svdsolve_s+0x460>
mov    %r14,0x28(%rsp)
mov    %ebp,%r8d
test   %ebp,%ebp
mov    %r15d,0x20(%rsp)
jle    12cc <svdsolve_s+0x14c>
cmp    $0x8,%ebp
jae    12dd <svdsolve_s+0x15d>
xor    %ecx,%ecx
mov    0x18(%rsp),%r9
jmp    1450 <svdsolve_s+0x2d0>
lea    -0x1(%rbp),%eax
mov    %eax,0x14(%rsp)
mov    0x18(%rsp),%r9
jmp    14c9 <svdsolve_s+0x349>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1311 <svdsolve_s+0x191>
movdqa 0xcfb(%rip),%xmm0
xor    %edi,%edi
mov    0x18(%rsp),%r9
jmp    13f0 <svdsolve_s+0x270>
and    $0xfffffffffffffffc,%rsi
movdqa 0xce3(%rip),%xmm0
xor    %edi,%edi
movdqa 0xce8(%rip),%xmm8
movdqa 0xcef(%rip),%xmm9
movdqa 0xcf6(%rip),%xmm10
movdqa 0xcfe(%rip),%xmm4
movdqa 0xd06(%rip),%xmm5
movdqa 0xd0e(%rip),%xmm6
movdqa 0xd16(%rip),%xmm7
movdqa 0xd1e(%rip),%xmm1
mov    0x18(%rsp),%r9
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r12,%rdi,4)
movdqu %xmm2,0x10(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r12,%rdi,4)
movdqu %xmm3,0x30(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r12,%rdi,4)
movdqu %xmm3,0x50(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r12,%rdi,4)
movdqu %xmm3,0x70(%r12,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1370 <svdsolve_s+0x1f0>
test   %rdx,%rdx
je     1440 <svdsolve_s+0x2c0>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xc05(%rip),%xmm1
movdqa 0xc0d(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1420 <svdsolve_s+0x2a0>
cmp    %r8,%rcx
je     145d <svdsolve_s+0x2dd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%r12,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1450 <svdsolve_s+0x2d0>
lea    -0x1(%rbp),%eax
cmp    $0x2,%ebp
mov    %eax,0x14(%rsp)
jl     14c9 <svdsolve_s+0x349>
mov    %rbp,%r14
mov    %eax,%r11d
xor    %r10d,%r10d
mov    %r8,%rdx
mov    %r12,%rsi
jmp    148d <svdsolve_s+0x30d>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rsi
add    $0xffffffffffffffff,%rdx
cmp    %r11,%r10
je     14c6 <svdsolve_s+0x346>
mov    %r10,%rdi
add    $0x1,%r10
cmp    %r8,%r10
jae    1480 <svdsolve_s+0x300>
mov    $0x1,%eax
jmp    14a9 <svdsolve_s+0x329>
add    $0x1,%rax
cmp    %rax,%rdx
je     1480 <svdsolve_s+0x300>
movslq (%r12,%rdi,4),%rcx
movsd  (%rbx,%rcx,8),%xmm0
movslq (%rsi,%rax,4),%rbp
ucomisd (%rbx,%rbp,8),%xmm0
jbe    14a0 <svdsolve_s+0x320>
mov    %ebp,(%r12,%rdi,4)
mov    %ecx,(%rsi,%rax,4)
jmp    14a0 <svdsolve_s+0x320>
mov    %r14,%rbp
xor    %ecx,%ecx
mov    %ebp,%eax
sub    0x24(%rsp),%eax
cmovs  %ecx,%eax
cmp    %ebp,%eax
cmovg  %ebp,%eax
test   %eax,%eax
jle    1565 <svdsolve_s+0x3e5>
mov    %eax,%edx
lea    -0x1(%rdx),%rax
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    14f6 <svdsolve_s+0x376>
xor    %esi,%esi
jmp    153c <svdsolve_s+0x3bc>
and    $0xfffffffc,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%r12,%rsi,4),%rax
movq   $0x0,(%rbx,%rax,8)
movslq 0x4(%r12,%rsi,4),%rax
movq   $0x0,(%rbx,%rax,8)
movslq 0x8(%r12,%rsi,4),%rax
movq   $0x0,(%rbx,%rax,8)
movslq 0xc(%r12,%rsi,4),%rax
movq   $0x0,(%rbx,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1500 <svdsolve_s+0x380>
test   %rcx,%rcx
je     1565 <svdsolve_s+0x3e5>
lea    (%r12,%rsi,4),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rdx,4),%rsi
movq   $0x0,(%rbx,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1550 <svdsolve_s+0x3d0>
test   %ebp,%ebp
jle    158d <svdsolve_s+0x40d>
cmp    $0x1,%ebp
jne    15fa <svdsolve_s+0x47a>
xor    %ecx,%ecx
test   $0x1,%r8b
je     158d <svdsolve_s+0x40d>
xorpd  %xmm0,%xmm0
ucomisd (%rbx,%rcx,8),%xmm0
jbe    158d <svdsolve_s+0x40d>
movq   $0x0,(%rbx,%rcx,8)
mov    %ebp,(%rsp)
mov    0x28(%rsp),%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    %r9,%rcx
mov    %r9,%r8
mov    0x20(%rsp),%r9d
call   1070 <svdbacksub@plt>
lea    0x70(%rsp),%rax
xor    %r14d,%r14d
cmp    %rax,%rbx
je     15e5 <svdsolve_s+0x465>
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x14(%rsp),%ebx
mov    %ebx,%edx
call   1080 <free_dvector@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1060 <free_ivector@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    %ebx,%r8d
call   10a0 <free_dmatrix@plt>
mov    %r14d,%eax
add    $0x2d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
jmp    161d <svdsolve_s+0x49d>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    %rcx,%rdx
je     1574 <svdsolve_s+0x3f4>
ucomisd (%rbx,%rcx,8),%xmm0
jbe    162c <svdsolve_s+0x4ac>
movq   $0x0,(%rbx,%rcx,8)
ucomisd 0x8(%rbx,%rcx,8),%xmm0
jbe    1610 <svdsolve_s+0x490>
movq   $0x0,0x8(%rbx,%rcx,8)
jmp    1610 <svdsolve_s+0x490>

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

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