#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 */
float fabs(float);
float sqrt(float);
void gauss(float *aug[], float *x, int n, int *ier, float *rnorm) {
  int i, j, k, nm1, np1, ipivot, ip1;
  float pivot, temp, rsq, resi, q;
  nm1 = n - 1;
  np1 = n + 1;
  for (i = 1; i <= nm1; i++) {
    pivot = 0.0;
    for (j = i; j <= n; j++) {
      temp = fabs(aug[i][j]);
      if (pivot >= temp)
        continue;
      pivot = temp;
      ipivot = j;
    }
    if (pivot == 0.0) {
      *ier = 2;
      return;
    }
    if (ipivot != i) {
      for (k = i; k <= np1; k++) {
        temp = aug[k][i];
        aug[k][i] = aug[k][ipivot];
        aug[k][ipivot] = temp;
      }
    }
    ip1 = i + 1;
    for (k = ip1; k <= n; k++) {
      q = -aug[i][k] / aug[i][i];
      aug[i][k] = 0.0;
      for (j = ip1; j <= np1; j++)
        aug[j][k] += q * aug[j][i];
    }
  }
  if (aug[n][n] == 0.0) {
    *ier = 2;
    return;
  }
  x[n] = aug[np1][n] / aug[n][n];
  for (k = 1; k <= nm1; k++) {
    q = 0.0;
    for (j = 1; j <= k; j++)
      q += aug[np1 - j][n - k] * x[np1 - j];
    x[n - k] = (aug[np1][n - k] - q) / aug[n - k][n - k];
  }
  rsq = 0.0;
  for (i = 1; i <= n; i++) {
    q = 0.0;
    for (j = 1; j <= n; j++)
      q = aug[j][i] * x[j];
    resi = fabs(aug[np1][i] - q);
    rsq += resi * resi;
  }
  *rnorm = sqrt(rsq);
  *ier = 1;
}


x86 assembly (clang, -O0):
<gauss>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1376 <gauss+0x256>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11cb <gauss+0xab>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jb     11ad <gauss+0x8d>
jmp    11bd <gauss+0x9d>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116e <gauss+0x4e>
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f6 <gauss+0xd6>
jp     11f6 <gauss+0xd6>
mov    -0x20(%rbp),%rax
movl   $0x2,(%rax)
jmp    159a <gauss+0x47a>
mov    -0x40(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1285 <gauss+0x165>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1280 <gauss+0x160>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1208 <gauss+0xe8>
jmp    1285 <gauss+0x165>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1363 <gauss+0x243>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1350 <gauss+0x230>
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12fa <gauss+0x1da>
jmp    1355 <gauss+0x235>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1294 <gauss+0x174>
jmp    1368 <gauss+0x248>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1154 <gauss+0x34>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13b1 <gauss+0x291>
jp     13b1 <gauss+0x291>
mov    -0x20(%rbp),%rax
movl   $0x2,(%rax)
jmp    159a <gauss+0x47a>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     14c5 <gauss+0x3a5>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1467 <gauss+0x347>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    140a <gauss+0x2ea>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ef <gauss+0x2cf>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     157e <gauss+0x45e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1530 <gauss+0x410>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14ef <gauss+0x3cf>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d4 <gauss+0x3b4>
movss  -0x50(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gauss>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,0x10(%rsp)
mov    %rcx,0x20(%rsp)
lea    0x1(%rdx),%eax
mov    %eax,0x4(%rsp)
mov    %rdx,0x8(%rsp)
cmp    $0x2,%edx
jl     125f <gauss+0x14f>
mov    0x8(%rsp),%rax
lea    0x2(%rax),%r15d
mov    0x4(%rsp),%r10d
mov    $0x1,%r14d
mov    $0x2,%r9d
movaps 0xea2(%rip),%xmm0
xorps  %xmm1,%xmm1
movaps 0xea8(%rip),%xmm2
mov    %rdi,%r13
nopl   0x0(%rax,%rax,1)
mov    %r14,%rbx
mov    (%rdi,%r14,8),%r14
mov    %rbx,%rbp
xorps  %xmm3,%xmm3
nopl   (%rax)
movss  (%r14,%rbp,4),%xmm5
andps  %xmm0,%xmm5
ucomiss %xmm5,%xmm3
cmovb  %ebp,%r11d
movaps %xmm5,%xmm4
cmpnless %xmm3,%xmm4
andps  %xmm4,%xmm5
andnps %xmm3,%xmm4
orps   %xmm5,%xmm4
add    $0x1,%rbp
movaps %xmm4,%xmm3
cmp    %rbp,%r10
jne    1180 <gauss+0x70>
ucomiss %xmm1,%xmm4
jne    11b8 <gauss+0xa8>
jnp    13d6 <gauss+0x2c6>
mov    %r11d,%ecx
cmp    %rcx,%rbx
je     11f4 <gauss+0xe4>
movslq %r11d,%r14
mov    $0x1,%ebp
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,8),%rcx
movss  (%rcx,%rbx,4),%xmm3
movss  (%rcx,%r14,4),%xmm4
movss  %xmm4,(%rcx,%rbx,4)
movss  %xmm3,(%rcx,%r14,4)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    11d0 <gauss+0xc0>
lea    0x1(%rbx),%r14
mov    (%rdi,%rbx,8),%r12
mov    %r9,%rbp
nop
movss  (%r12,%rbp,4),%xmm3
xorps  %xmm2,%xmm3
divss  (%r12,%rbx,4),%xmm3
movl   $0x0,(%r12,%rbp,4)
mov    $0x2,%ecx
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,8),%rax
movss  (%rax,%rbx,4),%xmm4
mulss  %xmm3,%xmm4
addss  (%rax,%rbp,4),%xmm4
movss  %xmm4,(%rax,%rbp,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1220 <gauss+0x110>
add    $0x1,%rbp
cmp    %r10,%rbp
jne    1200 <gauss+0xf0>
add    $0x1,%r9
add    $0x8,%r13
add    $0xffffffffffffffff,%r15
cmp    %r10,%r9
jne    1170 <gauss+0x60>
mov    0x8(%rsp),%rcx
movslq %ecx,%r12
mov    (%rdi,%r12,8),%rax
movss  (%rax,%r12,4),%xmm0
mov    $0x2,%eax
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1284 <gauss+0x174>
jnp    1487 <gauss+0x377>
movslq 0x4(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    (%rdi,%rax,8),%r11
movss  (%r11,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%r12,4)
mov    %ecx,%r10d
cmp    $0x2,%ecx
jl     13a2 <gauss+0x292>
mov    0x18(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
lea    (%rsi,%rax,4),%rcx
mov    $0x1,%r15d
xor    %r13d,%r13d
jmp    12f5 <gauss+0x1e5>
cs nopw 0x0(%rax,%rax,1)
movss  (%r11,%rbp,4),%xmm1
subss  %xmm0,%xmm1
mov    (%rdi,%rbp,8),%rax
divss  (%rax,%rbp,4),%xmm1
movss  %xmm1,(%rsi,%rbp,4)
add    $0x1,%r15
cmp    %r10,%r15
je     13a2 <gauss+0x292>
mov    %r13,%rax
add    $0x1,%r13
mov    %r12,%rbp
sub    %r15,%rbp
test   %rax,%rax
je     1370 <gauss+0x260>
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
xorps  %xmm0,%xmm0
mov    $0xffffffffffffffff,%r14
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rbx,%r14,8),%r8
mov    (%rbx,%r14,8),%r9
movss  (%r9,%rbp,4),%xmm1
mulss  (%rcx,%r14,4),%xmm1
addss  %xmm0,%xmm1
movss  (%r8,%rbp,4),%xmm0
mulss  -0x4(%rcx,%r14,4),%xmm0
addss  %xmm1,%xmm0
lea    (%rax,%r14,1),%rdx
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffffffffffe,%r14
cmp    $0xffffffffffffffff,%rdx
jne    1320 <gauss+0x210>
neg    %r14
test   $0x1,%r13b
je     12d0 <gauss+0x1c0>
jmp    1383 <gauss+0x273>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    $0x1,%r14d
test   $0x1,%r13b
je     12d0 <gauss+0x1c0>
mov    0x18(%rsp),%rax
sub    %r14,%rax
mov    (%rdi,%rax,8),%rdx
movss  (%rdx,%rbp,4),%xmm1
mulss  (%rsi,%rax,4),%xmm1
addss  %xmm1,%xmm0
jmp    12d0 <gauss+0x1c0>
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
cmpl   $0x0,0x8(%rsp)
jle    1469 <gauss+0x359>
mov    0x4(%rsp),%edx
mov    %edx,%ecx
mov    (%rdi,%r10,8),%rax
movss  (%rsi,%r10,4),%xmm2
add    $0xffffffffffffffff,%rcx
cmp    $0x2,%edx
jne    13e0 <gauss+0x2d0>
xorps  %xmm0,%xmm0
mov    $0x1,%edx
jmp    144d <gauss+0x33d>
mov    $0x2,%eax
jmp    1487 <gauss+0x377>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xorps  %xmm3,%xmm3
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
mulss  %xmm2,%xmm0
movss  (%r11,%rdx,4),%xmm4
subss  %xmm0,%xmm4
movss  0x4(%r11,%rdx,4),%xmm0
mulss  %xmm4,%xmm4
addss  %xmm3,%xmm4
movss  0x4(%rax,%rdx,4),%xmm3
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm4,%xmm0
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
movaps %xmm0,%xmm3
cmp    $0x1,%rdi
jne    1400 <gauss+0x2f0>
test   $0x1,%cl
je     1469 <gauss+0x359>
mulss  (%rax,%rdx,4),%xmm2
movss  (%r11,%rdx,4),%xmm3
subss  %xmm2,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
ucomiss %xmm1,%xmm0
jb     1474 <gauss+0x364>
sqrtss %xmm0,%xmm0
jmp    1479 <gauss+0x369>
call   1030 <sqrt@plt>
mov    0x10(%rsp),%rax
movss  %xmm0,(%rax)
mov    $0x1,%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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