#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*/ fprintf(int /*<<< orphan*/, 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*/ qrdcmp(float **, int, float *, float *, int *);
int /*<<< orphan*/ stderr;
float *vector(int, int);
int main(void) {
  int i, j, k, l, m, n, sing;
  float con, **a, *c, *d, **q, **qt, **r, **x;
  char dummy[80];
  FILE *fp;
  a = matrix(1, 20, 1, 20);
  c = vector(1, 20);
  d = vector(1, 20);
  q = matrix(1, 20, 1, 20);
  qt = matrix(1, 20, 1, 20);
  r = matrix(1, 20, 1, 20);
  x = 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 ", &x[k][l]);
    printf("Original matrix:\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++)
        printf("%12.6f", a[k][l]);
      printf("\n");
    }
    qrdcmp(a, n, c, d, &sing);
    if (sing)
      fprintf(stderr, "Singularity in QR decomposition.\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++) {
        if (l > k) {
          r[k][l] = a[k][l];
          q[k][l] = 0.0;
        } else if (l < k) {
          r[k][l] = q[k][l] = 0.0;
        } else {
          r[k][l] = d[k];
          q[k][l] = 1.0;
        }
      }
    }
    for (i = n - 1; i >= 1; i--) {
      for (con = 0.0, k = i; k <= n; k++)
        con += a[k][i] * a[k][i];
      con /= 2.0;
      for (k = i; k <= n; k++) {
        for (l = i; l <= n; l++) {
          qt[k][l] = 0.0;
          for (j = i; j <= n; j++) {
            qt[k][l] += q[j][l] * a[k][i] * a[j][i] / con;
          }
        }
      }
      for (k = i; k <= n; k++)
        for (l = i; l <= n; l++)
          q[k][l] -= qt[k][l];
    }
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++) {
        x[k][l] = 0.0;
        for (j = 1; j <= n; j++)
          x[k][l] += q[k][j] * r[j][l];
      }
    }
    printf("\nProduct of Q and R matrices:\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++)
        printf("%12.6f", x[k][l]);
      printf("\n");
    }
    printf("\nQ matrix of the decomposition:\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++)
        printf("%12.6f", q[k][l]);
      printf("\n");
    }
    printf("\nR matrix of the decomposition:\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++)
        printf("%12.6f", r[k][l]);
      printf("\n");
    }
    printf("\n***********************************\n");
    printf("press return for next problem:\n");
    (void)getchar();
  }
  fclose(fp);
  free_matrix(x, 1, 20, 1, 20);
  free_matrix(r, 1, 20, 1, 20);
  free_matrix(qt, 1, 20, 1, 20);
  free_matrix(q, 1, 20, 1, 20);
  free_vector(d, 1, 20);
  free_vector(c, 1, 20);
  free_matrix(a, 1, 20, 1, 20);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <matrix@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10e0 <vector@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10e0 <vector@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <matrix@plt>
mov    %rax,-0x48(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <matrix@plt>
mov    %rax,-0x50(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <matrix@plt>
mov    %rax,-0x58(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <matrix@plt>
mov    %rax,-0x60(%rbp)
lea    0xd7a(%rip),%rdi
lea    0xd7e(%rip),%rsi
call   1100 <fopen@plt>
mov    %rax,-0xb8(%rbp)
cmp    $0x0,%rax
jne    12bb <main+0xdb>
lea    0xd63(%rip),%rdi
call   1040 <nrerror@plt>
jmp    12c0 <main+0xe0>
mov    -0xb8(%rbp),%rdi
call   10c0 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    12e1 <main+0x101>
jmp    1aac <main+0x8cc>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
mov    -0xb8(%rbp),%rdi
lea    0xd1a(%rip),%rsi
lea    -0x1c(%rbp),%rdx
lea    -0x18(%rbp),%rcx
mov    $0x0,%al
call   1080 <fscanf@plt>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13b9 <main+0x1d9>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13a6 <main+0x1c6>
mov    -0xb8(%rbp),%rdi
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xcaf(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1360 <main+0x180>
jmp    13ab <main+0x1cb>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    134d <main+0x16d>
lea    -0xb0(%rbp),%rdi
mov    -0xb8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1444 <main+0x264>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1431 <main+0x251>
mov    -0xb8(%rbp),%rdi
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xc24(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13eb <main+0x20b>
jmp    1436 <main+0x256>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13d8 <main+0x1f8>
lea    0xbf9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14c9 <main+0x2e9>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14ad <main+0x2cd>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbbe(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    146c <main+0x28c>
lea    0xc50(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1459 <main+0x279>
mov    -0x30(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
lea    -0x20(%rbp),%r8
call   10f0 <qrdcmp@plt>
cmpl   $0x0,-0x20(%rbp)
je     1500 <main+0x320>
mov    0x2aee(%rip),%rax
mov    (%rax),%edi
lea    0xb62(%rip),%rsi
call   10b0 <fprintf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1624 <main+0x444>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1611 <main+0x431>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1579 <main+0x399>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    15fe <main+0x41e>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15ba <main+0x3da>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    15f9 <main+0x419>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  0xa14(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    15fe <main+0x41e>
jmp    1603 <main+0x423>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    151a <main+0x33a>
jmp    1616 <main+0x436>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1507 <main+0x327>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x8(%rbp)
cmpl   $0x1,-0x8(%rbp)
jl     1824 <main+0x644>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     169b <main+0x4bb>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1645 <main+0x465>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x954(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1799 <main+0x5b9>
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1786 <main+0x5a6>
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1773 <main+0x593>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16fb <main+0x51b>
jmp    1778 <main+0x598>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16d1 <main+0x4f1>
jmp    178b <main+0x5ab>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    16bf <main+0x4df>
mov    -0x8(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1811 <main+0x631>
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     17fe <main+0x61e>
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    17b1 <main+0x5d1>
jmp    1803 <main+0x623>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    179f <main+0x5bf>
jmp    1816 <main+0x636>
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
jmp    162d <main+0x44d>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     18f5 <main+0x715>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     18e2 <main+0x702>
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     18cf <main+0x6ef>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1869 <main+0x689>
jmp    18d4 <main+0x6f4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    183e <main+0x65e>
jmp    18e7 <main+0x707>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    182b <main+0x64b>
lea    0x783(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     197a <main+0x79a>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     195e <main+0x77e>
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x70d(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    191d <main+0x73d>
lea    0x79f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    190a <main+0x72a>
lea    0x71d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     19ff <main+0x81f>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     19e3 <main+0x803>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x688(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    19a2 <main+0x7c2>
lea    0x71a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    198f <main+0x7af>
lea    0x6b9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1a84 <main+0x8a4>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1a68 <main+0x888>
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x603(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1a27 <main+0x847>
lea    0x695(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1a14 <main+0x834>
lea    0x655(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x66d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10a0 <getchar@plt>
jmp    12c0 <main+0xe0>
mov    -0xb8(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x60(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x58(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x50(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x48(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@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    $0x118,%rsp
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10f0 <matrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x14,%esi
call   1100 <vector@plt>
mov    %rax,0x60(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
call   1100 <vector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10f0 <matrix@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10f0 <matrix@plt>
mov    %rax,0x48(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10f0 <matrix@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10f0 <matrix@plt>
mov    %rax,0x20(%rsp)
lea    0xd38(%rip),%rdi
lea    0xd3c(%rip),%rsi
call   1120 <fopen@plt>
mov    %rax,%r13
test   %rax,%rax
jne    12f0 <main+0xf0>
lea    0xd2a(%rip),%rdi
call   1060 <nrerror@plt>
mov    %r13,%rdi
call   10e0 <feof@plt>
test   %eax,%eax
je     13d9 <main+0x1d9>
mov    %r13,%rdi
call   1070 <fclose@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    0x48(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x88(%rsp)
lea    -0x8(%rbx),%rax
mov    %rax,0x80(%rsp)
lea    0xc41(%rip),%rbp
mov    %r12,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r13,0x50(%rsp)
jmp    144b <main+0x24b>
nopl   0x0(%rax)
lea    0xcc1(%rip),%rdi
call   1040 <puts@plt>
lea    0xcda(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   10c0 <getchar@plt>
mov    %r13,%rdi
call   10e0 <feof@plt>
test   %eax,%eax
lea    0xbfc(%rip),%rbp
mov    0x10(%rsp),%rbx
jne    1300 <main+0x100>
lea    0xc0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
mov    %rbx,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
mov    %r13,%rdi
lea    0xbb8(%rip),%rsi
lea    0x4(%rsp),%rdx
lea    0x1c(%rsp),%rcx
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    %rbx,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1510 <main+0x310>
mov    $0x1,%r15d
jmp    14bf <main+0x2bf>
xchg   %ax,%ax
movslq %eax,%rcx
lea    0x1(%r15),%rdx
cmp    %rcx,%r15
mov    %rdx,%r15
jge    1510 <main+0x310>
test   %eax,%eax
jle    14b0 <main+0x2b0>
mov    $0x4,%ebx
mov    %r12,%r13
mov    %rbp,%r12
xor    %ebp,%ebp
mov    0x0(%r13,%r15,8),%rdx
add    %rbx,%rdx
mov    0x50(%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
add    $0x4,%rbx
cmp    %rax,%rbp
jl     14d0 <main+0x2d0>
mov    %r12,%rbp
mov    %r13,%r12
mov    0x50(%rsp),%r13
jmp    14b0 <main+0x2b0>
cs nopw 0x0(%rax,%rax,1)
lea    0xc0(%rsp),%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
mov    0x1c(%rsp),%ecx
test   %ecx,%ecx
mov    0x20(%rsp),%r15
jle    15a0 <main+0x3a0>
mov    $0x1,%r12d
mov    0x4(%rsp),%eax
jmp    1550 <main+0x350>
xchg   %ax,%ax
lea    0x1(%r12),%rdx
movslq %ecx,%rsi
cmp    %rsi,%r12
mov    %rdx,%r12
jge    15a0 <main+0x3a0>
test   %eax,%eax
jle    1540 <main+0x340>
mov    %rbp,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    0x0(,%r12,4),%rdx
add    0x8(%r15,%rbp,8),%rdx
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1560 <main+0x360>
mov    0x1c(%rsp),%ecx
mov    %rbx,%rbp
jmp    1540 <main+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0xac2(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%esi
test   %esi,%esi
jle    1630 <main+0x430>
mov    $0x1,%ebx
lea    0xa80(%rip),%r15
mov    0x8(%rsp),%r12
jmp    15eb <main+0x3eb>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%rbx),%rax
movslq 0x4(%rsp),%rsi
cmp    %rsi,%rbx
mov    %rax,%rbx
jge    1635 <main+0x435>
test   %esi,%esi
jle    15d0 <main+0x3d0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1600 <main+0x400>
jmp    15d0 <main+0x3d0>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%r12
mov    %r12,%rdi
mov    0x60(%rsp),%rdx
mov    0x28(%rsp),%rcx
lea    0x5c(%rsp),%r8
call   1110 <qrdcmp@plt>
cmpl   $0x0,0x5c(%rsp)
je     1668 <main+0x468>
mov    0x2986(%rip),%rax
mov    (%rax),%edi
lea    0x9e4(%rip),%rsi
call   10d0 <fprintf@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
movss  0x98e(%rip),%xmm4
movss  0x982(%rip),%xmm3
mov    0x28(%rsp),%r9
jle    1c30 <main+0xa30>
mov    %rax,0x30(%rsp)
lea    0x1(%rax),%r15
mov    $0x1,%ecx
jmp    16a9 <main+0x4a9>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %r15,%rcx
je     1720 <main+0x520>
lea    (%r9,%rcx,4),%r8
lea    (%r14,%rcx,8),%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
mov    $0x1,%ebx
jmp    1705 <main+0x505>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rbx,4),%rax
add    (%r12,%rcx,8),%rax
xorps  %xmm1,%xmm1
movss  (%rax),%xmm0
mov    %rbp,%rsi
mov    %rdx,%rdi
movaps %xmm1,%xmm2
mov    (%rsi),%rax
movss  %xmm0,(%rax,%rbx,4)
mov    (%rdi),%rax
movss  %xmm2,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %r15,%rbx
je     16a0 <main+0x4a0>
cmp    %rcx,%rbx
ja     16d0 <main+0x4d0>
xorps  %xmm0,%xmm0
mov    %r8,%rax
movaps %xmm3,%xmm1
mov    %rdx,%rsi
mov    %rbp,%rdi
xorps  %xmm2,%xmm2
jae    16df <main+0x4df>
jmp    16ec <main+0x4ec>
mov    0x30(%rsp),%rbp
cmp    $0x2,%ebp
mov    0x48(%rsp),%r12
jl     1b40 <main+0x940>
lea    0x1(%rbp),%r13d
mov    $0x1,%eax
sub    %rbp,%rax
mov    %rax,0x68(%rsp)
mov    0x88(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
mov    0x80(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
lea    0xb(%rbp),%rax
mov    %rax,0x78(%rsp)
movq   $0xfffffffffffffffa,0x38(%rsp)
ff ff
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %rbp,%r11
jmp    17af <main+0x5af>
nopw   0x0(%rax,%rax,1)
addq   $0x1,0x40(%rsp)
addq   $0x1,0x68(%rsp)
add    $0xfffffffffffffff8,%rdi
addq   $0x1,0x38(%rsp)
add    $0xfffffffffffffff8,%rsi
addq   $0xffffffffffffffff,0x78(%rsp)
cmpq   $0x2,0xb8(%rsp)
jle    1b40 <main+0x940>
mov    %r11,0xb8(%rsp)
add    $0xffffffffffffffff,%r11
cmp    %rbp,%r11
jg     1780 <main+0x580>
mov    0x40(%rsp),%rax
lea    0x1(%rax),%ebx
add    $0x2,%eax
test   $0x3,%al
je     1801 <main+0x601>
mov    0x38(%rsp),%rax
and    $0x3,%eax
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rdi,%rcx,8),%rdx
movss  (%rdx,%r11,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %ecx,%eax
jne    17e0 <main+0x5e0>
sub    0x68(%rsp),%rcx
jmp    1807 <main+0x607>
xorps  %xmm0,%xmm0
mov    %r11,%rcx
mov    0x8(%rsp),%rbp
cmp    $0x3,%ebx
jb     1875 <main+0x675>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rcx,8),%rax
mov    0x8(%rbp,%rcx,8),%rdx
movss  (%rax,%r11,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rdx,%r11,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp,%rcx,8),%rax
movss  (%rax,%r11,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp,%rcx,8),%rax
movss  (%rax,%r11,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %ecx,%r15d
jne    1820 <main+0x620>
mulss  %xmm4,%xmm0
mov    0x30(%rsp),%rbp
cmp    %rbp,%r11
jg     1780 <main+0x580>
mov    0x38(%rsp),%rcx
shr    $0x3,%rcx
mov    0x40(%rsp),%rax
lea    -0x6(%rax),%rdx
add    $0x1,%rcx
mov    %rdx,0xb0(%rsp)
shr    $0x3,%rdx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x90(%rsp)
add    $0x1,%rdx
mov    %rdx,0xa8(%rsp)
lea    0x2(%rax),%r10
not    %rax
add    %rbp,%rax
mov    %rax,0x70(%rsp)
mov    %r11,%r8
mov    0x8(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    (%r12,%r8,8),%rax
mov    (%r9,%r8,8),%rbx
mov    %r11,%rdx
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rax,%rdx,4)
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rsi,%rcx,8),%rbp
movss  0x0(%rbp,%rdx,4),%xmm2
mulss  (%rbx,%r11,4),%xmm2
mov    (%rdi,%rcx,8),%rbp
mulss  0x0(%rbp,%r11,4),%xmm2
divss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  %xmm1,(%rax,%rdx,4)
add    $0x1,%rcx
cmp    %ecx,%r10d
jne    1900 <main+0x700>
add    $0x1,%rdx
cmp    %edx,%r13d
jne    18f0 <main+0x6f0>
add    $0x1,%r8
cmp    %r8d,%r13d
jne    18e0 <main+0x6e0>
mov    0x30(%rsp),%rbp
cmp    %rbp,%r11
mov    0x70(%rsp),%rbx
jg     1780 <main+0x580>
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0xa0(%rsp)
add    %r11,%rax
mov    %rax,0x98(%rsp)
mov    %r11,%r9
jmp    1992 <main+0x792>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
cmp    %r9d,%r13d
mov    0x48(%rsp),%r12
je     1780 <main+0x580>
mov    (%r12,%r9,8),%r8
mov    0x10(%rsp),%rax
mov    (%rax,%r9,8),%rcx
mov    %r11,%r12
cmp    $0x8,%r10
jb     1aa0 <main+0x8a0>
lea    (%rcx,%rbx,4),%rax
lea    (%r8,%rbp,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    19d5 <main+0x7d5>
lea    (%rcx,%rbp,4),%rax
add    $0x4,%rax
lea    (%r8,%rbx,4),%rdx
mov    %r11,%r12
cmp    %rax,%rdx
jb     1aa0 <main+0x8a0>
cmpq   $0x8,0xb0(%rsp)
jae    19e4 <main+0x7e4>
xor    %ebx,%ebx
jmp    1a53 <main+0x853>
mov    0x78(%rsp),%rdx
lea    (%rcx,%rdx,4),%rax
lea    (%r8,%rdx,4),%r12
mov    0x90(%rsp),%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%r12,%rbx,4),%xmm0
movups -0x20(%r12,%rbx,4),%xmm1
movups -0x30(%rax,%rbx,4),%xmm2
subps  %xmm0,%xmm2
movups -0x20(%rax,%rbx,4),%xmm0
subps  %xmm1,%xmm0
movups -0x10(%rax,%rbx,4),%xmm1
movups (%rax,%rbx,4),%xmm3
movups %xmm2,-0x30(%rax,%rbx,4)
movups %xmm0,-0x20(%rax,%rbx,4)
movups -0x10(%r12,%rbx,4),%xmm0
subps  %xmm0,%xmm1
movups (%r12,%rbx,4),%xmm0
subps  %xmm0,%xmm3
movups %xmm1,-0x10(%rax,%rbx,4)
movups %xmm3,(%rax,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1a00 <main+0x800>
testb  $0x1,0xa8(%rsp)
01
je     1a83 <main+0x883>
add    %r11,%rbx
movups (%r8,%rbx,4),%xmm0
movups 0x10(%r8,%rbx,4),%xmm1
movups (%rcx,%rbx,4),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%rcx,%rbx,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,(%rcx,%rbx,4)
movups %xmm0,0x10(%rcx,%rbx,4)
mov    0x98(%rsp),%r12
cmp    0xa0(%rsp),%r10
mov    0x70(%rsp),%rbx
je     1980 <main+0x780>
xchg   %ax,%ax
mov    %r13d,%edx
sub    %r12d,%edx
mov    %ebp,%eax
sub    %r12d,%eax
and    $0x3,%edx
je     1acb <main+0x8cb>
movss  (%rcx,%r12,4),%xmm0
subss  (%r8,%r12,4),%xmm0
movss  %xmm0,(%rcx,%r12,4)
add    $0x1,%r12
add    $0xffffffff,%edx
jne    1ab0 <main+0x8b0>
cmp    $0x3,%eax
jb     1980 <main+0x780>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%r12,4),%xmm0
subss  (%r8,%r12,4),%xmm0
movss  0x4(%rcx,%r12,4),%xmm1
movss  %xmm0,(%rcx,%r12,4)
subss  0x4(%r8,%r12,4),%xmm1
movss  %xmm1,0x4(%rcx,%r12,4)
movss  0x8(%rcx,%r12,4),%xmm0
subss  0x8(%r8,%r12,4),%xmm0
movss  %xmm0,0x8(%rcx,%r12,4)
movss  0xc(%rcx,%r12,4),%xmm0
subss  0xc(%r8,%r12,4),%xmm0
movss  %xmm0,0xc(%rcx,%r12,4)
add    $0x4,%r12
cmp    %r12d,%r15d
jne    1ae0 <main+0x8e0>
jmp    1980 <main+0x780>
nop
test   %ebp,%ebp
mov    0x8(%rsp),%r12
jle    1c30 <main+0xa30>
lea    -0x1(%r15),%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%r8d
jmp    1b7d <main+0x97d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
cmp    %r15,%r8
je     1c30 <main+0xa30>
mov    0x20(%rsp),%rax
mov    (%rax,%r8,8),%rdi
mov    0x10(%rsp),%rax
mov    (%rax,%r8,8),%rsi
mov    $0x1,%ebx
jmp    1ba9 <main+0x9a9>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r15,%rbx
je     1b70 <main+0x970>
movl   $0x0,(%rdi,%rbx,4)
mov    $0x1,%eax
xorps  %xmm0,%xmm0
cmp    $0x2,%r15d
je     1c04 <main+0xa04>
xchg   %ax,%ax
movss  (%rsi,%rax,4),%xmm1
mov    (%r14,%rax,8),%rbp
mulss  0x0(%rbp,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
movss  0x4(%rsi,%rax,4),%xmm0
mov    0x8(%r14,%rax,8),%rbp
mulss  0x0(%rbp,%rbx,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rbx,4)
lea    (%rdx,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
cmp    $0x1,%rbp
jne    1bc0 <main+0x9c0>
test   $0x1,%cl
je     1ba0 <main+0x9a0>
movss  (%rsi,%rax,4),%xmm1
mov    (%r14,%rax,8),%rax
mulss  (%rax,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
jmp    1ba0 <main+0x9a0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x443(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1cb0 <main+0xab0>
mov    $0x1,%ebx
jmp    1c6b <main+0xa6b>
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%rbx),%rcx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
mov    %rcx,%rbx
jge    1cb0 <main+0xab0>
test   %eax,%eax
mov    0x20(%rsp),%r13
lea    0x3c7(%rip),%r15
jle    1c50 <main+0xa50>
xor    %ebp,%ebp
nopl   (%rax)
mov    0x0(%r13,%rbx,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1c80 <main+0xa80>
jmp    1c50 <main+0xa50>
nopl   0x0(%rax)
lea    0x3e1(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1d30 <main+0xb30>
mov    $0x1,%ebx
jmp    1ceb <main+0xaeb>
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%rbx),%rcx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
mov    %rcx,%rbx
jge    1d30 <main+0xb30>
test   %eax,%eax
lea    0x34c(%rip),%r15
mov    0x10(%rsp),%r13
jle    1cd0 <main+0xad0>
xor    %ebp,%ebp
nopl   (%rax)
mov    0x0(%r13,%rbx,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1d00 <main+0xb00>
jmp    1cd0 <main+0xad0>
nopl   0x0(%rax)
lea    0x381(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
mov    0x50(%rsp),%r13
jle    1410 <main+0x210>
mov    $0x1,%ebx
jmp    1d7f <main+0xb7f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%rbx),%rcx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
mov    %rcx,%rbx
jge    1410 <main+0x210>
test   %eax,%eax
lea    0x2b8(%rip),%r15
jle    1d60 <main+0xb60>
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r14,%rbx,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x4(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1d90 <main+0xb90>
jmp    1d60 <main+0xb60>

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