#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ getchar();
float **matrix(int, int, int, int);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ svbksb(float **, float *, float **, int, int, float *,
                          float *);
int /*<<< orphan*/ svdcmp(float **, int, int, float *, float **);
float *vector(int, int);
int main(void) {
  int j, k, l, m, n;
  float wmax, wmin, *w, *x, *c;
  float **a, **b, **u, **v;
  char dummy[80];
  FILE *fp;
  w = vector(1, 20);
  x = vector(1, 20);
  c = vector(1, 20);
  a = matrix(1, 20, 1, 20);
  b = matrix(1, 20, 1, 20);
  u = matrix(1, 20, 1, 20);
  v = matrix(1, 20, 1, 20);
  if ((fp = fopen("matrx1.dat", "r")) == NULL)
    nrerror("Data file matrx1.dat not found\n");
  while (!feof(fp)) {
    fgets(dummy, 80, fp);
    fgets(dummy, 80, fp);
    fscanf(fp, "%d %d ", &n, &m);
    fgets(dummy, 80, fp);
    for (k = 1; k <= n; k++)
      for (l = 1; l <= n; l++)
        fscanf(fp, "%f ", &a[k][l]);
    fgets(dummy, 80, fp);
    for (l = 1; l <= m; l++)
      for (k = 1; k <= n; k++)
        fscanf(fp, "%f ", &b[k][l]);
    for (k = 1; k <= n; k++)
      for (l = 1; l <= n; l++)
        u[k][l] = a[k][l];
    svdcmp(u, n, n, w, v);
    wmax = 0.0;
    for (k = 1; k <= n; k++)
      if (w[k] > wmax)
        wmax = w[k];
    wmin = wmax * (1.0e-6);
    for (k = 1; k <= n; k++)
      if (w[k] < wmin)
        w[k] = 0.0;
    for (l = 1; l <= m; l++) {
      printf("\nVector number %2d\n", l);
      for (k = 1; k <= n; k++)
        c[k] = b[k][l];
      svbksb(u, w, v, n, n, c, x);
      printf(" solution vector is:\n");
      for (k = 1; k <= n; k++)
        printf("%12.6f", x[k]);
      printf("\n original right-hand side vector:\n");
      for (k = 1; k <= n; k++)
        printf("%12.6f", c[k]);
      printf("\n (matrix)*(sol'n vector):\n");
      for (k = 1; k <= n; k++) {
        c[k] = 0.0;
        for (j = 1; j <= n; j++)
          c[k] += a[k][j] * x[j];
      }
      for (k = 1; k <= n; k++)
        printf("%12.6f", c[k]);
      printf("\n");
    }
    printf("***********************************\n");
    printf("press RETURN for next problem\n");
    (void)getchar();
  }
  fclose(fp);
  free_matrix(v, 1, 20, 1, 20);
  free_matrix(u, 1, 20, 1, 20);
  free_matrix(b, 1, 20, 1, 20);
  free_matrix(a, 1, 20, 1, 20);
  free_vector(c, 1, 20);
  free_vector(x, 1, 20);
  free_vector(w, 1, 20);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10f0 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10f0 <vector@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10f0 <vector@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10e0 <matrix@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10e0 <matrix@plt>
mov    %rax,-0x48(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10e0 <matrix@plt>
mov    %rax,-0x50(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10e0 <matrix@plt>
mov    %rax,-0x58(%rbp)
lea    0xd7a(%rip),%rdi
lea    0xd7e(%rip),%rsi
call   1100 <fopen@plt>
mov    %rax,-0xb8(%rbp)
cmp    $0x0,%rax
jne    12b7 <main+0xd7>
lea    0xd63(%rip),%rdi
call   1050 <nrerror@plt>
jmp    12bc <main+0xdc>
mov    -0xb8(%rbp),%rdi
call   10d0 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    12dd <main+0xfd>
jmp    17da <main+0x5fa>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   10a0 <fgets@plt>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   10a0 <fgets@plt>
mov    -0xb8(%rbp),%rdi
lea    0xd1a(%rip),%rsi
lea    -0x18(%rbp),%rdx
lea    -0x14(%rbp),%rcx
mov    $0x0,%al
call   1090 <fscanf@plt>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   10a0 <fgets@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     13b5 <main+0x1d5>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     13a2 <main+0x1c2>
mov    -0xb8(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xcaf(%rip),%rsi
mov    $0x0,%al
call   1090 <fscanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    135c <main+0x17c>
jmp    13a7 <main+0x1c7>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1349 <main+0x169>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   10a0 <fgets@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1440 <main+0x260>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     142d <main+0x24d>
mov    -0xb8(%rbp),%rdi
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xc24(%rip),%rsi
mov    $0x0,%al
call   1090 <fscanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13e7 <main+0x207>
jmp    1432 <main+0x252>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13d4 <main+0x1f4>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     14b1 <main+0x2d1>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     149e <main+0x2be>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    145a <main+0x27a>
jmp    14a3 <main+0x2c3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1447 <main+0x267>
mov    -0x50(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   10c0 <svdcmp@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     151f <main+0x33f>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jbe    150c <main+0x32c>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1511 <main+0x331>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14d7 <main+0x2f7>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xad0(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     158e <main+0x3ae>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    157b <main+0x39b>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1580 <main+0x3a0>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1544 <main+0x364>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     17b2 <main+0x5d2>
mov    -0x10(%rbp),%esi
lea    0xa95(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     15f5 <main+0x415>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15b9 <main+0x3d9>
mov    -0x50(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x18(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    -0x38(%rbp),%r9
mov    -0x30(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <svbksb@plt>
lea    0xa34(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1667 <main+0x487>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa18(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    162e <main+0x44e>
lea    0xa03(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     16b5 <main+0x4d5>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9ca(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    167c <main+0x49c>
lea    0x9d9(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1756 <main+0x576>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1743 <main+0x563>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    16ed <main+0x50d>
jmp    1748 <main+0x568>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16ca <main+0x4ea>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1796 <main+0x5b6>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x8e9(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    175d <main+0x57d>
lea    0x937(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1595 <main+0x3b5>
lea    0x8f8(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0x90f(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10b0 <getchar@plt>
jmp    12bc <main+0xdc>
mov    -0xb8(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x58(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x50(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x48(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1080 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1080 <free_vector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1080 <free_vector@plt>
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    $0x1,%edi
mov    $0x14,%esi
call   1110 <vector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x14,%esi
call   1110 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x14,%esi
call   1110 <vector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   1100 <matrix@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   1100 <matrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   1100 <matrix@plt>
mov    %rax,0x20(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   1100 <matrix@plt>
mov    %rax,0x30(%rsp)
lea    0xd44(%rip),%rdi
lea    0xd48(%rip),%rsi
call   1120 <fopen@plt>
mov    %rax,%rbp
test   %rax,%rax
jne    12e4 <main+0xe4>
lea    0xd36(%rip),%rdi
call   1070 <nrerror@plt>
mov    %rbp,%rdi
call   10f0 <feof@plt>
test   %eax,%eax
je     13c0 <main+0x1c0>
mov    %rbp,%rdi
call   1080 <fclose@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1060 <free_matrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1060 <free_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1060 <free_matrix@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1060 <free_matrix@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   10a0 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   10a0 <free_vector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   10a0 <free_vector@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,0x38(%rsp)
mov    %r13,0x58(%rsp)
mov    %rbp,0x18(%rsp)
jmp    1414 <main+0x214>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0xc74(%rip),%rdi
call   1040 <puts@plt>
lea    0xc8c(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   10d0 <getchar@plt>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   10f0 <feof@plt>
test   %eax,%eax
jne    12f4 <main+0xf4>
lea    0x60(%rsp),%r14
mov    %r14,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10c0 <fgets@plt>
mov    %r14,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10c0 <fgets@plt>
mov    %rbp,%rdi
lea    0xbf2(%rip),%rsi
lea    0x10(%rsp),%rdx
lea    0x14(%rsp),%rcx
xor    %eax,%eax
call   10b0 <fscanf@plt>
mov    %r14,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10c0 <fgets@plt>
mov    0x10(%rsp),%eax
test   %eax,%eax
mov    %rbp,%rdx
jle    14f0 <main+0x2f0>
mov    $0x1,%edi
jmp    148f <main+0x28f>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rcx
lea    0x1(%rdi),%rsi
cmp    %rcx,%rdi
mov    %rsi,%rdi
jge    14f0 <main+0x2f0>
test   %eax,%eax
jle    1480 <main+0x280>
mov    $0x4,%ebp
xor    %r12d,%r12d
lea    0xb9a(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rax
mov    (%rax,%rdi,8),%rdx
add    %rbp,%rdx
mov    %rdi,%r13
mov    0x18(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fscanf@plt>
mov    %r13,%rdi
movslq 0x10(%rsp),%rax
add    $0x1,%r12
add    $0x4,%rbp
cmp    %rax,%r12
jl     14b0 <main+0x2b0>
mov    0x58(%rsp),%r13
mov    0x18(%rsp),%rdx
jmp    1480 <main+0x280>
nop
lea    0x60(%rsp),%rdi
mov    $0x50,%esi
call   10c0 <fgets@plt>
mov    0x14(%rsp),%eax
mov    0x10(%rsp),%edx
test   %eax,%eax
jle    1580 <main+0x380>
mov    $0x1,%r14d
mov    0x18(%rsp),%rdi
jmp    152f <main+0x32f>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r14),%rcx
movslq %eax,%rsi
cmp    %rsi,%r14
mov    %rcx,%r14
jge    1580 <main+0x380>
test   %edx,%edx
jle    1520 <main+0x320>
xor    %ebp,%ebp
mov    %r13,%r12
lea    0xafd(%rip),%r13
nop
lea    0x0(,%r14,4),%rdx
add    0x8(%r12,%rbp,8),%rdx
mov    %r13,%rsi
xor    %eax,%eax
call   10b0 <fscanf@plt>
mov    0x18(%rsp),%rdi
movslq 0x10(%rsp),%rdx
add    $0x1,%rbp
cmp    %rdx,%rbp
jl     1540 <main+0x340>
mov    0x14(%rsp),%eax
mov    %r12,%r13
jmp    1520 <main+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %edx,%edx
jle    1780 <main+0x580>
mov    %edx,%r11d
lea    0x1(%r11),%rcx
lea    -0x8(%r11),%rax
mov    %rax,0x50(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r11d,%r10d
and    $0xfffffff8,%r10d
lea    0x1(%r10),%rsi
mov    %rsi,0x48(%rsp)
mov    %eax,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    $0x1,%r12d
jmp    15dd <main+0x3dd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %rcx,%r12
je     1780 <main+0x580>
mov    0x28(%rsp),%rax
mov    (%rax,%r12,8),%rdi
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%r9
mov    $0x1,%r8d
cmp    $0x8,%r11d
jb     16f0 <main+0x4f0>
lea    0x4(%r9),%rax
lea    (%rdi,%rcx,4),%rbp
cmp    %rbp,%rax
jae    1623 <main+0x423>
lea    (%r9,%rcx,4),%rax
lea    0x4(%rdi),%rbp
mov    $0x1,%r8d
cmp    %rax,%rbp
jb     16f0 <main+0x4f0>
cmpq   $0x18,0x50(%rsp)
jae    162f <main+0x42f>
xor    %eax,%eax
jmp    16a2 <main+0x4a2>
mov    0x40(%rsp),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rdi,%rax,4),%xmm0
movups 0x14(%rdi,%rax,4),%xmm1
movups %xmm0,0x4(%r9,%rax,4)
movups %xmm1,0x14(%r9,%rax,4)
movups 0x24(%rdi,%rax,4),%xmm0
movups 0x34(%rdi,%rax,4),%xmm1
movups %xmm0,0x24(%r9,%rax,4)
movups %xmm1,0x34(%r9,%rax,4)
movups 0x44(%rdi,%rax,4),%xmm0
movups 0x54(%rdi,%rax,4),%xmm1
movups %xmm0,0x44(%r9,%rax,4)
movups %xmm1,0x54(%r9,%rax,4)
movups 0x64(%rdi,%rax,4),%xmm0
movups 0x74(%rdi,%rax,4),%xmm1
movups %xmm0,0x64(%r9,%rax,4)
movups %xmm1,0x74(%r9,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rbp
jne    1640 <main+0x440>
test   %r14,%r14
je     16da <main+0x4da>
mov    %r14,%rbp
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rax,4),%rsi
or     $0x4,%rsi
movups (%rdi,%rsi,1),%xmm0
movups 0x10(%rdi,%rsi,1),%xmm1
movups %xmm0,(%r9,%rsi,1)
movups %xmm1,0x10(%r9,%rsi,1)
add    $0x8,%rax
add    $0xffffffffffffffff,%rbp
jne    16b0 <main+0x4b0>
mov    0x48(%rsp),%r8
cmp    %r10,%r11
je     15d0 <main+0x3d0>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%ebp
sub    %r8d,%ebp
mov    %r8,%rax
not    %rax
add    %rcx,%rax
and    $0x3,%rbp
je     1726 <main+0x526>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdi,%r8,4),%xmm0
movss  %xmm0,(%r9,%r8,4)
add    $0x1,%r8
add    $0xffffffffffffffff,%rbp
jne    1710 <main+0x510>
cmp    $0x3,%rax
jb     15d0 <main+0x3d0>
movss  (%rdi,%r8,4),%xmm0
movss  %xmm0,(%r9,%r8,4)
movss  0x4(%rdi,%r8,4),%xmm0
movss  %xmm0,0x4(%r9,%r8,4)
movss  0x8(%rdi,%r8,4),%xmm0
movss  %xmm0,0x8(%r9,%r8,4)
movss  0xc(%rdi,%r8,4),%xmm0
movss  %xmm0,0xc(%r9,%r8,4)
add    $0x4,%r8
cmp    %r8,%rcx
jne    1730 <main+0x530>
jmp    15d0 <main+0x3d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%rdi
mov    %edx,%esi
mov    0x38(%rsp),%r12
mov    %r12,%rcx
mov    0x30(%rsp),%r8
call   10e0 <svdcmp@plt>
mov    0x10(%rsp),%eax
test   %eax,%eax
jle    1950 <main+0x750>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    17c0 <main+0x5c0>
xorps  %xmm0,%xmm0
mov    $0x1,%edx
jmp    1809 <main+0x609>
xchg   %ax,%ax
mov    %eax,%esi
and    $0xfffffffc,%esi
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
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    17d0 <main+0x5d0>
add    $0x1,%rdx
movaps %xmm0,%xmm1
test   %rcx,%rcx
je     1835 <main+0x635>
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    1820 <main+0x620>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x7bc(%rip),%xmm0
test   %eax,%eax
jle    1950 <main+0x750>
cvtsd2ss %xmm0,%xmm0
add    $0x1,%rax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1c2d <main+0xa2d>
mov    %rdx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %edi,%edi
jmp    188d <main+0x68d>
nopl   (%rax)
add    $0x8,%rdi
cmp    %rdi,%rsi
je     193e <main+0x73e>
movups 0x4(%r12,%rdi,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    18a1 <main+0x6a1>
movl   $0x0,0x4(%r12,%rdi,4)
cmpltps %xmm1,%xmm2
pextrw $0x2,%xmm2,%ebp
test   $0x1,%bpl
je     18b9 <main+0x6b9>
movl   $0x0,0x8(%r12,%rdi,4)
pextrw $0x4,%xmm2,%ebp
test   $0x1,%bpl
je     18cd <main+0x6cd>
movl   $0x0,0xc(%r12,%rdi,4)
pextrw $0x6,%xmm2,%ebp
test   $0x1,%bpl
je     18e1 <main+0x6e1>
movl   $0x0,0x10(%r12,%rdi,4)
movups 0x14(%r12,%rdi,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    18f5 <main+0x6f5>
movl   $0x0,0x14(%r12,%rdi,4)
cmpltps %xmm1,%xmm2
pextrw $0x2,%xmm2,%ebp
test   $0x1,%bpl
je     190d <main+0x70d>
movl   $0x0,0x18(%r12,%rdi,4)
pextrw $0x4,%xmm2,%ebp
test   $0x1,%bpl
je     1921 <main+0x721>
movl   $0x0,0x1c(%r12,%rdi,4)
pextrw $0x6,%xmm2,%ebp
test   $0x1,%bpl
je     1880 <main+0x680>
movl   $0x0,0x20(%r12,%rdi,4)
jmp    1880 <main+0x680>
cmp    %rsi,%rdx
jne    1c2d <main+0xa2d>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x14(%rsp)
jle    13e0 <main+0x1e0>
mov    $0x1,%r14d
jmp    1994 <main+0x794>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r14),%rax
movslq 0x14(%rsp),%rcx
cmp    %rcx,%r14
mov    %rax,%r14
mov    0x38(%rsp),%r12
jge    13e0 <main+0x1e0>
lea    0x6a5(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1090 <printf@plt>
mov    0x10(%rsp),%ecx
test   %ecx,%ecx
jle    1a59 <main+0x859>
lea    -0x1(%rcx),%rsi
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x1,%edx
cmp    $0x3,%rsi
jb     1a21 <main+0x821>
mov    %ecx,%esi
and    $0xfffffffc,%esi
xor    %edx,%edx
nopl   0x0(%rax)
mov    0x8(%r13,%rdx,8),%rdi
movss  (%rdi,%r14,4),%xmm0
movss  %xmm0,0x4(%rbx,%rdx,4)
mov    0x10(%r13,%rdx,8),%rdi
movss  (%rdi,%r14,4),%xmm0
movss  %xmm0,0x8(%rbx,%rdx,4)
mov    0x18(%r13,%rdx,8),%rdi
movss  (%rdi,%r14,4),%xmm0
movss  %xmm0,0xc(%rbx,%rdx,4)
mov    0x20(%r13,%rdx,8),%rdi
movss  (%rdi,%r14,4),%xmm0
movss  %xmm0,0x10(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    19d0 <main+0x7d0>
add    $0x1,%rdx
test   %rax,%rax
je     1a59 <main+0x859>
lea    (%rbx,%rdx,4),%rsi
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rbp
movss  0x0(%rbp,%r14,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1a40 <main+0x840>
mov    %r15,(%rsp)
mov    0x20(%rsp),%rdi
mov    %r12,%rsi
mov    0x30(%rsp),%rdx
mov    %ecx,%r8d
mov    %rbx,%r9
call   1050 <svbksb@plt>
lea    0x621(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x10(%rsp)
lea    0x5c7(%rip),%r12
jle    1ac3 <main+0x8c3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x4(%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movslq 0x10(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1aa0 <main+0x8a0>
lea    0x5e8(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x10(%rsp)
jle    1b02 <main+0x902>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movss  0x4(%rbx,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movslq 0x10(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1ae0 <main+0x8e0>
lea    0x5cc(%rip),%rdi
call   1040 <puts@plt>
mov    0x10(%rsp),%r8d
test   %r8d,%r8d
jle    1970 <main+0x770>
lea    0x1(%r8),%rcx
mov    %r8d,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%esi
mov    0x28(%rsp),%r9
jmp    1b4d <main+0x94d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
cmp    %rcx,%rsi
je     1bd0 <main+0x9d0>
movl   $0x0,(%rbx,%rsi,4)
mov    (%r9,%rsi,8),%rdi
xorps  %xmm0,%xmm0
mov    $0x1,%ebp
cmp    $0x2,%ecx
je     1bac <main+0x9ac>
mov    $0x1,%ebp
xorps  %xmm0,%xmm0
nopl   (%rax)
movss  (%rdi,%rbp,4),%xmm1
mulss  (%r15,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  0x4(%rdi,%rbp,4),%xmm0
mulss  0x4(%r15,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%rsi,4)
lea    (%rdx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbp
cmp    $0x1,%rax
jne    1b70 <main+0x970>
test   $0x1,%r8b
je     1b40 <main+0x940>
movss  (%rdi,%rbp,4),%xmm1
mulss  (%r15,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
jmp    1b40 <main+0x940>
nopl   0x0(%rax,%rax,1)
test   %r8d,%r8d
lea    0x47a(%rip),%r12
jle    1970 <main+0x770>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x4(%rbx,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movslq 0x10(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1bf0 <main+0x9f0>
jmp    1970 <main+0x770>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1950 <main+0x750>
ucomiss (%r12,%rcx,4),%xmm0
jbe    1c20 <main+0xa20>
movl   $0x0,(%r12,%rcx,4)
jmp    1c20 <main+0xa20>

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

LLVM IR (-O2):
@.str = [11 x i8] c"matrx1.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [32 x i8] c"Data file matrx1.dat not found\0A\00"
@.str.3 = [7 x i8] c"%d %d \00"
@.str.4 = [4 x i8] c"%f \00"
@.str.5 = [20 x i8] c"\0AVector number %2d\0A\00"
@.str.7 = [7 x i8] c"%12.6f\00"
@str = [36 x i8] c"***********************************\00"
@str.13 = [30 x i8] c"press RETURN for next problem\00"
@str.14 = [21 x i8] c" solution vector is:\00"
@str.15 = [35 x i8] c"\0A original right-hand side vector:\00"
@str.16 = [27 x i8] c"\0A (matrix)*(sol'n vector):\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [80 x i8]
%4 = bitcast i32* %1 to i8*
%5 = bitcast i32* %2 to i8*
%6 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 0
%7 = tail call float* @vector(i32 1, i32 20)
%8 = tail call float* @vector(i32 1, i32 20)
%9 = tail call float* @vector(i32 1, i32 20)
%10 = tail call float** @matrix(i32 1, i32 20, i32 1, i32 20)
%11 = tail call float** @matrix(i32 1, i32 20, i32 1, i32 20)
%12 = tail call float** @matrix(i32 1, i32 20, i32 1, i32 20)
%13 = tail call float** @matrix(i32 1, i32 20, i32 1, i32 20)
%14 = tail call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%15 = icmp eq i32* %14, null
br i1 %15, label %16, label %18
16: ; preds = %0
%17 = tail call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %18
18: ; preds = %16, %0
%19 = call i32 @feof(i32* %14)
%20 = icmp eq i32 %19, 0
br i1 %20, label %21, label %517
21: ; preds = %18, %511
%22 = call i32 @fgets(i8* %6, i32 80, i32* %14)
%23 = call i32 @fgets(i8* %6, i32 80, i32* %14)
%24 = call i32 (i32*, i8*, ...) @fscanf(i32* %14, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32* %2, i32* %1)
%25 = call i32 @fgets(i8* %6, i32 80, i32* %14)
%26 = load i32, i32* %2
%27 = icmp slt i32 %26, 1
br i1 %27, label %48, label %28
28: ; preds = %21, %43
%29 = phi i32 [ %44, %43 ], [ %26, %21 ]
%30 = phi i64 [ %46, %43 ], [ 1, %21 ]
%31 = icmp slt i32 %29, 1
br i1 %31, label %43, label %32
32: ; preds = %28
%33 = getelementptr inbounds float*, float** %10, i64 %30
br label %34
34: ; preds = %32, %34
%35 = phi i64 [ 1, %32 ], [ %39, %34 ]
%36 = load float*, float** %33
%37 = getelementptr inbounds float, float* %36, i64 %35
%38 = call i32 (i32*, i8*, ...) @fscanf(i32* %14, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), float* %37)
%39 = add nuw nsw i64 %35, 1
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = icmp slt i64 %35, %41
br i1 %42, label %34, label %43
43: ; preds = %34, %28
%44 = phi i32 [ %29, %28 ], [ %40, %34 ]
%45 = sext i32 %44 to i64
%46 = add nuw nsw i64 %30, 1
%47 = icmp slt i64 %30, %45
br i1 %47, label %28, label %48
48: ; preds = %43, %21
%49 = call i32 @fgets(i8* %6, i32 80, i32* %14)
%50 = load i32, i32* %1
%51 = icmp slt i32 %50, 1
%52 = load i32, i32* %2
br i1 %51, label %53, label %71
53: ; preds = %88, %48
%54 = phi i32 [ %52, %48 ], [ %90, %88 ]
%55 = icmp slt i32 %54, 1
br i1 %55, label %220, label %56
56: ; preds = %53
%57 = add nuw i32 %54, 1
%58 = zext i32 %57 to i64
%59 = add nsw i64 %58, -1
%60 = add nsw i64 %58, -9
%61 = lshr i64 %60, 3
%62 = add nuw nsw i64 %61, 1
%63 = icmp ult i64 %59, 8
%64 = and i64 %59, -8
%65 = or i64 %64, 1
%66 = and i64 %62, 3
%67 = icmp ult i64 %60, 24
%68 = and i64 %62, 4611686018427387900
%69 = icmp eq i64 %66, 0
%70 = icmp eq i64 %59, %64
br label %94
71: ; preds = %48, %88
%72 = phi i32 [ %89, %88 ], [ %50, %48 ]
%73 = phi i32 [ %90, %88 ], [ %52, %48 ]
%74 = phi i64 [ %91, %88 ], [ 1, %48 ]
%75 = icmp slt i32 %73, 1
br i1 %75, label %88, label %76
76: ; preds = %71, %76
%77 = phi i64 [ %82, %76 ], [ 1, %71 ]
%78 = getelementptr inbounds float*, float** %11, i64 %77
%79 = load float*, float** %78
%80 = getelementptr inbounds float, float* %79, i64 %74
%81 = call i32 (i32*, i8*, ...) @fscanf(i32* %14, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), float* %80)
%82 = add nuw nsw i64 %77, 1
%83 = load i32, i32* %2
%84 = sext i32 %83 to i64
%85 = icmp slt i64 %77, %84
br i1 %85, label %76, label %86
86: ; preds = %76
%87 = load i32, i32* %1
br label %88
88: ; preds = %86, %71
%89 = phi i32 [ %87, %86 ], [ %72, %71 ]
%90 = phi i32 [ %83, %86 ], [ %73, %71 ]
%91 = add nuw nsw i64 %74, 1
%92 = sext i32 %89 to i64
%93 = icmp slt i64 %74, %92
br i1 %93, label %71, label %53
94: ; preds = %217, %56
%95 = phi i64 [ 1, %56 ], [ %218, %217 ]
%96 = getelementptr inbounds float*, float** %10, i64 %95
%97 = load float*, float** %96
%98 = getelementptr inbounds float*, float** %12, i64 %95
%99 = load float*, float** %98
br i1 %63, label %179, label %100
100: ; preds = %94
%101 = getelementptr float, float* %99, i64 1
%102 = getelementptr float, float* %99, i64 %58
%103 = getelementptr float, float* %97, i64 1
%104 = getelementptr float, float* %97, i64 %58
%105 = icmp ult float* %101, %104
%106 = icmp ult float* %103, %102
%107 = and i1 %105, %106
br i1 %107, label %179, label %108
108: ; preds = %100
br i1 %67, label %159, label %109
109: ; preds = %108, %109
%110 = phi i64 [ %156, %109 ], [ 0, %108 ]
%111 = phi i64 [ %157, %109 ], [ 0, %108 ]
%112 = or i64 %110, 1
%113 = getelementptr inbounds float, float* %97, i64 %112
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = getelementptr inbounds float, float* %113, i64 4
%117 = bitcast float* %116 to <4 x float>*
%118 = load <4 x float>, <4 x float>* %117
%119 = getelementptr inbounds float, float* %99, i64 %112
%120 = bitcast float* %119 to <4 x float>*
store <4 x float> %115, <4 x float>* %120
%121 = getelementptr inbounds float, float* %119, i64 4
%122 = bitcast float* %121 to <4 x float>*
store <4 x float> %118, <4 x float>* %122
%123 = or i64 %110, 9
%124 = getelementptr inbounds float, float* %97, i64 %123
%125 = bitcast float* %124 to <4 x float>*
%126 = load <4 x float>, <4 x float>* %125
%127 = getelementptr inbounds float, float* %124, i64 4
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = getelementptr inbounds float, float* %99, i64 %123
%131 = bitcast float* %130 to <4 x float>*
store <4 x float> %126, <4 x float>* %131
%132 = getelementptr inbounds float, float* %130, i64 4
%133 = bitcast float* %132 to <4 x float>*
store <4 x float> %129, <4 x float>* %133
%134 = or i64 %110, 17
%135 = getelementptr inbounds float, float* %97, i64 %134
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = getelementptr inbounds float, float* %135, i64 4
%139 = bitcast float* %138 to <4 x float>*
%140 = load <4 x float>, <4 x float>* %139
%141 = getelementptr inbounds float, float* %99, i64 %134
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %137, <4 x float>* %142
%143 = getelementptr inbounds float, float* %141, i64 4
%144 = bitcast float* %143 to <4 x float>*
store <4 x float> %140, <4 x float>* %144
%145 = or i64 %110, 25
%146 = getelementptr inbounds float, float* %97, i64 %145
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = getelementptr inbounds float, float* %146, i64 4
%150 = bitcast float* %149 to <4 x float>*
%151 = load <4 x float>, <4 x float>* %150
%152 = getelementptr inbounds float, float* %99, i64 %145
%153 = bitcast float* %152 to <4 x float>*
store <4 x float> %148, <4 x float>* %153
%154 = getelementptr inbounds float, float* %152, i64 4
%155 = bitcast float* %154 to <4 x float>*
store <4 x float> %151, <4 x float>* %155
%156 = add nuw i64 %110, 32
%157 = add i64 %111, 4
%158 = icmp eq i64 %157, %68
br i1 %158, label %159, label %109
159: ; preds = %109, %108
%160 = phi i64 [ 0, %108 ], [ %156, %109 ]
br i1 %69, label %178, label %161
161: ; preds = %159, %161
%162 = phi i64 [ %175, %161 ], [ %160, %159 ]
%163 = phi i64 [ %176, %161 ], [ 0, %159 ]
%164 = or i64 %162, 1
%165 = getelementptr inbounds float, float* %97, i64 %164
%166 = bitcast float* %165 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = getelementptr inbounds float, float* %165, i64 4
%169 = bitcast float* %168 to <4 x float>*
%170 = load <4 x float>, <4 x float>* %169
%171 = getelementptr inbounds float, float* %99, i64 %164
%172 = bitcast float* %171 to <4 x float>*
store <4 x float> %167, <4 x float>* %172
%173 = getelementptr inbounds float, float* %171, i64 4
%174 = bitcast float* %173 to <4 x float>*
store <4 x float> %170, <4 x float>* %174
%175 = add nuw i64 %162, 8
%176 = add i64 %163, 1
%177 = icmp eq i64 %176, %66
br i1 %177, label %178, label %161
178: ; preds = %161, %159
br i1 %70, label %217, label %179
179: ; preds = %100, %94, %178
%180 = phi i64 [ 1, %100 ], [ 1, %94 ], [ %65, %178 ]
%181 = sub nsw i64 %58, %180
%182 = xor i64 %180, -1
%183 = add nsw i64 %182, %58
%184 = and i64 %181, 3
%185 = icmp eq i64 %184, 0
br i1 %185, label %195, label %186
186: ; preds = %179, %186
%187 = phi i64 [ %192, %186 ], [ %180, %179 ]
%188 = phi i64 [ %193, %186 ], [ 0, %179 ]
%189 = getelementptr inbounds float, float* %97, i64 %187
%190 = load float, float* %189
%191 = getelementptr inbounds float, float* %99, i64 %187
store float %190, float* %191
%192 = add nuw nsw i64 %187, 1
%193 = add i64 %188, 1
%194 = icmp eq i64 %193, %184
br i1 %194, label %195, label %186
195: ; preds = %186, %179
%196 = phi i64 [ %180, %179 ], [ %192, %186 ]
%197 = icmp ult i64 %183, 3
br i1 %197, label %217, label %198
198: ; preds = %195, %198
%199 = phi i64 [ %215, %198 ], [ %196, %195 ]
%200 = getelementptr inbounds float, float* %97, i64 %199
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %99, i64 %199
store float %201, float* %202
%203 = add nuw nsw i64 %199, 1
%204 = getelementptr inbounds float, float* %97, i64 %203
%205 = load float, float* %204
%206 = getelementptr inbounds float, float* %99, i64 %203
store float %205, float* %206
%207 = add nuw nsw i64 %199, 2
%208 = getelementptr inbounds float, float* %97, i64 %207
%209 = load float, float* %208
%210 = getelementptr inbounds float, float* %99, i64 %207
store float %209, float* %210
%211 = add nuw nsw i64 %199, 3
%212 = getelementptr inbounds float, float* %97, i64 %211
%213 = load float, float* %212
%214 = getelementptr inbounds float, float* %99, i64 %211
store float %213, float* %214
%215 = add nuw nsw i64 %199, 4
%216 = icmp eq i64 %215, %58
br i1 %216, label %217, label %198
217: ; preds = %195, %198, %178
%218 = add nuw nsw i64 %95, 1
%219 = icmp eq i64 %218, %58
br i1 %219, label %220, label %94
220: ; preds = %217, %53
%221 = call i32 @svdcmp(float** %12, i32 %54, i32 %54, float* %7, float** %13)
%222 = load i32, i32* %2
%223 = icmp slt i32 %222, 1
br i1 %223, label %348, label %224
224: ; preds = %220
%225 = add nuw i32 %222, 1
%226 = zext i32 %225 to i64
%227 = add nsw i64 %226, -1
%228 = add nsw i64 %226, -2
%229 = and i64 %227, 3
%230 = icmp ult i64 %228, 3
br i1 %230, label %259, label %231
231: ; preds = %224
%232 = and i64 %227, -4
br label %233
233: ; preds = %233, %231
%234 = phi i64 [ 1, %231 ], [ %256, %233 ]
%235 = phi float [ 0.000000e+00, %231 ], [ %255, %233 ]
%236 = phi i64 [ 0, %231 ], [ %257, %233 ]
%237 = getelementptr inbounds float, float* %7, i64 %234
%238 = load float, float* %237
%239 = fcmp ogt float %238, %235
%240 = select i1 %239, float %238, float %235
%241 = add nuw nsw i64 %234, 1
%242 = getelementptr inbounds float, float* %7, i64 %241
%243 = load float, float* %242
%244 = fcmp ogt float %243, %240
%245 = select i1 %244, float %243, float %240
%246 = add nuw nsw i64 %234, 2
%247 = getelementptr inbounds float, float* %7, i64 %246
%248 = load float, float* %247
%249 = fcmp ogt float %248, %245
%250 = select i1 %249, float %248, float %245
%251 = add nuw nsw i64 %234, 3
%252 = getelementptr inbounds float, float* %7, i64 %251
%253 = load float, float* %252
%254 = fcmp ogt float %253, %250
%255 = select i1 %254, float %253, float %250
%256 = add nuw nsw i64 %234, 4
%257 = add i64 %236, 4
%258 = icmp eq i64 %257, %232
br i1 %258, label %259, label %233
259: ; preds = %233, %224
%260 = phi float [ undef, %224 ], [ %255, %233 ]
%261 = phi i64 [ 1, %224 ], [ %256, %233 ]
%262 = phi float [ 0.000000e+00, %224 ], [ %255, %233 ]
%263 = icmp eq i64 %229, 0
br i1 %263, label %275, label %264
264: ; preds = %259, %264
%265 = phi i64 [ %272, %264 ], [ %261, %259 ]
%266 = phi float [ %271, %264 ], [ %262, %259 ]
%267 = phi i64 [ %273, %264 ], [ 0, %259 ]
%268 = getelementptr inbounds float, float* %7, i64 %265
%269 = load float, float* %268
%270 = fcmp ogt float %269, %266
%271 = select i1 %270, float %269, float %266
%272 = add nuw nsw i64 %265, 1
%273 = add i64 %267, 1
%274 = icmp eq i64 %273, %229
br i1 %274, label %275, label %264
275: ; preds = %264, %259
%276 = phi float [ %260, %259 ], [ %271, %264 ]
%277 = fpext float %276 to double
%278 = fmul double %277, 0x3EB0C6F7A0B5ED8D
%279 = fptrunc double %278 to float
br i1 %223, label %348, label %280
280: ; preds = %275
%281 = add nuw i32 %222, 1
%282 = zext i32 %281 to i64
%283 = add nsw i64 %226, -1
%284 = icmp ult i64 %283, 8
br i1 %284, label %346, label %285
285: ; preds = %280
%286 = and i64 %283, -8
%287 = or i64 %286, 1
%288 = insertelement <4 x float> poison, float %279, i64 0
%289 = shufflevector <4 x float> %288, <4 x float> poison, <4 x i32> zeroinitializer
%290 = insertelement <4 x float> poison, float %279, i64 0
%291 = shufflevector <4 x float> %290, <4 x float> poison, <4 x i32> zeroinitializer
br label %292
292: ; preds = %341, %285
%293 = phi i64 [ 0, %285 ], [ %342, %341 ]
%294 = or i64 %293, 1
%295 = or i64 %293, 5
%296 = getelementptr inbounds float, float* %7, i64 %294
%297 = bitcast float* %296 to <4 x float>*
%298 = load <4 x float>, <4 x float>* %297
%299 = getelementptr inbounds float, float* %296, i64 4
%300 = bitcast float* %299 to <4 x float>*
%301 = load <4 x float>, <4 x float>* %300
%302 = fcmp olt <4 x float> %298, %289
%303 = fcmp olt <4 x float> %301, %291
%304 = extractelement <4 x i1> %302, i64 0
br i1 %304, label %305, label %307
305: ; preds = %292
%306 = getelementptr inbounds float, float* %7, i64 %294
store float 0.000000e+00, float* %306
br label %307
307: ; preds = %305, %292
%308 = extractelement <4 x i1> %302, i64 1
br i1 %308, label %309, label %312
309: ; preds = %307
%310 = or i64 %293, 2
%311 = getelementptr inbounds float, float* %7, i64 %310
store float 0.000000e+00, float* %311
br label %312
312: ; preds = %309, %307
%313 = extractelement <4 x i1> %302, i64 2
br i1 %313, label %314, label %317
314: ; preds = %312
%315 = or i64 %293, 3
%316 = getelementptr inbounds float, float* %7, i64 %315
store float 0.000000e+00, float* %316
br label %317
317: ; preds = %314, %312
%318 = extractelement <4 x i1> %302, i64 3
br i1 %318, label %319, label %322
319: ; preds = %317
%320 = or i64 %293, 4
%321 = getelementptr inbounds float, float* %7, i64 %320
store float 0.000000e+00, float* %321
br label %322
322: ; preds = %319, %317
%323 = extractelement <4 x i1> %303, i64 0
br i1 %323, label %324, label %326
324: ; preds = %322
%325 = getelementptr inbounds float, float* %7, i64 %295
store float 0.000000e+00, float* %325
br label %326
326: ; preds = %324, %322
%327 = extractelement <4 x i1> %303, i64 1
br i1 %327, label %328, label %331
328: ; preds = %326
%329 = or i64 %293, 6
%330 = getelementptr inbounds float, float* %7, i64 %329
store float 0.000000e+00, float* %330
br label %331
331: ; preds = %328, %326
%332 = extractelement <4 x i1> %303, i64 2
br i1 %332, label %333, label %336
333: ; preds = %331
%334 = or i64 %293, 7
%335 = getelementptr inbounds float, float* %7, i64 %334
store float 0.000000e+00, float* %335
br label %336
336: ; preds = %333, %331
%337 = extractelement <4 x i1> %303, i64 3
br i1 %337, label %338, label %341
338: ; preds = %336
%339 = add i64 %293, 8
%340 = getelementptr inbounds float, float* %7, i64 %339
store float 0.000000e+00, float* %340
br label %341
341: ; preds = %338, %336
%342 = add nuw i64 %293, 8
%343 = icmp eq i64 %342, %286
br i1 %343, label %344, label %292
344: ; preds = %341
%345 = icmp eq i64 %283, %286
br i1 %345, label %348, label %346
346: ; preds = %280, %344
%347 = phi i64 [ 1, %280 ], [ %287, %344 ]
br label %351
348: ; preds = %357, %344, %220, %275
%349 = load i32, i32* %1
%350 = icmp slt i32 %349, 1
br i1 %350, label %511, label %360
351: ; preds = %346, %357
%352 = phi i64 [ %358, %357 ], [ %347, %346 ]
%353 = getelementptr inbounds float, float* %7, i64 %352
%354 = load float, float* %353
%355 = fcmp olt float %354, %279
br i1 %355, label %356, label %357
356: ; preds = %351
store float 0.000000e+00, float* %353
br label %357
357: ; preds = %351, %356
%358 = add nuw nsw i64 %352, 1
%359 = icmp eq i64 %358, %282
br i1 %359, label %348, label %351
360: ; preds = %348, %505
%361 = phi i64 [ %507, %505 ], [ 1, %348 ]
%362 = trunc i64 %361 to i32
%363 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.5, i64 0, i64 0), i32 %362)
%364 = load i32, i32* %2
%365 = icmp slt i32 %364, 1
br i1 %365, label %418, label %366
366: ; preds = %360
%367 = add nuw i32 %364, 1
%368 = zext i32 %367 to i64
%369 = add nsw i64 %368, -1
%370 = add nsw i64 %368, -2
%371 = and i64 %369, 3
%372 = icmp ult i64 %370, 3
br i1 %372, label %404, label %373
373: ; preds = %366
%374 = and i64 %369, -4
br label %375
375: ; preds = %375, %373
%376 = phi i64 [ 1, %373 ], [ %401, %375 ]
%377 = phi i64 [ 0, %373 ], [ %402, %375 ]
%378 = getelementptr inbounds float*, float** %11, i64 %376
%379 = load float*, float** %378
%380 = getelementptr inbounds float, float* %379, i64 %361
%381 = load float, float* %380
%382 = getelementptr inbounds float, float* %9, i64 %376
store float %381, float* %382
%383 = add nuw nsw i64 %376, 1
%384 = getelementptr inbounds float*, float** %11, i64 %383
%385 = load float*, float** %384
%386 = getelementptr inbounds float, float* %385, i64 %361
%387 = load float, float* %386
%388 = getelementptr inbounds float, float* %9, i64 %383
store float %387, float* %388
%389 = add nuw nsw i64 %376, 2
%390 = getelementptr inbounds float*, float** %11, i64 %389
%391 = load float*, float** %390
%392 = getelementptr inbounds float, float* %391, i64 %361
%393 = load float, float* %392
%394 = getelementptr inbounds float, float* %9, i64 %389
store float %393, float* %394
%395 = add nuw nsw i64 %376, 3
%396 = getelementptr inbounds float*, float** %11, i64 %395
%397 = load float*, float** %396
%398 = getelementptr inbounds float, float* %397, i64 %361
%399 = load float, float* %398
%400 = getelementptr inbounds float, float* %9, i64 %395
store float %399, float* %400
%401 = add nuw nsw i64 %376, 4
%402 = add i64 %377, 4
%403 = icmp eq i64 %402, %374
br i1 %403, label %404, label %375
404: ; preds = %375, %366
%405 = phi i64 [ 1, %366 ], [ %401, %375 ]
%406 = icmp eq i64 %371, 0
br i1 %406, label %418, label %407
407: ; preds = %404, %407
%408 = phi i64 [ %415, %407 ], [ %405, %404 ]
%409 = phi i64 [ %416, %407 ], [ 0, %404 ]
%410 = getelementptr inbounds float*, float** %11, i64 %408
%411 = load float*, float** %410
%412 = getelementptr inbounds float, float* %411, i64 %361
%413 = load float, float* %412
%414 = getelementptr inbounds float, float* %9, i64 %408
store float %413, float* %414
%415 = add nuw nsw i64 %408, 1
%416 = add i64 %409, 1
%417 = icmp eq i64 %416, %371
br i1 %417, label %418, label %407
418: ; preds = %404, %407, %360
%419 = call i32 @svbksb(float** %12, float* %7, float** %13, i32 %364, i32 %364, float* %9, float* %8)
%420 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.14, i64 0, i64 0))
%421 = load i32, i32* %2
%422 = icmp slt i32 %421, 1
br i1 %422, label %433, label %423
423: ; preds = %418, %423
%424 = phi i64 [ %429, %423 ], [ 1, %418 ]
%425 = getelementptr inbounds float, float* %8, i64 %424
%426 = load float, float* %425
%427 = fpext float %426 to double
%428 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %427)
%429 = add nuw nsw i64 %424, 1
%430 = load i32, i32* %2
%431 = sext i32 %430 to i64
%432 = icmp slt i64 %424, %431
br i1 %432, label %423, label %433
433: ; preds = %423, %418
%434 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str.15, i64 0, i64 0))
%435 = load i32, i32* %2
%436 = icmp slt i32 %435, 1
br i1 %436, label %447, label %437
437: ; preds = %433, %437
%438 = phi i64 [ %443, %437 ], [ 1, %433 ]
%439 = getelementptr inbounds float, float* %9, i64 %438
%440 = load float, float* %439
%441 = fpext float %440 to double
%442 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %441)
%443 = add nuw nsw i64 %438, 1
%444 = load i32, i32* %2
%445 = sext i32 %444 to i64
%446 = icmp slt i64 %438, %445
br i1 %446, label %437, label %447
447: ; preds = %437, %433
%448 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.16, i64 0, i64 0))
%449 = load i32, i32* %2
%450 = icmp slt i32 %449, 1
br i1 %450, label %505, label %451
451: ; preds = %447
%452 = add nuw i32 %449, 1
%453 = zext i32 %452 to i64
%454 = add nsw i64 %453, -1
%455 = and i64 %454, 1
%456 = icmp eq i32 %452, 2
%457 = and i64 %454, -2
%458 = icmp eq i64 %455, 0
br label %460
459: ; preds = %492
br i1 %450, label %505, label %495
460: ; preds = %492, %451
%461 = phi i64 [ 1, %451 ], [ %493, %492 ]
%462 = getelementptr inbounds float, float* %9, i64 %461
store float 0.000000e+00, float* %462
%463 = getelementptr inbounds float*, float** %10, i64 %461
%464 = load float*, float** %463
br i1 %456, label %483, label %465
465: ; preds = %460, %465
%466 = phi float [ %479, %465 ], [ 0.000000e+00, %460 ]
%467 = phi i64 [ %480, %465 ], [ 1, %460 ]
%468 = phi i64 [ %481, %465 ], [ 0, %460 ]
%469 = getelementptr inbounds float, float* %464, i64 %467
%470 = load float, float* %469
%471 = getelementptr inbounds float, float* %8, i64 %467
%472 = load float, float* %471
%473 = call float @llvm.fmuladd.f32(float %470, float %472, float %466)
store float %473, float* %462
%474 = add nuw nsw i64 %467, 1
%475 = getelementptr inbounds float, float* %464, i64 %474
%476 = load float, float* %475
%477 = getelementptr inbounds float, float* %8, i64 %474
%478 = load float, float* %477
%479 = call float @llvm.fmuladd.f32(float %476, float %478, float %473)
store float %479, float* %462
%480 = add nuw nsw i64 %467, 2
%481 = add i64 %468, 2
%482 = icmp eq i64 %481, %457
br i1 %482, label %483, label %465
483: ; preds = %465, %460
%484 = phi float [ 0.000000e+00, %460 ], [ %479, %465 ]
%485 = phi i64 [ 1, %460 ], [ %480, %465 ]
br i1 %458, label %492, label %486
486: ; preds = %483
%487 = getelementptr inbounds float, float* %464, i64 %485
%488 = load float, float* %487
%489 = getelementptr inbounds float, float* %8, i64 %485
%490 = load float, float* %489
%491 = call float @llvm.fmuladd.f32(float %488, float %490, float %484)
store float %491, float* %462
br label %492
492: ; preds = %483, %486
%493 = add nuw nsw i64 %461, 1
%494 = icmp eq i64 %493, %453
br i1 %494, label %459, label %460
495: ; preds = %459, %495
%496 = phi i64 [ %501, %495 ], [ 1, %459 ]
%497 = getelementptr inbounds float, float* %9, i64 %496
%498 = load float, float* %497
%499 = fpext float %498 to double
%500 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %499)
%501 = add nuw nsw i64 %496, 1
%502 = load i32, i32* %2
%503 = sext i32 %502 to i64
%504 = icmp slt i64 %496, %503
br i1 %504, label %495, label %505
505: ; preds = %495, %447, %459
%506 = call i32 @putchar(i32 10)
%507 = add nuw nsw i64 %361, 1
%508 = load i32, i32* %1
%509 = sext i32 %508 to i64
%510 = icmp slt i64 %361, %509
br i1 %510, label %360, label %511
511: ; preds = %505, %348
%512 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str, i64 0, i64 0))
%513 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.13, i64 0, i64 0))
%514 = call i32 (...) @getchar()
%515 = call i32 @feof(i32* %14)
%516 = icmp eq i32 %515, 0
br i1 %516, label %21, label %517
517: ; preds = %511, %18
%518 = call i32 @fclose(i32* %14)
%519 = call i32 @free_matrix(float** %13, i32 1, i32 20, i32 1, i32 20)
%520 = call i32 @free_matrix(float** %12, i32 1, i32 20, i32 1, i32 20)
%521 = call i32 @free_matrix(float** %11, i32 1, i32 20, i32 1, i32 20)
%522 = call i32 @free_matrix(float** %10, i32 1, i32 20, i32 1, i32 20)
%523 = call i32 @free_vector(float* %9, i32 1, i32 20)
%524 = call i32 @free_vector(float* %8, i32 1, i32 20)
%525 = call i32 @free_vector(float* %7, i32 1, i32 20)
ret i32 0
}