#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(float *);
float macheps();
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(float *, float *, float *, int, int, int);
int /*<<< orphan*/ mtranspose(float *, int, int, float *);
int /*<<< orphan*/ printf(char *);
int svd(float *, int, int, float *, float *, float *);
int lls_svd_multi(float *A, float *b, int M, int N, float *x) {
  int rnk, ret, i;
  float *U, *V, *q, *UT, *d;
  float eps, tol, szmax, qmax;
  if (M < N) {
    printf("Rows (M) should be greater than Columns (B) \n");
    return -1;
  }
  U = (float *)malloc(sizeof(float) * M * N);
  V = (float *)malloc(sizeof(float) * N * N);
  q = (float *)malloc(sizeof(float) * N);
  UT = (float *)malloc(sizeof(float) * M * N);
  d = (float *)malloc(sizeof(float) * N);
  ret = svd(A, M, N, U, V, q);
  if (ret != 0) {
    printf("Failed to Compute SVD");
    free(U);
    free(V);
    free(q);
    free(UT);
    free(d);
    return -1;
  }
  szmax = (float)M;
  eps = macheps();
  rnk = 0;
  qmax = q[0];
  tol = qmax * szmax * eps;
  for (i = 0; i < N; ++i) {
    if (q[i] > tol) {
      rnk++;
    }
  }
  mtranspose(U, M, N, UT);
  d = (float *)malloc(sizeof(float) * N);
  mmult(UT, b, d, N, M, 1);
  for (i = 0; i < rnk; ++i) {
    d[i] /= q[i];
  }
  for (i = rnk; i < N; ++i) {
    d[i] = 0.0;
  }
  mmult(V, d, x, N, N, 1);
  free(U);
  free(V);
  free(q);
  free(UT);
  free(d);
  return (rnk);
}


x86 assembly (clang, -O0):
<lls_svd_multi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11ae <lls_svd_multi+0x3e>
lea    0xe63(%rip),%rdi
call   1050 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    141f <lls_svd_multi+0x2af>
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    -0x50(%rbp),%r9
call   1070 <svd@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1292 <lls_svd_multi+0x122>
lea    0xdda(%rip),%rdi
call   1050 <printf@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@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>
movl   $0xffffffff,-0x4(%rbp)
jmp    141f <lls_svd_multi+0x2af>
cvtsi2ssl -0x1c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    $0x0,%al
call   1090 <macheps@plt>
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1316 <lls_svd_multi+0x1a6>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    1303 <lls_svd_multi+0x193>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1308 <lls_svd_multi+0x198>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12d7 <lls_svd_multi+0x167>
mov    -0x40(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x58(%rbp),%rcx
call   1060 <mtranspose@plt>
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    139e <lls_svd_multi+0x22e>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1361 <lls_svd_multi+0x1f1>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13ce <lls_svd_multi+0x25e>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a4 <lls_svd_multi+0x234>
mov    -0x48(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@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    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lls_svd_multi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
cmp    %ecx,%edx
jge    11b9 <lls_svd_multi+0x29>
lea    0xe6d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%r15d
jmp    15b9 <lls_svd_multi+0x429>
mov    %ecx,%ebx
mov    %rdi,%r12
mov    %rsi,0x20(%rsp)
mov    %r8,0x28(%rsp)
mov    %edx,%ebp
imul   %ecx,%ebp
shl    $0x2,%ebp
mov    %ebp,%edi
mov    %edx,%r15d
call   10a0 <malloc@plt>
mov    %rax,0x10(%rsp)
lea    0x0(,%rbx,4),%r13d
mov    %r13d,%edi
imul   %ebx,%edi
call   10a0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r13d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r13d,%edi
call   10a0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r12,%rdi
mov    %rbx,%rbp
mov    %r15d,%r12d
mov    %r15d,%esi
mov    0x10(%rsp),%rbx
mov    %ebp,%edx
mov    %rbx,%rcx
mov    0x18(%rsp),%r8
mov    %r14,%r9
call   1090 <svd@plt>
test   %eax,%eax
je     1287 <lls_svd_multi+0xf7>
lea    0xdb7(%rip),%rdi
call   1060 <printf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0xffffffff,%r15d
jmp    15b9 <lls_svd_multi+0x429>
xor    %r15d,%r15d
xor    %eax,%eax
call   10b0 <macheps@plt>
test   %ebp,%ebp
mov    0x8(%rsp),%rbx
mov    %rbp,%r10
jle    13ea <lls_svd_multi+0x25a>
cvtsi2ss %r12d,%xmm1
movss  (%r14),%xmm2
mulss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
xor    %r15d,%r15d
ucomiss %xmm0,%xmm2
seta   %r15b
cmp    $0x1,%r10d
je     13ea <lls_svd_multi+0x25a>
mov    %r10d,%eax
lea    -0x1(%rax),%r9
mov    $0x1,%ecx
cmp    $0x8,%r9
jb     13d0 <lls_svd_multi+0x240>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %r15d,%xmm1
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
lea    -0x8(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rdi,%rdi
je     1373 <lls_svd_multi+0x1e3>
mov    %rdx,%rbp
and    $0xfffffffffffffffe,%rbp
pxor   %xmm3,%xmm3
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
movups (%r14,%rdi,4),%xmm4
movups 0x10(%r14,%rdi,4),%xmm5
movups 0x20(%r14,%rdi,4),%xmm6
movups 0x30(%r14,%rdi,4),%xmm7
movaps %xmm8,%xmm2
cmpltps %xmm4,%xmm2
psubd  %xmm2,%xmm1
movaps %xmm8,%xmm2
cmpltps %xmm5,%xmm2
psubd  %xmm2,%xmm3
movaps %xmm8,%xmm2
cmpltps %xmm6,%xmm2
psubd  %xmm2,%xmm1
movaps %xmm8,%xmm2
cmpltps %xmm7,%xmm2
psubd  %xmm2,%xmm3
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1320 <lls_svd_multi+0x190>
jmp    137c <lls_svd_multi+0x1ec>
pxor   %xmm3,%xmm3
mov    $0x1,%edi
test   $0x1,%dl
je     13a2 <lls_svd_multi+0x212>
movups (%r14,%rdi,4),%xmm2
movups 0x10(%r14,%rdi,4),%xmm4
movaps %xmm8,%xmm5
cmpltps %xmm2,%xmm5
psubd  %xmm5,%xmm1
cmpltps %xmm4,%xmm8
psubd  %xmm8,%xmm3
paddd  %xmm3,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%r15d
cmp    %rcx,%r9
je     13ea <lls_svd_multi+0x25a>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
movss  (%r14,%rcx,4),%xmm1
xor    %edx,%edx
ucomiss %xmm0,%xmm1
seta   %dl
add    %edx,%r15d
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13d0 <lls_svd_multi+0x240>
mov    %r13d,%ebp
mov    0x10(%rsp),%rdi
mov    %r12d,%esi
mov    %r10d,%edx
mov    %rbx,%rcx
mov    %r10,%r13
call   1080 <mtranspose@plt>
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,%rdi
mov    0x20(%rsp),%rsi
mov    %rax,%rdx
mov    %r13,%rbx
mov    %r13d,%ecx
mov    %r12d,%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    %r15d,%eax
test   %r15d,%r15d
je     1543 <lls_svd_multi+0x3b3>
cmp    $0x4,%r15d
jb     1457 <lls_svd_multi+0x2c7>
lea    (%r14,%rax,4),%rcx
cmp    %rcx,%rbp
jae    14c3 <lls_svd_multi+0x333>
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%r14
jae    14c3 <lls_svd_multi+0x333>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1479 <lls_svd_multi+0x2e9>
movss  0x0(%rbp,%rcx,4),%xmm0
divss  (%r14,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     1543 <lls_svd_multi+0x3b3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm0
divss  (%r14,%rcx,4),%xmm0
movss  0x4(%rbp,%rcx,4),%xmm1
movss  %xmm0,0x0(%rbp,%rcx,4)
divss  0x4(%r14,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1490 <lls_svd_multi+0x300>
jmp    1543 <lls_svd_multi+0x3b3>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1521 <lls_svd_multi+0x391>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r14,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
divps  %xmm0,%xmm1
movups 0x10(%rbp,%rsi,4),%xmm0
movups %xmm1,0x0(%rbp,%rsi,4)
movups 0x10(%r14,%rsi,4),%xmm1
divps  %xmm1,%xmm0
movups %xmm0,0x10(%rbp,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14f0 <lls_svd_multi+0x360>
jmp    1523 <lls_svd_multi+0x393>
xor    %esi,%esi
test   $0x1,%dl
je     153a <lls_svd_multi+0x3aa>
movups (%r14,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,0x0(%rbp,%rsi,4)
cmp    %rax,%rcx
jne    1459 <lls_svd_multi+0x2c9>
mov    %rbx,%rcx
cmp    %ecx,%r15d
jge    156f <lls_svd_multi+0x3df>
lea    0x0(,%rax,4),%rdi
add    %rbp,%rdi
mov    %r15d,%eax
not    %eax
add    %ecx,%eax
lea    0x4(,%rax,4),%rdx
xor    %esi,%esi
call   1070 <memset@plt>
mov    %rbx,%rcx
mov    0x18(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    0x28(%rsp),%rdx
mov    %ecx,%r8d
mov    $0x1,%r9d
call   1050 <mmult@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r15d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [46 x i8] c"Rows (M) should be greater than Columns (B) \0A\00"
@.str.1 = [22 x i8] c"Failed to Compute SVD\00"
define i32 @lls_svd_multi(float* %0, float* %1, i32 %2, i32 %3, float* %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store float* %4, float** %11
%24 = load i32, i32* %9
%25 = load i32, i32* %10
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %29
27: ; preds = %5
%28 = call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str, i64 0, i64 0))
store i32 -1, i32* %6
br label %190
29: ; preds = %5
%30 = load i32, i32* %9
%31 = sext i32 %30 to i64
%32 = mul i64 4, %31
%33 = load i32, i32* %10
%34 = sext i32 %33 to i64
%35 = mul i64 %32, %34
%36 = trunc i64 %35 to i32
%37 = call i64 @malloc(i32 %36)
%38 = inttoptr i64 %37 to float*
store float* %38, float** %15
%39 = load i32, i32* %10
%40 = sext i32 %39 to i64
%41 = mul i64 4, %40
%42 = load i32, i32* %10
%43 = sext i32 %42 to i64
%44 = mul i64 %41, %43
%45 = trunc i64 %44 to i32
%46 = call i64 @malloc(i32 %45)
%47 = inttoptr i64 %46 to float*
store float* %47, float** %16
%48 = load i32, i32* %10
%49 = sext i32 %48 to i64
%50 = mul i64 4, %49
%51 = trunc i64 %50 to i32
%52 = call i64 @malloc(i32 %51)
%53 = inttoptr i64 %52 to float*
store float* %53, float** %17
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = mul i64 4, %55
%57 = load i32, i32* %10
%58 = sext i32 %57 to i64
%59 = mul i64 %56, %58
%60 = trunc i64 %59 to i32
%61 = call i64 @malloc(i32 %60)
%62 = inttoptr i64 %61 to float*
store float* %62, float** %18
%63 = load i32, i32* %10
%64 = sext i32 %63 to i64
%65 = mul i64 4, %64
%66 = trunc i64 %65 to i32
%67 = call i64 @malloc(i32 %66)
%68 = inttoptr i64 %67 to float*
store float* %68, float** %19
%69 = load float*, float** %7
%70 = load i32, i32* %9
%71 = load i32, i32* %10
%72 = load float*, float** %15
%73 = load float*, float** %16
%74 = load float*, float** %17
%75 = call i32 @svd(float* %69, i32 %70, i32 %71, float* %72, float* %73, float* %74)
store i32 %75, i32* %13
%76 = load i32, i32* %13
%77 = icmp ne i32 %76, 0
br i1 %77, label %78, label %90
78: ; preds = %29
%79 = call i32 @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0))
%80 = load float*, float** %15
%81 = call i32 @free(float* %80)
%82 = load float*, float** %16
%83 = call i32 @free(float* %82)
%84 = load float*, float** %17
%85 = call i32 @free(float* %84)
%86 = load float*, float** %18
%87 = call i32 @free(float* %86)
%88 = load float*, float** %19
%89 = call i32 @free(float* %88)
store i32 -1, i32* %6
br label %190
90: ; preds = %29
%91 = load i32, i32* %9
%92 = sitofp i32 %91 to float
store float %92, float* %22
%93 = call float (...) @macheps()
store float %93, float* %20
store i32 0, i32* %12
%94 = load float*, float** %17
%95 = getelementptr inbounds float, float* %94, i64 0
%96 = load float, float* %95
store float %96, float* %23
%97 = load float, float* %23
%98 = load float, float* %22
%99 = fmul float %97, %98
%100 = load float, float* %20
%101 = fmul float %99, %100
store float %101, float* %21
store i32 0, i32* %14
br label %102
102: ; preds = %118, %90
%103 = load i32, i32* %14
%104 = load i32, i32* %10
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %121
106: ; preds = %102
%107 = load float*, float** %17
%108 = load i32, i32* %14
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
%111 = load float, float* %110
%112 = load float, float* %21
%113 = fcmp ogt float %111, %112
br i1 %113, label %114, label %117
114: ; preds = %106
%115 = load i32, i32* %12
%116 = add nsw i32 %115, 1
store i32 %116, i32* %12
br label %117
117: ; preds = %114, %106
br label %118
118: ; preds = %117
%119 = load i32, i32* %14
%120 = add nsw i32 %119, 1
store i32 %120, i32* %14
br label %102
121: ; preds = %102
%122 = load float*, float** %15
%123 = load i32, i32* %9
%124 = load i32, i32* %10
%125 = load float*, float** %18
%126 = call i32 @mtranspose(float* %122, i32 %123, i32 %124, float* %125)
%127 = load i32, i32* %10
%128 = sext i32 %127 to i64
%129 = mul i64 4, %128
%130 = trunc i64 %129 to i32
%131 = call i64 @malloc(i32 %130)
%132 = inttoptr i64 %131 to float*
store float* %132, float** %19
%133 = load float*, float** %18
%134 = load float*, float** %8
%135 = load float*, float** %19
%136 = load i32, i32* %10
%137 = load i32, i32* %9
%138 = call i32 @mmult(float* %133, float* %134, float* %135, i32 %136, i32 %137, i32 1)
store i32 0, i32* %14
br label %139
139: ; preds = %155, %121
%140 = load i32, i32* %14
%141 = load i32, i32* %12
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %158
143: ; preds = %139
%144 = load float*, float** %17
%145 = load i32, i32* %14
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %19
%150 = load i32, i32* %14
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %149, i64 %151
%153 = load float, float* %152
%154 = fdiv float %153, %148
store float %154, float* %152
br label %155
155: ; preds = %143
%156 = load i32, i32* %14
%157 = add nsw i32 %156, 1
store i32 %157, i32* %14
br label %139
158: ; preds = %139
%159 = load i32, i32* %12
store i32 %159, i32* %14
br label %160
160: ; preds = %169, %158
%161 = load i32, i32* %14
%162 = load i32, i32* %10
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %172
164: ; preds = %160
%165 = load float*, float** %19
%166 = load i32, i32* %14
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %165, i64 %167
store float 0.000000e+00, float* %168
br label %169
169: ; preds = %164
%170 = load i32, i32* %14
%171 = add nsw i32 %170, 1
store i32 %171, i32* %14
br label %160
172: ; preds = %160
%173 = load float*, float** %16
%174 = load float*, float** %19
%175 = load float*, float** %11
%176 = load i32, i32* %10
%177 = load i32, i32* %10
%178 = call i32 @mmult(float* %173, float* %174, float* %175, i32 %176, i32 %177, i32 1)
%179 = load float*, float** %15
%180 = call i32 @free(float* %179)
%181 = load float*, float** %16
%182 = call i32 @free(float* %181)
%183 = load float*, float** %17
%184 = call i32 @free(float* %183)
%185 = load float*, float** %18
%186 = call i32 @free(float* %185)
%187 = load float*, float** %19
%188 = call i32 @free(float* %187)
%189 = load i32, i32* %12
store i32 %189, i32* %6
br label %190
190: ; preds = %172, %78, %27
%191 = load i32, i32* %6
ret i32 %191
}

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