#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 */
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void gauss(double a[], int l, int m, int n, double eps) {
  int i, iw, j, k, kp1, mm1, *p, r, s, t, u, v, *work;
  double api, pivot, *q, *q1, w, wmax;
  if (l < n || m < 2 || m >= n || eps <= 0.) {
    fprintf(stderr, "Error : Illegal parameter in gauss()\n");
    return;
  }
  work = (int *)malloc(m * sizeof(int));
  if (work == NULL) {
    fprintf(stderr, "Error : Out of memory  in gauss()\n");
    return;
  }
  for (i = 0, p = work; i < m; i++)
    *p++ = i;
  for (k = 0; k < m; k++) {
    wmax = 0.;
    for (i = k, q = a + i * l + k; i < m; i++) {
      w = fabs(*q++);
      if (w > wmax) {
        wmax = w;
        r = i;
      }
    }
    u = r * l;
    v = k * l;
    s = u + k;
    pivot = *(a + r * l + k);
    api = fabs(pivot);
    if (api < eps) {
      fprintf(stderr, "Error : pivot < eps in gauss()\n");
      free((char *)work);
      return;
    }
    if (r != k) {
      iw = *(work + k);
      *(work + k) = *(work + r);
      *(work + r) = iw;
      for (j = 0; j < n; j++) {
        s = k * l + j;
        t = r * l + j;
        w = *(a + s);
        *(a + s) = *(a + t);
        *(a + t) = w;
      }
    }
    for (i = k, q = a + v + k; i < n; i++)
      *q++ /= pivot;
    kp1 = k + 1;
    if (kp1 > m)
      break;
    for (i = kp1; i < m; i++) {
      w = *(a + i * l + k);
      if (w != 0.) {
        q = a + i * l + kp1;
        q1 = a + k * l + kp1;
        for (j = kp1; j < n; j++)
          *q++ -= w * *q1++;
      }
    }
  }
  mm1 = m - 1;
  for (k = m; k < n; k++) {
    for (i = 0, iw = m - 2; i < mm1; i++, iw--) {
      w = 0.;
      for (j = m - 1, q = a + iw * l + j; j > iw; j--)
        w += *q-- * *(a + j * l + k);
      *(a + iw * l + k) -= w;
    }
  }
  free((char *)work);
  return;
}


x86 assembly (clang, -O0):
<gauss>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     117d <gauss+0x4d>
cmpl   $0x2,-0x10(%rbp)
jl     117d <gauss+0x4d>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    117d <gauss+0x4d>
xorps  %xmm0,%xmm0
ucomisd -0x20(%rbp),%xmm0
jb     1197 <gauss+0x67>
mov    0x2e5c(%rip),%rax
mov    (%rax),%edi
lea    0xe83(%rip),%rsi
call   1040 <fprintf@plt>
jmp    16fb <gauss+0x5cb>
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    11cf <gauss+0x9f>
mov    0x2e24(%rip),%rax
mov    (%rax),%edi
lea    0xe71(%rip),%rsi
call   1040 <fprintf@plt>
jmp    16fb <gauss+0x5cb>
movl   $0x0,-0x24(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    120c <gauss+0xdc>
mov    -0x24(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11de <gauss+0xae>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15c7 <gauss+0x497>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12c5 <gauss+0x195>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm0
movaps 0xd86(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jbe    12b2 <gauss+0x182>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12b7 <gauss+0x187>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1254 <gauss+0x124>
mov    -0x44(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0xcef(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1351 <gauss+0x221>
mov    0x2cab(%rip),%rax
mov    (%rax),%edi
lea    0xd1b(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
jmp    16fb <gauss+0x5cb>
mov    -0x44(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1413 <gauss+0x2e3>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    140e <gauss+0x2de>
mov    -0x30(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1396 <gauss+0x266>
jmp    1413 <gauss+0x2e3>
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1471 <gauss+0x341>
movsd  -0x70(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1437 <gauss+0x307>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    148b <gauss+0x35b>
jmp    15c7 <gauss+0x497>
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15b4 <gauss+0x484>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14e3 <gauss+0x3b3>
jp     14e3 <gauss+0x3b3>
jmp    15a1 <gauss+0x471>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    159c <gauss+0x46c>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  (%rax),%xmm2
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1531 <gauss+0x401>
jmp    15a1 <gauss+0x471>
jmp    15a6 <gauss+0x476>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1491 <gauss+0x361>
jmp    15b9 <gauss+0x489>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1213 <gauss+0xe3>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16f2 <gauss+0x5c2>
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    16df <gauss+0x5af>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    1699 <gauss+0x569>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1636 <gauss+0x506>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    15f2 <gauss+0x4c2>
jmp    16e4 <gauss+0x5b4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15d6 <gauss+0x4a6>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gauss>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %esi,0x1c(%rsp)
cmp    $0x2,%edx
jl     11a9 <gauss+0x79>
mov    %ecx,%ebx
cmp    %ecx,0x1c(%rsp)
jl     11a9 <gauss+0x79>
mov    %edx,%r12d
cmp    %ebx,%edx
jge    11a9 <gauss+0x79>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    11a9 <gauss+0x79>
mov    %rdi,%r13
movsd  %xmm0,0x8(%rsp)
lea    0x0(,%r12,4),%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     11cf <gauss+0x9f>
mov    %rbx,0x10(%rsp)
movabs $0x1fffffffc,%rdx
lea    -0x1(%r12),%r15d
cmp    $0x7,%r15d
jae    11e1 <gauss+0xb1>
xor    %ebp,%ebp
mov    %rax,%rcx
movsd  0x8(%rsp),%xmm11
jmp    1350 <gauss+0x220>
mov    0x2e30(%rip),%rax
mov    (%rax),%edi
lea    0xef7(%rip),%rsi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fprintf@plt>
mov    0x2e0a(%rip),%rax
mov    (%rax),%edi
lea    0xef7(%rip),%rsi
jmp    11b9 <gauss+0x89>
lea    0x1(%r15),%rcx
lea    -0x4(%rdx),%rbp
and    %rcx,%rbp
lea    -0x8(%rbp),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    121c <gauss+0xec>
movdqa 0xdf2(%rip),%xmm0
xor    %edi,%edi
movsd  0x8(%rsp),%xmm11
jmp    12f8 <gauss+0x1c8>
and    $0xfffffffffffffffc,%rsi
movdqa 0xdd8(%rip),%xmm0
xor    %edi,%edi
movdqa 0xddd(%rip),%xmm8
movdqa 0xde4(%rip),%xmm9
movdqa 0xdeb(%rip),%xmm10
movdqa 0xdf3(%rip),%xmm4
movdqa 0xdfb(%rip),%xmm5
movdqa 0xe03(%rip),%xmm6
movdqa 0xe0b(%rip),%xmm7
movdqa 0xe13(%rip),%xmm1
movsd  0x8(%rsp),%xmm11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm2,0x10(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rdi,4)
movdqu %xmm3,0x30(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rdi,4)
movdqu %xmm3,0x50(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rdi,4)
movdqu %xmm3,0x70(%rax,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1280 <gauss+0x150>
test   %rdx,%rdx
je     1340 <gauss+0x210>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xcfd(%rip),%xmm1
movdqa 0xd05(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1320 <gauss+0x1f0>
cmp    %rbp,%rcx
je     135e <gauss+0x22e>
lea    (%rax,%rbp,4),%rcx
nopl   0x0(%rax)
mov    %ebp,(%rcx)
add    $0x4,%rcx
add    $0x1,%ebp
cmp    %ebp,%r12d
jne    1350 <gauss+0x220>
mov    %rax,0x38(%rsp)
movslq 0x1c(%rsp),%rdx
mov    0x10(%rsp),%rax
movslq %eax,%rcx
mov    %rcx,0x40(%rsp)
movslq %r12d,%rcx
mov    %rcx,0x78(%rsp)
mov    %r12d,%ecx
mov    %rcx,0x98(%rsp)
mov    %eax,%ebp
lea    0x1(%rdx),%rcx
mov    %rcx,0x128(%rsp)
lea    0x0(,%rdx,8),%r9
lea    0x8(,%rdx,8),%rdi
mov    %rdi,0x68(%rsp)
lea    0x2(%rdx),%rdi
mov    %rdi,0xe0(%rsp)
lea    -0x2(%rax),%r10d
mov    %ebp,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc0(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rsi
mov    %rbx,0xb0(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xa8(%rsp)
mov    %rbp,%rsi
neg    %rsi
mov    %rsi,0xd0(%rsp)
movapd 0xc83(%rip),%xmm8
pxor   %xmm10,%xmm10
movapd 0xc85(%rip),%xmm9
movapd 0xc6d(%rip),%xmm3
lea    0x8(%r13),%rbx
lea    0x10(%r13),%rdi
mov    %rbp,0x50(%rsp)
lea    0x0(%r13,%rbp,8),%rsi
mov    %rsi,0xc8(%rsp)
lea    0x30(%r13),%rbp
add    $0xffffffff,%eax
mov    %eax,0x30(%rsp)
lea    0x38(%r13),%r8
mov    %rdx,0x8(%rsp)
lea    0x38(%r13,%rdx,8),%rax
mov    %rax,0x60(%rsp)
mov    $0x1,%eax
mov    %rax,0x58(%rsp)
xor    %esi,%esi
mov    %r10d,0x48(%rsp)
mov    %r10d,0x34(%rsp)
mov    %rdi,0xd8(%rsp)
mov    %rbx,0x90(%rsp)
mov    %rbp,0xa0(%rsp)
mov    %rbp,%rdx
mov    %r12,0xf0(%rsp)
mov    %r15,0xe8(%rsp)
jmp    14fe <gauss+0x3ce>
xchg   %ax,%ax
addq   $0x1,0x58(%rsp)
mov    0x70(%rsp),%rdx
add    %r9,%rdx
mov    0x88(%rsp),%rbx
add    %r9,%rbx
mov    0x68(%rsp),%rax
mov    0x80(%rsp),%rdi
add    %rax,%rdi
addl   $0xffffffff,0x30(%rsp)
add    %rax,%r8
add    %rax,0x60(%rsp)
addl   $0xffffffff,0x34(%rsp)
cmp    0x98(%rsp),%rsi
mov    0xf0(%rsp),%r12
mov    0xe8(%rsp),%r15
mov    0x78(%rsp),%rcx
je     1cec <gauss+0xbbc>
mov    %rbx,0x88(%rsp)
mov    %rsi,%r11
mov    %r12d,%eax
sub    %r11d,%eax
mov    %rsi,%rcx
imul   0x8(%rsp),%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
mov    %rcx,0x28(%rsp)
lea    (%rcx,%rsi,8),%rbx
test   $0x1,%al
jne    1550 <gauss+0x420>
pxor   %xmm4,%xmm4
mov    %rbx,%rsi
mov    %r11d,%ebp
cmp    %r11d,%r15d
jne    1580 <gauss+0x450>
jmp    15b8 <gauss+0x488>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx),%xmm5
pxor   %xmm4,%xmm4
ucomisd %xmm5,%xmm4
cmovne %r11d,%r10d
je     156b <gauss+0x43b>
andpd  %xmm8,%xmm5
movapd %xmm5,%xmm4
lea    0x8(%rbx),%rsi
lea    0x1(%r11),%ebp
cmp    %r11d,%r15d
je     15b8 <gauss+0x488>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm5
andpd  %xmm3,%xmm5
ucomisd %xmm4,%xmm5
cmova  %ebp,%r10d
maxsd  %xmm4,%xmm5
movsd  0x8(%rsi),%xmm4
andpd  %xmm3,%xmm4
ucomisd %xmm5,%xmm4
lea    0x1(%rbp),%eax
cmova  %eax,%r10d
maxsd  %xmm5,%xmm4
add    $0x2,%ebp
add    $0x10,%rsi
cmp    %r12d,%ebp
jne    1580 <gauss+0x450>
mov    %r10d,%eax
imul   0x1c(%rsp),%eax
movslq %eax,%r14
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
movsd  (%rsi,%r11,8),%xmm4
movapd %xmm4,%xmm5
andpd  %xmm8,%xmm5
ucomisd %xmm5,%xmm11
ja     1cbc <gauss+0xb8c>
mov    %rdx,0x70(%rsp)
mov    %rdi,0x80(%rsp)
mov    %r10d,%eax
cmp    %rax,%r11
je     1810 <gauss+0x6e0>
mov    0x38(%rsp),%rbp
mov    0x0(%rbp,%r11,4),%eax
movslq %r10d,%rdx
mov    0x0(%rbp,%rdx,4),%edi
mov    %edi,0x0(%rbp,%r11,4)
mov    %eax,0x0(%rbp,%rdx,4)
mov    0x88(%rsp),%rbp
mov    0x50(%rsp),%rdx
cmpl   $0x0,0x10(%rsp)
jle    1810 <gauss+0x6e0>
cmpl   $0x4,0x10(%rsp)
jb     166d <gauss+0x53d>
mov    0xc8(%rsp),%rax
lea    (%rax,%r14,8),%rax
cmp    %rax,0x28(%rsp)
jae    170c <gauss+0x5dc>
mov    0x20(%rsp),%rax
add    %rdx,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
cmp    %rax,%rsi
jae    170c <gauss+0x5dc>
xor    %eax,%eax
mov    %rax,%rsi
test   $0x1,%dl
je     16ab <gauss+0x57b>
mov    0x20(%rsp),%rcx
add    %rax,%rcx
lea    (%rax,%r14,1),%rdx
movq   0x0(%r13,%rcx,8),%xmm0
movsd  0x0(%r13,%rdx,8),%xmm5
movsd  %xmm5,0x0(%r13,%rcx,8)
movq   %xmm0,0x0(%r13,%rdx,8)
mov    0x50(%rsp),%rdx
mov    %rax,%rsi
or     $0x1,%rsi
not    %rax
cmp    0xd0(%rsp),%rax
je     1810 <gauss+0x6e0>
mov    0x90(%rsp),%rax
lea    (%rax,%r14,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rsi,8),%xmm0
movsd  -0x8(%rax,%rsi,8),%xmm5
movsd  %xmm5,-0x8(%rbp,%rsi,8)
movsd  %xmm0,-0x8(%rax,%rsi,8)
movq   0x0(%rbp,%rsi,8),%xmm0
movsd  (%rax,%rsi,8),%xmm5
movsd  %xmm5,0x0(%rbp,%rsi,8)
movq   %xmm0,(%rax,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    16d0 <gauss+0x5a0>
jmp    1810 <gauss+0x6e0>
cmpq   $0x0,0xb8(%rsp)
je     1ca4 <gauss+0xb74>
mov    %r11,%rcx
mov    0xa0(%rsp),%rax
lea    (%rax,%r14,8),%rdi
mov    0xa8(%rsp),%rax
xor    %esi,%esi
mov    0x70(%rsp),%r11
nopl   0x0(%rax)
movups -0x30(%r11,%rsi,8),%xmm5
movups -0x20(%r11,%rsi,8),%xmm6
movups -0x30(%rdi,%rsi,8),%xmm7
movups -0x20(%rdi,%rsi,8),%xmm0
movups %xmm7,-0x30(%r11,%rsi,8)
movups %xmm0,-0x20(%r11,%rsi,8)
movups %xmm5,-0x30(%rdi,%rsi,8)
movups %xmm6,-0x20(%rdi,%rsi,8)
movdqu -0x10(%r11,%rsi,8),%xmm0
movupd (%r11,%rsi,8),%xmm5
movdqu -0x10(%rdi,%rsi,8),%xmm6
movdqu (%rdi,%rsi,8),%xmm7
movdqu %xmm6,-0x10(%r11,%rsi,8)
movdqu %xmm7,(%r11,%rsi,8)
movdqu %xmm0,-0x10(%rdi,%rsi,8)
movupd %xmm5,(%rdi,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    1740 <gauss+0x610>
testb  $0x1,0xb0(%rsp)
01
je     17f3 <gauss+0x6c3>
mov    0x20(%rsp),%rax
add    %rsi,%rax
add    %r14,%rsi
movdqu 0x0(%r13,%rax,8),%xmm0
movupd 0x10(%r13,%rax,8),%xmm5
movdqu 0x0(%r13,%rsi,8),%xmm6
movdqu 0x10(%r13,%rsi,8),%xmm7
movdqu %xmm6,0x0(%r13,%rax,8)
movdqu %xmm7,0x10(%r13,%rax,8)
movdqu %xmm0,0x0(%r13,%rsi,8)
movupd %xmm5,0x10(%r13,%rsi,8)
mov    0xc0(%rsp),%rsi
mov    %rsi,%rax
cmp    %rdx,%rsi
mov    %rcx,%r11
jne    166f <gauss+0x53f>
nopw   0x0(%rax,%rax,1)
cmp    0x40(%rsp),%r11
jge    1906 <gauss+0x7d6>
mov    %r11d,%ebp
not    %ebp
mov    0x10(%rsp),%rdx
add    %edx,%ebp
je     18e2 <gauss+0x7b2>
mov    %r11,%rcx
add    $0x1,%rbp
movabs $0x1fffffffc,%rax
add    $0x2,%rax
and    %rbp,%rax
lea    -0x2(%rax),%rdx
mov    %rdx,%r11
shr    %r11
add    $0x1,%r11
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
test   %rdx,%rdx
je     1c93 <gauss+0xb63>
mov    0x30(%rsp),%edi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffffe,%rdi
shr    %rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x80(%rsp),%rdx
nopl   0x0(%rax)
movupd -0x10(%rdx,%rsi,8),%xmm0
movupd (%rdx,%rsi,8),%xmm6
divpd  %xmm5,%xmm0
movupd %xmm0,-0x10(%rdx,%rsi,8)
divpd  %xmm5,%xmm6
movupd %xmm6,(%rdx,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1890 <gauss+0x760>
test   $0x1,%r11b
je     18cc <gauss+0x79c>
movupd (%rbx,%rsi,8),%xmm0
divpd  %xmm5,%xmm0
movupd %xmm0,(%rbx,%rsi,8)
cmp    %rax,%rbp
mov    %rcx,%r11
je     1906 <gauss+0x7d6>
lea    (%rbx,%rax,8),%rbx
add    %r11d,%eax
mov    0x10(%rsp),%rdx
jmp    18e5 <gauss+0x7b5>
mov    %r11d,%eax
sub    %eax,%edx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %eax,%edx
jne    18f0 <gauss+0x7c0>
mov    %r11,0x20(%rsp)
lea    0x1(%r11),%rsi
cmp    0x78(%rsp),%rsi
jge    14a0 <gauss+0x370>
mov    0x34(%rsp),%edi
add    $0x1,%rdi
mov    0x48(%rsp),%eax
mov    %eax,%ebp
mov    0x20(%rsp),%r11
sub    %r11d,%ebp
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rbp),%rax
add    $0xfffffffffffffffc,%rdi
mov    %rax,0x118(%rsp)
mov    %rax,%rbx
movabs $0x1fffffffc,%rax
and    %rax,%rbx
shr    $0x2,%rdi
lea    -0x4(%rbx),%rax
mov    0x68(%rsp),%rdx
imul   %r11,%rdx
add    $0x1,%rdi
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
mov    0xd8(%rsp),%rax
mov    %rdx,0x138(%rsp)
add    %rdx,%rax
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x100(%rsp)
add    $0x1,%rcx
mov    %rcx,0x108(%rsp)
mov    0xe0(%rsp),%rdx
add    %rbp,%rdx
mov    %rdx,0x120(%rsp)
mov    %rbp,0x140(%rsp)
lea    (%rax,%rbp,8),%rax
mov    %rax,0x130(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,%rcx
lea    (%rax,%rbx,8),%rax
mov    %rax,0xf8(%rsp)
mov    %rbx,0x28(%rsp)
lea    (%rbx,%rsi,1),%eax
mov    %eax,0x4c(%rsp)
mov    0x60(%rsp),%rbp
xor    %eax,%eax
mov    0x58(%rsp),%r11
jmp    1a1c <gauss+0x8ec>
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x1,%rax
add    %r9,%rbp
cmp    0x98(%rsp),%r11
mov    %r15,%r13
je     14a0 <gauss+0x370>
mov    %r11,%rdx
imul   0x8(%rsp),%rdx
mov    %r13,%r15
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
mov    0x20(%rsp),%rdi
movsd  (%rdx,%rdi,8),%xmm4
ucomisd %xmm10,%xmm4
jne    1a46 <gauss+0x916>
jnp    1a00 <gauss+0x8d0>
cmp    0x40(%rsp),%rsi
jge    1a00 <gauss+0x8d0>
lea    (%rdx,%rsi,8),%r12
xorpd  %xmm9,%xmm4
cmpl   $0x3,0x140(%rsp)
03
jb     1aab <gauss+0x97b>
mov    %rax,%rdx
imul   0x8(%rsp),%rdx
mov    0x128(%rsp),%rdi
add    %rdx,%rdi
lea    (%r15,%rdi,8),%rdi
add    0x138(%rsp),%rdi
cmp    0x130(%rsp),%rdi
jae    1b7f <gauss+0xa4f>
mov    %r15,%rbx
add    0x120(%rsp),%rdx
lea    (%r15,%rdx,8),%rdx
cmp    %rdx,0x90(%rsp)
jae    1b7f <gauss+0xa4f>
mov    %rcx,%r13
mov    %esi,%r14d
mov    0x10(%rsp),%rdx
mov    %edx,%edi
sub    %r14d,%edi
mov    %r14d,%ebx
not    %ebx
add    %edx,%ebx
and    $0x3,%edi
je     1af8 <gauss+0x9c8>
neg    %edi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r12),%xmm0
movsd  %xmm0,(%r12)
add    $0x8,%r12
add    $0x8,%r13
add    $0xffffffff,%edx
cmp    %edx,%edi
jne    1ad0 <gauss+0x9a0>
sub    %edx,%r14d
cmp    $0x3,%ebx
jb     1a00 <gauss+0x8d0>
mov    0x10(%rsp),%rdi
sub    %r14d,%edi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
movsd  0x8(%r13,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x8(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
movsd  0x10(%r13,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x10(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rbx,8)
movsd  0x18(%r13,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x18(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r12,%rbx,8)
add    $0x4,%rbx
cmp    %ebx,%edi
jne    1b10 <gauss+0x9e0>
jmp    1a00 <gauss+0x8d0>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0x0,0x110(%rsp)
je     1c85 <gauss+0xb55>
mov    0x100(%rsp),%rdi
xor    %ebx,%ebx
movupd -0x30(%r8,%rbx,8),%xmm0
movupd -0x20(%r8,%rbx,8),%xmm6
mulpd  %xmm5,%xmm0
movupd -0x30(%rbp,%rbx,8),%xmm7
addpd  %xmm0,%xmm7
movupd -0x20(%rbp,%rbx,8),%xmm0
movupd -0x10(%rbp,%rbx,8),%xmm2
movupd 0x0(%rbp,%rbx,8),%xmm1
mulpd  %xmm5,%xmm6
addpd  %xmm0,%xmm6
movupd %xmm7,-0x30(%rbp,%rbx,8)
movupd %xmm6,-0x20(%rbp,%rbx,8)
movupd -0x10(%r8,%rbx,8),%xmm0
movupd (%r8,%rbx,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm5,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm0,-0x10(%rbp,%rbx,8)
movupd %xmm6,0x0(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1ba0 <gauss+0xa70>
testb  $0x1,0x108(%rsp)
01
je     1c57 <gauss+0xb27>
mov    %rcx,%rdx
movupd (%rcx,%rbx,8),%xmm0
movupd 0x10(%rcx,%rbx,8),%xmm1
movupd (%r12,%rbx,8),%xmm2
movupd 0x10(%r12,%rbx,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm0,(%r12,%rbx,8)
movupd %xmm1,0x10(%r12,%rbx,8)
mov    0x28(%rsp),%rdx
cmp    %rdx,0x118(%rsp)
je     1a00 <gauss+0x8d0>
mov    0x28(%rsp),%rdx
lea    (%r12,%rdx,8),%r12
mov    0xf8(%rsp),%r13
mov    0x4c(%rsp),%r14d
jmp    1ab1 <gauss+0x981>
xor    %ebx,%ebx
testb  $0x1,0x108(%rsp)
01
jne    1c1f <gauss+0xaef>
jmp    1c57 <gauss+0xb27>
xor    %esi,%esi
test   $0x1,%r11b
jne    18be <gauss+0x78e>
jmp    18cc <gauss+0x79c>
mov    %r11,%rcx
xor    %esi,%esi
testb  $0x1,0xb0(%rsp)
01
jne    17b0 <gauss+0x680>
jmp    17f3 <gauss+0x6c3>
mov    0x231d(%rip),%rax
mov    (%rax),%edi
lea    0x42d(%rip),%rsi
call   1040 <fprintf@plt>
mov    0x38(%rsp),%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    -0x2(%r12),%eax
movslq %r15d,%r14
lea    -0x1(%rcx),%r10
movslq %eax,%r8
mov    %r10,%rax
imul   0x8(%rsp),%rax
add    %rcx,%rax
lea    0x0(,%rax,8),%r11
add    %r13,%r11
neg    %r9
jmp    1d2f <gauss+0xbff>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x8,%r11
cmp    0x40(%rsp),%rcx
je     1cd1 <gauss+0xba1>
cmp    $0x2,%r12d
jl     1d20 <gauss+0xbf0>
xor    %ebx,%ebx
mov    %r8,%rdx
jmp    1d5a <gauss+0xc2a>
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x1,%ebx
add    $0xffffffffffffffff,%rdx
cmp    %r15d,%ebx
je     1d20 <gauss+0xbf0>
mov    %rdx,%rax
imul   0x8(%rsp),%rax
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
pxor   %xmm0,%xmm0
cmp    %r14,%rdx
jge    1d40 <gauss+0xc10>
lea    (%rdi,%r14,8),%rsi
pxor   %xmm0,%xmm0
mov    %r11,%rbp
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm1
add    $0xfffffffffffffff8,%rsi
mulsd  0x0(%rbp),%xmm1
addsd  %xmm1,%xmm0
add    $0xffffffffffffffff,%rax
add    %r9,%rbp
cmp    %rdx,%rax
jg     1d90 <gauss+0xc60>
jmp    1d40 <gauss+0xc10>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [38 x i8] c"Error : Illegal parameter in gauss()\0A\00"
@.str.1 = [35 x i8] c"Error : Out of memory in gauss()\0A\00"
@.str.2 = [32 x i8] c"Error : pivot < eps in gauss()\0A\00"
define void @gauss(double* nocapture %0, i32 %1, i32 %2, i32 %3, double %4) {
%6 = icmp slt i32 %1, %3
%7 = icmp slt i32 %2, 2
%8 = or i1 %7, %6
br i1 %8, label %13, label %9
9: ; preds = %5
%10 = icmp sge i32 %2, %3
%11 = fcmp ole double %4, 0.000000e+00
%12 = or i1 %10, %11
br i1 %12, label %13, label %16
13: ; preds = %9, %5
%14 = load i32, i32* @stderr
%15 = tail call i32 @fprintf(i32 %14, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
br label %613
16: ; preds = %9
%17 = shl i32 %2, 2
%18 = tail call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to i32*
%20 = icmp eq i64 %18, 0
br i1 %20, label %93, label %21
21: ; preds = %16
%22 = add i32 %2, -1
%23 = zext i32 %22 to i64
%24 = add nuw nsw i64 %23, 1
%25 = icmp ult i32 %22, 7
br i1 %25, label %90, label %26
26: ; preds = %21
%27 = and i64 %24, 8589934584
%28 = trunc i64 %27 to i32
%29 = getelementptr i32, i32* %19, i64 %27
%30 = add nsw i64 %27, -8
%31 = lshr exact i64 %30, 3
%32 = add nuw nsw i64 %31, 1
%33 = and i64 %32, 3
%34 = icmp ult i64 %30, 24
br i1 %34, label %71, label %35
35: ; preds = %26
%36 = and i64 %32, 4611686018427387900
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %67, %37 ]
%39 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %35 ], [ %68, %37 ]
%40 = phi i64 [ 0, %35 ], [ %69, %37 ]
%41 = add <4 x i32> %39, <i32 4, i32 4, i32 4, i32 4>
%42 = getelementptr i32, i32* %19, i64 %38
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %43
%44 = getelementptr i32, i32* %42, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %45
%46 = or i64 %38, 8
%47 = add <4 x i32> %39, <i32 8, i32 8, i32 8, i32 8>
%48 = add <4 x i32> %39, <i32 12, i32 12, i32 12, i32 12>
%49 = getelementptr i32, i32* %19, i64 %46
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %50
%51 = getelementptr i32, i32* %49, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %52
%53 = or i64 %38, 16
%54 = add <4 x i32> %39, <i32 16, i32 16, i32 16, i32 16>
%55 = add <4 x i32> %39, <i32 20, i32 20, i32 20, i32 20>
%56 = getelementptr i32, i32* %19, i64 %53
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %54, <4 x i32>* %57
%58 = getelementptr i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = or i64 %38, 24
%61 = add <4 x i32> %39, <i32 24, i32 24, i32 24, i32 24>
%62 = add <4 x i32> %39, <i32 28, i32 28, i32 28, i32 28>
%63 = getelementptr i32, i32* %19, i64 %60
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %61, <4 x i32>* %64
%65 = getelementptr i32, i32* %63, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %66
%67 = add nuw i64 %38, 32
%68 = add <4 x i32> %39, <i32 32, i32 32, i32 32, i32 32>
%69 = add i64 %40, 4
%70 = icmp eq i64 %69, %36
br i1 %70, label %71, label %37
71: ; preds = %37, %26
%72 = phi i64 [ 0, %26 ], [ %67, %37 ]
%73 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %26 ], [ %68, %37 ]
%74 = icmp eq i64 %33, 0
br i1 %74, label %88, label %75
75: ; preds = %71, %75
%76 = phi i64 [ %84, %75 ], [ %72, %71 ]
%77 = phi <4 x i32> [ %85, %75 ], [ %73, %71 ]
%78 = phi i64 [ %86, %75 ], [ 0, %71 ]
%79 = add <4 x i32> %77, <i32 4, i32 4, i32 4, i32 4>
%80 = getelementptr i32, i32* %19, i64 %76
%81 = bitcast i32* %80 to <4 x i32>*
store <4 x i32> %77, <4 x i32>* %81
%82 = getelementptr i32, i32* %80, i64 4
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %83
%84 = add nuw i64 %76, 8
%85 = add <4 x i32> %77, <i32 8, i32 8, i32 8, i32 8>
%86 = add i64 %78, 1
%87 = icmp eq i64 %86, %33
br i1 %87, label %88, label %75
88: ; preds = %75, %71
%89 = icmp eq i64 %24, %27
br i1 %89, label %96, label %90
90: ; preds = %21, %88
%91 = phi i32 [ 0, %21 ], [ %28, %88 ]
%92 = phi i32* [ %19, %21 ], [ %29, %88 ]
br label %126
93: ; preds = %16
%94 = load i32, i32* @stderr
%95 = tail call i32 @fprintf(i32 %94, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.1, i64 0, i64 0))
br label %613
96: ; preds = %126, %88
%97 = icmp sgt i32 %3, 0
%98 = sext i32 %1 to i64
%99 = sext i32 %3 to i64
%100 = sext i32 %2 to i64
%101 = zext i32 %2 to i64
%102 = zext i32 %3 to i64
%103 = add nsw i64 %98, 1
%104 = shl nsw i64 %98, 3
%105 = add nsw i64 %104, 8
%106 = add nsw i64 %98, 2
%107 = add i32 %3, -2
%108 = getelementptr double, double* %0, i64 1
%109 = getelementptr double, double* %0, i64 2
%110 = bitcast double* %109 to i8*
%111 = getelementptr double, double* %0, i64 %102
%112 = and i64 %102, 4294967292
%113 = add nsw i64 %112, -4
%114 = lshr exact i64 %113, 2
%115 = add nuw nsw i64 %114, 1
%116 = icmp ult i32 %3, 4
%117 = and i64 %102, 4294967292
%118 = and i64 %115, 1
%119 = icmp eq i64 %113, 0
%120 = and i64 %115, 9223372036854775806
%121 = icmp eq i64 %118, 0
%122 = icmp eq i64 %117, %102
%123 = and i64 %102, 1
%124 = icmp eq i64 %123, 0
%125 = sub nsw i64 0, %102
br label %135
126: ; preds = %90, %126
%127 = phi i32 [ %130, %126 ], [ %91, %90 ]
%128 = phi i32* [ %129, %126 ], [ %92, %90 ]
%129 = getelementptr inbounds i32, i32* %128, i64 1
store i32 %127, i32* %128
%130 = add nuw nsw i32 %127, 1
%131 = icmp eq i32 %130, %2
br i1 %131, label %96, label %126
132: ; preds = %561, %403
%133 = add nuw nsw i64 %137, 1
%134 = icmp eq i64 %404, %101
br i1 %134, label %565, label %135
135: ; preds = %132, %96
%136 = phi i64 [ 0, %96 ], [ %404, %132 ]
%137 = phi i64 [ 1, %96 ], [ %133, %132 ]
%138 = phi i32 [ undef, %96 ], [ %222, %132 ]
%139 = trunc i64 %136 to i32
%140 = sub i32 %107, %139
%141 = zext i32 %140 to i64
%142 = add nuw nsw i64 %141, 1
%143 = and i64 %142, 8589934588
%144 = add nsw i64 %143, -4
%145 = lshr exact i64 %144, 2
%146 = add nuw nsw i64 %145, 1
%147 = trunc i64 %136 to i32
%148 = xor i32 %147, -1
%149 = add i32 %148, %3
%150 = zext i32 %149 to i64
%151 = add nuw nsw i64 %150, 1
%152 = and i64 %151, 8589934590
%153 = add nsw i64 %152, -2
%154 = lshr exact i64 %153, 1
%155 = add nuw i64 %154, 1
%156 = trunc i64 %136 to i32
%157 = sub i32 %2, %156
%158 = trunc i64 %136 to i32
%159 = mul i64 %136, %98
%160 = getelementptr double, double* %0, i64 %159
%161 = add i64 %159, %102
%162 = getelementptr double, double* %0, i64 %161
%163 = trunc i64 %136 to i32
%164 = xor i32 %163, -1
%165 = add i32 %164, %3
%166 = zext i32 %165 to i64
%167 = add nuw nsw i64 %166, 1
%168 = trunc i64 %136 to i32
%169 = sub i32 %107, %168
%170 = zext i32 %169 to i64
%171 = add nuw nsw i64 %170, 1
%172 = mul i64 %105, %136
%173 = trunc i64 %136 to i32
%174 = sub i32 %107, %173
%175 = zext i32 %174 to i64
%176 = add nsw i64 %106, %175
%177 = getelementptr i8, i8* %110, i64 %172
%178 = shl nuw nsw i64 %175, 3
%179 = getelementptr i8, i8* %177, i64 %178
%180 = mul nsw i64 %136, %98
%181 = getelementptr inbounds double, double* %0, i64 %180
%182 = getelementptr inbounds double, double* %181, i64 %136
%183 = trunc i64 %136 to i32
%184 = and i32 %157, 1
%185 = icmp eq i32 %184, 0
br i1 %185, label %194, label %186
186: ; preds = %135
%187 = getelementptr inbounds double, double* %182, i64 1
%188 = load double, double* %182
%189 = tail call double @llvm.fabs.f64(double %188)
%190 = fcmp one double %188, 0.000000e+00
%191 = select i1 %190, i32 %183, i32 %138
%192 = select i1 %190, double %189, double 0.000000e+00
%193 = add nuw nsw i32 %183, 1
br label %194
194: ; preds = %186, %135
%195 = phi i32 [ undef, %135 ], [ %191, %186 ]
%196 = phi double [ 0.000000e+00, %135 ], [ %192, %186 ]
%197 = phi double* [ %182, %135 ], [ %187, %186 ]
%198 = phi i32 [ %183, %135 ], [ %193, %186 ]
%199 = phi i32 [ %138, %135 ], [ %191, %186 ]
%200 = icmp eq i32 %22, %158
br i1 %200, label %221, label %201
201: ; preds = %194, %201
%202 = phi double [ %218, %201 ], [ %196, %194 ]
%203 = phi double* [ %213, %201 ], [ %197, %194 ]
%204 = phi i32 [ %219, %201 ], [ %198, %194 ]
%205 = phi i32 [ %217, %201 ], [ %199, %194 ]
%206 = getelementptr inbounds double, double* %203, i64 1
%207 = load double, double* %203
%208 = tail call double @llvm.fabs.f64(double %207)
%209 = fcmp ogt double %208, %202
%210 = select i1 %209, i32 %204, i32 %205
%211 = select i1 %209, double %208, double %202
%212 = add nuw nsw i32 %204, 1
%213 = getelementptr inbounds double, double* %203, i64 2
%214 = load double, double* %206
%215 = tail call double @llvm.fabs.f64(double %214)
%216 = fcmp ogt double %215, %211
%217 = select i1 %216, i32 %212, i32 %210
%218 = select i1 %216, double %215, double %211
%219 = add nuw nsw i32 %204, 2
%220 = icmp eq i32 %219, %2
br i1 %220, label %221, label %201
221: ; preds = %201, %194
%222 = phi i32 [ %195, %194 ], [ %217, %201 ]
%223 = mul nsw i32 %222, %1
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %0, i64 %224
%226 = getelementptr inbounds double, double* %225, i64 %136
%227 = load double, double* %226
%228 = tail call double @llvm.fabs.f64(double %227)
%229 = fcmp olt double %228, %4
br i1 %229, label %230, label %235
230: ; preds = %221
%231 = load i32, i32* @stderr
%232 = tail call i32 @fprintf(i32 %231, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
%233 = inttoptr i64 %18 to i8*
%234 = tail call i32 @free(i8* %233)
br label %613
235: ; preds = %221
%236 = zext i32 %222 to i64
%237 = icmp eq i64 %136, %236
br i1 %237, label %348, label %238
238: ; preds = %235
%239 = getelementptr inbounds i32, i32* %19, i64 %136
%240 = load i32, i32* %239
%241 = sext i32 %222 to i64
%242 = getelementptr inbounds i32, i32* %19, i64 %241
%243 = load i32, i32* %242
store i32 %243, i32* %239
store i32 %240, i32* %242
br i1 %97, label %244, label %348
244: ; preds = %238
br i1 %116, label %317, label %245
245: ; preds = %244
%246 = getelementptr double, double* %0, i64 %224
%247 = getelementptr double, double* %111, i64 %224
%248 = icmp ult double* %160, %247
%249 = icmp ult double* %246, %162
%250 = and i1 %248, %249
br i1 %250, label %317, label %251
251: ; preds = %245
br i1 %119, label %295, label %252
252: ; preds = %251, %252
%253 = phi i64 [ %292, %252 ], [ 0, %251 ]
%254 = phi i64 [ %293, %252 ], [ 0, %251 ]
%255 = add nsw i64 %253, %180
%256 = add nsw i64 %253, %224
%257 = getelementptr inbounds double, double* %0, i64 %255
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = getelementptr inbounds double, double* %257, i64 2
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %0, i64 %256
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = getelementptr inbounds double, double* %263, i64 2
%267 = bitcast double* %266 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = bitcast double* %257 to <2 x double>*
store <2 x double> %265, <2 x double>* %269
%270 = bitcast double* %260 to <2 x double>*
store <2 x double> %268, <2 x double>* %270
%271 = bitcast double* %263 to <2 x double>*
store <2 x double> %259, <2 x double>* %271
%272 = bitcast double* %266 to <2 x double>*
store <2 x double> %262, <2 x double>* %272
%273 = or i64 %253, 4
%274 = add nsw i64 %273, %180
%275 = add nsw i64 %273, %224
%276 = getelementptr inbounds double, double* %0, i64 %274
%277 = bitcast double* %276 to <2 x double>*
%278 = load <2 x double>, <2 x double>* %277
%279 = getelementptr inbounds double, double* %276, i64 2
%280 = bitcast double* %279 to <2 x double>*
%281 = load <2 x double>, <2 x double>* %280
%282 = getelementptr inbounds double, double* %0, i64 %275
%283 = bitcast double* %282 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283
%285 = getelementptr inbounds double, double* %282, i64 2
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = bitcast double* %276 to <2 x double>*
store <2 x double> %284, <2 x double>* %288
%289 = bitcast double* %279 to <2 x double>*
store <2 x double> %287, <2 x double>* %289
%290 = bitcast double* %282 to <2 x double>*
store <2 x double> %278, <2 x double>* %290
%291 = bitcast double* %285 to <2 x double>*
store <2 x double> %281, <2 x double>* %291
%292 = add nuw i64 %253, 8
%293 = add i64 %254, 2
%294 = icmp eq i64 %293, %120
br i1 %294, label %295, label %252
295: ; preds = %252, %251
%296 = phi i64 [ 0, %251 ], [ %292, %252 ]
br i1 %121, label %316, label %297
297: ; preds = %295
%298 = add nsw i64 %296, %180
%299 = add nsw i64 %296, %224
%300 = getelementptr inbounds double, double* %0, i64 %298
%301 = bitcast double* %300 to <2 x double>*
%302 = load <2 x double>, <2 x double>* %301
%303 = getelementptr inbounds double, double* %300, i64 2
%304 = bitcast double* %303 to <2 x double>*
%305 = load <2 x double>, <2 x double>* %304
%306 = getelementptr inbounds double, double* %0, i64 %299
%307 = bitcast double* %306 to <2 x double>*
%308 = load <2 x double>, <2 x double>* %307
%309 = getelementptr inbounds double, double* %306, i64 2
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = bitcast double* %300 to <2 x double>*
store <2 x double> %308, <2 x double>* %312
%313 = bitcast double* %303 to <2 x double>*
store <2 x double> %311, <2 x double>* %313
%314 = bitcast double* %306 to <2 x double>*
store <2 x double> %302, <2 x double>* %314
%315 = bitcast double* %309 to <2 x double>*
store <2 x double> %305, <2 x double>* %315
br label %316
316: ; preds = %295, %297
br i1 %122, label %348, label %317
317: ; preds = %245, %244, %316
%318 = phi i64 [ 0, %245 ], [ 0, %244 ], [ %117, %316 ]
%319 = xor i64 %318, -1
br i1 %124, label %328, label %320
320: ; preds = %317
%321 = add nsw i64 %318, %180
%322 = add nsw i64 %318, %224
%323 = getelementptr inbounds double, double* %0, i64 %321
%324 = load double, double* %323
%325 = getelementptr inbounds double, double* %0, i64 %322
%326 = load double, double* %325
store double %326, double* %323
store double %324, double* %325
%327 = or i64 %318, 1
br label %328
328: ; preds = %320, %317
%329 = phi i64 [ %318, %317 ], [ %327, %320 ]
%330 = icmp eq i64 %319, %125
br i1 %330, label %348, label %331
331: ; preds = %328, %331
%332 = phi i64 [ %346, %331 ], [ %329, %328 ]
%333 = add nsw i64 %332, %180
%334 = add nsw i64 %332, %224
%335 = getelementptr inbounds double, double* %0, i64 %333
%336 = load double, double* %335
%337 = getelementptr inbounds double, double* %0, i64 %334
%338 = load double, double* %337
store double %338, double* %335
store double %336, double* %337
%339 = add nuw nsw i64 %332, 1
%340 = add nsw i64 %339, %180
%341 = add nsw i64 %339, %224
%342 = getelementptr inbounds double, double* %0, i64 %340
%343 = load double, double* %342
%344 = getelementptr inbounds double, double* %0, i64 %341
%345 = load double, double* %344
store double %345, double* %342
store double %343, double* %344
%346 = add nuw nsw i64 %332, 2
%347 = icmp eq i64 %346, %102
br i1 %347, label %348, label %331
348: ; preds = %328, %331, %316, %238, %235
%349 = icmp slt i64 %136, %99
br i1 %349, label %350, label %403
350: ; preds = %348
%351 = trunc i64 %136 to i32
%352 = icmp eq i32 %165, 0
br i1 %352, label %392, label %353
353: ; preds = %350
%354 = and i64 %167, 8589934590
%355 = getelementptr double, double* %182, i64 %354
%356 = trunc i64 %354 to i32
%357 = add i32 %351, %356
%358 = insertelement <2 x double> poison, double %227, i64 0
%359 = shufflevector <2 x double> %358, <2 x double> poison, <2 x i32> zeroinitializer
%360 = and i64 %155, 1
%361 = icmp eq i64 %153, 0
br i1 %361, label %381, label %362
362: ; preds = %353
%363 = and i64 %155, -2
br label %364
364: ; preds = %364, %362
%365 = phi i64 [ 0, %362 ], [ %378, %364 ]
%366 = phi i64 [ 0, %362 ], [ %379, %364 ]
%367 = getelementptr double, double* %182, i64 %365
%368 = bitcast double* %367 to <2 x double>*
%369 = load <2 x double>, <2 x double>* %368
%370 = fdiv <2 x double> %369, %359
%371 = bitcast double* %367 to <2 x double>*
store <2 x double> %370, <2 x double>* %371
%372 = or i64 %365, 2
%373 = getelementptr double, double* %182, i64 %372
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = fdiv <2 x double> %375, %359
%377 = bitcast double* %373 to <2 x double>*
store <2 x double> %376, <2 x double>* %377
%378 = add nuw i64 %365, 4
%379 = add nuw i64 %366, 2
%380 = icmp eq i64 %379, %363
br i1 %380, label %381, label %364
381: ; preds = %364, %353
%382 = phi i64 [ 0, %353 ], [ %378, %364 ]
%383 = icmp eq i64 %360, 0
br i1 %383, label %390, label %384
384: ; preds = %381
%385 = getelementptr double, double* %182, i64 %382
%386 = bitcast double* %385 to <2 x double>*
%387 = load <2 x double>, <2 x double>* %386
%388 = fdiv <2 x double> %387, %359
%389 = bitcast double* %385 to <2 x double>*
store <2 x double> %388, <2 x double>* %389
br label %390
390: ; preds = %381, %384
%391 = icmp eq i64 %167, %354
br i1 %391, label %403, label %392
392: ; preds = %350, %390
%393 = phi double* [ %182, %350 ], [ %355, %390 ]
%394 = phi i32 [ %351, %350 ], [ %357, %390 ]
br label %395
395: ; preds = %392, %395
%396 = phi double* [ %398, %395 ], [ %393, %392 ]
%397 = phi i32 [ %401, %395 ], [ %394, %392 ]
%398 = getelementptr inbounds double, double* %396, i64 1
%399 = load double, double* %396
%400 = fdiv double %399, %227
store double %400, double* %396
%401 = add nuw nsw i32 %397, 1
%402 = icmp eq i32 %401, %3
br i1 %402, label %403, label %395
403: ; preds = %395, %390, %348
%404 = add nuw nsw i64 %136, 1
%405 = icmp slt i64 %404, %100
br i1 %405, label %406, label %132
406: ; preds = %403
%407 = getelementptr inbounds double, double* %181, i64 %404
%408 = icmp sge i64 %404, %99
%409 = trunc i64 %404 to i32
%410 = icmp ult i32 %169, 3
%411 = and i64 %171, 8589934588
%412 = getelementptr double, double* %407, i64 %411
%413 = trunc i64 %411 to i32
%414 = add i32 %409, %413
%415 = and i64 %146, 1
%416 = icmp eq i64 %144, 0
%417 = and i64 %146, 9223372036854775806
%418 = icmp eq i64 %415, 0
%419 = icmp eq i64 %171, %411
br label %420
420: ; preds = %406, %561
%421 = phi i64 [ 0, %406 ], [ %564, %561 ]
%422 = phi i64 [ %137, %406 ], [ %562, %561 ]
%423 = mul i64 %421, %98
%424 = add i64 %103, %423
%425 = getelementptr double, double* %0, i64 %424
%426 = bitcast double* %425 to i8*
%427 = getelementptr i8, i8* %426, i64 %172
%428 = add i64 %176, %423
%429 = getelementptr double, double* %0, i64 %428
%430 = mul nsw i64 %422, %98
%431 = getelementptr inbounds double, double* %0, i64 %430
%432 = getelementptr inbounds double, double* %431, i64 %136
%433 = load double, double* %432
%434 = fcmp oeq double %433, 0.000000e+00
%435 = select i1 %434, i1 true, i1 %408
br i1 %435, label %561, label %436
436: ; preds = %420
%437 = getelementptr inbounds double, double* %431, i64 %404
%438 = fneg double %433
br i1 %410, label %508, label %439
439: ; preds = %436
%440 = icmp ult i8* %427, %179
%441 = icmp ult double* %108, %429
%442 = and i1 %440, %441
br i1 %442, label %508, label %443
443: ; preds = %439
%444 = getelementptr double, double* %437, i64 %411
%445 = insertelement <2 x double> poison, double %438, i64 0
%446 = shufflevector <2 x double> %445, <2 x double> poison, <2 x i32> zeroinitializer
%447 = insertelement <2 x double> poison, double %438, i64 0
%448 = shufflevector <2 x double> %447, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %416, label %488, label %449
449: ; preds = %443, %449
%450 = phi i64 [ %485, %449 ], [ 0, %443 ]
%451 = phi i64 [ %486, %449 ], [ 0, %443 ]
%452 = getelementptr double, double* %407, i64 %450
%453 = getelementptr double, double* %437, i64 %450
%454 = bitcast double* %452 to <2 x double>*
%455 = load <2 x double>, <2 x double>* %454
%456 = getelementptr double, double* %452, i64 2
%457 = bitcast double* %456 to <2 x double>*
%458 = load <2 x double>, <2 x double>* %457
%459 = bitcast double* %453 to <2 x double>*
%460 = load <2 x double>, <2 x double>* %459
%461 = getelementptr double, double* %453, i64 2
%462 = bitcast double* %461 to <2 x double>*
%463 = load <2 x double>, <2 x double>* %462
%464 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %446, <2 x double> %455, <2 x double> %460)
%465 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %448, <2 x double> %458, <2 x double> %463)
%466 = bitcast double* %453 to <2 x double>*
store <2 x double> %464, <2 x double>* %466
%467 = bitcast double* %461 to <2 x double>*
store <2 x double> %465, <2 x double>* %467
%468 = or i64 %450, 4
%469 = getelementptr double, double* %407, i64 %468
%470 = getelementptr double, double* %437, i64 %468
%471 = bitcast double* %469 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = getelementptr double, double* %469, i64 2
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = bitcast double* %470 to <2 x double>*
%477 = load <2 x double>, <2 x double>* %476
%478 = getelementptr double, double* %470, i64 2
%479 = bitcast double* %478 to <2 x double>*
%480 = load <2 x double>, <2 x double>* %479
%481 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %446, <2 x double> %472, <2 x double> %477)
%482 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %448, <2 x double> %475, <2 x double> %480)
%483 = bitcast double* %470 to <2 x double>*
store <2 x double> %481, <2 x double>* %483
%484 = bitcast double* %478 to <2 x double>*
store <2 x double> %482, <2 x double>* %484
%485 = add nuw i64 %450, 8
%486 = add i64 %451, 2
%487 = icmp eq i64 %486, %417
br i1 %487, label %488, label %449
488: ; preds = %449, %443
%489 = phi i64 [ 0, %443 ], [ %485, %449 ]
br i1 %418, label %507, label %490
490: ; preds = %488
%491 = getelementptr double, double* %407, i64 %489
%492 = getelementptr double, double* %437, i64 %489
%493 = bitcast double* %491 to <2 x double>*
%494 = load <2 x double>, <2 x double>* %493
%495 = getelementptr double, double* %491, i64 2
%496 = bitcast double* %495 to <2 x double>*
%497 = load <2 x double>, <2 x double>* %496
%498 = bitcast double* %492 to <2 x double>*
%499 = load <2 x double>, <2 x double>* %498
%500 = getelementptr double, double* %492, i64 2
%501 = bitcast double* %500 to <2 x double>*
%502 = load <2 x double>, <2 x double>* %501
%503 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %446, <2 x double> %494, <2 x double> %499)
%504 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %448, <2 x double> %497, <2 x double> %502)
%505 = bitcast double* %492 to <2 x double>*
store <2 x double> %503, <2 x double>* %505
%506 = bitcast double* %500 to <2 x double>*
store <2 x double> %504, <2 x double>* %506
br label %507
507: ; preds = %488, %490
br i1 %419, label %561, label %508
508: ; preds = %439, %436, %507
%509 = phi double* [ %407, %439 ], [ %407, %436 ], [ %412, %507 ]
%510 = phi double* [ %437, %439 ], [ %437, %436 ], [ %444, %507 ]
%511 = phi i32 [ %409, %439 ], [ %409, %436 ], [ %414, %507 ]
%512 = sub i32 %3, %511
%513 = xor i32 %511, -1
%514 = add i32 %513, %3
%515 = and i32 %512, 3
%516 = icmp eq i32 %515, 0
br i1 %516, label %530, label %517
517: ; preds = %508, %517
%518 = phi double* [ %522, %517 ], [ %509, %508 ]
%519 = phi double* [ %524, %517 ], [ %510, %508 ]
%520 = phi i32 [ %527, %517 ], [ %511, %508 ]
%521 = phi i32 [ %528, %517 ], [ 0, %508 ]
%522 = getelementptr inbounds double, double* %518, i64 1
%523 = load double, double* %518
%524 = getelementptr inbounds double, double* %519, i64 1
%525 = load double, double* %519
%526 = tail call double @llvm.fmuladd.f64(double %438, double %523, double %525)
store double %526, double* %519
%527 = add nuw nsw i32 %520, 1
%528 = add i32 %521, 1
%529 = icmp eq i32 %528, %515
br i1 %529, label %530, label %517
530: ; preds = %517, %508
%531 = phi double* [ %509, %508 ], [ %522, %517 ]
%532 = phi double* [ %510, %508 ], [ %524, %517 ]
%533 = phi i32 [ %511, %508 ], [ %527, %517 ]
%534 = icmp ult i32 %514, 3
br i1 %534, label %561, label %535
535: ; preds = %530, %535
%536 = phi double* [ %554, %535 ], [ %531, %530 ]
%537 = phi double* [ %556, %535 ], [ %532, %530 ]
%538 = phi i32 [ %559, %535 ], [ %533, %530 ]
%539 = getelementptr inbounds double, double* %536, i64 1
%540 = load double, double* %536
%541 = getelementptr inbounds double, double* %537, i64 1
%542 = load double, double* %537
%543 = tail call double @llvm.fmuladd.f64(double %438, double %540, double %542)
store double %543, double* %537
%544 = getelementptr inbounds double, double* %536, i64 2
%545 = load double, double* %539
%546 = getelementptr inbounds double, double* %537, i64 2
%547 = load double, double* %541
%548 = tail call double @llvm.fmuladd.f64(double %438, double %545, double %547)
store double %548, double* %541
%549 = getelementptr inbounds double, double* %536, i64 3
%550 = load double, double* %544
%551 = getelementptr inbounds double, double* %537, i64 3
%552 = load double, double* %546
%553 = tail call double @llvm.fmuladd.f64(double %438, double %550, double %552)
store double %553, double* %546
%554 = getelementptr inbounds double, double* %536, i64 4
%555 = load double, double* %549
%556 = getelementptr inbounds double, double* %537, i64 4
%557 = load double, double* %551
%558 = tail call double @llvm.fmuladd.f64(double %438, double %555, double %557)
store double %558, double* %551
%559 = add nuw nsw i32 %538, 4
%560 = icmp eq i32 %559, %3
br i1 %560, label %561, label %535
561: ; preds = %530, %535, %507, %420
%562 = add nuw nsw i64 %422, 1
%563 = icmp eq i64 %562, %101
%564 = add i64 %421, 1
br i1 %563, label %132, label %420
565: ; preds = %132
%566 = add i32 %2, -1
%567 = add i32 %2, -2
%568 = icmp sgt i32 %2, 1
%569 = sext i32 %566 to i64
%570 = sext i32 %2 to i64
%571 = add nsw i64 %570, -1
%572 = sext i32 %1 to i64
%573 = sext i32 %567 to i64
%574 = sext i32 %3 to i64
br label %575
575: ; preds = %565, %607
%576 = phi i64 [ %570, %565 ], [ %608, %607 ]
br i1 %568, label %577, label %607
577: ; preds = %575
%578 = getelementptr inbounds double, double* %0, i64 %576
br label %579
579: ; preds = %577, %599
%580 = phi i64 [ %573, %577 ], [ %605, %599 ]
%581 = phi i32 [ 0, %577 ], [ %604, %599 ]
%582 = mul nsw i64 %580, %572
%583 = getelementptr inbounds double, double* %0, i64 %582
%584 = icmp slt i64 %580, %569
br i1 %584, label %585, label %599
585: ; preds = %579
%586 = getelementptr inbounds double, double* %583, i64 %569
br label %587
587: ; preds = %585, %587
%588 = phi i64 [ %571, %585 ], [ %597, %587 ]
%589 = phi double [ 0.000000e+00, %585 ], [ %596, %587 ]
%590 = phi double* [ %586, %585 ], [ %591, %587 ]
%591 = getelementptr inbounds double, double* %590, i64 -1
%592 = load double, double* %590
%593 = mul nsw i64 %588, %572
%594 = getelementptr inbounds double, double* %578, i64 %593
%595 = load double, double* %594
%596 = tail call double @llvm.fmuladd.f64(double %592, double %595, double %589)
%597 = add nsw i64 %588, -1
%598 = icmp sgt i64 %597, %580
br i1 %598, label %587, label %599
599: ; preds = %587, %579
%600 = phi double [ 0.000000e+00, %579 ], [ %596, %587 ]
%601 = getelementptr inbounds double, double* %583, i64 %576
%602 = load double, double* %601
%603 = fsub double %602, %600
store double %603, double* %601
%604 = add nuw nsw i32 %581, 1
%605 = add nsw i64 %580, -1
%606 = icmp eq i32 %604, %566
br i1 %606, label %607, label %579
607: ; preds = %599, %575
%608 = add nsw i64 %576, 1
%609 = icmp eq i64 %608, %574
br i1 %609, label %610, label %575
610: ; preds = %607
%611 = inttoptr i64 %18 to i8*
%612 = tail call i32 @free(i8* %611)
br label %613
613: ; preds = %610, %230, %93, %13
ret void
}