#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);
int /*<<< orphan*/ printf(char *, ...);
int Inverse(float a[][10], float ainv[][5], int n, int druck) {
  int i, j;
  int s;
  int pzeile;
  int fehler = 0;
  float f, h;
  const float Epsilon = 0.01f;
  float Maximum;
  int pivot = 1;
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      a[i][n + j] = 0.0;
      if (i == j)
        a[i][n + j] = 1.0;
    }
  }
  s = 0;
  do {
    Maximum = fabs(a[s][s]);
    if (pivot) {
      pzeile = s;
      for (i = s + 1; i < n; i++)
        if (fabs(a[i][s]) > Maximum) {
          Maximum = fabs(a[i][s]);
          pzeile = i;
        }
    }
    fehler = (Maximum < Epsilon);
    if (fehler)
      break;
    if (pivot) {
      if (pzeile != s) {
        for (j = s; j < 2 * n; j++) {
          h = a[s][j];
          a[s][j] = a[pzeile][j];
          a[pzeile][j] = h;
        }
      }
    }
    f = a[s][s];
    for (j = s; j < 2 * n; j++)
      a[s][j] = a[s][j] / f;
    for (i = 0; i < n; i++) {
      if (i != s) {
        f = -a[i][s];
        for (j = s; j < 2 * n; j++)
          a[i][j] += f * a[s][j];
      }
    }
    if (druck) {
      printf("\n\nNach %1i-tem Eliminationschritt:\n", s + 1);
      for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
          printf("%7.2f   ", a[i][j]);
      }
    }
    s++;
  } while (s < n);
  if (fehler) {
    return 1;
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      ainv[i][j] = a[i][n + j];
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<Inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
movss  0xebb(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ee <Inverse+0xce>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11db <Inverse+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11c8 <Inverse+0xa8>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  0xe41(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    11cd <Inverse+0xad>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116b <Inverse+0x4b>
jmp    11e0 <Inverse+0xc0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1158 <Inverse+0x38>
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x44(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     12a3 <Inverse+0x183>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    129e <Inverse+0x17e>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
ucomiss -0x44(%rbp),%xmm0
jbe    128b <Inverse+0x16b>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x44(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1290 <Inverse+0x170>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1230 <Inverse+0x110>
jmp    12a3 <Inverse+0x183>
movss  0xd55(%rip),%xmm0
ucomiss -0x44(%rbp),%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     12c9 <Inverse+0x1a9>
jmp    156e <Inverse+0x44e>
cmpl   $0x0,-0x48(%rbp)
je     1378 <Inverse+0x258>
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1373 <Inverse+0x253>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    136e <Inverse+0x24e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12e5 <Inverse+0x1c5>
jmp    1373 <Inverse+0x253>
jmp    1378 <Inverse+0x258>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    13ef <Inverse+0x2cf>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    139b <Inverse+0x27b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14b7 <Inverse+0x397>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     14a4 <Inverse+0x384>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    149f <Inverse+0x37f>
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    143e <Inverse+0x31e>
jmp    14a4 <Inverse+0x384>
jmp    14a9 <Inverse+0x389>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f6 <Inverse+0x2d6>
cmpl   $0x0,-0x20(%rbp)
je     1559 <Inverse+0x439>
mov    -0x2c(%rbp),%esi
add    $0x1,%esi
lea    0xb3a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1554 <Inverse+0x434>
lea    0xb3b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1541 <Inverse+0x421>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb00(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14fd <Inverse+0x3dd>
jmp    1546 <Inverse+0x426>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14dc <Inverse+0x3bc>
jmp    1559 <Inverse+0x439>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     11f5 <Inverse+0xd5>
cmpl   $0x0,-0x34(%rbp)
je     1584 <Inverse+0x464>
movl   $0x1,-0x4(%rbp)
jmp    1607 <Inverse+0x4e7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1600 <Inverse+0x4e0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15ed <Inverse+0x4cd>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    159e <Inverse+0x47e>
jmp    15f2 <Inverse+0x4d2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    158b <Inverse+0x46b>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Inverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %ecx,0x4c(%rsp)
mov    %rsi,0x60(%rsp)
mov    %edx,%r14d
test   %edx,%edx
jle    11e7 <Inverse+0xc7>
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rdi,%r8
lea    (%rdi,%r14,4),%rcx
add    $0x4,%rcx
xor    %ebp,%ebp
movss  0xea0(%rip),%xmm0
jmp    1191 <Inverse+0x71>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rbp,4),%rsi
add    %rbp,%rsi
lea    (%r8,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rbx,4)
add    $0x1,%rbp
add    $0x28,%rcx
cmp    %r14,%rbp
je     11e0 <Inverse+0xc0>
xor    %esi,%esi
cmp    $0x1,%edx
jne    11be <Inverse+0x9e>
test   $0x1,%r14b
je     1184 <Inverse+0x64>
lea    (%rsi,%r14,1),%rbx
movaps %xmm0,%xmm1
cmp    %rsi,%rbp
je     1170 <Inverse+0x50>
xorps  %xmm1,%xmm1
jmp    1170 <Inverse+0x50>
nop
movss  %xmm1,(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rax,%rsi
je     1198 <Inverse+0x78>
movaps %xmm0,%xmm1
cmp    %rsi,%rbp
je     11c9 <Inverse+0xa9>
xorps  %xmm1,%xmm1
movss  %xmm1,-0x4(%rcx,%rsi,4)
lea    0x1(%rsi),%rbx
movaps %xmm0,%xmm1
cmp    %rbx,%rbp
je     11b0 <Inverse+0x90>
xorps  %xmm1,%xmm1
jmp    11b0 <Inverse+0x90>
mov    %r14,0x20(%rsp)
jmp    11f2 <Inverse+0xd2>
mov    %rdi,%r8
movslq %edx,%rax
mov    %rax,0x20(%rsp)
lea    (%rdx,%rdx,1),%r13d
movslq %r13d,%rax
mov    %rax,0x40(%rsp)
cmp    $0x2,%edx
mov    $0x1,%eax
cmovge %edx,%eax
mov    %rax,0xc8(%rsp)
mov    %r8,%rbx
lea    (%r8,%r13,4),%rax
mov    %rax,0xc0(%rsp)
lea    -0x1(%r13),%rax
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0xf0(%rsp)
lea    0x28(%r8),%r12
lea    -0x9(%r13),%rcx
mov    %rcx,0x88(%rsp)
lea    0x34(%r8),%rcx
lea    0x4(%r8),%rsi
mov    %rsi,0xb8(%rsp)
add    $0x14,%r8
lea    -0x5(%r13),%rsi
mov    %rsi,0x90(%rsp)
mov    $0x1,%esi
movaps 0xda2(%rip),%xmm3
lea    0xddf(%rip),%rbp
movaps 0xda4(%rip),%xmm6
mov    %rax,0x78(%rsp)
mov    %rax,0x98(%rsp)
mov    %r8,%rax
mov    %rbx,%r15
mov    %rcx,0x80(%rsp)
xor    %edi,%edi
mov    %rdx,0x50(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r13,0x70(%rsp)
jmp    133e <Inverse+0x21e>
nopl   (%rax)
mov    0xe8(%rsp),%rsi
add    $0x1,%rsi
mov    0xe0(%rsp),%r12
add    $0x2c,%r12
addq   $0xffffffffffffffff,0x88(%rsp)
addq   $0x4,0x80(%rsp)
mov    0xa0(%rsp),%rcx
add    $0x2c,%rcx
add    $0x28,%r15
mov    0x68(%rsp),%rax
add    $0x2c,%rax
addq   $0xffffffffffffffff,0x90(%rsp)
addq   $0xffffffffffffffff,0x98(%rsp)
mov    0x38(%rsp),%r8
add    $0x4,%r8
mov    0x30(%rsp),%rdi
cmp    0xc8(%rsp),%rdi
mov    0x50(%rsp),%rdx
mov    0x10(%rsp),%rbx
mov    0x70(%rsp),%r13
movaps 0xcdf(%rip),%xmm3
movaps 0xce8(%rip),%xmm6
je     19ed <Inverse+0x8cd>
mov    %rax,0x68(%rsp)
mov    %rcx,0xa0(%rsp)
lea    (%rdi,%rdi,4),%rcx
lea    (%rbx,%rcx,8),%r11
lea    0x1(%rdi),%rcx
movss  (%r11,%rdi,4),%xmm0
movaps %xmm0,%xmm1
andps  %xmm3,%xmm1
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
cmp    0x20(%rsp),%rcx
mov    %rsi,0xe8(%rsp)
jge    13b0 <Inverse+0x290>
mov    %r12,%rbx
mov    %edi,%ecx
nop
movss  (%rbx),%xmm2
andps  %xmm3,%xmm2
ucomiss %xmm1,%xmm2
cmova  %esi,%ecx
maxss  %xmm1,%xmm2
add    $0x1,%rsi
add    $0x28,%rbx
movaps %xmm2,%xmm1
cmp    %rsi,%r14
jne    1380 <Inverse+0x260>
jmp    13b5 <Inverse+0x295>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edi,%ecx
movaps %xmm1,%xmm2
movss  0xc47(%rip),%xmm1
ucomiss %xmm2,%xmm1
ja     19e3 <Inverse+0x8c3>
mov    %rdi,%rbx
not    %rbx
imul   $0x2c,%rdi,%rsi
lea    (%rbx,%r13,1),%r10
mov    0x10(%rsp),%rax
add    %rax,%rsi
add    $0x4,%rsi
mov    %rsi,0xb0(%rsp)
lea    (%r11,%r13,4),%rsi
mov    %rsi,0xa8(%rsp)
lea    (%r11,%rdi,4),%rsi
mov    %rsi,0x18(%rsp)
mov    %ecx,%esi
cmp    %rsi,%rdi
mov    %r8,0x38(%rsp)
mov    %r11,0x58(%rsp)
je     1655 <Inverse+0x535>
cmp    0x40(%rsp),%rdi
jge    1655 <Inverse+0x535>
mov    %r10,%r9
movslq %ecx,%rcx
lea    (%rcx,%rcx,4),%rsi
mov    0x10(%rsp),%rax
lea    (%rax,%rsi,8),%r10
movss  (%r10,%rdi,4),%xmm1
movss  %xmm1,(%r11,%rdi,4)
movss  %xmm0,(%r10,%rdi,4)
lea    0x1(%rdi),%r11
cmp    %r13,%r11
mov    0x18(%rsp),%rax
je     1649 <Inverse+0x529>
cmp    $0x8,%r9
jb     15d0 <Inverse+0x4b0>
mov    %rsi,0x8(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rdi,4),%rsi
add    $0x4,%rsi
shl    $0x3,%rcx
lea    (%rcx,%rcx,4),%rcx
add    %rcx,%rsi
add    0xc0(%rsp),%rcx
mov    0xb0(%rsp),%rax
cmp    %rcx,%rax
setb   %r8b
mov    0xa8(%rsp),%rcx
cmp    %rcx,%rsi
mov    %rcx,%rsi
setb   %cl
and    %r8b,%cl
jne    14db <Inverse+0x3bb>
cmp    %rsi,%rax
jb     14db <Inverse+0x3bb>
test   %cl,%cl
jne    14db <Inverse+0x3bb>
lea    (%rbx,%r13,1),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,0x28(%rsp)
cmp    $0x8,%rcx
mov    0x18(%rsp),%rax
jae    14ef <Inverse+0x3cf>
xor    %ebx,%ebx
jmp    157e <Inverse+0x45e>
mov    0x38(%rsp),%r8
mov    0x18(%rsp),%rax
mov    0x8(%rsp),%rsi
jmp    15d0 <Inverse+0x4b0>
mov    0x88(%rsp),%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x80(%rsp),%rsi
mov    0x8(%rsp),%rbx
lea    (%rsi,%rbx,8),%rsi
xor    %ebx,%ebx
mov    0xa0(%rsp),%r8
xchg   %ax,%ax
movups -0x30(%r8,%rbx,4),%xmm0
movups -0x20(%r8,%rbx,4),%xmm1
movups -0x30(%rsi,%rbx,4),%xmm2
movups -0x20(%rsi,%rbx,4),%xmm3
movups %xmm2,-0x30(%r8,%rbx,4)
movups %xmm3,-0x20(%r8,%rbx,4)
movups %xmm0,-0x30(%rsi,%rbx,4)
movups %xmm1,-0x20(%rsi,%rbx,4)
movups -0x10(%r8,%rbx,4),%xmm0
movups (%r8,%rbx,4),%xmm1
movups -0x10(%rsi,%rbx,4),%xmm2
movups (%rsi,%rbx,4),%xmm3
movups %xmm2,-0x10(%r8,%rbx,4)
movups %xmm3,(%r8,%rbx,4)
movups %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm1,(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1520 <Inverse+0x400>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
testb  $0x1,0x28(%rsp)
je     15bc <Inverse+0x49c>
add    %r11,%rbx
mov    0x58(%rsp),%rsi
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups (%r10,%rbx,4),%xmm2
movups 0x10(%r10,%rbx,4),%xmm3
movups %xmm2,(%rsi,%rbx,4)
movups %xmm3,0x10(%rsi,%rbx,4)
movups %xmm0,(%r10,%rbx,4)
movups %xmm1,0x10(%r10,%rbx,4)
cmp    %rcx,%r9
mov    0x38(%rsp),%r8
mov    0x8(%rsp),%rsi
je     1649 <Inverse+0x529>
add    %rcx,%r11
xchg   %ax,%ax
mov    %r11,%rcx
test   $0x1,%r11b
je     15fa <Inverse+0x4da>
mov    0x58(%rsp),%rcx
movss  (%rcx,%r11,4),%xmm0
movss  (%r10,%r11,4),%xmm1
movss  %xmm1,(%rcx,%r11,4)
movss  %xmm0,(%r10,%r11,4)
lea    0x1(%r11),%rcx
cmp    %r11,0x78(%rsp)
je     1649 <Inverse+0x529>
mov    %rsi,%rbx
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rbx,8),%rsi
movss  (%r15,%rcx,4),%xmm0
movss  -0x4(%rsi,%rcx,4),%xmm1
movss  %xmm1,(%r15,%rcx,4)
movss  %xmm0,-0x4(%rsi,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm0
movss  (%rsi,%rcx,4),%xmm1
movss  %xmm1,0x4(%r15,%rcx,4)
movss  %xmm0,(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1610 <Inverse+0x4f0>
movss  (%rax),%xmm0
mov    0x58(%rsp),%r11
mov    %r9,%r10
mov    %r12,0xe0(%rsp)
cmp    0x40(%rsp),%rdi
jge    1750 <Inverse+0x630>
movaps %xmm0,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rdi,4)
lea    0x1(%rdi),%rcx
cmp    %r13,%rcx
je     1750 <Inverse+0x630>
cmp    $0x4,%r10
jb     1730 <Inverse+0x610>
mov    %r8,%r9
mov    0x78(%rsp),%rsi
sub    %rdi,%rsi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %r10,%r12
cmp    $0x4,%rsi
jae    16ba <Inverse+0x59a>
xor    %ebx,%ebx
jmp    1702 <Inverse+0x5e2>
mov    0x90(%rsp),%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebx,%ebx
mov    0x68(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rbx,4),%xmm2
movups (%rax,%rbx,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%rax,%rbx,4)
divps  %xmm1,%xmm3
movups %xmm3,(%rax,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    16e0 <Inverse+0x5c0>
mov    %r12,%rsi
and    $0xfffffffffffffffc,%rsi
test   $0x1,%r8b
je     171f <Inverse+0x5ff>
add    %rcx,%rbx
movups (%r11,%rbx,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r11,%rbx,4)
cmp    %rsi,%r12
mov    %r9,%r8
mov    %r12,%r10
je     1750 <Inverse+0x630>
add    %rsi,%rcx
nopl   (%rax)
movss  (%r15,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1730 <Inverse+0x610>
nopl   0x0(%rax)
test   %edx,%edx
jle    19c0 <Inverse+0x8a0>
mov    0x98(%rsp),%r12
and    $0xfffffffffffffff8,%r12
lea    0x1(%rdi),%rax
mov    %rax,0x8(%rsp)
mov    %r10,0x28(%rsp)
and    $0xfffffffffffffff8,%r10
mov    %r10,0xd8(%rsp)
lea    (%rdi,%r10,1),%rax
add    $0x1,%rax
mov    %rax,0xd0(%rsp)
mov    0x10(%rsp),%r9
xor    %r10d,%r10d
mov    0x18(%rsp),%rax
jmp    17b5 <Inverse+0x695>
nopl   (%rax)
add    $0x1,%r10
add    $0x28,%r8
add    $0x28,%r9
cmp    %r14,%r10
je     1940 <Inverse+0x820>
cmp    %rdi,%r10
je     17a0 <Inverse+0x680>
cmp    0x40(%rsp),%rdi
jge    17a0 <Inverse+0x680>
lea    (%r10,%r10,4),%rcx
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,8),%r11
movss  (%r11,%rdi,4),%xmm1
movaps %xmm1,%xmm0
xorps  %xmm6,%xmm0
movss  (%rax),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%r11,%rdi,4)
cmp    %r13,0x8(%rsp)
je     17a0 <Inverse+0x680>
mov    0x8(%rsp),%rdx
cmpq   $0x8,0x28(%rsp)
jae    187d <Inverse+0x75d>
mov    %rdx,%rsi
test   $0x1,%dl
je     1826 <Inverse+0x706>
mov    0x58(%rsp),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r11,%rdx,4),%xmm1
movss  %xmm1,(%r11,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0xf0(%rsp),%rdx
je     17a0 <Inverse+0x680>
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r9,%rsi,4),%xmm1
movss  %xmm1,(%r9,%rsi,4)
movss  0x4(%r15,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%r9,%rsi,4),%xmm1
movss  %xmm1,0x4(%r9,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r13
jne    1840 <Inverse+0x720>
jmp    17a0 <Inverse+0x680>
mov    0x30(%rsp),%rax
lea    (%r11,%rax,4),%rsi
mov    0x18(%rsp),%rax
mov    0x70(%rsp),%rcx
lea    (%r11,%rcx,4),%r13
cmp    0xa8(%rsp),%rsi
setb   %bl
cmp    %r13,0xb0(%rsp)
setb   %cl
mov    0x8(%rsp),%rdx
cmp    %r13,%rsi
mov    0x70(%rsp),%r13
jb     1800 <Inverse+0x6e0>
mov    0x8(%rsp),%rdx
and    %cl,%bl
jne    1800 <Inverse+0x6e0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %edx,%edx
mov    0x68(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movups -0x10(%r8,%rdx,4),%xmm2
movups (%r8,%rdx,4),%xmm3
movups -0x10(%rcx,%rdx,4),%xmm4
movups (%rcx,%rdx,4),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,-0x10(%r8,%rdx,4)
movups %xmm5,(%r8,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r12
jne    18e0 <Inverse+0x7c0>
mov    0xd0(%rsp),%rdx
mov    0xd8(%rsp),%rcx
cmp    %rcx,0x28(%rsp)
je     17a0 <Inverse+0x680>
jmp    1800 <Inverse+0x6e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x4c(%rsp)
je     12b0 <Inverse+0x190>
lea    0x6de(%rip),%rdi
mov    0x30(%rsp),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0x50(%rsp)
jle    12b0 <Inverse+0x190>
mov    0x10(%rsp),%r12
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1990 <Inverse+0x870>
add    $0x1,%r13
add    $0x28,%r12
cmp    %r14,%r13
jne    1980 <Inverse+0x860>
jmp    12b0 <Inverse+0x190>
nop
cmpl   $0x0,0x4c(%rsp)
je     12b0 <Inverse+0x190>
lea    0x65e(%rip),%rdi
mov    0x30(%rsp),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    12b0 <Inverse+0x190>
mov    $0x1,%eax
jmp    1c0a <Inverse+0xaea>
test   %edx,%edx
jle    1c08 <Inverse+0xae8>
mov    %rbx,%rdi
mov    0x20(%rsp),%rcx
lea    (%rcx,%r14,1),%rax
mov    %rax,0x40(%rsp)
mov    %r14d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%rax
mov    %rax,0x8(%rsp)
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x30(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x28(%rsp)
mov    %r14,%r12
neg    %r12
mov    %rbx,%rsi
lea    (%rdi,%rcx,4),%rbx
add    $0x30,%rbx
mov    0x60(%rsp),%rax
lea    0x30(%rax),%r11
lea    (%rdi,%rcx,4),%r10
add    $0x4,%r10
lea    0x4(%rax),%rsi
xor    %eax,%eax
jmp    1a7d <Inverse+0x95d>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x28,%rbx
add    $0x14,%r11
add    $0x28,%r10
add    $0x14,%rsi
cmp    %r14,%rax
je     1c08 <Inverse+0xae8>
cmp    $0x8,%edx
jae    1a90 <Inverse+0x970>
xor    %ebp,%ebp
jmp    1b80 <Inverse+0xa60>
nopl   0x0(%rax)
lea    (%rax,%rax,4),%rcx
lea    (%rdi,%rcx,8),%r13
mov    0x40(%rsp),%rdx
lea    0x0(,%rdx,4),%rbp
add    %r13,%rbp
mov    0x60(%rsp),%rdx
lea    (%rdx,%rcx,4),%r9
cmp    %rbp,%r9
jae    1ae0 <Inverse+0x9c0>
mov    0x20(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
lea    (%r9,%r14,4),%rbp
cmp    %rbp,%rcx
jae    1ae0 <Inverse+0x9c0>
xor    %ebp,%ebp
mov    0x50(%rsp),%rdx
mov    0x10(%rsp),%rdi
jmp    1b80 <Inverse+0xa60>
cmpq   $0x0,0x8(%rsp)
je     1bf6 <Inverse+0xad6>
mov    0x28(%rsp),%r8
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rbx,%rcx,4),%xmm0
movups -0x20(%rbx,%rcx,4),%xmm1
movups %xmm0,-0x30(%r11,%rcx,4)
movups %xmm1,-0x20(%r11,%rcx,4)
movups -0x10(%rbx,%rcx,4),%xmm0
movups (%rbx,%rcx,4),%xmm1
movups %xmm0,-0x10(%r11,%rcx,4)
movups %xmm1,(%r11,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%r8
jne    1b00 <Inverse+0x9e0>
testb  $0x1,0x30(%rsp)
je     1b5b <Inverse+0xa3b>
mov    0x20(%rsp),%rdx
lea    (%rcx,%rdx,1),%rbp
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
movups %xmm0,(%r9,%rcx,4)
movups %xmm1,0x10(%r9,%rcx,4)
mov    %r15,%rbp
cmp    %r14,%r15
mov    0x50(%rsp),%rdx
mov    0x10(%rsp),%rdi
je     1a60 <Inverse+0x940>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rcx
test   $0x1,%r14b
je     1bb5 <Inverse+0xa95>
mov    0x20(%rsp),%rcx
lea    (%rcx,%rbp,1),%r8
lea    (%rax,%rax,4),%r9
lea    (%rdi,%r9,8),%rcx
movss  (%rcx,%r8,4),%xmm0
mov    0x60(%rsp),%rcx
lea    (%rcx,%r9,4),%rcx
movss  %xmm0,(%rcx,%rbp,4)
mov    %rbp,%rcx
or     $0x1,%rcx
not    %rbp
cmp    %r12,%rbp
je     1a60 <Inverse+0x940>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r10,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rcx,4)
movss  (%r10,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    1bd0 <Inverse+0xab0>
jmp    1a60 <Inverse+0x940>
xor    %ecx,%ecx
testb  $0x1,0x30(%rsp)
jne    1b3b <Inverse+0xa1b>
jmp    1b5b <Inverse+0xa3b>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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