#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 */
typedef int /*<<< orphan*/ tmp;

/* Variables and functions */
double fabs(double);
int invmat2(double m[6], double m11[6]) {
  double t, tmp[3][3], m1[9];
  int i, j, k, sw;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++)
      m1[i * 3 + j] = i == j ? 1.0 : 0.0;
  for (k = 0, i = 0; i < 3; i++)
    for (j = i; j < 3; j++)
      tmp[i][j] = tmp[j][i] = m[k++];
  for (i = 0; i < 3; i++) {
    sw = i;
    for (j = i + 1; j < 3; j++)
      if (fabs(tmp[j][i]) > fabs(tmp[i][i]))
        sw = j;
    if (sw != i) {
      for (k = 0; k < 3; k++) {
        t = tmp[i][k];
        tmp[i][k] = tmp[sw][k];
        tmp[sw][k] = t;
        t = m1[i * 3 + k];
        m1[i * 3 + k] = m1[sw * 3 + k];
        m1[sw * 3 + k] = t;
      }
    }
    if (((((tmp[i][i]) == 0.0f)
              ? (fabs(0.0) < 1.e-06)
              : (((0.0) == 0.0f) ? (fabs(tmp[i][i]) < 1.e-06)
                                 : (fabs((tmp[i][i]) - (0.0)) /
                                        (fabs(tmp[i][i]) + fabs(0.0)) <
                                    2.e-06)))))
      return (0);
    t = tmp[i][i];
    for (k = 0; k < 3; k++) {
      tmp[i][k] /= t;
      m1[i * 3 + k] /= t;
    }
    for (j = 0; j < 3; j++)
      if (j != i) {
        t = tmp[j][i];
        for (k = 0; k < 3; k++) {
          tmp[j][k] -= tmp[i][k] * t;
          m1[j * 3 + k] -= m1[i * 3 + k] * t;
        }
      }
  }
  for (k = 0, i = 0; i < 3; i++)
    for (j = i; j < 3; j++)
      m11[k++] = m1[i * 3 + j];
  return (1);
}


x86 assembly (clang, -O0):
<invmat2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x3,-0xc4(%rbp)
jge    11ca <invmat2+0xca>
movl   $0x0,-0xc8(%rbp)
cmpl   $0x3,-0xc8(%rbp)
jge    11b1 <invmat2+0xb1>
mov    -0xc4(%rbp),%eax
mov    -0xc8(%rbp),%ecx
movsd  0xebe(%rip),%xmm0
xorps  %xmm1,%xmm1
movsd  %xmm1,-0xe0(%rbp)
ff
cmp    %ecx,%eax
movsd  %xmm0,-0xd8(%rbp)
ff
je     117d <invmat2+0x7d>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
imul   $0x3,-0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
cltq
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1131 <invmat2+0x31>
jmp    11b6 <invmat2+0xb6>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    111a <invmat2+0x1a>
movl   $0x0,-0xcc(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x3,-0xc4(%rbp)
jge    128a <invmat2+0x18a>
mov    -0xc4(%rbp),%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x3,-0xc8(%rbp)
jge    1271 <invmat2+0x171>
mov    -0x10(%rbp),%rax
mov    -0xcc(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xcc(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xc8(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    11f7 <invmat2+0xf7>
jmp    1276 <invmat2+0x176>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    11de <invmat2+0xde>
movl   $0x0,-0xc4(%rbp)
cmpl   $0x3,-0xc4(%rbp)
jge    17a8 <invmat2+0x6a8>
mov    -0xc4(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x3,-0xc8(%rbp)
jge    134a <invmat2+0x24a>
movslq -0xc8(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd32(%rip),%xmm1
pand   %xmm1,%xmm0
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xd09(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1331 <invmat2+0x231>
mov    -0xc8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    1336 <invmat2+0x236>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    12bc <invmat2+0x1bc>
mov    -0xd0(%rbp),%eax
cmp    -0xc4(%rbp),%eax
je     1478 <invmat2+0x378>
movl   $0x0,-0xcc(%rbp)
cmpl   $0x3,-0xcc(%rbp)
jge    1473 <invmat2+0x373>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movslq -0xd0(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
movslq -0xd0(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
imul   $0x3,-0xc4(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x20(%rbp)
imul   $0x3,-0xd0(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
imul   $0x3,-0xc4(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
movsd  -0x20(%rbp),%xmm0
imul   $0x3,-0xd0(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1366 <invmat2+0x266>
jmp    1478 <invmat2+0x378>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14c3 <invmat2+0x3c3>
jp     14c3 <invmat2+0x3c3>
xorps  %xmm1,%xmm1
movsd  0xb54(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1588 <invmat2+0x488>
jmp    1594 <invmat2+0x494>
mov    $0x1,%al
test   $0x1,%al
jne    14d2 <invmat2+0x3d2>
jmp    1512 <invmat2+0x412>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xb29(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb05(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1588 <invmat2+0x488>
jmp    1594 <invmat2+0x494>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movaps 0xae2(%rip),%xmm0
pand   %xmm0,%xmm1
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xab9(%rip),%xmm2
pand   %xmm2,%xmm0
xorps  %xmm2,%xmm2
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
movsd  0xa82(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1594 <invmat2+0x494>
movl   $0x0,-0x4(%rbp)
jmp    184b <invmat2+0x74b>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0xcc(%rbp)
cmpl   $0x3,-0xcc(%rbp)
jge    1638 <invmat2+0x538>
movsd  -0x20(%rbp),%xmm1
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm1
imul   $0x3,-0xc4(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    15c1 <invmat2+0x4c1>
movl   $0x0,-0xc8(%rbp)
cmpl   $0x3,-0xc8(%rbp)
jge    178f <invmat2+0x68f>
mov    -0xc8(%rbp),%eax
cmp    -0xc4(%rbp),%eax
je     1776 <invmat2+0x676>
movslq -0xc8(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0xcc(%rbp)
cmpl   $0x3,-0xcc(%rbp)
jge    1771 <invmat2+0x671>
movslq -0xc4(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x20(%rbp),%xmm2
movslq -0xc8(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
imul   $0x3,-0xc4(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x20(%rbp),%xmm2
imul   $0x3,-0xc8(%rbp),%eax
add    -0xcc(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    168e <invmat2+0x58e>
jmp    1776 <invmat2+0x676>
jmp    177b <invmat2+0x67b>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1642 <invmat2+0x542>
jmp    1794 <invmat2+0x694>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1294 <invmat2+0x194>
movl   $0x0,-0xcc(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x3,-0xc4(%rbp)
jge    1844 <invmat2+0x744>
mov    -0xc4(%rbp),%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x3,-0xc8(%rbp)
jge    182b <invmat2+0x72b>
imul   $0x3,-0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0xcc(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xcc(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    17d5 <invmat2+0x6d5>
jmp    1830 <invmat2+0x730>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    17bc <invmat2+0x6bc>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invmat2>:
sub    $0x18,%rsp
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x80(%rsp)
lea    -0x60(%rsp),%r8
xorps  %xmm0,%xmm0
movups %xmm0,-0x78(%rsp)
movq   $0x0,-0x68(%rsp)
mov    %rax,-0x60(%rsp)
movups %xmm0,-0x58(%rsp)
movq   $0x0,-0x48(%rsp)
mov    %rax,-0x40(%rsp)
movups (%rdi),%xmm0
lea    -0x18(%rsp),%r9
movhps %xmm0,-0x18(%rsp)
movaps %xmm0,-0x30(%rsp)
movsd  0x10(%rdi),%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,-0x20(%rsp)
movups 0x18(%rdi),%xmm0
movhps %xmm0,0x8(%rsp)
movaps %xmm0,-0x10(%rsp)
movsd  0x28(%rdi),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0xfffffffffffffffe,%r10
xor    %r11d,%r11d
movapd 0xe72(%rip),%xmm0
xorpd  %xmm1,%xmm1
movsd  0xe75(%rip),%xmm8
jmp    12c5 <invmat2+0x1c5>
movsd  -0x18(%rsp,%r11,8),%xmm3
movsd  -0x80(%rsp,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
movsd  -0x68(%rsp),%xmm4
subsd  %xmm2,%xmm4
movsd  -0x60(%rsp),%xmm2
movsd  %xmm4,-0x68(%rsp)
movupd (%rdi),%xmm4
movupd -0x18(%rsp),%xmm5
movapd %xmm3,%xmm6
unpcklpd %xmm3,%xmm6
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,-0x18(%rsp)
movsd  -0x78(%rsp,%rdx,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,-0x60(%rsp)
movsd  -0x8(%rsp),%xmm2
movsd  (%rax),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,-0x8(%rsp)
mulsd  -0x70(%rsp,%rdx,8),%xmm3
movsd  -0x58(%rsp),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,-0x58(%rsp)
cmp    $0x2,%r11
je     14a9 <invmat2+0x3a9>
movsd  (%rsp,%r11,8),%xmm3
add    $0x1,%r11
movsd  -0x80(%rsp,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
movsd  -0x50(%rsp),%xmm4
subsd  %xmm2,%xmm4
movsd  -0x48(%rsp),%xmm2
movsd  %xmm4,-0x50(%rsp)
movupd (%rdi),%xmm4
movapd (%rsp),%xmm5
movapd %xmm3,%xmm6
unpcklpd %xmm3,%xmm6
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movapd %xmm5,(%rsp)
movsd  -0x78(%rsp,%rdx,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,-0x48(%rsp)
movsd  0x10(%rsp),%xmm2
movsd  (%rax),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  -0x40(%rsp),%xmm2
mulsd  -0x70(%rsp,%rdx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,-0x40(%rsp)
add    $0x20,%r9
add    $0x1,%r10
cmp    $0x1,%r11
ja     1310 <invmat2+0x210>
lea    (%r11,%r11,2),%rax
lea    (%rsp,%rax,8),%rax
add    $0xffffffffffffffd0,%rax
movsd  (%rax,%r11,8),%xmm3
andpd  %xmm0,%xmm3
mov    %r10,%rdx
mov    %r9,%rdi
mov    %r11d,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm4
andpd  %xmm0,%xmm4
ucomisd %xmm3,%xmm4
lea    0x3(%rdx),%ecx
cmova  %ecx,%eax
add    $0x18,%rdi
inc    %rdx
jne    12f0 <invmat2+0x1f0>
jmp    1313 <invmat2+0x213>
nopl   (%rax)
mov    %r11d,%eax
mov    %eax,%ecx
cmp    %rcx,%r11
je     13aa <invmat2+0x2aa>
movslq %eax,%rcx
lea    (%rax,%rax,2),%eax
cltq
lea    0x0(,%r11,8),%rdx
lea    (%rdx,%rdx,2),%rdx
lea    (%rcx,%rcx,2),%rcx
movups -0x30(%rsp,%rdx,1),%xmm3
movsd  -0x80(%rsp,%rdx,1),%xmm4
movsd  -0x80(%rsp,%rax,8),%xmm5
movsd  %xmm5,-0x80(%rsp,%rdx,1)
movsd  %xmm4,-0x80(%rsp,%rax,8)
movups -0x30(%rsp,%rcx,8),%xmm4
movups %xmm4,-0x30(%rsp,%rdx,1)
movups %xmm3,-0x30(%rsp,%rcx,8)
movsd  -0x78(%rsp,%rdx,1),%xmm3
movsd  -0x78(%rsp,%rax,8),%xmm4
movsd  %xmm4,-0x78(%rsp,%rdx,1)
movsd  %xmm3,-0x78(%rsp,%rax,8)
movsd  -0x20(%rsp,%rdx,1),%xmm3
movsd  -0x20(%rsp,%rcx,8),%xmm4
movsd  %xmm4,-0x20(%rsp,%rdx,1)
movsd  %xmm3,-0x20(%rsp,%rcx,8)
movsd  -0x70(%rsp,%rdx,1),%xmm3
movsd  -0x70(%rsp,%rax,8),%xmm4
movsd  %xmm4,-0x70(%rsp,%rdx,1)
movsd  %xmm3,-0x70(%rsp,%rax,8)
lea    (%r11,%r11,2),%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0xffffffffffffffd0,%rdi
movsd  (%rdi,%r11,8),%xmm5
xor    %eax,%eax
ucomisd %xmm1,%xmm5
jne    13ca <invmat2+0x2ca>
jnp    14d2 <invmat2+0x3d2>
movapd %xmm5,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm3,%xmm8
ja     14d2 <invmat2+0x3d2>
movupd -0x30(%rsp,%rdx,8),%xmm6
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
divpd  %xmm3,%xmm6
movupd %xmm6,-0x30(%rsp,%rdx,8)
movupd -0x80(%rsp,%rdx,8),%xmm4
divpd  %xmm3,%xmm4
movupd %xmm4,-0x80(%rsp,%rdx,8)
lea    -0x20(%rsp,%rdx,8),%rax
movsd  -0x20(%rsp,%rdx,8),%xmm3
divsd  %xmm5,%xmm3
movsd  %xmm3,-0x20(%rsp,%rdx,8)
movsd  -0x70(%rsp,%rdx,8),%xmm7
divsd  %xmm5,%xmm7
movsd  %xmm7,-0x70(%rsp,%rdx,8)
test   %r11,%r11
je     11a0 <invmat2+0xa0>
movsd  -0x30(%rsp,%r11,8),%xmm2
movapd -0x30(%rsp),%xmm7
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mulpd  %xmm5,%xmm6
subpd  %xmm6,%xmm7
movapd %xmm7,-0x30(%rsp)
movapd -0x80(%rsp),%xmm6
movlpd -0x80(%rsp,%rdx,8),%xmm4
mulpd  %xmm5,%xmm4
subpd  %xmm4,%xmm6
movapd %xmm6,-0x80(%rsp)
movsd  -0x20(%rsp),%xmm4
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm4
movsd  %xmm4,-0x20(%rsp)
mulsd  -0x70(%rsp,%rdx,8),%xmm2
movsd  -0x70(%rsp),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x70(%rsp)
cmp    $0x1,%r11
jne    11a0 <invmat2+0xa0>
jmp    1233 <invmat2+0x133>
mov    -0x70(%rsp),%rax
mov    %rax,0x10(%rsi)
movaps -0x80(%rsp),%xmm0
movups %xmm0,(%rsi)
movupd (%r8),%xmm0
movupd %xmm0,0x18(%rsi)
mov    -0x40(%rsp),%rax
mov    %rax,0x28(%rsi)
mov    $0x1,%eax
add    $0x18,%rsp
ret

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

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