#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);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main(void) {
  int n, i, k, j, p;
  printf("Enter the order of the matrix\n");
  scanf("%d", &n);
  float a[n][n], b[n], sum;
  float *l[n], *u[n], *z, *x;
  z = (float *)calloc(n, sizeof(float));
  x = (float *)calloc(n, sizeof(float));
  for (i = 0; i < n; i++) {
    l[i] = (float *)calloc(n, sizeof(float));
    u[i] = (float *)calloc(n, sizeof(float));
  }
  printf("Enter all coefficients of matrix :\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      scanf("%f", &a[i][j]);
  }
  printf("Enter elements of B matrix :\n");
  for (i = 0; i < n; i++)
    scanf("%f", &b[i]);
  for (i = 0; i < n; i++) {
    u[i][i] = 1;
    l[i][0] = a[i][0];
  }
  for (j = 1; j < n; j++) {
    u[0][j] = a[0][j] / l[0][0];
  }
  for (i = 1; i < n; i++) {
    for (j = 1; j <= i; j++) {
      sum = 0;
      for (k = 0; k <= j - 1; k++) {
        sum += l[i][k] * u[k][j];
      }
      l[i][j] = a[i][j] - sum;
    }
    for (j = i + 1; j < n; j++) {
      sum = 0;
      for (k = 0; k <= i - 1; k++) {
        sum += l[i][k] * u[k][j];
      }
      u[i][j] = (a[i][j] - sum) / l[i][i];
    }
  }
  printf("L matrix is \n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      printf("\t%.6f\t", l[i][j]);
    printf("\n");
  }
  printf("\n");
  printf("U matrix is \n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      printf("\t%.6f\t", u[i][j]);
    printf("\n");
  }
  for (i = 0; i < n; i++) {
    sum = 0;
    for (p = 0; p < i; p++)
      sum += l[i][p] * z[p];
    z[i] = (b[i] - sum) / l[i][i];
  }
  for (i = n - 1; i >= 0; i--) {
    sum = 0;
    for (p = n - 1; p > i; p--)
      sum += u[i][p] * x[p];
    x[i] = (z[i] - sum) / u[i][i];
  }
  printf("Set of solution is:\n");
  for (i = 0; i < n; i++)
    printf("x[%d] = %.6f\n", i, x[i]);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xebb(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x89(%rbp)
call   1030 <printf@plt>
mov    -0x89(%rbp),%al
lea    0xec0(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %rax,-0x88(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%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,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1280 <main+0x150>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    122e <main+0xfe>
lea    0xd9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1308 <main+0x1d8>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12f5 <main+0x1c5>
mov    -0x80(%rbp),%rsi
mov    -0x88(%rbp),%rcx
movslq -0xc(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xd6a(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12a8 <main+0x178>
jmp    12fa <main+0x1ca>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1295 <main+0x165>
lea    0xd3e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1354 <main+0x224>
mov    -0x78(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xd0b(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    131d <main+0x1ed>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ba <main+0x28a>
mov    -0x70(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%rsi
mov    -0x68(%rbp),%rdx
movslq -0xc(%rbp),%rdi
mov    (%rdx,%rdi,8),%rdx
movslq -0xc(%rbp),%rdi
movss  0xc72(%rip),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    135b <main+0x22b>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1415 <main+0x2e5>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rsi
imul   $0x0,%rsi,%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
movslq -0x14(%rbp),%rsi
movss  (%rdx,%rsi,4),%xmm0
mov    (%rcx),%rcx
divss  (%rcx),%xmm0
mov    (%rax),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13c1 <main+0x291>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15e2 <main+0x4b2>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14f0 <main+0x3c0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14a5 <main+0x375>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    144a <main+0x31a>
mov    -0x70(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%rsi
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    142f <main+0x2ff>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15cf <main+0x49f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     156f <main+0x43f>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1514 <main+0x3e4>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rdi
movslq -0xc(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
movslq -0x14(%rbp),%rsi
movss  (%rdx,%rsi,4),%xmm0
subss  -0x3c(%rbp),%xmm0
movslq -0xc(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xc(%rbp),%rdx
divss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14f9 <main+0x3c9>
jmp    15d4 <main+0x4a4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    141c <main+0x2ec>
lea    0xa82(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1667 <main+0x537>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    164b <main+0x51b>
mov    -0x70(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa43(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    160a <main+0x4da>
lea    0xa25(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15f7 <main+0x4c7>
lea    0xa09(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16fa <main+0x5ca>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16de <main+0x5ae>
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9b0(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    169d <main+0x56d>
lea    0x992(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    168a <main+0x55a>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17ac <main+0x67c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    176a <main+0x63a>
mov    -0x70(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    171c <main+0x5ec>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1701 <main+0x5d1>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     1860 <main+0x730>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    181e <main+0x6ee>
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    17d0 <main+0x6a0>
mov    -0x68(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0xc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    17b5 <main+0x685>
lea    0x827(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18b1 <main+0x781>
mov    -0xc(%rbp),%esi
mov    -0x60(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x807(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1875 <main+0x745>
lea    0x7bf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
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    $0x58,%rsp
lea    0xeb3(%rip),%rdi
call   1040 <puts@plt>
lea    0xe8c(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rsp,-0x80(%rbp)
mov    -0x2c(%rbp),%eax
mov    %rax,-0x50(%rbp)
imul   %rax,%rax
mov    %rsp,%rcx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    -0x2c(%rbp),%edi
mov    %rsp,%rcx
lea    0xf(,%rdi,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rsp,%r14
lea    0xf(,%rdi,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x2c(%rbp),%edi
test   %edi,%edi
jle    123d <main+0xed>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,(%r14,%rbx,8)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
movslq -0x2c(%rbp),%rdi
cmp    %rdi,%rbx
jl     1210 <main+0xc0>
mov    %r14,-0x40(%rbp)
lea    0xdf1(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    12c4 <main+0x174>
mov    -0x50(%rbp),%rcx
lea    0x0(,%rcx,4),%rcx
mov    %rcx,-0x60(%rbp)
lea    0xd98(%rip),%r12
mov    -0x38(%rbp),%rbx
xor    %r15d,%r15d
jmp    1290 <main+0x140>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %eax,%rcx
add    $0x1,%r15
add    -0x60(%rbp),%rbx
cmp    %rcx,%r15
jge    12c4 <main+0x174>
test   %eax,%eax
jle    1280 <main+0x130>
mov    %rbx,-0x58(%rbp)
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%rax
add    $0x4,%rbx
cmp    %rax,%r14
jl     12a0 <main+0x150>
mov    -0x58(%rbp),%rbx
jmp    1280 <main+0x130>
lea    0xd91(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,-0x2c(%rbp)
jle    1770 <main+0x620>
lea    0xd22(%rip),%r12
mov    -0x68(%rbp),%r14
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
add    $0x4,%r14
cmp    %rax,%rbx
jl     12f0 <main+0x1a0>
mov    %eax,%ecx
test   %ecx,%ecx
jle    1770 <main+0x620>
cmp    $0x1,%ecx
mov    %rcx,-0x48(%rbp)
jne    1331 <main+0x1e1>
xor    %eax,%eax
mov    -0x40(%rbp),%rbx
mov    -0x50(%rbp),%r8
mov    -0x38(%rbp),%r9
jmp    1390 <main+0x240>
and    $0xfffffffe,%ecx
mov    -0x50(%rbp),%r8
lea    0x0(,%r8,8),%rdx
xor    %eax,%eax
mov    -0x38(%rbp),%r9
mov    %r9,%rsi
mov    -0x40(%rbp),%rbx
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rdi
movl   $0x3f800000,(%rdi,%rax,4)
movss  (%rsi),%xmm0
mov    (%rbx,%rax,8),%rdi
movss  %xmm0,(%rdi)
mov    0x8(%r13,%rax,8),%rdi
movl   $0x3f800000,0x4(%rdi,%rax,4)
3f
movss  (%rsi,%r8,4),%xmm0
mov    0x8(%rbx,%rax,8),%rdi
movss  %xmm0,(%rdi)
add    $0x2,%rax
add    %rdx,%rsi
cmp    %rax,%rcx
jne    1350 <main+0x200>
testb  $0x1,-0x48(%rbp)
je     13b7 <main+0x267>
mov    0x0(%r13,%rax,8),%rcx
movl   $0x3f800000,(%rcx,%rax,4)
mov    %rax,%rcx
imul   %r8,%rcx
movss  (%r9,%rcx,4),%xmm0
mov    (%rbx,%rax,8),%rax
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rsi
cmp    $0x2,%esi
jl     1770 <main+0x620>
mov    -0x40(%rbp),%rax
mov    (%rax),%r11
mov    0x0(%r13),%rcx
lea    -0x1(%rsi),%r9
mov    $0x1,%edx
cmp    $0x4,%r9
jae    143e <main+0x2ee>
mov    -0x38(%rbp),%rax
mov    %rdx,%rsi
not    %rsi
mov    -0x48(%rbp),%rdi
test   $0x1,%dil
jne    1405 <main+0x2b5>
movss  (%rax,%rdx,4),%xmm0
divss  (%r11),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%rdx
add    %rdi,%rsi
je     1503 <main+0x3b3>
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
divss  (%r11),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
divss  (%r11),%xmm0
movss  %xmm0,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rdi
jne    1410 <main+0x2c0>
jmp    1503 <main+0x3b3>
lea    0x4(%rcx),%r8
lea    (%rcx,%rsi,4),%rdi
mov    -0x38(%rbp),%rax
lea    0x4(%rax),%rbx
lea    (%rax,%rsi,4),%rsi
cmp    %rsi,%r8
setb   %r8b
cmp    %rdi,%rbx
setb   %r10b
cmp    %r11,%rcx
setb   %bl
cmp    %rdi,%r11
setb   %sil
test   %r10b,%r8b
jne    13e2 <main+0x292>
and    %sil,%bl
jne    13e2 <main+0x292>
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     1aeb <main+0x99b>
mov    %rsi,%rbx
and    $0xfffffffffffffffe,%rbx
movss  (%r11),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %edi,%edi
movups 0x4(%rax,%rdi,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,0x4(%rcx,%rdi,4)
movups 0x14(%rax,%rdi,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,0x14(%rcx,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    14b0 <main+0x360>
test   $0x1,%sil
je     14f6 <main+0x3a6>
shl    $0x2,%rdi
or     $0x4,%rdi
movups (%rax,%rdi,1),%xmm0
movss  (%r11),%xmm1
shufps $0x0,%xmm1,%xmm1
divps  %xmm1,%xmm0
movups %xmm0,(%rcx,%rdi,1)
cmp    %rdx,%r9
mov    -0x48(%rbp),%rdi
jne    1ae2 <main+0x992>
cmp    $0x2,%edi
jl     1770 <main+0x620>
mov    $0x2,%r11d
mov    $0x1,%r12d
xor    %eax,%eax
mov    %rax,-0x58(%rbp)
jmp    1536 <main+0x3e6>
add    $0x1,%r11
addq   $0x1,-0x58(%rbp)
mov    -0x60(%rbp),%r12
cmp    %r9,%r12
je     1770 <main+0x620>
mov    %r12d,%r15d
and    $0x3,%r15d
mov    %r12,%r14
and    $0xfffffffffffffffc,%r14
mov    -0x40(%rbp),%rax
mov    (%rax,%r12,8),%rax
mov    %r12,%rcx
imul   -0x50(%rbp),%rcx
mov    -0x38(%rbp),%rdx
lea    (%rdx,%rcx,4),%r10
xor    %r9d,%r9d
mov    $0x1,%ebx
jmp    1590 <main+0x440>
cs nopw 0x0(%rax,%rax,1)
movss  (%r10,%rbx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0x1,%r9
cmp    %r11,%rbx
je     1660 <main+0x510>
cmp    $0x3,%r9
jae    15a0 <main+0x450>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1608 <main+0x4b8>
nopl   (%rax)
mov    %rbx,%rsi
and    $0xfffffffffffffffc,%rsi
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm1
movss  0x4(%rax,%rdx,4),%xmm2
mov    0x0(%r13,%rdx,8),%rdi
mov    0x8(%r13,%rdx,8),%rcx
mulss  (%rdi,%rbx,4),%xmm1
addss  %xmm0,%xmm1
mulss  (%rcx,%rbx,4),%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rax,%rdx,4),%xmm1
mov    0x10(%r13,%rdx,8),%rcx
mulss  (%rcx,%rbx,4),%xmm1
movss  0xc(%rax,%rdx,4),%xmm0
mov    0x18(%r13,%rdx,8),%rcx
mulss  (%rcx,%rbx,4),%xmm0
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    15b0 <main+0x460>
test   $0x3,%bl
je     1570 <main+0x420>
mov    %ebx,%esi
and    $0x3,%esi
lea    0x0(,%rdx,8),%rdi
add    %r13,%rdi
lea    (%rax,%rdx,4),%rdx
xor    %r8d,%r8d
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%r8,4),%xmm1
mov    (%rdi,%r8,8),%rcx
mulss  (%rcx,%rbx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%r8
cmp    %r8,%rsi
jne    1630 <main+0x4e0>
jmp    1570 <main+0x420>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%rcx
mov    -0x48(%rbp),%r9
mov    %rcx,-0x60(%rbp)
cmp    %r9,%rcx
jae    1520 <main+0x3d0>
mov    0x0(%r13,%r12,8),%r8
mov    %r11,%rbx
jmp    16a3 <main+0x553>
movss  (%r10,%rbx,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rax,%r12,4),%xmm1
movss  %xmm1,(%r8,%rbx,4)
add    $0x1,%rbx
cmp    %r9,%rbx
je     1520 <main+0x3d0>
cmpq   $0x3,-0x58(%rbp)
jae    16c0 <main+0x570>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1728 <main+0x5d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%rdx,4),%xmm1
movss  0x4(%rax,%rdx,4),%xmm2
mov    0x0(%r13,%rdx,8),%rsi
mov    0x8(%r13,%rdx,8),%rdi
mulss  (%rsi,%rbx,4),%xmm1
addss  %xmm0,%xmm1
mulss  (%rdi,%rbx,4),%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rax,%rdx,4),%xmm1
mov    0x10(%r13,%rdx,8),%rsi
mulss  (%rsi,%rbx,4),%xmm1
movss  0xc(%rax,%rdx,4),%xmm0
mov    0x18(%r13,%rdx,8),%rsi
mulss  (%rsi,%rbx,4),%xmm0
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r14
jne    16d0 <main+0x580>
test   $0x3,%r12b
je     1680 <main+0x530>
lea    0x0(,%rdx,8),%rsi
add    %r13,%rsi
lea    (%rax,%rdx,4),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rdi,4),%xmm1
mov    (%rsi,%rdi,8),%rcx
mulss  (%rcx,%rbx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%r15
jne    1750 <main+0x600>
jmp    1680 <main+0x530>
lea    0x902(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    17e3 <main+0x693>
xor    %r14d,%r14d
lea    0x879(%rip),%r15
jmp    17a7 <main+0x657>
nop
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%rax
cmp    %rax,%r14
jge    17e3 <main+0x693>
test   %eax,%eax
jle    1790 <main+0x640>
mov    -0x40(%rbp),%rax
mov    (%rax,%r14,8),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     17c0 <main+0x670>
jmp    1790 <main+0x640>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x892(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
mov    -0x70(%rbp),%r14
jle    1a82 <main+0x932>
xor    %r14d,%r14d
lea    0x7f2(%rip),%r15
jmp    1837 <main+0x6e7>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%r9
cmp    %r9,%r14
jge    1873 <main+0x723>
test   %r9d,%r9d
jle    1820 <main+0x6d0>
mov    0x0(%r13,%r14,8),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1850 <main+0x700>
jmp    1820 <main+0x6d0>
test   %r9d,%r9d
mov    -0x70(%rbp),%r14
mov    -0x78(%rbp),%r11
jle    1a82 <main+0x932>
mov    %r9d,%r8d
xor    %edx,%edx
mov    -0x68(%rbp),%r10
mov    -0x40(%rbp),%r15
jmp    18c8 <main+0x778>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15),%rsi
xorps  %xmm0,%xmm0
movss  (%r10,%rdx,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rsi,%rdx,4),%xmm1
movss  %xmm1,(%r11,%rdx,4)
add    $0x1,%rdx
cmp    %r8,%rdx
je     198c <main+0x83c>
test   %rdx,%rdx
je     18a0 <main+0x750>
lea    -0x1(%rdx),%rax
mov    (%r15,%rdx,8),%rsi
cmp    $0x3,%rax
jae    18f0 <main+0x7a0>
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    194b <main+0x7fb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
xorps  %xmm0,%xmm0
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
movss  0x4(%rsi,%rax,4),%xmm2
mulss  (%r11,%rax,4),%xmm1
mulss  0x4(%r11,%rax,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rsi,%rax,4),%xmm3
mulss  0x8(%r11,%rax,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rsi,%rax,4),%xmm0
mulss  0xc(%r11,%rax,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rax
cmp    %rax,%rdi
jne    1900 <main+0x7b0>
test   $0x3,%dl
je     18a6 <main+0x756>
mov    %edx,%edi
and    $0x3,%edi
lea    (%r11,%rax,4),%rbx
lea    (%rsi,%rax,4),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rcx,4),%xmm1
mulss  (%rbx,%rcx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1970 <main+0x820>
jmp    18a6 <main+0x756>
test   %r9d,%r9d
jle    1a82 <main+0x932>
xor    %ebx,%ebx
mov    %r8,%r10
jmp    19c4 <main+0x874>
nopl   0x0(%rax)
movss  (%r11,%r10,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rdi,%r10,4),%xmm1
movss  %xmm1,(%r14,%r10,4)
add    $0x1,%rbx
cmp    $0x1,%rsi
jle    1a82 <main+0x932>
mov    %r10,%rsi
add    $0xffffffffffffffff,%r10
mov    -0x8(%r13,%rsi,8),%rdi
xorps  %xmm0,%xmm0
cmp    %r8,%rsi
jge    19a0 <main+0x850>
lea    -0x1(%rbx),%r9
test   $0x3,%bl
je     1a16 <main+0x8c6>
mov    %ebx,%ecx
and    $0x3,%ecx
xorps  %xmm0,%xmm0
mov    %r8,%rdx
nopl   0x0(%rax)
lea    -0x1(%rdx),%rax
movss  -0x4(%rdi,%rdx,4),%xmm1
mulss  -0x4(%r14,%rdx,4),%xmm1
addss  %xmm1,%xmm0
mov    %rax,%rdx
add    $0xffffffffffffffff,%rcx
jne    19f0 <main+0x8a0>
cmp    $0x3,%r9
jae    1a30 <main+0x8e0>
jmp    19a0 <main+0x850>
xorps  %xmm0,%xmm0
mov    %r8,%rax
cmp    $0x3,%r9
jb     19a0 <main+0x850>
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rdi,%rax,4),%xmm1
mulss  -0x4(%r14,%rax,4),%xmm1
movss  -0x8(%rdi,%rax,4),%xmm2
mulss  -0x8(%r14,%rax,4),%xmm2
addss  %xmm0,%xmm1
addss  %xmm1,%xmm2
movss  -0x10(%rdi,%rax,4),%xmm0
movss  -0xc(%rdi,%rax,4),%xmm1
mulss  -0xc(%r14,%rax,4),%xmm1
mulss  -0x10(%r14,%rax,4),%xmm0
addss  %xmm2,%xmm1
add    $0xfffffffffffffffc,%rax
addss  %xmm1,%xmm0
cmp    %rsi,%rax
jg     1a30 <main+0x8e0>
jmp    19a0 <main+0x850>
lea    0x60a(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,-0x2c(%rbp)
jle    1ac3 <main+0x973>
xor    %ebx,%ebx
lea    0x570(%rip),%r15
nopl   (%rax)
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1aa0 <main+0x950>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x80(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rdx
jmp    13e2 <main+0x292>
xor    %edi,%edi
test   $0x1,%sil
jne    14da <main+0x38a>
jmp    14f6 <main+0x3a6>

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

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