#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 /*<<< orphan*/ system(char *);
char toupper(char);
int main() {
  int li, co;
  int il, ic;
S:
  system("cls");
  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 : ");
    goto S;
  }
  system("cls");
  float matriz[li][co];
  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;
  int zero = 1;
  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;
      }
      if (lo != li) {
        for (oc = 0; oc < co; oc++) {
          laux[oc] = matriz[il][oc];
          matriz[il][oc] = matriz[ld][oc];
          matriz[ld][oc] = laux[oc];
        }
      } else {
        zero = 0;
        printf("\n impossivel");
      }
    }
    if (zero) {
      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')
    goto S;
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xea7(%rip),%rdi
call   1040 <system@plt>
lea    0xe9f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xebd(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
lea    0xeaf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe9d(%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    11c2 <main+0x82>
lea    0xe8a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1152 <main+0x12>
lea    0xe37(%rip),%rdi
call   1040 <system@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x70(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x20(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x68(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    129a <main+0x15a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1287 <main+0x147>
mov    -0x10(%rbp),%esi
add    $0x1,%esi
mov    -0x14(%rbp),%edx
add    $0x1,%edx
lea    0xe32(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x70(%rbp),%rcx
mov    -0x68(%rbp),%rsi
movslq -0x10(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe22(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1223 <main+0xe3>
jmp    128c <main+0x14c>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1210 <main+0xd0>
lea    0xd5f(%rip),%rdi
call   1040 <system@plt>
lea    0xdeb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    133b <main+0x1fb>
lea    0xdec(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1328 <main+0x1e8>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x10(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xda9(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12dc <main+0x19c>
jmp    132d <main+0x1ed>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12bb <main+0x17b>
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x54(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1664 <main+0x524>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x10(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14e3 <main+0x3a3>
jp     14e3 <main+0x3a3>
mov    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1410 <main+0x2d0>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    13f7 <main+0x2b7>
jp     13f7 <main+0x2b7>
jmp    13fd <main+0x2bd>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1402 <main+0x2c2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13b4 <main+0x274>
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     14c9 <main+0x389>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14c4 <main+0x384>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
movslq -0x10(%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 -0x10(%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    1423 <main+0x2e3>
jmp    14de <main+0x39e>
movl   $0x0,-0x54(%rbp)
lea    0xbec(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    14e3 <main+0x3a3>
cmpl   $0x0,-0x54(%rbp)
je     1648 <main+0x508>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x10(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1560 <main+0x420>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movss  -0x4c(%rbp),%xmm1
movslq -0x10(%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    1518 <main+0x3d8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1643 <main+0x503>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1630 <main+0x4f0>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
movslq -0x10(%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    15ad <main+0x46d>
jmp    1635 <main+0x4f5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1569 <main+0x429>
jmp    1648 <main+0x508>
jmp    164d <main+0x50d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1370 <main+0x230>
lea    0xa65(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16f9 <main+0x5b9>
lea    0xa2e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16e6 <main+0x5a6>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x10(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9eb(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    169a <main+0x55a>
jmp    16eb <main+0x5ab>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1679 <main+0x539>
lea    0x9f7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xa05(%rip),%rdi
lea    -0x55(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
movsbl -0x55(%rbp),%edi
call   1030 <toupper@plt>
mov    %al,-0x55(%rbp)
movsbl -0x55(%rbp),%eax
cmp    $0x53,%eax
jne    173e <main+0x5fe>
movl   $0x2,-0x5c(%rbp)
jmp    174c <main+0x60c>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
je     1769 <main+0x629>
jmp    1764 <main+0x624>
jmp    1152 <main+0x12>
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    0xe85(%rip),%rbx
lea    0xe82(%rip),%r12
lea    0xea7(%rip),%r15
lea    -0x30(%rbp),%r14
lea    0xf04(%rip),%r13
jmp    11ed <main+0x8d>
cs nopw 0x0(%rax,%rax,1)
lea    0xf05(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xf13(%rip),%rdi
lea    -0x31(%rbp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movsbl -0x31(%rbp),%edi
call   1040 <toupper@plt>
mov    %al,-0x31(%rbp)
cmp    $0x53,%al
mov    -0x108(%rbp),%rsp
lea    0xe24(%rip),%rbx
lea    0xe21(%rip),%r12
lea    -0x30(%rbp),%r14
jne    1e83 <main+0xd23>
mov    %rbx,%rdi
call   1060 <system@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    %r14,%rbx
lea    0xe2a(%rip),%r14
lea    0xe17(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
lea    -0x2c(%rbp),%r12
nopl   0x0(%rax,%rax,1)
mov    %r12,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
cmp    %eax,-0x30(%rbp)
jge    1290 <main+0x130>
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xdaa(%rip),%rdi
call   1060 <system@plt>
lea    0xda2(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
lea    0xdb7(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
jmp    1230 <main+0xd0>
nopl   0x0(%rax)
lea    0xd69(%rip),%rdi
call   1060 <system@plt>
mov    %rsp,-0x108(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%edx
mov    %rdx,%rcx
mov    %rdx,-0x48(%rbp)
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    -0x30(%rbp),%ecx
test   %ecx,%ecx
jle    1380 <main+0x220>
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%rdx
lea    0x0(,%rdx,4),%rdx
mov    %rdx,-0x78(%rbp)
mov    -0x50(%rbp),%rbx
xor    %r15d,%r15d
jmp    130c <main+0x1ac>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ecx,%rdx
add    -0x78(%rbp),%rbx
cmp    %rdx,%r15
jge    1380 <main+0x220>
add    $0x1,%r15
test   %eax,%eax
jle    1300 <main+0x1a0>
mov    %rbx,-0x88(%rbp)
xor    %r12d,%r12d
lea    0xd4f(%rip),%r14
lea    0xd68(%rip),%r13
nopl   0x0(%rax)
add    $0x1,%r12
mov    %r14,%rdi
mov    %r15d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movslq -0x2c(%rbp),%rax
add    $0x4,%rbx
cmp    %rax,%r12
jl     1330 <main+0x1d0>
mov    -0x30(%rbp),%ecx
lea    0xd30(%rip),%r13
mov    -0x88(%rbp),%rbx
jmp    1300 <main+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0xc79(%rip),%rdi
call   1060 <system@plt>
lea    0xd39(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,-0x30(%rbp)
jle    1e00 <main+0xca0>
mov    -0x48(%rbp),%rax
lea    0x0(,%rax,4),%r12
mov    -0x50(%rbp),%r15
xor    %r14d,%r14d
jmp    13d0 <main+0x270>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
movslq -0x30(%rbp),%r8
add    %r12,%r15
cmp    %r8,%r14
jge    1420 <main+0x2c0>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpl   $0x0,-0x2c(%rbp)
jle    13c0 <main+0x260>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r15,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     13f0 <main+0x290>
jmp    13c0 <main+0x260>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r8d,%r8d
xorps  %xmm6,%xmm6
jle    1e00 <main+0xca0>
mov    -0x48(%rbp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,-0x148(%rbp)
lea    0x4(,%rax,4),%rcx
mov    %rcx,-0x118(%rbp)
mov    -0x50(%rbp),%r14
lea    0x4(%r14),%rdx
lea    0x8(%r14),%rsi
mov    %rsi,-0x110(%rbp)
lea    0x30(%r14),%rsi
lea    0x14(%r14),%r11
lea    0x4(%r12),%rdi
mov    %rdi,-0x168(%rbp)
lea    0x34(%r14),%rdi
mov    %rdi,-0xe8(%rbp)
lea    (%r14,%rax,4),%rdi
add    $0x34,%rdi
lea    (%r14,%rax,4),%rbx
shl    $0x4,%rax
mov    %rax,-0xd0(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    $0x1,%r9d
mov    $0xffffffffffffffff,%r15
mov    $0xfffffffffffffff7,%r10
xor    %eax,%eax
mov    %rax,-0xc0(%rbp)
mov    %r14,-0xe0(%rbp)
mov    %r14,-0xf0(%rbp)
mov    %rdx,-0xd8(%rbp)
mov    %rdx,-0xf8(%rbp)
mov    %rsi,-0x100(%rbp)
xor    %ecx,%ecx
jmp    15a2 <main+0x442>
mov    %r10,-0x60(%rbp)
mov    %r15,-0x40(%rbp)
mov    %r9,-0x58(%rbp)
mov    %r11,-0xb8(%rbp)
mov    %esi,-0xc4(%rbp)
movl   $0x0,-0x7c(%rbp)
lea    0xb97(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xorps  %xmm6,%xmm6
mov    -0x30(%rbp),%r8d
mov    -0xb8(%rbp),%r11
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rbx
mov    -0x58(%rbp),%r9
mov    -0x40(%rbp),%r15
mov    -0x60(%rbp),%r10
mov    -0x90(%rbp),%rsi
mov    -0x70(%rbp),%rcx
add    $0x1,%rcx
movslq %r8d,%rax
add    $0x1,%r9
add    %r12,%rsi
add    %r12,-0xf8(%rbp)
mov    -0x168(%rbp),%rdx
add    %rdx,%r11
add    $0xffffffffffffffff,%r15
add    %r12,%r14
add    %rdx,-0xe8(%rbp)
add    %rdx,%rdi
add    $0xffffffffffffffff,%r10
add    %r12,%rbx
add    %rdx,-0xf0(%rbp)
mov    -0xc0(%rbp),%rdx
add    $0x3,%dl
mov    %rdx,-0xc0(%rbp)
addq   $0x4,-0xe0(%rbp)
04
cmp    %rax,%rcx
jge    1e00 <main+0xca0>
mov    %rbx,-0x98(%rbp)
mov    %rdi,-0xa0(%rbp)
mov    %rsi,-0x90(%rbp)
mov    %rcx,%rax
not    %rax
mov    %rax,-0x68(%rbp)
mov    %rcx,%rax
imul   -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
lea    (%rdx,%rax,4),%rdi
mov    %rcx,-0x70(%rbp)
movss  (%rdi,%rcx,4),%xmm0
ucomiss %xmm6,%xmm0
mov    -0xc4(%rbp),%esi
jne    18f0 <main+0x790>
jp     18f0 <main+0x790>
movslq %r8d,%rax
mov    -0x70(%rbp),%rcx
cmp    %rax,%rcx
jge    1680 <main+0x520>
mov    %r8,%rdx
mov    %edx,%r8d
mov    %edx,%eax
sub    %ecx,%eax
add    %r8,-0x68(%rbp)
test   $0x3,%al
mov    %r11,-0xb8(%rbp)
mov    %r9,-0x58(%rbp)
mov    %r15,-0x40(%rbp)
mov    %r10,-0x60(%rbp)
je     1751 <main+0x5f1>
add    -0xc0(%rbp),%dl
movzbl %dl,%eax
and    $0x3,%eax
mov    -0xf0(%rbp),%rdx
mov    -0xd0(%rbp),%r11
mov    -0x68(%rbp),%rdi
cs nopw 0x0(%rax,%rax,1)
ucomiss (%rdx),%xmm6
cmovne %ecx,%esi
cmovp  %ecx,%esi
add    $0x1,%rcx
add    %r12,%rdx
add    $0xffffffffffffffff,%rax
jne    1650 <main+0x4f0>
cmp    $0x3,%rdi
jb     14f4 <main+0x394>
jmp    1766 <main+0x606>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %ecx,%r8d
je     14e1 <main+0x381>
mov    -0x2c(%rbp),%ecx
test   %ecx,%ecx
jle    18f0 <main+0x790>
movslq %esi,%rax
imul   -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
lea    (%rsi,%rax,4),%rbx
cmp    $0x8,%ecx
jb     16c7 <main+0x567>
lea    (%rax,%rcx,1),%rdx
lea    (%rsi,%rdx,4),%rdx
cmp    %rdx,%rdi
jae    17d4 <main+0x674>
lea    (%rdi,%rcx,4),%rdx
cmp    %rdx,%rbx
jae    17d4 <main+0x674>
xor    %esi,%esi
mov    %rsi,%rdx
test   $0x1,%cl
je     16ec <main+0x58c>
movss  (%rdi,%rsi,4),%xmm0
movss  (%rbx,%rsi,4),%xmm1
movss  %xmm1,(%rdi,%rsi,4)
movss  %xmm0,(%rbx,%rsi,4)
mov    %rsi,%rdx
or     $0x1,%rdx
not    %rsi
add    %rcx,%rsi
je     18f0 <main+0x790>
mov    -0xd8(%rbp),%rsi
lea    (%rsi,%rax,4),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xf8(%rbp),%rsi
movss  -0x4(%rsi,%rdx,4),%xmm0
movss  -0x4(%rax,%rdx,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rdx,4)
movss  %xmm0,-0x4(%rax,%rdx,4)
movss  (%rsi,%rdx,4),%xmm0
movss  (%rax,%rdx,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movss  %xmm0,(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1710 <main+0x5b0>
jmp    18f0 <main+0x790>
mov    -0xd0(%rbp),%r11
mov    -0x68(%rbp),%rdi
cmp    $0x3,%rdi
jb     14f4 <main+0x394>
lea    0x3(%rcx),%r9
imul   %r12,%r9
lea    0x2(%rcx),%r10
imul   %r12,%r10
mov    %r12,%rdi
imul   %rcx,%rdi
lea    0x1(%rcx),%rbx
imul   %r12,%rbx
mov    -0xe0(%rbp),%rax
nopl   0x0(%rax)
ucomiss (%rax,%rdi,1),%xmm6
cmovne %ecx,%esi
cmovp  %ecx,%esi
lea    0x1(%rcx),%edx
ucomiss (%rax,%rbx,1),%xmm6
cmovne %edx,%esi
cmovp  %edx,%esi
lea    0x2(%rcx),%edx
ucomiss (%rax,%r10,1),%xmm6
cmovne %edx,%esi
cmovp  %edx,%esi
lea    0x3(%rcx),%edx
ucomiss (%rax,%r9,1),%xmm6
cmovne %edx,%esi
cmovp  %edx,%esi
add    $0x4,%rcx
add    %r11,%rax
cmp    %r8,%rcx
jne    1790 <main+0x630>
jmp    14f4 <main+0x394>
mov    %r15,-0x40(%rbp)
mov    %r9,-0x58(%rbp)
mov    %ecx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
mov    %r10,-0x60(%rbp)
mov    %r8,-0xb0(%rbp)
mov    %rbx,-0x88(%rbp)
mov    %rdi,%r15
je     1890 <main+0x730>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    -0x100(%rbp),%rdx
lea    (%rdx,%rax,4),%rdx
xor    %ebx,%ebx
mov    -0x90(%rbp),%r8
nopl   0x0(%rax)
movups -0x30(%r8,%rbx,4),%xmm0
movups -0x20(%r8,%rbx,4),%xmm1
movups -0x30(%rdx,%rbx,4),%xmm2
movups -0x20(%rdx,%rbx,4),%xmm3
movups %xmm2,-0x30(%r8,%rbx,4)
movups %xmm3,-0x20(%r8,%rbx,4)
movups %xmm0,-0x30(%rdx,%rbx,4)
movups %xmm1,-0x20(%rdx,%rbx,4)
movups -0x10(%r8,%rbx,4),%xmm0
movups (%r8,%rbx,4),%xmm1
movups -0x10(%rdx,%rbx,4),%xmm2
movups (%rdx,%rbx,4),%xmm3
movups %xmm2,-0x10(%r8,%rbx,4)
movups %xmm3,(%r8,%rbx,4)
movups %xmm0,-0x10(%rdx,%rbx,4)
movups %xmm1,(%rdx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1830 <main+0x6d0>
jmp    1892 <main+0x732>
xor    %ebx,%ebx
test   $0x1,%r9b
mov    %r15,%rdi
je     18c6 <main+0x766>
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm1
mov    -0x88(%rbp),%rdx
movups (%rdx,%rbx,4),%xmm2
movups 0x10(%rdx,%rbx,4),%xmm3
movups %xmm2,(%rdi,%rbx,4)
movups %xmm3,0x10(%rdi,%rbx,4)
movups %xmm0,(%rdx,%rbx,4)
movups %xmm1,0x10(%rdx,%rbx,4)
cmp    %rcx,%rsi
mov    -0x58(%rbp),%r9
mov    -0x40(%rbp),%r15
mov    -0x60(%rbp),%r10
mov    -0xb0(%rbp),%r8
mov    -0x88(%rbp),%rbx
jne    16c9 <main+0x569>
nopl   0x0(%rax)
cmpl   $0x0,-0x7c(%rbp)
je     196b <main+0x80b>
mov    %rdi,-0xa8(%rbp)
mov    %r8,-0xb0(%rbp)
mov    %r10,-0x60(%rbp)
movslq -0x2c(%rbp),%rax
mov    %eax,%edi
mov    %rax,-0x88(%rbp)
cmp    %rax,-0x70(%rbp)
jge    1a40 <main+0x8e0>
mov    -0x70(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movss  (%rcx,%rax,4),%xmm0
movaps %xmm0,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rdi,%rax
je     1a40 <main+0x8e0>
mov    %r15,-0x40(%rbp)
mov    %r9,-0x58(%rbp)
mov    -0x68(%rbp),%rcx
lea    (%rcx,%rdi,1),%r9
cmp    $0x4,%r9
jae    1977 <main+0x817>
mov    -0x58(%rbp),%r9
mov    -0x40(%rbp),%r15
jmp    1a20 <main+0x8c0>
movl   $0x0,-0x7c(%rbp)
jmp    1d99 <main+0xc39>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%r8),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1de7 <main+0xc87>
mov    -0x40(%rbp),%rdx
add    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x10(%r11,%rbx,4),%xmm2
movups (%r11,%rbx,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%r11,%rbx,4)
divps  %xmm1,%xmm3
movups %xmm3,(%r11,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    19c0 <main+0x860>
test   $0x1,%sil
je     1a01 <main+0x8a1>
add    %rax,%rbx
mov    -0xa8(%rbp),%rcx
movups (%rcx,%rbx,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rcx,%rbx,4)
cmp    %r8,%r9
mov    -0x58(%rbp),%r9
mov    -0x40(%rbp),%r15
je     1a40 <main+0x8e0>
add    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1a20 <main+0x8c0>
nopl   0x0(%rax)
mov    -0x70(%rbp),%rcx
lea    0x1(%rcx),%rdx
mov    -0xb0(%rbp),%r8
movslq %r8d,%rax
mov    %rdx,-0x78(%rbp)
cmp    %rax,%rdx
jge    1d95 <main+0xc35>
mov    %r15,-0x40(%rbp)
mov    %r11,-0xb8(%rbp)
mov    -0x118(%rbp),%rdx
imul   %rcx,%rdx
mov    -0x48(%rbp),%rsi
sub    %rcx,%rsi
mov    -0x110(%rbp),%rax
mov    %rdx,-0x160(%rbp)
add    %rdx,%rax
mov    $0xfffffffffffffffe,%rdx
sub    %rcx,%rdx
mov    %r8d,%ebx
mov    %rbx,-0x178(%rbp)
add    %rdi,%rsi
mov    %rsi,-0x158(%rbp)
add    %rdi,%rdx
lea    (%rax,%rdx,4),%rax
mov    %rax,-0x150(%rbp)
mov    -0x68(%rbp),%r15
lea    (%r15,%rdi,1),%rax
add    $0xfffffffffffffff8,%rax
add    %rdi,%r15
mov    %rax,-0x140(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x138(%rbp)
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x130(%rbp)
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x128(%rbp)
mov    %rdi,%rax
neg    %rax
mov    %rax,-0x170(%rbp)
mov    -0x60(%rbp),%rax
add    %rdi,%rax
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x120(%rbp)
mov    -0x98(%rbp),%r10
mov    %r9,%r11
mov    -0xa0(%rbp),%r9
xor    %r8d,%r8d
mov    %r11,-0x58(%rbp)
mov    %r15,-0x68(%rbp)
jmp    1b5b <main+0x9fb>
nop
add    $0x1,%r11
add    $0x1,%r8
add    %r12,%r9
add    %r12,%r10
cmp    -0x178(%rbp),%r11
je     1db3 <main+0xc53>
cmp    -0x88(%rbp),%rcx
jge    1b40 <main+0x9e0>
mov    %r11,%rax
imul   -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
lea    (%rdx,%rax,4),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0xa8(%rbp),%rdx
movss  (%rdx,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rax,%rcx,4)
cmp    %rdi,-0x78(%rbp)
je     1b40 <main+0x9e0>
mov    -0x78(%rbp),%rsi
cmp    $0x8,%r15
jb     1d00 <main+0xba0>
mov    %r8,%rdx
imul   -0x48(%rbp),%rdx
mov    -0x148(%rbp),%rcx
lea    (%rcx,%rdx,1),%rsi
mov    -0x50(%rbp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    -0x160(%rbp),%rsi
add    %rcx,%rsi
add    -0x158(%rbp),%rdx
mov    -0x50(%rbp),%rbx
mov    %r12,%r15
lea    (%rbx,%rdx,4),%r12
cmp    -0x150(%rbp),%rsi
setb   %bl
cmp    %r12,-0xd8(%rbp)
setb   %dl
mov    -0x78(%rbp),%rsi
cmp    %r12,%rcx
mov    %r15,%r12
mov    -0x68(%rbp),%r15
jb     1d00 <main+0xba0>
mov    -0x78(%rbp),%rsi
and    %dl,%bl
jne    1d00 <main+0xba0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,-0x140(%rbp)
08
jae    1c29 <main+0xac9>
xor    %esi,%esi
jmp    1ca3 <main+0xb43>
mov    -0x120(%rbp),%rbx
xor    %esi,%esi
mov    -0xe8(%rbp),%rcx
nopl   0x0(%rax)
movups -0x30(%rcx,%rsi,4),%xmm2
movups -0x20(%rcx,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups -0x30(%r9,%rsi,4),%xmm4
subps  %xmm2,%xmm4
movups -0x20(%r9,%rsi,4),%xmm2
subps  %xmm3,%xmm2
movups -0x10(%r9,%rsi,4),%xmm3
movups (%r9,%rsi,4),%xmm5
movups %xmm4,-0x30(%r9,%rsi,4)
movups %xmm2,-0x20(%r9,%rsi,4)
movups -0x10(%rcx,%rsi,4),%xmm2
movups (%rcx,%rsi,4),%xmm4
mulps  %xmm1,%xmm2
subps  %xmm2,%xmm3
mulps  %xmm1,%xmm4
subps  %xmm4,%xmm5
movups %xmm3,-0x10(%r9,%rsi,4)
movups %xmm5,(%r9,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1c40 <main+0xae0>
testb  $0x1,-0x138(%rbp)
mov    -0x70(%rbp),%rcx
je     1ce2 <main+0xb82>
add    -0x78(%rbp),%rsi
movups (%rax,%rsi,4),%xmm2
movups 0x10(%rax,%rsi,4),%xmm3
mov    -0xa8(%rbp),%rdx
movups (%rdx,%rsi,4),%xmm4
movups 0x10(%rdx,%rsi,4),%xmm5
mulps  %xmm1,%xmm4
subps  %xmm4,%xmm2
mulps  %xmm1,%xmm5
subps  %xmm5,%xmm3
movups %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
mov    -0x128(%rbp),%rsi
cmp    -0x130(%rbp),%r15
je     1b40 <main+0x9e0>
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%ecx
sub    %esi,%ecx
mov    %rsi,%rbx
test   $0x1,%cl
je     1d2e <main+0xbce>
movss  (%rax,%rsi,4),%xmm1
mov    -0xa8(%rbp),%rcx
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rax,%rsi,4)
lea    0x1(%rsi),%rbx
not    %rsi
cmp    -0x170(%rbp),%rsi
mov    -0x70(%rbp),%rcx
je     1b40 <main+0x9e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
movss  (%r10,%rbx,4),%xmm2
subss  %xmm1,%xmm2
movss  0x4(%r10,%rbx,4),%xmm1
movss  %xmm2,(%r10,%rbx,4)
movss  0x4(%r14,%rbx,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%r10,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    1d50 <main+0xbf0>
jmp    1b40 <main+0x9e0>
mov    -0x60(%rbp),%r10
mov    -0x90(%rbp),%rsi
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rbx
jmp    153e <main+0x3de>
mov    -0xb8(%rbp),%r11
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rbx
mov    -0x58(%rbp),%r9
mov    -0x40(%rbp),%r15
mov    -0x60(%rbp),%r10
mov    -0x90(%rbp),%rsi
mov    -0xb0(%rbp),%r8
jmp    153e <main+0x3de>
xor    %ebx,%ebx
test   $0x1,%sil
jne    19ec <main+0x88c>
jmp    1a01 <main+0x8a1>
nopl   0x0(%rax,%rax,1)
lea    0x2e8(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,-0x30(%rbp)
lea    0x219(%rip),%r15
jle    11a0 <main+0x40>
shlq   $0x2,-0x48(%rbp)
xor    %r14d,%r14d
jmp    1e49 <main+0xce9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
movslq -0x30(%rbp),%rax
add    -0x48(%rbp),%r12
mov    %r12,-0x50(%rbp)
cmp    %rax,%r14
jge    11a0 <main+0x40>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpl   $0x0,-0x2c(%rbp)
mov    -0x50(%rbp),%r12
jle    1e30 <main+0xcd0>
xor    %ebx,%ebx
nop
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1e60 <main+0xd00>
jmp    1e30 <main+0xcd0>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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