#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*/ free_vector(float *, int, int);
void stub1(float, float *, int);
void stub2(float, float *, int);
float *vector(int, int);
void svdfit(float x[], float y[], float sig[], int ndata, float a[], int ma,
            float **u, float **v, float w[], float *chisq,
            void (*funcs)(float, float[], int)) {
  void svbksb(float **u, float w[], float **v, int m, int n, float b[],
              float x[]);
  void svdcmp(float **a, int m, int n, float w[], float **v);
  int j, i;
  float wmax, tmp, thresh, sum, *b, *afunc;
  b = vector(1, ndata);
  afunc = vector(1, ma);
  for (i = 1; i <= ndata; i++) {
    (*funcs)(x[i], afunc, ma);
    tmp = 1.0 / sig[i];
    for (j = 1; j <= ma; j++)
      u[i][j] = afunc[j] * tmp;
    b[i] = y[i] * tmp;
  }
  svdcmp(u, ndata, ma, w, v);
  wmax = 0.0;
  for (j = 1; j <= ma; j++)
    if (w[j] > wmax)
      wmax = w[j];
  thresh = 1.0e-5 * wmax;
  for (j = 1; j <= ma; j++)
    if (w[j] < thresh)
      w[j] = 0.0;
  svbksb(u, w, v, ndata, ma, b, a);
  *chisq = 0.0;
  for (i = 1; i <= ndata; i++) {
    (*funcs)(x[i], afunc, ma);
    for (sum = 0.0, j = 1; j <= ma; j++)
      sum += a[j] * afunc[j];
    *chisq += (tmp = (y[i] - sum) / sig[i], tmp * tmp);
  }
  free_vector(afunc, 1, ma);
  free_vector(b, 1, ndata);
}


x86 assembly (clang, -O0):
<svdfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1060 <vector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%esi
mov    $0x1,%edi
call   1060 <vector@plt>
mov    %rax,-0x58(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     125d <svdfit+0x11d>
mov    0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x2c(%rbp),%esi
call   *%rax
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe2d(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1230 <svdfit+0xf0>
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ef <svdfit+0xaf>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119c <svdfit+0x5c>
mov    0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    0x20(%rbp),%rcx
mov    0x18(%rbp),%r8
call   1050 <svdcmp@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12cb <svdfit+0x18b>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x38(%rbp),%xmm0
jbe    12b8 <svdfit+0x178>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    12bd <svdfit+0x17d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1283 <svdfit+0x143>
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd24(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     133a <svdfit+0x1fa>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1327 <svdfit+0x1e7>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    132c <svdfit+0x1ec>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f0 <svdfit+0x1b0>
mov    0x10(%rbp),%rdi
mov    0x20(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x50(%rbp),%r9
mov    -0x28(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <svbksb@plt>
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     143b <svdfit+0x2fb>
mov    0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x2c(%rbp),%esi
call   *%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13eb <svdfit+0x2ab>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13a5 <svdfit+0x265>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1370 <svdfit+0x230>
mov    -0x58(%rbp),%rdi
mov    -0x2c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svdfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9d,%r15d
mov    %r8,%rbx
mov    %ecx,%ebp
mov    %rdx,0x50(%rsp)
mov    %rsi,0x48(%rsp)
mov    %rdi,0x40(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0xe8(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0xe0(%rsp),%r12
mov    0xd8(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    %ecx,%esi
call   1060 <vector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %r15d,%esi
call   1060 <vector@plt>
mov    %rax,%r14
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    1420 <svdfit+0x2e0>
lea    0x1(%r15),%ebp
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
lea    0x4(%r14),%rax
mov    %rax,0x88(%rsp)
lea    (%r14,%rbp,4),%rax
mov    %rax,0x90(%rsp)
lea    -0x1(%rbp),%rax
lea    -0x9(%rbp),%rcx
mov    %rcx,0x80(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rax,0x10(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rsp)
add    $0x1,%rax
mov    %rax,0x68(%rsp)
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x60(%rsp)
mov    $0x1,%r13d
jmp    1275 <svdfit+0x135>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x48(%rsp),%rax
mulss  (%rax,%r13,4),%xmm0
mov    0x28(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
add    $0x1,%r13
cmp    0x20(%rsp),%r13
je     1420 <svdfit+0x2e0>
mov    0x40(%rsp),%rax
movss  (%rax,%r13,4),%xmm0
mov    %r14,%rdi
mov    %r15d,%esi
call   *0x38(%rsp)
movss  0xd6e(%rip),%xmm0
mov    0x50(%rsp),%rax
divss  (%rax,%r13,4),%xmm0
test   %r15d,%r15d
jle    1250 <svdfit+0x110>
mov    0x18(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    $0x1,%ecx
cmpq   $0x8,0x10(%rsp)
jb     1380 <svdfit+0x240>
lea    0x4(%rax),%rdx
cmp    0x90(%rsp),%rdx
jae    12dc <svdfit+0x19c>
lea    (%rax,%rbp,4),%rdx
cmp    %rdx,0x88(%rsp)
jb     1380 <svdfit+0x240>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0x80(%rsp)
jae    12f2 <svdfit+0x1b2>
xor    %ecx,%ecx
jmp    1342 <svdfit+0x202>
mov    0x60(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups 0x4(%r14,%rcx,4),%xmm2
movups 0x14(%r14,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x4(%rax,%rcx,4)
movups %xmm3,0x14(%rax,%rcx,4)
movups 0x24(%r14,%rcx,4),%xmm2
movups 0x34(%r14,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x24(%rax,%rcx,4)
movups %xmm3,0x34(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1300 <svdfit+0x1c0>
testb  $0x1,0x78(%rsp)
je     136b <svdfit+0x22b>
shl    $0x2,%rcx
or     $0x4,%rcx
movups (%r14,%rcx,1),%xmm2
movups 0x10(%r14,%rcx,1),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rax,%rcx,1)
movups %xmm3,0x10(%rax,%rcx,1)
mov    0x68(%rsp),%rcx
mov    0x70(%rsp),%rdx
cmp    %rdx,0x10(%rsp)
je     1250 <svdfit+0x110>
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     13b9 <svdfit+0x279>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13a0 <svdfit+0x260>
cmp    $0x3,%rdx
jb     1250 <svdfit+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
movss  0x4(%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rax,%rcx,4)
movss  0x8(%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rax,%rcx,4)
movss  0xc(%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    13d0 <svdfit+0x290>
jmp    1250 <svdfit+0x110>
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %r15d,%edx
mov    %r12,%rcx
mov    0x58(%rsp),%r13
mov    %r13,%r8
call   1050 <svdcmp@plt>
test   %r15d,%r15d
jle    15e3 <svdfit+0x4a3>
mov    %r15d,%eax
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1462 <svdfit+0x322>
xorps  %xmm0,%xmm0
mov    $0x1,%edx
jmp    14a9 <svdfit+0x369>
mov    %eax,%esi
and    $0xfffffffc,%esi
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  0x4(%r12,%rdx,4),%xmm1
maxss  %xmm0,%xmm1
movss  0x8(%r12,%rdx,4),%xmm0
maxss  %xmm1,%xmm0
movss  0xc(%r12,%rdx,4),%xmm1
maxss  %xmm0,%xmm1
movss  0x10(%r12,%rdx,4),%xmm0
maxss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1470 <svdfit+0x330>
add    $0x1,%rdx
movaps %xmm0,%xmm1
test   %rcx,%rcx
je     14d5 <svdfit+0x395>
lea    (%r12,%rdx,4),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm1
maxss  %xmm0,%xmm1
add    $0x1,%rsi
movaps %xmm1,%xmm0
cmp    %rsi,%rcx
jne    14c0 <svdfit+0x380>
test   %r15d,%r15d
jle    15e3 <svdfit+0x4a3>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0xb1b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x1,%rax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1659 <svdfit+0x519>
mov    %rdx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %edi,%edi
jmp    152d <svdfit+0x3ed>
xchg   %ax,%ax
add    $0x8,%rdi
cmp    %rdi,%rsi
je     15de <svdfit+0x49e>
movups 0x4(%r12,%rdi,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    1541 <svdfit+0x401>
movl   $0x0,0x4(%r12,%rdi,4)
cmpltps %xmm1,%xmm2
pextrw $0x2,%xmm2,%ebp
test   $0x1,%bpl
je     1559 <svdfit+0x419>
movl   $0x0,0x8(%r12,%rdi,4)
pextrw $0x4,%xmm2,%ebp
test   $0x1,%bpl
je     156d <svdfit+0x42d>
movl   $0x0,0xc(%r12,%rdi,4)
pextrw $0x6,%xmm2,%ebp
test   $0x1,%bpl
je     1581 <svdfit+0x441>
movl   $0x0,0x10(%r12,%rdi,4)
movups 0x14(%r12,%rdi,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    1595 <svdfit+0x455>
movl   $0x0,0x14(%r12,%rdi,4)
cmpltps %xmm1,%xmm2
pextrw $0x2,%xmm2,%ebp
test   $0x1,%bpl
je     15ad <svdfit+0x46d>
movl   $0x0,0x18(%r12,%rdi,4)
pextrw $0x4,%xmm2,%ebp
test   $0x1,%bpl
je     15c1 <svdfit+0x481>
movl   $0x0,0x1c(%r12,%rdi,4)
pextrw $0x6,%xmm2,%ebp
test   $0x1,%bpl
je     1520 <svdfit+0x3e0>
movl   $0x0,0x20(%r12,%rdi,4)
jmp    1520 <svdfit+0x3e0>
cmp    %rsi,%rdx
jne    1659 <svdfit+0x519>
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
mov    %r13,%rdx
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
mov    %r15d,%r8d
mov    0x28(%rsp),%r9
call   1030 <svbksb@plt>
mov    0x30(%rsp),%rax
movl   $0x0,(%rax)
test   %ebp,%ebp
jle    177c <svdfit+0x63c>
lea    0x1(%r15),%ecx
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
lea    -0x1(%rcx),%r12
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x10(%rsp)
mov    %r12d,%ebp
and    $0x3,%ebp
and    $0xfffffffffffffffc,%r12
mov    $0x1,%r13d
jmp    16ad <svdfit+0x56d>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %rcx,%rax
je     15e3 <svdfit+0x4a3>
ucomiss (%r12,%rcx,4),%xmm0
jbe    1650 <svdfit+0x510>
movl   $0x0,(%r12,%rcx,4)
jmp    1650 <svdfit+0x510>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    0x48(%rsp),%rax
movss  (%rax,%r13,4),%xmm1
subss  %xmm0,%xmm1
mov    0x50(%rsp),%rax
divss  (%rax,%r13,4),%xmm1
mulss  %xmm1,%xmm1
mov    0x30(%rsp),%rax
addss  (%rax),%xmm1
movss  %xmm1,(%rax)
add    $0x1,%r13
cmp    0x20(%rsp),%r13
je     177c <svdfit+0x63c>
mov    0x40(%rsp),%rax
movss  (%rax,%r13,4),%xmm0
mov    %r14,%rdi
mov    %r15d,%esi
call   *0x38(%rsp)
test   %r15d,%r15d
jle    1670 <svdfit+0x530>
cmpq   $0x3,0x10(%rsp)
jae    16e0 <svdfit+0x5a0>
xorps  %xmm0,%xmm0
mov    $0x1,%eax
test   %rbp,%rbp
jne    174a <svdfit+0x60a>
jmp    1673 <svdfit+0x533>
xchg   %ax,%ax
xorps  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x4(%rbx,%rax,4),%xmm1
movss  0x8(%rbx,%rax,4),%xmm2
mulss  0x4(%r14,%rax,4),%xmm1
mulss  0x8(%r14,%rax,4),%xmm2
addss  %xmm0,%xmm1
movss  0xc(%rbx,%rax,4),%xmm3
mulss  0xc(%r14,%rax,4),%xmm3
addss  %xmm1,%xmm2
movss  0x10(%rbx,%rax,4),%xmm0
mulss  0x10(%r14,%rax,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rax
cmp    %rax,%r12
jne    16f0 <svdfit+0x5b0>
add    $0x1,%rax
test   %rbp,%rbp
je     1673 <svdfit+0x533>
lea    (%r14,%rax,4),%rcx
lea    (%rbx,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm1
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1760 <svdfit+0x620>
jmp    1673 <svdfit+0x533>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r15d,%edx
call   1040 <free_vector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>

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

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