#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
void invers(int n, double a[10][10], double eps, double b[10][10],
            double *det_a, int *err) {
  int i, j, k, pozmax;
  double amax, aux;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      if (i == j)
        b[i][j] = 1.0;
      else
        b[i][j] = 0.0;
  *det_a = 1.0;
  k = 0;
  *err = 0;
  while ((k < n) && (*err == 0)) {
    amax = fabs(a[k][k]);
    pozmax = k;
    for (i = k + 1; i < n; i++)
      if (fabs(a[i][k]) > amax) {
        amax = fabs(a[i][k]);
        pozmax = i;
      };
    if (k != pozmax) {
      for (j = 0; j < n; j++) {
        aux = a[k][j];
        a[k][j] = a[pozmax][j];
        a[pozmax][j] = aux;
        aux = b[k][j];
        b[k][j] = b[pozmax][j];
        b[pozmax][j] = aux;
      };
      *det_a = -*det_a;
    };
    if (fabs(a[k][k]) < eps)
      *err = 1;
    else {
      *det_a = *det_a * a[k][k];
      aux = a[k][k];
      for (j = 0; j < n; j++) {
        a[k][j] = a[k][j] / aux;
        b[k][j] = b[k][j] / aux;
      };
      for (i = 0; i < n; i++)
        if (i != k) {
          aux = a[i][k];
          for (j = 0; j < n; j++) {
            a[i][j] = a[i][j] - a[k][j] * aux;
            b[i][j] = b[i][j] - b[k][j] * aux;
          }
        }
    }
    k++;
  }
}


x86 assembly (clang, -O0):
<invers>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11b4 <invers+0xb4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a1 <invers+0xa1>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    1173 <invers+0x73>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  0xe97(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    118e <invers+0x8e>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1193 <invers+0x93>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1136 <invers+0x36>
jmp    11a6 <invers+0xa6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1123 <invers+0x23>
mov    -0x28(%rbp),%rax
movsd  0xe40(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x51(%rbp)
jge    11f3 <invers+0xf3>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
sete   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    1203 <invers+0x103>
jmp    164e <invers+0x54e>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdee(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b5 <invers+0x1b5>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdab(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    12a2 <invers+0x1a2>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd7d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12a7 <invers+0x1a7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    123a <invers+0x13a>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     13dd <invers+0x2dd>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b6 <invers+0x2b6>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c8 <invers+0x1c8>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc14(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    141e <invers+0x31e>
mov    -0x30(%rbp),%rax
movl   $0x1,(%rax)
jmp    1640 <invers+0x540>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14ee <invers+0x3ee>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    146a <invers+0x36a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    163b <invers+0x53b>
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1628 <invers+0x528>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1623 <invers+0x523>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1531 <invers+0x431>
jmp    1628 <invers+0x528>
jmp    162d <invers+0x52d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14f5 <invers+0x3f5>
jmp    1640 <invers+0x540>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d5 <invers+0xd5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<invers>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %rcx,%r15
movabs $0x3ff0000000000000,%r14
test   %edi,%edi
jle    196d <invers+0x86d>
mov    %rsi,-0x70(%rsp)
mov    %r8,0x8(%rsp)
mov    %edi,-0x78(%rsp)
mov    %edi,%eax
mov    %rdx,%r10
lea    -0x1(%rax),%r9
mov    %eax,%esi
and    $0x3,%esi
mov    %eax,%r11d
and    $0xfffffffc,%r11d
lea    0x18(%rdx),%rbx
xor    %ecx,%ecx
movsd  0xeac(%rip),%xmm1
mov    %rdx,-0x48(%rsp)
jmp    1175 <invers+0x75>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x50,%rbx
add    $0x50,%r10
cmp    %rax,%rcx
je     1212 <invers+0x112>
xor    %edi,%edi
cmp    $0x3,%r9
jae    11be <invers+0xbe>
test   %rsi,%rsi
je     1160 <invers+0x60>
lea    (%r10,%rdi,8),%rdx
mov    %rcx,%rbp
sub    %rdi,%rbp
xor    %edi,%edi
jmp    119e <invers+0x9e>
movsd  %xmm2,(%rdx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
je     1160 <invers+0x60>
movapd %xmm1,%xmm2
cmp    %rdi,%rbp
je     1190 <invers+0x90>
xorpd  %xmm2,%xmm2
jmp    1190 <invers+0x90>
nopl   (%rax)
movsd  %xmm2,(%rbx,%rdi,8)
add    $0x4,%rdi
cmp    %r11,%rdi
je     117d <invers+0x7d>
movapd %xmm1,%xmm2
cmp    %rdi,%rcx
je     11cb <invers+0xcb>
xorpd  %xmm2,%xmm2
movsd  %xmm2,-0x18(%rbx,%rdi,8)
lea    0x1(%rdi),%rdx
movapd %xmm1,%xmm2
cmp    %rdx,%rcx
je     11e2 <invers+0xe2>
xorpd  %xmm2,%xmm2
movsd  %xmm2,-0x10(%rbx,%rdi,8)
lea    0x2(%rdi),%rdx
movapd %xmm1,%xmm2
cmp    %rdx,%rcx
je     11f9 <invers+0xf9>
xorpd  %xmm2,%xmm2
movsd  %xmm2,-0x8(%rbx,%rdi,8)
lea    0x3(%rdi),%rdx
movapd %xmm1,%xmm2
cmp    %rdx,%rcx
je     11b0 <invers+0xb0>
xorpd  %xmm2,%xmm2
jmp    11b0 <invers+0xb0>
mov    %r14,(%r15)
mov    0x8(%rsp),%rcx
movl   $0x0,(%rcx)
mov    -0x78(%rsp),%r10d
test   %r10d,%r10d
mov    -0x48(%rsp),%r9
mov    -0x70(%rsp),%r8
jle    1977 <invers+0x877>
lea    (%r8,%rax,8),%rcx
mov    %rcx,0x40(%rsp)
lea    (%r9,%rax,8),%rcx
mov    %rcx,0x38(%rsp)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x10(%rsp)
lea    0x50(%r8),%r11
lea    0x10(%r8),%rcx
lea    0x10(%r9),%rdi
lea    0x0(,%rax,8),%r14
mov    %r14,%rdx
and    $0xffffffffffffffe0,%rdx
mov    %rdx,0x30(%rsp)
and    $0xfffffffffffffff0,%r14
xor    %ebx,%ebx
mov    $0x1,%r13d
movapd 0xd7e(%rip),%xmm1
movapd 0xd86(%rip),%xmm2
mov    %r8,%rsi
mov    %r9,%rdx
mov    %rdi,0x18(%rsp)
mov    %rcx,0x20(%rsp)
mov    %rcx,%r12
xor    %ecx,%ecx
mov    %r15,-0x60(%rsp)
mov    %r14,-0x40(%rsp)
jmp    1304 <invers+0x204>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    -0x60(%rsp),%r15
mov    -0x50(%rsp),%r11
mov    -0x58(%rsp),%r13
mov    -0x18(%rsp),%rdi
mov    -0x68(%rsp),%r12
add    $0x1,%r13
add    $0x58,%r11
add    $0x50,%r12
add    $0x50,%rdi
add    $0x50,%rdx
add    $0x50,%rsi
mov    0x48(%rsp),%rbp
mov    %rbp,%rbx
cmp    %rax,%rbp
je     1977 <invers+0x877>
test   %ecx,%ecx
jne    1977 <invers+0x877>
mov    %r9,%rbp
mov    %r15,%r9
mov    %rdi,-0x18(%rsp)
mov    %rbx,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,4),%rcx
lea    (%r8,%rcx,1),%rdi
mov    %rdi,-0x20(%rsp)
add    %rbp,%rcx
mov    %rcx,-0x28(%rsp)
lea    (%rbx,%rbx,4),%r15
shl    $0x4,%r15
add    %r8,%r15
movsd  (%r15,%rbx,8),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm1,%xmm4
lea    0x1(%rbx),%rcx
mov    %rcx,0x48(%rsp)
cmp    %rax,%rcx
jae    13a0 <invers+0x2a0>
mov    %r11,%rbp
mov    %r13,%rcx
movapd %xmm4,%xmm5
mov    %ebx,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm6
andpd  %xmm1,%xmm6
ucomisd %xmm5,%xmm6
cmova  %ecx,%edi
maxsd  %xmm5,%xmm6
add    $0x1,%rcx
add    $0x50,%rbp
movapd %xmm6,%xmm5
cmp    %rcx,%rax
jne    1370 <invers+0x270>
jmp    13a2 <invers+0x2a2>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%edi
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,-0x10(%rsp)
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,-0x8(%rsp)
lea    (%r15,%rbx,8),%rbp
mov    %edi,%ecx
cmp    %rcx,%rbx
mov    %rbx,-0x38(%rsp)
mov    %r9,%r15
mov    -0x48(%rsp),%r9
je     1451 <invers+0x351>
movslq %edi,%rcx
cmp    $0x4,%r10d
mov    %rcx,(%rsp)
jae    14b0 <invers+0x3b0>
xor    %edi,%edi
mov    (%rsp),%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,4),%rcx
lea    (%r9,%rcx,1),%rbx
add    %r8,%rcx
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm3
movsd  (%rcx,%rdi,8),%xmm4
movsd  %xmm4,(%rsi,%rdi,8)
movsd  %xmm3,(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm3
movsd  (%rbx,%rdi,8),%xmm4
movsd  %xmm4,(%rdx,%rdi,8)
movsd  %xmm3,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1400 <invers+0x300>
movsd  (%r15),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%r15)
movsd  0x0(%rbp),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm1,%xmm4
mov    -0x38(%rsp),%rbx
ucomisd %xmm4,%xmm0
mov    -0x18(%rsp),%rdi
jbe    1480 <invers+0x380>
mov    0x8(%rsp),%rcx
movl   $0x1,(%rcx)
mov    $0x1,%ecx
jmp    12db <invers+0x1db>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  (%r15),%xmm3
movsd  %xmm3,(%r15)
movsd  0x0(%rbp),%xmm3
cmp    $0x2,%r10d
mov    %r11,-0x50(%rsp)
mov    %r13,-0x58(%rsp)
mov    %r12,-0x68(%rsp)
jae    1680 <invers+0x580>
xor    %ecx,%ecx
jmp    16f0 <invers+0x5f0>
nop
mov    %rbp,-0x30(%rsp)
mov    %r12,-0x68(%rsp)
mov    %r13,-0x58(%rsp)
mov    %r11,-0x50(%rsp)
shl    $0x4,%rcx
lea    (%rcx,%rcx,4),%rcx
lea    (%r8,%rcx,1),%r12
mov    0x40(%rsp),%rdi
lea    (%rdi,%rcx,1),%rbp
lea    (%r9,%rcx,1),%r11
mov    0x38(%rsp),%rdi
lea    (%rdi,%rcx,1),%r15
mov    -0x20(%rsp),%rbx
cmp    %rbp,%rbx
setb   -0x79(%rsp)
mov    -0x10(%rsp),%r13
cmp    %r13,%r12
setb   %r14b
mov    -0x8(%rsp),%r8
cmp    %r8,%rbx
setb   %r10b
mov    -0x28(%rsp),%rdi
cmp    %r13,%rdi
setb   -0x7a(%rsp)
cmp    %r15,%rbx
setb   -0x72(%rsp)
cmp    %r13,%r11
setb   -0x71(%rsp)
cmp    %r8,%r12
setb   %r13b
cmp    %rbp,%rdi
setb   -0x73(%rsp)
cmp    %r15,%r12
setb   %r12b
cmp    %rbp,%r11
setb   %bl
cmp    %r15,%rdi
setb   %r15b
cmp    %r8,%r11
setb   %dil
test   %r14b,-0x79(%rsp)
jne    193e <invers+0x83e>
and    -0x7a(%rsp),%r10b
mov    -0x40(%rsp),%r14
mov    -0x30(%rsp),%rbp
jne    1919 <invers+0x819>
mov    %ebx,%r11d
mov    -0x72(%rsp),%bl
and    -0x71(%rsp),%bl
jne    1919 <invers+0x819>
and    -0x73(%rsp),%r13b
mov    -0x70(%rsp),%r8
mov    -0x78(%rsp),%r10d
jne    1910 <invers+0x810>
and    %r11b,%r12b
mov    -0x50(%rsp),%r11
mov    0x30(%rsp),%rbx
mov    -0x58(%rsp),%r13
jne    18ff <invers+0x7ff>
mov    %edi,%r12d
mov    $0x0,%edi
and    %r12b,%r15b
mov    -0x60(%rsp),%r15
mov    -0x68(%rsp),%r12
jne    13e9 <invers+0x2e9>
mov    %r15,%r9
mov    0x20(%rsp),%rdi
add    %rcx,%rdi
add    0x18(%rsp),%rcx
xor    %ebp,%ebp
mov    %r12,%r15
mov    -0x18(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%r15,%rbp,1),%xmm3
movups (%r15,%rbp,1),%xmm4
movups -0x10(%rdi,%rbp,1),%xmm5
movups (%rdi,%rbp,1),%xmm6
movups %xmm5,-0x10(%r15,%rbp,1)
movups %xmm6,(%r15,%rbp,1)
movups %xmm3,-0x10(%rdi,%rbp,1)
movups %xmm4,(%rdi,%rbp,1)
movupd -0x10(%r12,%rbp,1),%xmm3
movupd (%r12,%rbp,1),%xmm4
movupd -0x10(%rcx,%rbp,1),%xmm5
movupd (%rcx,%rbp,1),%xmm6
movupd %xmm5,-0x10(%r12,%rbp,1)
movupd %xmm6,(%r12,%rbp,1)
movupd %xmm3,-0x10(%rcx,%rbp,1)
movupd %xmm4,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    15f0 <invers+0x4f0>
mov    0x28(%rsp),%rcx
mov    %rcx,%rdi
cmp    %rax,%rcx
mov    %r15,%r12
mov    %r9,%r15
mov    -0x48(%rsp),%r9
mov    -0x30(%rsp),%rbp
jne    13e9 <invers+0x2e9>
jmp    1431 <invers+0x331>
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rsp),%rcx
cmp    %rcx,-0x20(%rsp)
jae    169c <invers+0x59c>
mov    -0x10(%rsp),%rcx
cmp    %rcx,-0x28(%rsp)
jae    169c <invers+0x59c>
xor    %ecx,%ecx
jmp    16f0 <invers+0x5f0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rcx,1),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%rsi,%rcx,1)
movupd (%rdx,%rcx,1),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%rdx,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%r14
jne    16b0 <invers+0x5b0>
mov    0x10(%rsp),%rdi
mov    %rdi,%rcx
cmp    %rax,%rdi
je     1715 <invers+0x615>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    16f0 <invers+0x5f0>
mov    %r9,%r13
mov    %r8,%r12
xor    %r15d,%r15d
jmp    1735 <invers+0x635>
add    $0x1,%r15
add    $0x50,%r12
add    $0x50,%r13
cmp    %rax,%r15
je     12c0 <invers+0x1c0>
cmp    %rbx,%r15
je     1720 <invers+0x620>
lea    (%r15,%r15,4),%rcx
shl    $0x4,%rcx
add    %r8,%rcx
movsd  (%rcx,%rbx,8),%xmm3
cmp    $0x2,%r10d
jae    17a0 <invers+0x6a0>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rcx,8),%xmm4
movsd  (%rsi,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r12,%rcx,8)
movsd  0x0(%r13,%rcx,8),%xmm4
movsd  (%rdx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,0x0(%r13,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1760 <invers+0x660>
jmp    1720 <invers+0x620>
nop
mov    %r15,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,4),%rdi
lea    (%r8,%rdi,1),%rbp
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
add    %r9,%rdi
lea    (%rdi,%rax,8),%rcx
cmp    %rcx,%rbp
setb   (%rsp)
cmp    %rbx,%rdi
setb   -0x30(%rsp)
mov    -0x10(%rsp),%r8
cmp    %r8,%rbp
setb   %r14b
mov    -0x20(%rsp),%r10
cmp    %rbx,%r10
setb   -0x79(%rsp)
mov    -0x8(%rsp),%r9
cmp    %r9,%rbp
setb   %bpl
mov    -0x28(%rsp),%r11
cmp    %rbx,%r11
setb   -0x7a(%rsp)
cmp    %r8,%rdi
setb   %bl
cmp    %rcx,%r10
setb   %r8b
cmp    %r9,%rdi
setb   %dil
cmp    %rcx,%r11
setb   %r11b
mov    -0x30(%rsp),%cl
test   %cl,(%rsp)
jne    18d3 <invers+0x7d3>
and    -0x79(%rsp),%r14b
jne    18d3 <invers+0x7d3>
and    -0x7a(%rsp),%bpl
jne    18d3 <invers+0x7d3>
and    %r8b,%bl
mov    -0x48(%rsp),%r9
mov    -0x70(%rsp),%r8
mov    -0x78(%rsp),%r10d
mov    -0x40(%rsp),%r14
jne    18f3 <invers+0x7f3>
mov    $0x0,%ecx
and    %r11b,%dil
mov    -0x38(%rsp),%rbx
jne    1760 <invers+0x660>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rcx,1),%xmm5
movupd (%rsi,%rcx,1),%xmm6
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,(%r12,%rcx,1)
movupd 0x0(%r13,%rcx,1),%xmm5
movupd (%rdx,%rcx,1),%xmm6
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x0(%r13,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%r14
jne    1880 <invers+0x780>
mov    0x10(%rsp),%rdi
mov    %rdi,%rcx
cmp    %rax,%rdi
jne    1760 <invers+0x660>
jmp    1720 <invers+0x620>
xor    %ecx,%ecx
mov    -0x48(%rsp),%r9
mov    -0x70(%rsp),%r8
mov    -0x78(%rsp),%r10d
mov    -0x40(%rsp),%r14
mov    -0x38(%rsp),%rbx
jmp    1760 <invers+0x660>
xor    %ecx,%ecx
mov    -0x38(%rsp),%rbx
jmp    1760 <invers+0x660>
xor    %edi,%edi
mov    -0x60(%rsp),%r15
mov    -0x68(%rsp),%r12
jmp    13e9 <invers+0x2e9>
xor    %edi,%edi
mov    -0x60(%rsp),%r15
jmp    192a <invers+0x82a>
xor    %edi,%edi
mov    -0x60(%rsp),%r15
mov    -0x70(%rsp),%r8
mov    -0x78(%rsp),%r10d
mov    -0x50(%rsp),%r11
mov    -0x58(%rsp),%r13
mov    -0x68(%rsp),%r12
jmp    13e9 <invers+0x2e9>
xor    %edi,%edi
mov    -0x60(%rsp),%r15
mov    -0x70(%rsp),%r8
mov    -0x78(%rsp),%r10d
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r14
mov    -0x58(%rsp),%r13
mov    -0x68(%rsp),%r12
mov    -0x30(%rsp),%rbp
jmp    13e9 <invers+0x2e9>
mov    %r14,(%r15)
movl   $0x0,(%r8)
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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