#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
float fabs(float);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ print1(float *, int);
int /*<<< orphan*/ print2(float **, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, ...);
int main(void) {
  int n, i, j, k;
  printf("Enter the number of simultaneous equations in the system: ");
  scanf("%d", &n);
  float *a[n], *d[n], *l[n], *u[n], *x, *b, *mat[n], *inv[n], *t, temp, err,
      ratio;
  for (i = 0; i < n; i++) {
    a[i] = (float *)calloc(n, sizeof(float));
    d[i] = (float *)calloc(n, sizeof(float));
    l[i] = (float *)calloc(n, sizeof(float));
    u[i] = (float *)calloc(n, sizeof(float));
    inv[i] = (float *)calloc(n, sizeof(float));
    mat[i] = (float *)calloc(2 * n, sizeof(float));
  }
  x = (float *)calloc(n, sizeof(float));
  b = (float *)calloc(n, sizeof(float));
  t = (float *)calloc(n, sizeof(float));
  printf("Enter the augmented matrix:\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      scanf("%f", &a[i][j]);
    scanf("%f", &b[i]);
  }
  printf("A Matrix:\n");
  print2(a, n);
  printf("B Matrix:\n");
  print1(b, n);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (i > j)
        l[i][j] = a[i][j];
      else if (i == j)
        d[i][j] = a[i][j];
      else
        u[i][j] = a[i][j];
      mat[i][j] = l[i][j] + d[i][j];
    }
  }
  printf("L Matrix:\n");
  print2(l, n);
  printf("U Matrix:\n");
  print2(u, n);
  printf("D Matrix:\n");
  print2(d, n);
  printf("L+D Matrix:\n");
  print2(mat, n);
  for (i = 0; i < n; i++) {
    for (j = n; j < 2 * n; j++) {
      if (j - n == i)
        mat[i][j] = 1;
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (i != j) {
        ratio = mat[j][i] / mat[i][i];
        for (k = 0; k < 2 * n; k++) {
          mat[j][k] -= ratio * mat[i][k];
        }
      } else {
        ratio = mat[i][i];
        for (k = 0; k < 2 * n; k++)
          mat[i][k] /= ratio;
      }
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      inv[i][j] = mat[i][j + n];
  }
  printf("(L+D)-1 Matrix:\n");
  print2(inv, n);
  for (i = 0; i < n; i++) {
    free(mat[i]);
    mat[i] = (float *)calloc(n, sizeof(float));
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      t[i] += inv[i][j] * b[j];
  printf("D^(-1)*B Matrix:\n");
  print1(t, n);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      for (k = 0; k < n; k++)
        mat[i][j] += inv[i][k] * u[k][j];
    }
  }
  printf("((L+D)^-1)*U Matrix:\n");
  print2(mat, n);
  do {
    printf("X Matrix:\n");
    print1(x, n);
    err = 0;
    for (i = 0; i < n; i++) {
      temp = t[i];
      for (j = 0; j < n; j++)
        temp -= mat[i][j] * x[j];
      if (fabs(temp - x[i]) > err)
        err = fabs(temp - x[i]);
      x[i] = temp;
    }
  } while (err >= 0.0000005);
  printf("\nSolution of the given system:\n");
  print1(x, n);
  free(x);
  free(b);
  free(t);
  for (i = 0; i < n; i++) {
    free(a[i]);
    free(l[i]);
    free(u[i]);
    free(d[i]);
    free(mat[i]);
    free(inv[i]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe83(%rip),%rdi
call   1040 <printf@plt>
lea    0xeb2(%rip),%rdi
xor    %eax,%eax
lea    -0x8(%rbp),%rsi
call   1080 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x88(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1351 <main+0x1e1>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0xa8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0xa0(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x98(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x90(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x80(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
shl    $0x1,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    127d <main+0x10d>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x68(%rbp)
lea    0xcbf(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1417 <main+0x2a7>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ec <main+0x27c>
mov    -0xa8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xc90(%rip),%rdi
mov    $0x0,%al
call   1080 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13aa <main+0x23a>
mov    -0x50(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xc65(%rip),%rdi
mov    $0x0,%al
call   1080 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1397 <main+0x227>
lea    0xc4c(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
lea    0xc6c(%rip),%rdi
call   1040 <printf@plt>
mov    -0x50(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1060 <print1@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1590 <main+0x420>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    157d <main+0x40d>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    14b1 <main+0x341>
mov    -0x98(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1527 <main+0x3b7>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    14f2 <main+0x382>
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1522 <main+0x3b2>
mov    -0x90(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1527 <main+0x3b7>
mov    -0x88(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    -0x98(%rbp),%rdx
movslq -0xc(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq -0x10(%rbp),%rsi
movss  (%rdx,%rsi,4),%xmm0
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
addss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1464 <main+0x2f4>
jmp    1582 <main+0x412>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1451 <main+0x2e1>
lea    0xade(%rip),%rdi
call   1040 <printf@plt>
mov    -0x98(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
lea    0xb09(%rip),%rdi
call   1040 <printf@plt>
mov    -0x90(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
lea    0xab5(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
lea    0xa98(%rip),%rdi
call   1040 <printf@plt>
mov    -0x88(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    167b <main+0x50b>
mov    -0x8(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1668 <main+0x4f8>
mov    -0x10(%rbp),%eax
sub    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1655 <main+0x4e5>
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  0x9b8(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    165a <main+0x4ea>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1615 <main+0x4a5>
jmp    166d <main+0x4fd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1603 <main+0x493>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17e3 <main+0x673>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17d0 <main+0x660>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     174f <main+0x5df>
mov    -0x88(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movslq -0xc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    174a <main+0x5da>
mov    -0x88(%rbp),%rax
movss  -0x74(%rbp),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movslq -0x14(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16e2 <main+0x572>
jmp    17bd <main+0x64d>
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    17b8 <main+0x648>
mov    -0x88(%rbp),%rax
movss  -0x74(%rbp),%xmm1
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1773 <main+0x603>
jmp    17bd <main+0x64d>
jmp    17c2 <main+0x652>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1695 <main+0x525>
jmp    17d5 <main+0x665>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1682 <main+0x512>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    185c <main+0x6ec>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1849 <main+0x6d9>
mov    -0x80(%rbp),%rax
mov    -0x88(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x10(%rbp),%edx
add    -0x8(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    17fd <main+0x68d>
jmp    184e <main+0x6de>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    17ea <main+0x67a>
lea    0x82a(%rip),%rdi
call   1040 <printf@plt>
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18c8 <main+0x758>
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    187b <main+0x70b>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    194b <main+0x7db>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1938 <main+0x7c8>
mov    -0x80(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    18e2 <main+0x772>
jmp    193d <main+0x7cd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18cf <main+0x75f>
lea    0x74c(%rip),%rdi
call   1040 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1060 <print1@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a22 <main+0x8b2>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a0f <main+0x89f>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19fc <main+0x88c>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x80(%rbp),%rdx
movslq -0xc(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq -0x14(%rbp),%rsi
movss  (%rdx,%rsi,4),%xmm0
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
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    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1990 <main+0x820>
jmp    1a01 <main+0x891>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    197d <main+0x80d>
jmp    1a14 <main+0x8a4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    196a <main+0x7fa>
lea    0x687(%rip),%rdi
call   1040 <printf@plt>
mov    -0x88(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1090 <print2@plt>
lea    0x682(%rip),%rdi
call   1040 <printf@plt>
mov    -0x48(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1060 <print1@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b44 <main+0x9d4>
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1ae7 <main+0x977>
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x6c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1a89 <main+0x919>
movss  -0x6c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1070 <fabs@plt>
ucomiss -0x70(%rbp),%xmm0
jbe    1b24 <main+0x9b4>
movss  -0x6c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1070 <fabs@plt>
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1a64 <main+0x8f4>
jmp    1b49 <main+0x9d9>
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4a6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jae    1a3d <main+0x8cd>
lea    0x566(%rip),%rdi
call   1040 <printf@plt>
mov    -0x48(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1060 <print1@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c2d <main+0xabd>
mov    -0xa8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1b9e <main+0xa2e>
movl   $0x0,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
lea    0xe9d(%rip),%rdi
call   1050 <printf@plt>
lea    0xecc(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    %rsp,-0xa0(%rbp)
mov    -0x2c(%rbp),%eax
mov    %rsp,%rcx
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,%rbx
mov    %rcx,%rsp
mov    -0x2c(%rbp),%edi
mov    %rsp,%rcx
lea    0xf(,%rdi,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,%r15
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,%r12
mov    %rcx,%rsp
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
test   %edi,%edi
jle    129b <main+0x12b>
xor    %r14d,%r14d
nopl   0x0(%rax)
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,(%rbx,%r14,8)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,(%r15,%r14,8)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,(%r12,%r14,8)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,0x0(%r13,%r14,8)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    -0x60(%rbp),%rcx
mov    %rax,(%rcx,%r14,8)
mov    -0x2c(%rbp),%edi
add    %edi,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    -0x38(%rbp),%rcx
mov    %rax,(%rcx,%r14,8)
add    $0x1,%r14
movslq -0x2c(%rbp),%rdi
cmp    %rdi,%r14
jl     1220 <main+0xb0>
mov    %r13,-0x98(%rbp)
mov    %r12,-0x68(%rbp)
mov    %r15,-0x90(%rbp)
mov    %rbx,-0x58(%rbp)
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%r15
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x48(%rbp)
lea    0xd82(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    1369 <main+0x1f9>
lea    0xd6c(%rip),%r14
xor    %edx,%edx
mov    -0x58(%rbp),%r13
jmp    1333 <main+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x50(%rbp),%rax
lea    (%rax,%rdx,4),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    -0x40(%rbp),%rdx
add    $0x1,%rdx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rdx
jge    1369 <main+0x1f9>
test   %eax,%eax
mov    %rdx,-0x40(%rbp)
jle    1310 <main+0x1a0>
xor    %ebx,%ebx
xor    %r12d,%r12d
mov    0x0(%r13,%rdx,8),%rsi
add    %rbx,%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    -0x40(%rbp),%rdx
add    $0x1,%r12
movslq -0x2c(%rbp),%rax
add    $0x4,%rbx
cmp    %rax,%r12
jl     1340 <main+0x1d0>
jmp    1310 <main+0x1a0>
lea    0xd15(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    -0x58(%rbp),%r14
mov    %r14,%rdi
call   1090 <print2@plt>
lea    0xd31(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    -0x50(%rbp),%rdi
call   1070 <print1@plt>
mov    -0x2c(%rbp),%r8d
test   %r8d,%r8d
mov    -0x90(%rbp),%r12
mov    -0x98(%rbp),%r13
jle    1441 <main+0x2d1>
xor    %ecx,%ecx
jmp    13c9 <main+0x259>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r8,%rcx
je     1441 <main+0x2d1>
mov    -0x68(%rbp),%rax
mov    (%rax,%rcx,8),%rdx
mov    (%r12,%rcx,8),%rsi
mov    -0x38(%rbp),%rax
mov    (%rax,%rcx,8),%rdi
xor    %ebx,%ebx
jmp    1416 <main+0x2a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rcx,8),%rax
movss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rdx,%rbx,4)
movss  (%rdx,%rbx,4),%xmm0
addss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r8
je     13c0 <main+0x250>
cmp    %rbx,%rcx
ja     13f0 <main+0x280>
mov    (%r14,%rcx,8),%rax
jne    1430 <main+0x2c0>
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
jmp    13fe <main+0x28e>
nopl   (%rax)
movss  (%rax,%rbx,4),%xmm0
mov    0x0(%r13,%rcx,8),%rax
movss  %xmm0,(%rax,%rbx,4)
jmp    13fe <main+0x28e>
lea    0xc47(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    -0x68(%rbp),%rdi
call   1090 <print2@plt>
lea    0xc71(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %r13,%rdi
call   1090 <print2@plt>
lea    0xc24(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %r12,%rdi
call   1090 <print2@plt>
lea    0xc0b(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    -0x38(%rbp),%rdi
call   1090 <print2@plt>
mov    -0x2c(%rbp),%r14d
test   %r14d,%r14d
jle    1a3c <main+0x8cc>
lea    (%r14,%r14,1),%r11d
movslq %r11d,%rdx
mov    %r14,%r9
not    %r9
lea    0x1(%r14),%r8
mov    %rdx,%r10
neg    %r10
xor    %esi,%esi
mov    %r14,%rax
jmp    14dd <main+0x36d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x1,%rax
cmp    %r14,%rsi
je     154e <main+0x3de>
cmp    %r11d,%r14d
jge    14d0 <main+0x360>
mov    %r14,%rdi
test   $0x1,%r14b
je     14f3 <main+0x383>
mov    %r8,%rdi
test   %rsi,%rsi
je     1534 <main+0x3c4>
cmp    %r10,%r9
je     14d0 <main+0x360>
lea    -0x1(%rax),%rcx
jmp    1509 <main+0x399>
xchg   %ax,%ax
add    $0x2,%rdi
cmp    %rdi,%rdx
je     14d0 <main+0x360>
cmp    %rdi,%rax
jne    151d <main+0x3ad>
mov    -0x38(%rbp),%rbx
mov    (%rbx,%rsi,8),%rbx
movl   $0x3f800000,(%rbx,%rdi,4)
cmp    %rdi,%rcx
jne    1500 <main+0x390>
mov    -0x38(%rbp),%rbx
mov    (%rbx,%rsi,8),%rbx
movl   $0x3f800000,0x4(%rbx,%rdi,4)
3f
jmp    1500 <main+0x390>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rsi,8),%rcx
movl   $0x3f800000,(%rcx,%r14,4)
3f
mov    %r8,%rdi
cmp    %r10,%r9
jne    14f8 <main+0x388>
jmp    14d0 <main+0x360>
test   %r14d,%r14d
jle    1a3c <main+0x8cc>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
lea    (%r14,%r14,1),%eax
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
mov    %edx,%eax
and    $0x7ffffff8,%eax
mov    %rax,-0x80(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x78(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %edx,%ecx
and    $0x7ffffffc,%ecx
lea    -0x4(%rcx),%rbx
mov    %rbx,-0x40(%rbp)
shr    $0x2,%rbx
add    $0x1,%rbx
lea    0x2(%rsi),%rdi
mov    %rax,%rsi
mov    %rax,-0x70(%rbp)
and    %rax,%rdi
mov    %rdi,-0xa8(%rbp)
mov    %rdx,%r8
neg    %r8
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x88(%rbp)
xor    %r9d,%r9d
movaps 0xa2a(%rip),%xmm0
jmp    15ed <main+0x47d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    %r14,%r9
je     1849 <main+0x6d9>
xor    %r10d,%r10d
jmp    1609 <main+0x499>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
cmp    %r14,%r10
je     15e0 <main+0x470>
cmp    %r10,%r9
jne    1630 <main+0x4c0>
mov    -0x38(%rbp),%rax
mov    (%rax,%r9,8),%rsi
movss  (%rsi,%r9,4),%xmm1
cmp    $0x4,%edx
jae    16e0 <main+0x570>
xor    %eax,%eax
jmp    1740 <main+0x5d0>
nopl   0x0(%rax)
mov    -0x38(%rbp),%rax
mov    (%rax,%r10,8),%r12
mov    (%rax,%r9,8),%r11
movss  (%r12,%r9,4),%xmm1
xorps  %xmm0,%xmm1
divss  (%r11,%r9,4),%xmm1
cmp    $0x8,%edx
jb     166a <main+0x4fa>
lea    (%r11,%rdx,4),%rax
cmp    %rax,%r12
jae    175c <main+0x5ec>
lea    (%r12,%rdx,4),%rax
cmp    %rax,%r11
jae    175c <main+0x5ec>
xor    %esi,%esi
mov    %rsi,%rax
test   $0x1,%dl
je     1691 <main+0x521>
movss  (%r11,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%r12,%rsi,4),%xmm2
movss  %xmm2,(%r12,%rsi,4)
mov    %rsi,%rax
or     $0x1,%rax
not    %rsi
cmp    %r8,%rsi
je     1600 <main+0x490>
nopl   (%rax)
movss  (%r11,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%r12,%rax,4),%xmm2
movss  %xmm2,(%r12,%rax,4)
movss  0x4(%r11,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%r12,%rax,4),%xmm2
movss  %xmm2,0x4(%r12,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdx
jne    16a0 <main+0x530>
jmp    1600 <main+0x490>
nopl   (%rax)
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
cmpq   $0x0,-0x40(%rbp)
je     182f <main+0x6bf>
mov    -0x88(%rbp),%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm3
movups 0x10(%rsi,%rax,4),%xmm4
divps  %xmm2,%xmm3
movups %xmm3,(%rsi,%rax,4)
divps  %xmm2,%xmm4
movups %xmm4,0x10(%rsi,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1700 <main+0x590>
test   $0x1,%bl
je     1732 <main+0x5c2>
movups (%rsi,%rax,4),%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%rsi,%rax,4)
mov    %rcx,%rax
cmp    %rdx,%rcx
je     1600 <main+0x490>
xchg   %ax,%ax
movss  (%rsi,%rax,4),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1740 <main+0x5d0>
jmp    1600 <main+0x490>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
cmpq   $0x0,-0x78(%rbp)
je     183f <main+0x6cf>
mov    -0xa8(%rbp),%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r11,%rsi,4),%xmm3
movups 0x10(%r11,%rsi,4),%xmm4
mulps  %xmm2,%xmm3
movups (%r12,%rsi,4),%xmm5
addps  %xmm3,%xmm5
movups 0x10(%r12,%rsi,4),%xmm3
movups 0x20(%r12,%rsi,4),%xmm6
movups 0x30(%r12,%rsi,4),%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm5,(%r12,%rsi,4)
movups %xmm4,0x10(%r12,%rsi,4)
movups 0x20(%r11,%rsi,4),%xmm3
movups 0x30(%r11,%rsi,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm6,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movups %xmm3,0x20(%r12,%rsi,4)
movups %xmm4,0x30(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rax
jne    1780 <main+0x610>
testb  $0x1,-0x70(%rbp)
je     181a <main+0x6aa>
movups (%r11,%rsi,4),%xmm3
movups 0x10(%r11,%rsi,4),%xmm4
movups (%r12,%rsi,4),%xmm5
movups 0x10(%r12,%rsi,4),%xmm6
mulps  %xmm2,%xmm3
addps  %xmm5,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movups %xmm3,(%r12,%rsi,4)
movups %xmm4,0x10(%r12,%rsi,4)
mov    -0x80(%rbp),%rax
mov    %rax,%rsi
cmp    %rdx,%rax
je     1600 <main+0x490>
jmp    166c <main+0x4fc>
xor    %eax,%eax
test   $0x1,%bl
jne    1727 <main+0x5b7>
jmp    1732 <main+0x5c2>
xor    %esi,%esi
testb  $0x1,-0x70(%rbp)
jne    17ed <main+0x67d>
jmp    181a <main+0x6aa>
test   %r14d,%r14d
jle    1a3c <main+0x8cc>
lea    (%r14,%r14,1),%rax
mov    %rax,-0x40(%rbp)
mov    %r14d,%eax
and    $0xfffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x88(%rbp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r14d,%r11d
and    $0xfffffff8,%r11d
mov    %ecx,%edx
and    $0x3,%edx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,-0x78(%rbp)
mov    %r14d,%r12d
and    $0x3,%r12d
lea    0x1c(%r14),%rax
mov    %rax,-0x70(%rbp)
mov    %rdx,-0x80(%rbp)
shl    $0x5,%rdx
lea    0x3(%r14),%rbx
xor    %r10d,%r10d
jmp    18cd <main+0x75d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
cmp    %r14,%r10
je     1a3c <main+0x8cc>
mov    -0x38(%rbp),%rax
mov    (%rax,%r10,8),%r9
mov    -0x60(%rbp),%rax
mov    (%rax,%r10,8),%r8
cmp    $0x8,%r14d
jb     18f9 <main+0x789>
mov    -0x40(%rbp),%rax
lea    (%r9,%rax,4),%rax
cmp    %rax,%r8
jae    1970 <main+0x800>
cmp    %r8,%r9
jae    1970 <main+0x800>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
test   %r12,%r12
je     1925 <main+0x7b5>
lea    (%r9,%r14,4),%rdi
mov    %r12,%rsi
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1910 <main+0x7a0>
cmp    $0x3,%rcx
jb     18c0 <main+0x750>
lea    (%r9,%rbx,4),%rcx
nop
movss  -0xc(%rcx,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
movss  -0x8(%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r8,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r8,%rax,4)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%r8,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    1930 <main+0x7c0>
jmp    18c0 <main+0x750>
cmpq   $0x18,-0x88(%rbp)
18
jae    197e <main+0x80e>
xor    %eax,%eax
jmp    19f0 <main+0x880>
mov    -0x70(%rbp),%rax
lea    (%r9,%rax,4),%rdi
mov    -0x78(%rbp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups -0x70(%rdi,%rax,4),%xmm0
movups -0x60(%rdi,%rax,4),%xmm1
movups %xmm0,(%r8,%rax,4)
movups %xmm1,0x10(%r8,%rax,4)
movups -0x50(%rdi,%rax,4),%xmm0
movups -0x40(%rdi,%rax,4),%xmm1
movups %xmm0,0x20(%r8,%rax,4)
movups %xmm1,0x30(%r8,%rax,4)
movups -0x30(%rdi,%rax,4),%xmm0
movups -0x20(%rdi,%rax,4),%xmm1
movups %xmm0,0x40(%r8,%rax,4)
movups %xmm1,0x50(%r8,%rax,4)
movups -0x10(%rdi,%rax,4),%xmm0
movups (%rdi,%rax,4),%xmm1
movups %xmm0,0x60(%r8,%rax,4)
movups %xmm1,0x70(%r8,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1990 <main+0x820>
cmpq   $0x0,-0x80(%rbp)
je     1a2b <main+0x8bb>
lea    (%r8,%rax,4),%rcx
add    $0x10,%rcx
add    %r14,%rax
lea    (%r9,%rax,4),%rax
add    $0x10,%rax
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1a10 <main+0x8a0>
mov    %r11,%rax
cmp    %r14,%r11
je     18c0 <main+0x750>
jmp    18fb <main+0x78b>
lea    0x662(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    -0x60(%rbp),%r12
mov    %r12,%rdi
call   1090 <print2@plt>
cmpl   $0x0,-0x2c(%rbp)
mov    -0x38(%rbp),%r14
mov    -0x48(%rbp),%rax
jle    1b2c <main+0x9bc>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1a70 <main+0x900>
mov    %eax,%r8d
test   %r8d,%r8d
mov    -0x50(%rbp),%rbx
mov    -0x48(%rbp),%rax
jle    1b2c <main+0x9bc>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
xor    %edx,%edx
jmp    1ac9 <main+0x959>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
cmp    %r8,%rdx
je     1b2c <main+0x9bc>
mov    (%r12,%rdx,8),%rsi
movss  (%rax,%rdx,4),%xmm0
xor    %edi,%edi
cmp    $0x1,%r8d
je     1b11 <main+0x9a1>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rdi,4),%xmm1
mulss  (%rbx,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
movss  0x4(%rsi,%rdi,4),%xmm0
mulss  0x4(%rbx,%rdi,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1ae0 <main+0x970>
test   $0x1,%r8b
je     1ac0 <main+0x950>
movss  (%rsi,%rdi,4),%xmm1
mulss  (%rbx,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
jmp    1ac0 <main+0x950>
lea    0x582(%rip),%rdi
mov    %rax,%rbx
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %rbx,%rdi
call   1070 <print1@plt>
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
jle    1bfa <main+0xa8a>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
xor    %r8d,%r8d
jmp    1b6d <main+0x9fd>
xchg   %ax,%ax
add    $0x1,%r8
cmp    %r9,%r8
je     1bfa <main+0xa8a>
mov    (%r12,%r8,8),%rsi
mov    (%r14,%r8,8),%rdi
xor    %edx,%edx
jmp    1b89 <main+0xa19>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %r9,%rdx
je     1b60 <main+0x9f0>
movss  (%rdi,%rdx,4),%xmm0
xor    %ebx,%ebx
cmp    $0x1,%r9d
je     1bda <main+0xa6a>
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm1
mov    0x0(%r13,%rbx,8),%rax
mulss  (%rax,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rdx,4)
movss  0x4(%rsi,%rbx,4),%xmm0
mov    0x8(%r13,%rbx,8),%rax
mulss  (%rax,%rdx,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rdx,4)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1ba0 <main+0xa30>
test   $0x1,%r9b
je     1b80 <main+0xa10>
movss  (%rsi,%rbx,4),%xmm1
mov    0x0(%r13,%rbx,8),%rax
mulss  (%rax,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rdx,4)
jmp    1b80 <main+0xa10>
lea    0x4c5(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %r14,%rdi
call   1090 <print2@plt>
jmp    1c38 <main+0xac8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
ucomisd 0x3ee(%rip),%xmm0
jb     1d3c <main+0xbcc>
lea    0x49c(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %r15,%rdi
call   1070 <print1@plt>
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
jle    1c20 <main+0xab0>
lea    -0x1(%r9),%r8
mov    %r9d,%edx
and    $0x3,%edx
mov    %r9d,%esi
and    $0xfffffffc,%esi
xorps  %xmm0,%xmm0
xor    %edi,%edi
mov    -0x48(%rbp),%r10
movaps 0x398(%rip),%xmm4
jmp    1ca2 <main+0xb32>
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm2
subss  (%r15,%rdi,4),%xmm2
andps  %xmm4,%xmm2
maxss  %xmm0,%xmm2
movss  %xmm1,(%r15,%rdi,4)
add    $0x1,%rdi
movaps %xmm2,%xmm0
cmp    %r9,%rdi
je     1c23 <main+0xab3>
movss  (%r10,%rdi,4),%xmm1
mov    (%r14,%rdi,8),%rcx
xor    %eax,%eax
cmp    $0x3,%r8
jb     1d0b <main+0xb9b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rax,4),%xmm2
movss  0x4(%rcx,%rax,4),%xmm3
mulss  (%r15,%rax,4),%xmm2
mulss  0x4(%r15,%rax,4),%xmm3
subss  %xmm2,%xmm1
movss  0x8(%rcx,%rax,4),%xmm2
mulss  0x8(%r15,%rax,4),%xmm2
subss  %xmm3,%xmm1
movss  0xc(%rcx,%rax,4),%xmm3
mulss  0xc(%r15,%rax,4),%xmm3
subss  %xmm2,%xmm1
subss  %xmm3,%xmm1
add    $0x4,%rax
cmp    %rax,%rsi
jne    1cc0 <main+0xb50>
test   %rdx,%rdx
je     1c80 <main+0xb10>
lea    (%r15,%rax,4),%rbx
lea    (%rcx,%rax,4),%rax
xor    %ecx,%ecx
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm2
mulss  (%rbx,%rcx,4),%xmm2
subss  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1d20 <main+0xbb0>
jmp    1c80 <main+0xb10>
lea    0x3a2(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%esi
mov    %r15,%rdi
call   1070 <print1@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x2c(%rbp)
mov    -0x58(%rbp),%rbx
jle    1dcf <main+0xc5f>
mov    %r12,%r15
mov    %r14,%r12
xor    %r14d,%r14d
mov    (%rbx,%r14,8),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rax
mov    (%rax,%r14,8),%rdi
call   1030 <free@plt>
mov    0x0(%r13,%r14,8),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rax
mov    (%rax,%r14,8),%rdi
call   1030 <free@plt>
mov    (%r12,%r14,8),%rdi
call   1030 <free@plt>
mov    (%r15,%r14,8),%rdi
call   1030 <free@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%rax
cmp    %rax,%r14
jl     1d80 <main+0xc10>
mov    -0xa0(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [59 x i8] c"Enter the number of simultaneous equations in the system: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [29 x i8] c"Enter the augmented matrix:\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [11 x i8] c"A Matrix:\0A\00"
@.str.5 = [11 x i8] c"B Matrix:\0A\00"
@.str.6 = [11 x i8] c"L Matrix:\0A\00"
@.str.7 = [11 x i8] c"U Matrix:\0A\00"
@.str.8 = [11 x i8] c"D Matrix:\0A\00"
@.str.9 = [13 x i8] c"L+D Matrix:\0A\00"
@.str.10 = [17 x i8] c"(L+D)-1 Matrix:\0A\00"
@.str.11 = [18 x i8] c"D^(-1)*B Matrix:\0A\00"
@.str.12 = [22 x i8] c"((L+D)^-1)*U Matrix:\0A\00"
@.str.13 = [11 x i8] c"X Matrix:\0A\00"
@.str.14 = [32 x i8] c"\0ASolution of the given system:\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca float*
%12 = alloca float*
%13 = alloca i64
%14 = alloca i64
%15 = alloca float*
%16 = alloca float
%17 = alloca float
%18 = alloca float
store i32 0, i32* %1
%19 = call i32 @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%20 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%21 = load i32, i32* %2
%22 = zext i32 %21 to i64
%23 = call i8* @llvm.stacksave()
store i8* %23, i8** %6
%24 = alloca float*, i64 %22
store i64 %22, i64* %7
%25 = load i32, i32* %2
%26 = zext i32 %25 to i64
%27 = alloca float*, i64 %26
store i64 %26, i64* %8
%28 = load i32, i32* %2
%29 = zext i32 %28 to i64
%30 = alloca float*, i64 %29
store i64 %29, i64* %9
%31 = load i32, i32* %2
%32 = zext i32 %31 to i64
%33 = alloca float*, i64 %32
store i64 %32, i64* %10
%34 = load i32, i32* %2
%35 = zext i32 %34 to i64
%36 = alloca float*, i64 %35
store i64 %35, i64* %13
%37 = load i32, i32* %2
%38 = zext i32 %37 to i64
%39 = alloca float*, i64 %38
store i64 %38, i64* %14
store i32 0, i32* %3
br label %40
40: ; preds = %82, %0
%41 = load i32, i32* %3
%42 = load i32, i32* %2
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %85
44: ; preds = %40
%45 = load i32, i32* %2
%46 = call i64 @calloc(i32 %45, i32 4)
%47 = inttoptr i64 %46 to float*
%48 = load i32, i32* %3
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float*, float** %24, i64 %49
store float* %47, float** %50
%51 = load i32, i32* %2
%52 = call i64 @calloc(i32 %51, i32 4)
%53 = inttoptr i64 %52 to float*
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float*, float** %27, i64 %55
store float* %53, float** %56
%57 = load i32, i32* %2
%58 = call i64 @calloc(i32 %57, i32 4)
%59 = inttoptr i64 %58 to float*
%60 = load i32, i32* %3
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float*, float** %30, i64 %61
store float* %59, float** %62
%63 = load i32, i32* %2
%64 = call i64 @calloc(i32 %63, i32 4)
%65 = inttoptr i64 %64 to float*
%66 = load i32, i32* %3
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float*, float** %33, i64 %67
store float* %65, float** %68
%69 = load i32, i32* %2
%70 = call i64 @calloc(i32 %69, i32 4)
%71 = inttoptr i64 %70 to float*
%72 = load i32, i32* %3
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float*, float** %39, i64 %73
store float* %71, float** %74
%75 = load i32, i32* %2
%76 = mul nsw i32 2, %75
%77 = call i64 @calloc(i32 %76, i32 4)
%78 = inttoptr i64 %77 to float*
%79 = load i32, i32* %3
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float*, float** %36, i64 %80
store float* %78, float** %81
br label %82
82: ; preds = %44
%83 = load i32, i32* %3
%84 = add nsw i32 %83, 1
store i32 %84, i32* %3
br label %40
85: ; preds = %40
%86 = load i32, i32* %2
%87 = call i64 @calloc(i32 %86, i32 4)
%88 = inttoptr i64 %87 to float*
store float* %88, float** %11
%89 = load i32, i32* %2
%90 = call i64 @calloc(i32 %89, i32 4)
%91 = inttoptr i64 %90 to float*
store float* %91, float** %12
%92 = load i32, i32* %2
%93 = call i64 @calloc(i32 %92, i32 4)
%94 = inttoptr i64 %93 to float*
store float* %94, float** %15
%95 = call i32 @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %3
br label %96
96: ; preds = %123, %85
%97 = load i32, i32* %3
%98 = load i32, i32* %2
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %126
100: ; preds = %96
store i32 0, i32* %4
br label %101
101: ; preds = %114, %100
%102 = load i32, i32* %4
%103 = load i32, i32* %2
%104 = icmp slt i32 %102, %103
br i1 %104, label %105, label %117
105: ; preds = %101
%106 = load i32, i32* %3
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float*, float** %24, i64 %107
%109 = load float*, float** %108
%110 = load i32, i32* %4
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %112)
br label %114
114: ; preds = %105
%115 = load i32, i32* %4
%116 = add nsw i32 %115, 1
store i32 %116, i32* %4
br label %101
117: ; preds = %101
%118 = load float*, float** %12
%119 = load i32, i32* %3
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %121)
br label %123
123: ; preds = %117
%124 = load i32, i32* %3
%125 = add nsw i32 %124, 1
store i32 %125, i32* %3
br label %96
126: ; preds = %96
%127 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0))
%128 = load i32, i32* %2
%129 = call i32 @print2(float** %24, i32 %128)
%130 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0))
%131 = load float*, float** %12
%132 = load i32, i32* %2
%133 = call i32 @print1(float* %131, i32 %132)
store i32 0, i32* %3
br label %134
134: ; preds = %229, %126
%135 = load i32, i32* %3
%136 = load i32, i32* %2
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %232
138: ; preds = %134
store i32 0, i32* %4
br label %139
139: ; preds = %225, %138
%140 = load i32, i32* %4
%141 = load i32, i32* %2
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %228
143: ; preds = %139
%144 = load i32, i32* %3
%145 = load i32, i32* %4
%146 = icmp sgt i32 %144, %145
br i1 %146, label %147, label %163
147: ; preds = %143
%148 = load i32, i32* %3
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float*, float** %24, i64 %149
%151 = load float*, float** %150
%152 = load i32, i32* %4
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %151, i64 %153
%155 = load float, float* %154
%156 = load i32, i32* %3
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float*, float** %30, i64 %157
%159 = load float*, float** %158
%160 = load i32, i32* %4
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %159, i64 %161
store float %155, float* %162
br label %200
163: ; preds = %143
%164 = load i32, i32* %3
%165 = load i32, i32* %4
%166 = icmp eq i32 %164, %165
br i1 %166, label %167, label %183
167: ; preds = %163
%168 = load i32, i32* %3
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float*, float** %24, i64 %169
%171 = load float*, float** %170
%172 = load i32, i32* %4
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
%175 = load float, float* %174
%176 = load i32, i32* %3
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float*, float** %27, i64 %177
%179 = load float*, float** %178
%180 = load i32, i32* %4
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
store float %175, float* %182
br label %199
183: ; preds = %163
%184 = load i32, i32* %3
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float*, float** %24, i64 %185
%187 = load float*, float** %186
%188 = load i32, i32* %4
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %187, i64 %189
%191 = load float, float* %190
%192 = load i32, i32* %3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float*, float** %33, i64 %193
%195 = load float*, float** %194
%196 = load i32, i32* %4
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %195, i64 %197
store float %191, float* %198
br label %199
199: ; preds = %183, %167
br label %200
200: ; preds = %199, %147
%201 = load i32, i32* %3
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float*, float** %30, i64 %202
%204 = load float*, float** %203
%205 = load i32, i32* %4
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = load i32, i32* %3
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float*, float** %27, i64 %210
%212 = load float*, float** %211
%213 = load i32, i32* %4
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %212, i64 %214
%216 = load float, float* %215
%217 = fadd float %208, %216
%218 = load i32, i32* %3
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float*, float** %36, i64 %219
%221 = load float*, float** %220
%222 = load i32, i32* %4
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
store float %217, float* %224
br label %225
225: ; preds = %200
%226 = load i32, i32* %4
%227 = add nsw i32 %226, 1
store i32 %227, i32* %4
br label %139
228: ; preds = %139
br label %229
229: ; preds = %228
%230 = load i32, i32* %3
%231 = add nsw i32 %230, 1
store i32 %231, i32* %3
br label %134
232: ; preds = %134
%233 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i64 0, i64 0))
%234 = load i32, i32* %2
%235 = call i32 @print2(float** %30, i32 %234)
%236 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0))
%237 = load i32, i32* %2
%238 = call i32 @print2(float** %33, i32 %237)
%239 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
%240 = load i32, i32* %2
%241 = call i32 @print2(float** %27, i32 %240)
%242 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i64 0, i64 0))
%243 = load i32, i32* %2
%244 = call i32 @print2(float** %36, i32 %243)
store i32 0, i32* %3
br label %245
245: ; preds = %275, %232
%246 = load i32, i32* %3
%247 = load i32, i32* %2
%248 = icmp slt i32 %246, %247
br i1 %248, label %249, label %278
249: ; preds = %245
%250 = load i32, i32* %2
store i32 %250, i32* %4
br label %251
251: ; preds = %271, %249
%252 = load i32, i32* %4
%253 = load i32, i32* %2
%254 = mul nsw i32 2, %253
%255 = icmp slt i32 %252, %254
br i1 %255, label %256, label %274
256: ; preds = %251
%257 = load i32, i32* %4
%258 = load i32, i32* %2
%259 = sub nsw i32 %257, %258
%260 = load i32, i32* %3
%261 = icmp eq i32 %259, %260
br i1 %261, label %262, label %270
262: ; preds = %256
%263 = load i32, i32* %3
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float*, float** %36, i64 %264
%266 = load float*, float** %265
%267 = load i32, i32* %4
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %266, i64 %268
store float 1.000000e+00, float* %269
br label %270
270: ; preds = %262, %256
br label %271
271: ; preds = %270
%272 = load i32, i32* %4
%273 = add nsw i32 %272, 1
store i32 %273, i32* %4
br label %251
274: ; preds = %251
br label %275
275: ; preds = %274
%276 = load i32, i32* %3
%277 = add nsw i32 %276, 1
store i32 %277, i32* %3
br label %245
278: ; preds = %245
store i32 0, i32* %3
br label %279
279: ; preds = %373, %278
%280 = load i32, i32* %3
%281 = load i32, i32* %2
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %376
283: ; preds = %279
store i32 0, i32* %4
br label %284
284: ; preds = %369, %283
%285 = load i32, i32* %4
%286 = load i32, i32* %2
%287 = icmp slt i32 %285, %286
br i1 %287, label %288, label %372
288: ; preds = %284
%289 = load i32, i32* %3
%290 = load i32, i32* %4
%291 = icmp ne i32 %289, %290
br i1 %291, label %292, label %339
292: ; preds = %288
%293 = load i32, i32* %4
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float*, float** %36, i64 %294
%296 = load float*, float** %295
%297 = load i32, i32* %3
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %296, i64 %298
%300 = load float, float* %299
%301 = load i32, i32* %3
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float*, float** %36, i64 %302
%304 = load float*, float** %303
%305 = load i32, i32* %3
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %304, i64 %306
%308 = load float, float* %307
%309 = fdiv float %300, %308
store float %309, float* %18
store i32 0, i32* %5
br label %310
310: ; preds = %335, %292
%311 = load i32, i32* %5
%312 = load i32, i32* %2
%313 = mul nsw i32 2, %312
%314 = icmp slt i32 %311, %313
br i1 %314, label %315, label %338
315: ; preds = %310
%316 = load float, float* %18
%317 = load i32, i32* %3
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float*, float** %36, i64 %318
%320 = load float*, float** %319
%321 = load i32, i32* %5
%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** %36, i64 %326
%328 = load float*, float** %327
%329 = load i32, i32* %5
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
%332 = load float, float* %331
%333 = fneg float %316
%334 = call float @llvm.fmuladd.f32(float %333, float %324, float %332)
store float %334, float* %331
br label %335
335: ; preds = %315
%336 = load i32, i32* %5
%337 = add nsw i32 %336, 1
store i32 %337, i32* %5
br label %310
338: ; preds = %310
br label %368
339: ; preds = %288
%340 = load i32, i32* %3
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float*, float** %36, i64 %341
%343 = load float*, float** %342
%344 = load i32, i32* %3
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
store float %347, float* %18
store i32 0, i32* %5
br label %348
348: ; preds = %364, %339
%349 = load i32, i32* %5
%350 = load i32, i32* %2
%351 = mul nsw i32 2, %350
%352 = icmp slt i32 %349, %351
br i1 %352, label %353, label %367
353: ; preds = %348
%354 = load float, float* %18
%355 = load i32, i32* %3
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float*, float** %36, i64 %356
%358 = load float*, float** %357
%359 = load i32, i32* %5
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %358, i64 %360
%362 = load float, float* %361
%363 = fdiv float %362, %354
store float %363, float* %361
br label %364
364: ; preds = %353
%365 = load i32, i32* %5
%366 = add nsw i32 %365, 1
store i32 %366, i32* %5
br label %348
367: ; preds = %348
br label %368
368: ; preds = %367, %338
br label %369
369: ; preds = %368
%370 = load i32, i32* %4
%371 = add nsw i32 %370, 1
store i32 %371, i32* %4
br label %284
372: ; preds = %284
br label %373
373: ; preds = %372
%374 = load i32, i32* %3
%375 = add nsw i32 %374, 1
store i32 %375, i32* %3
br label %279
376: ; preds = %279
store i32 0, i32* %3
br label %377
377: ; preds = %408, %376
%378 = load i32, i32* %3
%379 = load i32, i32* %2
%380 = icmp slt i32 %378, %379
br i1 %380, label %381, label %411
381: ; preds = %377
store i32 0, i32* %4
br label %382
382: ; preds = %404, %381
%383 = load i32, i32* %4
%384 = load i32, i32* %2
%385 = icmp slt i32 %383, %384
br i1 %385, label %386, label %407
386: ; preds = %382
%387 = load i32, i32* %3
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float*, float** %36, i64 %388
%390 = load float*, float** %389
%391 = load i32, i32* %4
%392 = load i32, i32* %2
%393 = add nsw i32 %391, %392
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds float, float* %390, i64 %394
%396 = load float, float* %395
%397 = load i32, i32* %3
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds float*, float** %39, i64 %398
%400 = load float*, float** %399
%401 = load i32, i32* %4
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds float, float* %400, i64 %402
store float %396, float* %403
br label %404
404: ; preds = %386
%405 = load i32, i32* %4
%406 = add nsw i32 %405, 1
store i32 %406, i32* %4
br label %382
407: ; preds = %382
br label %408
408: ; preds = %407
%409 = load i32, i32* %3
%410 = add nsw i32 %409, 1
store i32 %410, i32* %3
br label %377
411: ; preds = %377
%412 = call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.10, i64 0, i64 0))
%413 = load i32, i32* %2
%414 = call i32 @print2(float** %39, i32 %413)
store i32 0, i32* %3
br label %415
415: ; preds = %431, %411
%416 = load i32, i32* %3
%417 = load i32, i32* %2
%418 = icmp slt i32 %416, %417
br i1 %418, label %419, label %434
419: ; preds = %415
%420 = load i32, i32* %3
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds float*, float** %36, i64 %421
%423 = load float*, float** %422
%424 = call i32 @free(float* %423)
%425 = load i32, i32* %2
%426 = call i64 @calloc(i32 %425, i32 4)
%427 = inttoptr i64 %426 to float*
%428 = load i32, i32* %3
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds float*, float** %36, i64 %429
store float* %427, float** %430
br label %431
431: ; preds = %419
%432 = load i32, i32* %3
%433 = add nsw i32 %432, 1
store i32 %433, i32* %3
br label %415
434: ; preds = %415
store i32 0, i32* %3
br label %435
435: ; preds = %468, %434
%436 = load i32, i32* %3
%437 = load i32, i32* %2
%438 = icmp slt i32 %436, %437
br i1 %438, label %439, label %471
439: ; preds = %435
store i32 0, i32* %4
br label %440
440: ; preds = %464, %439
%441 = load i32, i32* %4
%442 = load i32, i32* %2
%443 = icmp slt i32 %441, %442
br i1 %443, label %444, label %467
444: ; preds = %440
%445 = load i32, i32* %3
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float*, float** %39, i64 %446
%448 = load float*, float** %447
%449 = load i32, i32* %4
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %448, i64 %450
%452 = load float, float* %451
%453 = load float*, float** %12
%454 = load i32, i32* %4
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds float, float* %453, i64 %455
%457 = load float, float* %456
%458 = load float*, float** %15
%459 = load i32, i32* %3
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds float, float* %458, i64 %460
%462 = load float, float* %461
%463 = call float @llvm.fmuladd.f32(float %452, float %457, float %462)
store float %463, float* %461
br label %464
464: ; preds = %444
%465 = load i32, i32* %4
%466 = add nsw i32 %465, 1
store i32 %466, i32* %4
br label %440
467: ; preds = %440
br label %468
468: ; preds = %467
%469 = load i32, i32* %3
%470 = add nsw i32 %469, 1
store i32 %470, i32* %3
br label %435
471: ; preds = %435
%472 = call i32 @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.11, i64 0, i64 0))
%473 = load float*, float** %15
%474 = load i32, i32* %2
%475 = call i32 @print1(float* %473, i32 %474)
store i32 0, i32* %3
br label %476
476: ; preds = %524, %471
%477 = load i32, i32* %3
%478 = load i32, i32* %2
%479 = icmp slt i32 %477, %478
br i1 %479, label %480, label %527
480: ; preds = %476
store i32 0, i32* %4
br label %481
481: ; preds = %520, %480
%482 = load i32, i32* %4
%483 = load i32, i32* %2
%484 = icmp slt i32 %482, %483
br i1 %484, label %485, label %523
485: ; preds = %481
store i32 0, i32* %5
br label %486
486: ; preds = %516, %485
%487 = load i32, i32* %5
%488 = load i32, i32* %2
%489 = icmp slt i32 %487, %488
br i1 %489, label %490, label %519
490: ; preds = %486
%491 = load i32, i32* %3
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds float*, float** %39, i64 %492
%494 = load float*, float** %493
%495 = load i32, i32* %5
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds float, float* %494, i64 %496
%498 = load float, float* %497
%499 = load i32, i32* %5
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float*, float** %33, i64 %500
%502 = load float*, float** %501
%503 = load i32, i32* %4
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %502, i64 %504
%506 = load float, float* %505
%507 = load i32, i32* %3
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float*, float** %36, i64 %508
%510 = load float*, float** %509
%511 = load i32, i32* %4
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds float, float* %510, i64 %512
%514 = load float, float* %513
%515 = call float @llvm.fmuladd.f32(float %498, float %506, float %514)
store float %515, float* %513
br label %516
516: ; preds = %490
%517 = load i32, i32* %5
%518 = add nsw i32 %517, 1
store i32 %518, i32* %5
br label %486
519: ; preds = %486
br label %520
520: ; preds = %519
%521 = load i32, i32* %4
%522 = add nsw i32 %521, 1
store i32 %522, i32* %4
br label %481
523: ; preds = %481
br label %524
524: ; preds = %523
%525 = load i32, i32* %3
%526 = add nsw i32 %525, 1
store i32 %526, i32* %3
br label %476
527: ; preds = %476
%528 = call i32 @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%529 = load i32, i32* %2
%530 = call i32 @print2(float** %36, i32 %529)
br label %531
531: ; preds = %600, %527
%532 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0))
%533 = load float*, float** %11
%534 = load i32, i32* %2
%535 = call i32 @print1(float* %533, i32 %534)
store float 0.000000e+00, float* %17
store i32 0, i32* %3
br label %536
536: ; preds = %596, %531
%537 = load i32, i32* %3
%538 = load i32, i32* %2
%539 = icmp slt i32 %537, %538
br i1 %539, label %540, label %599
540: ; preds = %536
%541 = load float*, float** %15
%542 = load i32, i32* %3
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds float, float* %541, i64 %543
%545 = load float, float* %544
store float %545, float* %16
store i32 0, i32* %4
br label %546
546: ; preds = %567, %540
%547 = load i32, i32* %4
%548 = load i32, i32* %2
%549 = icmp slt i32 %547, %548
br i1 %549, label %550, label %570
550: ; preds = %546
%551 = load i32, i32* %3
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds float*, float** %36, i64 %552
%554 = load float*, float** %553
%555 = load i32, i32* %4
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds float, float* %554, i64 %556
%558 = load float, float* %557
%559 = load float*, float** %11
%560 = load i32, i32* %4
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds float, float* %559, i64 %561
%563 = load float, float* %562
%564 = load float, float* %16
%565 = fneg float %558
%566 = call float @llvm.fmuladd.f32(float %565, float %563, float %564)
store float %566, float* %16
br label %567
567: ; preds = %550
%568 = load i32, i32* %4
%569 = add nsw i32 %568, 1
store i32 %569, i32* %4
br label %546
570: ; preds = %546
%571 = load float, float* %16
%572 = load float*, float** %11
%573 = load i32, i32* %3
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float, float* %572, i64 %574
%576 = load float, float* %575
%577 = fsub float %571, %576
%578 = call float @fabs(float %577)
%579 = load float, float* %17
%580 = fcmp ogt float %578, %579
br i1 %580, label %581, label %590
581: ; preds = %570
%582 = load float, float* %16
%583 = load float*, float** %11
%584 = load i32, i32* %3
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds float, float* %583, i64 %585
%587 = load float, float* %586
%588 = fsub float %582, %587
%589 = call float @fabs(float %588)
store float %589, float* %17
br label %590
590: ; preds = %581, %570
%591 = load float, float* %16
%592 = load float*, float** %11
%593 = load i32, i32* %3
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds float, float* %592, i64 %594
store float %591, float* %595
br label %596
596: ; preds = %590
%597 = load i32, i32* %3
%598 = add nsw i32 %597, 1
store i32 %598, i32* %3
br label %536
599: ; preds = %536
br label %600
600: ; preds = %599
%601 = load float, float* %17
%602 = fpext float %601 to double
%603 = fcmp oge double %602, 5.000000e-07
br i1 %603, label %531, label %604
604: ; preds = %600
%605 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.14, i64 0, i64 0))
%606 = load float*, float** %11
%607 = load i32, i32* %2
%608 = call i32 @print1(float* %606, i32 %607)
%609 = load float*, float** %11
%610 = call i32 @free(float* %609)
%611 = load float*, float** %12
%612 = call i32 @free(float* %611)
%613 = load float*, float** %15
%614 = call i32 @free(float* %613)
store i32 0, i32* %3
br label %615
615: ; preds = %650, %604
%616 = load i32, i32* %3
%617 = load i32, i32* %2
%618 = icmp slt i32 %616, %617
br i1 %618, label %619, label %653
619: ; preds = %615
%620 = load i32, i32* %3
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds float*, float** %24, i64 %621
%623 = load float*, float** %622
%624 = call i32 @free(float* %623)
%625 = load i32, i32* %3
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds float*, float** %30, i64 %626
%628 = load float*, float** %627
%629 = call i32 @free(float* %628)
%630 = load i32, i32* %3
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds float*, float** %33, i64 %631
%633 = load float*, float** %632
%634 = call i32 @free(float* %633)
%635 = load i32, i32* %3
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds float*, float** %27, i64 %636
%638 = load float*, float** %637
%639 = call i32 @free(float* %638)
%640 = load i32, i32* %3
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds float*, float** %36, i64 %641
%643 = load float*, float** %642
%644 = call i32 @free(float* %643)
%645 = load i32, i32* %3
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds float*, float** %39, i64 %646
%648 = load float*, float** %647
%649 = call i32 @free(float* %648)
br label %650
650: ; preds = %619
%651 = load i32, i32* %3
%652 = add nsw i32 %651, 1
store i32 %652, i32* %3
br label %615
653: ; preds = %615
store i32 0, i32* %1
%654 = load i8*, i8** %6
%655 = load i32, i32* %1
ret i32 %655
}

LLVM IR (-O2):
@.str = [59 x i8] c"Enter the number of simultaneous equations in the system: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.3 = [3 x i8] c"%f\00"
@str = [28 x i8] c"Enter the augmented matrix:\00"
@str.15 = [10 x i8] c"A Matrix:\00"
@str.16 = [10 x i8] c"B Matrix:\00"
@str.17 = [10 x i8] c"L Matrix:\00"
@str.18 = [10 x i8] c"U Matrix:\00"
@str.19 = [10 x i8] c"D Matrix:\00"
@str.20 = [12 x i8] c"L+D Matrix:\00"
@str.21 = [16 x i8] c"(L+D)-1 Matrix:\00"
@str.22 = [17 x i8] c"D^(-1)*B Matrix:\00"
@str.23 = [21 x i8] c"((L+D)^-1)*U Matrix:\00"
@str.24 = [10 x i8] c"X Matrix:\00"
@str.25 = [31 x i8] c"\0ASolution of the given system:\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%4 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%5 = load i32, i32* %1
%6 = zext i32 %5 to i64
%7 = call i8* @llvm.stacksave()
%8 = alloca float*, i64 %6
%9 = load i32, i32* %1
%10 = zext i32 %9 to i64
%11 = alloca float*, i64 %10
%12 = alloca float*, i64 %10
%13 = alloca float*, i64 %10
%14 = alloca float*, i64 %10
%15 = alloca float*, i64 %10
%16 = icmp sgt i32 %9, 0
br i1 %16, label %17, label %48
17: ; preds = %0, %17
%18 = phi i64 [ %44, %17 ], [ 0, %0 ]
%19 = phi i32 [ %45, %17 ], [ %9, %0 ]
%20 = call i64 @calloc(i32 %19, i32 4)
%21 = inttoptr i64 %20 to float*
%22 = getelementptr inbounds float*, float** %8, i64 %18
store float* %21, float** %22
%23 = load i32, i32* %1
%24 = call i64 @calloc(i32 %23, i32 4)
%25 = inttoptr i64 %24 to float*
%26 = getelementptr inbounds float*, float** %11, i64 %18
store float* %25, float** %26
%27 = load i32, i32* %1
%28 = call i64 @calloc(i32 %27, i32 4)
%29 = inttoptr i64 %28 to float*
%30 = getelementptr inbounds float*, float** %12, i64 %18
store float* %29, float** %30
%31 = load i32, i32* %1
%32 = call i64 @calloc(i32 %31, i32 4)
%33 = inttoptr i64 %32 to float*
%34 = getelementptr inbounds float*, float** %13, i64 %18
store float* %33, float** %34
%35 = load i32, i32* %1
%36 = call i64 @calloc(i32 %35, i32 4)
%37 = inttoptr i64 %36 to float*
%38 = getelementptr inbounds float*, float** %15, i64 %18
store float* %37, float** %38
%39 = load i32, i32* %1
%40 = shl nsw i32 %39, 1
%41 = call i64 @calloc(i32 %40, i32 4)
%42 = inttoptr i64 %41 to float*
%43 = getelementptr inbounds float*, float** %14, i64 %18
store float* %42, float** %43
%44 = add nuw nsw i64 %18, 1
%45 = load i32, i32* %1
%46 = sext i32 %45 to i64
%47 = icmp slt i64 %44, %46
br i1 %47, label %17, label %48
48: ; preds = %17, %0
%49 = phi i32 [ %9, %0 ], [ %45, %17 ]
%50 = call i64 @calloc(i32 %49, i32 4)
%51 = inttoptr i64 %50 to float*
%52 = load i32, i32* %1
%53 = call i64 @calloc(i32 %52, i32 4)
%54 = inttoptr i64 %53 to float*
%55 = load i32, i32* %1
%56 = call i64 @calloc(i32 %55, i32 4)
%57 = inttoptr i64 %56 to float*
%58 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%59 = load i32, i32* %1
%60 = icmp sgt i32 %59, 0
br i1 %60, label %61, label %83
61: ; preds = %48, %76
%62 = phi i32 [ %80, %76 ], [ %59, %48 ]
%63 = phi i64 [ %79, %76 ], [ 0, %48 ]
%64 = icmp sgt i32 %62, 0
br i1 %64, label %65, label %76
65: ; preds = %61
%66 = getelementptr inbounds float*, float** %8, i64 %63
br label %67
67: ; preds = %65, %67
%68 = phi i64 [ 0, %65 ], [ %72, %67 ]
%69 = load float*, float** %66
%70 = getelementptr inbounds float, float* %69, i64 %68
%71 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %70)
%72 = add nuw nsw i64 %68, 1
%73 = load i32, i32* %1
%74 = sext i32 %73 to i64
%75 = icmp slt i64 %72, %74
br i1 %75, label %67, label %76
76: ; preds = %67, %61
%77 = getelementptr inbounds float, float* %54, i64 %63
%78 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %77)
%79 = add nuw nsw i64 %63, 1
%80 = load i32, i32* %1
%81 = sext i32 %80 to i64
%82 = icmp slt i64 %79, %81
br i1 %82, label %61, label %83
83: ; preds = %76, %48
%84 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.15, i64 0, i64 0))
%85 = load i32, i32* %1
%86 = call i32 @print2(float** %8, i32 %85)
%87 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.16, i64 0, i64 0))
%88 = load i32, i32* %1
%89 = call i32 @print1(float* %54, i32 %88)
%90 = load i32, i32* %1
%91 = icmp sgt i32 %90, 0
br i1 %91, label %92, label %136
92: ; preds = %83
%93 = zext i32 %90 to i64
br label %94
94: ; preds = %133, %92
%95 = phi i64 [ 0, %92 ], [ %134, %133 ]
%96 = getelementptr inbounds float*, float** %8, i64 %95
%97 = getelementptr inbounds float*, float** %13, i64 %95
%98 = getelementptr inbounds float*, float** %11, i64 %95
%99 = getelementptr inbounds float*, float** %12, i64 %95
%100 = load float*, float** %99
%101 = load float*, float** %98
%102 = getelementptr inbounds float*, float** %14, i64 %95
%103 = load float*, float** %102
%104 = getelementptr inbounds float, float* %101, i64 %95
br label %105
105: ; preds = %94, %124
%106 = phi i64 [ 0, %94 ], [ %131, %124 ]
%107 = icmp ugt i64 %95, %106
br i1 %107, label %108, label %113
108: ; preds = %105
%109 = load float*, float** %96
%110 = getelementptr inbounds float, float* %109, i64 %106
%111 = load float, float* %110
%112 = getelementptr inbounds float, float* %100, i64 %106
store float %111, float* %112
br label %124
113: ; preds = %105
%114 = icmp eq i64 %95, %106
%115 = load float*, float** %96
br i1 %114, label %116, label %119
116: ; preds = %113
%117 = getelementptr inbounds float, float* %115, i64 %95
%118 = load float, float* %117
store float %118, float* %104
br label %124
119: ; preds = %113
%120 = getelementptr inbounds float, float* %115, i64 %106
%121 = load float, float* %120
%122 = load float*, float** %97
%123 = getelementptr inbounds float, float* %122, i64 %106
store float %121, float* %123
br label %124
124: ; preds = %116, %119, %108
%125 = getelementptr inbounds float, float* %100, i64 %106
%126 = load float, float* %125
%127 = getelementptr inbounds float, float* %101, i64 %106
%128 = load float, float* %127
%129 = fadd float %126, %128
%130 = getelementptr inbounds float, float* %103, i64 %106
store float %129, float* %130
%131 = add nuw nsw i64 %106, 1
%132 = icmp eq i64 %131, %93
br i1 %132, label %133, label %105
133: ; preds = %124
%134 = add nuw nsw i64 %95, 1
%135 = icmp eq i64 %134, %93
br i1 %135, label %136, label %94
136: ; preds = %133, %83
%137 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.17, i64 0, i64 0))
%138 = load i32, i32* %1
%139 = call i32 @print2(float** %12, i32 %138)
%140 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.18, i64 0, i64 0))
%141 = load i32, i32* %1
%142 = call i32 @print2(float** %13, i32 %141)
%143 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.19, i64 0, i64 0))
%144 = load i32, i32* %1
%145 = call i32 @print2(float** %11, i32 %144)
%146 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.20, i64 0, i64 0))
%147 = load i32, i32* %1
%148 = call i32 @print2(float** %14, i32 %147)
%149 = load i32, i32* %1
%150 = icmp sgt i32 %149, 0
br i1 %150, label %151, label %534
151: ; preds = %136
%152 = shl nuw i32 %149, 1
%153 = icmp slt i32 %149, %152
%154 = zext i32 %149 to i64
%155 = zext i32 %149 to i64
%156 = sext i32 %152 to i64
%157 = xor i64 %155, -1
%158 = and i64 %155, 1
%159 = icmp eq i64 %158, 0
%160 = add nuw nsw i64 %154, 1
%161 = sub nsw i64 0, %156
%162 = icmp eq i64 %157, %161
br label %163
163: ; preds = %151, %223
%164 = phi i64 [ 0, %151 ], [ %224, %223 ]
br i1 %153, label %165, label %223
165: ; preds = %163
%166 = getelementptr inbounds float*, float** %14, i64 %164
br i1 %159, label %172, label %167
167: ; preds = %165
%168 = icmp eq i64 %164, 0
br i1 %168, label %169, label %172
169: ; preds = %167
%170 = load float*, float** %166
%171 = getelementptr inbounds float, float* %170, i64 %154
store float 1.000000e+00, float* %171
br label %172
172: ; preds = %167, %169, %165
%173 = phi i64 [ %154, %165 ], [ %160, %169 ], [ %160, %167 ]
br i1 %162, label %223, label %206
174: ; preds = %223
br i1 %150, label %175, label %534
175: ; preds = %174
%176 = shl nuw i32 %149, 1
%177 = call i32 @llvm.smax.i32(i32 %176, i32 1)
%178 = zext i32 %149 to i64
%179 = zext i32 %177 to i64
%180 = zext i32 %177 to i64
%181 = and i64 %179, 2147483640
%182 = add nsw i64 %181, -8
%183 = lshr exact i64 %182, 3
%184 = add nuw nsw i64 %183, 1
%185 = and i64 %179, 2147483644
%186 = add nsw i64 %185, -4
%187 = lshr exact i64 %186, 2
%188 = add nuw nsw i64 %187, 1
%189 = icmp ult i32 %177, 8
%190 = and i64 %179, 2147483640
%191 = and i64 %184, 1
%192 = icmp eq i64 %182, 0
%193 = and i64 %184, 4611686018427387902
%194 = icmp eq i64 %191, 0
%195 = icmp eq i64 %190, %179
%196 = and i64 %179, 1
%197 = icmp eq i64 %196, 0
%198 = sub nsw i64 0, %179
%199 = icmp ult i32 %177, 4
%200 = and i64 %179, 2147483644
%201 = and i64 %188, 1
%202 = icmp eq i64 %186, 0
%203 = and i64 %188, 9223372036854775806
%204 = icmp eq i64 %201, 0
%205 = icmp eq i64 %200, %179
br label %226
206: ; preds = %172, %220
%207 = phi i64 [ %221, %220 ], [ %173, %172 ]
%208 = sub nsw i64 %207, %154
%209 = icmp eq i64 %208, %164
br i1 %209, label %210, label %213
210: ; preds = %206
%211 = load float*, float** %166
%212 = getelementptr inbounds float, float* %211, i64 %207
store float 1.000000e+00, float* %212
br label %213
213: ; preds = %206, %210
%214 = add nuw nsw i64 %207, 1
%215 = sub nsw i64 %214, %154
%216 = icmp eq i64 %215, %164
br i1 %216, label %217, label %220
217: ; preds = %213
%218 = load float*, float** %166
%219 = getelementptr inbounds float, float* %218, i64 %214
store float 1.000000e+00, float* %219
br label %220
220: ; preds = %217, %213
%221 = add nuw nsw i64 %207, 2
%222 = icmp eq i64 %221, %156
br i1 %222, label %223, label %206
223: ; preds = %172, %220, %163
%224 = add nuw nsw i64 %164, 1
%225 = icmp eq i64 %224, %155
br i1 %225, label %174, label %163
226: ; preds = %403, %175
%227 = phi i64 [ 0, %175 ], [ %404, %403 ]
%228 = getelementptr inbounds float*, float** %14, i64 %227
br label %247
229: ; preds = %403
br i1 %150, label %230, label %534
230: ; preds = %229
%231 = zext i32 %149 to i64
%232 = zext i32 %149 to i64
%233 = shl nuw nsw i64 %154, 1
%234 = and i64 %232, 4294967288
%235 = add nsw i64 %234, -8
%236 = lshr exact i64 %235, 3
%237 = add nuw nsw i64 %236, 1
%238 = icmp ult i32 %149, 8
%239 = and i64 %154, 4294967288
%240 = and i64 %237, 3
%241 = icmp ult i64 %235, 24
%242 = and i64 %237, 4611686018427387900
%243 = icmp eq i64 %240, 0
%244 = icmp eq i64 %239, %154
%245 = and i64 %232, 3
%246 = icmp eq i64 %245, 0
br label %406
247: ; preds = %226, %400
%248 = phi i64 [ 0, %226 ], [ %401, %400 ]
%249 = icmp eq i64 %227, %248
br i1 %249, label %358, label %250
250: ; preds = %247
%251 = getelementptr inbounds float*, float** %14, i64 %248
%252 = load float*, float** %251
%253 = load float*, float** %228
%254 = getelementptr inbounds float, float* %253, i64 %227
%255 = load float, float* %254
%256 = getelementptr inbounds float, float* %252, i64 %227
%257 = load float, float* %256
%258 = fneg float %257
%259 = fdiv float %258, %255
br i1 %189, label %330, label %260
260: ; preds = %250
%261 = getelementptr float, float* %252, i64 %179
%262 = getelementptr float, float* %253, i64 %179
%263 = icmp ult float* %252, %262
%264 = icmp ult float* %253, %261
%265 = and i1 %263, %264
br i1 %265, label %330, label %266
266: ; preds = %260
%267 = insertelement <4 x float> poison, float %259, i64 0
%268 = shufflevector <4 x float> %267, <4 x float> poison, <4 x i32> zeroinitializer
%269 = insertelement <4 x float> poison, float %259, i64 0
%270 = shufflevector <4 x float> %269, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %192, label %310, label %271
271: ; preds = %266, %271
%272 = phi i64 [ %307, %271 ], [ 0, %266 ]
%273 = phi i64 [ %308, %271 ], [ 0, %266 ]
%274 = getelementptr inbounds float, float* %253, i64 %272
%275 = bitcast float* %274 to <4 x float>*
%276 = load <4 x float>, <4 x float>* %275
%277 = getelementptr inbounds float, float* %274, i64 4
%278 = bitcast float* %277 to <4 x float>*
%279 = load <4 x float>, <4 x float>* %278
%280 = getelementptr inbounds float, float* %252, i64 %272
%281 = bitcast float* %280 to <4 x float>*
%282 = load <4 x float>, <4 x float>* %281
%283 = getelementptr inbounds float, float* %280, i64 4
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %284
%286 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %268, <4 x float> %276, <4 x float> %282)
%287 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %270, <4 x float> %279, <4 x float> %285)
%288 = bitcast float* %280 to <4 x float>*
store <4 x float> %286, <4 x float>* %288
%289 = bitcast float* %283 to <4 x float>*
store <4 x float> %287, <4 x float>* %289
%290 = or i64 %272, 8
%291 = getelementptr inbounds float, float* %253, i64 %290
%292 = bitcast float* %291 to <4 x float>*
%293 = load <4 x float>, <4 x float>* %292
%294 = getelementptr inbounds float, float* %291, i64 4
%295 = bitcast float* %294 to <4 x float>*
%296 = load <4 x float>, <4 x float>* %295
%297 = getelementptr inbounds float, float* %252, i64 %290
%298 = bitcast float* %297 to <4 x float>*
%299 = load <4 x float>, <4 x float>* %298
%300 = getelementptr inbounds float, float* %297, i64 4
%301 = bitcast float* %300 to <4 x float>*
%302 = load <4 x float>, <4 x float>* %301
%303 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %268, <4 x float> %293, <4 x float> %299)
%304 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %270, <4 x float> %296, <4 x float> %302)
%305 = bitcast float* %297 to <4 x float>*
store <4 x float> %303, <4 x float>* %305
%306 = bitcast float* %300 to <4 x float>*
store <4 x float> %304, <4 x float>* %306
%307 = add nuw i64 %272, 16
%308 = add i64 %273, 2
%309 = icmp eq i64 %308, %193
br i1 %309, label %310, label %271
310: ; preds = %271, %266
%311 = phi i64 [ 0, %266 ], [ %307, %271 ]
br i1 %194, label %329, label %312
312: ; preds = %310
%313 = getelementptr inbounds float, float* %253, i64 %311
%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 = getelementptr inbounds float, float* %252, i64 %311
%320 = bitcast float* %319 to <4 x float>*
%321 = load <4 x float>, <4 x float>* %320
%322 = getelementptr inbounds float, float* %319, i64 4
%323 = bitcast float* %322 to <4 x float>*
%324 = load <4 x float>, <4 x float>* %323
%325 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %268, <4 x float> %315, <4 x float> %321)
%326 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %270, <4 x float> %318, <4 x float> %324)
%327 = bitcast float* %319 to <4 x float>*
store <4 x float> %325, <4 x float>* %327
%328 = bitcast float* %322 to <4 x float>*
store <4 x float> %326, <4 x float>* %328
br label %329
329: ; preds = %310, %312
br i1 %195, label %400, label %330
330: ; preds = %260, %250, %329
%331 = phi i64 [ 0, %260 ], [ 0, %250 ], [ %190, %329 ]
%332 = xor i64 %331, -1
br i1 %197, label %340, label %333
333: ; preds = %330
%334 = getelementptr inbounds float, float* %253, i64 %331
%335 = load float, float* %334
%336 = getelementptr inbounds float, float* %252, i64 %331
%337 = load float, float* %336
%338 = call float @llvm.fmuladd.f32(float %259, float %335, float %337)
store float %338, float* %336
%339 = or i64 %331, 1
br label %340
340: ; preds = %333, %330
%341 = phi i64 [ %331, %330 ], [ %339, %333 ]
%342 = icmp eq i64 %332, %198
br i1 %342, label %400, label %343
343: ; preds = %340, %343
%344 = phi i64 [ %356, %343 ], [ %341, %340 ]
%345 = getelementptr inbounds float, float* %253, i64 %344
%346 = load float, float* %345
%347 = getelementptr inbounds float, float* %252, i64 %344
%348 = load float, float* %347
%349 = call float @llvm.fmuladd.f32(float %259, float %346, float %348)
store float %349, float* %347
%350 = add nuw nsw i64 %344, 1
%351 = getelementptr inbounds float, float* %253, i64 %350
%352 = load float, float* %351
%353 = getelementptr inbounds float, float* %252, i64 %350
%354 = load float, float* %353
%355 = call float @llvm.fmuladd.f32(float %259, float %352, float %354)
store float %355, float* %353
%356 = add nuw nsw i64 %344, 2
%357 = icmp eq i64 %356, %179
br i1 %357, label %400, label %343
358: ; preds = %247
%359 = load float*, float** %228
%360 = getelementptr inbounds float, float* %359, i64 %227
%361 = load float, float* %360
br i1 %199, label %391, label %362
362: ; preds = %358
%363 = insertelement <4 x float> poison, float %361, i64 0
%364 = shufflevector <4 x float> %363, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %202, label %382, label %365
365: ; preds = %362, %365
%366 = phi i64 [ %379, %365 ], [ 0, %362 ]
%367 = phi i64 [ %380, %365 ], [ 0, %362 ]
%368 = getelementptr inbounds float, float* %359, i64 %366
%369 = bitcast float* %368 to <4 x float>*
%370 = load <4 x float>, <4 x float>* %369
%371 = fdiv <4 x float> %370, %364
%372 = bitcast float* %368 to <4 x float>*
store <4 x float> %371, <4 x float>* %372
%373 = or i64 %366, 4
%374 = getelementptr inbounds float, float* %359, i64 %373
%375 = bitcast float* %374 to <4 x float>*
%376 = load <4 x float>, <4 x float>* %375
%377 = fdiv <4 x float> %376, %364
%378 = bitcast float* %374 to <4 x float>*
store <4 x float> %377, <4 x float>* %378
%379 = add nuw i64 %366, 8
%380 = add i64 %367, 2
%381 = icmp eq i64 %380, %203
br i1 %381, label %382, label %365
382: ; preds = %365, %362
%383 = phi i64 [ 0, %362 ], [ %379, %365 ]
br i1 %204, label %390, label %384
384: ; preds = %382
%385 = getelementptr inbounds float, float* %359, i64 %383
%386 = bitcast float* %385 to <4 x float>*
%387 = load <4 x float>, <4 x float>* %386
%388 = fdiv <4 x float> %387, %364
%389 = bitcast float* %385 to <4 x float>*
store <4 x float> %388, <4 x float>* %389
br label %390
390: ; preds = %382, %384
br i1 %205, label %400, label %391
391: ; preds = %358, %390
%392 = phi i64 [ 0, %358 ], [ %200, %390 ]
br label %393
393: ; preds = %391, %393
%394 = phi i64 [ %398, %393 ], [ %392, %391 ]
%395 = getelementptr inbounds float, float* %359, i64 %394
%396 = load float, float* %395
%397 = fdiv float %396, %361
store float %397, float* %395
%398 = add nuw nsw i64 %394, 1
%399 = icmp eq i64 %398, %180
br i1 %399, label %400, label %393
400: ; preds = %340, %343, %393, %329, %390
%401 = add nuw nsw i64 %248, 1
%402 = icmp eq i64 %401, %178
br i1 %402, label %403, label %247
403: ; preds = %400
%404 = add nuw nsw i64 %227, 1
%405 = icmp eq i64 %404, %178
br i1 %405, label %229, label %226
406: ; preds = %531, %230
%407 = phi i64 [ 0, %230 ], [ %532, %531 ]
%408 = getelementptr inbounds float*, float** %14, i64 %407
%409 = load float*, float** %408
%410 = getelementptr inbounds float*, float** %15, i64 %407
%411 = load float*, float** %410
br i1 %238, label %491, label %412
412: ; preds = %406
%413 = getelementptr float, float* %409, i64 %233
%414 = icmp ult float* %411, %413
%415 = icmp ult float* %409, %411
%416 = and i1 %414, %415
br i1 %416, label %491, label %417
417: ; preds = %412
br i1 %241, label %471, label %418
418: ; preds = %417, %418
%419 = phi i64 [ %468, %418 ], [ 0, %417 ]
%420 = phi i64 [ %469, %418 ], [ 0, %417 ]
%421 = add nuw nsw i64 %419, %231
%422 = getelementptr inbounds float, float* %409, i64 %421
%423 = bitcast float* %422 to <4 x float>*
%424 = load <4 x float>, <4 x float>* %423
%425 = getelementptr inbounds float, float* %422, i64 4
%426 = bitcast float* %425 to <4 x float>*
%427 = load <4 x float>, <4 x float>* %426
%428 = getelementptr inbounds float, float* %411, i64 %419
%429 = bitcast float* %428 to <4 x float>*
store <4 x float> %424, <4 x float>* %429
%430 = getelementptr inbounds float, float* %428, i64 4
%431 = bitcast float* %430 to <4 x float>*
store <4 x float> %427, <4 x float>* %431
%432 = or i64 %419, 8
%433 = add nuw nsw i64 %432, %231
%434 = getelementptr inbounds float, float* %409, i64 %433
%435 = bitcast float* %434 to <4 x float>*
%436 = load <4 x float>, <4 x float>* %435
%437 = getelementptr inbounds float, float* %434, i64 4
%438 = bitcast float* %437 to <4 x float>*
%439 = load <4 x float>, <4 x float>* %438
%440 = getelementptr inbounds float, float* %411, i64 %432
%441 = bitcast float* %440 to <4 x float>*
store <4 x float> %436, <4 x float>* %441
%442 = getelementptr inbounds float, float* %440, i64 4
%443 = bitcast float* %442 to <4 x float>*
store <4 x float> %439, <4 x float>* %443
%444 = or i64 %419, 16
%445 = add nuw nsw i64 %444, %231
%446 = getelementptr inbounds float, float* %409, i64 %445
%447 = bitcast float* %446 to <4 x float>*
%448 = load <4 x float>, <4 x float>* %447
%449 = getelementptr inbounds float, float* %446, i64 4
%450 = bitcast float* %449 to <4 x float>*
%451 = load <4 x float>, <4 x float>* %450
%452 = getelementptr inbounds float, float* %411, i64 %444
%453 = bitcast float* %452 to <4 x float>*
store <4 x float> %448, <4 x float>* %453
%454 = getelementptr inbounds float, float* %452, i64 4
%455 = bitcast float* %454 to <4 x float>*
store <4 x float> %451, <4 x float>* %455
%456 = or i64 %419, 24
%457 = add nuw nsw i64 %456, %231
%458 = getelementptr inbounds float, float* %409, i64 %457
%459 = bitcast float* %458 to <4 x float>*
%460 = load <4 x float>, <4 x float>* %459
%461 = getelementptr inbounds float, float* %458, i64 4
%462 = bitcast float* %461 to <4 x float>*
%463 = load <4 x float>, <4 x float>* %462
%464 = getelementptr inbounds float, float* %411, i64 %456
%465 = bitcast float* %464 to <4 x float>*
store <4 x float> %460, <4 x float>* %465
%466 = getelementptr inbounds float, float* %464, i64 4
%467 = bitcast float* %466 to <4 x float>*
store <4 x float> %463, <4 x float>* %467
%468 = add nuw i64 %419, 32
%469 = add i64 %420, 4
%470 = icmp eq i64 %469, %242
br i1 %470, label %471, label %418
471: ; preds = %418, %417
%472 = phi i64 [ 0, %417 ], [ %468, %418 ]
br i1 %243, label %490, label %473
473: ; preds = %471, %473
%474 = phi i64 [ %487, %473 ], [ %472, %471 ]
%475 = phi i64 [ %488, %473 ], [ 0, %471 ]
%476 = add nuw nsw i64 %474, %231
%477 = getelementptr inbounds float, float* %409, i64 %476
%478 = bitcast float* %477 to <4 x float>*
%479 = load <4 x float>, <4 x float>* %478
%480 = getelementptr inbounds float, float* %477, i64 4
%481 = bitcast float* %480 to <4 x float>*
%482 = load <4 x float>, <4 x float>* %481
%483 = getelementptr inbounds float, float* %411, i64 %474
%484 = bitcast float* %483 to <4 x float>*
store <4 x float> %479, <4 x float>* %484
%485 = getelementptr inbounds float, float* %483, i64 4
%486 = bitcast float* %485 to <4 x float>*
store <4 x float> %482, <4 x float>* %486
%487 = add nuw i64 %474, 8
%488 = add i64 %475, 1
%489 = icmp eq i64 %488, %240
br i1 %489, label %490, label %473
490: ; preds = %473, %471
br i1 %244, label %531, label %491
491: ; preds = %412, %406, %490
%492 = phi i64 [ 0, %412 ], [ 0, %406 ], [ %239, %490 ]
%493 = xor i64 %492, -1
%494 = add nsw i64 %493, %232
br i1 %246, label %505, label %495
495: ; preds = %491, %495
%496 = phi i64 [ %502, %495 ], [ %492, %491 ]
%497 = phi i64 [ %503, %495 ], [ 0, %491 ]
%498 = add nuw nsw i64 %496, %231
%499 = getelementptr inbounds float, float* %409, i64 %498
%500 = load float, float* %499
%501 = getelementptr inbounds float, float* %411, i64 %496
store float %500, float* %501
%502 = add nuw nsw i64 %496, 1
%503 = add i64 %497, 1
%504 = icmp eq i64 %503, %245
br i1 %504, label %505, label %495
505: ; preds = %495, %491
%506 = phi i64 [ %492, %491 ], [ %502, %495 ]
%507 = icmp ult i64 %494, 3
br i1 %507, label %531, label %508
508: ; preds = %505, %508
%509 = phi i64 [ %529, %508 ], [ %506, %505 ]
%510 = add nuw nsw i64 %509, %231
%511 = getelementptr inbounds float, float* %409, i64 %510
%512 = load float, float* %511
%513 = getelementptr inbounds float, float* %411, i64 %509
store float %512, float* %513
%514 = add nuw nsw i64 %509, 1
%515 = add nuw nsw i64 %514, %231
%516 = getelementptr inbounds float, float* %409, i64 %515
%517 = load float, float* %516
%518 = getelementptr inbounds float, float* %411, i64 %514
store float %517, float* %518
%519 = add nuw nsw i64 %509, 2
%520 = add nuw nsw i64 %519, %231
%521 = getelementptr inbounds float, float* %409, i64 %520
%522 = load float, float* %521
%523 = getelementptr inbounds float, float* %411, i64 %519
store float %522, float* %523
%524 = add nuw nsw i64 %509, 3
%525 = add nuw nsw i64 %524, %231
%526 = getelementptr inbounds float, float* %409, i64 %525
%527 = load float, float* %526
%528 = getelementptr inbounds float, float* %411, i64 %524
store float %527, float* %528
%529 = add nuw nsw i64 %509, 4
%530 = icmp eq i64 %529, %232
br i1 %530, label %531, label %508
531: ; preds = %505, %508, %490
%532 = add nuw nsw i64 %407, 1
%533 = icmp eq i64 %532, %232
br i1 %533, label %534, label %406
534: ; preds = %531, %136, %174, %229
%535 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.21, i64 0, i64 0))
%536 = load i32, i32* %1
%537 = call i32 @print2(float** %15, i32 %536)
%538 = load i32, i32* %1
%539 = icmp sgt i32 %538, 0
br i1 %539, label %548, label %596
540: ; preds = %548
%541 = icmp sgt i32 %557, 0
br i1 %541, label %542, label %596
542: ; preds = %540
%543 = zext i32 %557 to i64
%544 = and i64 %543, 1
%545 = icmp eq i32 %557, 1
%546 = and i64 %543, 4294967294
%547 = icmp eq i64 %544, 0
br label %560
548: ; preds = %534, %548
%549 = phi i64 [ %556, %548 ], [ 0, %534 ]
%550 = getelementptr inbounds float*, float** %14, i64 %549
%551 = load float*, float** %550
%552 = call i32 @free(float* %551)
%553 = load i32, i32* %1
%554 = call i64 @calloc(i32 %553, i32 4)
%555 = inttoptr i64 %554 to float*
store float* %555, float** %550
%556 = add nuw nsw i64 %549, 1
%557 = load i32, i32* %1
%558 = sext i32 %557 to i64
%559 = icmp slt i64 %556, %558
br i1 %559, label %548, label %540
560: ; preds = %593, %542
%561 = phi i64 [ 0, %542 ], [ %594, %593 ]
%562 = getelementptr inbounds float*, float** %15, i64 %561
%563 = load float*, float** %562
%564 = getelementptr inbounds float, float* %57, i64 %561
%565 = load float, float* %564
br i1 %545, label %584, label %566
566: ; preds = %560, %566
%567 = phi float [ %580, %566 ], [ %565, %560 ]
%568 = phi i64 [ %581, %566 ], [ 0, %560 ]
%569 = phi i64 [ %582, %566 ], [ 0, %560 ]
%570 = getelementptr inbounds float, float* %563, i64 %568
%571 = load float, float* %570
%572 = getelementptr inbounds float, float* %54, i64 %568
%573 = load float, float* %572
%574 = call float @llvm.fmuladd.f32(float %571, float %573, float %567)
store float %574, float* %564
%575 = or i64 %568, 1
%576 = getelementptr inbounds float, float* %563, i64 %575
%577 = load float, float* %576
%578 = getelementptr inbounds float, float* %54, i64 %575
%579 = load float, float* %578
%580 = call float @llvm.fmuladd.f32(float %577, float %579, float %574)
store float %580, float* %564
%581 = add nuw nsw i64 %568, 2
%582 = add i64 %569, 2
%583 = icmp eq i64 %582, %546
br i1 %583, label %584, label %566
584: ; preds = %566, %560
%585 = phi float [ %565, %560 ], [ %580, %566 ]
%586 = phi i64 [ 0, %560 ], [ %581, %566 ]
br i1 %547, label %593, label %587
587: ; preds = %584
%588 = getelementptr inbounds float, float* %563, i64 %586
%589 = load float, float* %588
%590 = getelementptr inbounds float, float* %54, i64 %586
%591 = load float, float* %590
%592 = call float @llvm.fmuladd.f32(float %589, float %591, float %585)
store float %592, float* %564
br label %593
593: ; preds = %584, %587
%594 = add nuw nsw i64 %561, 1
%595 = icmp eq i64 %594, %543
br i1 %595, label %596, label %560
596: ; preds = %593, %534, %540
%597 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.22, i64 0, i64 0))
%598 = load i32, i32* %1
%599 = call i32 @print1(float* %57, i32 %598)
%600 = load i32, i32* %1
%601 = icmp sgt i32 %600, 0
br i1 %601, label %602, label %657
602: ; preds = %596
%603 = zext i32 %600 to i64
%604 = and i64 %603, 1
%605 = icmp eq i32 %600, 1
%606 = and i64 %603, 4294967294
%607 = icmp eq i64 %604, 0
br label %608
608: ; preds = %654, %602
%609 = phi i64 [ 0, %602 ], [ %655, %654 ]
%610 = getelementptr inbounds float*, float** %15, i64 %609
%611 = getelementptr inbounds float*, float** %14, i64 %609
%612 = load float*, float** %610
%613 = load float*, float** %611
br label %614
614: ; preds = %651, %608
%615 = phi i64 [ 0, %608 ], [ %652, %651 ]
%616 = getelementptr inbounds float, float* %613, i64 %615
%617 = load float, float* %616
br i1 %605, label %640, label %618
618: ; preds = %614, %618
%619 = phi float [ %636, %618 ], [ %617, %614 ]
%620 = phi i64 [ %637, %618 ], [ 0, %614 ]
%621 = phi i64 [ %638, %618 ], [ 0, %614 ]
%622 = getelementptr inbounds float, float* %612, i64 %620
%623 = load float, float* %622
%624 = getelementptr inbounds float*, float** %13, i64 %620
%625 = load float*, float** %624
%626 = getelementptr inbounds float, float* %625, i64 %615
%627 = load float, float* %626
%628 = call float @llvm.fmuladd.f32(float %623, float %627, float %619)
store float %628, float* %616
%629 = or i64 %620, 1
%630 = getelementptr inbounds float, float* %612, i64 %629
%631 = load float, float* %630
%632 = getelementptr inbounds float*, float** %13, i64 %629
%633 = load float*, float** %632
%634 = getelementptr inbounds float, float* %633, i64 %615
%635 = load float, float* %634
%636 = call float @llvm.fmuladd.f32(float %631, float %635, float %628)
store float %636, float* %616
%637 = add nuw nsw i64 %620, 2
%638 = add i64 %621, 2
%639 = icmp eq i64 %638, %606
br i1 %639, label %640, label %618
640: ; preds = %618, %614
%641 = phi float [ %617, %614 ], [ %636, %618 ]
%642 = phi i64 [ 0, %614 ], [ %637, %618 ]
br i1 %607, label %651, label %643
643: ; preds = %640
%644 = getelementptr inbounds float, float* %612, i64 %642
%645 = load float, float* %644
%646 = getelementptr inbounds float*, float** %13, i64 %642
%647 = load float*, float** %646
%648 = getelementptr inbounds float, float* %647, i64 %615
%649 = load float, float* %648
%650 = call float @llvm.fmuladd.f32(float %645, float %649, float %641)
store float %650, float* %616
br label %651
651: ; preds = %640, %643
%652 = add nuw nsw i64 %615, 1
%653 = icmp eq i64 %652, %603
br i1 %653, label %654, label %614
654: ; preds = %651
%655 = add nuw nsw i64 %609, 1
%656 = icmp eq i64 %655, %603
br i1 %656, label %657, label %608
657: ; preds = %654, %596
%658 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.23, i64 0, i64 0))
%659 = load i32, i32* %1
%660 = call i32 @print2(float** %14, i32 %659)
br label %661
661: ; preds = %742, %657
%662 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.24, i64 0, i64 0))
%663 = load i32, i32* %1
%664 = call i32 @print1(float* %51, i32 %663)
%665 = load i32, i32* %1
%666 = icmp sgt i32 %665, 0
br i1 %666, label %667, label %742
667: ; preds = %661
%668 = zext i32 %665 to i64
%669 = add nsw i64 %668, -1
%670 = and i64 %668, 3
%671 = icmp ult i64 %669, 3
%672 = and i64 %668, 4294967292
%673 = icmp eq i64 %670, 0
br label %674
674: ; preds = %732, %667
%675 = phi i64 [ 0, %667 ], [ %740, %732 ]
%676 = phi float [ 0.000000e+00, %667 ], [ %739, %732 ]
%677 = getelementptr inbounds float, float* %57, i64 %675
%678 = load float, float* %677
%679 = getelementptr inbounds float*, float** %14, i64 %675
%680 = load float*, float** %679
br i1 %671, label %715, label %681
681: ; preds = %674, %681
%682 = phi i64 [ %712, %681 ], [ 0, %674 ]
%683 = phi float [ %711, %681 ], [ %678, %674 ]
%684 = phi i64 [ %713, %681 ], [ 0, %674 ]
%685 = getelementptr inbounds float, float* %680, i64 %682
%686 = load float, float* %685
%687 = getelementptr inbounds float, float* %51, i64 %682
%688 = load float, float* %687
%689 = fneg float %686
%690 = call float @llvm.fmuladd.f32(float %689, float %688, float %683)
%691 = or i64 %682, 1
%692 = getelementptr inbounds float, float* %680, i64 %691
%693 = load float, float* %692
%694 = getelementptr inbounds float, float* %51, i64 %691
%695 = load float, float* %694
%696 = fneg float %693
%697 = call float @llvm.fmuladd.f32(float %696, float %695, float %690)
%698 = or i64 %682, 2
%699 = getelementptr inbounds float, float* %680, i64 %698
%700 = load float, float* %699
%701 = getelementptr inbounds float, float* %51, i64 %698
%702 = load float, float* %701
%703 = fneg float %700
%704 = call float @llvm.fmuladd.f32(float %703, float %702, float %697)
%705 = or i64 %682, 3
%706 = getelementptr inbounds float, float* %680, i64 %705
%707 = load float, float* %706
%708 = getelementptr inbounds float, float* %51, i64 %705
%709 = load float, float* %708
%710 = fneg float %707
%711 = call float @llvm.fmuladd.f32(float %710, float %709, float %704)
%712 = add nuw nsw i64 %682, 4
%713 = add i64 %684, 4
%714 = icmp eq i64 %713, %672
br i1 %714, label %715, label %681
715: ; preds = %681, %674
%716 = phi float [ undef, %674 ], [ %711, %681 ]
%717 = phi i64 [ 0, %674 ], [ %712, %681 ]
%718 = phi float [ %678, %674 ], [ %711, %681 ]
br i1 %673, label %732, label %719
719: ; preds = %715, %719
%720 = phi i64 [ %729, %719 ], [ %717, %715 ]
%721 = phi float [ %728, %719 ], [ %718, %715 ]
%722 = phi i64 [ %730, %719 ], [ 0, %715 ]
%723 = getelementptr inbounds float, float* %680, i64 %720
%724 = load float, float* %723
%725 = getelementptr inbounds float, float* %51, i64 %720
%726 = load float, float* %725
%727 = fneg float %724
%728 = call float @llvm.fmuladd.f32(float %727, float %726, float %721)
%729 = add nuw nsw i64 %720, 1
%730 = add i64 %722, 1
%731 = icmp eq i64 %730, %670
br i1 %731, label %732, label %719
732: ; preds = %719, %715
%733 = phi float [ %716, %715 ], [ %728, %719 ]
%734 = getelementptr inbounds float, float* %51, i64 %675
%735 = load float, float* %734
%736 = fsub float %733, %735
%737 = call float @llvm.fabs.f32(float %736)
%738 = fcmp ogt float %737, %676
%739 = select i1 %738, float %737, float %676
store float %733, float* %734
%740 = add nuw nsw i64 %675, 1
%741 = icmp eq i64 %740, %668
br i1 %741, label %742, label %674
742: ; preds = %732, %661
%743 = phi float [ 0.000000e+00, %661 ], [ %739, %732 ]
%744 = fpext float %743 to double
%745 = fcmp ult double %744, 5.000000e-07
br i1 %745, label %746, label %661
746: ; preds = %742
%747 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.25, i64 0, i64 0))
%748 = load i32, i32* %1
%749 = call i32 @print1(float* %51, i32 %748)
%750 = call i32 @free(float* %51)
%751 = call i32 @free(float* %54)
%752 = call i32 @free(float* %57)
%753 = load i32, i32* %1
%754 = icmp sgt i32 %753, 0
br i1 %754, label %755, label %779
755: ; preds = %746, %755
%756 = phi i64 [ %775, %755 ], [ 0, %746 ]
%757 = getelementptr inbounds float*, float** %8, i64 %756
%758 = load float*, float** %757
%759 = call i32 @free(float* %758)
%760 = getelementptr inbounds float*, float** %12, i64 %756
%761 = load float*, float** %760
%762 = call i32 @free(float* %761)
%763 = getelementptr inbounds float*, float** %13, i64 %756
%764 = load float*, float** %763
%765 = call i32 @free(float* %764)
%766 = getelementptr inbounds float*, float** %11, i64 %756
%767 = load float*, float** %766
%768 = call i32 @free(float* %767)
%769 = getelementptr inbounds float*, float** %14, i64 %756
%770 = load float*, float** %769
%771 = call i32 @free(float* %770)
%772 = getelementptr inbounds float*, float** %15, i64 %756
%773 = load float*, float** %772
%774 = call i32 @free(float* %773)
%775 = add nuw nsw i64 %756, 1
%776 = load i32, i32* %1
%777 = sext i32 %776 to i64
%778 = icmp slt i64 %775, %777
br i1 %778, label %755, label %779
779: ; preds = %755, %746
ret i32 0
}