#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 */
scalar_t__ calloc(int, int);
float *d3_np_fs(int n, float a[], float b[]) {
  int i;
  float *x;
  float xmult;
  for (i = 0; i < n; i++) {
    if (a[1 + i * 3] == 0.0E+00) {
      return NULL;
    }
  }
  x = (float *)calloc(n, sizeof(float));
  for (i = 0; i < n; i++) {
    x[i] = b[i];
  }
  for (i = 1; i < n; i++) {
    xmult = a[2 + (i - 1) * 3] / a[1 + (i - 1) * 3];
    a[1 + i * 3] = a[1 + i * 3] - xmult * a[0 + i * 3];
    x[i] = x[i] - xmult * x[i - 1];
  }
  x[n - 1] = x[n - 1] / a[1 + (n - 1) * 3];
  for (i = n - 2; 0 <= i; i--) {
    x[i] = (x[i] - a[0 + (i + 1) * 3] * x[i + 1]) / a[1 + i * 3];
  }
  return x;
}


x86 assembly (clang, -O0):
<d3_np_fs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1180 <d3_np_fs+0x70>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    116d <d3_np_fs+0x5d>
jp     116d <d3_np_fs+0x5d>
movq   $0x0,-0x8(%rbp)
jmp    138d <d3_np_fs+0x27d>
jmp    1172 <d3_np_fs+0x62>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112a <d3_np_fs+0x1a>
mov    -0xc(%rbp),%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11cc <d3_np_fs+0xbc>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1198 <d3_np_fs+0x88>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12bb <d3_np_fs+0x1ab>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11d3 <d3_np_fs+0xc3>
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmp    -0x24(%rbp),%eax
jg     1385 <d3_np_fs+0x275>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1300 <d3_np_fs+0x1f0>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<d3_np_fs>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r15
mov    %edi,%r14d
test   %edi,%edi
jle    120c <d3_np_fs+0xfc>
mov    %rdx,%rbx
mov    %r14d,%r12d
lea    0x0(,%r12,4),%rax
lea    (%rax,%rax,2),%rcx
xor    %eax,%eax
xorps  %xmm0,%xmm0
xor    %edx,%edx
nop
movss  0x4(%r15,%rdx,1),%xmm1
ucomiss %xmm0,%xmm1
jne    1152 <d3_np_fs+0x42>
jnp    13e8 <d3_np_fs+0x2d8>
add    $0xc,%rdx
cmp    %rdx,%rcx
jne    1140 <d3_np_fs+0x30>
mov    %r14d,%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
test   %r14d,%r14d
jle    137d <d3_np_fs+0x26d>
cmp    $0x8,%r14d
jb     1191 <d3_np_fs+0x81>
lea    (%rbx,%r12,4),%rcx
cmp    %rcx,%rax
jae    121e <d3_np_fs+0x10e>
lea    (%rax,%r12,4),%rcx
cmp    %rbx,%rcx
jbe    121e <d3_np_fs+0x10e>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r12,%rdx
mov    %r12,%rsi
and    $0x3,%rsi
je     11c4 <d3_np_fs+0xb4>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <d3_np_fs+0xa0>
cmp    $0x3,%rdx
jb     12f4 <d3_np_fs+0x1e4>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r12
jne    11d0 <d3_np_fs+0xc0>
jmp    12f4 <d3_np_fs+0x1e4>
mov    %r14d,%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
jmp    137d <d3_np_fs+0x26d>
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    1244 <d3_np_fs+0x134>
xor    %edi,%edi
jmp    12a8 <d3_np_fs+0x198>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%rax,%rdi,4)
movups %xmm1,0x30(%rax,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%rax,%rdi,4)
movups %xmm1,0x50(%rax,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%rax,%rdi,4)
movups %xmm1,0x70(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1250 <d3_np_fs+0x140>
test   %r8,%r8
je     12eb <d3_np_fs+0x1db>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    12d0 <d3_np_fs+0x1c0>
cmp    %r12,%rcx
jne    1193 <d3_np_fs+0x83>
cmp    $0x2,%r14d
setge  %cl
jl     137d <d3_np_fs+0x26d>
lea    0x4(%r15),%rdx
lea    (%rax,%r12,4),%rsi
cmp    %rsi,%rdx
jae    13f4 <d3_np_fs+0x2e4>
lea    (%r12,%r12,2),%rdx
lea    (%r15,%rdx,4),%rdx
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%rax
jae    13f4 <d3_np_fs+0x2e4>
lea    0x10(%r15),%rdx
mov    $0x1,%esi
movaps 0xcc9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movss  -0x8(%rdx),%xmm1
xorps  %xmm0,%xmm1
divss  -0xc(%rdx),%xmm1
movss  -0x4(%rdx),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx),%xmm2
movss  %xmm2,(%rdx)
mulss  -0x4(%rax,%rsi,4),%xmm1
addss  (%rax,%rsi,4),%xmm1
movss  %xmm1,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xc,%rdx
cmp    %rsi,%r12
jne    1340 <d3_np_fs+0x230>
jmp    137f <d3_np_fs+0x26f>
xor    %ecx,%ecx
movslq %r14d,%rdx
movss  -0x4(%rax,%rdx,4),%xmm0
lea    (%r14,%r14,2),%esi
add    $0xfffffffd,%esi
movslq %esi,%rsi
divss  0x4(%r15,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdx,4)
test   %cl,%cl
je     13e8 <d3_np_fs+0x2d8>
add    $0xfffffffe,%r14d
movslq %r14d,%rdx
lea    0x1(%rdx),%rcx
lea    (%rdx,%rdx,2),%rdx
lea    (%r15,%rdx,4),%rdx
add    $0xc,%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rdx),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  -0x4(%rax,%rcx,4),%xmm1
subss  %xmm0,%xmm1
divss  -0x8(%rdx),%xmm1
movss  %xmm1,-0x4(%rax,%rcx,4)
add    $0xfffffffffffffff4,%rdx
add    $0xffffffffffffffff,%rcx
jg     13c0 <d3_np_fs+0x2b0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movss  (%rax),%xmm1
lea    0x10(%r15),%rdx
mov    $0x1,%esi
movaps 0xbf8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rdx),%xmm2
xorps  %xmm0,%xmm2
divss  -0xc(%rdx),%xmm2
movss  -0x4(%rdx),%xmm3
mulss  %xmm2,%xmm3
addss  (%rdx),%xmm3
movss  %xmm3,(%rdx)
mulss  %xmm1,%xmm2
addss  (%rax,%rsi,4),%xmm2
movss  %xmm2,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xc,%rdx
movaps %xmm2,%xmm1
cmp    %rsi,%r12
jne    1410 <d3_np_fs+0x300>
jmp    137f <d3_np_fs+0x26f>

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

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