#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*/ exit(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, float *);
main() {
  int n = 3;
  float A[n][n];
  float b[n];
  float x[n];
  int i, j, k;
  float m;
  float s;
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("Digite o coeficiente A[%d][%d] = ", i + 1, j + 1);
      scanf("%f", &A[i][j]);
    }
  }
  for (i = 0; i < n; i++) {
    printf("Digite o coeficiente b[%d] = ", i + 1);
    scanf("%f", &b[i]);
  }
  for (k = 0; k < (n - 1); k++) {
    for (i = k + 1; i < n; i++) {
      if (A[k][k] == 0.0) {
        printf(
            "Detectado pivô nulo na fase de eliminação... Aborto o programa\n");
        exit(1);
      }
      m = A[i][k] / A[k][k];
      A[i][k] = 0.0;
      for (j = k + 1; j < n; j++) {
        A[i][j] = A[i][j] - m * A[k][j];
      }
      b[i] = b[i] - m * b[k];
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      printf("A matriz A e o vetor b resultaram transformados em: [%d][%d] "
             "%.2f \n",
             i + 1, j + 1, A[i][j]);
  }
  x[n - 1] = b[n - 1] / A[n - 1][n - 1];
  for (k = n - 2; k >= 0; k--) {
    s = 0.0;
    for (j = k + 1; j < n; j++) {
      s = s + A[k][j] * x[j];
    }
    x[k] = (b[k] - s) / A[k][k];
  }
  for (i = 0; i < n; i++) {
    for (j = i + 1; j < n; j++) {
      for (k = j + 1; k < n; k++) {
        printf("o vetor solução é %.2f \n", x[i]);
        printf("o vetor solução é %.2f \n", x[j]);
        printf("o vetor solução é %.2f \n", x[k]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x3,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x68(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x10(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x18(%rbp)
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    124b <main+0x11b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1238 <main+0x108>
mov    -0x34(%rbp),%esi
add    $0x1,%esi
mov    -0x38(%rbp),%edx
add    $0x1,%edx
lea    0xe0b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x68(%rbp),%rcx
mov    -0x60(%rbp),%rsi
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xdfd(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11d6 <main+0xa6>
jmp    123d <main+0x10d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c3 <main+0x93>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    129b <main+0x16b>
mov    -0x34(%rbp),%esi
add    $0x1,%esi
lea    0xdba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x58(%rbp),%rsi
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xd9a(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1252 <main+0x122>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1464 <main+0x334>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1451 <main+0x321>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1317 <main+0x1e7>
jp     1317 <main+0x1e7>
lea    0xd3d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x3c(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm0
movslq -0x3c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x3c(%rbp),%rsi
divss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1409 <main+0x2d9>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x38(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm1
movss  -0x40(%rbp),%xmm0
movslq -0x3c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x38(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    137e <main+0x24e>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x40(%rbp),%xmm0
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bc <main+0x18c>
jmp    1456 <main+0x326>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a2 <main+0x172>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14e9 <main+0x3b9>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d6 <main+0x3a6>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdi
mov    -0x34(%rbp),%esi
add    $0x1,%esi
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq -0x34(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbc5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    147e <main+0x34e>
jmp    14db <main+0x3ab>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146b <main+0x33b>
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x8(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
divss  (%rcx,%rdx,4),%xmm0
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1601 <main+0x4d1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15b4 <main+0x484>
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
movss  -0x44(%rbp),%xmm1
movslq -0x3c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x38(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    155b <main+0x42b>
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
mov    -0x58(%rbp),%rdx
movslq -0x3c(%rbp),%rdi
movss  (%rdx,%rdi,4),%xmm0
subss  -0x44(%rbp),%xmm0
movslq -0x3c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x3c(%rbp),%rdx
divss  (%rcx,%rdx,4),%xmm0
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1540 <main+0x410>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16cf <main+0x59f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16bc <main+0x58c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16a9 <main+0x579>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa74(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa55(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa36(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1632 <main+0x502>
jmp    16ae <main+0x57e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    161d <main+0x4ed>
jmp    16c1 <main+0x591>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1608 <main+0x4d8>
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x48,%rsp
lea    0xebe(%rip),%r14
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xec5(%rip),%r12
mov    %rsp,%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x4(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x8(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
lea    0xc(%rsp),%r15
mov    %r14,%rdi
mov    $0x2,%esi
mov    $0x1,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x10(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x2,%esi
mov    $0x3,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x14(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
lea    0x18(%rsp),%r15
mov    %r14,%rdi
mov    $0x3,%esi
mov    $0x1,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x3,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1c(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x20(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
lea    0xda8(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x30(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x34(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x38(%rsp),%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
movss  (%rsp),%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jne    12f4 <main+0x1b4>
jnp    15b2 <main+0x472>
movss  0xc(%rsp),%xmm2
movl   $0x0,0xc(%rsp)
movaps 0xcf7(%rip),%xmm5
xorps  %xmm5,%xmm2
divss  %xmm3,%xmm2
movss  0x4(%rsp),%xmm6
movss  0x8(%rsp),%xmm4
movaps %xmm2,%xmm1
mulss  %xmm6,%xmm1
addss  0x10(%rsp),%xmm1
movss  %xmm1,0x10(%rsp)
movaps %xmm2,%xmm7
mulss  %xmm4,%xmm7
addss  0x14(%rsp),%xmm7
movss  %xmm7,0x14(%rsp)
movss  0x18(%rsp),%xmm7
xorps  %xmm5,%xmm7
movss  0x30(%rsp),%xmm5
mulss  %xmm5,%xmm2
addss  0x34(%rsp),%xmm2
movl   $0x0,0x18(%rsp)
divss  %xmm3,%xmm7
mulss  %xmm7,%xmm6
addss  0x1c(%rsp),%xmm6
movss  %xmm6,0x1c(%rsp)
mulss  %xmm7,%xmm4
addss  0x20(%rsp),%xmm4
movss  %xmm2,0x34(%rsp)
mulss  %xmm5,%xmm7
addss  0x38(%rsp),%xmm7
movss  %xmm4,0x20(%rsp)
movss  %xmm7,0x38(%rsp)
ucomiss %xmm0,%xmm1
jne    13a8 <main+0x268>
jnp    15b2 <main+0x472>
movss  0x1c(%rsp),%xmm0
movl   $0x0,0x1c(%rsp)
xorps  0xc43(%rip),%xmm0
divss  %xmm1,%xmm0
movss  0x14(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  0x20(%rsp),%xmm1
mulss  0x34(%rsp),%xmm0
addss  0x38(%rsp),%xmm0
movss  %xmm1,0x20(%rsp)
movss  %xmm0,0x38(%rsp)
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc5a(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x3,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x38(%rsp),%xmm1
divss  0x20(%rsp),%xmm1
movss  0x14(%rsp),%xmm0
mulss  %xmm1,%xmm0
movaps %xmm1,%xmm3
movss  %xmm1,0x44(%rsp)
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
movss  0x30(%rsp),%xmm2
movss  0x34(%rsp),%xmm4
subss  %xmm0,%xmm4
divss  0x10(%rsp),%xmm4
movss  %xmm4,0x40(%rsp)
movss  0x4(%rsp),%xmm0
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsp),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  (%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
lea    0xb25(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
lea    0xafa(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   1060 <exit@plt>

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

LLVM IR (-O2):
@.str = [34 x i8] c"Digite o coeficiente A[%d][%d] = \00"
@.str.1 = [3 x i8] c"%f\00"
@.str.2 = [30 x i8] c"Digite o coeficiente b[%d] = \00"
@.str.4 = [68 x i8] c"A matriz A e o vetor b resultaram transformados em: [%d][%d] %.2f \0A\00"
@.str.5 = [28 x i8] c"o vetor solu\C3\A7\C3\A3o \C3\A9 %.2f \0A\00"
@str = [66 x i8] c"Detectado piv\C3\B4 nulo na fase de elimina\C3\A7\C3\A3o... Aborto o programa\00"
define i32 @main() {
%1 = alloca [9 x float]
%2 = alloca [3 x float]
%3 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 0
%4 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 1, i32 1)
%5 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %3)
%6 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 1, i32 2)
%7 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 1
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %7)
%9 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 1, i32 3)
%10 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 2
%11 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %10)
%12 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 3
%13 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 2, i32 1)
%14 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %12)
%15 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 2, i32 2)
%16 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 4
%17 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %16)
%18 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 2, i32 3)
%19 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 5
%20 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %19)
%21 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 6
%22 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 3, i32 1)
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %21)
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 3, i32 2)
%25 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 7
%26 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %25)
%27 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 3, i32 3)
%28 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 8
%29 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %28)
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), i32 1)
%31 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 0
%32 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %31)
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), i32 2)
%34 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 1
%35 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %34)
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), i32 3)
%37 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 2
%38 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), float* %37)
%39 = load float, float* %3
%40 = fcmp oeq float %39, 0.000000e+00
br i1 %40, label %67, label %41
41: ; preds = %0
%42 = load float, float* %12
store float 0.000000e+00, float* %12
%43 = fneg float %42
%44 = fdiv float %43, %39
%45 = load float, float* %16
%46 = load float, float* %7
%47 = call float @llvm.fmuladd.f32(float %44, float %46, float %45)
store float %47, float* %16
%48 = load float, float* %19
%49 = load float, float* %10
%50 = call float @llvm.fmuladd.f32(float %44, float %49, float %48)
store float %50, float* %19
%51 = load float, float* %34
%52 = load float, float* %31
%53 = call float @llvm.fmuladd.f32(float %44, float %52, float %51)
store float %53, float* %34
%54 = load float, float* %21
store float 0.000000e+00, float* %21
%55 = fneg float %54
%56 = fdiv float %55, %39
%57 = load float, float* %25
%58 = load float, float* %7
%59 = call float @llvm.fmuladd.f32(float %56, float %58, float %57)
store float %59, float* %25
%60 = load float, float* %28
%61 = load float, float* %10
%62 = call float @llvm.fmuladd.f32(float %56, float %61, float %60)
store float %62, float* %28
%63 = load float, float* %37
%64 = call float @llvm.fmuladd.f32(float %56, float %52, float %63)
store float %64, float* %37
%65 = load float, float* %16
%66 = fcmp oeq float %65, 0.000000e+00
br i1 %66, label %67, label %70
67: ; preds = %41, %0
%68 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str, i64 0, i64 0))
%69 = call i32 @exit(i32 1)
unreachable
70: ; preds = %41
%71 = load float, float* %25
store float 0.000000e+00, float* %25
%72 = fneg float %71
%73 = fdiv float %72, %65
%74 = load float, float* %28
%75 = load float, float* %19
%76 = call float @llvm.fmuladd.f32(float %73, float %75, float %74)
store float %76, float* %28
%77 = load float, float* %37
%78 = load float, float* %34
%79 = call float @llvm.fmuladd.f32(float %73, float %78, float %77)
store float %79, float* %37
%80 = load float, float* %3
%81 = fpext float %80 to double
%82 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 1, i32 1, double %81)
%83 = load float, float* %7
%84 = fpext float %83 to double
%85 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 1, i32 2, double %84)
%86 = load float, float* %10
%87 = fpext float %86 to double
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 1, i32 3, double %87)
%89 = load float, float* %12
%90 = fpext float %89 to double
%91 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 2, i32 1, double %90)
%92 = load float, float* %16
%93 = fpext float %92 to double
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 2, i32 2, double %93)
%95 = load float, float* %19
%96 = fpext float %95 to double
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 2, i32 3, double %96)
%98 = load float, float* %21
%99 = fpext float %98 to double
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 3, i32 1, double %99)
%101 = load float, float* %25
%102 = fpext float %101 to double
%103 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 3, i32 2, double %102)
%104 = load float, float* %28
%105 = fpext float %104 to double
%106 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.4, i64 0, i64 0), i32 3, i32 3, double %105)
%107 = load float, float* %37
%108 = getelementptr inbounds [9 x float], [9 x float]* %1, i64 0, i64 8
%109 = load float, float* %108
%110 = fdiv float %107, %109
%111 = load float, float* %19
%112 = call float @llvm.fmuladd.f32(float %111, float %110, float 0.000000e+00)
%113 = load float, float* %34
%114 = fsub float %113, %112
%115 = load float, float* %16
%116 = fdiv float %114, %115
%117 = load float, float* %7
%118 = call float @llvm.fmuladd.f32(float %117, float %116, float 0.000000e+00)
%119 = load float, float* %10
%120 = call float @llvm.fmuladd.f32(float %119, float %110, float %118)
%121 = load float, float* %31
%122 = fsub float %121, %120
%123 = load float, float* %3
%124 = fdiv float %122, %123
%125 = fpext float %124 to double
%126 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), double %125)
%127 = fpext float %116 to double
%128 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), double %127)
%129 = fpext float %110 to double
%130 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), double %129)
ret i32 0
}