#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__ MallocWithErrorMessage(int);
int /*<<< orphan*/ free(float *);
int equalize_image(float *image, int width, int height, int num_bins) {
  const long num_pixels = ((long)width) * ((long)height);
  const long num_el = 3 * num_pixels;
  const int num_bins_minus_one = num_bins - 1;
  float *histogram1d[3] = {NULL, NULL, NULL};
  double accum;
  long i;
  int n, channel, success = 0;
  if (!(histogram1d[0] =
            (float *)MallocWithErrorMessage(sizeof(float) * 3 * num_bins)))
    goto fail;
  histogram1d[1] = histogram1d[0] + num_bins;
  histogram1d[2] = histogram1d[0] + 2 * num_bins;
  for (channel = 0; channel < 3; channel++)
    for (i = 0; i < num_bins; i++)
      histogram1d[channel][i] = 0;
  for (i = 0; i < num_el; i += 3) {
    histogram1d[0][(int)(image[i + 0] * num_bins_minus_one + 0.5f)]++;
    histogram1d[1][(int)(image[i + 1] * num_bins_minus_one + 0.5f)]++;
    histogram1d[2][(int)(image[i + 2] * num_bins_minus_one + 0.5f)]++;
  }
  for (channel = 0; channel < 3; channel++)
    for (i = 0; i < num_bins; i++)
      histogram1d[channel][i] /= num_pixels;
  for (channel = 0; channel < 3; channel++) {
    for (n = 0, accum = 0; n < num_bins; n++) {
      accum += histogram1d[channel][n];
      histogram1d[channel][n] = accum - histogram1d[channel][n] / 2;
    }
    histogram1d[channel][0] = 0;
    histogram1d[channel][num_bins - 1] = 1;
  }
  for (i = 0; i < num_el; i += 3) {
    image[i + 0] =
        histogram1d[0][(int)(image[i + 0] * num_bins_minus_one + 0.5f)];
    image[i + 1] =
        histogram1d[1][(int)(image[i + 1] * num_bins_minus_one + 0.5f)];
    image[i + 2] =
        histogram1d[2][(int)(image[i + 2] * num_bins_minus_one + 0.5f)];
  }
  success = 1;
fail:
  free(histogram1d[0]);
  return success;
}


x86 assembly (clang, -O0):
<equalize_image>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movslq -0xc(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   %rcx,%rax
mov    %rax,-0x20(%rbp)
imul   $0x3,-0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1040 <memset@plt>
movl   $0x0,-0x6c(%rbp)
movslq -0x14(%rbp),%rax
imul   $0xc,%rax,%rax
mov    %eax,%edi
call   1050 <MallocWithErrorMessage@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    11a0 <equalize_image+0x70>
jmp    154a <equalize_image+0x41a>
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x3,-0x68(%rbp)
jge    122e <equalize_image+0xfe>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmp    %rcx,%rax
jge    121b <equalize_image+0xeb>
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
mov    -0x60(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11e4 <equalize_image+0xb4>
jmp    1220 <equalize_image+0xf0>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    11d2 <equalize_image+0xa2>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1314 <equalize_image+0x1e4>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xd9a(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  0xd8b(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  0x4(%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xd5a(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  0xd4b(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  0x8(%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xd1a(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  0xd0b(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x60(%rbp)
jmp    1236 <equalize_image+0x106>
movl   $0x0,-0x68(%rbp)
cmpl   $0x3,-0x68(%rbp)
jge    1383 <equalize_image+0x253>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmp    %rcx,%rax
jge    1370 <equalize_image+0x240>
cvtsi2ssq -0x20(%rbp),%xmm1
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
mov    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    132d <equalize_image+0x1fd>
jmp    1375 <equalize_image+0x245>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    131b <equalize_image+0x1eb>
movl   $0x0,-0x68(%rbp)
cmpl   $0x3,-0x68(%rbp)
jge    145b <equalize_image+0x32b>
movl   $0x0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    141e <equalize_image+0x2ee>
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xc1a(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13a3 <equalize_image+0x273>
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movslq -0x68(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0xbbc(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    138a <equalize_image+0x25a>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1543 <equalize_image+0x413>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xb6d(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  0x4(%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xb2d(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movss  0x8(%rcx,%rdx,4),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xaec(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,0x8(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x60(%rbp)
jmp    1463 <equalize_image+0x333>
movl   $0x1,-0x6c(%rbp)
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x6c(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<equalize_image>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%ebp
mov    %edx,%r15d
mov    %esi,%r12d
mov    %rdi,%rbx
lea    0x0(,%rbp,4),%eax
lea    (%rax,%rax,2),%edi
call   1050 <MallocWithErrorMessage@plt>
mov    %rax,%r14
test   %rax,%rax
je     1292 <equalize_image+0x162>
movslq %r12d,%rax
movslq %r15d,%r11
imul   %rax,%r11
movslq %ebp,%r13
lea    (%r14,%r13,4),%r15
lea    0x0(%rbp,%rbp,1),%eax
cltq
mov    %rax,(%rsp)
lea    (%r14,%rax,4),%r12
test   %ebp,%ebp
mov    %rbp,%r8
jle    11cd <equalize_image+0x9d>
lea    0x0(,%r13,4),%rbp
mov    %r14,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
mov    %r11,0x10(%rsp)
mov    %r8,0x8(%rsp)
call   1040 <memset@plt>
mov    %r15,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x8(%rsp),%r8
mov    0x10(%rsp),%r11
lea    (%r11,%r11,2),%rax
lea    -0x1(%r8),%r10d
test   %r11,%r11
jle    1277 <equalize_image+0x147>
cvtsi2ss %r10d,%xmm0
xor    %edx,%edx
movss  0xe13(%rip),%xmm1
movss  0xe0f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
cvttss2si %xmm3,%ecx
movslq %ecx,%rcx
movss  (%r14,%rcx,4),%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%r14,%rcx,4)
movss  0x4(%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
cvttss2si %xmm3,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%r15,%rcx,4)
movss  0x8(%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
cvttss2si %xmm3,%ecx
movslq %ecx,%rcx
movss  (%r12,%rcx,4),%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%r12,%rcx,4)
add    $0x3,%rdx
cmp    %rax,%rdx
jl     1200 <equalize_image+0xd0>
test   %r8d,%r8d
jle    13ef <equalize_image+0x2bf>
xorps  %xmm0,%xmm0
cvtsi2ss %r11,%xmm0
cmp    $0x4,%r8d
jae    1299 <equalize_image+0x169>
xor    %edx,%edx
jmp    1310 <equalize_image+0x1e0>
xor    %ebp,%ebp
jmp    14aa <equalize_image+0x37a>
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rdx),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     17b3 <equalize_image+0x683>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%r14,%rdi,4),%xmm2
movups 0x10(%r14,%rdi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%r14,%rdi,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%r14,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    12d0 <equalize_image+0x1a0>
test   $0x1,%bpl
je     1309 <equalize_image+0x1d9>
movups (%r14,%rdi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r14,%rdi,4)
cmp    %r13,%rdx
je     1329 <equalize_image+0x1f9>
xchg   %ax,%ax
movss  (%r14,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1310 <equalize_image+0x1e0>
test   %r8d,%r8d
jle    13ef <equalize_image+0x2bf>
cmp    $0x4,%r8d
jae    133f <equalize_image+0x20f>
xor    %edx,%edx
jmp    13c0 <equalize_image+0x290>
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rdx),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     17c4 <equalize_image+0x694>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r14,%r13,4),%rcx
add    $0x10,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdi,4),%xmm2
movups (%rcx,%rdi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%rcx,%rdi,4)
divps  %xmm1,%xmm3
movups %xmm3,(%rcx,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1380 <equalize_image+0x250>
test   $0x1,%bpl
je     13b5 <equalize_image+0x285>
movups (%r15,%rdi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r15,%rdi,4)
cmp    %r13,%rdx
je     13d9 <equalize_image+0x2a9>
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    13c0 <equalize_image+0x290>
test   %r8d,%r8d
jle    13ef <equalize_image+0x2bf>
cmp    $0x4,%r8d
jae    14c3 <equalize_image+0x393>
xor    %edx,%edx
jmp    1540 <equalize_image+0x410>
movslq %r10d,%rdx
movl   $0x0,(%r14)
movl   $0x3f800000,(%r14,%rdx,4)
movl   $0x0,(%r15)
movl   $0x3f800000,(%r15,%rdx,4)
3f
movl   $0x0,(%r12)
movl   $0x3f800000,(%r12,%rdx,4)
3f
mov    $0x1,%ebp
test   %r11,%r11
jle    14aa <equalize_image+0x37a>
xorps  %xmm0,%xmm0
cvtsi2ss %r10d,%xmm0
xor    %ecx,%ecx
movss  0xbc0(%rip),%xmm1
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
cvttss2si %xmm2,%edx
movslq %edx,%rdx
movss  (%r14,%rdx,4),%xmm2
movss  %xmm2,(%rbx,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
cvttss2si %xmm2,%edx
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm2
movss  %xmm2,0x4(%rbx,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
cvttss2si %xmm2,%edx
movslq %edx,%rdx
movss  (%r12,%rdx,4),%xmm2
movss  %xmm2,0x8(%rbx,%rcx,4)
add    $0x3,%rcx
cmp    %rax,%rcx
jl     1440 <equalize_image+0x310>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rdx),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     17e9 <equalize_image+0x6b9>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
mov    (%rsp),%rcx
lea    (%r14,%rcx,4),%rcx
add    $0x10,%rcx
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rcx,%rdi,4),%xmm2
movups (%rcx,%rdi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%rcx,%rdi,4)
divps  %xmm1,%xmm3
movups %xmm3,(%rcx,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1500 <equalize_image+0x3d0>
test   $0x1,%bpl
je     1535 <equalize_image+0x405>
movups (%r12,%rdi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r12,%rdi,4)
cmp    %r13,%rdx
je     1559 <equalize_image+0x429>
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1540 <equalize_image+0x410>
movslq %r10d,%rdx
test   %r8d,%r8d
jle    13f2 <equalize_image+0x2c2>
mov    %r8,%rcx
mov    %r8d,%r8d
mov    %r8,%r9
add    $0xffffffffffffffff,%r9
je     17d5 <equalize_image+0x6a5>
mov    %r8d,%esi
and    $0xfffffffe,%esi
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
movss  0xa75(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rbp,4),%xmm2
movss  0x4(%r14,%rbp,4),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
addsd  %xmm0,%xmm4
mulss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
addsd  %xmm4,%xmm0
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm2,(%r14,%rbp,4)
movss  %xmm3,0x4(%r14,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    1590 <equalize_image+0x460>
test   $0x1,%r8b
je     1627 <equalize_image+0x4f7>
movss  (%r14,%rbp,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
addsd  %xmm2,%xmm0
mulss  0x9f6(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r14,%rbp,4)
movl   $0x0,(%r14)
movl   $0x3f800000,(%r14,%rdx,4)
3f
test   %ecx,%ecx
jle    1401 <equalize_image+0x2d1>
test   %r9,%r9
je     17fa <equalize_image+0x6ca>
mov    %r8d,%esi
and    $0xfffffffe,%esi
lea    (%r14,%r13,4),%rdi
add    $0x4,%rdi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
movss  0x99d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rdi,%rbp,4),%xmm2
movss  (%rdi,%rbp,4),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
addsd  %xmm0,%xmm4
mulss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
addsd  %xmm4,%xmm0
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm2,-0x4(%rdi,%rbp,4)
movss  %xmm3,(%rdi,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    1670 <equalize_image+0x540>
test   $0x1,%r8b
je     1703 <equalize_image+0x5d3>
movss  (%r15,%rbp,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
addsd  %xmm2,%xmm0
mulss  0x91a(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r15,%rbp,4)
movl   $0x0,(%r15)
movl   $0x3f800000,(%r15,%rdx,4)
3f
test   %ecx,%ecx
jle    1410 <equalize_image+0x2e0>
test   %r9,%r9
je     180f <equalize_image+0x6df>
mov    %r8d,%esi
and    $0xfffffffe,%esi
mov    (%rsp),%rcx
lea    (%r14,%rcx,4),%rbp
add    $0x4,%rbp
xorpd  %xmm0,%xmm0
xor    %edi,%edi
movss  0x8bd(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rbp,%rdi,4),%xmm2
movss  0x0(%rbp,%rdi,4),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
addsd  %xmm0,%xmm4
mulss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
addsd  %xmm4,%xmm0
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm2,-0x4(%rbp,%rdi,4)
movss  %xmm3,0x0(%rbp,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    1750 <equalize_image+0x620>
jmp    1815 <equalize_image+0x6e5>
xor    %edi,%edi
test   $0x1,%bpl
jne    12fc <equalize_image+0x1cc>
jmp    1309 <equalize_image+0x1d9>
xor    %edi,%edi
test   $0x1,%bpl
jne    13a8 <equalize_image+0x278>
jmp    13b5 <equalize_image+0x285>
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
test   $0x1,%r8b
jne    15f9 <equalize_image+0x4c9>
jmp    1627 <equalize_image+0x4f7>
xor    %edi,%edi
test   $0x1,%bpl
jne    1528 <equalize_image+0x3f8>
jmp    1535 <equalize_image+0x405>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
test   $0x1,%r8b
jne    16d5 <equalize_image+0x5a5>
jmp    1703 <equalize_image+0x5d3>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
test   $0x1,%r8b
je     1410 <equalize_image+0x2e0>
movss  (%r12,%rdi,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
addsd  %xmm2,%xmm0
mulss  0x7d0(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r12,%rdi,4)
jmp    1410 <equalize_image+0x2e0>

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

LLVM IR (-O2):
define i32 @equalize_image(float* nocapture %0, i32 %1, i32 %2, i32 %3) {
%5 = sext i32 %1 to i64
%6 = sext i32 %2 to i64
%7 = mul nsw i64 %6, %5
%8 = mul nsw i64 %7, 3
%9 = add nsw i32 %3, -1
%10 = sext i32 %3 to i64
%11 = mul i32 %3, 12
%12 = tail call i64 @MallocWithErrorMessage(i32 %11)
%13 = inttoptr i64 %12 to float*
%14 = icmp eq i64 %12, 0
br i1 %14, label %388, label %15
15: ; preds = %4
%16 = getelementptr inbounds float, float* %13, i64 %10
%17 = shl nsw i32 %3, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds float, float* %13, i64 %18
%20 = icmp sgt i32 %3, 0
%21 = shl nuw nsw i64 %10, 2
br i1 %20, label %24, label %28
22: ; preds = %28
%23 = sitofp i32 %9 to float
br label %75
24: ; preds = %15
%25 = inttoptr i64 %12 to i8*
%26 = bitcast float* %16 to i8*
%27 = bitcast float* %19 to i8*
br label %28
28: ; preds = %15, %24
%29 = icmp sgt i64 %7, 0
br i1 %29, label %22, label %30
30: ; preds = %75, %28
%31 = sitofp i64 %7 to float
br i1 %20, label %32, label %214
32: ; preds = %30
%33 = icmp ult i32 %3, 4
br i1 %33, label %73, label %34
34: ; preds = %32
%35 = and i64 %10, -4
%36 = insertelement <4 x float> poison, float %31, i64 0
%37 = shufflevector <4 x float> %36, <4 x float> poison, <4 x i32> zeroinitializer
%38 = add nsw i64 %35, -4
%39 = lshr exact i64 %38, 2
%40 = add nuw nsw i64 %39, 1
%41 = and i64 %40, 1
%42 = icmp eq i64 %38, 0
br i1 %42, label %62, label %43
43: ; preds = %34
%44 = and i64 %40, 9223372036854775806
br label %45
45: ; preds = %45, %43
%46 = phi i64 [ 0, %43 ], [ %59, %45 ]
%47 = phi i64 [ 0, %43 ], [ %60, %45 ]
%48 = getelementptr inbounds float, float* %13, i64 %46
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = fdiv <4 x float> %50, %37
%52 = bitcast float* %48 to <4 x float>*
store <4 x float> %51, <4 x float>* %52
%53 = or i64 %46, 4
%54 = getelementptr inbounds float, float* %13, i64 %53
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = fdiv <4 x float> %56, %37
%58 = bitcast float* %54 to <4 x float>*
store <4 x float> %57, <4 x float>* %58
%59 = add nuw i64 %46, 8
%60 = add i64 %47, 2
%61 = icmp eq i64 %60, %44
br i1 %61, label %62, label %45
62: ; preds = %45, %34
%63 = phi i64 [ 0, %34 ], [ %59, %45 ]
%64 = icmp eq i64 %41, 0
br i1 %64, label %71, label %65
65: ; preds = %62
%66 = getelementptr inbounds float, float* %13, i64 %63
%67 = bitcast float* %66 to <4 x float>*
%68 = load <4 x float>, <4 x float>* %67
%69 = fdiv <4 x float> %68, %37
%70 = bitcast float* %66 to <4 x float>*
store <4 x float> %69, <4 x float>* %70
br label %71
71: ; preds = %62, %65
%72 = icmp eq i64 %35, %10
br i1 %72, label %112, label %73
73: ; preds = %32, %71
%74 = phi i64 [ 0, %32 ], [ %35, %71 ]
br label %105
75: ; preds = %22, %75
%76 = phi i64 [ 0, %22 ], [ %103, %75 ]
%77 = getelementptr inbounds float, float* %0, i64 %76
%78 = load float, float* %77
%79 = tail call float @llvm.fmuladd.f32(float %78, float %23, float 5.000000e-01)
%80 = fptosi float %79 to i32
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %13, i64 %81
%83 = load float, float* %82
%84 = fadd float %83, 1.000000e+00
store float %84, float* %82
%85 = add nuw nsw i64 %76, 1
%86 = getelementptr inbounds float, float* %0, i64 %85
%87 = load float, float* %86
%88 = tail call float @llvm.fmuladd.f32(float %87, float %23, float 5.000000e-01)
%89 = fptosi float %88 to i32
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %16, i64 %90
%92 = load float, float* %91
%93 = fadd float %92, 1.000000e+00
store float %93, float* %91
%94 = add nuw nsw i64 %76, 2
%95 = getelementptr inbounds float, float* %0, i64 %94
%96 = load float, float* %95
%97 = tail call float @llvm.fmuladd.f32(float %96, float %23, float 5.000000e-01)
%98 = fptosi float %97 to i32
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %19, i64 %99
%101 = load float, float* %100
%102 = fadd float %101, 1.000000e+00
store float %102, float* %100
%103 = add nuw nsw i64 %76, 3
%104 = icmp slt i64 %103, %8
br i1 %104, label %75, label %30
105: ; preds = %73, %105
%106 = phi i64 [ %110, %105 ], [ %74, %73 ]
%107 = getelementptr inbounds float, float* %13, i64 %106
%108 = load float, float* %107
%109 = fdiv float %108, %31
store float %109, float* %107
%110 = add nuw nsw i64 %106, 1
%111 = icmp eq i64 %110, %10
br i1 %111, label %112, label %105
112: ; preds = %105, %71
br i1 %20, label %113, label %214
113: ; preds = %112
%114 = icmp ult i32 %3, 4
br i1 %114, label %154, label %115
115: ; preds = %113
%116 = and i64 %10, -4
%117 = insertelement <4 x float> poison, float %31, i64 0
%118 = shufflevector <4 x float> %117, <4 x float> poison, <4 x i32> zeroinitializer
%119 = add nsw i64 %116, -4
%120 = lshr exact i64 %119, 2
%121 = add nuw nsw i64 %120, 1
%122 = and i64 %121, 1
%123 = icmp eq i64 %119, 0
br i1 %123, label %143, label %124
124: ; preds = %115
%125 = and i64 %121, 9223372036854775806
br label %126
126: ; preds = %126, %124
%127 = phi i64 [ 0, %124 ], [ %140, %126 ]
%128 = phi i64 [ 0, %124 ], [ %141, %126 ]
%129 = getelementptr inbounds float, float* %16, i64 %127
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = fdiv <4 x float> %131, %118
%133 = bitcast float* %129 to <4 x float>*
store <4 x float> %132, <4 x float>* %133
%134 = or i64 %127, 4
%135 = getelementptr inbounds float, float* %16, i64 %134
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = fdiv <4 x float> %137, %118
%139 = bitcast float* %135 to <4 x float>*
store <4 x float> %138, <4 x float>* %139
%140 = add nuw i64 %127, 8
%141 = add i64 %128, 2
%142 = icmp eq i64 %141, %125
br i1 %142, label %143, label %126
143: ; preds = %126, %115
%144 = phi i64 [ 0, %115 ], [ %140, %126 ]
%145 = icmp eq i64 %122, 0
br i1 %145, label %152, label %146
146: ; preds = %143
%147 = getelementptr inbounds float, float* %16, i64 %144
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = fdiv <4 x float> %149, %118
%151 = bitcast float* %147 to <4 x float>*
store <4 x float> %150, <4 x float>* %151
br label %152
152: ; preds = %143, %146
%153 = icmp eq i64 %116, %10
br i1 %153, label %163, label %154
154: ; preds = %113, %152
%155 = phi i64 [ 0, %113 ], [ %116, %152 ]
br label %156
156: ; preds = %154, %156
%157 = phi i64 [ %161, %156 ], [ %155, %154 ]
%158 = getelementptr inbounds float, float* %16, i64 %157
%159 = load float, float* %158
%160 = fdiv float %159, %31
store float %160, float* %158
%161 = add nuw nsw i64 %157, 1
%162 = icmp eq i64 %161, %10
br i1 %162, label %163, label %156
163: ; preds = %156, %152
br i1 %20, label %164, label %214
164: ; preds = %163
%165 = icmp ult i32 %3, 4
br i1 %165, label %205, label %166
166: ; preds = %164
%167 = and i64 %10, -4
%168 = insertelement <4 x float> poison, float %31, i64 0
%169 = shufflevector <4 x float> %168, <4 x float> poison, <4 x i32> zeroinitializer
%170 = add nsw i64 %167, -4
%171 = lshr exact i64 %170, 2
%172 = add nuw nsw i64 %171, 1
%173 = and i64 %172, 1
%174 = icmp eq i64 %170, 0
br i1 %174, label %194, label %175
175: ; preds = %166
%176 = and i64 %172, 9223372036854775806
br label %177
177: ; preds = %177, %175
%178 = phi i64 [ 0, %175 ], [ %191, %177 ]
%179 = phi i64 [ 0, %175 ], [ %192, %177 ]
%180 = getelementptr inbounds float, float* %19, i64 %178
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = fdiv <4 x float> %182, %169
%184 = bitcast float* %180 to <4 x float>*
store <4 x float> %183, <4 x float>* %184
%185 = or i64 %178, 4
%186 = getelementptr inbounds float, float* %19, i64 %185
%187 = bitcast float* %186 to <4 x float>*
%188 = load <4 x float>, <4 x float>* %187
%189 = fdiv <4 x float> %188, %169
%190 = bitcast float* %186 to <4 x float>*
store <4 x float> %189, <4 x float>* %190
%191 = add nuw i64 %178, 8
%192 = add i64 %179, 2
%193 = icmp eq i64 %192, %176
br i1 %193, label %194, label %177
194: ; preds = %177, %166
%195 = phi i64 [ 0, %166 ], [ %191, %177 ]
%196 = icmp eq i64 %173, 0
br i1 %196, label %203, label %197
197: ; preds = %194
%198 = getelementptr inbounds float, float* %19, i64 %195
%199 = bitcast float* %198 to <4 x float>*
%200 = load <4 x float>, <4 x float>* %199
%201 = fdiv <4 x float> %200, %169
%202 = bitcast float* %198 to <4 x float>*
store <4 x float> %201, <4 x float>* %202
br label %203
203: ; preds = %194, %197
%204 = icmp eq i64 %167, %10
br i1 %204, label %216, label %205
205: ; preds = %164, %203
%206 = phi i64 [ 0, %164 ], [ %167, %203 ]
br label %207
207: ; preds = %205, %207
%208 = phi i64 [ %212, %207 ], [ %206, %205 ]
%209 = getelementptr inbounds float, float* %19, i64 %208
%210 = load float, float* %209
%211 = fdiv float %210, %31
store float %211, float* %209
%212 = add nuw nsw i64 %208, 1
%213 = icmp eq i64 %212, %10
br i1 %213, label %216, label %207
214: ; preds = %163, %112, %30
%215 = sext i32 %9 to i64
br label %251
216: ; preds = %207, %203
%217 = sext i32 %9 to i64
br i1 %20, label %218, label %251
218: ; preds = %216
%219 = zext i32 %3 to i64
%220 = add nsw i64 %219, -1
%221 = and i64 %219, 1
%222 = icmp eq i64 %220, 0
br i1 %222, label %254, label %223
223: ; preds = %218
%224 = and i64 %219, 4294967294
br label %227
225: ; preds = %358
%226 = sitofp i32 %9 to float
br label %361
227: ; preds = %227, %223
%228 = phi i64 [ 0, %223 ], [ %248, %227 ]
%229 = phi double [ 0.000000e+00, %223 ], [ %243, %227 ]
%230 = phi i64 [ 0, %223 ], [ %249, %227 ]
%231 = getelementptr inbounds float, float* %13, i64 %228
%232 = load float, float* %231
%233 = fpext float %232 to double
%234 = fadd double %229, %233
%235 = fmul float %232, 5.000000e-01
%236 = fpext float %235 to double
%237 = fsub double %234, %236
%238 = fptrunc double %237 to float
store float %238, float* %231
%239 = or i64 %228, 1
%240 = getelementptr inbounds float, float* %13, i64 %239
%241 = load float, float* %240
%242 = fpext float %241 to double
%243 = fadd double %234, %242
%244 = fmul float %241, 5.000000e-01
%245 = fpext float %244 to double
%246 = fsub double %243, %245
%247 = fptrunc double %246 to float
store float %247, float* %240
%248 = add nuw nsw i64 %228, 2
%249 = add i64 %230, 2
%250 = icmp eq i64 %249, %224
br i1 %250, label %254, label %227
251: ; preds = %214, %216
%252 = phi i64 [ %217, %216 ], [ %215, %214 ]
store float 0.000000e+00, float* %13
%253 = getelementptr inbounds float, float* %13, i64 %252
store float 1.000000e+00, float* %253
br label %298
254: ; preds = %227, %218
%255 = phi i64 [ 0, %218 ], [ %248, %227 ]
%256 = phi double [ 0.000000e+00, %218 ], [ %243, %227 ]
%257 = icmp eq i64 %221, 0
br i1 %257, label %267, label %258
258: ; preds = %254
%259 = getelementptr inbounds float, float* %13, i64 %255
%260 = load float, float* %259
%261 = fpext float %260 to double
%262 = fadd double %256, %261
%263 = fmul float %260, 5.000000e-01
%264 = fpext float %263 to double
%265 = fsub double %262, %264
%266 = fptrunc double %265 to float
store float %266, float* %259
br label %267
267: ; preds = %254, %258
store float 0.000000e+00, float* %13
%268 = getelementptr inbounds float, float* %13, i64 %217
store float 1.000000e+00, float* %268
br i1 %20, label %269, label %298
269: ; preds = %267
%270 = and i64 %219, 1
%271 = icmp eq i64 %220, 0
br i1 %271, label %301, label %272
272: ; preds = %269
%273 = and i64 %219, 4294967294
br label %274
274: ; preds = %274, %272
%275 = phi i64 [ 0, %272 ], [ %295, %274 ]
%276 = phi double [ 0.000000e+00, %272 ], [ %290, %274 ]
%277 = phi i64 [ 0, %272 ], [ %296, %274 ]
%278 = getelementptr inbounds float, float* %16, i64 %275
%279 = load float, float* %278
%280 = fpext float %279 to double
%281 = fadd double %276, %280
%282 = fmul float %279, 5.000000e-01
%283 = fpext float %282 to double
%284 = fsub double %281, %283
%285 = fptrunc double %284 to float
store float %285, float* %278
%286 = or i64 %275, 1
%287 = getelementptr inbounds float, float* %16, i64 %286
%288 = load float, float* %287
%289 = fpext float %288 to double
%290 = fadd double %281, %289
%291 = fmul float %288, 5.000000e-01
%292 = fpext float %291 to double
%293 = fsub double %290, %292
%294 = fptrunc double %293 to float
store float %294, float* %287
%295 = add nuw nsw i64 %275, 2
%296 = add i64 %277, 2
%297 = icmp eq i64 %296, %273
br i1 %297, label %301, label %274
298: ; preds = %251, %267
%299 = phi i64 [ %217, %267 ], [ %252, %251 ]
store float 0.000000e+00, float* %16
%300 = getelementptr inbounds float, float* %16, i64 %299
store float 1.000000e+00, float* %300
br label %358
301: ; preds = %274, %269
%302 = phi i64 [ 0, %269 ], [ %295, %274 ]
%303 = phi double [ 0.000000e+00, %269 ], [ %290, %274 ]
%304 = icmp eq i64 %270, 0
br i1 %304, label %314, label %305
305: ; preds = %301
%306 = getelementptr inbounds float, float* %16, i64 %302
%307 = load float, float* %306
%308 = fpext float %307 to double
%309 = fadd double %303, %308
%310 = fmul float %307, 5.000000e-01
%311 = fpext float %310 to double
%312 = fsub double %309, %311
%313 = fptrunc double %312 to float
store float %313, float* %306
br label %314
314: ; preds = %301, %305
store float 0.000000e+00, float* %16
%315 = getelementptr inbounds float, float* %16, i64 %217
store float 1.000000e+00, float* %315
br i1 %20, label %316, label %358
316: ; preds = %314
%317 = and i64 %219, 1
%318 = icmp eq i64 %220, 0
br i1 %318, label %345, label %319
319: ; preds = %316
%320 = and i64 %219, 4294967294
br label %321
321: ; preds = %321, %319
%322 = phi i64 [ 0, %319 ], [ %342, %321 ]
%323 = phi double [ 0.000000e+00, %319 ], [ %337, %321 ]
%324 = phi i64 [ 0, %319 ], [ %343, %321 ]
%325 = getelementptr inbounds float, float* %19, i64 %322
%326 = load float, float* %325
%327 = fpext float %326 to double
%328 = fadd double %323, %327
%329 = fmul float %326, 5.000000e-01
%330 = fpext float %329 to double
%331 = fsub double %328, %330
%332 = fptrunc double %331 to float
store float %332, float* %325
%333 = or i64 %322, 1
%334 = getelementptr inbounds float, float* %19, i64 %333
%335 = load float, float* %334
%336 = fpext float %335 to double
%337 = fadd double %328, %336
%338 = fmul float %335, 5.000000e-01
%339 = fpext float %338 to double
%340 = fsub double %337, %339
%341 = fptrunc double %340 to float
store float %341, float* %334
%342 = add nuw nsw i64 %322, 2
%343 = add i64 %324, 2
%344 = icmp eq i64 %343, %320
br i1 %344, label %345, label %321
345: ; preds = %321, %316
%346 = phi i64 [ 0, %316 ], [ %342, %321 ]
%347 = phi double [ 0.000000e+00, %316 ], [ %337, %321 ]
%348 = icmp eq i64 %317, 0
br i1 %348, label %358, label %349
349: ; preds = %345
%350 = getelementptr inbounds float, float* %19, i64 %346
%351 = load float, float* %350
%352 = fpext float %351 to double
%353 = fadd double %347, %352
%354 = fmul float %351, 5.000000e-01
%355 = fpext float %354 to double
%356 = fsub double %353, %355
%357 = fptrunc double %356 to float
store float %357, float* %350
br label %358
358: ; preds = %349, %345, %298, %314
%359 = phi i64 [ %299, %298 ], [ %217, %314 ], [ %217, %345 ], [ %217, %349 ]
store float 0.000000e+00, float* %19
%360 = getelementptr inbounds float, float* %19, i64 %359
store float 1.000000e+00, float* %360
br i1 %29, label %225, label %388
361: ; preds = %225, %361
%362 = phi i64 [ 0, %225 ], [ %386, %361 ]
%363 = getelementptr inbounds float, float* %0, i64 %362
%364 = load float, float* %363
%365 = tail call float @llvm.fmuladd.f32(float %364, float %226, float 5.000000e-01)
%366 = fptosi float %365 to i32
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %13, i64 %367
%369 = load float, float* %368
store float %369, float* %363
%370 = add nuw nsw i64 %362, 1
%371 = getelementptr inbounds float, float* %0, i64 %370
%372 = load float, float* %371
%373 = tail call float @llvm.fmuladd.f32(float %372, float %226, float 5.000000e-01)
%374 = fptosi float %373 to i32
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds float, float* %16, i64 %375
%377 = load float, float* %376
store float %377, float* %371
%378 = add nuw nsw i64 %362, 2
%379 = getelementptr inbounds float, float* %0, i64 %378
%380 = load float, float* %379
%381 = tail call float @llvm.fmuladd.f32(float %380, float %226, float 5.000000e-01)
%382 = fptosi float %381 to i32
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds float, float* %19, i64 %383
%385 = load float, float* %384
store float %385, float* %379
%386 = add nuw nsw i64 %362, 3
%387 = icmp slt i64 %386, %8
br i1 %387, label %361, label %388
388: ; preds = %361, %358, %4
%389 = phi i32 [ 0, %4 ], [ 1, %358 ], [ 1, %361 ]
%390 = tail call i32 @free(float* %13)
ret i32 %389
}