#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  int i, j, k, n, iteration = 0;
  float a[20][20], x[20];
  double s, p;
  printf("Enter the number of equations : ");
  scanf("%d", &n);
  printf("\nEnter the co-efficients of the equations :\n\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("a[%d][%d] = ", i, j);
      scanf("%f", &a[i][j]);
    }
    printf("b[%d] = ", i);
    scanf("%f", &a[i][n]);
  }
  printf("Augmented co-efficient matrix:\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f ", a[i][j]);
    }
    printf("%f\n", a[i][n]);
  }
  printf("\n");
  for (k = 0; k < n - 1; k++) {
    for (i = k + 1; i < n; i++) {
      p = a[i][k] / a[k][k];
      for (j = k; j < n + 1; j++)
        a[i][j] = a[i][j] - p * a[k][j];
    }
    printf("Augmented co-efficient matrix after %d elimination:\n",
           ++iteration);
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        printf("%f ", a[i][j]);
      }
      printf("%f\n", a[i][n]);
    }
    printf("\n");
  }
  x[n - 1] = a[n - 1][n] / a[n - 1][n - 1];
  for (i = n - 2; i >= 0; i--) {
    s = 0;
    for (j = i + 1; j < n; j++) {
      s += (a[i][j] * x[j]);
      x[i] = (a[i][n] - s) / a[i][i];
    }
  }
  printf("\nThe result is :\n");
  for (i = 0; i < n; i++)
    printf("\nx[%d] = %.2f", i + 1, x[i]);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x6c0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x18(%rbp)
lea    0xec0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xed3(%rip),%rdi
lea    -0x14(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xec4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1224 <main+0x104>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11da <main+0xba>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xeb8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0x8(%rbp),%rax
lea    -0x660(%rbp),%rsi
imul   $0x50,%rax,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1181 <main+0x61>
mov    -0x8(%rbp),%esi
lea    0xe7e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0x8(%rbp),%rax
lea    -0x660(%rbp),%rsi
imul   $0x50,%rax,%rax
add    %rax,%rsi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe50(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    116e <main+0x4e>
lea    0xe40(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ce <main+0x1ae>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1293 <main+0x173>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe0d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    124c <main+0x12c>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdd6(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1239 <main+0x119>
lea    0xd7b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14d6 <main+0x3b6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1407 <main+0x2e7>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x6c0(%rbp)
ff
mov    -0x10(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13f4 <main+0x2d4>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x6c0(%rbp),%xmm0
ff
movslq -0x10(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1351 <main+0x231>
jmp    13f9 <main+0x2d9>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12fd <main+0x1dd>
mov    -0x18(%rbp),%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
lea    0xc7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ba <main+0x39a>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    147f <main+0x35f>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc21(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1438 <main+0x318>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbea(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1425 <main+0x305>
lea    0xb8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12e3 <main+0x1c3>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movss  %xmm0,-0x6b0(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x8(%rbp)
cmpl   $0x0,-0x8(%rbp)
jl     1617 <main+0x4f7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x6b8(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1604 <main+0x4e4>
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0xc(%rbp),%rax
mulss  -0x6b0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
addsd  -0x6b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x6b8(%rbp)
ff
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x6b8(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x6b0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1553 <main+0x433>
jmp    1609 <main+0x4e9>
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
jmp    1535 <main+0x415>
lea    0xaaa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    166b <main+0x54b>
mov    -0x8(%rbp),%esi
add    $0x1,%esi
movslq -0x8(%rbp),%rax
movss  -0x6b0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xa84(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    162c <main+0x50c>
lea    0x9de(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x6c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x748,%rsp
lea    0xeb8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xecb(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xf1f(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1243 <main+0x103>
lea    0x100(%rsp),%r15
lea    0xe9b(%rip),%r14
lea    0xea1(%rip),%r12
xor    %r13d,%r13d
jmp    11ff <main+0xbf>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xe8d(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
movslq 0x4(%rsp),%rax
lea    0x0(,%r13,4),%rcx
add    %r13,%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
lea    (%rcx,%rax,4),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%r13
movslq 0x4(%rsp),%rax
add    $0x50,%r15
cmp    %rax,%r13
jge    1243 <main+0x103>
test   %eax,%eax
jle    11b0 <main+0x70>
mov    %r15,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1210 <main+0xd0>
jmp    11b0 <main+0x70>
lea    0xe7b(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    12e4 <main+0x1a4>
lea    0x100(%rsp),%rbp
xor    %r15d,%r15d
lea    0xde0(%rip),%r12
lea    0xddd(%rip),%r14
jmp    12b9 <main+0x179>
cs nopw 0x0(%rax,%rax,1)
cltq
lea    (%r15,%r15,4),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%r15
movslq 0x4(%rsp),%rax
add    $0x50,%rbp
cmp    %rax,%r15
jge    12e4 <main+0x1a4>
test   %eax,%eax
jle    1280 <main+0x140>
xor    %ebx,%ebx
nop
movss  0x0(%rbp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     12c0 <main+0x180>
jmp    1280 <main+0x140>
mov    $0xa,%edi
call   1030 <putchar@plt>
movslq 0x4(%rsp),%rdi
cmp    $0x2,%rdi
jl     1834 <main+0x6f4>
lea    0x114(%rsp),%rax
lea    0x164(%rsp),%rcx
mov    %rcx,0x28(%rsp)
lea    0x150(%rsp),%rcx
mov    %rcx,0x20(%rsp)
lea    0x104(%rsp),%r12
mov    $0x1,%ecx
mov    %rcx,0x18(%rsp)
movq   $0xfffffffffffffffb,0x10(%rsp)
ff ff
movapd 0xcbe(%rip),%xmm6
lea    0xd04(%rip),%r14
xor    %r8d,%r8d
jmp    13a4 <main+0x264>
xchg   %ax,%ax
mov    $0xa,%edi
call   1030 <putchar@plt>
movslq 0x4(%rsp),%rdi
mov    %rdi,%rcx
add    $0xffffffffffffffff,%rcx
addq   $0x1,0x18(%rsp)
mov    0x38(%rsp),%rax
add    $0x54,%rax
addq   $0x54,0x28(%rsp)
addq   $0xffffffffffffffff,0x10(%rsp)
addq   $0x50,0x20(%rsp)
add    $0x50,%r12
mov    0x30(%rsp),%rdx
mov    %rdx,%r8
cmp    %rcx,%rdx
movapd 0xc62(%rip),%xmm6
jge    183b <main+0x6fb>
mov    %rax,0x38(%rsp)
lea    0x1(%r8),%rax
movslq %edi,%rcx
mov    %rax,0x30(%rsp)
cmp    %rcx,%rax
jge    1780 <main+0x640>
lea    (%r8,%r8,4),%rcx
lea    (%r8,%rcx,4),%rdx
lea    (%r8,%rcx,4),%rax
add    $0x1,%rax
mov    %rax,0xa0(%rsp)
lea    (%rsp,%rdx,4),%rax
add    $0x104,%rax
lea    0x1(%rdi),%esi
mov    %rsi,%rdx
sub    %r8,%rdx
mov    %rax,0x98(%rsp)
lea    (%rax,%rdx,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
mov    %r8,%rdx
not    %rdx
lea    (%rsi,%rcx,4),%rax
mov    %rax,0x88(%rsp)
shl    $0x4,%rcx
lea    (%rsp,%rcx,1),%rax
add    $0x100,%rax
mov    %rax,0x40(%rsp)
lea    (%rax,%r8,4),%rbp
mov    %edi,%r9d
lea    (%rdx,%rsi,1),%rax
add    $0xfffffffffffffffc,%rax
add    %rsi,%rdx
mov    %rax,0x78(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x70(%rsp)
lea    0x1(%r8),%rax
mov    %rax,0x8(%rsp)
mov    %rdx,0x50(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rsi,%rax
neg    %rax
mov    %rax,0xa8(%rsp)
mov    0x10(%rsp),%rax
add    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x58(%rsp)
mov    %rdx,0x68(%rsp)
lea    (%r8,%rdx,1),%rax
add    $0x1,%rax
mov    %rax,0x60(%rsp)
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%r11
xor    %r10d,%r10d
mov    0x18(%rsp),%rdi
mov    %r9,0x80(%rsp)
mov    %rbp,0x48(%rsp)
jmp    14d9 <main+0x399>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x1,%r10
add    $0x50,%r11
add    $0x50,%r13
cmp    %r9,%rdi
je     1780 <main+0x640>
lea    (%rdi,%rdi,4),%rcx
shl    $0x4,%rcx
lea    (%rsp,%rcx,1),%r15
add    $0x100,%r15
movss  (%r15,%r8,4),%xmm0
movss  0x0(%rbp),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%r15,%r8,4)
cmp    %rsi,0x8(%rsp)
je     14c0 <main+0x380>
xorpd  %xmm6,%xmm0
mov    0x8(%rsp),%rcx
cmpq   $0x4,0x50(%rsp)
jae    1600 <main+0x4c0>
mov    %esi,%eax
sub    %ecx,%eax
mov    %rcx,%rbx
test   $0x1,%al
je     1577 <main+0x437>
movss  (%r15,%rcx,4),%xmm1
mov    0x40(%rsp),%rax
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%r15,%rcx,4)
lea    0x1(%rcx),%rbx
not    %rcx
cmp    0xa8(%rsp),%rcx
je     14c0 <main+0x380>
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r12,%rbx,4),%xmm1
movss  0x0(%r13,%rbx,4),%xmm2
movss  0x4(%r13,%rbx,4),%xmm3
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x0(%r13,%rbx,4)
movss  (%r12,%rbx,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%r13,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    1590 <main+0x450>
jmp    14c0 <main+0x380>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%r10,4),%rcx
shl    $0x4,%rcx
lea    0x100(%rsp),%rax
add    %rax,%rcx
mov    0xa0(%rsp),%rax
lea    (%rcx,%rax,4),%rbp
add    $0x50,%rbp
mov    0x88(%rsp),%rax
lea    (%rcx,%rax,4),%rax
add    $0x50,%rax
cmp    0x90(%rsp),%rbp
setb   %bl
cmp    %rax,0x98(%rsp)
setb   %dl
mov    0x8(%rsp),%rcx
cmp    %rax,%rbp
mov    0x48(%rsp),%rbp
jb     153b <main+0x3fb>
mov    0x8(%rsp),%rcx
and    %dl,%bl
jne    153b <main+0x3fb>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x78(%rsp)
jae    1681 <main+0x541>
xor    %r9d,%r9d
jmp    170d <main+0x5cd>
mov    0x58(%rsp),%rbx
xor    %r9d,%r9d
mov    0x38(%rsp),%rax
xchg   %ax,%ax
cvtps2pd -0x8(%r11,%r9,4),%xmm2
cvtps2pd -0x10(%r11,%r9,4),%xmm3
cvtps2pd -0x8(%rax,%r9,4),%xmm4
cvtps2pd -0x10(%rax,%r9,4),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
cvtpd2ps %xmm4,%xmm2
cvtpd2ps %xmm5,%xmm3
unpcklpd %xmm2,%xmm3
movupd %xmm3,-0x10(%r11,%r9,4)
cvtps2pd 0x8(%r11,%r9,4),%xmm2
cvtps2pd (%r11,%r9,4),%xmm3
cvtps2pd 0x8(%rax,%r9,4),%xmm4
cvtps2pd (%rax,%r9,4),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
cvtpd2ps %xmm4,%xmm2
cvtpd2ps %xmm5,%xmm3
unpcklpd %xmm2,%xmm3
movupd %xmm3,(%r11,%r9,4)
add    $0x8,%r9
add    $0xfffffffffffffffe,%rbx
jne    1690 <main+0x550>
testb  $0x1,0x70(%rsp)
je     1756 <main+0x616>
add    0x8(%rsp),%r9
cvtps2pd 0x8(%r15,%r9,4),%xmm2
cvtps2pd (%r15,%r9,4),%xmm3
mov    0x40(%rsp),%rax
cvtps2pd 0x8(%rax,%r9,4),%xmm4
cvtps2pd (%rax,%r9,4),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
cvtpd2ps %xmm4,%xmm1
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm1,%xmm2
movupd %xmm2,(%r15,%r9,4)
mov    0x60(%rsp),%rcx
mov    0x68(%rsp),%rax
cmp    %rax,0x50(%rsp)
mov    0x48(%rsp),%rbp
mov    0x80(%rsp),%r9
je     14c0 <main+0x380>
jmp    153b <main+0x3fb>
nopl   (%rax)
lea    0x8ce(%rip),%rdi
mov    0x30(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
lea    0x8b1(%rip),%r13
jle    1350 <main+0x210>
lea    0x100(%rsp),%rbp
xor    %r15d,%r15d
jmp    17fd <main+0x6bd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cltq
lea    (%r15,%r15,4),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%r15
movslq 0x4(%rsp),%rax
add    $0x50,%rbp
cmp    %rax,%r15
jge    1350 <main+0x210>
test   %eax,%eax
jle    17c0 <main+0x680>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     1810 <main+0x6d0>
jmp    17c0 <main+0x680>
mov    %rdi,%rcx
add    $0xffffffffffffffff,%rcx
movslq %edi,%rax
lea    (%rcx,%rcx,4),%rdx
shl    $0x4,%rdx
add    %rsp,%rdx
add    $0x100,%rdx
movss  (%rdx,%rax,4),%xmm0
divss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0xb0(%rsp,%rcx,4)
cmp    $0x2,%eax
jl     1937 <main+0x7f7>
lea    -0x2(%rax),%edx
lea    (%rsp,%rax,4),%rcx
add    $0xb0,%rcx
lea    (%rdx,%rdx,4),%rsi
shl    $0x4,%rsi
add    %rsp,%rsi
add    $0x100,%rsi
lea    (%rsi,%rax,4),%rsi
xor    %edi,%edi
jmp    18b8 <main+0x778>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rdx),%rbp
add    $0xfffffffffffffffc,%rcx
add    $0xffffffffffffffac,%rsi
add    $0x1,%rdi
test   %rdx,%rdx
mov    %rbp,%rdx
jle    1937 <main+0x7f7>
lea    0x1(%rdx),%rbp
cmp    %rax,%rbp
jge    18a0 <main+0x760>
lea    (%rdx,%rdx,4),%rbp
shl    $0x4,%rbp
add    %rsp,%rbp
add    $0x100,%rbp
movss  0x0(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%rbp,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm1
xorpd  %xmm2,%xmm2
mov    $0xffffffffffffffff,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm3
mulss  (%rcx,%rbp,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm2
movaps %xmm0,%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm1,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0xb0(%rsp,%rdx,4)
add    $0x1,%rbp
cmp    %ebp,%edi
jne    1900 <main+0x7c0>
jmp    18a0 <main+0x760>
lea    0x7a6(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x4(%rsp)
jle    1987 <main+0x847>
xor    %ebx,%ebx
lea    0x737(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0xb0(%rsp,%rbx,4),%xmm0
add    $0x1,%rbx
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1050 <printf@plt>
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     1960 <main+0x820>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x748,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [33 x i8] c"Enter the number of equations : \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [46 x i8] c"\0AEnter the co-efficients of the equations :\0A\0A\00"
@.str.3 = [13 x i8] c"a[%d][%d] = \00"
@.str.4 = [3 x i8] c"%f\00"
@.str.5 = [9 x i8] c"b[%d] = \00"
@.str.6 = [32 x i8] c"Augmented co-efficient matrix:\0A\00"
@.str.7 = [4 x i8] c"%f \00"
@.str.8 = [4 x i8] c"%f\0A\00"
@.str.9 = [2 x i8] c"\0A\00"
@.str.10 = [53 x i8] c"Augmented co-efficient matrix after %d elimination:\0A\00"
@.str.11 = [18 x i8] c"\0AThe result is :\0A\00"
@.str.12 = [14 x i8] c"\0Ax[%d] = %.2f\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca [20 x [20 x float]]
%8 = alloca [20 x float]
%9 = alloca double
%10 = alloca double
store i32 0, i32* %1
store i32 0, i32* %6
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 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* %5)
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %2
br label %14
14: ; preds = %47, %0
%15 = load i32, i32* %2
%16 = load i32, i32* %5
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %50
18: ; preds = %14
store i32 0, i32* %3
br label %19
19: ; preds = %34, %18
%20 = load i32, i32* %3
%21 = load i32, i32* %5
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %37
23: ; preds = %19
%24 = load i32, i32* %2
%25 = load i32, i32* %3
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i32 %24, i32 %25)
%27 = load i32, i32* %2
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %28
%30 = load i32, i32* %3
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [20 x float], [20 x float]* %29, i64 0, i64 %31
%33 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), float* %32)
br label %34
34: ; preds = %23
%35 = load i32, i32* %3
%36 = add nsw i32 %35, 1
store i32 %36, i32* %3
br label %19
37: ; preds = %19
%38 = load i32, i32* %2
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i32 %38)
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %41
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [20 x float], [20 x float]* %42, i64 0, i64 %44
%46 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), float* %45)
br label %47
47: ; preds = %37
%48 = load i32, i32* %2
%49 = add nsw i32 %48, 1
store i32 %49, i32* %2
br label %14
50: ; preds = %14
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %2
br label %52
52: ; preds = %84, %50
%53 = load i32, i32* %2
%54 = load i32, i32* %5
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %87
56: ; preds = %52
store i32 0, i32* %3
br label %57
57: ; preds = %71, %56
%58 = load i32, i32* %3
%59 = load i32, i32* %5
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %74
61: ; preds = %57
%62 = load i32, i32* %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %63
%65 = load i32, i32* %3
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [20 x float], [20 x float]* %64, i64 0, i64 %66
%68 = load float, float* %67
%69 = fpext float %68 to double
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double %69)
br label %71
71: ; preds = %61
%72 = load i32, i32* %3
%73 = add nsw i32 %72, 1
store i32 %73, i32* %3
br label %57
74: ; preds = %57
%75 = load i32, i32* %2
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %76
%78 = load i32, i32* %5
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [20 x float], [20 x float]* %77, i64 0, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), double %82)
br label %84
84: ; preds = %74
%85 = load i32, i32* %2
%86 = add nsw i32 %85, 1
store i32 %86, i32* %2
br label %52
87: ; preds = %52
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %4
br label %89
89: ; preds = %199, %87
%90 = load i32, i32* %4
%91 = load i32, i32* %5
%92 = sub nsw i32 %91, 1
%93 = icmp slt i32 %90, %92
br i1 %93, label %94, label %202
94: ; preds = %89
%95 = load i32, i32* %4
%96 = add nsw i32 %95, 1
store i32 %96, i32* %2
br label %97
97: ; preds = %155, %94
%98 = load i32, i32* %2
%99 = load i32, i32* %5
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %158
101: ; preds = %97
%102 = load i32, i32* %2
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %103
%105 = load i32, i32* %4
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [20 x float], [20 x float]* %104, i64 0, i64 %106
%108 = load float, float* %107
%109 = load i32, i32* %4
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %110
%112 = load i32, i32* %4
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [20 x float], [20 x float]* %111, i64 0, i64 %113
%115 = load float, float* %114
%116 = fdiv float %108, %115
%117 = fpext float %116 to double
store double %117, double* %10
%118 = load i32, i32* %4
store i32 %118, i32* %3
br label %119
119: ; preds = %151, %101
%120 = load i32, i32* %3
%121 = load i32, i32* %5
%122 = add nsw i32 %121, 1
%123 = icmp slt i32 %120, %122
br i1 %123, label %124, label %154
124: ; preds = %119
%125 = load i32, i32* %2
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %126
%128 = load i32, i32* %3
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [20 x float], [20 x float]* %127, i64 0, i64 %129
%131 = load float, float* %130
%132 = fpext float %131 to double
%133 = load double, double* %10
%134 = load i32, i32* %4
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %135
%137 = load i32, i32* %3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [20 x float], [20 x float]* %136, i64 0, i64 %138
%140 = load float, float* %139
%141 = fpext float %140 to double
%142 = fneg double %133
%143 = call double @llvm.fmuladd.f64(double %142, double %141, double %132)
%144 = fptrunc double %143 to float
%145 = load i32, i32* %2
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %146
%148 = load i32, i32* %3
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [20 x float], [20 x float]* %147, i64 0, i64 %149
store float %144, float* %150
br label %151
151: ; preds = %124
%152 = load i32, i32* %3
%153 = add nsw i32 %152, 1
store i32 %153, i32* %3
br label %119
154: ; preds = %119
br label %155
155: ; preds = %154
%156 = load i32, i32* %2
%157 = add nsw i32 %156, 1
store i32 %157, i32* %2
br label %97
158: ; preds = %97
%159 = load i32, i32* %6
%160 = add nsw i32 %159, 1
store i32 %160, i32* %6
%161 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.10, i64 0, i64 0), i32 %160)
store i32 0, i32* %2
br label %162
162: ; preds = %194, %158
%163 = load i32, i32* %2
%164 = load i32, i32* %5
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %197
166: ; preds = %162
store i32 0, i32* %3
br label %167
167: ; preds = %181, %166
%168 = load i32, i32* %3
%169 = load i32, i32* %5
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %184
171: ; preds = %167
%172 = load i32, i32* %2
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %173
%175 = load i32, i32* %3
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [20 x float], [20 x float]* %174, i64 0, i64 %176
%178 = load float, float* %177
%179 = fpext float %178 to double
%180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double %179)
br label %181
181: ; preds = %171
%182 = load i32, i32* %3
%183 = add nsw i32 %182, 1
store i32 %183, i32* %3
br label %167
184: ; preds = %167
%185 = load i32, i32* %2
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %186
%188 = load i32, i32* %5
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [20 x float], [20 x float]* %187, i64 0, i64 %189
%191 = load float, float* %190
%192 = fpext float %191 to double
%193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), double %192)
br label %194
194: ; preds = %184
%195 = load i32, i32* %2
%196 = add nsw i32 %195, 1
store i32 %196, i32* %2
br label %162
197: ; preds = %162
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
br label %199
199: ; preds = %197
%200 = load i32, i32* %4
%201 = add nsw i32 %200, 1
store i32 %201, i32* %4
br label %89
202: ; preds = %89
%203 = load i32, i32* %5
%204 = sub nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %205
%207 = load i32, i32* %5
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [20 x float], [20 x float]* %206, i64 0, i64 %208
%210 = load float, float* %209
%211 = load i32, i32* %5
%212 = sub nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %213
%215 = load i32, i32* %5
%216 = sub nsw i32 %215, 1
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [20 x float], [20 x float]* %214, i64 0, i64 %217
%219 = load float, float* %218
%220 = fdiv float %210, %219
%221 = load i32, i32* %5
%222 = sub nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [20 x float], [20 x float]* %8, i64 0, i64 %223
store float %220, float* %224
%225 = load i32, i32* %5
%226 = sub nsw i32 %225, 2
store i32 %226, i32* %2
br label %227
227: ; preds = %280, %202
%228 = load i32, i32* %2
%229 = icmp sge i32 %228, 0
br i1 %229, label %230, label %283
230: ; preds = %227
store double 0.000000e+00, double* %9
%231 = load i32, i32* %2
%232 = add nsw i32 %231, 1
store i32 %232, i32* %3
br label %233
233: ; preds = %276, %230
%234 = load i32, i32* %3
%235 = load i32, i32* %5
%236 = icmp slt i32 %234, %235
br i1 %236, label %237, label %279
237: ; preds = %233
%238 = load i32, i32* %2
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %239
%241 = load i32, i32* %3
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [20 x float], [20 x float]* %240, i64 0, i64 %242
%244 = load float, float* %243
%245 = load i32, i32* %3
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [20 x float], [20 x float]* %8, i64 0, i64 %246
%248 = load float, float* %247
%249 = fmul float %244, %248
%250 = fpext float %249 to double
%251 = load double, double* %9
%252 = fadd double %251, %250
store double %252, double* %9
%253 = load i32, i32* %2
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %254
%256 = load i32, i32* %5
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [20 x float], [20 x float]* %255, i64 0, i64 %257
%259 = load float, float* %258
%260 = fpext float %259 to double
%261 = load double, double* %9
%262 = fsub double %260, %261
%263 = load i32, i32* %2
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [20 x [20 x float]], [20 x [20 x float]]* %7, i64 0, i64 %264
%266 = load i32, i32* %2
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [20 x float], [20 x float]* %265, i64 0, i64 %267
%269 = load float, float* %268
%270 = fpext float %269 to double
%271 = fdiv double %262, %270
%272 = fptrunc double %271 to float
%273 = load i32, i32* %2
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [20 x float], [20 x float]* %8, i64 0, i64 %274
store float %272, float* %275
br label %276
276: ; preds = %237
%277 = load i32, i32* %3
%278 = add nsw i32 %277, 1
store i32 %278, i32* %3
br label %233
279: ; preds = %233
br label %280
280: ; preds = %279
%281 = load i32, i32* %2
%282 = add nsw i32 %281, -1
store i32 %282, i32* %2
br label %227
283: ; preds = %227
%284 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %2
br label %285
285: ; preds = %298, %283
%286 = load i32, i32* %2
%287 = load i32, i32* %5
%288 = icmp slt i32 %286, %287
br i1 %288, label %289, label %301
289: ; preds = %285
%290 = load i32, i32* %2
%291 = add nsw i32 %290, 1
%292 = load i32, i32* %2
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [20 x float], [20 x float]* %8, i64 0, i64 %293
%295 = load float, float* %294
%296 = fpext float %295 to double
%297 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i32 %291, double %296)
br label %298
298: ; preds = %289
%299 = load i32, i32* %2
%300 = add nsw i32 %299, 1
store i32 %300, i32* %2
br label %285
301: ; preds = %285
%302 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
ret i32 0
}

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