#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 */
int fabs(float);
int lib3ds_matrix_inv(float m[4][4]) {
  int i, j, k;
  int pvt_i[4], pvt_j[4];
  float pvt_val;
  float hold;
  float determinat;
  determinat = 1.0f;
  for (k = 0; k < 4; k++) {
    pvt_val = m[k][k];
    pvt_i[k] = k;
    pvt_j[k] = k;
    for (i = k; i < 4; i++) {
      for (j = k; j < 4; j++) {
        if (fabs(m[i][j]) > fabs(pvt_val)) {
          pvt_i[k] = i;
          pvt_j[k] = j;
          pvt_val = m[i][j];
        }
      }
    }
    determinat *= pvt_val;
    if (fabs(determinat) < (1e-5)) {
      return (0);
    }
    i = pvt_i[k];
    if (i != k) {
      for (j = 0; j < 4; j++) {
        hold = -m[k][j];
        m[k][j] = m[i][j];
        m[i][j] = hold;
      }
    }
    j = pvt_j[k];
    if (j != k) {
      for (i = 0; i < 4; i++) {
        hold = -m[i][k];
        m[i][k] = m[i][j];
        m[i][j] = hold;
      }
    }
    for (i = 0; i < 4; i++) {
      if (i != k)
        m[i][k] /= (-pvt_val);
    }
    for (i = 0; i < 4; i++) {
      hold = m[i][k];
      for (j = 0; j < 4; j++) {
        if (i != k && j != k)
          m[i][j] += hold * m[k][j];
      }
    }
    for (j = 0; j < 4; j++) {
      if (j != k)
        m[k][j] /= pvt_val;
    }
    m[k][k] = 1.0f / pvt_val;
  }
  for (k = 4 - 2; k >= 0; k--) {
    i = pvt_j[k];
    if (i != k) {
      for (j = 0; j < 4; j++) {
        hold = m[k][j];
        m[k][j] = -m[i][j];
        m[i][j] = hold;
      }
    }
    j = pvt_i[k];
    if (j != k)
      for (i = 0; i < 4; i++) {
        hold = m[i][k];
        m[i][k] = -m[i][j];
        m[i][j] = hold;
      }
  }
  return (1);
}


x86 assembly (clang, -O0):
<lib3ds_matrix_inv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
movss  0xedc(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jge    1567 <lib3ds_matrix_inv+0x457>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x1c(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x1c(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    121d <lib3ds_matrix_inv+0x10d>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    120a <lib3ds_matrix_inv+0xfa>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
mov    %eax,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%eax
cmp    %ecx,%eax
jle    11f7 <lib3ds_matrix_inv+0xe7>
mov    -0x14(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x18(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    11fc <lib3ds_matrix_inv+0xec>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1183 <lib3ds_matrix_inv+0x73>
jmp    120f <lib3ds_matrix_inv+0xff>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1173 <lib3ds_matrix_inv+0x63>
movss  -0x44(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xdc6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1258 <lib3ds_matrix_inv+0x148>
movl   $0x0,-0x4(%rbp)
jmp    16f6 <lib3ds_matrix_inv+0x5e6>
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     130a <lib3ds_matrix_inv+0x1fa>
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1305 <lib3ds_matrix_inv+0x1f5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1276 <lib3ds_matrix_inv+0x166>
jmp    130a <lib3ds_matrix_inv+0x1fa>
movslq -0x1c(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     13bc <lib3ds_matrix_inv+0x2ac>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    13b7 <lib3ds_matrix_inv+0x2a7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1328 <lib3ds_matrix_inv+0x218>
jmp    13bc <lib3ds_matrix_inv+0x2ac>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    141f <lib3ds_matrix_inv+0x30f>
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     140c <lib3ds_matrix_inv+0x2fc>
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1411 <lib3ds_matrix_inv+0x301>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13c3 <lib3ds_matrix_inv+0x2b3>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    14de <lib3ds_matrix_inv+0x3ce>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    14cb <lib3ds_matrix_inv+0x3bb>
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     14b8 <lib3ds_matrix_inv+0x3a8>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     14b8 <lib3ds_matrix_inv+0x3a8>
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    14bd <lib3ds_matrix_inv+0x3ad>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1454 <lib3ds_matrix_inv+0x344>
jmp    14d0 <lib3ds_matrix_inv+0x3c0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1426 <lib3ds_matrix_inv+0x316>
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1534 <lib3ds_matrix_inv+0x424>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1521 <lib3ds_matrix_inv+0x411>
movss  -0x44(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1526 <lib3ds_matrix_inv+0x416>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14e5 <lib3ds_matrix_inv+0x3d5>
movss  0xac4(%rip),%xmm0
divss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1130 <lib3ds_matrix_inv+0x20>
movl   $0x2,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     16ef <lib3ds_matrix_inv+0x5df>
movslq -0x1c(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     162a <lib3ds_matrix_inv+0x51a>
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1625 <lib3ds_matrix_inv+0x515>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1596 <lib3ds_matrix_inv+0x486>
jmp    162a <lib3ds_matrix_inv+0x51a>
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     16dc <lib3ds_matrix_inv+0x5cc>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    16d7 <lib3ds_matrix_inv+0x5c7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1648 <lib3ds_matrix_inv+0x538>
jmp    16dc <lib3ds_matrix_inv+0x5cc>
jmp    16e1 <lib3ds_matrix_inv+0x5d1>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    156e <lib3ds_matrix_inv+0x45e>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lib3ds_matrix_inv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
lea    0xc(%rdi),%r15
movss  0xed3(%rip),%xmm0
xor    %ebx,%ebx
mov    %rdi,%r9
mov    %r15,%r14
xor    %r12d,%r12d
movss  %xmm0,0x2c(%rsp)
mov    %rdi,0x68(%rsp)
jmp    1180 <lib3ds_matrix_inv+0x70>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xea8(%rip),%xmm0
divss  0x10(%rsp),%xmm0
mov    0x80(%rsp),%rax
movss  %xmm0,(%rax)
add    $0x14,%r14
add    $0x10,%rbx
add    $0x4,%r9
cmp    $0x4,%r12
je     1609 <lib3ds_matrix_inv+0x4f9>
mov    %r9,0x90(%rsp)
mov    %r12,%rax
shl    $0x4,%rax
mov    %rax,0x78(%rsp)
lea    (%rdi,%rax,1),%rcx
lea    (%rcx,%r12,4),%rax
mov    %rax,0x80(%rsp)
mov    %rcx,0x70(%rsp)
movss  (%rcx,%r12,4),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %r12d,0x40(%rsp,%r12,4)
mov    %r12d,0x30(%rsp,%r12,4)
lea    0x1(%r12),%rax
mov    %rax,0x50(%rsp)
lea    0x2(%r12),%rax
mov    %rax,0x60(%rsp)
lea    0x3(%r12),%rax
mov    %rax,0x58(%rsp)
mov    %r14,0x88(%rsp)
mov    %r12d,%eax
mov    %r12d,0xc(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r12,%r13
jmp    1212 <lib3ds_matrix_inv+0x102>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x10,%r14
cmp    $0x4,%r13
je     1340 <lib3ds_matrix_inv+0x230>
movss  -0xc(%r14),%xmm0
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jle    1252 <lib3ds_matrix_inv+0x142>
mov    %r13d,0x40(%rsp,%r12,4)
mov    %r12d,0x30(%rsp,%r12,4)
movss  -0xc(%r14),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %r12d,%eax
mov    %r12d,0xc(%rsp)
mov    %r13d,%eax
mov    %r13d,0x8(%rsp)
cmpq   $0x4,0x50(%rsp)
je     1200 <lib3ds_matrix_inv+0xf0>
movss  -0x8(%r14),%xmm0
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jle    129b <lib3ds_matrix_inv+0x18b>
mov    %r13d,0x40(%rsp,%r12,4)
mov    0x50(%rsp),%rax
mov    %eax,0x30(%rsp,%r12,4)
movss  -0x8(%r14),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %eax,0xc(%rsp)
mov    %r13d,%eax
mov    %r13d,0x8(%rsp)
cmpq   $0x4,0x60(%rsp)
je     1200 <lib3ds_matrix_inv+0xf0>
movss  -0x4(%r14),%xmm0
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jle    12e8 <lib3ds_matrix_inv+0x1d8>
mov    %r13d,0x40(%rsp,%r12,4)
mov    0x60(%rsp),%rax
mov    %eax,0x30(%rsp,%r12,4)
movss  -0x4(%r14),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %eax,0xc(%rsp)
mov    %r13d,%eax
mov    %r13d,0x8(%rsp)
cmpq   $0x4,0x58(%rsp)
je     1200 <lib3ds_matrix_inv+0xf0>
movss  (%r14),%xmm0
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jle    1200 <lib3ds_matrix_inv+0xf0>
mov    %r13d,0x40(%rsp,%r12,4)
mov    0x58(%rsp),%rax
mov    %eax,0x30(%rsp,%r12,4)
movss  (%r14),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %eax,0xc(%rsp)
mov    %r13d,%eax
mov    %r13d,0x8(%rsp)
jmp    1200 <lib3ds_matrix_inv+0xf0>
nopl   0x0(%rax)
movss  0x2c(%rsp),%xmm0
mulss  0x10(%rsp),%xmm0
movss  %xmm0,0x2c(%rsp)
call   1030 <fabs@plt>
test   %eax,%eax
jle    17c3 <lib3ds_matrix_inv+0x6b3>
mov    0x8(%rsp),%ecx
mov    %ecx,%eax
cmp    %rax,%r12
mov    0x68(%rsp),%rdi
movaps 0xc9c(%rip),%xmm2
mov    0x78(%rsp),%r10
je     1397 <lib3ds_matrix_inv+0x287>
movslq %ecx,%rax
shl    $0x4,%rax
movups (%rdi,%r10,1),%xmm0
xorps  %xmm2,%xmm0
movups (%rdi,%rax,1),%xmm1
movups %xmm1,(%rdi,%r10,1)
movups %xmm0,(%rdi,%rax,1)
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
cmp    %rax,%r12
mov    0x90(%rsp),%r9
mov    0x88(%rsp),%r14
mov    0x70(%rsp),%r11
je     142a <lib3ds_matrix_inv+0x31a>
movslq %ecx,%rax
movss  (%rdi,%r12,4),%xmm0
xorps  %xmm2,%xmm0
movss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdi,%r12,4)
movss  %xmm0,(%rdi,%rax,4)
movss  0x10(%rdi,%r12,4),%xmm0
xorps  %xmm2,%xmm0
movss  0x10(%rdi,%rax,4),%xmm1
movss  %xmm1,0x10(%rdi,%r12,4)
movss  %xmm0,0x10(%rdi,%rax,4)
movss  0x20(%rdi,%r12,4),%xmm0
xorps  %xmm2,%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
movss  %xmm1,0x20(%rdi,%r12,4)
movss  %xmm0,0x20(%rdi,%rax,4)
movss  0x30(%rdi,%r12,4),%xmm0
xorps  %xmm2,%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
movss  %xmm1,0x30(%rdi,%r12,4)
movss  %xmm0,0x30(%rdi,%rax,4)
movaps 0x10(%rsp),%xmm0
xorps  %xmm2,%xmm0
test   %r12,%r12
je     1470 <lib3ds_matrix_inv+0x360>
movss  (%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%r12,4)
cmp    $0x1,%r12
je     1482 <lib3ds_matrix_inv+0x372>
movss  0x10(%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%rdi,%r12,4)
cmp    $0x2,%r12
jne    15de <lib3ds_matrix_inv+0x4ce>
mov    $0x1,%r8b
xor    %ecx,%ecx
jmp    149d <lib3ds_matrix_inv+0x38d>
movss  0x10(%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%rdi,%r12,4)
test   %r12,%r12
setne  %cl
movss  0x20(%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x20(%rdi,%r12,4)
xor    %r8d,%r8d
movss  0x30(%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x30(%rdi,%r12,4)
xor    %edx,%edx
lea    (%rdi,%r10,1),%rsi
add    $0x4,%rsi
xor    %ebp,%ebp
jmp    14ce <lib3ds_matrix_inv+0x3be>
nopl   (%rax)
add    $0x10,%rbp
cmp    $0x40,%rbp
je     1560 <lib3ds_matrix_inv+0x450>
movss  (%r9,%rbp,1),%xmm0
cmp    %rbp,%rbx
je     14f5 <lib3ds_matrix_inv+0x3e5>
test   %r12,%r12
je     14f5 <lib3ds_matrix_inv+0x3e5>
movss  (%r11),%xmm1
mulss  %xmm0,%xmm1
addss  -0xc(%r15,%rbp,1),%xmm1
movss  %xmm1,-0xc(%r15,%rbp,1)
cmp    %rbp,%rbx
sete   %al
or     %cl,%al
jne    1515 <lib3ds_matrix_inv+0x405>
movss  (%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  -0x8(%r15,%rbp,1),%xmm1
movss  %xmm1,-0x8(%r15,%rbp,1)
cmp    %rbp,%rbx
sete   %al
or     %r8b,%al
jne    1537 <lib3ds_matrix_inv+0x427>
movss  0x4(%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  -0x4(%r15,%rbp,1),%xmm1
movss  %xmm1,-0x4(%r15,%rbp,1)
cmp    %rbp,%rbx
sete   %al
or     %dl,%al
jne    14c0 <lib3ds_matrix_inv+0x3b0>
mulss  0x8(%rsi),%xmm0
addss  (%r15,%rbp,1),%xmm0
movss  %xmm0,(%r15,%rbp,1)
jmp    14c0 <lib3ds_matrix_inv+0x3b0>
nopl   0x0(%rax,%rax,1)
test   %r12,%r12
je     1577 <lib3ds_matrix_inv+0x467>
movss  (%rdi,%r10,1),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,(%rdi,%r10,1)
test   %cl,%cl
mov    0x50(%rsp),%r12
je     1590 <lib3ds_matrix_inv+0x480>
test   %r8b,%r8b
je     15a9 <lib3ds_matrix_inv+0x499>
test   %dl,%dl
jne    1150 <lib3ds_matrix_inv+0x40>
jmp    15c5 <lib3ds_matrix_inv+0x4b5>
nop
movss  0x4(%rdi,%r10,1),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,0x4(%rdi,%r10,1)
test   %r8b,%r8b
jne    1585 <lib3ds_matrix_inv+0x475>
movss  0x8(%rdi,%r10,1),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,0x8(%rdi,%r10,1)
test   %dl,%dl
jne    1150 <lib3ds_matrix_inv+0x40>
movss  0xc(%rdi,%r10,1),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,0xc(%rdi,%r10,1)
jmp    1150 <lib3ds_matrix_inv+0x40>
movss  0x20(%rdi,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x20(%rdi,%r12,4)
mov    $0x1,%dl
xor    %ecx,%ecx
mov    $0x0,%r8d
cmp    $0x3,%r12
jne    149d <lib3ds_matrix_inv+0x38d>
jmp    14b1 <lib3ds_matrix_inv+0x3a1>
movslq 0x38(%rsp),%rax
cmp    $0x2,%rax
je     162f <lib3ds_matrix_inv+0x51f>
shl    $0x4,%rax
movups 0x20(%rdi),%xmm0
movups (%rdi,%rax,1),%xmm1
xorps  0x9e9(%rip),%xmm1
movups %xmm1,0x20(%rdi)
movups %xmm0,(%rdi,%rax,1)
movslq 0x48(%rsp),%rax
cmp    $0x2,%rax
je     169c <lib3ds_matrix_inv+0x58c>
movss  0x8(%rdi),%xmm0
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x8(%rdi)
movss  %xmm0,(%rdi,%rax,4)
movss  0x18(%rdi),%xmm0
movss  0x10(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x18(%rdi)
movss  %xmm0,0x10(%rdi,%rax,4)
movss  0x28(%rdi),%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x28(%rdi)
movss  %xmm0,0x20(%rdi,%rax,4)
movss  0x38(%rdi),%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x38(%rdi)
movss  %xmm0,0x30(%rdi,%rax,4)
movslq 0x34(%rsp),%rax
cmp    $0x1,%rax
je     16c2 <lib3ds_matrix_inv+0x5b2>
shl    $0x4,%rax
movups 0x10(%rdi),%xmm0
movups (%rdi,%rax,1),%xmm1
xorps  0x956(%rip),%xmm1
movups %xmm1,0x10(%rdi)
movups %xmm0,(%rdi,%rax,1)
movslq 0x44(%rsp),%rax
cmp    $0x1,%rax
je     172f <lib3ds_matrix_inv+0x61f>
movss  0x4(%rdi),%xmm0
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x4(%rdi)
movss  %xmm0,(%rdi,%rax,4)
movss  0x14(%rdi),%xmm0
movss  0x10(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x14(%rdi)
movss  %xmm0,0x10(%rdi,%rax,4)
movss  0x24(%rdi),%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x24(%rdi)
movss  %xmm0,0x20(%rdi,%rax,4)
movss  0x34(%rdi),%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x34(%rdi)
movss  %xmm0,0x30(%rdi,%rax,4)
movslq 0x30(%rsp),%rax
test   %rax,%rax
je     1752 <lib3ds_matrix_inv+0x642>
shl    $0x4,%rax
movups (%rdi),%xmm0
movups (%rdi,%rax,1),%xmm1
xorps  0x8c5(%rip),%xmm1
movups %xmm1,(%rdi)
movups %xmm0,(%rdi,%rax,1)
movslq 0x40(%rsp),%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     17c5 <lib3ds_matrix_inv+0x6b5>
movss  (%rdi),%xmm0
movss  (%rdi,%rcx,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,(%rdi)
movss  %xmm0,(%rdi,%rcx,4)
movss  0x10(%rdi),%xmm0
movss  0x10(%rdi,%rcx,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x10(%rdi)
movss  %xmm0,0x10(%rdi,%rcx,4)
movss  0x20(%rdi),%xmm0
movss  0x20(%rdi,%rcx,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x20(%rdi)
movss  %xmm0,0x20(%rdi,%rcx,4)
movss  0x30(%rdi),%xmm0
movss  0x30(%rdi,%rcx,4),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x30(%rdi)
movss  %xmm0,0x30(%rdi,%rcx,4)
jmp    17c5 <lib3ds_matrix_inv+0x6b5>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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