#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*/ free(float *);
float *malloc(int);
void equalization_meanp(float *ref, float *modified, float *out, int w, int h,
                        int w2, int h2, int pd) {
  float *mean_ref = malloc(pd * sizeof(float));
  float *mean_modified = malloc(pd * sizeof(float));
  for (int l = 0; l < pd; l++) {
    mean_ref[l] = 0;
    for (int i = 0; i < w * h; i++)
      mean_ref[l] += ref[i + l * w * h];
    mean_ref[l] /= (float)(w * h);
    mean_modified[l] = 0;
    for (int i = 0; i < w2 * h2; i++)
      mean_modified[l] += modified[i + l * w2 * h2];
    mean_modified[l] /= (float)(w2 * h2);
  }
  for (int l = 0; l < pd; l++)
    for (int i = 0; i < w2 * h2; i++)
      out[i + l * w2 * h2] =
          modified[i + l * w2 * h2] - mean_modified[l] + mean_ref[l];
  free(mean_ref);
  free(mean_modified);
}


x86 assembly (clang, -O0):
<equalization_meanp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1298 <equalization_meanp+0x178>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    11e3 <equalization_meanp+0xc3>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1195 <equalization_meanp+0x75>
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2ss %eax,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1269 <equalization_meanp+0x149>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x24(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    121b <equalization_meanp+0xfb>
mov    -0x24(%rbp),%eax
imul   0x10(%rbp),%eax
cvtsi2ss %eax,%xmm1
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1172 <equalization_meanp+0x52>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1337 <equalization_meanp+0x217>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1324 <equalization_meanp+0x204>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x24(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x24(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b2 <equalization_meanp+0x192>
jmp    1329 <equalization_meanp+0x209>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    129f <equalization_meanp+0x17f>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<equalization_meanp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r12d
mov    %r8d,%r13d
mov    %ecx,(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
mov    0x88(%rsp),%ebx
mov    0x80(%rsp),%r14d
lea    0x0(,%rbx,4),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
test   %ebx,%ebx
jle    1535 <equalization_meanp+0x415>
imul   (%rsp),%r13d
cvtsi2ss %r13d,%xmm0
imul   %r12d,%r14d
cvtsi2ss %r14d,%xmm1
mov    %rbx,0x10(%rsp)
mov    %ebx,%r12d
lea    -0x1(%r13),%r8
lea    -0x1(%r14),%r11
mov    %r13d,%esi
and    $0x3,%esi
mov    %r13d,%edi
and    $0xfffffffc,%edi
mov    %r14d,%ebp
and    $0x3,%ebp
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %r15,(%rsp)
lea    0xc(%r15),%rax
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%rax
add    $0xc,%rax
mov    %rax,0x20(%rsp)
xor    %edx,%edx
xor    %r9d,%r9d
xor    %r10d,%r10d
jmp    1202 <equalization_meanp+0xe2>
nopw   0x0(%rax,%rax,1)
divss  %xmm1,%xmm2
mov    0x30(%rsp),%rax
movss  %xmm2,(%rax,%r10,4)
add    $0x1,%r10
add    %r13d,%r9d
add    %r14d,%edx
cmp    %r12,%r10
je     1313 <equalization_meanp+0x1f3>
xorps  %xmm2,%xmm2
xorps  %xmm3,%xmm3
test   %r13d,%r13d
jle    127e <equalization_meanp+0x15e>
movslq %r9d,%r15
cmp    $0x3,%r8
jae    1220 <equalization_meanp+0x100>
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
jmp    1250 <equalization_meanp+0x130>
nopl   (%rax)
mov    0x28(%rsp),%rax
lea    (%rax,%r15,4),%rax
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
xchg   %ax,%ax
addss  -0xc(%rax,%rbx,4),%xmm3
addss  -0x8(%rax,%rbx,4),%xmm3
addss  -0x4(%rax,%rbx,4),%xmm3
addss  (%rax,%rbx,4),%xmm3
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1230 <equalization_meanp+0x110>
test   %rsi,%rsi
je     127e <equalization_meanp+0x15e>
add    %r15,%rbx
mov    (%rsp),%rax
lea    (%rax,%rbx,4),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addss  (%rax,%rbx,4),%xmm3
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1270 <equalization_meanp+0x150>
divss  %xmm0,%xmm3
mov    0x38(%rsp),%rax
movss  %xmm3,(%rax,%r10,4)
test   %r14d,%r14d
jle    11e0 <equalization_meanp+0xc0>
movslq %edx,%r15
cmp    $0x3,%r11
jae    12b0 <equalization_meanp+0x190>
xorps  %xmm2,%xmm2
xor    %eax,%eax
jmp    12e0 <equalization_meanp+0x1c0>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
lea    (%rax,%r15,4),%rbx
xorps  %xmm2,%xmm2
xor    %eax,%eax
xchg   %ax,%ax
addss  -0xc(%rbx,%rax,4),%xmm2
addss  -0x8(%rbx,%rax,4),%xmm2
addss  -0x4(%rbx,%rax,4),%xmm2
addss  (%rbx,%rax,4),%xmm2
add    $0x4,%rax
cmp    %rax,%rcx
jne    12c0 <equalization_meanp+0x1a0>
test   %rbp,%rbp
je     11e0 <equalization_meanp+0xc0>
add    %r15,%rax
mov    0x8(%rsp),%rbx
lea    (%rbx,%rax,4),%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
addss  (%rax,%rbx,4),%xmm2
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1300 <equalization_meanp+0x1e0>
jmp    11e0 <equalization_meanp+0xc0>
cmpl   $0x0,0x10(%rsp)
jle    1535 <equalization_meanp+0x415>
mov    0x18(%rsp),%rsi
lea    (%rsi,%r14,4),%rax
mov    0x8(%rsp),%rdi
lea    (%rdi,%r14,4),%rdx
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%r15
mov    %r15,%r13
shr    $0x3,%r13
add    $0x1,%r13
cmp    %rsi,%rdx
seta   %dl
cmp    %rdi,%rax
seta   %bl
and    %dl,%bl
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x20(%rsp)
mov    %r14,%rbp
neg    %rbp
lea    0x30(%rsi),%rax
mov    %rax,0x10(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,0x40(%rsp)
lea    0x4(%rdi),%rax
mov    %rax,(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,0x28(%rsp)
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    13a0 <equalization_meanp+0x280>
add    $0x1,%r9
add    %r14d,%r8d
cmp    %r12,%r9
je     1535 <equalization_meanp+0x415>
test   %r14d,%r14d
jle    1390 <equalization_meanp+0x270>
movslq %r8d,%r10
cmp    $0x8,%r14d
setb   %al
mov    %r14d,%edx
imul   %r9d,%edx
mov    0x30(%rsp),%rsi
movss  (%rsi,%r9,4),%xmm0
mov    0x38(%rsp),%rsi
movss  (%rsi,%r9,4),%xmm1
movslq %edx,%r11
or     %bl,%al
je     13e0 <equalization_meanp+0x2c0>
xor    %edx,%edx
jmp    1495 <equalization_meanp+0x375>
nopw   0x0(%rax,%rax,1)
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
test   %r15,%r15
je     1524 <equalization_meanp+0x404>
mov    0x10(%rsp),%rax
lea    (%rax,%r10,4),%rax
mov    0x40(%rsp),%rdx
lea    (%rdx,%r10,4),%rdx
mov    0x20(%rsp),%rsi
xor    %edi,%edi
movups -0x30(%rdx,%rdi,4),%xmm4
movups -0x20(%rdx,%rdi,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm3,%xmm5
addps  %xmm2,%xmm4
addps  %xmm2,%xmm5
movups %xmm4,-0x30(%rax,%rdi,4)
movups %xmm5,-0x20(%rax,%rdi,4)
movups -0x10(%rdx,%rdi,4),%xmm4
movups (%rdx,%rdi,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm3,%xmm5
addps  %xmm2,%xmm4
addps  %xmm2,%xmm5
movups %xmm4,-0x10(%rax,%rdi,4)
movups %xmm5,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1410 <equalization_meanp+0x2f0>
test   $0x1,%r13b
je     1489 <equalization_meanp+0x369>
add    %r11,%rdi
mov    0x8(%rsp),%rax
movups (%rax,%rdi,4),%xmm4
movups 0x10(%rax,%rdi,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm3,%xmm5
addps  %xmm2,%xmm4
addps  %xmm2,%xmm5
mov    0x18(%rsp),%rax
movups %xmm4,(%rax,%rdi,4)
movups %xmm5,0x10(%rax,%rdi,4)
mov    %rcx,%rdx
cmp    %r14,%rcx
je     1390 <equalization_meanp+0x270>
mov    %rdx,%rax
test   $0x1,%r14b
je     14c6 <equalization_meanp+0x3a6>
add    %rdx,%r11
mov    0x8(%rsp),%rax
movss  (%rax,%r11,4),%xmm2
subss  %xmm0,%xmm2
addss  %xmm1,%xmm2
mov    0x18(%rsp),%rax
movss  %xmm2,(%rax,%r11,4)
mov    %rdx,%rax
or     $0x1,%rax
not    %rdx
cmp    %rbp,%rdx
je     1390 <equalization_meanp+0x270>
mov    (%rsp),%rdx
lea    (%rdx,%r10,4),%rdx
mov    0x28(%rsp),%rsi
lea    (%rsi,%r10,4),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rdx,%rax,4),%xmm2
subss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rsi,%rax,4)
movss  (%rdx,%rax,4),%xmm2
subss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rax,4)
add    $0x2,%rax
cmp    %rax,%r14
jne    14f0 <equalization_meanp+0x3d0>
jmp    1390 <equalization_meanp+0x270>
xor    %edi,%edi
test   $0x1,%r13b
jne    145e <equalization_meanp+0x33e>
jmp    1489 <equalization_meanp+0x369>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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