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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double ccp4_pow_ii(double, int);
double fabs(double);
float invert4matrix(const float a[4][4], float ai[4][4]) {
  double c[4][4], d;
  int i, j;
  double x[3][3];
  int i1, j1, i2;
  double am, q;
  int ii, jj;
  for (ii = 0; ii < 4; ++ii) {
    for (jj = 0; jj < 4; ++jj) {
      ai[ii][jj] = 0.0;
      i = -1;
      for (i1 = 0; i1 < 4; ++i1) {
        if (i1 != ii) {
          ++i;
          j = -1;
          for (j1 = 0; j1 < 4; ++j1) {
            if (j1 != jj) {
              ++j;
              x[i][j] = a[i1][j1];
            }
          }
        }
      }
      am = x[0][0] * x[1][1] * x[2][2] - x[0][0] * x[1][2] * x[2][1] +
           x[0][1] * x[1][2] * x[2][0] - x[0][1] * x[1][0] * x[2][2] +
           x[0][2] * x[1][0] * x[2][1] - x[0][2] * x[1][1] * x[2][0];
      i2 = ii + jj;
      c[ii][jj] = ccp4_pow_ii(-1.0, i2) * am;
    }
  }
  d = 0.0;
  for (i = 0; i < 4; ++i) {
    d = a[i][0] * c[i][0] + d;
  }
  if (fabs(d) > 1.0e-30) {
    q = 1.0 / d;
    for (i = 0; i < 4; ++i) {
      for (j = 0; j < 4; ++j) {
        ai[i][j] = (float)(c[j][i] * q);
      }
    }
  } else {
    return 0.0;
  }
  return ((float)d);
}


x86 assembly (clang, -O0):
<invert4matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x124(%rbp)
cmpl   $0x4,-0x124(%rbp)
jge    13f0 <invert4matrix+0x2e0>
movl   $0x0,-0x128(%rbp)
cmpl   $0x4,-0x128(%rbp)
jge    13d7 <invert4matrix+0x2c7>
mov    -0x18(%rbp),%rax
movslq -0x124(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x128(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0xffffffff,-0xac(%rbp)
ff ff ff
movl   $0x0,-0x104(%rbp)
cmpl   $0x4,-0x104(%rbp)
jge    1270 <invert4matrix+0x160>
mov    -0x104(%rbp),%eax
cmp    -0x124(%rbp),%eax
je     1257 <invert4matrix+0x147>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
movl   $0xffffffff,-0xb0(%rbp)
ff ff ff
movl   $0x0,-0x108(%rbp)
cmpl   $0x4,-0x108(%rbp)
jge    1252 <invert4matrix+0x142>
mov    -0x108(%rbp),%eax
cmp    -0x128(%rbp),%eax
je     1239 <invert4matrix+0x129>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x104(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x108(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0xac(%rbp),%rcx
lea    -0x100(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    123e <invert4matrix+0x12e>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    11c8 <invert4matrix+0xb8>
jmp    1257 <invert4matrix+0x147>
jmp    125c <invert4matrix+0x14c>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1186 <invert4matrix+0x76>
movsd  -0x100(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x124(%rbp),%eax
add    -0x128(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%edi
movsd  0xc7b(%rip),%xmm0
call   1030 <ccp4_pow_ii@plt>
mulsd  -0x118(%rbp),%xmm0
ff
movslq -0x124(%rbp),%rcx
lea    -0xa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x128(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1144 <invert4matrix+0x34>
jmp    13dc <invert4matrix+0x2cc>
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    112d <invert4matrix+0x1d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0xac(%rbp)
cmpl   $0x4,-0xac(%rbp)
jge    1471 <invert4matrix+0x361>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0xac(%rbp),%rcx
lea    -0xa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1405 <invert4matrix+0x2f5>
movsd  -0xa8(%rbp),%xmm0
ff
movaps 0xba0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xb74(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1559 <invert4matrix+0x449>
movsd  0xb6a(%rip),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0xac(%rbp)
cmpl   $0x4,-0xac(%rbp)
jge    1554 <invert4matrix+0x444>
movl   $0x0,-0xb0(%rbp)
cmpl   $0x4,-0xb0(%rbp)
jge    153b <invert4matrix+0x42b>
movslq -0xb0(%rbp),%rcx
lea    -0xa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x120(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xac(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    14cf <invert4matrix+0x3bf>
jmp    1540 <invert4matrix+0x430>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    14b8 <invert4matrix+0x3a8>
jmp    1566 <invert4matrix+0x456>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1577 <invert4matrix+0x467>
movsd  -0xa8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert4matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
lea    0x50(%rsp),%r15
xor    %r12d,%r12d
mov    %rsi,%r13
jmp    1156 <invert4matrix+0x46>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0x10,%r13
add    $0x20,%r15
cmp    $0x4,%r12
je     146d <invert4matrix+0x35d>
xor    %ebp,%ebp
jmp    1227 <invert4matrix+0x117>
nopl   (%rax)
movss  0x3c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %edx,%ecx
lea    (%rax,%rax,2),%rax
lea    (%rsp,%rax,8),%rax
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x20(%rsp),%xmm0
movsd  (%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
movsd  0x28(%rsp),%xmm4
movsd  0x38(%rsp),%xmm5
movapd %xmm4,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
mulsd  %xmm5,%xmm6
mulsd  %xmm3,%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm2,%xmm4
movsd  0x30(%rsp),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm1,%xmm4
movsd  0x18(%rsp),%xmm7
mulsd  %xmm7,%xmm2
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm4
movsd  0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm4,%xmm7
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm0,%xmm7
movsd  %xmm7,0x48(%rsp)
lea    (%r12,%rbp,1),%edi
movsd  0xdf8(%rip),%xmm0
call   1030 <ccp4_pow_ii@plt>
mulsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    $0x4,%rbp
je     1140 <invert4matrix+0x30>
movl   $0x0,0x0(%r13,%rbp,4)
test   %r12,%r12
je     1260 <invert4matrix+0x150>
test   %rbp,%rbp
je     1270 <invert4matrix+0x160>
xor    %ecx,%ecx
movss  (%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    $0x1,%eax
cmp    $0x1,%rbp
jne    1272 <invert4matrix+0x162>
jmp    128a <invert4matrix+0x17a>
cs nopw 0x0(%rax,%rax,1)
mov    $0xffffffff,%eax
jmp    12bb <invert4matrix+0x1ab>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
movss  0x4(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %eax,%ecx
movsd  %xmm0,(%rsp,%rcx,8)
mov    %eax,%ecx
cmp    $0x2,%rbp
je     12a8 <invert4matrix+0x198>
xor    %eax,%eax
movss  0x8(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %ecx,%edx
movsd  %xmm0,0x8(%rsp,%rdx,8)
cmp    $0x3,%rbp
je     12bb <invert4matrix+0x1ab>
add    $0x1,%ecx
mov    %ecx,%eax
movss  0xc(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %eax,%eax
movsd  %xmm0,0x8(%rsp,%rax,8)
xor    %eax,%eax
cmp    $0x1,%r12
je     1350 <invert4matrix+0x240>
add    $0x1,%eax
movslq %eax,%rcx
test   %rbp,%rbp
je     12f1 <invert4matrix+0x1e1>
xor    %edx,%edx
movss  0x10(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
lea    (%rcx,%rcx,2),%rsi
movsd  %xmm0,(%rsp,%rsi,8)
mov    $0x1,%esi
cmp    $0x1,%rbp
jne    12f3 <invert4matrix+0x1e3>
jmp    1313 <invert4matrix+0x203>
xor    %esi,%esi
movss  0x14(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %esi,%edx
lea    (%rcx,%rcx,2),%rdi
lea    (%rsp,%rdi,8),%rdi
movsd  %xmm0,(%rdi,%rdx,8)
mov    %esi,%edx
cmp    $0x2,%rbp
je     1337 <invert4matrix+0x227>
movss  0x18(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %edx,%esi
lea    (%rcx,%rcx,2),%rdi
lea    (%rsp,%rdi,8),%rdi
movsd  %xmm0,0x8(%rdi,%rsi,8)
cmp    $0x3,%rbp
je     1350 <invert4matrix+0x240>
add    $0x1,%edx
mov    %edx,%esi
movss  0x1c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %esi,%edx
lea    (%rcx,%rcx,2),%rcx
lea    (%rsp,%rcx,8),%rcx
movsd  %xmm0,0x8(%rcx,%rdx,8)
cmp    $0x2,%r12
je     13e5 <invert4matrix+0x2d5>
add    $0x1,%eax
movslq %eax,%rcx
test   %rbp,%rbp
je     1386 <invert4matrix+0x276>
xor    %edx,%edx
movss  0x20(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
lea    (%rcx,%rcx,2),%rsi
movsd  %xmm0,(%rsp,%rsi,8)
mov    $0x1,%esi
cmp    $0x1,%rbp
jne    1388 <invert4matrix+0x278>
jmp    13a8 <invert4matrix+0x298>
xor    %esi,%esi
movss  0x24(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %esi,%edx
lea    (%rcx,%rcx,2),%rdi
lea    (%rsp,%rdi,8),%rdi
movsd  %xmm0,(%rdi,%rdx,8)
mov    %esi,%edx
cmp    $0x2,%rbp
je     13cc <invert4matrix+0x2bc>
movss  0x28(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %edx,%esi
lea    (%rcx,%rcx,2),%rdi
lea    (%rsp,%rdi,8),%rdi
movsd  %xmm0,0x8(%rdi,%rsi,8)
cmp    $0x3,%rbp
je     13e5 <invert4matrix+0x2d5>
add    $0x1,%edx
mov    %edx,%esi
movss  0x2c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %esi,%edx
lea    (%rcx,%rcx,2),%rcx
lea    (%rsp,%rcx,8),%rcx
movsd  %xmm0,0x8(%rcx,%rdx,8)
cmp    $0x3,%r12
je     1179 <invert4matrix+0x69>
add    $0x1,%eax
cltq
test   %rbp,%rbp
je     141a <invert4matrix+0x30a>
xor    %ecx,%ecx
movss  0x30(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
lea    (%rax,%rax,2),%rdx
movsd  %xmm0,(%rsp,%rdx,8)
mov    $0x1,%edx
cmp    $0x1,%rbp
jne    141c <invert4matrix+0x30c>
jmp    1440 <invert4matrix+0x330>
xor    %edx,%edx
movss  0x34(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %edx,%ecx
lea    (%rax,%rax,2),%rsi
lea    (%rsp,%rsi,8),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
mov    %edx,%ecx
cmp    $0x2,%rbp
je     1160 <invert4matrix+0x50>
movss  0x38(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %ecx,%edx
lea    (%rax,%rax,2),%rsi
lea    (%rsp,%rsi,8),%rsi
movsd  %xmm0,0x8(%rsi,%rdx,8)
cmp    $0x3,%rbp
je     1179 <invert4matrix+0x69>
add    $0x1,%ecx
mov    %ecx,%edx
jmp    1160 <invert4matrix+0x50>
movss  (%rbx),%xmm0
movss  0x10(%rbx),%xmm1
cvtss2sd %xmm0,%xmm0
movsd  0x50(%rsp),%xmm2
movsd  0x70(%rsp),%xmm3
mulsd  %xmm2,%xmm0
xorpd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
movss  0x20(%rbx),%xmm1
xorps  %xmm6,%xmm6
cvtss2sd %xmm1,%xmm6
movsd  0x90(%rsp),%xmm4
mulsd  %xmm4,%xmm6
addsd  %xmm0,%xmm6
movss  0x30(%rbx),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xb0(%rsp),%xmm5
mulsd  %xmm5,%xmm1
addsd  %xmm6,%xmm1
movapd 0xb3d(%rip),%xmm6
andpd  %xmm1,%xmm6
xorps  %xmm0,%xmm0
ucomisd 0xb16(%rip),%xmm6
jbe    15de <invert4matrix+0x4ce>
movsd  0xb10(%rip),%xmm0
divsd  %xmm1,%xmm0
unpcklpd %xmm0,%xmm0
unpcklpd %xmm5,%xmm4
unpcklpd %xmm3,%xmm2
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm4,%xmm3
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm3,%xmm2
movupd %xmm2,(%r14)
movupd 0x58(%rsp),%xmm2
movhpd 0x78(%rsp),%xmm2
movsd  0x98(%rsp),%xmm3
movhpd 0xb8(%rsp),%xmm3
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm3
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm3,%xmm2
movupd %xmm2,0x10(%r14)
movapd 0x60(%rsp),%xmm2
movhpd 0x80(%rsp),%xmm2
movsd  0xa0(%rsp),%xmm3
movhpd 0xc0(%rsp),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm3,%xmm2
movupd %xmm2,0x20(%r14)
movupd 0x68(%rsp),%xmm2
movhpd 0x88(%rsp),%xmm2
movsd  0xa8(%rsp),%xmm3
movhpd 0xc8(%rsp),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm0
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm0,%xmm2
movupd %xmm2,0x30(%r14)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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