#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);
int gauss_make_triangular(double *A, int *p, int n) {
  p[n - 1] = n - 1;
  for (int k = 0; k < n; ++k) {
    int m = k;
    for (int i = k + 1; i < n; ++i)
      if (fabs(A[k + n * i]) > fabs(A[k + n * m]))
        m = i;
    p[k] = m;
    double t1 = A[k + n * m];
    A[k + n * m] = A[k + n * k];
    A[k + n * k] = t1;
    if (t1 != 0) {
      for (int i = k + 1; i < n; ++i)
        A[k + n * i] /= -t1;
      if (k != m)
        for (int i = k + 1; i < n; ++i) {
          double t2 = A[i + n * m];
          A[i + n * m] = A[i + n * k];
          A[i + n * k] = t2;
        }
      for (int j = k + 1; j < n; ++j)
        for (int i = k + 1; i < n; ++i)
          A[i + n * j] += A[k + j * n] * A[i + k * n];
    } else
      return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<gauss_make_triangular>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1425 <gauss_make_triangular+0x315>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ce <gauss_make_triangular+0xbe>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
cmp    %rcx,%rax
jle    11bb <gauss_make_triangular+0xab>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11c0 <gauss_make_triangular+0xb0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115b <gauss_make_triangular+0x4b>
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1263 <gauss_make_triangular+0x153>
jp     1263 <gauss_make_triangular+0x153>
jmp    1406 <gauss_make_triangular+0x2f6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c3 <gauss_make_triangular+0x1b3>
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126c <gauss_make_triangular+0x15c>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1361 <gauss_make_triangular+0x251>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    135c <gauss_make_triangular+0x24c>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d8 <gauss_make_triangular+0x1c8>
jmp    1361 <gauss_make_triangular+0x251>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1401 <gauss_make_triangular+0x2f1>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13ee <gauss_make_triangular+0x2de>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x20(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    137f <gauss_make_triangular+0x26f>
jmp    13f3 <gauss_make_triangular+0x2e3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    136a <gauss_make_triangular+0x25a>
jmp    1412 <gauss_make_triangular+0x302>
movl   $0x0,-0x4(%rbp)
jmp    142c <gauss_make_triangular+0x31c>
jmp    1417 <gauss_make_triangular+0x307>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1140 <gauss_make_triangular+0x30>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gauss_make_triangular>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
lea    -0x1(%rdx),%eax
movslq %edx,%r14
mov    %rsi,0xe8(%rsp)
mov    %eax,-0x4(%rsi,%r14,4)
xor    %ecx,%ecx
mov    $0x1,%eax
test   %r14d,%r14d
cmovg  %edx,%ecx
mov    %rcx,0xe0(%rsp)
jle    1b87 <gauss_make_triangular+0xa77>
mov    %rdi,%r12
lea    0x8(%rdi),%r8
lea    -0x2(%r14),%esi
mov    %r14,%rax
shl    $0x4,%rax
mov    %rax,0xc8(%rsp)
lea    0x0(,%r14,8),%rax
mov    %rax,0x60(%rsp)
lea    (%r14,%r14,2),%rax
lea    (%rdi,%rax,8),%r9
lea    0x8(,%r14,8),%rax
mov    %rax,0xd8(%rsp)
mov    %r14,%rax
shl    $0x5,%rax
mov    %rax,0xd0(%rsp)
lea    (%rdi,%r14,8),%rbp
lea    0x38(%rdi),%rax
mov    %r14d,%ebx
mov    %rbx,0x70(%rsp)
mov    %r14d,%ebx
neg    %ebx
mov    %ebx,0x2c(%rsp)
lea    0x18(%rdi),%rbx
lea    (%rdi,%r14,8),%rcx
add    $0x18,%rcx
mov    %rcx,0x98(%rsp)
lea    0x8(%rdi,%r14,8),%rcx
mov    %rcx,0x90(%rsp)
mov    $0x1,%ecx
mov    %rcx,0x18(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x68(%rsp)
mov    %rdi,%rcx
mov    %r8,0x58(%rsp)
mov    %rax,0x88(%rsp)
mov    %esi,0x50(%rsp)
mov    %esi,0x54(%rsp)
mov    %r12,%rsi
xor    %ecx,%ecx
mov    %rdx,0x10(%rsp)
mov    %r14,0x48(%rsp)
mov    %rdi,0x120(%rsp)
jmp    12ae <gauss_make_triangular+0x19e>
nopl   0x0(%rax)
add    $0x1,%ebx
movslq %ebx,%rbx
mov    %rbx,0x18(%rsp)
addq   $0x8,0x68(%rsp)
mov    0xa8(%rsp),%r9
mov    0xd8(%rsp),%rcx
add    %rcx,%r9
mov    0xb8(%rsp),%rbp
add    %rcx,%rbp
addl   $0xffffffff,0x54(%rsp)
mov    0xa0(%rsp),%rax
add    %rcx,%rax
addq   $0x8,0x88(%rsp)
mov    0x60(%rsp),%rdi
mov    0xb0(%rsp),%r8
add    %rdi,%r8
mov    0xc0(%rsp),%rbx
add    %rcx,%rbx
add    %rcx,0x98(%rsp)
add    %rdi,0x90(%rsp)
add    %rdi,%rsi
mov    0x20(%rsp),%rcx
cmp    0xe0(%rsp),%rcx
mov    0x48(%rsp),%r14
je     1b82 <gauss_make_triangular+0xa72>
mov    %rax,0xa0(%rsp)
mov    %r8,0xb0(%rsp)
mov    %rbx,0xc0(%rsp)
mov    %rbp,0xb8(%rsp)
mov    %r9,0xa8(%rsp)
mov    %rcx,%rdi
mov    %rcx,%rax
imul   %r14,%rax
mov    %rax,0x38(%rsp)
add    $0x1,%rcx
mov    %rdi,%rax
mov    %rdi,0x8(%rsp)
mov    %edi,%r10d
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    %r14,%rcx
mov    %rsi,0x30(%rsp)
jge    1374 <gauss_make_triangular+0x264>
mov    0x8(%rsp),%rbp
mov    %ebp,%eax
not    %eax
add    %edx,%eax
mov    0x18(%rsp),%rbx
mov    %rbx,%r15
mov    %ebp,%r13d
test   $0x1,%al
je     136a <gauss_make_triangular+0x25a>
mov    %rbx,%rax
imul   %r14,%rax
add    %rbp,%rax
movsd  (%r12,%rax,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%r15
mov    %ebp,%eax
imul   0x10(%rsp),%eax
cltq
add    %rbp,%rax
movsd  (%r12,%rax,8),%xmm0
call   1030 <fabs@plt>
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rdx
cmp    %rax,%r15
mov    %ebx,%r10d
cmovle %ebp,%r10d
lea    0x1(%rbx),%r15
mov    %r10d,%r13d
cmp    %ebp,0x50(%rsp)
jne    14c0 <gauss_make_triangular+0x3b0>
mov    0xe8(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    %r10d,(%rax,%rcx,4)
mov    %r10d,%eax
imul   %edx,%eax
movslq %eax,%r8
lea    (%rcx,%r8,1),%rax
movsd  (%r12,%rax,8),%xmm0
mov    0x38(%rsp),%rdi
add    %rdi,%rcx
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  %xmm0,(%r12,%rcx,8)
ucomisd 0xc56(%rip),%xmm0
jne    13c2 <gauss_make_triangular+0x2b2>
jnp    1b7e <gauss_make_triangular+0xa6e>
cmp    %r14,0x20(%rsp)
mov    0x18(%rsp),%rbx
jge    1220 <gauss_make_triangular+0x110>
mov    0x54(%rsp),%ebp
add    $0x1,%rbp
mov    0x50(%rsp),%eax
mov    %eax,%r9d
sub    0x8(%rsp),%r9d
add    $0x1,%r9
xorpd  0xc0e(%rip),%xmm0
mov    %ebx,%r11d
not    %r11d
mov    %rbx,%r15
add    %edx,%r11d
mov    0xc8(%rsp),%r13
mov    0xb8(%rsp),%rsi
mov    0x48(%rsp),%r14
je     15f3 <gauss_make_triangular+0x4e3>
mov    %rbx,%r15
cmp    $0x1,%edx
jne    15f3 <gauss_make_triangular+0x4e3>
mov    %r10d,0x40(%rsp)
movabs $0x1fffffffc,%rax
lea    0x2(%rax),%r15
mov    %r9,%rax
and    %r15,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,%r10
shr    %r10
add    $0x1,%r10
add    $0x1,%r11
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
test   %rax,%rax
je     15af <gauss_make_triangular+0x49f>
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
add    $0xfffffffffffffffe,%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
xor    %ebx,%ebx
mov    0xa8(%rsp),%rdi
mov    0xd0(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rdx,1),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rsi,%rdx,1)
movupd (%rdi,%rdx,1),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rdx,1)
add    $0x4,%rbx
add    %rcx,%rdx
add    $0xfffffffffffffffe,%rax
jne    1490 <gauss_make_triangular+0x380>
jmp    15b1 <gauss_make_triangular+0x4a1>
xchg   %ax,%ax
mov    %r14,%rax
imul   %r15,%rax
add    0x8(%rsp),%rax
mov    %rax,0x80(%rsp)
lea    0x1(%r15),%rax
imul   0x60(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    %r12,%rbx
jmp    151a <gauss_make_triangular+0x40a>
nopl   (%rax)
mov    0x48(%rsp),%r14
mov    0x30(%rsp),%rsi
mov    %r13d,%r10d
add    $0x2,%r15
add    0xc8(%rsp),%rbx
mov    %r10d,%r13d
mov    0x10(%rsp),%rdx
cmp    %edx,%r15d
je     1374 <gauss_make_triangular+0x264>
mov    0x80(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
mov    %rdx,%r14
call   1030 <fabs@plt>
mov    %r12,%rcx
mov    %rax,0x40(%rsp)
mov    %r13d,%eax
imul   %r14d,%eax
cltq
mov    0x8(%rsp),%r12
add    %r12,%rax
movsd  (%rcx,%rax,8),%xmm0
call   1030 <fabs@plt>
mov    %r15d,%ebp
cmp    %rax,0x40(%rsp)
jg     155f <gauss_make_triangular+0x44f>
mov    %r13d,%ebp
mov    0x78(%rsp),%rax
movsd  (%rbx,%rax,1),%xmm0
call   1030 <fabs@plt>
mov    %rax,%r14
mov    %ebp,%r13d
mov    %ebp,%eax
imul   0x10(%rsp),%eax
cltq
add    %r12,%rax
mov    0x120(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%r14
jle    14f0 <gauss_make_triangular+0x3e0>
lea    0x1(%r15),%r10d
mov    0x48(%rsp),%r14
mov    0x30(%rsp),%rsi
jmp    14fd <gauss_make_triangular+0x3ed>
xor    %ebx,%ebx
and    %r11,%r15
test   $0x1,%r10b
je     15d8 <gauss_make_triangular+0x4c8>
add    0x18(%rsp),%rbx
imul   %r14,%rbx
add    0x8(%rsp),%rbx
movupd (%r12,%rbx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rbx,8)
cmp    %r15,%r11
mov    0x18(%rsp),%rbx
mov    0x40(%rsp),%r10d
je     1684 <gauss_make_triangular+0x574>
add    %rbx,%r15
mov    0x10(%rsp),%rdx
mov    %edx,%eax
sub    %r15d,%eax
test   $0x1,%al
jne    1601 <gauss_make_triangular+0x4f1>
mov    %r15,%rdi
jmp    1624 <gauss_make_triangular+0x514>
mov    %r15,%rax
imul   %r14,%rax
add    0x8(%rsp),%rax
movsd  (%r12,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
mov    %r15,%rdi
add    $0x1,%rdi
not    %r15d
cmp    0x2c(%rsp),%r15d
je     1684 <gauss_make_triangular+0x574>
mov    0x10(%rsp),%rax
sub    %edi,%eax
mov    %r14,%rcx
imul   %rdi,%rcx
add    0x8(%rsp),%rcx
add    $0x1,%rdi
imul   0x60(%rsp),%rdi
add    0x68(%rsp),%rdi
mov    %r12,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
movsd  (%rdx,%rdi,1),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rdi,1)
add    %r13,%rdx
add    $0xfffffffe,%eax
jne    1660 <gauss_make_triangular+0x550>
and    $0xfffffffffffffffc,%rbp
mov    %r10d,%eax
cmp    %rax,0x8(%rsp)
mov    0x10(%rsp),%rdx
mov    0xb0(%rsp),%rdi
mov    0x20(%rsp),%r10
je     18d4 <gauss_make_triangular+0x7c4>
cmp    %r14,%r10
jge    18d4 <gauss_make_triangular+0x7c4>
mov    %ebx,%r13d
not    %r13d
add    %edx,%r13d
mov    %rbx,%rsi
cmp    $0x3,%r13d
mov    %rdx,%rcx
jb     1840 <gauss_make_triangular+0x730>
lea    (%rbx,%r8,1),%r15
lea    (%r12,%r15,8),%r10
mov    %ebx,%edx
not    %edx
add    %ecx,%edx
mov    0x38(%rsp),%rax
lea    (%rbx,%rax,1),%r11
lea    (%r11,%rdx,1),%rbx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
cmp    %rbx,%r10
mov    0x18(%rsp),%rbx
jae    1714 <gauss_make_triangular+0x604>
add    %rdx,%r15
mov    0x58(%rsp),%rdx
lea    (%rdx,%r15,8),%r10
lea    (%r12,%r11,8),%rdx
mov    %rbx,%rsi
cmp    %r10,%rdx
jb     1840 <gauss_make_triangular+0x730>
movabs $0x1fffffffc,%rcx
and    %rcx,%r9
add    $0xfffffffffffffffc,%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
add    $0x1,%r13
test   %r9,%r9
mov    0xa0(%rsp),%rax
je     17c0 <gauss_make_triangular+0x6b0>
lea    -0x4(%rbp),%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x88(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
xor    %edx,%edx
nop
movups -0x30(%rcx,%rdx,8),%xmm0
movups -0x20(%rcx,%rdx,8),%xmm1
movups -0x30(%rax,%rdx,8),%xmm2
movups -0x20(%rax,%rdx,8),%xmm3
movups %xmm2,-0x30(%rcx,%rdx,8)
movups %xmm3,-0x20(%rcx,%rdx,8)
movups %xmm0,-0x30(%rax,%rdx,8)
movups %xmm1,-0x20(%rax,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd -0x10(%rax,%rdx,8),%xmm2
movupd (%rax,%rdx,8),%xmm3
movupd %xmm2,-0x10(%rcx,%rdx,8)
movupd %xmm3,(%rcx,%rdx,8)
movupd %xmm0,-0x10(%rax,%rdx,8)
movupd %xmm1,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1760 <gauss_make_triangular+0x650>
jmp    17c2 <gauss_make_triangular+0x6b2>
xor    %edx,%edx
mov    %r13,%rsi
movabs $0x1fffffffc,%rcx
and    %rcx,%rsi
test   $0x1,%r10b
mov    0x20(%rsp),%r10
je     181d <gauss_make_triangular+0x70d>
add    %rbx,%rdx
lea    (%rdx,%r8,1),%rcx
movupd (%r12,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm1
add    0x38(%rsp),%rdx
movupd (%r12,%rdx,8),%xmm2
movupd 0x10(%r12,%rdx,8),%xmm3
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
movupd %xmm0,(%r12,%rdx,8)
movupd %xmm1,0x10(%r12,%rdx,8)
cmp    %rsi,%r13
mov    0x10(%rsp),%rdx
je     18d4 <gauss_make_triangular+0x7c4>
add    %rbx,%rsi
mov    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
sub    %esi,%eax
test   $0x1,%al
mov    %rcx,%rdx
jne    1850 <gauss_make_triangular+0x740>
mov    %rsi,%rax
jmp    187b <gauss_make_triangular+0x76b>
lea    (%rsi,%r8,1),%rax
movsd  (%r12,%rax,8),%xmm0
mov    0x38(%rsp),%rcx
add    %rsi,%rcx
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  %xmm0,(%r12,%rcx,8)
mov    %rsi,%rax
add    $0x1,%rax
mov    0x20(%rsp),%r10
not    %esi
cmp    0x2c(%rsp),%esi
mov    0x70(%rsp),%rsi
je     18d4 <gauss_make_triangular+0x7c4>
mov    0x58(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  -0x8(%rdi,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rax,8)
movsd  %xmm0,-0x8(%rdi,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
movsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  %xmm0,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %eax,%esi
jne    18a0 <gauss_make_triangular+0x790>
cmp    %r14,%r10
mov    0x30(%rsp),%rsi
jge    1220 <gauss_make_triangular+0x110>
cmp    $0x1,%edx
sete   %al
lea    (%rbx,%rbx,1),%rcx
mov    %rcx,0x40(%rsp)
mov    %ebx,%edx
not    %edx
add    0x10(%rsp),%edx
lea    (%rdx,%rbx,2),%rcx
add    $0x1,%rcx
mov    %rcx,0x80(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rbx,%rcx,1),%rsi
mov    0x20(%rsp),%rcx
lea    (%rbx,%rcx,1),%rcx
mov    %rcx,0x118(%rsp)
lea    (%r12,%rsi,8),%rcx
mov    %rcx,0x110(%rsp)
mov    %rsi,0x78(%rsp)
lea    (%rsi,%rdx,1),%rcx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x108(%rsp)
mov    0x30(%rsp),%rsi
lea    0x1(%rdx),%rcx
cmp    $0x3,%edx
mov    0x10(%rsp),%rdx
setae  %r14b
and    %al,%r14b
mov    %rcx,0x100(%rsp)
movabs $0x1fffffffc,%rax
and    %rax,%rcx
mov    %rcx,0xf8(%rsp)
lea    (%rbx,%rcx,1),%rax
mov    %rax,0xf0(%rsp)
mov    0x90(%rsp),%r15
mov    0x98(%rsp),%r9
xor    %r11d,%r11d
mov    %rbx,%rdi
jmp    19d0 <gauss_make_triangular+0x8c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
add    $0x1,%r11
mov    0x60(%rsp),%rax
add    %rax,%r9
add    %rax,%r15
cmp    %edx,%edi
mov    0x18(%rsp),%rbx
je     1220 <gauss_make_triangular+0x110>
mov    %rdi,%r8
imul   0x48(%rsp),%r8
mov    0x8(%rsp),%rax
lea    (%r8,%rax,1),%r10
mov    %rbx,%rax
test   %r14b,%r14b
je     1af0 <gauss_make_triangular+0x9e0>
mov    0x40(%rsp),%rax
add    %r11,%rax
lea    (%r12,%rax,8),%rax
mov    0x80(%rsp),%rcx
lea    (%rcx,%r11,1),%rbx
lea    (%r12,%rbx,8),%rcx
mov    0x118(%rsp),%rdx
lea    (%rdx,%r11,1),%rbx
lea    (%r12,%rbx,8),%rbx
mov    0x78(%rsp),%rdx
lea    (%rdx,%r11,1),%rsi
lea    (%r12,%rsi,8),%rsi
cmp    %rbx,%rax
setb   %dl
cmp    %rcx,%rsi
setb   %sil
cmp    0x108(%rsp),%rax
setb   %bl
cmp    %rcx,0x110(%rsp)
setb   %r13b
mov    0x18(%rsp),%rax
test   %sil,%dl
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rdx
jne    1af0 <gauss_make_triangular+0x9e0>
mov    0x18(%rsp),%rax
and    %r13b,%bl
jne    1af0 <gauss_make_triangular+0x9e0>
movsd  (%r12,%r10,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
mov    0xc0(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rcx,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
movupd -0x10(%r9,%rax,8),%xmm3
movupd (%r9,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r9,%rax,8)
movupd %xmm2,(%r9,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1a90 <gauss_make_triangular+0x980>
mov    0xf0(%rsp),%rax
mov    0xf8(%rsp),%rcx
cmp    %rcx,0x100(%rsp)
je     19b0 <gauss_make_triangular+0x8a0>
nopl   0x0(%rax)
mov    %edx,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    1b00 <gauss_make_triangular+0x9f0>
mov    %rax,%rbx
jmp    1b2a <gauss_make_triangular+0xa1a>
xchg   %ax,%ax
movsd  (%r12,%r10,8),%xmm0
mov    0x38(%rsp),%rcx
add    %rax,%rcx
add    %rax,%r8
mulsd  (%r12,%rcx,8),%xmm0
addsd  (%r12,%r8,8),%xmm0
movsd  %xmm0,(%r12,%r8,8)
mov    %rax,%rbx
add    $0x1,%rbx
mov    0x70(%rsp),%rcx
not    %eax
cmp    0x2c(%rsp),%eax
je     19b0 <gauss_make_triangular+0x8a0>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%r10,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
addsd  -0x8(%r15,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rbx,8)
movsd  (%r12,%r10,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x2,%rbx
cmp    %ebx,%ecx
jne    1b40 <gauss_make_triangular+0xa30>
jmp    19b0 <gauss_make_triangular+0x8a0>
xor    %eax,%eax
jmp    1b87 <gauss_make_triangular+0xa77>
mov    $0x1,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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