#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 */
int /*<<< orphan*/ getminmax(float *, float *, float const *, int);
void image_normalization(const float *I0, const float *I1, float *I0n,
                         float *I1n, int size) {
  float max0, max1, min0, min1;
  getminmax(&min0, &max0, I0, size);
  getminmax(&min1, &max1, I1, size);
  const float max = (max0 > max1) ? max0 : max1;
  const float min = (min0 < min1) ? min0 : min1;
  const float den = max - min;
  if (den > 0)
    for (int i = 0; i < size; i++) {
      I0n[i] = 255.0 * (I0[i] - min) / den;
      I1n[i] = 255.0 * (I1[i] - min) / den;
    }
  else
    for (int i = 0; i < size; i++) {
      I0n[i] = I0[i];
      I1n[i] = I1[i];
    }
}


x86 assembly (clang, -O0):
<image_normalization>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x8(%rbp),%rdx
mov    -0x24(%rbp),%ecx
lea    -0x30(%rbp),%rdi
lea    -0x28(%rbp),%rsi
call   1030 <getminmax@plt>
mov    -0x10(%rbp),%rdx
mov    -0x24(%rbp),%ecx
lea    -0x34(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
call   1030 <getminmax@plt>
movss  -0x28(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jbe    1172 <image_normalization+0x62>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    117c <image_normalization+0x6c>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    11a8 <image_normalization+0x98>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    11b2 <image_normalization+0xa2>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1282 <image_normalization+0x172>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    127d <image_normalization+0x16d>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdf3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdb3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11e3 <image_normalization+0xd3>
jmp    12dc <image_normalization+0x1cc>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12d7 <image_normalization+0x1c7>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1289 <image_normalization+0x179>
jmp    12dc <image_normalization+0x1cc>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<image_normalization>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,%ebp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0xc(%rsp),%rdi
lea    0x14(%rsp),%rsi
mov    %rbx,%rdx
mov    %r8d,%ecx
call   1030 <getminmax@plt>
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rsi
mov    %r12,%rdx
mov    %ebp,%ecx
call   1030 <getminmax@plt>
movss  0x14(%rsp),%xmm1
maxss  0x10(%rsp),%xmm1
movss  0xc(%rsp),%xmm0
minss  0x8(%rsp),%xmm0
subss  %xmm0,%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
jbe    11ed <image_normalization+0xdd>
test   %ebp,%ebp
jle    14eb <image_normalization+0x3db>
cvtss2sd %xmm1,%xmm1
mov    %ebp,%eax
cmp    $0x4,%ebp
jae    1270 <image_normalization+0x160>
xor    %ecx,%ecx
movsd  0xe75(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm3
subss  %xmm0,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm2,%xmm3
divsd  %xmm1,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,(%r15,%rcx,4)
movss  (%r12,%rcx,4),%xmm3
subss  %xmm0,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm2,%xmm3
divsd  %xmm1,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    11a0 <image_normalization+0x90>
jmp    14eb <image_normalization+0x3db>
test   %ebp,%ebp
jle    14eb <image_normalization+0x3db>
mov    %ebp,%eax
cmp    $0x8,%ebp
jae    139c <image_normalization+0x28c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1227 <image_normalization+0x117>
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
movss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     14eb <image_normalization+0x3db>
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
movss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r15,%rcx,4)
movss  0x4(%r12,%rcx,4),%xmm0
movss  %xmm0,0x4(%r14,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1230 <image_normalization+0x120>
jmp    14eb <image_normalization+0x3db>
lea    (%r14,%rax,4),%rcx
cmp    %r15,%rcx
seta   0x7(%rsp)
lea    (%r15,%rax,4),%rdi
cmp    %r14,%rdi
seta   %bpl
lea    (%rbx,%rax,4),%rsi
cmp    %r15,%rsi
seta   %r13b
cmp    %rbx,%rdi
seta   %r9b
lea    (%r12,%rax,4),%rdx
cmp    %r15,%rdx
seta   %r11b
cmp    %r12,%rdi
seta   %r10b
cmp    %r14,%rsi
seta   %dil
cmp    %rbx,%rcx
seta   %sil
cmp    %r14,%rdx
seta   %r8b
cmp    %r12,%rcx
seta   %dl
xor    %ecx,%ecx
test   %bpl,0x7(%rsp)
jne    1193 <image_normalization+0x83>
and    %r9b,%r13b
jne    1193 <image_normalization+0x83>
and    %r10b,%r11b
jne    1193 <image_normalization+0x83>
and    %sil,%dil
jne    1193 <image_normalization+0x83>
and    %dl,%r8b
jne    1193 <image_normalization+0x83>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movaps %xmm1,%xmm3
movlhps %xmm1,%xmm3
lea    0x0(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
movapd 0xce1(%rip),%xmm4
nop
movups (%rbx,%rsi,1),%xmm5
subps  %xmm2,%xmm5
cvtps2pd %xmm5,%xmm6
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
mulpd  %xmm4,%xmm6
mulpd  %xmm4,%xmm5
divpd  %xmm3,%xmm5
divpd  %xmm3,%xmm6
cvtpd2ps %xmm6,%xmm6
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm5,%xmm6
movupd %xmm6,(%r15,%rsi,1)
movups (%r12,%rsi,1),%xmm5
subps  %xmm2,%xmm5
cvtps2pd %xmm5,%xmm6
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
mulpd  %xmm4,%xmm6
mulpd  %xmm4,%xmm5
divpd  %xmm3,%xmm5
divpd  %xmm3,%xmm6
cvtpd2ps %xmm6,%xmm6
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm5,%xmm6
movupd %xmm6,(%r14,%rsi,1)
add    $0x10,%rsi
cmp    %rsi,%rdx
jne    1320 <image_normalization+0x210>
cmp    %rax,%rcx
jne    1193 <image_normalization+0x83>
jmp    14eb <image_normalization+0x3db>
lea    (%r14,%rax,4),%rcx
cmp    %r15,%rcx
seta   0x7(%rsp)
lea    (%r15,%rax,4),%rdi
cmp    %r14,%rdi
seta   %bpl
lea    (%rbx,%rax,4),%rsi
cmp    %r15,%rsi
seta   %r13b
cmp    %rbx,%rdi
seta   %r9b
lea    (%r12,%rax,4),%rdx
cmp    %r15,%rdx
seta   %r11b
cmp    %r12,%rdi
seta   %r10b
cmp    %r14,%rsi
seta   %dil
cmp    %rbx,%rcx
seta   %sil
cmp    %r14,%rdx
seta   %r8b
cmp    %r12,%rcx
seta   %dl
xor    %ecx,%ecx
test   %bpl,0x7(%rsp)
jne    1202 <image_normalization+0xf2>
and    %r9b,%r13b
jne    1202 <image_normalization+0xf2>
and    %r10b,%r11b
jne    1202 <image_normalization+0xf2>
and    %sil,%dil
jne    1202 <image_normalization+0xf2>
and    %dl,%r8b
jne    1202 <image_normalization+0xf2>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     14fa <image_normalization+0x3ea>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
movups (%r12,%rdx,4),%xmm0
movups 0x10(%r12,%rdx,4),%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm0
movups 0x30(%rbx,%rdx,4),%xmm1
movups %xmm0,0x20(%r15,%rdx,4)
movups %xmm1,0x30(%r15,%rdx,4)
movups 0x20(%r12,%rdx,4),%xmm0
movups 0x30(%r12,%rdx,4),%xmm1
movups %xmm0,0x20(%r14,%rdx,4)
movups %xmm1,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1450 <image_normalization+0x340>
test   $0x1,%sil
je     14e2 <image_normalization+0x3d2>
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
movups (%r12,%rdx,4),%xmm0
movups 0x10(%r12,%rdx,4),%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
cmp    %rax,%rcx
jne    1202 <image_normalization+0xf2>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    14b8 <image_normalization+0x3a8>
jmp    14e2 <image_normalization+0x3d2>

LLVM IR (-O0):
define void @image_normalization(float* %0, float* %1, float* %2, float* %3, i32 %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca i32
%19 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store i32 %4, i32* %10
%20 = load float*, float** %6
%21 = load i32, i32* %10
%22 = call i32 @getminmax(float* %13, float* %11, float* %20, i32 %21)
%23 = load float*, float** %7
%24 = load i32, i32* %10
%25 = call i32 @getminmax(float* %14, float* %12, float* %23, i32 %24)
%26 = load float, float* %11
%27 = load float, float* %12
%28 = fcmp ogt float %26, %27
br i1 %28, label %29, label %31
29: ; preds = %5
%30 = load float, float* %11
br label %33
31: ; preds = %5
%32 = load float, float* %12
br label %33
33: ; preds = %31, %29
%34 = phi float [ %30, %29 ], [ %32, %31 ]
store float %34, float* %15
%35 = load float, float* %13
%36 = load float, float* %14
%37 = fcmp olt float %35, %36
br i1 %37, label %38, label %40
38: ; preds = %33
%39 = load float, float* %13
br label %42
40: ; preds = %33
%41 = load float, float* %14
br label %42
42: ; preds = %40, %38
%43 = phi float [ %39, %38 ], [ %41, %40 ]
store float %43, float* %16
%44 = load float, float* %15
%45 = load float, float* %16
%46 = fsub float %44, %45
store float %46, float* %17
%47 = load float, float* %17
%48 = fcmp ogt float %47, 0.000000e+00
br i1 %48, label %49, label %93
49: ; preds = %42
store i32 0, i32* %18
br label %50
50: ; preds = %89, %49
%51 = load i32, i32* %18
%52 = load i32, i32* %10
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %92
54: ; preds = %50
%55 = load float*, float** %6
%56 = load i32, i32* %18
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
%60 = load float, float* %16
%61 = fsub float %59, %60
%62 = fpext float %61 to double
%63 = fmul double 2.550000e+02, %62
%64 = load float, float* %17
%65 = fpext float %64 to double
%66 = fdiv double %63, %65
%67 = fptrunc double %66 to float
%68 = load float*, float** %8
%69 = load i32, i32* %18
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
store float %67, float* %71
%72 = load float*, float** %7
%73 = load i32, i32* %18
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
%76 = load float, float* %75
%77 = load float, float* %16
%78 = fsub float %76, %77
%79 = fpext float %78 to double
%80 = fmul double 2.550000e+02, %79
%81 = load float, float* %17
%82 = fpext float %81 to double
%83 = fdiv double %80, %82
%84 = fptrunc double %83 to float
%85 = load float*, float** %9
%86 = load i32, i32* %18
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %85, i64 %87
store float %84, float* %88
br label %89
89: ; preds = %54
%90 = load i32, i32* %18
%91 = add nsw i32 %90, 1
store i32 %91, i32* %18
br label %50
92: ; preds = %50
br label %121
93: ; preds = %42
store i32 0, i32* %19
br label %94
94: ; preds = %117, %93
%95 = load i32, i32* %19
%96 = load i32, i32* %10
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %120
98: ; preds = %94
%99 = load float*, float** %6
%100 = load i32, i32* %19
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %99, i64 %101
%103 = load float, float* %102
%104 = load float*, float** %8
%105 = load i32, i32* %19
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
store float %103, float* %107
%108 = load float*, float** %7
%109 = load i32, i32* %19
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = load float*, float** %9
%114 = load i32, i32* %19
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
store float %112, float* %116
br label %117
117: ; preds = %98
%118 = load i32, i32* %19
%119 = add nsw i32 %118, 1
store i32 %119, i32* %19
br label %94
120: ; preds = %94
br label %121
121: ; preds = %120, %92
ret void
}

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