main() {
  int n;
  float **A;
  float *b;
  float *x;
  int i, j, k;
  float m;
  float s;
  printf("Digite a quantidade de variáveis do sistema n = ");
  scanf("%d", &n);
  A = malloc(n * sizeof(float *));
  for (i = 0; i < n; i++) {
    A[i] = malloc(n * sizeof(float));
  }
  b = malloc(n * sizeof(float));
  x = malloc(n * sizeof(float));
  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");
        for (i = 0; i < n; i++) {
          free(A[i]);
        }
        free(A);
        free(b);
        free(x);
        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];
    }
  }
  printf("A matriz A e o vetor b resultaram transformados em:\n");
  printf("\nMatriz A:\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("| %f ", A[i][j]);
    }
    printf("\n");
  }
  printf("\n\nVetor b:\n");
  for (i = 0; i < n; i++) {
    printf("| %f ", b[i]);
  }
  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];
  }
  printf("\n\n O vetor solução é \n");
  for (k = 0; k < n; k++) {
    printf("| %f ", x[k]);
  }
  printf("\n");
  for (i = 0; i < n; i++) {
    free(A[i]);
  }
  free(A);
  free(b);
  free(x);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xebe(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11cd <main+0x7d>
movslq -0x8(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1197 <main+0x47>
movslq -0x8(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1275 <main+0x125>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1262 <main+0x112>
mov    -0x24(%rbp),%esi
add    $0x1,%esi
mov    -0x28(%rbp),%edx
add    $0x1,%edx
lea    0xe0d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x28(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe0a(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1209 <main+0xb9>
jmp    1267 <main+0x117>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f6 <main+0xa6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12c7 <main+0x177>
mov    -0x24(%rbp),%esi
add    $0x1,%esi
lea    0xdc5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rsi
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xda5(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    127c <main+0x12c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14aa <main+0x35a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1497 <main+0x347>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1385 <main+0x235>
jp     1385 <main+0x235>
lea    0xd51(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1360 <main+0x210>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1335 <main+0x1e5>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1448 <main+0x2f8>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13d5 <main+0x285>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e8 <main+0x198>
jmp    149c <main+0x34c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ce <main+0x17e>
lea    0xc0a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc31(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    153d <main+0x3ed>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1521 <main+0x3d1>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbf0(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14e0 <main+0x390>
lea    0xbfe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14cd <main+0x37d>
lea    0xbbe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    158b <main+0x43b>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb86(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1552 <main+0x402>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1682 <main+0x532>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1640 <main+0x4f0>
movss  -0x34(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15f2 <main+0x4a2>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x34(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d7 <main+0x487>
lea    0xa85(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16d0 <main+0x580>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa41(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1697 <main+0x547>
lea    0xa4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1710 <main+0x5c0>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16e5 <main+0x595>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
lea    0xe8b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xeaf(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movslq 0x4(%rsp),%r14
lea    0x0(,%r14,8),%rdi
call   1070 <malloc@plt>
mov    %rax,%r13
lea    0x0(,%r14,4),%r15
test   %r14,%r14
jle    11e6 <main+0x76>
mov    %r14d,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    11d0 <main+0x60>
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,0x18(%rsp)
test   %r14d,%r14d
jle    158b <main+0x41b>
lea    0xe35(%rip),%rbp
xor    %r12d,%r12d
mov    %r13,0x10(%rsp)
jmp    122b <main+0xbb>
nopw   0x0(%rax,%rax,1)
movslq %r14d,%rax
mov    %rbx,%r12
cmp    %rax,%rbx
jge    1282 <main+0x112>
lea    0x1(%r12),%rbx
test   %r14d,%r14d
jle    1220 <main+0xb0>
xor    %r13d,%r13d
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rsi
add    %r13,%rsi
lea    0xe01(%rip),%rdi
xor    %eax,%eax
call   1080 <scanf@plt>
movslq 0x4(%rsp),%r14
add    $0x4,%r13
cmp    %r14,%r15
jl     1240 <main+0xd0>
mov    0x10(%rsp),%r13
jmp    1220 <main+0xb0>
test   %r14d,%r14d
jle    158b <main+0x41b>
lea    0xdd8(%rip),%r15
lea    0xdce(%rip),%r13
mov    0x8(%rsp),%rbx
xor    %ebp,%ebp
add    $0x1,%rbp
mov    %r15,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
movslq 0x4(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     12a0 <main+0x130>
mov    %eax,%r12d
cmp    $0x2,%r12d
mov    0x10(%rsp),%r13
jl     158b <main+0x41b>
lea    -0x1(%r12),%eax
mov    %rax,0x28(%rsp)
mov    %r12,%r8
neg    %r8
lea    -0x9(%r12),%rax
mov    %rax,0x20(%rsp)
mov    $0x1,%r15d
mov    $0xd,%r14d
xor    %ebx,%ebx
xorps  %xmm8,%xmm8
movaps 0xcf0(%rip),%xmm1
jmp    133e <main+0x1ce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
add    $0x1,%r14
addq   $0xffffffffffffffff,0x20(%rsp)
mov    0x30(%rsp),%rbx
cmp    0x28(%rsp),%rbx
je     158b <main+0x41b>
lea    0x1(%rbx),%rax
mov    %rax,0x30(%rsp)
cmp    %r12,%rax
jae    1320 <main+0x1b0>
mov    0x20(%rsp),%rax
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x38(%rsp)
mov    %rbx,%rcx
not    %rcx
lea    (%rcx,%r12,1),%rax
add    $0xfffffffffffffff8,%rax
add    %r12,%rcx
mov    %rax,0x58(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,0x50(%rsp)
mov    0x0(%r13,%rbx,8),%rsi
lea    (%rsi,%r15,4),%rax
mov    %rax,0x60(%rsp)
lea    (%rsi,%r12,4),%r9
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rsp)
add    %r15,%rax
mov    %rax,0x40(%rsp)
lea    (%rsi,%r14,4),%r10
mov    %r15,%rdi
jmp    13e1 <main+0x271>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rax
mulss  (%rax,%rbx,4),%xmm2
addss  (%rax,%rdi,4),%xmm2
movss  %xmm2,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %r12,%rdi
je     1320 <main+0x1b0>
movss  (%rsi,%rbx,4),%xmm3
ucomiss %xmm8,%xmm3
jne    13f2 <main+0x282>
jnp    1851 <main+0x6e1>
mov    0x0(%r13,%rdi,8),%r11
movss  (%r11,%rbx,4),%xmm2
xorps  %xmm1,%xmm2
movl   $0x0,(%r11,%rbx,4)
divss  %xmm3,%xmm2
mov    %r15,%rbp
cmp    $0x8,%rcx
jb     1510 <main+0x3a0>
lea    (%r11,%r15,4),%rdx
cmp    %r9,%rdx
jae    1434 <main+0x2c4>
lea    (%r11,%r12,4),%rdx
mov    %r15,%rbp
cmp    %rdx,0x60(%rsp)
jb     1510 <main+0x3a0>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
cmpq   $0x8,0x58(%rsp)
jae    1447 <main+0x2d7>
xor    %ebp,%ebp
jmp    14bf <main+0x34f>
lea    (%r11,%r14,4),%rdx
mov    0x38(%rsp),%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%r10,%rbp,4),%xmm4
movups -0x20(%r10,%rbp,4),%xmm5
mulps  %xmm3,%xmm4
movups -0x30(%rdx,%rbp,4),%xmm6
addps  %xmm4,%xmm6
movups -0x20(%rdx,%rbp,4),%xmm4
movups -0x10(%rdx,%rbp,4),%xmm7
movups (%rdx,%rbp,4),%xmm0
mulps  %xmm3,%xmm5
addps  %xmm4,%xmm5
movups %xmm6,-0x30(%rdx,%rbp,4)
movups %xmm5,-0x20(%rdx,%rbp,4)
movups -0x10(%r10,%rbp,4),%xmm4
movups (%r10,%rbp,4),%xmm5
mulps  %xmm3,%xmm4
addps  %xmm7,%xmm4
mulps  %xmm3,%xmm5
addps  %xmm0,%xmm5
movups %xmm4,-0x10(%rdx,%rbp,4)
movups %xmm5,(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%r13
jne    1460 <main+0x2f0>
testb  $0x1,0x50(%rsp)
mov    0x10(%rsp),%r13
je     14f9 <main+0x389>
add    %r15,%rbp
movups (%r11,%rbp,4),%xmm0
movups 0x10(%r11,%rbp,4),%xmm4
movups (%rsi,%rbp,4),%xmm5
movups 0x10(%rsi,%rbp,4),%xmm6
mulps  %xmm3,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm3,%xmm6
addps  %xmm4,%xmm6
movups %xmm5,(%r11,%rbp,4)
movups %xmm6,0x10(%r11,%rbp,4)
mov    0x40(%rsp),%rbp
cmp    0x48(%rsp),%rcx
je     13c0 <main+0x250>
nopl   0x0(%rax)
mov    %r12d,%eax
sub    %ebp,%eax
mov    %rbp,%rdx
test   $0x1,%al
je     1535 <main+0x3c5>
movss  (%rsi,%rbp,4),%xmm0
mulss  %xmm2,%xmm0
addss  (%r11,%rbp,4),%xmm0
movss  %xmm0,(%r11,%rbp,4)
lea    0x1(%rbp),%rdx
not    %rbp
cmp    %r8,%rbp
je     13c0 <main+0x250>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm0
mulss  %xmm2,%xmm0
addss  (%r11,%rdx,4),%xmm0
movss  %xmm0,(%r11,%rdx,4)
movss  0x4(%rsi,%rdx,4),%xmm0
mulss  %xmm2,%xmm0
addss  0x4(%r11,%rdx,4),%xmm0
movss  %xmm0,0x4(%r11,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    1550 <main+0x3e0>
jmp    13c0 <main+0x250>
lea    0xafc(%rip),%rdi
call   1050 <puts@plt>
lea    0xb24(%rip),%rdi
call   1050 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1614 <main+0x4a4>
xor    %r14d,%r14d
lea    0xad3(%rip),%r15
jmp    15d8 <main+0x468>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1040 <putchar@plt>
add    $0x1,%r14
movslq 0x4(%rsp),%rax
cmp    %rax,%r14
jge    1614 <main+0x4a4>
test   %eax,%eax
jle    15c0 <main+0x450>
mov    0x0(%r13,%r14,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     15f0 <main+0x480>
jmp    15c0 <main+0x450>
lea    0xab2(%rip),%rdi
call   1050 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
mov    0x18(%rsp),%r14
mov    0x8(%rsp),%r15
jle    1662 <main+0x4f2>
xor    %ebp,%ebp
lea    0xa4d(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
cmp    %rax,%rbp
jl     1640 <main+0x4d0>
movslq %eax,%rcx
movss  -0x4(%r15,%rcx,4),%xmm0
mov    -0x8(%r13,%rcx,8),%rdx
divss  -0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,-0x4(%r14,%rcx,4)
cmp    $0x2,%ecx
jl     17af <main+0x63f>
mov    %eax,%ecx
add    $0xfffffffe,%eax
mov    $0x1,%r9d
sub    %rcx,%r9
lea    (%r14,%rcx,4),%rsi
add    $0xfffffffffffffffc,%rsi
lea    -0x1(%rcx),%r10
xor    %r11d,%r11d
mov    $0x1,%bl
mov    %rcx,%r8
jmp    16e8 <main+0x578>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rdx,%rax,4),%xmm1
movss  %xmm1,(%r14,%rax,4)
lea    -0x1(%rax),%rdx
add    $0x1,%r11d
add    $0x1,%r9
add    $0xfffffffffffffffc,%rsi
add    $0xffffffffffffffff,%r10
add    $0x1,%bl
test   %rax,%rax
mov    %rdx,%rax
jle    17af <main+0x63f>
movzbl %bl,%ebx
and    $0x3,%ebx
add    $0xffffffffffffffff,%r8
lea    0x1(%rax),%rdi
mov    0x0(%r13,%rax,8),%rdx
xorps  %xmm0,%xmm0
cmp    %rcx,%rdi
jge    16b0 <main+0x540>
lea    0x1(%r11),%edi
test   $0x3,%dil
je     1745 <main+0x5d5>
lea    (%rdx,%r10,4),%rbp
xorps  %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%rbp,%rdi,4),%xmm1
mulss  (%rsi,%rdi,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %edi,%ebx
jne    1720 <main+0x5b0>
sub    %r9,%rdi
cmp    $0x3,%r11d
jae    1760 <main+0x5f0>
jmp    16b0 <main+0x540>
xorps  %xmm0,%xmm0
mov    %r8,%rdi
cmp    $0x3,%r11d
jb     16b0 <main+0x540>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdx,%rdi,4),%xmm1
movss  0x4(%rdx,%rdi,4),%xmm2
mulss  (%r14,%rdi,4),%xmm1
mulss  0x4(%r14,%rdi,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rdx,%rdi,4),%xmm3
mulss  0x8(%r14,%rdi,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rdx,%rdi,4),%xmm0
mulss  0xc(%r14,%rdi,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %edi,%ecx
jne    1760 <main+0x5f0>
jmp    16b0 <main+0x540>
lea    0x922(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x4(%rsp)
jle    17f2 <main+0x682>
xor    %ebp,%ebp
lea    0x8bd(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
cmp    %rax,%rbp
jl     17d0 <main+0x660>
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpl   $0x0,0x4(%rsp)
jle    1828 <main+0x6b8>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     1810 <main+0x6a0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x899(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x4(%rsp)
jle    1888 <main+0x718>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     1870 <main+0x700>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

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

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