void invert_affine(float affineIn[3][4], float affineOut[3][4]) {
  int a, b, c, d, i, j;
  double temp, temp2, det = 0.0;
  for (i = 0; i < 3; ++i) {
    temp = 1.0;
    temp2 = 1.0;
    affineOut[i][3] = 0.0f;
    for (j = 0; j < 3; ++j) {
      temp *= affineIn[j][(i + j) % 3];
      temp2 *= affineIn[j][(i - j + 3) % 3];
    }
    det += temp - temp2;
  }
  for (i = 0; i < 3; ++i) {
    a = (i + 1) % 3;
    b = (i + 2) % 3;
    for (j = 0; j < 3; ++j) {
      c = (j + 1) % 3;
      d = (j + 2) % 3;
      affineOut[j][i] =
          affineIn[a][c] * affineIn[b][d] - affineIn[a][d] * affineIn[b][c];
    }
  }
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < 3; ++j) {
      affineOut[i][j] /= det;
    }
  }
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < 3; ++j) {
      affineOut[i][3] -= affineOut[i][j] * affineIn[j][3];
    }
  }
}


x86 assembly (clang, -O0):
<invert_affine>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1210 <invert_affine+0x110>
movsd  0xed3(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xec6(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    11ee <invert_affine+0xee>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x50(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
add    $0x3,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x48(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115d <invert_affine+0x5d>
movsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <invert_affine+0x1b>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1324 <invert_affine+0x224>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x18(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1311 <invert_affine+0x211>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    124a <invert_affine+0x14a>
jmp    1316 <invert_affine+0x216>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1217 <invert_affine+0x117>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1395 <invert_affine+0x295>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1382 <invert_affine+0x282>
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    133c <invert_affine+0x23c>
jmp    1387 <invert_affine+0x287>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    132b <invert_affine+0x22b>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1433 <invert_affine+0x333>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1420 <invert_affine+0x320>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ad <invert_affine+0x2ad>
jmp    1425 <invert_affine+0x325>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    139c <invert_affine+0x29c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert_affine>:
movl   $0x0,0xc(%rsi)
movss  (%rdi),%xmm0
movss  0x14(%rdi),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movss  0x18(%rdi),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
movss  0x28(%rdi),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
movss  0x24(%rdi),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
xorpd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movl   $0x0,0x1c(%rsi)
movss  0x4(%rdi),%xmm0
movss  0x10(%rdi),%xmm1
cvtss2sd %xmm0,%xmm0
movss  0x18(%rdi),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
cvtss2sd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
movss  0x20(%rdi),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movss  0x28(%rdi),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm4,%xmm0
subsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movl   $0x0,0x2c(%rsi)
movss  0x8(%rdi),%xmm0
movss  0x10(%rdi),%xmm2
cvtss2sd %xmm0,%xmm0
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
mulsd  %xmm0,%xmm3
movss  0x14(%rdi),%xmm10
xorps  %xmm4,%xmm4
cvtss2sd %xmm10,%xmm4
mulsd  %xmm0,%xmm4
movss  0x24(%rdi),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
mulsd  %xmm3,%xmm0
movss  0x20(%rdi),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
mulss  0x18(%rdi),%xmm5
mulss  0x28(%rdi),%xmm10
subss  %xmm5,%xmm10
movss  %xmm10,(%rsi)
movss  0x18(%rdi),%xmm9
movss  0x28(%rdi),%xmm1
mulss  0x10(%rdi),%xmm1
mulss  0x20(%rdi),%xmm9
subss  %xmm1,%xmm9
movss  %xmm9,0x10(%rsi)
movss  0x10(%rdi),%xmm8
movss  0x20(%rdi),%xmm1
mulss  0x14(%rdi),%xmm1
mulss  0x24(%rdi),%xmm8
subss  %xmm1,%xmm8
movss  %xmm8,0x20(%rsi)
movss  0x4(%rdi),%xmm1
movss  0x24(%rdi),%xmm6
mulss  0x28(%rdi),%xmm1
mulss  0x8(%rdi),%xmm6
subss  %xmm1,%xmm6
movss  %xmm6,0x4(%rsi)
movss  0x8(%rdi),%xmm1
movss  0x28(%rdi),%xmm5
mulss  0x20(%rdi),%xmm1
mulss  (%rdi),%xmm5
subss  %xmm1,%xmm5
movss  %xmm5,0x14(%rsi)
movss  (%rdi),%xmm1
movss  0x20(%rdi),%xmm4
mulss  0x24(%rdi),%xmm1
mulss  0x4(%rdi),%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,0x24(%rsi)
movss  0x4(%rdi),%xmm3
movss  0x14(%rdi),%xmm1
mulss  0x8(%rdi),%xmm1
mulss  0x18(%rdi),%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,0x8(%rsi)
movss  0x8(%rdi),%xmm1
movss  0x18(%rdi),%xmm7
mulss  (%rdi),%xmm7
mulss  0x10(%rdi),%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,0x18(%rsi)
movss  (%rdi),%xmm7
movss  0x10(%rdi),%xmm2
mulss  0x4(%rdi),%xmm2
mulss  0x14(%rdi),%xmm7
subss  %xmm2,%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm10,%xmm2
divsd  %xmm0,%xmm2
xorps  %xmm10,%xmm10
cvtsd2ss %xmm2,%xmm10
movss  %xmm10,(%rsi)
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
divsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
divsd  %xmm0,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm2,0x4(%rsi)
movss  %xmm3,0x8(%rsi)
xorps  %xmm6,%xmm6
cvtss2sd %xmm9,%xmm6
divsd  %xmm0,%xmm6
xorps  %xmm9,%xmm9
cvtsd2ss %xmm6,%xmm9
movss  %xmm9,0x10(%rsi)
cvtss2sd %xmm5,%xmm5
divsd  %xmm0,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm5,0x14(%rsi)
cvtss2sd %xmm1,%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm6,%xmm6
cvtsd2ss %xmm1,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm8,%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm8,%xmm8
cvtsd2ss %xmm1,%xmm8
movss  %xmm6,0x18(%rsi)
movss  %xmm8,0x20(%rsi)
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm4,%xmm4
cvtsd2ss %xmm1,%xmm4
movss  %xmm4,0x24(%rsi)
xorps  %xmm1,%xmm1
cvtss2sd %xmm7,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x28(%rsi)
movss  0xc(%rsi),%xmm1
mulss  0xc(%rdi),%xmm10
subss  %xmm10,%xmm1
movss  %xmm1,0xc(%rsi)
mulss  0x1c(%rdi),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0xc(%rsi)
mulss  0x2c(%rdi),%xmm3
subss  %xmm3,%xmm1
movss  %xmm1,0xc(%rsi)
movss  0x1c(%rsi),%xmm1
mulss  0xc(%rdi),%xmm9
subss  %xmm9,%xmm1
movss  %xmm1,0x1c(%rsi)
mulss  0x1c(%rdi),%xmm5
subss  %xmm5,%xmm1
movss  %xmm1,0x1c(%rsi)
mulss  0x2c(%rdi),%xmm6
subss  %xmm6,%xmm1
movss  %xmm1,0x1c(%rsi)
movss  0x2c(%rsi),%xmm1
mulss  0xc(%rdi),%xmm8
subss  %xmm8,%xmm1
movss  %xmm1,0x2c(%rsi)
mulss  0x1c(%rdi),%xmm4
subss  %xmm4,%xmm1
movss  %xmm1,0x2c(%rsi)
mulss  0x2c(%rdi),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,0x2c(%rsi)
ret

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

LLVM IR (-O2):
define void @invert_affine([4 x float]* nocapture %0, [4 x float]* nocapture %1) {
%3 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 3
store float 0.000000e+00, float* %3
%4 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 0
%5 = load float, float* %4
%6 = fpext float %5 to double
%7 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 1
%8 = load float, float* %7
%9 = fpext float %8 to double
%10 = fmul double %6, %9
%11 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 2
%12 = load float, float* %11
%13 = fpext float %12 to double
%14 = fmul double %6, %13
%15 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 2
%16 = load float, float* %15
%17 = fpext float %16 to double
%18 = fmul double %10, %17
%19 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 1
%20 = load float, float* %19
%21 = fpext float %20 to double
%22 = fmul double %14, %21
%23 = fsub double %18, %22
%24 = fadd double %23, 0.000000e+00
%25 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 3
store float 0.000000e+00, float* %25
%26 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 1
%27 = load float, float* %26
%28 = fpext float %27 to double
%29 = load float, float* %11
%30 = fpext float %29 to double
%31 = fmul double %28, %30
%32 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 0
%33 = load float, float* %32
%34 = fpext float %33 to double
%35 = fmul double %28, %34
%36 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 0
%37 = load float, float* %36
%38 = fpext float %37 to double
%39 = fmul double %31, %38
%40 = load float, float* %15
%41 = fpext float %40 to double
%42 = fmul double %35, %41
%43 = fsub double %39, %42
%44 = fadd double %24, %43
%45 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 3
store float 0.000000e+00, float* %45
%46 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 2
%47 = load float, float* %46
%48 = fpext float %47 to double
%49 = load float, float* %32
%50 = fpext float %49 to double
%51 = fmul double %48, %50
%52 = load float, float* %7
%53 = fpext float %52 to double
%54 = fmul double %48, %53
%55 = load float, float* %19
%56 = fpext float %55 to double
%57 = fmul double %51, %56
%58 = load float, float* %36
%59 = fpext float %58 to double
%60 = fmul double %54, %59
%61 = fsub double %57, %60
%62 = load float, float* %15
%63 = load float, float* %11
%64 = fneg float %63
%65 = fmul float %55, %64
%66 = tail call float @llvm.fmuladd.f32(float %52, float %62, float %65)
%67 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 0
store float %66, float* %67
%68 = load float, float* %11
%69 = load float, float* %36
%70 = load float, float* %32
%71 = load float, float* %15
%72 = fneg float %70
%73 = fmul float %71, %72
%74 = tail call float @llvm.fmuladd.f32(float %68, float %69, float %73)
%75 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 0
store float %74, float* %75
%76 = load float, float* %32
%77 = load float, float* %19
%78 = load float, float* %7
%79 = load float, float* %36
%80 = fneg float %78
%81 = fmul float %79, %80
%82 = tail call float @llvm.fmuladd.f32(float %76, float %77, float %81)
%83 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 0
store float %82, float* %83
%84 = load float, float* %19
%85 = load float, float* %46
%86 = load float, float* %15
%87 = load float, float* %26
%88 = fneg float %86
%89 = fmul float %87, %88
%90 = tail call float @llvm.fmuladd.f32(float %84, float %85, float %89)
%91 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 1
store float %90, float* %91
%92 = load float, float* %15
%93 = load float, float* %4
%94 = load float, float* %36
%95 = load float, float* %46
%96 = fneg float %94
%97 = fmul float %95, %96
%98 = tail call float @llvm.fmuladd.f32(float %92, float %93, float %97)
%99 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 1
store float %98, float* %99
%100 = load float, float* %36
%101 = load float, float* %26
%102 = load float, float* %19
%103 = load float, float* %4
%104 = fneg float %102
%105 = fmul float %103, %104
%106 = tail call float @llvm.fmuladd.f32(float %100, float %101, float %105)
%107 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 1
store float %106, float* %107
%108 = load float, float* %26
%109 = load float, float* %11
%110 = load float, float* %46
%111 = load float, float* %7
%112 = fneg float %110
%113 = fmul float %111, %112
%114 = tail call float @llvm.fmuladd.f32(float %108, float %109, float %113)
%115 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 2
store float %114, float* %115
%116 = load float, float* %46
%117 = load float, float* %32
%118 = load float, float* %4
%119 = load float, float* %11
%120 = fneg float %118
%121 = fmul float %119, %120
%122 = tail call float @llvm.fmuladd.f32(float %116, float %117, float %121)
%123 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 2
store float %122, float* %123
%124 = load float, float* %4
%125 = load float, float* %7
%126 = load float, float* %26
%127 = load float, float* %32
%128 = fneg float %126
%129 = fmul float %127, %128
%130 = tail call float @llvm.fmuladd.f32(float %124, float %125, float %129)
%131 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 2
%132 = fadd double %44, %61
%133 = fpext float %66 to double
%134 = fdiv double %133, %132
%135 = fptrunc double %134 to float
store float %135, float* %67
%136 = fpext float %90 to double
%137 = fdiv double %136, %132
%138 = fptrunc double %137 to float
store float %138, float* %91
%139 = fpext float %114 to double
%140 = fdiv double %139, %132
%141 = fptrunc double %140 to float
store float %141, float* %115
%142 = fpext float %74 to double
%143 = fdiv double %142, %132
%144 = fptrunc double %143 to float
store float %144, float* %75
%145 = fpext float %98 to double
%146 = fdiv double %145, %132
%147 = fptrunc double %146 to float
store float %147, float* %99
%148 = fpext float %122 to double
%149 = fdiv double %148, %132
%150 = fptrunc double %149 to float
store float %150, float* %123
%151 = fpext float %82 to double
%152 = fdiv double %151, %132
%153 = fptrunc double %152 to float
store float %153, float* %83
%154 = fpext float %106 to double
%155 = fdiv double %154, %132
%156 = fptrunc double %155 to float
store float %156, float* %107
%157 = fpext float %130 to double
%158 = fdiv double %157, %132
%159 = fptrunc double %158 to float
store float %159, float* %131
%160 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 3
%161 = load float, float* %160
%162 = load float, float* %3
%163 = fneg float %135
%164 = tail call float @llvm.fmuladd.f32(float %163, float %161, float %162)
store float %164, float* %3
%165 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 3
%166 = load float, float* %165
%167 = fneg float %138
%168 = tail call float @llvm.fmuladd.f32(float %167, float %166, float %164)
store float %168, float* %3
%169 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 3
%170 = load float, float* %169
%171 = fneg float %141
%172 = tail call float @llvm.fmuladd.f32(float %171, float %170, float %168)
store float %172, float* %3
%173 = load float, float* %160
%174 = load float, float* %25
%175 = fneg float %144
%176 = tail call float @llvm.fmuladd.f32(float %175, float %173, float %174)
store float %176, float* %25
%177 = load float, float* %165
%178 = fneg float %147
%179 = tail call float @llvm.fmuladd.f32(float %178, float %177, float %176)
store float %179, float* %25
%180 = load float, float* %169
%181 = fneg float %150
%182 = tail call float @llvm.fmuladd.f32(float %181, float %180, float %179)
store float %182, float* %25
%183 = load float, float* %160
%184 = load float, float* %45
%185 = fneg float %153
%186 = tail call float @llvm.fmuladd.f32(float %185, float %183, float %184)
store float %186, float* %45
%187 = load float, float* %165
%188 = fneg float %156
%189 = tail call float @llvm.fmuladd.f32(float %188, float %187, float %186)
store float %189, float* %45
%190 = load float, float* %169
%191 = fneg float %159
%192 = tail call float @llvm.fmuladd.f32(float %191, float %190, float %189)
store float %192, float* %45
ret void
}