#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 */
float fabs(float);
void invert(float *phi, float *psi, float *rc) {
  float save;
  long i, j, k;
  float v[100];
  for (j = 0; j < 10; ++j) {
    for (i = j; i < 10; ++i) {
      v[i + j * 10] = phi[i + j * 10];
    }
    for (k = 0; k < j; ++k) {
      save = v[j + k * 10] * v[k + k * 10];
      for (i = j; i < 10; ++i) {
        v[i + j * 10] -= v[i + k * 10] * save;
      }
    }
    if ((fabs(v[j + j * 10])) < 1e-10f) {
      goto L100;
    }
    rc[j] = psi[j];
    for (k = 0; k < j; ++k) {
      rc[j] -= rc[k] * v[j + k * 10];
    }
    v[j + j * 10] = 1.f / v[j + j * 10];
    rc[j] *= v[j + j * 10];
    rc[j] = ((((rc[j]) <= (.999f) ? (rc[j]) : (.999f))) >= (-.999f)
                 ? (((rc[j]) <= (.999f) ? (rc[j]) : (.999f)))
                 : (-.999f));
  }
  return;
L100:
  for (i = j; i < 10; ++i) {
    rc[i] = 0.f;
  }
}


x86 assembly (clang, -O0):
<invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x30(%rbp)
cmpq   $0xa,-0x30(%rbp)
jge    1467 <invert+0x357>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0xa,-0x28(%rbp)
jge    1188 <invert+0x78>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   $0xa,-0x30(%rbp),%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  %xmm0,-0x1d0(%rbp,%rax,4)
ff ff
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1142 <invert+0x32>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1255 <invert+0x145>
mov    -0x30(%rbp),%rax
imul   $0xa,-0x38(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x38(%rbp),%rax
imul   $0xa,-0x38(%rbp),%rcx
add    %rcx,%rax
mulss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0xa,-0x28(%rbp)
jge    123f <invert+0x12f>
mov    -0x28(%rbp),%rax
imul   $0xa,-0x38(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
movss  -0x1c(%rbp),%xmm2
mov    -0x28(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1d0(%rbp,%rax,4)
ff ff
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11d5 <invert+0xc5>
jmp    1244 <invert+0x134>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1190 <invert+0x80>
mov    -0x30(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movss  0xd86(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1288 <invert+0x178>
jmp    146c <invert+0x35c>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1313 <invert+0x203>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
imul   $0xa,-0x38(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x18(%rbp),%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    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12aa <invert+0x19a>
mov    -0x30(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  0xce1(%rip),%xmm0
divss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x30(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  %xmm0,-0x1d0(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%rax
imul   $0xa,-0x30(%rbp),%rcx
add    %rcx,%rax
movss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0xc88(%rip),%xmm0
ucomiss (%rax,%rcx,4),%xmm0
jb     13a0 <invert+0x290>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1d4(%rbp)
ff
jmp    13b5 <invert+0x2a5>
movss  0xc5c(%rip),%xmm0
movss  %xmm0,-0x1d4(%rbp)
ff
jmp    13b5 <invert+0x2a5>
movss  -0x1d4(%rbp),%xmm0
ff
movss  0xc47(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     142c <invert+0x31c>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0xc26(%rip),%xmm0
ucomiss (%rax,%rcx,4),%xmm0
jb     1402 <invert+0x2f2>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1d8(%rbp)
ff
jmp    1417 <invert+0x307>
movss  0xbfa(%rip),%xmm0
movss  %xmm0,-0x1d8(%rbp)
ff
jmp    1417 <invert+0x307>
movss  -0x1d8(%rbp),%xmm0
ff
movss  %xmm0,-0x1dc(%rbp)
ff
jmp    1441 <invert+0x331>
movss  0xbd8(%rip),%xmm0
movss  %xmm0,-0x1dc(%rbp)
ff
jmp    1441 <invert+0x331>
movss  -0x1dc(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    112f <invert+0x1f>
jmp    14a0 <invert+0x390>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0xa,-0x28(%rbp)
jge    14a0 <invert+0x390>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1474 <invert+0x364>
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %rdx,%r13
mov    %rsi,(%rsp)
mov    %rdi,0x8(%rsp)
lea    0x10(%rsp),%r14
xor    %ebx,%ebx
mov    %r14,%rbp
jmp    116a <invert+0x4a>
nopl   0x0(%rax)
movss  %xmm0,(%rax)
add    $0x1,%rbx
add    $0x2c,%rbp
add    $0x4,%r14
cmp    $0xa,%rbx
je     138b <invert+0x26b>
imul   $0x2c,%rbx,%rsi
lea    (%rsp,%rsi,1),%r12
add    $0x10,%r12
lea    0x0(,%rbx,4),%r15
mov    $0x28,%edx
sub    %r15,%rdx
add    0x8(%rsp),%rsi
mov    %r12,%rdi
call   1040 <memcpy@plt>
test   %rbx,%rbx
je     1260 <invert+0x140>
mov    %rbx,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %r14,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rdx,4),%rsi
lea    (%rbx,%rsi,2),%rsi
movss  0x10(%rsp,%rsi,4),%xmm0
imul   $0x2c,%rdx,%rsi
mulss  0x10(%rsp,%rsi,1),%xmm0
mov    $0xffffffffffffffff,%rsi
nop
movss  0x4(%rbp,%rsi,4),%xmm1
movss  0x4(%rax,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbp,%rsi,4)
lea    (%rbx,%rsi,1),%rdi
add    $0x1,%rdi
add    $0x1,%rsi
cmp    $0x9,%rdi
jb     11d0 <invert+0xb0>
add    $0x1,%rdx
add    $0x28,%rax
cmp    %rbx,%rdx
jne    11b0 <invert+0x90>
movss  (%r12),%xmm0
movaps %xmm0,%xmm1
andps  0xde7(%rip),%xmm1
movss  0xdef(%rip),%xmm2
ucomiss %xmm1,%xmm2
ja     136b <invert+0x24b>
mov    (%rsp),%rax
movss  (%rax,%rbx,4),%xmm1
lea    0x0(,%rbx,4),%rax
add    %r13,%rax
movss  %xmm1,0x0(%r13,%rbx,4)
test   %rbx,%rbx
je     12f9 <invert+0x1d9>
cmp    $0x1,%rbx
jne    1297 <invert+0x177>
xor    %edx,%edx
jmp    12d4 <invert+0x1b4>
nopl   0x0(%rax,%rax,1)
movss  (%r12),%xmm0
movaps %xmm0,%xmm1
andps  0xd90(%rip),%xmm1
movss  0xd98(%rip),%xmm2
ucomiss %xmm1,%xmm2
ja     1371 <invert+0x251>
mov    (%rsp),%rax
movss  (%rax,%rbx,4),%xmm1
lea    0x0(,%rbx,4),%rax
add    %r13,%rax
jmp    12f2 <invert+0x1d2>
mov    %r14,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movss  0x0(%r13,%rdx,4),%xmm2
mulss  (%rsi),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rax)
movss  0x4(%r13,%rdx,4),%xmm2
mulss  0x28(%rsi),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rax)
add    $0x2,%rdx
add    $0x50,%rsi
cmp    %rdx,%rcx
jne    12a0 <invert+0x180>
test   $0x1,%bl
je     12f9 <invert+0x1d9>
movss  0x0(%r13,%rdx,4),%xmm2
lea    (%rdx,%rdx,4),%rcx
lea    (%rbx,%rcx,2),%rcx
mulss  0x10(%rsp,%rcx,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x0(%r13,%rbx,4)
movss  0xd13(%rip),%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,(%r12)
mulss  %xmm1,%xmm2
movaps %xmm2,%xmm1
movss  0xcfe(%rip),%xmm3
cmpnless %xmm3,%xmm1
movaps %xmm1,%xmm0
andnps %xmm2,%xmm0
andps  %xmm3,%xmm1
orps   %xmm0,%xmm1
movss  0xce9(%rip),%xmm4
ucomiss %xmm4,%xmm1
movaps %xmm4,%xmm0
cmpnless %xmm1,%xmm0
movaps %xmm0,%xmm1
andps  %xmm4,%xmm1
andnps %xmm3,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,%xmm1
jb     1352 <invert+0x232>
movaps %xmm2,%xmm1
movss  0xcbe(%rip),%xmm3
ucomiss %xmm2,%xmm3
jb     1150 <invert+0x30>
movaps %xmm1,%xmm0
jmp    1150 <invert+0x30>
cmp    $0x9,%rbx
ja     138b <invert+0x26b>
lea    0x0(,%rbx,4),%rdi
add    %r13,%rdi
mov    $0x28,%edx
sub    %r15,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @invert(float* nocapture %0, float* nocapture %1, float* nocapture %2) {
%4 = alloca [100 x float]
%5 = bitcast [100 x float]* %4 to i8*
br label %6
6: ; preds = %3, %109
%7 = phi i64 [ 0, %3 ], [ %121, %109 ]
%8 = mul nuw nsw i64 %7, 11
%9 = getelementptr [100 x float], [100 x float]* %4, i64 0, i64 %8
%10 = mul nsw i64 %7, -4
%11 = add nsw i64 %10, 40
%12 = getelementptr float, float* %0, i64 %8
%13 = bitcast float* %12 to i8*
%14 = bitcast float* %9 to i8*
%15 = icmp eq i64 %7, 0
br i1 %15, label %47, label %16
16: ; preds = %6
%17 = mul nuw nsw i64 %7, 10
br label %18
18: ; preds = %40, %16
%19 = phi i64 [ 0, %16 ], [ %41, %40 ]
%20 = mul nuw nsw i64 %19, 10
%21 = add nuw nsw i64 %20, %7
%22 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %21
%23 = load float, float* %22
%24 = mul nuw nsw i64 %19, 11
%25 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %24
%26 = load float, float* %25
%27 = fmul float %23, %26
br label %28
28: ; preds = %18, %28
%29 = phi i64 [ %38, %28 ], [ %7, %18 ]
%30 = add nuw nsw i64 %29, %20
%31 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %30
%32 = load float, float* %31
%33 = add nuw nsw i64 %29, %17
%34 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %33
%35 = load float, float* %34
%36 = fneg float %32
%37 = tail call float @llvm.fmuladd.f32(float %36, float %27, float %35)
store float %37, float* %34
%38 = add nuw nsw i64 %29, 1
%39 = icmp ult i64 %29, 9
br i1 %39, label %28, label %40
40: ; preds = %28
%41 = add nuw nsw i64 %19, 1
%42 = icmp eq i64 %41, %7
br i1 %42, label %43, label %18
43: ; preds = %40
%44 = load float, float* %9
%45 = tail call float @llvm.fabs.f32(float %44)
%46 = fcmp olt float %45, 0x3DDB7CDFE0000000
br i1 %46, label %55, label %62
47: ; preds = %6
%48 = load float, float* %9
%49 = tail call float @llvm.fabs.f32(float %48)
%50 = fcmp olt float %49, 0x3DDB7CDFE0000000
br i1 %50, label %57, label %51
51: ; preds = %47
%52 = getelementptr inbounds float, float* %1, i64 %7
%53 = load float, float* %52
%54 = getelementptr inbounds float, float* %2, i64 %7
store float %53, float* %54
br label %109
55: ; preds = %43
%56 = icmp ult i64 %7, 10
br i1 %56, label %57, label %123
57: ; preds = %47, %55
%58 = getelementptr float, float* %2, i64 %7
%59 = bitcast float* %58 to i8*
%60 = mul nsw i64 %7, -4
%61 = add nsw i64 %60, 40
br label %123
62: ; preds = %43
%63 = getelementptr inbounds float, float* %1, i64 %7
%64 = load float, float* %63
%65 = getelementptr inbounds float, float* %2, i64 %7
store float %64, float* %65
br i1 %15, label %109, label %66
66: ; preds = %62
%67 = and i64 %7, 1
%68 = icmp eq i64 %7, 1
br i1 %68, label %95, label %69
69: ; preds = %66
%70 = and i64 %7, 9223372036854775806
br label %71
71: ; preds = %71, %69
%72 = phi float [ %64, %69 ], [ %91, %71 ]
%73 = phi i64 [ 0, %69 ], [ %92, %71 ]
%74 = phi i64 [ 0, %69 ], [ %93, %71 ]
%75 = getelementptr inbounds float, float* %2, i64 %73
%76 = load float, float* %75
%77 = mul nuw nsw i64 %73, 10
%78 = add nuw nsw i64 %77, %7
%79 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %78
%80 = load float, float* %79
%81 = fneg float %76
%82 = tail call float @llvm.fmuladd.f32(float %81, float %80, float %72)
store float %82, float* %65
%83 = or i64 %73, 1
%84 = getelementptr inbounds float, float* %2, i64 %83
%85 = load float, float* %84
%86 = mul nuw nsw i64 %83, 10
%87 = add nuw nsw i64 %86, %7
%88 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %87
%89 = load float, float* %88
%90 = fneg float %85
%91 = tail call float @llvm.fmuladd.f32(float %90, float %89, float %82)
store float %91, float* %65
%92 = add nuw nsw i64 %73, 2
%93 = add i64 %74, 2
%94 = icmp eq i64 %93, %70
br i1 %94, label %95, label %71
95: ; preds = %71, %66
%96 = phi float [ undef, %66 ], [ %91, %71 ]
%97 = phi float [ %64, %66 ], [ %91, %71 ]
%98 = phi i64 [ 0, %66 ], [ %92, %71 ]
%99 = icmp eq i64 %67, 0
br i1 %99, label %109, label %100
100: ; preds = %95
%101 = getelementptr inbounds float, float* %2, i64 %98
%102 = load float, float* %101
%103 = mul nuw nsw i64 %98, 10
%104 = add nuw nsw i64 %103, %7
%105 = getelementptr inbounds [100 x float], [100 x float]* %4, i64 0, i64 %104
%106 = load float, float* %105
%107 = fneg float %102
%108 = tail call float @llvm.fmuladd.f32(float %107, float %106, float %97)
store float %108, float* %65
br label %109
109: ; preds = %100, %95, %51, %62
%110 = phi float* [ %65, %62 ], [ %54, %51 ], [ %65, %95 ], [ %65, %100 ]
%111 = phi float [ %44, %62 ], [ %48, %51 ], [ %44, %95 ], [ %44, %100 ]
%112 = phi float [ %64, %62 ], [ %53, %51 ], [ %96, %95 ], [ %108, %100 ]
%113 = fdiv float 1.000000e+00, %111
store float %113, float* %9
%114 = fmul float %113, %112
%115 = fcmp ugt float %114, 0x3FEFF7CEE0000000
%116 = select i1 %115, float 0x3FEFF7CEE0000000, float %114
%117 = fcmp ult float %116, 0xBFEFF7CEE0000000
%118 = or i1 %115, %117
%119 = select i1 %117, float 0xBFEFF7CEE0000000, float 0x3FEFF7CEE0000000
%120 = select i1 %118, float %119, float %114
store float %120, float* %110
%121 = add nuw nsw i64 %7, 1
%122 = icmp eq i64 %121, 10
br i1 %122, label %123, label %6
123: ; preds = %109, %57, %55
ret void
}