#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__ fabs(double);
void Gauss_elimination(int n, double (*a)[n + 1], double *x) {
  int i, j, k;
  double temp, s, l;
  for (i = 0; i < n - 1; i++) {
    k = i;
    for (j = i + 1; j < n; j++) {
      if (fabs(a[j][i]) > fabs(a[k][i]))
        k = j;
    }
    if (k != i)
      for (j = i; j <= n; j++) {
        temp = a[i][j];
        a[i][j] = a[k][j];
        a[k][j] = temp;
      }
    for (j = i + 1; j < n; j++) {
      l = a[j][i] / a[i][i];
      for (k = 0; k < n + 1; k++)
        a[j][k] = a[j][k] - a[i][k] * l;
    }
  }
  x[n - 1] = a[n - 1][n] / a[n - 1][n - 1];
  for (i = n - 2; i >= 0; i--) {
    s = 0.0;
    for (j = i; j < n; j++) {
      if (j == i)
        continue;
      s += a[i][j] * x[j];
    }
    x[i] = (a[i][n] - s) / a[i][i];
  }
}


x86 assembly (clang, -O0):
<Gauss_elimination>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13a6 <Gauss_elimination+0x296>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11d9 <Gauss_elimination+0xc9>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    -0x48(%rbp),%rdx
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
cmp    %rcx,%rax
jle    11c6 <Gauss_elimination+0xb6>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11cb <Gauss_elimination+0xbb>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1156 <Gauss_elimination+0x46>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1288 <Gauss_elimination+0x178>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1283 <Gauss_elimination+0x173>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11eb <Gauss_elimination+0xdb>
jmp    1288 <Gauss_elimination+0x178>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1393 <Gauss_elimination+0x283>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1380 <Gauss_elimination+0x270>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e5 <Gauss_elimination+0x1d5>
jmp    1385 <Gauss_elimination+0x275>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1291 <Gauss_elimination+0x181>
jmp    1398 <Gauss_elimination+0x288>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1136 <Gauss_elimination+0x26>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     14ea <Gauss_elimination+0x3da>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    148e <Gauss_elimination+0x37e>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1441 <Gauss_elimination+0x331>
jmp    1480 <Gauss_elimination+0x370>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1424 <Gauss_elimination+0x314>
mov    -0x48(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    140c <Gauss_elimination+0x2fc>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Gauss_elimination>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
lea    0x1(%rdi),%r13d
lea    -0x1(%rdi),%ecx
cmp    $0x1,%edi
jle    179f <Gauss_elimination+0x68f>
mov    %rdx,0x98(%rsp)
mov    %rdi,0x20(%rsp)
mov    %edi,%r11d
mov    %ecx,0x3c(%rsp)
mov    %ecx,%eax
mov    %rax,0xc8(%rsp)
lea    0x0(%r13,%r13,1),%rax
mov    %rax,0xb8(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0x8(%rsp)
lea    0x8(,%r13,8),%rax
mov    %rax,0x28(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xc0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xf0(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r13,%rax
neg    %rax
mov    %rax,0x80(%rsp)
mov    %rcx,%rax
mov    %rcx,0xe8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xe0(%rsp)
lea    (%rsi,%r13,8),%rax
lea    -0x4(%r13),%rcx
mov    %rcx,0x48(%rsp)
lea    0x30(%rsi),%r14
lea    0x8(%rsi),%r12
lea    (%rsi,%r13,8),%rcx
add    $0x30,%rcx
mov    %rcx,0x50(%rsp)
mov    $0x1,%r15d
xor    %edx,%edx
mov    %r12,0xb0(%rsp)
mov    %r14,%rcx
mov    %rsi,0x40(%rsp)
mov    %rax,0x58(%rsp)
mov    %rax,%rbp
mov    %rsi,0xd0(%rsp)
mov    %r13,0x88(%rsp)
mov    %r11,0x18(%rsp)
jmp    1275 <Gauss_elimination+0x165>
nopl   0x0(%rax)
mov    0x68(%rsp),%r15
add    $0x1,%r15
mov    0x28(%rsp),%rax
mov    0xd8(%rsp),%rbp
add    %rax,%rbp
addq   $0xffffffffffffffff,0x48(%rsp)
addq   $0x8,0x40(%rsp)
mov    0x60(%rsp),%rcx
add    %rax,%rcx
mov    0x8(%rsp),%rax
add    %rax,%r12
add    %rax,0x50(%rsp)
add    %rax,%r14
add    %rax,0x58(%rsp)
mov    0x70(%rsp),%rdx
cmp    0xc8(%rsp),%rdx
je     17c1 <Gauss_elimination+0x6b1>
mov    %rdx,%rax
imul   %r13,%rax
mov    %rax,%rdi
mov    %rax,0x10(%rsp)
add    %r13,%rax
mov    %rax,0x78(%rsp)
lea    (%rsi,%rdx,8),%rax
mov    %rax,0x90(%rsp)
lea    0x1(%rdx),%rax
cmp    %r11,%rax
mov    %rdx,0x30(%rsp)
mov    %r15,0x68(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rbp,0xd8(%rsp)
mov    %rax,0x70(%rsp)
jae    1320 <Gauss_elimination+0x210>
mov    %edx,%r13d
jmp    12e6 <Gauss_elimination+0x1d6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
add    0x8(%rsp),%rbp
mov    %ecx,%r13d
mov    0x18(%rsp),%r11
cmp    %r15,%r11
je     1322 <Gauss_elimination+0x212>
movsd  0x0(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbx
movslq %r13d,%rax
imul   0x88(%rsp),%rax
mov    0x90(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
call   1030 <fabs@plt>
mov    %r15d,%ecx
cmp    %rax,%rbx
jg     12d0 <Gauss_elimination+0x1c0>
mov    %r13d,%ecx
jmp    12d0 <Gauss_elimination+0x1c0>
xchg   %ax,%ax
mov    %edx,%ecx
mov    0xd0(%rsp),%rsi
mov    0x78(%rsp),%rax
lea    (%rsi,%rax,8),%r8
mov    0x10(%rsp),%rax
lea    (%rsi,%rax,8),%r9
mov    %ecx,%eax
mov    0x30(%rsp),%rdi
cmp    %rax,%rdi
mov    0x88(%rsp),%r13
mov    0xc0(%rsp),%r15
je     1569 <Gauss_elimination+0x459>
cmp    %r11,%rdi
ja     1569 <Gauss_elimination+0x459>
mov    %r13,%rdx
sub    %rdi,%rdx
movslq %ecx,%rcx
mov    %rcx,%rbx
imul   %r13,%rbx
lea    (%rsi,%rbx,8),%rbp
mov    %rdi,%rax
cmp    $0x4,%rdx
jb     14e0 <Gauss_elimination+0x3d0>
mov    0x28(%rsp),%rax
imul   %rdi,%rax
add    %rsi,%rax
lea    0x8(,%rcx,8),%rcx
imul   %r13,%rcx
add    %rsi,%rcx
cmp    %rcx,%rax
jae    13be <Gauss_elimination+0x2ae>
mov    0x90(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
mov    %rdi,%rax
cmp    %r8,%rcx
jb     14e0 <Gauss_elimination+0x3d0>
lea    -0x4(%rdx),%rdi
mov    %rdi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    $0x4,%rdi
mov    %rbx,0xa8(%rsp)
mov    %rbp,0xa0(%rsp)
jae    13ea <Gauss_elimination+0x2da>
xor    %ebx,%ebx
jmp    1478 <Gauss_elimination+0x368>
mov    0x48(%rsp),%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x40(%rsp),%rbp
lea    0x0(%rbp,%rbx,8),%rbp
xor    %ebx,%ebx
mov    0x60(%rsp),%r10
nopl   0x0(%rax)
movups -0x30(%r10,%rbx,8),%xmm0
movups -0x20(%r10,%rbx,8),%xmm1
movups 0x0(%rbp,%rbx,8),%xmm2
movups 0x10(%rbp,%rbx,8),%xmm3
movups %xmm2,-0x30(%r10,%rbx,8)
movups %xmm3,-0x20(%r10,%rbx,8)
movups %xmm0,0x0(%rbp,%rbx,8)
movups %xmm1,0x10(%rbp,%rbx,8)
movupd -0x10(%r10,%rbx,8),%xmm0
movupd (%r10,%rbx,8),%xmm1
movupd 0x20(%rbp,%rbx,8),%xmm2
movupd 0x30(%rbp,%rbx,8),%xmm3
movupd %xmm2,-0x10(%r10,%rbx,8)
movupd %xmm3,(%r10,%rbx,8)
movupd %xmm0,0x20(%rbp,%rbx,8)
movupd %xmm1,0x30(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1410 <Gauss_elimination+0x300>
mov    %rdx,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%cl
mov    0x30(%rsp),%rcx
mov    0xa0(%rsp),%rbp
je     14c6 <Gauss_elimination+0x3b6>
add    %rcx,%rbx
movupd (%r9,%rbx,8),%xmm0
movupd 0x10(%r9,%rbx,8),%xmm1
movupd 0x0(%rbp,%rbx,8),%xmm2
movupd 0x10(%rbp,%rbx,8),%xmm3
movupd %xmm2,(%r9,%rbx,8)
movupd %xmm3,0x10(%r9,%rbx,8)
movupd %xmm0,0x0(%rbp,%rbx,8)
movupd %xmm1,0x10(%rbp,%rbx,8)
cmp    %rax,%rdx
mov    0xa8(%rsp),%rbx
je     1569 <Gauss_elimination+0x459>
add    %rcx,%rax
nopw   0x0(%rax,%rax,1)
mov    %r13d,%edx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1509 <Gauss_elimination+0x3f9>
movsd  (%r9,%rax,8),%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,(%r9,%rax,8)
movsd  %xmm0,0x0(%rbp,%rax,8)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x80(%rsp),%rax
je     1569 <Gauss_elimination+0x459>
mov    0xb0(%rsp),%rax
lea    (%rax,%rbx,8),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%r12,%rcx,8),%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rcx,8)
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r12,%rcx,8)
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1530 <Gauss_elimination+0x420>
cmp    %r11,0x70(%rsp)
jae    1220 <Gauss_elimination+0x110>
mov    0x10(%rsp),%rax
add    0xb8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%rdx
mov    0x50(%rsp),%rdi
xor    %r10d,%r10d
mov    0x68(%rsp),%rbx
jmp    15bc <Gauss_elimination+0x4ac>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r10
mov    0x8(%rsp),%rax
add    %rax,%rdi
add    %rax,%rdx
cmp    %r11,%rbx
je     1220 <Gauss_elimination+0x110>
mov    %rbx,%rax
imul   %r13,%rax
lea    (%rsi,%rax,8),%rax
mov    0x30(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  (%r9,%rcx,8),%xmm0
cmp    $0x4,%r13d
jb     160b <Gauss_elimination+0x4fb>
mov    %r10,%rcx
imul   %r13,%rcx
mov    0x78(%rsp),%rbp
add    %rcx,%rbp
lea    (%rsi,%rbp,8),%rbp
cmp    %r8,%rbp
jae    16a0 <Gauss_elimination+0x590>
add    0x10(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,%r9
jae    16a0 <Gauss_elimination+0x590>
xor    %ebp,%ebp
mov    %rbp,%rcx
test   $0x1,%r13b
je     1635 <Gauss_elimination+0x525>
movsd  (%rax,%rbp,8),%xmm1
movsd  (%r9,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rbp,8)
mov    %rbp,%rcx
or     $0x1,%rcx
not    %rbp
cmp    0x80(%rsp),%rbp
je     15a0 <Gauss_elimination+0x490>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdx,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm2,(%rdx,%rcx,8)
movsd  (%r12,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1650 <Gauss_elimination+0x540>
jmp    15a0 <Gauss_elimination+0x490>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf0(%rsp)
je     1791 <Gauss_elimination+0x681>
mov    0xe0(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r14,%rcx,8),%xmm2
movupd -0x20(%r14,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdi,%rcx,8),%xmm4
subpd  %xmm2,%xmm4
movupd -0x20(%rdi,%rcx,8),%xmm2
movupd -0x10(%rdi,%rcx,8),%xmm5
movupd (%rdi,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm2
movupd %xmm4,-0x30(%rdi,%rcx,8)
movupd %xmm2,-0x20(%rdi,%rcx,8)
movupd -0x10(%r14,%rcx,8),%xmm2
movupd (%r14,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm6
movupd %xmm5,-0x10(%rdi,%rcx,8)
movupd %xmm6,(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    16d0 <Gauss_elimination+0x5c0>
testb  $0x1,0xe8(%rsp)
01
je     1780 <Gauss_elimination+0x670>
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movupd (%r9,%rcx,8),%xmm4
movupd 0x10(%r9,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%rcx,8)
movupd %xmm3,0x10(%rax,%rcx,8)
mov    %r15,%rbp
cmp    %r13,%r15
je     15a0 <Gauss_elimination+0x490>
jmp    160d <Gauss_elimination+0x4fd>
xor    %ecx,%ecx
testb  $0x1,0xe8(%rsp)
01
jne    174d <Gauss_elimination+0x63d>
jmp    1780 <Gauss_elimination+0x670>
movslq %edi,%rax
movslq %ecx,%rcx
imul   %rcx,%r13
lea    (%rsi,%r13,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
divsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
jmp    194d <Gauss_elimination+0x83d>
movslq 0x3c(%rsp),%rdx
mov    %rdx,%rcx
imul   %r13,%rcx
lea    (%rsi,%rcx,8),%rcx
movsd  (%rcx,%r11,8),%xmm0
divsd  (%rcx,%rdx,8),%xmm0
mov    0x98(%rsp),%rax
movsd  %xmm0,(%rax,%rdx,8)
cmpl   $0x2,0x20(%rsp)
jl     194d <Gauss_elimination+0x83d>
mov    0x20(%rsp),%rcx
lea    -0x2(%rcx),%r15d
mov    %r15,%r14
not    %r14
lea    (%rax,%r15,8),%rcx
add    $0x8,%rcx
mov    0x28(%rsp),%rdx
imul   %r15,%rdx
add    %rsi,%rdx
add    $0x8,%rdx
mov    0x8(%rsp),%rbx
mov    %rbx,%r8
xor    $0xfffffffffffffff8,%r8
mov    %r15,%rdi
imul   %r13,%rdi
lea    (%rsi,%rdi,8),%rbp
add    $0x10,%rbp
neg    %rbx
mov    %rbx,0x8(%rsp)
xor    %r12d,%r12d
mov    $0x1,%bl
jmp    1892 <Gauss_elimination+0x782>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x18(%rsp),%r11
lea    (%rsi,%r10,8),%rdi
movsd  (%rdi,%r11,8),%xmm1
subsd  %xmm0,%xmm1
divsd  (%rdi,%r15,8),%xmm1
movsd  %xmm1,(%rax,%r15,8)
lea    -0x1(%r15),%rdi
add    $0x1,%r14
add    $0xfffffffffffffff8,%rcx
add    %r8,%rdx
add    $0x1,%bl
add    0x8(%rsp),%rbp
test   %r15,%r15
mov    %rdi,%r15
jle    194d <Gauss_elimination+0x83d>
mov    %r12d,%r9d
movzbl %bl,%ebx
and    $0x3,%ebx
lea    0x1(%r9),%r12d
mov    %r15,%r10
imul   %r13,%r10
xorpd  %xmm0,%xmm0
cmp    %r11,%r15
jge    1850 <Gauss_elimination+0x740>
lea    0x1(%r15),%rdi
cmp    0x20(%rsp),%edi
mov    0x18(%rsp),%r11
je     1855 <Gauss_elimination+0x745>
xorpd  %xmm0,%xmm0
test   $0x3,%r12b
je     18e9 <Gauss_elimination+0x7d9>
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %edi,%ebx
jne    18d0 <Gauss_elimination+0x7c0>
sub    %r14,%rdi
cmp    $0x3,%r9d
mov    0x18(%rsp),%r11
jb     1855 <Gauss_elimination+0x745>
nopl   0x0(%rax,%rax,1)
movsd  -0x10(%rbp,%rdi,8),%xmm1
movsd  -0x8(%rbp,%rdi,8),%xmm2
mulsd  (%rax,%rdi,8),%xmm1
mulsd  0x8(%rax,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rdi,8),%xmm3
mulsd  0x10(%rax,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x8(%rbp,%rdi,8),%xmm0
mulsd  0x18(%rax,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %edi,%r11d
jne    1900 <Gauss_elimination+0x7f0>
jmp    1855 <Gauss_elimination+0x745>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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