#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*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ gaussj(float **, int, float **, int);
int /*<<< orphan*/ getchar();
float **matrix(int, int, int, int);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  int j, k, l, m, n;
  float **a, **ai, **u, **b, **x, **t;
  char dummy[80];
  FILE *fp;
  a = matrix(1, 20, 1, 20);
  ai = matrix(1, 20, 1, 20);
  u = matrix(1, 20, 1, 20);
  b = matrix(1, 20, 1, 20);
  x = matrix(1, 20, 1, 20);
  t = 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 (l = 1; l <= n; l++) {
      for (k = 1; k <= n; k++)
        ai[k][l] = a[k][l];
      for (k = 1; k <= m; k++)
        x[l][k] = b[l][k];
    }
    gaussj(ai, n, x, m);
    printf("\nInverse of matrix a : \n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++)
        printf("%12.6f", ai[k][l]);
      printf("\n");
    }
    printf("\na times a-inverse:\n");
    for (k = 1; k <= n; k++) {
      for (l = 1; l <= n; l++) {
        u[k][l] = 0.0;
        for (j = 1; j <= n; j++)
          u[k][l] += (a[k][j] * ai[j][l]);
      }
      for (l = 1; l <= n; l++)
        printf("%12.6f", u[k][l]);
      printf("\n");
    }
    printf("\nCheck the following for equality:\n");
    printf("%21s %14s\n", "original", "matrix*sol'n");
    for (l = 1; l <= m; l++) {
      printf("vector %2d: \n", l);
      for (k = 1; k <= n; k++) {
        t[k][l] = 0.0;
        for (j = 1; j <= n; j++)
          t[k][l] += (a[k][j] * x[j][l]);
        printf("%8s %12.6f %12.6f\n", " ", b[k][l], t[k][l]);
      }
    }
    printf("***********************************\n");
    printf("press RETURN for next problem:\n");
    (void)getchar();
  }
  fclose(fp);
  free_matrix(t, 1, 20, 1, 20);
  free_matrix(x, 1, 20, 1, 20);
  free_matrix(b, 1, 20, 1, 20);
  free_matrix(u, 1, 20, 1, 20);
  free_matrix(ai, 1, 20, 1, 20);
  free_matrix(a, 1, 20, 1, 20);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edx
mov    $0x14,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <matrix@plt>
mov    %rax,-0x48(%rbp)
lea    0xdad(%rip),%rdi
lea    0xdb1(%rip),%rsi
call   10d0 <fopen@plt>
mov    %rax,-0xa8(%rbp)
cmp    $0x0,%rax
jne    127c <main+0xcc>
lea    0xd96(%rip),%rdi
call   1040 <nrerror@plt>
jmp    1281 <main+0xd1>
mov    -0xa8(%rbp),%rdi
call   10b0 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    12a2 <main+0xf2>
jmp    17ff <main+0x64f>
lea    -0xa0(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0xa0(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
mov    -0xa8(%rbp),%rdi
lea    0xd4d(%rip),%rsi
lea    -0x18(%rbp),%rdx
lea    -0x14(%rbp),%rcx
mov    $0x0,%al
call   1080 <fscanf@plt>
lea    -0xa0(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     137a <main+0x1ca>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1367 <main+0x1b7>
mov    -0xa8(%rbp),%rdi
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xce2(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1321 <main+0x171>
jmp    136c <main+0x1bc>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    130e <main+0x15e>
lea    -0xa0(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1405 <main+0x255>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     13f2 <main+0x242>
mov    -0xa8(%rbp),%rdi
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xc57(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13ac <main+0x1fc>
jmp    13f7 <main+0x247>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1399 <main+0x1e9>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     14c1 <main+0x311>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1463 <main+0x2b3>
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    141f <main+0x26f>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14ae <main+0x2fe>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    146a <main+0x2ba>
jmp    14b3 <main+0x303>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    140c <main+0x25c>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    -0x14(%rbp),%ecx
call   1070 <gaussj@plt>
lea    0xb5d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1559 <main+0x3a9>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     153d <main+0x38d>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb29(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14fc <main+0x34c>
lea    0xb0b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14e9 <main+0x339>
lea    0xaf8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1689 <main+0x4d9>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1625 <main+0x475>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1612 <main+0x462>
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%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    15ac <main+0x3fc>
jmp    1617 <main+0x467>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1581 <main+0x3d1>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     166d <main+0x4bd>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9f9(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    162c <main+0x47c>
lea    0x9db(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    156e <main+0x3be>
lea    0x9dd(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x9f3(%rip),%rdi
lea    0x9f7(%rip),%rsi
lea    0x9f9(%rip),%rdx
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     17d7 <main+0x627>
mov    -0x10(%rbp),%esi
lea    0x9e2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     17c4 <main+0x614>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     176f <main+0x5bf>
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%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    1709 <main+0x559>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x918(%rip),%rdi
lea    0x883(%rip),%rsi
mov    $0x2,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16de <main+0x52e>
jmp    17c9 <main+0x619>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    16ba <main+0x50a>
lea    0x8f5(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x90c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10a0 <getchar@plt>
jmp    1281 <main+0xd1>
mov    -0xa8(%rbp),%rdi
call   1050 <fclose@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,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0x14,%ecx
call   10e0 <matrix@plt>
mov    %rax,0x40(%rsp)
lea    0xd6c(%rip),%rdi
lea    0xd70(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,%rbp
test   %rax,%rax
jne    12b4 <main+0xe4>
lea    0xd5e(%rip),%rdi
call   1060 <nrerror@plt>
mov    %rbp,%rdi
call   10d0 <feof@plt>
test   %eax,%eax
je     1392 <main+0x1c2>
mov    %rbp,%rdi
call   1070 <fclose@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
mov    %r15,%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    %r14,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0x14,%r8d
call   1050 <free_matrix@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,0x38(%rsp)
mov    %rbp,0x20(%rsp)
mov    %r14,0x10(%rsp)
jmp    13e9 <main+0x219>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0xd19(%rip),%rdi
call   1040 <puts@plt>
lea    0xd31(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   10c0 <getchar@plt>
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
call   10d0 <feof@plt>
test   %eax,%eax
mov    0x38(%rsp),%r15
jne    12c4 <main+0xf4>
lea    0x80(%rsp),%r15
mov    %r15,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10b0 <fgets@plt>
mov    %r15,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10b0 <fgets@plt>
mov    %rbp,%rdi
lea    0xc12(%rip),%rsi
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    %r15,%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10b0 <fgets@plt>
mov    0x8(%rsp),%eax
test   %eax,%eax
jle    14c0 <main+0x2f0>
mov    $0x1,%esi
jmp    145f <main+0x28f>
nop
movslq %eax,%rcx
lea    0x1(%rsi),%rdx
cmp    %rcx,%rsi
mov    %rdx,%rsi
jge    14c0 <main+0x2f0>
test   %eax,%eax
jle    1450 <main+0x280>
mov    $0x4,%ebp
xor    %r15d,%r15d
lea    0xbc2(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
mov    (%rax,%rsi,8),%rdx
add    %rbp,%rdx
mov    0x20(%rsp),%rdi
mov    %rsi,%r14
mov    %r12,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    %r14,%rsi
movslq 0x8(%rsp),%rax
add    $0x1,%r15
add    $0x4,%rbp
cmp    %rax,%r15
jl     1480 <main+0x2b0>
mov    0x10(%rsp),%r14
jmp    1450 <main+0x280>
nopw   0x0(%rax,%rax,1)
lea    0x80(%rsp),%rdi
mov    $0x50,%esi
mov    0x20(%rsp),%rdx
call   10b0 <fgets@plt>
mov    0xc(%rsp),%r11d
mov    0x8(%rsp),%esi
test   %r11d,%r11d
jle    1560 <main+0x390>
mov    $0x1,%edx
mov    0x18(%rsp),%r15
jmp    150f <main+0x33f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rax
movslq %r11d,%rcx
cmp    %rcx,%rdx
mov    %rax,%rdx
jge    1560 <main+0x390>
test   %esi,%esi
jle    1500 <main+0x330>
xor    %ebp,%ebp
lea    0xb18(%rip),%r12
nopl   0x0(%rax)
mov    %rdx,%r14
lea    0x0(,%rdx,4),%rdx
add    0x8(%r15,%rbp,8),%rdx
mov    0x20(%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    %r14,%rdx
movslq 0x8(%rsp),%rsi
add    $0x1,%rbp
cmp    %rsi,%rbp
jl     1520 <main+0x350>
mov    0xc(%rsp),%r11d
mov    0x10(%rsp),%r14
jmp    1500 <main+0x330>
nopl   0x0(%rax)
test   %esi,%esi
jle    1860 <main+0x690>
mov    %esi,%r12d
lea    0x1(%r12),%rax
mov    %rax,0x78(%rsp)
lea    0x1(%r11),%r15d
lea    -0x1(%r15),%rcx
lea    -0x1(%r12),%rax
mov    %rax,0x70(%rsp)
lea    -0x9(%r15),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %r12d,%eax
and    $0x3,%eax
and    $0xfffffffc,%r12d
mov    %rcx,0x30(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0x58(%rsp)
add    $0x1,%rcx
mov    %rcx,0x50(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rcx,0x28(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x48(%rsp)
mov    $0x1,%r9d
mov    %r11,0x68(%rsp)
jmp    15ef <main+0x41f>
nopl   0x0(%rax)
add    $0x1,%r9
cmp    0x78(%rsp),%r9
je     1860 <main+0x690>
mov    $0x1,%ebp
cmpq   $0x3,0x70(%rsp)
jb     1665 <main+0x495>
xor    %ebp,%ebp
xchg   %ax,%ax
mov    0x8(%r14,%rbp,8),%rcx
movss  (%rcx,%r9,4),%xmm0
mov    0x8(%rbx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r9,4)
mov    0x10(%r14,%rbp,8),%rcx
movss  (%rcx,%r9,4),%xmm0
mov    0x10(%rbx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r9,4)
mov    0x18(%r14,%rbp,8),%rcx
movss  (%rcx,%r9,4),%xmm0
mov    0x18(%rbx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r9,4)
mov    0x20(%r14,%rbp,8),%rcx
movss  (%rcx,%r9,4),%xmm0
mov    0x20(%rbx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r9,4)
add    $0x4,%rbp
cmp    %rbp,%r12
jne    1600 <main+0x430>
add    $0x1,%rbp
test   %rax,%rax
je     169d <main+0x4cd>
lea    (%rbx,%rbp,8),%rdx
lea    (%r14,%rbp,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbp,8),%rcx
movss  (%rcx,%r9,4),%xmm0
mov    (%rdx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r9,4)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1680 <main+0x4b0>
test   %r11d,%r11d
jle    15e0 <main+0x410>
mov    0x18(%rsp),%rcx
mov    (%rcx,%r9,8),%r10
mov    0x0(%r13,%r9,8),%r8
mov    $0x1,%ebp
cmpq   $0x8,0x30(%rsp)
jb     17d0 <main+0x600>
lea    0x4(%r8),%rcx
lea    (%r10,%r15,4),%rdx
cmp    %rdx,%rcx
jae    16e3 <main+0x513>
lea    (%r8,%r15,4),%rcx
lea    0x4(%r10),%rdx
cmp    %rcx,%rdx
jb     17d0 <main+0x600>
cmpq   $0x18,0x60(%rsp)
jae    16ef <main+0x51f>
xor    %ebp,%ebp
jmp    176a <main+0x59a>
mov    0x48(%rsp),%r11
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%r10,%rbp,4),%xmm0
movups 0x14(%r10,%rbp,4),%xmm1
movups %xmm0,0x4(%r8,%rbp,4)
movups %xmm1,0x14(%r8,%rbp,4)
movups 0x24(%r10,%rbp,4),%xmm0
movups 0x34(%r10,%rbp,4),%xmm1
movups %xmm0,0x24(%r8,%rbp,4)
movups %xmm1,0x34(%r8,%rbp,4)
movups 0x44(%r10,%rbp,4),%xmm0
movups 0x54(%r10,%rbp,4),%xmm1
movups %xmm0,0x44(%r8,%rbp,4)
movups %xmm1,0x54(%r8,%rbp,4)
movups 0x64(%r10,%rbp,4),%xmm0
movups 0x74(%r10,%rbp,4),%xmm1
movups %xmm0,0x64(%r8,%rbp,4)
movups %xmm1,0x74(%r8,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r11
jne    1700 <main+0x530>
cmpq   $0x0,0x28(%rsp)
mov    0x68(%rsp),%r11
je     17ac <main+0x5dc>
mov    0x28(%rsp),%rdx
nopl   0x0(%rax)
lea    0x0(,%rbp,4),%rcx
or     $0x4,%rcx
movups (%r10,%rcx,1),%xmm0
movups 0x10(%r10,%rcx,1),%xmm1
movups %xmm0,(%r8,%rcx,1)
movups %xmm1,0x10(%r8,%rcx,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rdx
jne    1780 <main+0x5b0>
mov    0x50(%rsp),%rbp
mov    0x58(%rsp),%rcx
cmp    %rcx,0x30(%rsp)
je     15e0 <main+0x410>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edx
sub    %ebp,%edx
mov    %rbp,%rdi
not    %rdi
add    %r15,%rdi
and    $0x3,%rdx
je     1806 <main+0x636>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r10,%rbp,4),%xmm0
movss  %xmm0,(%r8,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    17f0 <main+0x620>
cmp    $0x3,%rdi
jb     15e0 <main+0x410>
movss  (%r10,%rbp,4),%xmm0
movss  %xmm0,(%r8,%rbp,4)
movss  0x4(%r10,%rbp,4),%xmm0
movss  %xmm0,0x4(%r8,%rbp,4)
movss  0x8(%r10,%rbp,4),%xmm0
movss  %xmm0,0x8(%r8,%rbp,4)
movss  0xc(%r10,%rbp,4),%xmm0
movss  %xmm0,0xc(%r8,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r15
jne    1810 <main+0x640>
jmp    15e0 <main+0x410>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r13,%rdx
mov    %r11d,%ecx
call   1090 <gaussj@plt>
lea    0x80c(%rip),%rdi
call   1040 <puts@plt>
mov    0x8(%rsp),%eax
test   %eax,%eax
lea    0x7b1(%rip),%r12
jle    1900 <main+0x730>
mov    $0x1,%r15d
jmp    18bb <main+0x6eb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r15),%rcx
movslq 0x8(%rsp),%rax
cmp    %rax,%r15
mov    %rcx,%r15
jge    1900 <main+0x730>
test   %eax,%eax
jle    18a0 <main+0x6d0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%r15,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x8(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     18d0 <main+0x700>
jmp    18a0 <main+0x6d0>
nopl   0x0(%rax,%rax,1)
lea    0x792(%rip),%rdi
call   1040 <puts@plt>
mov    0x8(%rsp),%r8d
test   %r8d,%r8d
jle    1a70 <main+0x8a0>
mov    $0x1,%r12d
jmp    1950 <main+0x780>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r12),%rax
movslq 0x8(%rsp),%r8
cmp    %r8,%r12
mov    %rax,%r12
jge    1a70 <main+0x8a0>
test   %r8d,%r8d
mov    0x38(%rsp),%r14
jle    1930 <main+0x760>
mov    (%r14,%r12,8),%rcx
mov    %r8d,%r9d
lea    0x1(%r9),%r10
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rdi
mov    %r9d,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%ebp
jmp    198d <main+0x7bd>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %r10,%rbp
je     1a20 <main+0x850>
movl   $0x0,(%rcx,%rbp,4)
xorps  %xmm0,%xmm0
mov    $0x1,%eax
cmp    $0x2,%r10d
je     19f2 <main+0x822>
mov    $0x1,%eax
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm1
mov    (%rbx,%rax,8),%rsi
mulss  (%rsi,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
movss  0x4(%rdi,%rax,4),%xmm0
mov    0x8(%rbx,%rax,8),%rsi
mulss  (%rsi,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rcx,%rbp,4)
lea    (%rdx,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    19b0 <main+0x7e0>
test   $0x1,%r9b
je     1980 <main+0x7b0>
movss  (%rdi,%rax,4),%xmm1
mov    (%rbx,%rax,8),%rax
mulss  (%rax,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
jmp    1980 <main+0x7b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r8d,%r8d
lea    0x60e(%rip),%r15
jle    1930 <main+0x760>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%r12,8),%rax
movss  0x4(%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movslq 0x8(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1a40 <main+0x870>
jmp    1930 <main+0x760>
nopl   0x0(%rax,%rax,1)
lea    0x636(%rip),%rdi
call   1040 <puts@plt>
lea    0x5bc(%rip),%rdi
lea    0x5c0(%rip),%rsi
lea    0x5c2(%rip),%rdx
xor    %eax,%eax
call   1080 <printf@plt>
cmpl   $0x0,0xc(%rsp)
mov    0x10(%rsp),%r14
jle    13b0 <main+0x1e0>
mov    $0x1,%ebp
jmp    1ac5 <main+0x8f5>
nop
lea    0x1(%rbp),%rax
movslq 0xc(%rsp),%rcx
cmp    %rcx,%rbp
mov    %rax,%rbp
jge    13b0 <main+0x1e0>
lea    0x594(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x8(%rsp),%esi
test   %esi,%esi
jle    1ab0 <main+0x8e0>
mov    $0x1,%r12d
jmp    1b30 <main+0x960>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
mov    0x18(%rsp),%rax
mov    (%rax,%r12,8),%rax
movss  (%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0x55e(%rip),%rdi
lea    0x580(%rip),%rsi
mov    $0x2,%al
call   1080 <printf@plt>
lea    0x1(%r12),%rax
movslq 0x8(%rsp),%rsi
cmp    %rsi,%r12
mov    %rax,%r12
jge    1ab0 <main+0x8e0>
mov    0x40(%rsp),%rax
mov    (%rax,%r12,8),%rax
movl   $0x0,(%rax,%rbp,4)
test   %esi,%esi
jle    1af0 <main+0x920>
mov    (%r14,%r12,8),%rcx
mov    %esi,%r8d
cmp    $0x1,%esi
jne    1b60 <main+0x990>
mov    $0x1,%esi
xorps  %xmm1,%xmm1
jmp    1bc3 <main+0x9f3>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%esi
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
mov    0x0(%r13,%rsi,8),%rdx
mulss  (%rdx,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rbp,4)
movss  0x4(%rcx,%rsi,4),%xmm1
mov    0x8(%r13,%rsi,8),%rdx
mulss  (%rdx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbp,4)
lea    (%rdi,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
cmp    $0x1,%rdx
jne    1b80 <main+0x9b0>
test   $0x1,%r8b
je     1af3 <main+0x923>
movss  (%rcx,%rsi,4),%xmm0
mov    0x0(%r13,%rsi,8),%rcx
mulss  (%rcx,%rbp,4),%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbp,4)
jmp    1af3 <main+0x923>

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