#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*/ getch();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int /*<<< orphan*/ system(char *);
char toupper(char);
int main() {
  int li, co;
S:
  printf("\n DIGITE A DIMENSAO DA MATRIZ. \n LINHAS :: ");
  scanf(" %d", &li);
  printf(" COLUNA :: ");
  scanf(" %d", &co);
  if (li < co - 1) {
    printf("\n NUMERO DE EQUACOES INSUFICIENTE. TENTE DE NOVO : ");
    getch();
    goto S;
  }
  system("cls");
  float matriz[li][co];
  int il, ic;
  for (il = 0; il < li; il++) {
    for (ic = 0; ic < co; ic++) {
      printf("\n VALOR DO ELEMENTO [%d][%d] = ", il + 1, ic + 1);
      scanf(" %f", &matriz[il][ic]);
    }
  }
  system("cls");
  printf("\n A MATRIZ AMPLIADA DO SISTEMA :: \n");
  for (il = 0; il < li; il++) {
    printf("\n");
    for (ic = 0; ic < co; ic++) {
      printf(" \t%.2f", matriz[il][ic]);
    }
  }
  int lo, ld, oc, n;
  float laux[co];
  float aux, k;
  for (ic = 0, il = 0; il < li; ic++, ++il) {
    if (matriz[il][ic] == 0) {
      for (lo = il; lo < li; lo++) {
        if (matriz[lo][ic] != 0)
          ld = lo;
      }
      for (oc = 0; oc < co; oc++) {
        laux[oc] = matriz[il][oc];
        matriz[il][oc] = matriz[ld][oc];
        matriz[ld][oc] = laux[oc];
      }
    }
    aux = matriz[il][ic];
    for (oc = ic; oc < co; oc++) {
      matriz[il][oc] /= aux;
    }
    for (lo = il + 1; lo < li; lo++) {
      k = -matriz[lo][ic];
      for (oc = ic; oc < co; oc++) {
        laux[oc] = matriz[il][oc];
        laux[oc] *= k;
        matriz[lo][oc] += laux[oc];
      }
    }
  }
  printf("\n\n A MATRIZ ESCALONADA DO SISTEMA :: \n");
  for (il = 0; il < li; il++) {
    printf("\n");
    for (ic = 0; ic < co; ic++) {
      printf(" \t%.2f", matriz[il][ic]);
    }
  }
  char r;
  printf("\n\n DESEJA REPETIR? [S/N] : ");
  scanf(" %c", &r);
  r = toupper(r);
  if (r == 'S') {
    system("cls");
    goto S;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xeb8(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
lea    0xeaa(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe98(%rip),%rdi
lea    -0xc(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11ca <main+0x7a>
lea    0xe85(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1070 <getch@plt>
jmp    115f <main+0xf>
lea    0xe9f(%rip),%rdi
call   1040 <system@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x68(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x18(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12a2 <main+0x152>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128f <main+0x13f>
mov    -0x2c(%rbp),%esi
add    $0x1,%esi
mov    -0x30(%rbp),%edx
add    $0x1,%edx
lea    0xe2a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%rcx
mov    -0x60(%rbp),%rsi
movslq -0x2c(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x30(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe1a(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    122b <main+0xdb>
jmp    1294 <main+0x144>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1218 <main+0xc8>
lea    0xdc7(%rip),%rdi
call   1040 <system@plt>
lea    0xde3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1343 <main+0x1f3>
lea    0xde4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1330 <main+0x1e0>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xda1(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12e4 <main+0x194>
jmp    1335 <main+0x1e5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12c3 <main+0x173>
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1630 <main+0x4e0>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14be <main+0x36e>
jp     14be <main+0x36e>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1411 <main+0x2c1>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    13f8 <main+0x2a8>
jp     13f8 <main+0x2a8>
jmp    13fe <main+0x2ae>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1403 <main+0x2b3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13b5 <main+0x265>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14b9 <main+0x369>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x2,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x3c(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm0
movslq -0x3c(%rbp),%rsi
movss  %xmm0,(%rcx,%rsi,4)
movslq -0x38(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x2,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x3c(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm0
movslq -0x2c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x2,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x3c(%rbp),%rdi
movss  %xmm0,(%rsi,%rdi,4)
movslq -0x3c(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm0
movslq -0x38(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1418 <main+0x2c8>
jmp    14be <main+0x36e>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1531 <main+0x3e1>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movss  -0x4c(%rbp),%xmm1
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14e9 <main+0x399>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1614 <main+0x4c4>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1601 <main+0x4b1>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x2,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x3c(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm0
movslq -0x3c(%rbp),%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  -0x50(%rbp),%xmm0
movslq -0x3c(%rbp),%rsi
mulss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
movslq -0x3c(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    157e <main+0x42e>
jmp    1606 <main+0x4b6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    153a <main+0x3ea>
jmp    1619 <main+0x4c9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1371 <main+0x221>
lea    0xa8c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16c5 <main+0x575>
lea    0xa62(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16b2 <main+0x562>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa1f(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1666 <main+0x516>
jmp    16b7 <main+0x567>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1645 <main+0x4f5>
lea    0xa1e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xa2c(%rip),%rdi
lea    -0x51(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
movsbl -0x51(%rbp),%edi
call   1030 <toupper@plt>
mov    %al,-0x51(%rbp)
movsbl -0x51(%rbp),%eax
cmp    $0x53,%eax
jne    1716 <main+0x5c6>
lea    0x96b(%rip),%rdi
call   1040 <system@plt>
movl   $0x2,-0x58(%rbp)
jmp    1724 <main+0x5d4>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
je     1741 <main+0x5f1>
jmp    173c <main+0x5ec>
jmp    115f <main+0xf>
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    $0x158,%rsp
lea    0xe75(%rip),%r14
lea    0xe9a(%rip),%rbx
lea    -0x34(%rbp),%r12
lea    0xe93(%rip),%r13
lea    0xef4(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    %r13,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
mov    %r13,%r14
mov    %r12,%r13
lea    -0x30(%rbp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
cmp    %eax,-0x34(%rbp)
lea    0xe47(%rip),%r12
jge    124f <main+0xdf>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %eax,%eax
call   1090 <getch@plt>
lea    0xde8(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
lea    -0x30(%rbp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
cmp    %eax,-0x34(%rbp)
jl     1200 <main+0x90>
lea    0xe1a(%rip),%rdi
call   1060 <system@plt>
mov    %rsp,-0x90(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%edx
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rbx
sub    %rax,%rbx
mov    %rbx,%rsp
mov    -0x34(%rbp),%ecx
test   %ecx,%ecx
mov    %rdx,-0x50(%rbp)
mov    %rbx,-0x48(%rbp)
jle    1320 <main+0x1b0>
mov    -0x30(%rbp),%eax
lea    0x0(,%rdx,4),%rdx
mov    %rdx,-0x60(%rbp)
xor    %r13d,%r13d
jmp    12bc <main+0x14c>
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rdx
add    -0x60(%rbp),%rbx
cmp    %rdx,%r13
jge    1320 <main+0x1b0>
add    $0x1,%r13
test   %eax,%eax
jle    12b0 <main+0x140>
mov    %rbx,-0x68(%rbp)
xor    %r14d,%r14d
lea    0xda2(%rip),%r12
lea    0xdbb(%rip),%r15
nopl   0x0(%rax)
add    $0x1,%r14
mov    %r12,%rdi
mov    %r13d,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movslq -0x30(%rbp),%rax
add    $0x4,%rbx
cmp    %rax,%r14
jl     12e0 <main+0x170>
mov    -0x34(%rbp),%ecx
lea    0xd80(%rip),%r15
mov    -0x68(%rbp),%rbx
jmp    12b0 <main+0x140>
xchg   %ax,%ax
lea    0xd49(%rip),%rdi
call   1060 <system@plt>
lea    0xd8c(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,-0x34(%rbp)
jle    1ba0 <main+0xa30>
mov    -0x50(%rbp),%rax
lea    0x0(,%rax,4),%rdi
mov    -0x48(%rbp),%r12
xor    %r14d,%r14d
mov    %rdi,-0x70(%rbp)
jmp    1374 <main+0x204>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
movslq -0x34(%rbp),%rcx
mov    -0x70(%rbp),%rdi
add    %rdi,%r12
cmp    %rcx,%r14
jge    13c0 <main+0x250>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x30(%rbp),%r9d
test   %r9d,%r9d
jle    1360 <main+0x1f0>
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
movslq -0x30(%rbp),%r9
cmp    %r9,%rbx
jl     1390 <main+0x220>
jmp    1360 <main+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%eax
test   %eax,%eax
jle    1ba0 <main+0xa30>
movslq %r9d,%rcx
mov    %rcx,-0xe0(%rbp)
mov    %ecx,%r11d
mov    -0x50(%rbp),%rbx
lea    0x1(%rbx),%rcx
mov    %rcx,-0x168(%rbp)
lea    0x4(,%rbx,4),%rcx
mov    %rcx,-0x120(%rbp)
lea    (%r11,%rbx,1),%rcx
mov    %rcx,-0x118(%rbp)
mov    -0x48(%rbp),%r8
lea    0x4(%r8),%rcx
lea    (%r8,%r11,4),%rdx
mov    %rdx,-0x110(%rbp)
mov    %r11d,%edx
and    $0xfffffff8,%edx
mov    %rdx,-0x108(%rbp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x100(%rbp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
lea    -0x1(%r11),%rdx
mov    %rdx,-0xa0(%rbp)
mov    %rsi,%rdx
mov    %rsi,-0xf8(%rbp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0xf0(%rbp)
mov    %r11,%rdx
neg    %rdx
mov    %rdx,-0x180(%rbp)
lea    0x4(%rdi),%rdx
mov    %rdx,-0x130(%rbp)
lea    0x30(%r8),%rdx
lea    -0x5(%r11),%r14
lea    0x34(%r8,%rbx,4),%rsi
mov    %rsi,-0xc0(%rbp)
lea    -0x9(%r11),%rsi
mov    %rsi,-0xb8(%rbp)
lea    (%r8,%rbx,4),%rsi
mov    %rsi,-0xb0(%rbp)
mov    $0x1,%esi
mov    %rsi,-0xa8(%rbp)
mov    %r8,%r12
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rbx
mov    %rdx,-0xe8(%rbp)
mov    %rdx,%r10
mov    %r8,%r15
xor    %r13d,%r13d
xorps  %xmm6,%xmm6
mov    %r11,-0x60(%rbp)
jmp    1534 <main+0x3c4>
nopw   0x0(%rax,%rax,1)
addq   $0x1,-0xa8(%rbp)
01
mov    -0x130(%rbp),%rcx
add    %rcx,%r15
mov    -0xc8(%rbp),%r10
add    %rdi,%r10
mov    -0xd0(%rbp),%rbx
add    %rdi,%rbx
mov    -0x160(%rbp),%r14
add    $0xffffffffffffffff,%r14
add    %rdi,%r12
add    %rcx,-0xc0(%rbp)
addq   $0xffffffffffffffff,-0xb8(%rbp)
ff
add    %rdi,-0xb0(%rbp)
mov    -0x158(%rbp),%rdx
mov    %rdx,%rcx
cmp    %rax,%rdx
mov    %rdx,%r13
mov    -0x60(%rbp),%r11
je     1ba0 <main+0xa30>
mov    %r13,%rcx
imul   -0x50(%rbp),%rcx
lea    (%r8,%rcx,4),%rdx
mov    %rcx,-0x80(%rbp)
add    %r11,%rcx
lea    (%r8,%rcx,4),%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rdx,-0x40(%rbp)
movss  (%rdx,%r13,4),%xmm0
ucomiss %xmm6,%xmm0
mov    %r15,%rcx
mov    %r13,%rdx
mov    -0x84(%rbp),%esi
mov    %r13,-0x68(%rbp)
mov    %rbx,-0xd0(%rbp)
mov    %r10,-0xc8(%rbp)
jne    176e <main+0x5fe>
jp     176e <main+0x5fe>
nopl   0x0(%rax)
ucomiss (%rcx),%xmm6
cmovne %edx,%esi
cmovp  %edx,%esi
add    $0x1,%rdx
add    %rdi,%rcx
cmp    %rdx,%rax
jne    1590 <main+0x420>
test   %r9d,%r9d
jle    176e <main+0x5fe>
movslq %esi,%rdx
imul   -0x50(%rbp),%rdx
lea    (%r8,%rdx,4),%r10
cmp    $0x8,%r9d
jb     15e2 <main+0x472>
mov    -0x110(%rbp),%rcx
lea    (%rcx,%rdx,4),%rcx
cmp    %rcx,-0x40(%rbp)
jae    166a <main+0x4fa>
cmp    -0xd8(%rbp),%r10
jae    166a <main+0x4fa>
xor    %edi,%edi
mov    %rdi,%rcx
test   $0x1,%r11b
je     160e <main+0x49e>
mov    -0x40(%rbp),%rcx
movss  (%rcx,%rdi,4),%xmm0
movss  (%r10,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
movss  %xmm0,(%r10,%rdi,4)
mov    %rdi,%rcx
or     $0x1,%rcx
cmp    %rdi,-0xa0(%rbp)
je     1760 <main+0x5f0>
mov    -0x98(%rbp),%rdi
lea    (%rdi,%rdx,4),%rdx
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rcx,4),%xmm0
movss  -0x4(%rdx,%rcx,4),%xmm1
movss  %xmm1,-0x4(%rbx,%rcx,4)
movss  %xmm0,-0x4(%rdx,%rcx,4)
movss  (%rbx,%rcx,4),%xmm0
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  %xmm0,(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    1630 <main+0x4c0>
jmp    1760 <main+0x5f0>
cmpq   $0x0,-0x100(%rbp)
je     1b85 <main+0xa15>
mov    -0xe8(%rbp),%rcx
lea    (%rcx,%rdx,4),%rbx
mov    -0xf0(%rbp),%rdi
xor    %ecx,%ecx
mov    -0xc8(%rbp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r13,%rcx,4),%xmm0
movups -0x20(%r13,%rcx,4),%xmm1
movups -0x30(%rbx,%rcx,4),%xmm2
movups -0x20(%rbx,%rcx,4),%xmm3
movups %xmm2,-0x30(%r13,%rcx,4)
movups %xmm3,-0x20(%r13,%rcx,4)
movups %xmm0,-0x30(%rbx,%rcx,4)
movups %xmm1,-0x20(%rbx,%rcx,4)
movups -0x10(%r13,%rcx,4),%xmm0
movups 0x0(%r13,%rcx,4),%xmm1
movups -0x10(%rbx,%rcx,4),%xmm2
movups (%rbx,%rcx,4),%xmm3
movups %xmm2,-0x10(%r13,%rcx,4)
movups %xmm3,0x0(%r13,%rcx,4)
movups %xmm0,-0x10(%rbx,%rcx,4)
movups %xmm1,(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    16a0 <main+0x530>
testb  $0x1,-0xf8(%rbp)
je     1735 <main+0x5c5>
mov    -0x40(%rbp),%rdi
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups (%r10,%rcx,4),%xmm2
movups 0x10(%r10,%rcx,4),%xmm3
movups %xmm2,(%rdi,%rcx,4)
movups %xmm3,0x10(%rdi,%rcx,4)
movups %xmm0,(%r10,%rcx,4)
movups %xmm1,0x10(%r10,%rcx,4)
mov    -0x108(%rbp),%rcx
mov    %rcx,%rdi
cmp    %r11,%rcx
mov    -0xd0(%rbp),%rbx
mov    -0x68(%rbp),%r13
jne    15e4 <main+0x474>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x40(%rbp),%rcx
movss  (%rcx,%r13,4),%xmm0
mov    -0x70(%rbp),%rdi
mov    -0xa0(%rbp),%r10
sub    %r13,%r10
mov    %r13,%rcx
not    %rcx
add    %r11,%rcx
mov    %rcx,-0x58(%rbp)
cmp    -0xe0(%rbp),%r13
jge    1870 <main+0x700>
movaps %xmm0,%xmm1
divss  %xmm0,%xmm1
mov    -0x40(%rbp),%rcx
movss  %xmm1,(%rcx,%r13,4)
lea    0x1(%r13),%rdx
cmp    %r11,%rdx
je     1870 <main+0x700>
cmpq   $0x4,-0x58(%rbp)
jb     1850 <main+0x6e0>
lea    -0x4(%r10),%rdi
mov    %rdi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmp    $0x4,%rdi
jae    17db <main+0x66b>
xor    %edi,%edi
jmp    1818 <main+0x6a8>
mov    %r14,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x4(%r15,%rdi,4),%xmm2
movups 0x14(%r15,%rdi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,0x4(%r15,%rdi,4)
divps  %xmm1,%xmm3
movups %xmm3,0x14(%r15,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    17f0 <main+0x680>
mov    -0x58(%rbp),%rbx
and    $0xfffffffffffffffc,%rbx
test   $0x1,%cl
je     1837 <main+0x6c7>
add    %rdx,%rdi
mov    -0x40(%rbp),%rcx
movups (%rcx,%rdi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rcx,%rdi,4)
cmp    %rbx,-0x58(%rbp)
mov    -0x70(%rbp),%rdi
je     1870 <main+0x700>
add    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r12,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r11
jne    1850 <main+0x6e0>
nopl   0x0(%rax)
mov    %r14,-0x160(%rbp)
mov    %esi,-0x84(%rbp)
lea    0x1(%r13),%rcx
mov    %rcx,-0x158(%rbp)
cmp    %rax,%rcx
jae    14d0 <main+0x360>
mov    -0xb8(%rbp),%rcx
shr    $0x3,%rcx
add    $0xfffffffffffffff8,%r10
add    $0x1,%rcx
mov    %r10,-0x150(%rbp)
shr    $0x3,%r10
mov    -0x120(%rbp),%rsi
mov    -0x68(%rbp),%rdx
imul   %rdx,%rsi
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x128(%rbp)
add    $0x1,%r10
mov    %r10,-0x148(%rbp)
mov    -0x80(%rbp),%rcx
add    -0x118(%rbp),%rcx
mov    %rcx,-0x80(%rbp)
mov    -0x98(%rbp),%rcx
mov    %rsi,-0x178(%rbp)
add    %rsi,%rcx
mov    %rcx,-0x170(%rbp)
lea    0x1(%rdx),%rcx
mov    %rcx,-0x78(%rbp)
mov    -0x58(%rbp),%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x140(%rbp)
add    %rdx,%rcx
add    $0x1,%rcx
mov    %rcx,-0x138(%rbp)
mov    -0xb0(%rbp),%r11
mov    -0xc0(%rbp),%rdx
xor    %r10d,%r10d
mov    -0xa8(%rbp),%r13
jmp    1957 <main+0x7e7>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r10
add    %rdi,%rdx
add    %rdi,%r11
cmp    %rax,%r13
je     14d0 <main+0x360>
mov    -0x68(%rbp),%rcx
cmp    -0xe0(%rbp),%rcx
mov    -0x60(%rbp),%rsi
jge    1940 <main+0x7d0>
mov    %r13,%rcx
imul   -0x50(%rbp),%rcx
lea    (%r8,%rcx,4),%r14
mov    -0x68(%rbp),%rcx
movss  (%r14,%rcx,4),%xmm0
mov    -0x40(%rbp),%rbx
movss  (%rbx,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%r14,%rcx,4)
cmp    %rsi,-0x78(%rbp)
je     1940 <main+0x7d0>
mov    -0x78(%rbp),%rcx
cmpq   $0x8,-0x58(%rbp)
jb     1af0 <main+0x980>
mov    %r10,%rcx
imul   -0x50(%rbp),%rcx
mov    -0x168(%rbp),%rdi
add    %rcx,%rdi
mov    -0x48(%rbp),%rbx
lea    (%rbx,%rdi,4),%r8
add    -0x178(%rbp),%r8
add    -0x80(%rbp),%rcx
mov    -0x48(%rbp),%rdi
lea    (%rdi,%rcx,4),%rdi
cmp    -0xd8(%rbp),%r8
setb   %bl
cmp    %rdi,-0x170(%rbp)
setb   -0x35(%rbp)
mov    -0x78(%rbp),%rcx
cmp    %rdi,%r8
mov    -0x70(%rbp),%rdi
mov    -0x48(%rbp),%r8
jb     1af0 <main+0x980>
mov    -0x78(%rbp),%rcx
and    -0x35(%rbp),%bl
jne    1af0 <main+0x980>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,-0x150(%rbp)
08
jae    1a26 <main+0x8b6>
xor    %ecx,%ecx
jmp    1a90 <main+0x920>
mov    -0x128(%rbp),%rbx
xor    %ecx,%ecx
nop
movups 0x4(%r15,%rcx,4),%xmm2
movups 0x14(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups -0x30(%rdx,%rcx,4),%xmm4
subps  %xmm2,%xmm4
movups -0x20(%rdx,%rcx,4),%xmm2
subps  %xmm3,%xmm2
movups -0x10(%rdx,%rcx,4),%xmm3
movups (%rdx,%rcx,4),%xmm5
movups %xmm4,-0x30(%rdx,%rcx,4)
movups %xmm2,-0x20(%rdx,%rcx,4)
movups 0x24(%r15,%rcx,4),%xmm2
movups 0x34(%r15,%rcx,4),%xmm4
mulps  %xmm1,%xmm2
subps  %xmm2,%xmm3
mulps  %xmm1,%xmm4
subps  %xmm4,%xmm5
movups %xmm3,-0x10(%rdx,%rcx,4)
movups %xmm5,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1a30 <main+0x8c0>
testb  $0x1,-0x148(%rbp)
je     1acc <main+0x95c>
add    -0x78(%rbp),%rcx
movups (%r14,%rcx,4),%xmm2
movups 0x10(%r14,%rcx,4),%xmm3
mov    -0x40(%rbp),%rsi
movups (%rsi,%rcx,4),%xmm4
movups 0x10(%rsi,%rcx,4),%xmm5
mulps  %xmm1,%xmm4
subps  %xmm4,%xmm2
mulps  %xmm1,%xmm5
subps  %xmm5,%xmm3
movups %xmm2,(%r14,%rcx,4)
movups %xmm3,0x10(%r14,%rcx,4)
mov    -0x138(%rbp),%rcx
mov    -0x140(%rbp),%rsi
cmp    %rsi,-0x58(%rbp)
mov    -0x60(%rbp),%rsi
je     1940 <main+0x7d0>
nopl   0x0(%rax,%rax,1)
mov    %esi,%edi
sub    %ecx,%edi
mov    %rcx,%rbx
test   $0x1,%dil
je     1b1e <main+0x9ae>
movss  (%r14,%rcx,4),%xmm1
mov    -0x40(%rbp),%rsi
movss  (%rsi,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%r14,%rcx,4)
lea    0x1(%rcx),%rbx
not    %rcx
cmp    -0x180(%rbp),%rcx
mov    -0x70(%rbp),%rdi
mov    -0x60(%rbp),%rcx
je     1940 <main+0x7d0>
cs nopw 0x0(%rax,%rax,1)
movss  (%r12,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
movss  (%r11,%rbx,4),%xmm2
subss  %xmm1,%xmm2
movss  0x4(%r11,%rbx,4),%xmm1
movss  %xmm2,(%r11,%rbx,4)
movss  0x4(%r12,%rbx,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%r11,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1b40 <main+0x9d0>
jmp    1940 <main+0x7d0>
xor    %ecx,%ecx
testb  $0x1,-0xf8(%rbp)
jne    1709 <main+0x599>
jmp    1735 <main+0x5c5>
nopl   0x0(%rax)
lea    0x53b(%rip),%rdi
call   1050 <puts@plt>
mov    -0x50(%rbp),%rcx
cmpl   $0x0,-0x34(%rbp)
lea    0x4dd(%rip),%r15
jle    1c30 <main+0xac0>
shl    $0x2,%rcx
xor    %r14d,%r14d
jmp    1be7 <main+0xa77>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
movslq -0x34(%rbp),%rax
mov    %r12,%rcx
add    %r12,%r13
mov    %r13,-0x48(%rbp)
cmp    %rax,%r14
jge    1c30 <main+0xac0>
mov    %rcx,%r12
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpl   $0x0,-0x30(%rbp)
mov    -0x48(%rbp),%r13
jle    1bd0 <main+0xa60>
xor    %ebx,%ebx
movss  0x0(%r13,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
movslq -0x30(%rbp),%rax
cmp    %rax,%rbx
jl     1c00 <main+0xa90>
jmp    1bd0 <main+0xa60>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x468(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x476(%rip),%rdi
lea    -0x29(%rbp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movsbl -0x29(%rbp),%edi
call   1040 <toupper@plt>
mov    %al,-0x29(%rbp)
cmp    $0x53,%al
jne    1c91 <main+0xb21>
lea    0x409(%rip),%rdi
call   1060 <system@plt>
mov    -0x90(%rbp),%rsp
lea    0x3b2(%rip),%rbx
lea    -0x34(%rbp),%r12
lea    0x3ab(%rip),%r13
lea    0x374(%rip),%r14
jmp    11b0 <main+0x40>
mov    -0x90(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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