#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(void) {
  int n, i, j, k;
  printf("Enter the number of linear simultaneous equations:\t");
  scanf("%d", &n);
  float a[n][n + 1], factor, x[n], sum;
  printf("Enter the %d x %d matrix:\n", n, n + 1);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n + 1; j++) {
      scanf("%f", &a[i][j]);
    }
  }
  for (k = 0; k < n - 1; k++) {
    for (i = k + 1; i < n; i++) {
      factor = a[i][k] / a[k][k];
      for (j = k; j <= n; j++)
        a[i][j] = (a[i][j] - (factor * a[k][j]));
    }
  }
  printf("Modified Matrix:\n\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n + 1; j++) {
      printf("%.6f\t", a[i][j]);
    }
    printf("\n");
  }
  x[n - 1] = a[n - 1][n] / a[n - 1][n - 1];
  for (i = n - 2; i >= 0; i--) {
    sum = 0;
    for (j = i + 1; j < n; j++)
      sum = sum + (a[i][j] * x[j]);
    x[i] = (a[i][n] - sum) / a[i][i];
  }
  printf("\nSolution of the Given System of Equations:\n");
  for (i = 0; i < n; i++) {
    printf("x_%d = %.6f\n", i, x[i]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeca(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x61(%rbp)
call   1030 <printf@plt>
mov    -0x61(%rbp),%al
lea    0xeea(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    %ecx,%eax
add    $0x1,%eax
mov    %rax,-0x60(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x20(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x58(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
add    $0x1,%edx
lea    0xe77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1243 <main+0x123>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1230 <main+0x110>
mov    -0x58(%rbp),%rsi
mov    -0x60(%rbp),%rcx
movslq -0xc(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe37(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11e1 <main+0xc1>
jmp    1235 <main+0x115>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11ce <main+0xae>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1367 <main+0x247>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1354 <main+0x234>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rdx
movslq -0xc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x14(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm0
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1341 <main+0x221>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rdx
movslq -0xc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x10(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm1
movss  -0x34(%rbp),%xmm0
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x10(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0xc(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12b6 <main+0x196>
jmp    1346 <main+0x226>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1264 <main+0x144>
jmp    1359 <main+0x239>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    124a <main+0x12a>
lea    0xce7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13fc <main+0x2dc>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13e0 <main+0x2c0>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rdx
movslq -0xc(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc9d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    138f <main+0x26f>
lea    0xc7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    137c <main+0x25c>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rsi
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdi
imul   %rsi,%rdi
shl    $0x2,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x8(%rbp),%rdi
movss  (%rdx,%rdi,4),%xmm0
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
divss  (%rcx,%rdx,4),%xmm0
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     1530 <main+0x410>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d5 <main+0x3b5>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rsi
movss  -0x44(%rbp),%xmm1
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    147c <main+0x35c>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rsi
movslq -0xc(%rbp),%rdi
imul   %rsi,%rdi
shl    $0x2,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x8(%rbp),%rdi
movss  (%rdx,%rdi,4),%xmm0
subss  -0x44(%rbp),%xmm0
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0xc(%rbp),%rdx
divss  (%rcx,%rdx,4),%xmm0
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1461 <main+0x341>
lea    0xb37(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1581 <main+0x461>
mov    -0x50(%rbp),%rax
mov    -0xc(%rbp),%esi
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb2f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1545 <main+0x425>
movl   $0x0,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
lea    0xeb5(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xedb(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %rsp,-0xb0(%rbp)
mov    -0x2c(%rbp),%eax
lea    0x1(%rax),%r14d
imul   %r14,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    -0x2c(%rbp),%esi
mov    %rsp,%rcx
lea    0xf(,%rsi,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
lea    0x1(%rsi),%edx
lea    0xe82(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,%r11
mov    -0x2c(%rbp),%r14d
test   %r14d,%r14d
mov    %r11,-0x50(%rbp)
jle    165d <main+0x51d>
lea    0x0(,%r11,4),%rcx
mov    %rcx,-0x60(%rbp)
lea    0xe6f(%rip),%r15
mov    -0x38(%rbp),%rbx
xor    %r12d,%r12d
jmp    1210 <main+0xd0>
nopl   0x0(%rax)
movslq %r14d,%rcx
add    $0x1,%r12
add    -0x60(%rbp),%rbx
cmp    %rcx,%r12
jge    1248 <main+0x108>
test   %r14d,%r14d
js     1200 <main+0xc0>
mov    $0xffffffffffffffff,%r13
mov    %rbx,-0x40(%rbp)
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq -0x2c(%rbp),%r14
add    $0x1,%r13
add    $0x4,%rbx
cmp    %r14,%r13
jl     1220 <main+0xe0>
mov    -0x50(%rbp),%r11
mov    -0x40(%rbp),%rbx
jmp    1200 <main+0xc0>
cmp    $0x2,%r14d
jl     165d <main+0x51d>
mov    %r14d,%ecx
add    $0xffffffff,%r14d
lea    0x1(%rcx),%r9
lea    0x1(%r11),%rdx
mov    %rdx,-0xf8(%rbp)
lea    0x4(,%r11,4),%rdx
mov    %rdx,-0x88(%rbp)
lea    0x1(%r11,%rcx,1),%rdx
mov    %rdx,-0xc0(%rbp)
mov    -0x38(%rbp),%rax
lea    0x4(%rax),%r10
mov    %rcx,%rdx
not    %rdx
mov    %rdx,-0x120(%rbp)
lea    0x34(%rax),%r13
lea    0x34(%rax,%r11,4),%rdx
mov    %rdx,-0x80(%rbp)
mov    %rcx,-0x98(%rbp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x78(%rbp)
lea    (%rax,%r11,4),%rcx
mov    %rcx,-0x70(%rbp)
mov    $0x1,%ecx
mov    %rcx,-0x68(%rbp)
xor    %ecx,%ecx
movaps 0xd32(%rip),%xmm0
mov    %r10,-0xb8(%rbp)
jmp    1313 <main+0x1d3>
nopw   0x0(%rax,%rax,1)
addq   $0x1,-0x68(%rbp)
mov    -0x88(%rbp),%rcx
add    %rcx,%r13
add    %rcx,-0x80(%rbp)
addq   $0xffffffffffffffff,-0x78(%rbp)
mov    -0x60(%rbp),%rcx
add    %rcx,-0x70(%rbp)
add    %rcx,%r10
mov    -0xd0(%rbp),%rcx
cmp    %r14,%rcx
je     165d <main+0x51d>
mov    %rcx,-0xa0(%rbp)
add    $0x1,%rcx
mov    %rcx,-0xd0(%rbp)
cmp    -0x98(%rbp),%rcx
jae    12e0 <main+0x1a0>
mov    -0x78(%rbp),%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0xc8(%rbp)
mov    -0xa0(%rbp),%rsi
mov    %rsi,%rdi
not    %rdi
lea    (%rdi,%r9,1),%rcx
add    $0xfffffffffffffff8,%rcx
add    %r9,%rdi
mov    %rcx,-0xf0(%rbp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,-0xe8(%rbp)
mov    -0x88(%rbp),%rbx
imul   %rsi,%rbx
mov    %rsi,%rcx
imul   %r11,%rcx
mov    -0xc0(%rbp),%rdx
add    %rcx,%rdx
mov    %rdx,-0x110(%rbp)
mov    -0xb8(%rbp),%rdx
mov    %rbx,-0x118(%rbp)
lea    (%rdx,%rbx,1),%rdx
mov    %rdx,-0x108(%rbp)
lea    (%rcx,%r9,1),%rdx
mov    -0x38(%rbp),%rax
lea    (%rax,%rdx,4),%rdx
mov    %rdx,-0x100(%rbp)
lea    (%rax,%rcx,4),%rcx
mov    %rcx,-0x58(%rbp)
lea    0x1(%rsi),%rcx
mov    %rcx,-0x40(%rbp)
mov    %rdi,-0x90(%rbp)
and    $0xfffffffffffffff8,%rdi
mov    %rdi,-0xe0(%rbp)
lea    (%rsi,%rdi,1),%rcx
add    $0x1,%rcx
mov    %rcx,-0xd8(%rbp)
mov    -0x70(%rbp),%rbx
mov    -0x80(%rbp),%rsi
xor    %r15d,%r15d
mov    -0x68(%rbp),%rcx
jmp    142f <main+0x2ef>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x1,%r15
mov    -0x60(%rbp),%rdx
add    %rdx,%rsi
add    %rdx,%rbx
cmp    -0x98(%rbp),%rcx
je     12e0 <main+0x1a0>
mov    %rcx,%rdx
imul   %r11,%rdx
mov    -0x38(%rbp),%rax
lea    (%rax,%rdx,4),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x58(%rbp),%rdi
movss  (%rdi,%rdx,4),%xmm2
movss  (%rax,%rdx,4),%xmm3
movaps %xmm3,%xmm1
xorps  %xmm0,%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
mov    %rax,-0xa8(%rbp)
movss  %xmm2,(%rax,%rdx,4)
cmp    %r9,-0x40(%rbp)
je     1410 <main+0x2d0>
mov    -0x40(%rbp),%rdx
cmpq   $0x8,-0x90(%rbp)
08
jae    1510 <main+0x3d0>
mov    %r9d,%eax
sub    %edx,%eax
mov    %rdx,%rdi
test   $0x1,%al
je     14b7 <main+0x377>
mov    -0x58(%rbp),%rax
movss  (%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm2
mov    -0xa8(%rbp),%rax
addss  (%rax,%rdx,4),%xmm2
movss  %xmm2,(%rax,%rdx,4)
lea    0x1(%rdx),%rdi
not    %rdx
cmp    -0x120(%rbp),%rdx
je     1410 <main+0x2d0>
nopw   0x0(%rax,%rax,1)
movss  -0x4(%r10,%rdi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,(%rbx,%rdi,4)
movss  (%r10,%rdi,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rbx,%rdi,4),%xmm2
movss  %xmm2,0x4(%rbx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    14d0 <main+0x390>
jmp    1410 <main+0x2d0>
nopl   0x0(%rax)
mov    %r15,%rdx
imul   %r11,%rdx
mov    -0xf8(%rbp),%rdi
add    %rdx,%rdi
mov    -0x38(%rbp),%rax
lea    (%rax,%rdi,4),%rdi
add    -0x118(%rbp),%rdi
add    -0x110(%rbp),%rdx
lea    (%rax,%rdx,4),%r11
cmp    -0x100(%rbp),%rdi
setb   %r12b
cmp    %r11,-0x108(%rbp)
setb   %r8b
mov    -0x40(%rbp),%rdx
cmp    %r11,%rdi
mov    -0x50(%rbp),%r11
jb     1489 <main+0x349>
mov    -0x40(%rbp),%rdx
and    %r8b,%r12b
jne    1489 <main+0x349>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
cmpq   $0x8,-0xf0(%rbp)
08
jae    1585 <main+0x445>
xor    %r12d,%r12d
jmp    15f8 <main+0x4b8>
mov    -0xc8(%rbp),%r8
xor    %r12d,%r12d
nop
movups -0x30(%r13,%r12,4),%xmm3
movups -0x20(%r13,%r12,4),%xmm4
mulps  %xmm2,%xmm3
movups -0x30(%rsi,%r12,4),%xmm5
addps  %xmm3,%xmm5
movups -0x20(%rsi,%r12,4),%xmm3
movups -0x10(%rsi,%r12,4),%xmm6
movups (%rsi,%r12,4),%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm5,-0x30(%rsi,%r12,4)
movups %xmm4,-0x20(%rsi,%r12,4)
movups -0x10(%r13,%r12,4),%xmm3
movups 0x0(%r13,%r12,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm6,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movups %xmm3,-0x10(%rsi,%r12,4)
movups %xmm4,(%rsi,%r12,4)
add    $0x10,%r12
add    $0xfffffffffffffffe,%r8
jne    1590 <main+0x450>
testb  $0x1,-0xe8(%rbp)
je     163d <main+0x4fd>
add    -0x40(%rbp),%r12
mov    -0xa8(%rbp),%rax
movups (%rax,%r12,4),%xmm3
movups 0x10(%rax,%r12,4),%xmm4
mov    -0x58(%rbp),%rdx
movups (%rdx,%r12,4),%xmm5
movups 0x10(%rdx,%r12,4),%xmm6
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm2,%xmm6
addps  %xmm4,%xmm6
movups %xmm5,(%rax,%r12,4)
movups %xmm6,0x10(%rax,%r12,4)
mov    -0xd8(%rbp),%rdx
mov    -0xe0(%rbp),%rdi
cmp    %rdi,-0x90(%rbp)
je     1410 <main+0x2d0>
jmp    1489 <main+0x349>
lea    0xa14(%rip),%rdi
call   1040 <puts@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    16e4 <main+0x5a4>
mov    -0x50(%rbp),%rcx
lea    0x0(,%rcx,4),%r14
xor    %r15d,%r15d
lea    0x9df(%rip),%r12
mov    -0x38(%rbp),%r13
jmp    16aa <main+0x56a>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r15
movslq -0x2c(%rbp),%rax
add    %r14,%r13
cmp    %rax,%r15
jge    16e4 <main+0x5a4>
test   %eax,%eax
js     1690 <main+0x550>
mov    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x4(%r13,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movslq -0x2c(%rbp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jl     16c0 <main+0x580>
jmp    1690 <main+0x550>
movslq %eax,%r8
lea    -0x1(%r8),%rax
imul   -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
movss  (%rax,%r8,4),%xmm0
divss  -0x4(%rax,%r8,4),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,-0x4(%rax,%r8,4)
cmp    $0x2,%r8d
jl     1884 <main+0x744>
lea    -0x2(%r8),%r13d
mov    $0x1,%r11d
sub    %r8,%r11
mov    -0x48(%rbp),%rax
lea    (%rax,%r8,4),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %r13,%rax
mov    -0x50(%rbp),%rsi
imul   %rsi,%rax
lea    (%rax,%r8,1),%rcx
mov    -0x38(%rbp),%rbx
lea    (%rbx,%rcx,4),%rdi
add    $0xfffffffffffffffc,%rdi
lea    0x0(,%rsi,4),%rcx
mov    %rcx,%rsi
xor    $0xfffffffffffffffc,%rsi
mov    %rsi,-0x58(%rbp)
mov    %r8d,%r12d
lea    (%rbx,%rax,4),%rax
add    $0x8,%rax
neg    %rcx
mov    %rcx,-0x40(%rbp)
xor    %r14d,%r14d
mov    $0x1,%cl
mov    %r8,%r10
jmp    17c8 <main+0x688>
nopl   (%rax)
mov    %rbx,%rsi
mov    -0x38(%rbp),%rbx
lea    (%rbx,%r9,4),%rbx
movss  (%rbx,%r8,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rbx,%r13,4),%xmm1
movss  %xmm1,(%rsi,%r13,4)
lea    -0x1(%r13),%rbx
add    $0x1,%r14d
add    $0x1,%r11
add    $0xfffffffffffffffc,%rdx
add    -0x58(%rbp),%rdi
add    $0x1,%cl
add    -0x40(%rbp),%rax
test   %r13,%r13
mov    %rbx,%r13
jle    1884 <main+0x744>
movzbl %cl,%ecx
and    $0x3,%ecx
add    $0xffffffffffffffff,%r10
lea    0x1(%r13),%rbx
mov    %r13,%r9
imul   -0x50(%rbp),%r9
xorps  %xmm0,%xmm0
cmp    %r8,%rbx
mov    -0x48(%rbp),%rbx
jge    1780 <main+0x640>
lea    0x1(%r14),%ebx
xorps  %xmm0,%xmm0
test   $0x3,%bl
je     181e <main+0x6de>
xor    %r15d,%r15d
nopl   0x0(%rax)
movss  (%rdi,%r15,4),%xmm1
mulss  (%rdx,%r15,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%r15
cmp    %r15d,%ecx
jne    1800 <main+0x6c0>
sub    %r11,%r15
jmp    1821 <main+0x6e1>
mov    %r10,%r15
mov    -0x48(%rbp),%rbx
cmp    $0x3,%r14d
jb     1780 <main+0x640>
nop
movss  -0x8(%rax,%r15,4),%xmm1
movss  -0x4(%rax,%r15,4),%xmm2
mulss  (%rbx,%r15,4),%xmm1
mulss  0x4(%rbx,%r15,4),%xmm2
addss  %xmm0,%xmm1
movss  (%rax,%r15,4),%xmm3
mulss  0x8(%rbx,%r15,4),%xmm3
addss  %xmm1,%xmm2
movss  0x4(%rax,%r15,4),%xmm0
mulss  0xc(%rbx,%r15,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%r15
cmp    %r15d,%r12d
jne    1830 <main+0x6f0>
jmp    1780 <main+0x640>
lea    0x7ff(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,-0x2c(%rbp)
mov    -0x48(%rbp),%r15
jle    18d3 <main+0x793>
xor    %ebx,%ebx
lea    0x7c8(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r15,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     18b0 <main+0x770>
mov    -0xb0(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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