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

/* Forward declarations */

/* Type definitions */
typedef size_t int32_t;

/* Variables and functions */
float fabsf(float);
void invert(int32_t order, float phi[], float psi[], float rc[]) {
  float r1;
  int32_t i;
  int32_t j;
  int32_t k;
  float v[10][10];
  for (j = 0; j < order; j++) {
    for (i = j; i < order; i++)
      v[j][i] = phi[i + j * order];
    for (k = 0; k < j; k++) {
      r1 = v[k][j] * v[k][k];
      for (i = j; i <= order; i++)
        v[j][i] -= v[k][i] * r1;
    }
    if (fabsf(v[j][j]) < 1.0e-10f) {
      for (i = j; i < order; i++)
        rc[i] = 0.0f;
      return;
    }
    rc[j] = psi[j];
    for (k = 0; k < j; k++)
      rc[j] -= rc[k] * v[k][j];
    v[j][j] = 1.0f / v[j][j];
    rc[j] *= v[j][j];
    r1 = ((rc[j]) <= (0.999f) ? (rc[j]) : (0.999f));
    rc[j] = ((r1) >= (-0.999f) ? (r1) : (-0.999f));
  }
}


x86 assembly (clang, -O0):
<invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    147a <invert+0x37a>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1189 <invert+0x89>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rdx
imul   -0x8(%rbp),%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1139 <invert+0x39>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    1261 <invert+0x161>
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x40(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x40(%rbp),%rcx
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     124b <invert+0x14b>
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x40(%rbp),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11dc <invert+0xdc>
jmp    1250 <invert+0x150>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1191 <invert+0x91>
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movaps 0xd90(%rip),%xmm0
pand   %xmm0,%xmm1
movss  0xd74(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    12d1 <invert+0x1d1>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    12cc <invert+0x1cc>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    129d <invert+0x19d>
jmp    147a <invert+0x37a>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    135f <invert+0x25f>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x40(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12f3 <invert+0x1f3>
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  0xc8e(%rip),%xmm0
divss  (%rax,%rcx,4),%xmm0
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
lea    -0x1d0(%rbp),%rax
imul   $0x28,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0xc33(%rip),%xmm0
ucomiss (%rax,%rcx,4),%xmm0
jb     13f5 <invert+0x2f5>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1d4(%rbp)
ff
jmp    140a <invert+0x30a>
movss  0xc07(%rip),%xmm0
movss  %xmm0,-0x1d4(%rbp)
ff
jmp    140a <invert+0x30a>
movss  -0x1d4(%rbp),%xmm0
ff
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movss  0xbe8(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     143f <invert+0x33f>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x1d8(%rbp)
ff
jmp    1454 <invert+0x354>
movss  0xbc5(%rip),%xmm0
movss  %xmm0,-0x1d8(%rbp)
ff
jmp    1454 <invert+0x354>
movss  -0x1d8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1123 <invert+0x23>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
mov    %rdx,0x40(%rsp)
mov    %rsi,0x48(%rsp)
test   %rdi,%rdi
je     147f <invert+0x35f>
mov    %rcx,%r15
mov    %rdi,%rbx
lea    0x0(,%rdi,4),%rax
mov    %rax,0x38(%rsp)
lea    0x4(,%rdi,4),%rax
mov    %rax,0x30(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x28(%rsp)
lea    0x74(%rsp),%r12
lea    0x60(%rsp),%rbp
xor    %r14d,%r14d
mov    %rbp,%rsi
mov    %r12,0x10(%rsp)
mov    %rdi,0x8(%rsp)
jmp    11e8 <invert+0xc8>
nopl   0x0(%rax)
mov    0x18(%rsp),%rsi
lea    (%rdi,%r14,4),%rax
movss  0xe73(%rip),%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,(%rax)
mulss  %xmm1,%xmm2
minss  0xe63(%rip),%xmm2
maxss  0xe5f(%rip),%xmm2
movss  %xmm2,(%r15,%r14,4)
add    $0x1,%r14
addq   $0xffffffffffffffff,0x8(%rsp)
addq   $0x4,0x10(%rsp)
add    $0x2c,%r12
add    $0x28,%rbp
add    $0x4,%rsi
cmp    %rbx,%r14
je     147f <invert+0x35f>
mov    %rsi,0x18(%rsp)
mov    %rbx,%r13
sub    %r14,%r13
imul   $0x2c,%r14,%rcx
lea    (%r14,%r14,4),%rax
lea    (%rsp,%rax,8),%rax
add    $0x60,%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%r14,4),%rax
mov    0x38(%rsp),%rdx
sub    %rax,%rdx
mov    0x30(%rsp),%rsi
imul   %r14,%rsi
add    0x48(%rsp),%rsi
mov    %rcx,(%rsp)
lea    (%rsp,%rcx,1),%rdi
add    $0x60,%rdi
call   1040 <memcpy@plt>
test   %r14,%r14
je     13a0 <invert+0x280>
mov    0x8(%rsp),%rax
and    $0xfffffffffffffff8,%rax
mov    (%rsp),%rcx
lea    (%rsp,%rcx,1),%r11
add    $0x64,%r11
mov    0x28(%rsp),%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %rcx,(%rsp)
lea    0x1(%r14),%r8
lea    (%rdx,%r14,4),%rdi
mov    %r13,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0x58(%rsp)
add    %r14,%rcx
add    $0x1,%rcx
mov    %rcx,0x50(%rsp)
lea    0x60(%rsp),%rdx
mov    0x10(%rsp),%rcx
xor    %r9d,%r9d
jmp    12b5 <invert+0x195>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x28,%rcx
add    $0x28,%rdx
cmp    %r14,%r9
je     13a0 <invert+0x280>
lea    (%r9,%r9,4),%rsi
lea    (%rsp,%rsi,8),%r10
add    $0x60,%r10
movss  (%r10,%r14,4),%xmm1
movss  (%r10,%r9,4),%xmm0
mulss  %xmm1,%xmm0
movss  (%rdi),%xmm2
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
cmp    %rbx,%r8
ja     12a0 <invert+0x180>
mov    %r8,%rsi
cmp    $0x8,%r13
jb     1370 <invert+0x250>
mov    0x28(%rsp),%rsi
lea    (%r10,%rsi,4),%rsi
cmp    %rsi,%r11
jae    130e <invert+0x1ee>
lea    (%r10,%r8,4),%r10
mov    %r8,%rsi
cmp    (%rsp),%r10
jb     1370 <invert+0x250>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,4),%xmm2
movups (%rcx,%rsi,4),%xmm3
movups -0x10(%r12,%rsi,4),%xmm4
movups (%r12,%rsi,4),%xmm5
mulps  %xmm1,%xmm2
subps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
subps  %xmm3,%xmm5
movups %xmm4,-0x10(%r12,%rsi,4)
movups %xmm5,(%r12,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rax
jne    1320 <invert+0x200>
mov    0x50(%rsp),%rsi
cmp    0x58(%rsp),%r13
je     12a0 <invert+0x180>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%rsi,4),%xmm1
movss  (%rdx,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x0(%rbp,%rsi,4)
add    $0x1,%rsi
cmp    %rbx,%rsi
jbe    1370 <invert+0x250>
jmp    12a0 <invert+0x180>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdi
movss  (%rdi,%r14,4),%xmm0
movaps %xmm0,%xmm1
andps  0xc4b(%rip),%xmm1
movss  0xc53(%rip),%xmm2
ucomiss %xmm1,%xmm2
ja     1468 <invert+0x348>
mov    0x40(%rsp),%rax
movss  (%rax,%r14,4),%xmm1
movss  %xmm1,(%r15,%r14,4)
test   %r14,%r14
je     1190 <invert+0x70>
cmp    $0x1,%r14
mov    0x18(%rsp),%rsi
jne    13f0 <invert+0x2d0>
xor    %eax,%eax
jmp    1437 <invert+0x317>
nop
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rsi,%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%r15,%rax,4),%xmm2
mulss  (%rdx),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%r15,%r14,4)
movss  0x4(%r15,%rax,4),%xmm2
mulss  0x28(%rdx),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%r15,%r14,4)
add    $0x2,%rax
add    $0x50,%rdx
cmp    %rax,%rcx
jne    1400 <invert+0x2e0>
test   $0x1,%r14b
je     1195 <invert+0x75>
movss  (%r15,%rax,4),%xmm2
lea    (%rax,%rax,4),%rax
lea    (%rsp,%rax,8),%rax
add    $0x60,%rax
mulss  (%rax,%r14,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%r15,%r14,4)
jmp    1195 <invert+0x75>
cmp    %rbx,%r14
jae    147f <invert+0x35f>
lea    (%r15,%r14,4),%rdi
shl    $0x2,%r13
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @invert(i64 %0, float* nocapture %1, float* nocapture %2, float* nocapture %3) {
%5 = bitcast float* %1 to i8*
%6 = alloca [10 x [10 x float]]
%7 = bitcast [10 x [10 x float]]* %6 to i8*
%8 = icmp eq i64 %0, 0
br i1 %8, label %161, label %9
9: ; preds = %4
%10 = shl i64 %0, 2
%11 = add i64 %10, 4
%12 = add nuw i64 %0, 1
br label %13
13: ; preds = %9, %151
%14 = phi i64 [ %159, %151 ], [ 0, %9 ]
%15 = sub i64 %0, %14
%16 = mul i64 %14, 11
%17 = add i64 %16, 1
%18 = getelementptr [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 0, i64 %17
%19 = getelementptr [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %14, i64 %12
%20 = add i64 %14, 1
%21 = mul i64 %14, -4
%22 = add i64 %10, %21
%23 = mul i64 %11, %14
%24 = getelementptr i8, i8* %5, i64 %23
%25 = mul i64 %14, 11
%26 = getelementptr [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 0, i64 %25
%27 = bitcast float* %26 to i8*
%28 = icmp eq i64 %14, 0
br i1 %28, label %98, label %29
29: ; preds = %13
%30 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %14, i64 %14
%31 = add i64 %14, 1
%32 = icmp ugt i64 %31, %0
%33 = icmp ult i64 %15, 8
%34 = and i64 %15, -8
%35 = add i64 %31, %34
%36 = icmp eq i64 %15, %34
br label %37
37: ; preds = %29, %95
%38 = phi i64 [ %96, %95 ], [ 0, %29 ]
%39 = getelementptr [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %20
%40 = getelementptr [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %12
%41 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %14
%42 = load float, float* %41
%43 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %38
%44 = load float, float* %43
%45 = fmul float %42, %44
%46 = load float, float* %30
%47 = fneg float %42
%48 = tail call float @llvm.fmuladd.f32(float %47, float %45, float %46)
store float %48, float* %30
br i1 %32, label %95, label %49
49: ; preds = %37
br i1 %33, label %83, label %50
50: ; preds = %49
%51 = icmp ult float* %18, %40
%52 = icmp ult float* %39, %19
%53 = and i1 %51, %52
br i1 %53, label %83, label %54
54: ; preds = %50
%55 = insertelement <4 x float> poison, float %45, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = insertelement <4 x float> poison, float %45, i64 0
%58 = shufflevector <4 x float> %57, <4 x float> poison, <4 x i32> zeroinitializer
br label %59
59: ; preds = %59, %54
%60 = phi i64 [ 0, %54 ], [ %80, %59 ]
%61 = add i64 %31, %60
%62 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %61
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = getelementptr inbounds float, float* %62, i64 4
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %14, i64 %61
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %68, i64 4
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = fneg <4 x float> %64
%75 = fneg <4 x float> %67
%76 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %74, <4 x float> %56, <4 x float> %70)
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %75, <4 x float> %58, <4 x float> %73)
%78 = bitcast float* %68 to <4 x float>*
store <4 x float> %76, <4 x float>* %78
%79 = bitcast float* %71 to <4 x float>*
store <4 x float> %77, <4 x float>* %79
%80 = add nuw i64 %60, 8
%81 = icmp eq i64 %80, %34
br i1 %81, label %82, label %59
82: ; preds = %59
br i1 %36, label %95, label %83
83: ; preds = %50, %49, %82
%84 = phi i64 [ %31, %50 ], [ %31, %49 ], [ %35, %82 ]
br label %85
85: ; preds = %83, %85
%86 = phi i64 [ %93, %85 ], [ %84, %83 ]
%87 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %38, i64 %86
%88 = load float, float* %87
%89 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %14, i64 %86
%90 = load float, float* %89
%91 = fneg float %88
%92 = tail call float @llvm.fmuladd.f32(float %91, float %45, float %90)
store float %92, float* %89
%93 = add i64 %86, 1
%94 = icmp ugt i64 %93, %0
br i1 %94, label %95, label %85
95: ; preds = %85, %82, %37
%96 = add nuw i64 %38, 1
%97 = icmp eq i64 %96, %14
br i1 %97, label %98, label %37
98: ; preds = %95, %13
%99 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %14, i64 %14
%100 = load float, float* %99
%101 = tail call float @llvm.fabs.f32(float %100)
%102 = fcmp olt float %101, 0x3DDB7CDFE0000000
br i1 %102, label %103, label %110
103: ; preds = %98
%104 = icmp ult i64 %14, %0
br i1 %104, label %105, label %161
105: ; preds = %103
%106 = getelementptr float, float* %3, i64 %14
%107 = bitcast float* %106 to i8*
%108 = sub i64 %0, %14
%109 = shl i64 %108, 2
br label %161
110: ; preds = %98
%111 = getelementptr inbounds float, float* %2, i64 %14
%112 = load float, float* %111
%113 = getelementptr inbounds float, float* %3, i64 %14
store float %112, float* %113
br i1 %28, label %151, label %114
114: ; preds = %110
%115 = and i64 %14, 1
%116 = icmp eq i64 %14, 1
br i1 %116, label %139, label %117
117: ; preds = %114
%118 = and i64 %14, -2
br label %119
119: ; preds = %119, %117
%120 = phi float [ %112, %117 ], [ %135, %119 ]
%121 = phi i64 [ 0, %117 ], [ %136, %119 ]
%122 = phi i64 [ 0, %117 ], [ %137, %119 ]
%123 = getelementptr inbounds float, float* %3, i64 %121
%124 = load float, float* %123
%125 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %121, i64 %14
%126 = load float, float* %125
%127 = fneg float %124
%128 = tail call float @llvm.fmuladd.f32(float %127, float %126, float %120)
store float %128, float* %113
%129 = or i64 %121, 1
%130 = getelementptr inbounds float, float* %3, i64 %129
%131 = load float, float* %130
%132 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %129, i64 %14
%133 = load float, float* %132
%134 = fneg float %131
%135 = tail call float @llvm.fmuladd.f32(float %134, float %133, float %128)
store float %135, float* %113
%136 = add nuw i64 %121, 2
%137 = add i64 %122, 2
%138 = icmp eq i64 %137, %118
br i1 %138, label %139, label %119
139: ; preds = %119, %114
%140 = phi float [ undef, %114 ], [ %135, %119 ]
%141 = phi float [ %112, %114 ], [ %135, %119 ]
%142 = phi i64 [ 0, %114 ], [ %136, %119 ]
%143 = icmp eq i64 %115, 0
br i1 %143, label %151, label %144
144: ; preds = %139
%145 = getelementptr inbounds float, float* %3, i64 %142
%146 = load float, float* %145
%147 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %6, i64 0, i64 %142, i64 %14
%148 = load float, float* %147
%149 = fneg float %146
%150 = tail call float @llvm.fmuladd.f32(float %149, float %148, float %141)
store float %150, float* %113
br label %151
151: ; preds = %144, %139, %110
%152 = phi float [ %112, %110 ], [ %140, %139 ], [ %150, %144 ]
%153 = fdiv float 1.000000e+00, %100
store float %153, float* %99
%154 = fmul float %153, %152
%155 = fcmp ole float %154, 0x3FEFF7CEE0000000
%156 = select i1 %155, float %154, float 0x3FEFF7CEE0000000
%157 = fcmp oge float %156, 0xBFEFF7CEE0000000
%158 = select i1 %157, float %156, float 0xBFEFF7CEE0000000
store float %158, float* %113
%159 = add nuw i64 %14, 1
%160 = icmp eq i64 %159, %0
br i1 %160, label %161, label %13
161: ; preds = %151, %105, %4, %103
ret void
}