#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 array_max(float const *, int);
float array_min(float const *, int);
void linear_conversion(const float *in, float *out, int l) {
  float a, b;
  float min = array_min(in, l);
  float max = array_max(in, l);
  if (max > min + 0.00001) {
    a = (1.0 - 0.0) / (max - min);
    b = -a * min;
    for (int i = 0; i < l; i++)
      out[i] = a * in[i] + b;
  } else {
    for (int i = 0; i < l; i++)
      out[i] = in[i];
  }
}


x86 assembly (clang, -O0):
<linear_conversion>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1030 <array_min@plt>
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <array_max@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe91(%rip),%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    120e <linear_conversion+0xee>
movss  -0x24(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe75(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1209 <linear_conversion+0xe9>
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c3 <linear_conversion+0xa3>
jmp    124e <linear_conversion+0x12e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1249 <linear_conversion+0x129>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1215 <linear_conversion+0xf5>
jmp    124e <linear_conversion+0x12e>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<linear_conversion>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %edx,%esi
call   1030 <array_min@plt>
movss  %xmm0,0xc(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
call   1040 <array_max@plt>
movss  0xc(%rsp),%xmm3
cvtss2sd %xmm0,%xmm1
cvtss2sd %xmm3,%xmm2
addsd  0xea3(%rip),%xmm2
ucomisd %xmm2,%xmm1
jbe    1260 <linear_conversion+0x140>
test   %ebp,%ebp
jle    1494 <linear_conversion+0x374>
subss  %xmm3,%xmm0
movss  0xe8d(%rip),%xmm1
divss  %xmm0,%xmm1
movaps 0xe8a(%rip),%xmm0
xorps  %xmm1,%xmm0
mulss  %xmm3,%xmm0
mov    %ebp,%eax
cmp    $0x8,%ebp
jb     11ae <linear_conversion+0x8e>
lea    (%rbx,%rax,4),%rcx
cmp    %r14,%rcx
jbe    1300 <linear_conversion+0x1e0>
lea    (%r14,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    1300 <linear_conversion+0x1e0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11ed <linear_conversion+0xcd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11d0 <linear_conversion+0xb0>
cmp    $0x3,%rdx
jb     1494 <linear_conversion+0x374>
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%r14,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%r14,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1200 <linear_conversion+0xe0>
jmp    1494 <linear_conversion+0x374>
test   %ebp,%ebp
jle    1494 <linear_conversion+0x374>
mov    %ebp,%eax
cmp    $0x8,%ebp
jb     1289 <linear_conversion+0x169>
lea    (%rbx,%rax,4),%rcx
cmp    %r14,%rcx
jbe    13c0 <linear_conversion+0x2a0>
lea    (%r14,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    13c0 <linear_conversion+0x2a0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     12b5 <linear_conversion+0x195>
nopl   (%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12a0 <linear_conversion+0x180>
cmp    $0x3,%rdx
jb     1494 <linear_conversion+0x374>
nop
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r14,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%r14,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    12c0 <linear_conversion+0x1a0>
jmp    1494 <linear_conversion+0x374>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     149d <linear_conversion+0x37d>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rsi,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movups (%rbx,%rdx,4),%xmm4
movups 0x10(%rbx,%rdx,4),%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,(%r14,%rdx,4)
movups %xmm5,0x10(%r14,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm4
movups 0x30(%rbx,%rdx,4),%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,0x20(%r14,%rdx,4)
movups %xmm5,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1340 <linear_conversion+0x220>
test   $0x1,%sil
je     13b2 <linear_conversion+0x292>
movups (%rbx,%rdx,4),%xmm4
movups 0x10(%rbx,%rdx,4),%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,(%r14,%rdx,4)
movups %xmm5,0x10(%r14,%rdx,4)
cmp    %rax,%rcx
je     1494 <linear_conversion+0x374>
jmp    11b0 <linear_conversion+0x90>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    13e3 <linear_conversion+0x2c3>
xor    %edi,%edi
jmp    1450 <linear_conversion+0x330>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%r14,%rdi,4)
movups %xmm1,0x50(%r14,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%r14,%rdi,4)
movups %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13f0 <linear_conversion+0x2d0>
test   %rdx,%rdx
je     148b <linear_conversion+0x36b>
lea    (%r14,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1470 <linear_conversion+0x350>
cmp    %rax,%rcx
jne    128b <linear_conversion+0x16b>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1392 <linear_conversion+0x272>
jmp    13b2 <linear_conversion+0x292>

LLVM IR (-O0):
define void @linear_conversion(float* %0, float* %1, i32 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i32
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca i32
%12 = alloca i32
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
%13 = load float*, float** %4
%14 = load i32, i32* %6
%15 = call float @array_min(float* %13, i32 %14)
store float %15, float* %9
%16 = load float*, float** %4
%17 = load i32, i32* %6
%18 = call float @array_max(float* %16, i32 %17)
store float %18, float* %10
%19 = load float, float* %10
%20 = fpext float %19 to double
%21 = load float, float* %9
%22 = fpext float %21 to double
%23 = fadd double %22, 1.000000e-05
%24 = fcmp ogt double %20, %23
br i1 %24, label %25, label %57
25: ; preds = %3
%26 = load float, float* %10
%27 = load float, float* %9
%28 = fsub float %26, %27
%29 = fpext float %28 to double
%30 = fdiv double 1.000000e+00, %29
%31 = fptrunc double %30 to float
store float %31, float* %7
%32 = load float, float* %7
%33 = fneg float %32
%34 = load float, float* %9
%35 = fmul float %33, %34
store float %35, float* %8
store i32 0, i32* %11
br label %36
36: ; preds = %53, %25
%37 = load i32, i32* %11
%38 = load i32, i32* %6
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %56
40: ; preds = %36
%41 = load float, float* %7
%42 = load float*, float** %4
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
%46 = load float, float* %45
%47 = load float, float* %8
%48 = call float @llvm.fmuladd.f32(float %41, float %46, float %47)
%49 = load float*, float** %5
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
store float %48, float* %52
br label %53
53: ; preds = %40
%54 = load i32, i32* %11
%55 = add nsw i32 %54, 1
store i32 %55, i32* %11
br label %36
56: ; preds = %36
br label %76
57: ; preds = %3
store i32 0, i32* %12
br label %58
58: ; preds = %72, %57
%59 = load i32, i32* %12
%60 = load i32, i32* %6
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %75
62: ; preds = %58
%63 = load float*, float** %4
%64 = load i32, i32* %12
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %63, i64 %65
%67 = load float, float* %66
%68 = load float*, float** %5
%69 = load i32, i32* %12
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
store float %67, float* %71
br label %72
72: ; preds = %62
%73 = load i32, i32* %12
%74 = add nsw i32 %73, 1
store i32 %74, i32* %12
br label %58
75: ; preds = %58
br label %76
76: ; preds = %75, %56
ret void
}

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