#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 */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  float mat[100][100], low[100][100], U[100][100], B[100], Y[100], X[100];
  float sum = 0;
  int n, i, j, k, p;
  printf("\n\tenter the size of the matrix: ");
  scanf("%d", &n);
  printf("\nenter the coefficient matrix: \n\n");
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      scanf("%f", &mat[i][j]);
  for (j = 0; j < n; j++) {
    for (i = 0; i < n; i++) {
      if (i >= j) {
        low[i][j] = mat[i][j];
        for (k = 0; k <= j - 1; k++)
          low[i][j] -= low[i][k] * U[k][j];
        if (i == j)
          U[i][j] = 1;
      } else {
        U[i][j] = mat[i][j];
        for (k = 0; k <= i - 1; k++)
          U[i][j] -= low[i][k] * U[k][j];
        U[i][j] /= low[i][i];
      }
    }
  }
  printf("\nL matrix:");
  for (i = 0; i < n; i++) {
    printf("\n\t");
    for (j = 0; j < n; j++)
      printf("%f ", low[i][j]);
  }
  printf("\n\n");
  printf("\nU matrix:");
  for (i = 0; i < n; i++) {
    printf("\n\t");
    for (j = 0; j < n; j++)
      printf("%f ", U[i][j]);
  }
  printf("\nenter the constant terms\n");
  for (i = 0; i < n; i++)
    scanf("%f", &B[i]);
  for (i = 0; i < n; i++) {
    Y[i] = B[i];
    for (j = 0; j < i; j++) {
      Y[i] -= low[i][j] * Y[j];
    }
    Y[i] /= low[i][i];
  }
  printf("\n[Y]:");
  for (i = 0; i < n; i++)
    printf("\n\t%f ", Y[i]);
  for (i = n - 1; i >= 0; i--) {
    X[i] = Y[i];
    for (j = i + 1; j < n; j++)
      X[i] -= U[i][j] * X[j];
  }
  printf("\n\t So the result will be: \n");
  for (i = 0; i < n; i++)
    printf("\n\t%f ", X[i]);
  printf("\n\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d9a0,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1d984(%rbp)
ff
lea    0xec0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xed3(%rip),%rdi
lea    -0x1d988(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xec1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1207 <main+0xe7>
movl   $0x0,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    11ee <main+0xce>
movslq -0x1d98c(%rbp),%rax
lea    -0x9c50(%rbp),%rsi
imul   $0x190,%rax,%rax
add    %rax,%rsi
movslq -0x1d990(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe77(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    1194 <main+0x74>
jmp    11f3 <main+0xd3>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    1178 <main+0x58>
movl   $0x0,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    151f <main+0x3ff>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1506 <main+0x3e6>
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d990(%rbp),%eax
jl     1398 <main+0x278>
movslq -0x1d98c(%rbp),%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x1d994(%rbp)
mov    -0x1d994(%rbp),%eax
mov    -0x1d990(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1355 <main+0x235>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d994(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d994(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%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    -0x1d994(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d994(%rbp)
jmp    12a3 <main+0x183>
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d990(%rbp),%eax
jne    1393 <main+0x273>
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  0xc72(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    14ed <main+0x3cd>
movslq -0x1d98c(%rbp),%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x1d994(%rbp)
mov    -0x1d994(%rbp),%eax
mov    -0x1d98c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     149c <main+0x37c>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d994(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d994(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%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    -0x1d994(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d994(%rbp)
jmp    13ea <main+0x2ca>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d98c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    14f2 <main+0x3d2>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    122d <main+0x10d>
jmp    150b <main+0x3eb>
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    1211 <main+0xf1>
lea    0xb27(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    15d6 <main+0x4b6>
lea    0xb08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    15bd <main+0x49d>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xae7(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    1561 <main+0x441>
jmp    15c2 <main+0x4a2>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    1537 <main+0x417>
lea    0xa6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa70(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    169b <main+0x57b>
lea    0xa43(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1682 <main+0x562>
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa22(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    1626 <main+0x506>
jmp    1687 <main+0x567>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    15fc <main+0x4dc>
lea    0x9c4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    16fc <main+0x5dc>
movslq -0x1d98c(%rbp),%rax
lea    -0x1d660(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0x969(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    16b3 <main+0x593>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1820 <main+0x700>
movslq -0x1d98c(%rbp),%rax
movss  -0x1d660(%rbp,%rax,4),%xmm0
fe ff
movslq -0x1d98c(%rbp),%rax
movss  %xmm0,-0x1d7f0(%rbp,%rax,4)
fe ff
movl   $0x0,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d98c(%rbp),%eax
jge    17cb <main+0x6ab>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d990(%rbp),%rax
movss  -0x1d7f0(%rbp,%rax,4),%xmm2
fe ff
movslq -0x1d98c(%rbp),%rax
movss  -0x1d7f0(%rbp,%rax,4),%xmm1
fe ff
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1d7f0(%rbp,%rax,4)
fe ff
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    1742 <main+0x622>
movslq -0x1d98c(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d98c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movslq -0x1d98c(%rbp),%rax
movss  -0x1d7f0(%rbp,%rax,4),%xmm0
fe ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x1d7f0(%rbp,%rax,4)
fe ff
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    1706 <main+0x5e6>
lea    0x85a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1880 <main+0x760>
movslq -0x1d98c(%rbp),%rax
movss  -0x1d7f0(%rbp,%rax,4),%xmm0
fe ff
cvtss2sd %xmm0,%xmm0
lea    0x822(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    1838 <main+0x718>
mov    -0x1d988(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
cmpl   $0x0,-0x1d98c(%rbp)
jl     196d <main+0x84d>
movslq -0x1d98c(%rbp),%rax
movss  -0x1d7f0(%rbp,%rax,4),%xmm0
fe ff
movslq -0x1d98c(%rbp),%rax
movss  %xmm0,-0x1d980(%rbp,%rax,4)
fe ff
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
mov    -0x1d990(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    1954 <main+0x834>
movslq -0x1d98c(%rbp),%rcx
lea    -0x1d4d0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1d990(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x1d990(%rbp),%rax
movss  -0x1d980(%rbp,%rax,4),%xmm2
fe ff
movslq -0x1d98c(%rbp),%rax
movss  -0x1d980(%rbp,%rax,4),%xmm1
fe ff
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1d980(%rbp,%rax,4)
fe ff
mov    -0x1d990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d990(%rbp)
jmp    18cb <main+0x7ab>
jmp    1959 <main+0x839>
mov    -0x1d98c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    188f <main+0x76f>
lea    0x719(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d98c(%rbp)
mov    -0x1d98c(%rbp),%eax
cmp    -0x1d988(%rbp),%eax
jge    19cd <main+0x8ad>
movslq -0x1d98c(%rbp),%rax
movss  -0x1d980(%rbp,%rax,4),%xmm0
fe ff
cvtss2sd %xmm0,%xmm0
lea    0x6d5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1d98c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d98c(%rbp)
jmp    1985 <main+0x865>
lea    0x673(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1d9a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d980,%rsp
lea    0xeb9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xecc(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
lea    0xee4(%rip),%rdi
call   1030 <puts@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    13e5 <main+0x2b5>
lea    0x13d40(%rsp),%r15
lea    0xe9c(%rip),%r14
xor    %r12d,%r12d
jmp    11a3 <main+0x73>
nopl   (%rax)
movslq %eax,%rcx
add    $0x1,%r12
add    $0x190,%r15
cmp    %rcx,%r12
jge    11d1 <main+0xa1>
test   %eax,%eax
jle    1190 <main+0x60>
mov    %r15,%r13
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%r13
cmp    %rax,%rbx
jl     11b0 <main+0x80>
jmp    1190 <main+0x60>
test   %eax,%eax
jle    13e5 <main+0x2b5>
mov    %eax,%r11d
lea    0x4c0(%rsp),%r10
lea    0xa104(%rsp),%r8
xor    %r15d,%r15d
jmp    1211 <main+0xe1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
add    $0x4,%r10
cmp    %r11,%r15
je     13e5 <main+0x2b5>
mov    %r15,%r14
and    $0xfffffffffffffffe,%r14
imul   $0x190,%r15,%rax
add    %rsp,%rax
add    $0x4c0,%rax
lea    (%rax,%r15,4),%r9
mov    %r8,%rdx
xor    %esi,%esi
jmp    1264 <main+0x134>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsp,%r12,1),%rcx
add    $0xa100,%rcx
divss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax)
add    $0x1,%rsi
add    $0x190,%rdx
cmp    %r11,%rsi
je     1200 <main+0xd0>
imul   $0x190,%rsi,%r12
lea    (%rsp,%r12,1),%rax
add    $0x13d40,%rax
movss  (%rax,%r15,4),%xmm0
cmp    %r15,%rsi
jae    12b0 <main+0x180>
lea    (%rsp,%r12,1),%rcx
add    $0x4c0,%rcx
lea    (%rcx,%r15,4),%rax
movss  %xmm0,(%rcx,%r15,4)
test   %rsi,%rsi
je     1240 <main+0x110>
cmp    $0x1,%rsi
jne    1356 <main+0x226>
xor    %edi,%edi
jmp    13a7 <main+0x277>
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%r12,1),%rcx
add    $0xa100,%rcx
movss  %xmm0,(%rcx,%r15,4)
test   %r15,%r15
je     1341 <main+0x211>
lea    (%rcx,%r15,4),%rax
cmp    $0x1,%r15
jne    12d4 <main+0x1a4>
xor    %edi,%edi
jmp    1317 <main+0x1e7>
mov    %r10,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movss  -0x4(%rdx,%rdi,4),%xmm1
mulss  (%rbx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  (%rdx,%rdi,4),%xmm1
mulss  0x190(%rbx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
add    $0x2,%rdi
add    $0x320,%rbx
cmp    %rdi,%r14
jne    12e0 <main+0x1b0>
test   $0x1,%r15b
je     1341 <main+0x211>
movss  (%rcx,%rdi,4),%xmm1
imul   $0x190,%rdi,%rcx
add    %rsp,%rcx
add    $0x4c0,%rcx
mulss  (%rcx,%r15,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
cmp    %r15,%rsi
jne    1254 <main+0x124>
movl   $0x3f800000,(%r9)
jmp    1254 <main+0x124>
mov    %rsi,%rbx
and    $0xfffffffffffffffe,%rbx
mov    %r10,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rdx,%rdi,4),%xmm1
mulss  (%rcx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  (%rdx,%rdi,4),%xmm1
mulss  0x190(%rcx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
add    $0x2,%rdi
add    $0x320,%rcx
cmp    %rdi,%rbx
jne    1370 <main+0x240>
test   $0x1,%sil
je     1240 <main+0x110>
lea    (%rsp,%r12,1),%rcx
add    $0xa100,%rcx
movss  (%rcx,%rdi,4),%xmm1
imul   $0x190,%rdi,%rcx
add    %rsp,%rcx
add    $0x4c0,%rcx
mulss  (%rcx,%r15,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    1240 <main+0x110>
lea    0xc3b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1475 <main+0x345>
lea    0xa100(%rsp),%r13
lea    0xc29(%rip),%r14
lea    0xc38(%rip),%r15
xor    %r12d,%r12d
jmp    1432 <main+0x302>
cs nopw 0x0(%rax,%rax,1)
nop
cltq
add    $0x1,%r12
add    $0x190,%r13
cmp    %rax,%r12
jge    1475 <main+0x345>
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1420 <main+0x2f0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1450 <main+0x320>
jmp    1420 <main+0x2f0>
lea    0xbef(%rip),%rdi
call   1030 <puts@plt>
lea    0xbad(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1515 <main+0x3e5>
lea    0x4c0(%rsp),%r13
lea    0xb8d(%rip),%r14
lea    0xb9c(%rip),%r15
xor    %r12d,%r12d
jmp    14d2 <main+0x3a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cltq
add    $0x1,%r12
add    $0x190,%r13
cmp    %rax,%r12
jge    1515 <main+0x3e5>
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    14c0 <main+0x390>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     14f0 <main+0x3c0>
jmp    14c0 <main+0x390>
lea    0xb51(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    1648 <main+0x518>
lea    0x330(%rsp),%r15
lea    0xae9(%rip),%r14
xor    %ebx,%ebx
nopl   (%rax)
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%r15
cmp    %rax,%rbx
jl     1540 <main+0x410>
mov    %eax,%eax
test   %eax,%eax
jle    1648 <main+0x518>
lea    0xa104(%rsp),%rcx
xor    %edx,%edx
jmp    15b0 <main+0x480>
cs nopw 0x0(%rax,%rax,1)
nop
imul   $0x190,%rdx,%rsi
add    %rsp,%rsi
add    $0xa100,%rsi
divss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rdx,4)
add    $0x1,%rdx
add    $0x190,%rcx
cmp    %rax,%rdx
je     1648 <main+0x518>
movss  0x330(%rsp,%rdx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rdx,4)
test   %rdx,%rdx
je     1580 <main+0x450>
cmp    $0x1,%rdx
jne    15d0 <main+0x4a0>
xor    %esi,%esi
jmp    1614 <main+0x4e4>
xchg   %ax,%ax
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movss  -0x4(%rcx,%rsi,4),%xmm1
mulss  0x10(%rsp,%rsi,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp,%rdx,4)
movss  (%rcx,%rsi,4),%xmm1
mulss  0x14(%rsp,%rsi,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp,%rdx,4)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    15e0 <main+0x4b0>
test   $0x1,%dl
je     1580 <main+0x450>
imul   $0x190,%rdx,%rdi
add    %rsp,%rdi
add    $0xa100,%rdi
movss  (%rdi,%rsi,4),%xmm1
mulss  0x10(%rsp,%rsi,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp,%rdx,4)
jmp    1580 <main+0x450>
lea    0x9f1(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1784 <main+0x654>
xor    %ebx,%ebx
lea    0x9dc(%rip),%r14
nopw   0x0(%rax,%rax,1)
movss  0x10(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1670 <main+0x540>
mov    %eax,%eax
test   %eax,%eax
jle    1784 <main+0x654>
lea    0x4c4(%rsp),%r8
lea    -0x1(%rax),%edx
xor    %esi,%esi
mov    %rax,%r9
jmp    16c0 <main+0x590>
xchg   %ax,%ax
add    $0x1,%esi
add    $0xffffffff,%edx
cmp    $0x2,%r10
jl     1784 <main+0x654>
mov    %r9,%r10
add    $0xffffffffffffffff,%r9
mov    %r9d,%ecx
movss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x1a0(%rsp,%rcx,4)
cmp    %rax,%r10
jge    16b0 <main+0x580>
test   $0x1,%sil
jne    16f0 <main+0x5c0>
mov    %r10,%rdi
cmp    $0x1,%esi
je     16b0 <main+0x580>
jmp    1727 <main+0x5f7>
xchg   %ax,%ax
imul   $0x190,%rcx,%rdi
add    %rsp,%rdi
add    $0x4c0,%rdi
movss  (%rdi,%r10,4),%xmm1
mulss  0x1a0(%rsp,%r10,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x1a0(%rsp,%rcx,4)
lea    0x1(%r10),%rdi
cmp    $0x1,%esi
je     16b0 <main+0x580>
mov    %edx,%ebx
imul   $0x190,%rbx,%rbx
add    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rbx,%rdi,4),%xmm1
mulss  0x1a0(%rsp,%rdi,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x1a0(%rsp,%rcx,4)
movss  (%rbx,%rdi,4),%xmm1
mulss  0x1a4(%rsp,%rdi,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x1a0(%rsp,%rcx,4)
add    $0x2,%rdi
cmp    %edi,%eax
jne    1740 <main+0x610>
jmp    16b0 <main+0x580>
lea    0x8fc(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    17c5 <main+0x695>
xor    %ebx,%ebx
lea    0x8a6(%rip),%r14
movss  0x1a0(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     17a0 <main+0x670>
lea    0x89f(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x1d980,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [33 x i8] c"\0A\09enter the size of the matrix: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [34 x i8] c"\0Aenter the coefficient matrix: \0A\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [11 x i8] c"\0AL matrix:\00"
@.str.5 = [3 x i8] c"\0A\09\00"
@.str.6 = [4 x i8] c"%f \00"
@.str.7 = [3 x i8] c"\0A\0A\00"
@.str.8 = [11 x i8] c"\0AU matrix:\00"
@.str.9 = [27 x i8] c"\0Aenter the constant terms\0A\00"
@.str.10 = [6 x i8] c"\0A[Y]:\00"
@.str.11 = [6 x i8] c"\0A\09%f \00"
@.str.12 = [28 x i8] c"\0A\09 So the result will be: \0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x [100 x float]]
%3 = alloca [100 x [100 x float]]
%4 = alloca [100 x [100 x float]]
%5 = alloca [100 x float]
%6 = alloca [100 x float]
%7 = alloca [100 x float]
%8 = alloca float
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32 0, i32* %1
store float 0.000000e+00, float* %8
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%15 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %9)
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %10
br label %17
17: ; preds = %38, %0
%18 = load i32, i32* %10
%19 = load i32, i32* %9
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %41
21: ; preds = %17
store i32 0, i32* %11
br label %22
22: ; preds = %34, %21
%23 = load i32, i32* %11
%24 = load i32, i32* %9
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %37
26: ; preds = %22
%27 = load i32, i32* %10
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %28
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [100 x float], [100 x float]* %29, i64 0, i64 %31
%33 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %32)
br label %34
34: ; preds = %26
%35 = load i32, i32* %11
%36 = add nsw i32 %35, 1
store i32 %36, i32* %11
br label %22
37: ; preds = %22
br label %38
38: ; preds = %37
%39 = load i32, i32* %10
%40 = add nsw i32 %39, 1
store i32 %40, i32* %10
br label %17
41: ; preds = %17
store i32 0, i32* %11
br label %42
42: ; preds = %180, %41
%43 = load i32, i32* %11
%44 = load i32, i32* %9
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %183
46: ; preds = %42
store i32 0, i32* %10
br label %47
47: ; preds = %176, %46
%48 = load i32, i32* %10
%49 = load i32, i32* %9
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %179
51: ; preds = %47
%52 = load i32, i32* %10
%53 = load i32, i32* %11
%54 = icmp sge i32 %52, %53
br i1 %54, label %55, label %113
55: ; preds = %51
%56 = load i32, i32* %10
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %57
%59 = load i32, i32* %11
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [100 x float], [100 x float]* %58, i64 0, i64 %60
%62 = load float, float* %61
%63 = load i32, i32* %10
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %64
%66 = load i32, i32* %11
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [100 x float], [100 x float]* %65, i64 0, i64 %67
store float %62, float* %68
store i32 0, i32* %12
br label %69
69: ; preds = %98, %55
%70 = load i32, i32* %12
%71 = load i32, i32* %11
%72 = sub nsw i32 %71, 1
%73 = icmp sle i32 %70, %72
br i1 %73, label %74, label %101
74: ; preds = %69
%75 = load i32, i32* %10
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %76
%78 = load i32, i32* %12
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [100 x float], [100 x float]* %77, i64 0, i64 %79
%81 = load float, float* %80
%82 = load i32, i32* %12
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %83
%85 = load i32, i32* %11
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [100 x float], [100 x float]* %84, i64 0, i64 %86
%88 = load float, float* %87
%89 = load i32, i32* %10
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %90
%92 = load i32, i32* %11
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [100 x float], [100 x float]* %91, i64 0, i64 %93
%95 = load float, float* %94
%96 = fneg float %81
%97 = call float @llvm.fmuladd.f32(float %96, float %88, float %95)
store float %97, float* %94
br label %98
98: ; preds = %74
%99 = load i32, i32* %12
%100 = add nsw i32 %99, 1
store i32 %100, i32* %12
br label %69
101: ; preds = %69
%102 = load i32, i32* %10
%103 = load i32, i32* %11
%104 = icmp eq i32 %102, %103
br i1 %104, label %105, label %112
105: ; preds = %101
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %107
%109 = load i32, i32* %11
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [100 x float], [100 x float]* %108, i64 0, i64 %110
store float 1.000000e+00, float* %111
br label %112
112: ; preds = %105, %101
br label %175
113: ; preds = %51
%114 = load i32, i32* %10
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %115
%117 = load i32, i32* %11
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [100 x float], [100 x float]* %116, i64 0, i64 %118
%120 = load float, float* %119
%121 = load i32, i32* %10
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %122
%124 = load i32, i32* %11
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [100 x float], [100 x float]* %123, i64 0, i64 %125
store float %120, float* %126
store i32 0, i32* %12
br label %127
127: ; preds = %156, %113
%128 = load i32, i32* %12
%129 = load i32, i32* %10
%130 = sub nsw i32 %129, 1
%131 = icmp sle i32 %128, %130
br i1 %131, label %132, label %159
132: ; preds = %127
%133 = load i32, i32* %10
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %134
%136 = load i32, i32* %12
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [100 x float], [100 x float]* %135, i64 0, i64 %137
%139 = load float, float* %138
%140 = load i32, i32* %12
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %141
%143 = load i32, i32* %11
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [100 x float], [100 x float]* %142, i64 0, i64 %144
%146 = load float, float* %145
%147 = load i32, i32* %10
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %148
%150 = load i32, i32* %11
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [100 x float], [100 x float]* %149, i64 0, i64 %151
%153 = load float, float* %152
%154 = fneg float %139
%155 = call float @llvm.fmuladd.f32(float %154, float %146, float %153)
store float %155, float* %152
br label %156
156: ; preds = %132
%157 = load i32, i32* %12
%158 = add nsw i32 %157, 1
store i32 %158, i32* %12
br label %127
159: ; preds = %127
%160 = load i32, i32* %10
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %161
%163 = load i32, i32* %10
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [100 x float], [100 x float]* %162, i64 0, i64 %164
%166 = load float, float* %165
%167 = load i32, i32* %10
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %168
%170 = load i32, i32* %11
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [100 x float], [100 x float]* %169, i64 0, i64 %171
%173 = load float, float* %172
%174 = fdiv float %173, %166
store float %174, float* %172
br label %175
175: ; preds = %159, %112
br label %176
176: ; preds = %175
%177 = load i32, i32* %10
%178 = add nsw i32 %177, 1
store i32 %178, i32* %10
br label %47
179: ; preds = %47
br label %180
180: ; preds = %179
%181 = load i32, i32* %11
%182 = add nsw i32 %181, 1
store i32 %182, i32* %11
br label %42
183: ; preds = %42
%184 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %10
br label %185
185: ; preds = %209, %183
%186 = load i32, i32* %10
%187 = load i32, i32* %9
%188 = icmp slt i32 %186, %187
br i1 %188, label %189, label %212
189: ; preds = %185
%190 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %11
br label %191
191: ; preds = %205, %189
%192 = load i32, i32* %11
%193 = load i32, i32* %9
%194 = icmp slt i32 %192, %193
br i1 %194, label %195, label %208
195: ; preds = %191
%196 = load i32, i32* %10
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %197
%199 = load i32, i32* %11
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [100 x float], [100 x float]* %198, i64 0, i64 %200
%202 = load float, float* %201
%203 = fpext float %202 to double
%204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double %203)
br label %205
205: ; preds = %195
%206 = load i32, i32* %11
%207 = add nsw i32 %206, 1
store i32 %207, i32* %11
br label %191
208: ; preds = %191
br label %209
209: ; preds = %208
%210 = load i32, i32* %10
%211 = add nsw i32 %210, 1
store i32 %211, i32* %10
br label %185
212: ; preds = %185
%213 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %10
br label %215
215: ; preds = %239, %212
%216 = load i32, i32* %10
%217 = load i32, i32* %9
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %242
219: ; preds = %215
%220 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %11
br label %221
221: ; preds = %235, %219
%222 = load i32, i32* %11
%223 = load i32, i32* %9
%224 = icmp slt i32 %222, %223
br i1 %224, label %225, label %238
225: ; preds = %221
%226 = load i32, i32* %10
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %227
%229 = load i32, i32* %11
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [100 x float], [100 x float]* %228, i64 0, i64 %230
%232 = load float, float* %231
%233 = fpext float %232 to double
%234 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double %233)
br label %235
235: ; preds = %225
%236 = load i32, i32* %11
%237 = add nsw i32 %236, 1
store i32 %237, i32* %11
br label %221
238: ; preds = %221
br label %239
239: ; preds = %238
%240 = load i32, i32* %10
%241 = add nsw i32 %240, 1
store i32 %241, i32* %10
br label %215
242: ; preds = %215
%243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %10
br label %244
244: ; preds = %253, %242
%245 = load i32, i32* %10
%246 = load i32, i32* %9
%247 = icmp slt i32 %245, %246
br i1 %247, label %248, label %256
248: ; preds = %244
%249 = load i32, i32* %10
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %250
%252 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %251)
br label %253
253: ; preds = %248
%254 = load i32, i32* %10
%255 = add nsw i32 %254, 1
store i32 %255, i32* %10
br label %244
256: ; preds = %244
store i32 0, i32* %10
br label %257
257: ; preds = %307, %256
%258 = load i32, i32* %10
%259 = load i32, i32* %9
%260 = icmp slt i32 %258, %259
br i1 %260, label %261, label %310
261: ; preds = %257
%262 = load i32, i32* %10
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %263
%265 = load float, float* %264
%266 = load i32, i32* %10
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %267
store float %265, float* %268
store i32 0, i32* %11
br label %269
269: ; preds = %291, %261
%270 = load i32, i32* %11
%271 = load i32, i32* %10
%272 = icmp slt i32 %270, %271
br i1 %272, label %273, label %294
273: ; preds = %269
%274 = load i32, i32* %10
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %275
%277 = load i32, i32* %11
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [100 x float], [100 x float]* %276, i64 0, i64 %278
%280 = load float, float* %279
%281 = load i32, i32* %11
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %282
%284 = load float, float* %283
%285 = load i32, i32* %10
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %286
%288 = load float, float* %287
%289 = fneg float %280
%290 = call float @llvm.fmuladd.f32(float %289, float %284, float %288)
store float %290, float* %287
br label %291
291: ; preds = %273
%292 = load i32, i32* %11
%293 = add nsw i32 %292, 1
store i32 %293, i32* %11
br label %269
294: ; preds = %269
%295 = load i32, i32* %10
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %296
%298 = load i32, i32* %10
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [100 x float], [100 x float]* %297, i64 0, i64 %299
%301 = load float, float* %300
%302 = load i32, i32* %10
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %303
%305 = load float, float* %304
%306 = fdiv float %305, %301
store float %306, float* %304
br label %307
307: ; preds = %294
%308 = load i32, i32* %10
%309 = add nsw i32 %308, 1
store i32 %309, i32* %10
br label %257
310: ; preds = %257
%311 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0))
store i32 0, i32* %10
br label %312
312: ; preds = %323, %310
%313 = load i32, i32* %10
%314 = load i32, i32* %9
%315 = icmp slt i32 %313, %314
br i1 %315, label %316, label %326
316: ; preds = %312
%317 = load i32, i32* %10
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %318
%320 = load float, float* %319
%321 = fpext float %320 to double
%322 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), double %321)
br label %323
323: ; preds = %316
%324 = load i32, i32* %10
%325 = add nsw i32 %324, 1
store i32 %325, i32* %10
br label %312
326: ; preds = %312
%327 = load i32, i32* %9
%328 = sub nsw i32 %327, 1
store i32 %328, i32* %10
br label %329
329: ; preds = %368, %326
%330 = load i32, i32* %10
%331 = icmp sge i32 %330, 0
br i1 %331, label %332, label %371
332: ; preds = %329
%333 = load i32, i32* %10
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %334
%336 = load float, float* %335
%337 = load i32, i32* %10
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %338
store float %336, float* %339
%340 = load i32, i32* %10
%341 = add nsw i32 %340, 1
store i32 %341, i32* %11
br label %342
342: ; preds = %364, %332
%343 = load i32, i32* %11
%344 = load i32, i32* %9
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %367
346: ; preds = %342
%347 = load i32, i32* %10
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 %348
%350 = load i32, i32* %11
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [100 x float], [100 x float]* %349, i64 0, i64 %351
%353 = load float, float* %352
%354 = load i32, i32* %11
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %355
%357 = load float, float* %356
%358 = load i32, i32* %10
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %359
%361 = load float, float* %360
%362 = fneg float %353
%363 = call float @llvm.fmuladd.f32(float %362, float %357, float %361)
store float %363, float* %360
br label %364
364: ; preds = %346
%365 = load i32, i32* %11
%366 = add nsw i32 %365, 1
store i32 %366, i32* %11
br label %342
367: ; preds = %342
br label %368
368: ; preds = %367
%369 = load i32, i32* %10
%370 = add nsw i32 %369, -1
store i32 %370, i32* %10
br label %329
371: ; preds = %329
%372 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %10
br label %373
373: ; preds = %384, %371
%374 = load i32, i32* %10
%375 = load i32, i32* %9
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %387
377: ; preds = %373
%378 = load i32, i32* %10
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %379
%381 = load float, float* %380
%382 = fpext float %381 to double
%383 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), double %382)
br label %384
384: ; preds = %377
%385 = load i32, i32* %10
%386 = add nsw i32 %385, 1
store i32 %386, i32* %10
br label %373
387: ; preds = %373
%388 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [33 x i8] c"\0A\09enter the size of the matrix: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [11 x i8] c"\0AL matrix:\00"
@.str.5 = [3 x i8] c"\0A\09\00"
@.str.6 = [4 x i8] c"%f \00"
@.str.8 = [11 x i8] c"\0AU matrix:\00"
@.str.10 = [6 x i8] c"\0A[Y]:\00"
@.str.11 = [6 x i8] c"\0A\09%f \00"
@str = [33 x i8] c"\0Aenter the coefficient matrix: \0A\00"
@str.14 = [26 x i8] c"\0Aenter the constant terms\00"
@str.15 = [27 x i8] c"\0A\09 So the result will be: \00"
@str.16 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca [100 x [100 x float]]
%2 = alloca [100 x [100 x float]]
%3 = alloca [100 x [100 x float]]
%4 = alloca [100 x float]
%5 = alloca [100 x float]
%6 = alloca [100 x float]
%7 = alloca i32
%8 = bitcast [100 x [100 x float]]* %1 to i8*
%9 = bitcast [100 x [100 x float]]* %2 to i8*
%10 = bitcast [100 x [100 x float]]* %3 to i8*
%11 = bitcast [100 x float]* %4 to i8*
%12 = bitcast [100 x float]* %5 to i8*
%13 = bitcast [100 x float]* %6 to i8*
%14 = bitcast i32* %7 to i8*
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%16 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %7)
%17 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%18 = load i32, i32* %7
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %139
20: ; preds = %0, %36
%21 = phi i32 [ %37, %36 ], [ %18, %0 ]
%22 = phi i64 [ %39, %36 ], [ 0, %0 ]
%23 = icmp sgt i32 %21, 0
br i1 %23, label %28, label %36
24: ; preds = %36
%25 = icmp sgt i32 %37, 0
br i1 %25, label %26, label %139
26: ; preds = %24
%27 = zext i32 %37 to i64
br label %41
28: ; preds = %20, %28
%29 = phi i64 [ %32, %28 ], [ 0, %20 ]
%30 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %1, i64 0, i64 %22, i64 %29
%31 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %30)
%32 = add nuw nsw i64 %29, 1
%33 = load i32, i32* %7
%34 = sext i32 %33 to i64
%35 = icmp slt i64 %32, %34
br i1 %35, label %28, label %36
36: ; preds = %28, %20
%37 = phi i32 [ %21, %20 ], [ %33, %28 ]
%38 = sext i32 %37 to i64
%39 = add nuw nsw i64 %22, 1
%40 = icmp slt i64 %39, %38
br i1 %40, label %20, label %24
41: ; preds = %136, %26
%42 = phi i64 [ 0, %26 ], [ %137, %136 ]
%43 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %42, i64 %42
%44 = and i64 %42, 1
%45 = icmp eq i64 %42, 1
%46 = and i64 %42, 9223372036854775806
%47 = icmp eq i64 %44, 0
br label %48
48: ; preds = %41, %133
%49 = phi i64 [ 0, %41 ], [ %134, %133 ]
%50 = icmp ult i64 %49, %42
%51 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %1, i64 0, i64 %49, i64 %42
%52 = load float, float* %51
br i1 %50, label %88, label %53
53: ; preds = %48
%54 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %42
store float %52, float* %54
switch i64 %42, label %55 [
i64 0, label %85
i64 1, label %75
]
55: ; preds = %53, %55
%56 = phi float [ %71, %55 ], [ %52, %53 ]
%57 = phi i64 [ %72, %55 ], [ 0, %53 ]
%58 = phi i64 [ %73, %55 ], [ 0, %53 ]
%59 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %57
%60 = load float, float* %59
%61 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %57, i64 %42
%62 = load float, float* %61
%63 = fneg float %60
%64 = call float @llvm.fmuladd.f32(float %63, float %62, float %56)
store float %64, float* %54
%65 = or i64 %57, 1
%66 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %65
%67 = load float, float* %66
%68 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %65, i64 %42
%69 = load float, float* %68
%70 = fneg float %67
%71 = call float @llvm.fmuladd.f32(float %70, float %69, float %64)
store float %71, float* %54
%72 = add nuw nsw i64 %57, 2
%73 = add i64 %58, 2
%74 = icmp eq i64 %73, %46
br i1 %74, label %75, label %55
75: ; preds = %55, %53
%76 = phi float [ %52, %53 ], [ %71, %55 ]
%77 = phi i64 [ 0, %53 ], [ %72, %55 ]
br i1 %47, label %85, label %78
78: ; preds = %75
%79 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %77
%80 = load float, float* %79
%81 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %77, i64 %42
%82 = load float, float* %81
%83 = fneg float %80
%84 = call float @llvm.fmuladd.f32(float %83, float %82, float %76)
store float %84, float* %54
br label %85
85: ; preds = %78, %75, %53
%86 = icmp eq i64 %49, %42
br i1 %86, label %87, label %133
87: ; preds = %85
store float 1.000000e+00, float* %43
br label %133
88: ; preds = %48
%89 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %49, i64 %42
store float %52, float* %89
%90 = icmp eq i64 %49, 0
br i1 %90, label %128, label %91
91: ; preds = %88
%92 = and i64 %49, 1
%93 = icmp eq i64 %49, 1
br i1 %93, label %116, label %94
94: ; preds = %91
%95 = and i64 %49, 9223372036854775806
br label %96
96: ; preds = %96, %94
%97 = phi float [ %52, %94 ], [ %112, %96 ]
%98 = phi i64 [ 0, %94 ], [ %113, %96 ]
%99 = phi i64 [ 0, %94 ], [ %114, %96 ]
%100 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %98
%101 = load float, float* %100
%102 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %98, i64 %42
%103 = load float, float* %102
%104 = fneg float %101
%105 = call float @llvm.fmuladd.f32(float %104, float %103, float %97)
store float %105, float* %89
%106 = or i64 %98, 1
%107 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %106
%108 = load float, float* %107
%109 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %106, i64 %42
%110 = load float, float* %109
%111 = fneg float %108
%112 = call float @llvm.fmuladd.f32(float %111, float %110, float %105)
store float %112, float* %89
%113 = add nuw nsw i64 %98, 2
%114 = add i64 %99, 2
%115 = icmp eq i64 %114, %95
br i1 %115, label %116, label %96
116: ; preds = %96, %91
%117 = phi float [ undef, %91 ], [ %112, %96 ]
%118 = phi float [ %52, %91 ], [ %112, %96 ]
%119 = phi i64 [ 0, %91 ], [ %113, %96 ]
%120 = icmp eq i64 %92, 0
br i1 %120, label %128, label %121
121: ; preds = %116
%122 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %119
%123 = load float, float* %122
%124 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %119, i64 %42
%125 = load float, float* %124
%126 = fneg float %123
%127 = call float @llvm.fmuladd.f32(float %126, float %125, float %118)
store float %127, float* %89
br label %128
128: ; preds = %121, %116, %88
%129 = phi float [ %52, %88 ], [ %117, %116 ], [ %127, %121 ]
%130 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %49, i64 %49
%131 = load float, float* %130
%132 = fdiv float %129, %131
store float %132, float* %89
br label %133
133: ; preds = %128, %87, %85
%134 = add nuw nsw i64 %49, 1
%135 = icmp eq i64 %134, %27
br i1 %135, label %136, label %48
136: ; preds = %133
%137 = add nuw nsw i64 %42, 1
%138 = icmp eq i64 %137, %27
br i1 %138, label %139, label %41
139: ; preds = %136, %0, %24
%140 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0))
%141 = load i32, i32* %7
%142 = icmp sgt i32 %141, 0
br i1 %142, label %143, label %163
143: ; preds = %139, %158
%144 = phi i64 [ %161, %158 ], [ 0, %139 ]
%145 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%146 = load i32, i32* %7
%147 = icmp sgt i32 %146, 0
br i1 %147, label %148, label %158
148: ; preds = %143, %148
%149 = phi i64 [ %154, %148 ], [ 0, %143 ]
%150 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %144, i64 %149
%151 = load float, float* %150
%152 = fpext float %151 to double
%153 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double %152)
%154 = add nuw nsw i64 %149, 1
%155 = load i32, i32* %7
%156 = sext i32 %155 to i64
%157 = icmp slt i64 %154, %156
br i1 %157, label %148, label %158
158: ; preds = %148, %143
%159 = phi i32 [ %146, %143 ], [ %155, %148 ]
%160 = sext i32 %159 to i64
%161 = add nuw nsw i64 %144, 1
%162 = icmp slt i64 %161, %160
br i1 %162, label %143, label %163
163: ; preds = %158, %139
%164 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.16, i64 0, i64 0))
%165 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
%166 = load i32, i32* %7
%167 = icmp sgt i32 %166, 0
br i1 %167, label %168, label %188
168: ; preds = %163, %183
%169 = phi i64 [ %186, %183 ], [ 0, %163 ]
%170 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%171 = load i32, i32* %7
%172 = icmp sgt i32 %171, 0
br i1 %172, label %173, label %183
173: ; preds = %168, %173
%174 = phi i64 [ %179, %173 ], [ 0, %168 ]
%175 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %169, i64 %174
%176 = load float, float* %175
%177 = fpext float %176 to double
%178 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double %177)
%179 = add nuw nsw i64 %174, 1
%180 = load i32, i32* %7
%181 = sext i32 %180 to i64
%182 = icmp slt i64 %179, %181
br i1 %182, label %173, label %183
183: ; preds = %173, %168
%184 = phi i32 [ %171, %168 ], [ %180, %173 ]
%185 = sext i32 %184 to i64
%186 = add nuw nsw i64 %169, 1
%187 = icmp slt i64 %186, %185
br i1 %187, label %168, label %188
188: ; preds = %183, %163
%189 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.14, i64 0, i64 0))
%190 = load i32, i32* %7
%191 = icmp sgt i32 %190, 0
br i1 %191, label %196, label %254
192: ; preds = %196
%193 = icmp sgt i32 %201, 0
br i1 %193, label %194, label %254
194: ; preds = %192
%195 = zext i32 %201 to i64
br label %204
196: ; preds = %188, %196
%197 = phi i64 [ %200, %196 ], [ 0, %188 ]
%198 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %197
%199 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %198)
%200 = add nuw nsw i64 %197, 1
%201 = load i32, i32* %7
%202 = sext i32 %201 to i64
%203 = icmp slt i64 %200, %202
br i1 %203, label %196, label %192
204: ; preds = %194, %247
%205 = phi i64 [ 0, %194 ], [ %252, %247 ]
%206 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %205
%207 = load float, float* %206
%208 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %205
store float %207, float* %208
%209 = icmp eq i64 %205, 0
br i1 %209, label %247, label %210
210: ; preds = %204
%211 = and i64 %205, 1
%212 = icmp eq i64 %205, 1
br i1 %212, label %235, label %213
213: ; preds = %210
%214 = and i64 %205, 9223372036854775806
br label %215
215: ; preds = %215, %213
%216 = phi float [ %207, %213 ], [ %231, %215 ]
%217 = phi i64 [ 0, %213 ], [ %232, %215 ]
%218 = phi i64 [ 0, %213 ], [ %233, %215 ]
%219 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %205, i64 %217
%220 = load float, float* %219
%221 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %217
%222 = load float, float* %221
%223 = fneg float %220
%224 = call float @llvm.fmuladd.f32(float %223, float %222, float %216)
store float %224, float* %208
%225 = or i64 %217, 1
%226 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %205, i64 %225
%227 = load float, float* %226
%228 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %225
%229 = load float, float* %228
%230 = fneg float %227
%231 = call float @llvm.fmuladd.f32(float %230, float %229, float %224)
store float %231, float* %208
%232 = add nuw nsw i64 %217, 2
%233 = add i64 %218, 2
%234 = icmp eq i64 %233, %214
br i1 %234, label %235, label %215
235: ; preds = %215, %210
%236 = phi float [ undef, %210 ], [ %231, %215 ]
%237 = phi float [ %207, %210 ], [ %231, %215 ]
%238 = phi i64 [ 0, %210 ], [ %232, %215 ]
%239 = icmp eq i64 %211, 0
br i1 %239, label %247, label %240
240: ; preds = %235
%241 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %205, i64 %238
%242 = load float, float* %241
%243 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %238
%244 = load float, float* %243
%245 = fneg float %242
%246 = call float @llvm.fmuladd.f32(float %245, float %244, float %237)
store float %246, float* %208
br label %247
247: ; preds = %240, %235, %204
%248 = phi float [ %207, %204 ], [ %236, %235 ], [ %246, %240 ]
%249 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 %205, i64 %205
%250 = load float, float* %249
%251 = fdiv float %248, %250
store float %251, float* %208
%252 = add nuw nsw i64 %205, 1
%253 = icmp eq i64 %252, %195
br i1 %253, label %254, label %204
254: ; preds = %247, %188, %192
%255 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0))
%256 = load i32, i32* %7
%257 = icmp sgt i32 %256, 0
br i1 %257, label %263, label %321
258: ; preds = %263
%259 = icmp sgt i32 %270, 0
br i1 %259, label %260, label %321
260: ; preds = %258
%261 = zext i32 %270 to i64
%262 = zext i32 %270 to i64
br label %277
263: ; preds = %254, %263
%264 = phi i64 [ %269, %263 ], [ 0, %254 ]
%265 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %264
%266 = load float, float* %265
%267 = fpext float %266 to double
%268 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), double %267)
%269 = add nuw nsw i64 %264, 1
%270 = load i32, i32* %7
%271 = sext i32 %270 to i64
%272 = icmp slt i64 %269, %271
br i1 %272, label %263, label %258
273: ; preds = %298, %302, %277
%274 = icmp sgt i64 %279, 1
%275 = add nsw i64 %279, -1
%276 = add i32 %278, 1
br i1 %274, label %277, label %321
277: ; preds = %260, %273
%278 = phi i32 [ 0, %260 ], [ %276, %273 ]
%279 = phi i64 [ %262, %260 ], [ %275, %273 ]
%280 = phi i64 [ %261, %260 ], [ %281, %273 ]
%281 = add nsw i64 %280, -1
%282 = and i64 %281, 4294967295
%283 = getelementptr inbounds [100 x float], [100 x float]* %5, i64 0, i64 %282
%284 = load float, float* %283
%285 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %282
store float %284, float* %285
%286 = icmp slt i64 %279, %261
br i1 %286, label %287, label %273
287: ; preds = %277
%288 = and i32 %278, 1
%289 = icmp eq i32 %288, 0
br i1 %289, label %298, label %290
290: ; preds = %287
%291 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %282, i64 %280
%292 = load float, float* %291
%293 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %280
%294 = load float, float* %293
%295 = fneg float %292
%296 = call float @llvm.fmuladd.f32(float %295, float %294, float %284)
store float %296, float* %285
%297 = add nsw i64 %280, 1
br label %298
298: ; preds = %290, %287
%299 = phi float [ %284, %287 ], [ %296, %290 ]
%300 = phi i64 [ %280, %287 ], [ %297, %290 ]
%301 = icmp eq i32 %278, 1
br i1 %301, label %273, label %302
302: ; preds = %298, %302
%303 = phi float [ %317, %302 ], [ %299, %298 ]
%304 = phi i64 [ %318, %302 ], [ %300, %298 ]
%305 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %282, i64 %304
%306 = load float, float* %305
%307 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %304
%308 = load float, float* %307
%309 = fneg float %306
%310 = call float @llvm.fmuladd.f32(float %309, float %308, float %303)
store float %310, float* %285
%311 = add nsw i64 %304, 1
%312 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 %282, i64 %311
%313 = load float, float* %312
%314 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %311
%315 = load float, float* %314
%316 = fneg float %313
%317 = call float @llvm.fmuladd.f32(float %316, float %315, float %310)
store float %317, float* %285
%318 = add nsw i64 %304, 2
%319 = trunc i64 %318 to i32
%320 = icmp eq i32 %270, %319
br i1 %320, label %273, label %302
321: ; preds = %273, %254, %258
%322 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.15, i64 0, i64 0))
%323 = load i32, i32* %7
%324 = icmp sgt i32 %323, 0
br i1 %324, label %325, label %335
325: ; preds = %321, %325
%326 = phi i64 [ %331, %325 ], [ 0, %321 ]
%327 = getelementptr inbounds [100 x float], [100 x float]* %6, i64 0, i64 %326
%328 = load float, float* %327
%329 = fpext float %328 to double
%330 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), double %329)
%331 = add nuw nsw i64 %326, 1
%332 = load i32, i32* %7
%333 = sext i32 %332 to i64
%334 = icmp slt i64 %331, %333
br i1 %334, label %325, label %335
335: ; preds = %325, %321
%336 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.16, i64 0, i64 0))
ret i32 0
}