#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 */
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
double **gaussjordan(int rank, double matrix[rank][rank], double accuracy) {
  int i = 1, j, k = 1;
  double temp;
  double **inversematrix = (double **)malloc(rank * rank * sizeof(double));
  do {
    *(inversematrix + i - 1) = (double *)malloc(rank * sizeof(double));
    j = 1;
    do {
      if (j == i)
        *(*(inversematrix + i - 1) + j - 1) = 1;
      else
        *(*(inversematrix + i - 1) + j - 1) = 0;
    } while (++j <= rank);
  } while (++i <= rank);
  do {
    i = k + 1;
    do {
      temp = matrix[i - 1][k - 1] / matrix[k - 1][k - 1];
      j = 1;
      do {
        matrix[i - 1][j - 1] -= matrix[k - 1][j - 1] * temp;
        *(*(inversematrix + i - 1) + j - 1) -=
            *(*(inversematrix + k - 1) + j - 1) * temp;
      } while (++j <= rank);
    } while (++i <= rank);
  } while (++k <= rank - 1);
  k = rank;
  do {
    i = k - 1;
    do {
      temp = matrix[i - 1][k - 1] / matrix[k - 1][k - 1];
      j = 1;
      do {
        matrix[i - 1][j - 1] -= matrix[k - 1][j - 1] * temp;
        *(*(inversematrix + i - 1) + j - 1) -=
            *(*(inversematrix + k - 1) + j - 1) * temp;
      } while (++j <= rank);
    } while (--i > 0);
  } while (--k > 1);
  i = 1;
  do {
    j = 1;
    temp = matrix[i - 1][i - 1];
    do {
      matrix[i - 1][j - 1] /= temp;
      *(*(inversematrix + i - 1) + j - 1) /= temp;
    } while (++j <= rank);
  } while (++i <= rank);
  i = 1;
  printf("GAUSS JORDAN METHOD:\n\n");
  do {
    j = 1;
    do {
      printf("%+09g\t", *(*(inversematrix + i - 1) + j - 1));
    } while (++j <= rank);
    printf("\n");
  } while (++i <= rank);
  return inversematrix;
}


x86 assembly (clang, -O0):
<gaussjordan>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x4(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,-0x8(%rax,%rcx,8)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    11b7 <gaussjordan+0x97>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  0xe54(%rip),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
jmp    11d1 <gaussjordan+0xb1>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
jmp    11d6 <gaussjordan+0xb6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmp    -0x4(%rbp),%eax
jle    1187 <gaussjordan+0x67>
jmp    11ed <gaussjordan+0xcd>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmp    -0x4(%rbp),%eax
jle    1161 <gaussjordan+0x41>
jmp    1204 <gaussjordan+0xe4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmp    -0x4(%rbp),%eax
jle    1269 <gaussjordan+0x149>
jmp    1351 <gaussjordan+0x231>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmp    -0x4(%rbp),%eax
jle    120d <gaussjordan+0xed>
jmp    1368 <gaussjordan+0x248>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1204 <gaussjordan+0xe4>
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmp    -0x4(%rbp),%eax
jle    13ea <gaussjordan+0x2ca>
jmp    14d2 <gaussjordan+0x3b2>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jg     138e <gaussjordan+0x26e>
jmp    14e9 <gaussjordan+0x3c9>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x1,%eax
jg     1385 <gaussjordan+0x265>
movl   $0x1,-0x1c(%rbp)
mov    -0x40(%rbp),%rdx
movl   $0x1,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rdx
movsd  -0x30(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmp    -0x4(%rbp),%eax
jle    1538 <gaussjordan+0x418>
jmp    15ad <gaussjordan+0x48d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmp    -0x4(%rbp),%eax
jle    1502 <gaussjordan+0x3e2>
movl   $0x1,-0x1c(%rbp)
lea    0xa3b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x20(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
lea    0xa26(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmp    -0x4(%rbp),%eax
jle    15db <gaussjordan+0x4bb>
lea    0xa04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmp    -0x4(%rbp),%eax
jle    15d4 <gaussjordan+0x4b4>
mov    -0x38(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussjordan>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rsi,0x70(%rsp)
mov    %edi,%ebx
lea    0x0(,%rbx,8),%edi
mov    %edi,0x20(%rsp)
imul   %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
cmp    $0x2,%ebx
mov    $0x1,%r15d
mov    %rbx,0x28(%rsp)
cmovge %ebx,%r15d
lea    0x1(%r15),%r14
mov    %r15,0x68(%rsp)
and    $0x7ffffffe,%r15d
mov    $0x1,%ebp
xor    %ebx,%ebx
movabs $0x3ff0000000000000,%r12
mov    %r14,0x10(%rsp)
jmp    11cb <gaussjordan+0x8b>
nopl   0x0(%rax,%rax,1)
mov    %r12,-0x8(%rax,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rbx
mov    0x10(%rsp),%r14
cmp    %r14,%rbp
je     125c <gaussjordan+0x11c>
mov    0x20(%rsp),%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%r13,%rbp,8)
mov    $0x1,%ecx
cmp    $0x2,%r14d
jne    1200 <gaussjordan+0xc0>
testb  $0x1,0x68(%rsp)
je     11b5 <gaussjordan+0x75>
cmp    %rbp,%rcx
je     11b0 <gaussjordan+0x70>
movq   $0x0,-0x8(%rax,%rcx,8)
jmp    11b5 <gaussjordan+0x75>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ecx
xor    %edx,%edx
jmp    1222 <gaussjordan+0xe2>
nopl   0x0(%rax)
mov    %r12,-0x8(%rax,%rbp,8)
add    $0x2,%rcx
add    $0x2,%rdx
cmp    %r15,%rdx
je     11e4 <gaussjordan+0xa4>
lea    (%rbx,%rcx,1),%rsi
cmp    $0x1,%rsi
jne    1240 <gaussjordan+0x100>
mov    %r12,-0x8(%rax,%rbp,8)
jmp    1249 <gaussjordan+0x109>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,-0x8(%rax,%rcx,8)
lea    0x1(%rcx),%rsi
cmp    %rbp,%rsi
je     1210 <gaussjordan+0xd0>
movq   $0x0,(%rax,%rcx,8)
jmp    1215 <gaussjordan+0xd5>
mov    0x28(%rsp),%rcx
mov    %ecx,%esi
movslq %ecx,%rax
mov    %rax,0xc8(%rsp)
add    $0xffffffff,%ecx
cmp    $0x2,%ecx
mov    $0x1,%eax
mov    %rcx,0x28(%rsp)
cmovge %ecx,%eax
add    $0x1,%eax
mov    %rax,0x80(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x98(%rsp)
mov    %rax,%rcx
or     $0x1,%rcx
mov    %rcx,0x90(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x60(%rsp)
mov    0x70(%rsp),%r15
lea    -0x8(%r15),%rcx
mov    $0x2,%edx
mov    $0x1,%ebp
xor    %r8d,%r8d
mov    %rcx,0x78(%rsp)
mov    %rcx,0x30(%rsp)
mov    %r15,%r10
mov    %r13,0x68(%rsp)
mov    %r14,%rcx
mov    %rax,%r14
mov    %rax,0x18(%rsp)
mov    %rsi,0x20(%rsp)
jmp    1332 <gaussjordan+0x1f2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
mov    0x88(%rsp),%edx
add    $0x1,%edx
mov    0x40(%rsp),%r8
add    $0x1,%r8
mov    0x60(%rsp),%rax
add    %rax,%r10
add    %rax,0x30(%rsp)
cmp    0x80(%rsp),%rbp
je     15fb <gaussjordan+0x4bb>
mov    %edx,0x88(%rsp)
movslq %edx,%r12
lea    -0x1(%r12),%rdi
imul   %rsi,%rdi
mov    0x78(%rsp),%rax
lea    (%rax,%rdi,8),%rbx
lea    (%r15,%rdi,8),%rdx
mov    %rdi,0xb8(%rsp)
lea    (%r14,%rdi,1),%rax
mov    %rax,0xb0(%rsp)
mov    %r8,0x40(%rsp)
mov    %r8,%rax
imul   %rsi,%rax
lea    (%r15,%rax,8),%rdi
mov    %rdi,0xa8(%rsp)
add    %r14,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%rbp),%rax
imul   %rsi,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0x50(%rsp)
mov    -0x8(%r13,%rbp,8),%r11
lea    (%r11,%r14,8),%rax
mov    %rax,0xa0(%rsp)
lea    -0x8(%r11),%rax
mov    %rax,0xc0(%rsp)
xor    %r8d,%r8d
mov    %rbp,0x58(%rsp)
jmp    140c <gaussjordan+0x2cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%r12),%rax
add    $0x1,%r8
mov    0x60(%rsp),%rsi
add    %rsi,%rdx
add    %rsi,%rbx
mov    0xc8(%rsp),%rdi
cmp    %rdi,%r12
mov    %rax,%r12
mov    0x68(%rsp),%r13
mov    0x70(%rsp),%r15
mov    0x20(%rsp),%rsi
mov    0x58(%rsp),%rbp
jge    1300 <gaussjordan+0x1c0>
lea    -0x1(%r12),%rax
imul   %rsi,%rax
lea    (%r15,%rax,8),%rax
movsd  -0x8(%rax,%rbp,8),%xmm0
mov    0x50(%rsp),%rax
divsd  -0x8(%rax,%rbp,8),%xmm0
mov    %r12d,%eax
mov    -0x8(%r13,%rax,8),%rax
mov    $0x1,%r13d
cmp    $0x2,%r14
jae    14b0 <gaussjordan+0x370>
lea    (%rax,%r13,8),%rax
add    $0xfffffffffffffff8,%rax
mov    0xc0(%rsp),%rsi
lea    (%rsi,%r13,8),%r9
mov    0x30(%rsp),%rsi
lea    (%rsi,%r13,8),%rsi
lea    (%rbx,%r13,8),%r15
mov    %rcx,%rbp
sub    %r13,%rbp
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rdi,8),%xmm1
movsd  (%rsi,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%rdi,8)
movsd  (%rax,%rdi,8),%xmm1
movsd  (%r9,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1470 <gaussjordan+0x330>
jmp    13d0 <gaussjordan+0x290>
nop
mov    %rbx,0x38(%rsp)
mov    %r8,%rcx
imul   %rsi,%rcx
mov    0xb8(%rsp),%rsi
add    %rcx,%rsi
add    0xb0(%rsp),%rcx
lea    (%r15,%rsi,8),%rsi
lea    (%r15,%rcx,8),%rdi
lea    (%rax,%r14,8),%r14
cmp    %r14,%rsi
setb   0xf(%rsp)
cmp    %rdi,%rax
setb   0xe(%rsp)
mov    0x48(%rsp),%rcx
cmp    %rcx,%rsi
setb   %r15b
mov    0xa8(%rsp),%rbp
cmp    %rdi,%rbp
setb   0xd(%rsp)
mov    0xa0(%rsp),%rbx
cmp    %rbx,%rsi
setb   %sil
cmp    %rdi,%r11
setb   0xc(%rsp)
cmp    %rcx,%rax
setb   %dil
cmp    %r14,%rbp
setb   %bpl
cmp    %rbx,%rax
setb   %r9b
cmp    %r14,%r11
setb   %r14b
mov    0xe(%rsp),%cl
test   %cl,0xf(%rsp)
jne    15e7 <gaussjordan+0x4a7>
and    0xd(%rsp),%r15b
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%r15
mov    0x38(%rsp),%rbx
jne    15df <gaussjordan+0x49f>
and    0xc(%rsp),%sil
jne    15df <gaussjordan+0x49f>
and    %bpl,%dil
jne    15df <gaussjordan+0x49f>
and    %r14b,%r9b
mov    %r15,%r14
jne    143e <gaussjordan+0x2fe>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %esi,%esi
mov    0x98(%rsp),%rdi
nopl   0x0(%rax)
movupd (%r10,%rsi,8),%xmm2
movupd (%rdx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%rdx,%rsi,8)
movupd (%r11,%rsi,8),%xmm2
movupd (%rax,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%rax,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    1590 <gaussjordan+0x450>
mov    0x90(%rsp),%r13
cmp    %rdi,%r14
je     13d0 <gaussjordan+0x290>
jmp    143e <gaussjordan+0x2fe>
mov    %r15,%r14
jmp    143e <gaussjordan+0x2fe>
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%r14
mov    0x38(%rsp),%rbx
jmp    143e <gaussjordan+0x2fe>
movslq 0x28(%rsp),%r9
lea    -0x1(%r9),%rax
imul   %rsi,%rax
lea    (%rax,%rcx,1),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x88(%rsp)
lea    -0x1(%rdi),%rdx
imul   %rsi,%rdx
lea    (%rdx,%rcx,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    %rbp,0xd0(%rsp)
mov    %r14,%rbp
or     $0x1,%rbp
mov    %rbp,0x80(%rsp)
lea    (%r15,%rax,8),%r11
mov    0x60(%rsp),%rbp
neg    %rbp
mov    %rbp,0x50(%rsp)
lea    (%r15,%rdx,8),%rbp
lea    -0x8(,%rcx,8),%rcx
ff
and    $0xfffffffffffffff0,%rcx
mov    %rcx,0x78(%rsp)
mov    %rdx,0xd8(%rsp)
lea    (%r15,%rdx,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x30(%rsp)
mov    %rax,0x90(%rsp)
lea    (%r15,%rax,8),%r12
add    $0xfffffffffffffff8,%r12
xor    %ecx,%ecx
jmp    16e6 <gaussjordan+0x5a6>
xchg   %ax,%ax
mov    0x28(%rsp),%r9
add    $0xffffffffffffffff,%r9
mov    0xe0(%rsp),%rcx
add    $0x1,%rcx
mov    0xf0(%rsp),%r11
mov    0x50(%rsp),%rax
add    %rax,%r11
mov    0x40(%rsp),%rbp
add    %rax,%rbp
add    %rax,0x30(%rsp)
mov    0xe8(%rsp),%r12
add    %rax,%r12
cmpq   $0x2,0xc8(%rsp)
mov    0x58(%rsp),%rdi
mov    0x18(%rsp),%r14
jle    19b8 <gaussjordan+0x878>
mov    %rbp,0x40(%rsp)
mov    %rcx,0xe0(%rsp)
imul   %rsi,%rcx
mov    0xd8(%rsp),%rax
sub    %rcx,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0xb0(%rsp)
mov    0xd0(%rsp),%rax
mov    %rcx,0xb8(%rsp)
sub    %rcx,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0xa8(%rsp)
lea    -0x1(%rdi),%rax
mov    %rax,0x58(%rsp)
imul   %rsi,%rax
lea    (%r15,%rax,8),%r8
mov    %rdi,0xc8(%rsp)
mov    -0x8(%r13,%rdi,8),%rdi
lea    (%rdi,%r14,8),%rax
mov    %rax,0xa0(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,0xc0(%rsp)
mov    %r12,0xe8(%rsp)
mov    %r11,0xf0(%rsp)
xor    %r14d,%r14d
mov    %r9,0x28(%rsp)
mov    %r8,0x48(%rsp)
jmp    17bb <gaussjordan+0x67b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
mov    0x50(%rsp),%rax
add    %rax,%r11
add    %rax,%r12
cmp    $0x1,%r9
mov    %r10,%r9
mov    0x68(%rsp),%r13
mov    0x70(%rsp),%r15
mov    0x20(%rsp),%rsi
jle    1690 <gaussjordan+0x550>
lea    -0x1(%r9),%r10
mov    %r10,%rax
imul   %rsi,%rax
lea    (%r15,%rax,8),%rax
mov    0x58(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  (%r8,%rcx,8),%xmm0
mov    -0x8(%r13,%r9,8),%rbx
mov    $0x1,%r13d
mov    0x18(%rsp),%rbp
cmp    $0x2,%rbp
jae    1860 <gaussjordan+0x720>
lea    (%rbx,%r13,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    0xc0(%rsp),%rax
lea    (%rax,%r13,8),%r15
mov    0x30(%rsp),%rax
lea    (%rax,%r13,8),%rdx
lea    (%r12,%r13,8),%rbp
mov    0x10(%rsp),%rsi
sub    %r13,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  (%rdx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm1
movsd  (%r15,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1820 <gaussjordan+0x6e0>
jmp    1790 <gaussjordan+0x650>
nop
mov    %r10,0x38(%rsp)
mov    %r14,%rax
imul   %rsi,%rax
add    0xb8(%rsp),%rax
mov    0x90(%rsp),%rcx
sub    %rax,%rcx
mov    0x88(%rsp),%rdx
sub    %rax,%rdx
lea    (%r15,%rcx,8),%rax
lea    (%r15,%rdx,8),%rsi
lea    (%rbx,%rbp,8),%r15
cmp    %r15,%rax
setb   0xf(%rsp)
cmp    %rsi,%rbx
setb   0xe(%rsp)
mov    0xa8(%rsp),%r10
cmp    %r10,%rax
setb   %cl
mov    0xb0(%rsp),%r8
cmp    %rsi,%r8
setb   0xd(%rsp)
mov    0xa0(%rsp),%rdx
cmp    %rdx,%rax
setb   %bpl
cmp    %rsi,%rdi
setb   0xc(%rsp)
cmp    %r10,%rbx
setb   %al
cmp    %r15,%r8
setb   %r8b
cmp    %rdx,%rbx
setb   %sil
cmp    %r15,%rdi
setb   %r15b
mov    0xe(%rsp),%dl
test   %dl,0xf(%rsp)
jne    19a9 <gaussjordan+0x869>
mov    %r8d,%edx
and    0xd(%rsp),%cl
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%r10
jne    17f0 <gaussjordan+0x6b0>
and    0xc(%rsp),%bpl
jne    17f0 <gaussjordan+0x6b0>
and    %dl,%al
jne    17f0 <gaussjordan+0x6b0>
and    %r15b,%sil
jne    17f0 <gaussjordan+0x6b0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %edx,%edx
mov    0x78(%rsp),%rax
mov    0x40(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rdx,1),%xmm2
movupd (%r11,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%r11,%rdx,1)
movupd (%rdi,%rdx,1),%xmm2
movupd (%rbx,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%rbx,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rax
jne    1950 <gaussjordan+0x810>
mov    0x80(%rsp),%r13
mov    0x98(%rsp),%rax
cmp    %rax,0x18(%rsp)
je     1790 <gaussjordan+0x650>
jmp    17f0 <gaussjordan+0x6b0>
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%r10
jmp    17f0 <gaussjordan+0x6b0>
mov    %r14,%r8
or     $0x1,%r8
mov    $0x1,%edx
xor    %esi,%esi
mov    %r15,%rdi
mov    0x10(%rsp),%r9
jmp    19e6 <gaussjordan+0x8a6>
add    $0x1,%rdx
add    $0x1,%rsi
add    0x60(%rsp),%rdi
cmp    %r9,%rdx
je     1aca <gaussjordan+0x98a>
lea    -0x1(%rdx),%rax
imul   0x20(%rsp),%rax
lea    (%r15,%rax,8),%rax
movsd  -0x8(%rax,%rdx,8),%xmm0
mov    -0x8(%r13,%rdx,8),%rbx
mov    $0x1,%eax
cmp    $0x2,%r14
jb     1a90 <gaussjordan+0x950>
mov    %rsi,%rax
imul   0x20(%rsp),%rax
lea    (%r15,%rax,8),%rcx
lea    (%rbx,%r14,8),%rbp
cmp    %rbp,%rcx
mov    0x98(%rsp),%rbp
mov    0x70(%rsp),%r15
jae    1a42 <gaussjordan+0x902>
add    %r14,%rax
lea    (%r15,%rax,8),%rcx
mov    $0x1,%eax
cmp    %rcx,%rbx
jb     1a90 <gaussjordan+0x950>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movupd (%rdi,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rax,8)
movupd (%rbx,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1a50 <gaussjordan+0x910>
mov    %r8,%rax
cmp    %rbp,%r14
je     19d0 <gaussjordan+0x890>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1aa0 <gaussjordan+0x960>
jmp    19d0 <gaussjordan+0x890>
lea    0x536(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%r12d
lea    0x51d(%rip),%r14
mov    0x18(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%r13,%r12,8),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1b00 <gaussjordan+0x9c0>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r12
cmp    0x10(%rsp),%r12
jne    1af0 <gaussjordan+0x9b0>
mov    %r13,%rax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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