#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__ floorf(float);
int interpBL_b32(unsigned char *sl, int w, int h, float x, float y, float o,
                 unsigned char *v, int is_atop) {
  int m, n, k, l, n1, l1, k1;
  float a, b;
  m = (int)floorf(x);
  if (m + 2 > w)
    m = w - 2;
  n = (int)floorf(y);
  if (n + 2 > h)
    n = h - 2;
  k = n * w + m;
  l = (n + 1) * w + m;
  k1 = 4 * (k + 1);
  l1 = 4 * (l + 1);
  n1 = 4 * ((n + 1) * w + m);
  l = 4 * l;
  k = 4 * k;
  a = sl[k + 3] + (sl[k1 + 3] - sl[k + 3]) * (x - (float)m);
  b = sl[l + 3] + (sl[l1 + 3] - sl[n1 + 3]) * (x - (float)m);
  float alpha_sl = a + (b - a) * (y - (float)n);
  float alpha_v = (float)v[3] / 255.0f;
  if (is_atop)
    v[3] = alpha_sl;
  alpha_sl = alpha_sl / 255.0f * o;
  float alpha = alpha_sl + alpha_v - alpha_sl * alpha_v;
  if (!is_atop)
    v[3] = 255 * alpha;
  alpha = alpha_sl / alpha;
  a = sl[k] + (sl[k1] - sl[k]) * (x - (float)m);
  b = sl[l] + (sl[l1] - sl[n1]) * (x - (float)m);
  v[0] = v[0] * (1.0f - alpha) + (a + (b - a) * (y - (float)n)) * alpha;
  a = sl[k + 1] + (sl[k1 + 1] - sl[k + 1]) * (x - (float)m);
  b = sl[l + 1] + (sl[l1 + 1] - sl[n1 + 1]) * (x - (float)m);
  v[1] = v[1] * (1.0f - alpha) + (a + (b - a) * (y - (float)n)) * alpha;
  a = sl[k + 2] + (sl[k1 + 2] - sl[k + 2]) * (x - (float)m);
  b = sl[l + 2] + (sl[l1 + 2] - sl[n1 + 2]) * (x - (float)m);
  v[2] = v[2] * (1.0f - alpha) + (a + (b - a) * (y - (float)n)) * alpha;
  return 0;
}


x86 assembly (clang, -O0):
<interpBL_b32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  %xmm2,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movss  -0x14(%rbp),%xmm0
call   1030 <floorf@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
cmp    -0xc(%rbp),%eax
jle    115e <interpBL_b32+0x4e>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
movss  -0x18(%rbp),%xmm0
call   1030 <floorf@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
cmp    -0x10(%rbp),%eax
jle    1183 <interpBL_b32+0x73>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   %ecx,%eax
mov    -0x30(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%ecx
imul   %ecx,%eax
mov    -0x30(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%ecx
mov    %ecx,%eax
lea    0x4(,%rax,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%ecx
mov    %ecx,%eax
lea    0x4(,%rax,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%ecx
imul   %ecx,%eax
mov    -0x30(%rbp),%ecx
add    %ecx,%eax
shl    $0x2,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rdx
movslq -0x38(%rbp),%rax
movzbl 0x3(%rax,%rdx,1),%ecx
cvtsi2ss %ecx,%xmm1
movslq -0x48(%rbp),%rax
movzbl 0x3(%rax,%rdx,1),%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm2
cvtsi2ssl -0x30(%rbp),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rdx
movslq -0x3c(%rbp),%rax
movzbl 0x3(%rax,%rdx,1),%eax
cvtsi2ss %eax,%xmm1
movslq -0x44(%rbp),%rax
movzbl 0x3(%rax,%rdx,1),%eax
movslq -0x40(%rbp),%rcx
movzbl 0x3(%rcx,%rdx,1),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm2
cvtsi2ssl -0x30(%rbp),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm2
cvtsi2ssl -0x34(%rbp),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xd55(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     12cc <interpBL_b32+0x1bc>
cvttss2si -0x54(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
movss  -0x54(%rbp),%xmm0
movss  0xd27(%rip),%xmm1
divss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
addss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    133d <interpBL_b32+0x22d>
movss  -0x5c(%rbp),%xmm0
movss  0xcd4(%rip),%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
cvtsi2ss %ecx,%xmm1
movslq -0x48(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm2
cvtsi2ssl -0x30(%rbp),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rcx
movslq -0x3c(%rbp),%rax
movzbl (%rcx,%rax,1),%eax
cvtsi2ss %eax,%xmm1
movslq -0x44(%rbp),%rax
movzbl (%rcx,%rax,1),%eax
movslq -0x40(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm2
cvtsi2ssl -0x30(%rbp),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%ecx
cvtsi2ss %ecx,%xmm0
movss  -0x5c(%rbp),%xmm4
movss  0xc22(%rip),%xmm2
movaps %xmm2,%xmm3
subss  %xmm4,%xmm3
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm1
subss  %xmm5,%xmm1
movss  -0x18(%rbp),%xmm6
cvtsi2ssl -0x34(%rbp),%xmm7
subss  %xmm7,%xmm6
mulss  %xmm6,%xmm1
addss  %xmm5,%xmm1
mulss  %xmm4,%xmm1
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
mov    %cl,(%rax)
mov    -0x8(%rbp),%rdx
movslq -0x38(%rbp),%rax
movzbl 0x1(%rax,%rdx,1),%ecx
cvtsi2ss %ecx,%xmm1
movslq -0x48(%rbp),%rax
movzbl 0x1(%rax,%rdx,1),%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm3
cvtsi2ssl -0x30(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rdx
movslq -0x3c(%rbp),%rax
movzbl 0x1(%rax,%rdx,1),%eax
cvtsi2ss %eax,%xmm1
movslq -0x44(%rbp),%rax
movzbl 0x1(%rax,%rdx,1),%eax
movslq -0x40(%rbp),%rcx
movzbl 0x1(%rcx,%rdx,1),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm3
cvtsi2ssl -0x30(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%ecx
cvtsi2ss %ecx,%xmm0
movss  -0x5c(%rbp),%xmm4
movaps %xmm2,%xmm3
subss  %xmm4,%xmm3
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm1
subss  %xmm5,%xmm1
movss  -0x18(%rbp),%xmm6
cvtsi2ssl -0x34(%rbp),%xmm7
subss  %xmm7,%xmm6
mulss  %xmm6,%xmm1
addss  %xmm5,%xmm1
mulss  %xmm4,%xmm1
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rdx
movslq -0x38(%rbp),%rax
movzbl 0x2(%rax,%rdx,1),%ecx
cvtsi2ss %ecx,%xmm1
movslq -0x48(%rbp),%rax
movzbl 0x2(%rax,%rdx,1),%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm3
cvtsi2ssl -0x30(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rdx
movslq -0x3c(%rbp),%rax
movzbl 0x2(%rax,%rdx,1),%eax
cvtsi2ss %eax,%xmm1
movslq -0x44(%rbp),%rax
movzbl 0x2(%rax,%rdx,1),%eax
movslq -0x40(%rbp),%rcx
movzbl 0x2(%rcx,%rdx,1),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm3
cvtsi2ssl -0x30(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  -0x5c(%rbp),%xmm3
subss  %xmm3,%xmm2
movss  -0x4c(%rbp),%xmm4
movss  -0x50(%rbp),%xmm1
subss  %xmm4,%xmm1
movss  -0x18(%rbp),%xmm5
cvtsi2ssl -0x34(%rbp),%xmm6
subss  %xmm6,%xmm5
mulss  %xmm5,%xmm1
addss  %xmm4,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpBL_b32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,%r15d
mov    %rcx,%r14
movss  %xmm2,0xc(%rsp)
movss  %xmm1,0x10(%rsp)
movss  %xmm0,0x14(%rsp)
mov    %edx,%r13d
mov    %esi,%r12d
mov    %rdi,%rbx
call   1030 <floorf@plt>
lea    0x2(%rax),%ecx
lea    -0x2(%r12),%ebp
cmp    %r12d,%ecx
cmovle %eax,%ebp
movss  0x10(%rsp),%xmm0
call   1030 <floorf@plt>
movss  0x14(%rsp),%xmm7
movss  0x10(%rsp),%xmm6
lea    0x2(%rax),%edx
lea    -0x2(%r13),%ecx
cmp    %r13d,%edx
cmovle %eax,%ecx
lea    0x1(%rcx),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
mov    %ecx,%eax
imul   %r12d,%eax
add    %ebp,%eax
imul   %r12d,%edx
lea    0x0(,%rax,4),%ecx
movslq %ecx,%rcx
movzbl 0x3(%rbx,%rcx,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %ebp,%edx
lea    0x7(,%rax,4),%eax
cltq
movzbl (%rbx,%rax,1),%eax
sub    %esi,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
lea    0x0(,%rdx,4),%eax
cvtsi2ss %ebp,%xmm3
subss  %xmm3,%xmm7
mulss  %xmm7,%xmm2
addss  %xmm0,%xmm2
cltq
movzbl 0x3(%rbx,%rax,1),%esi
xorps  %xmm3,%xmm3
cvtsi2ss %esi,%xmm3
lea    0x7(,%rdx,4),%edx
movslq %edx,%rdx
movzbl (%rbx,%rdx,1),%edx
sub    %esi,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm7,%xmm0
addss  %xmm3,%xmm0
subss  %xmm2,%xmm0
subss  %xmm1,%xmm6
mulss  %xmm6,%xmm0
movzbl 0x3(%r14),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
addss  %xmm2,%xmm0
divss  0xdde(%rip),%xmm1
test   %r15d,%r15d
je     124e <interpBL_b32+0x13e>
cvttss2si %xmm0,%edx
mov    %dl,0x3(%r14)
divss  0xdc9(%rip),%xmm0
mulss  0xc(%rsp),%xmm0
movaps %xmm0,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm1
subss  %xmm2,%xmm1
jmp    127b <interpBL_b32+0x16b>
movss  0xdaa(%rip),%xmm2
divss  %xmm2,%xmm0
mulss  0xc(%rsp),%xmm0
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
addss  %xmm0,%xmm1
subss  %xmm3,%xmm1
mulss  %xmm1,%xmm2
cvttss2si %xmm2,%edx
mov    %dl,0x3(%r14)
movzbl (%rbx,%rcx,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
lea    0x4(%rcx),%esi
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%esi
sub    %edx,%esi
xorps  %xmm3,%xmm3
cvtsi2ss %esi,%xmm3
movzbl (%rbx,%rax,1),%edx
cvtsi2ss %edx,%xmm4
divss  %xmm1,%xmm0
lea    0x4(%rax),%esi
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%esi
sub    %edx,%esi
cvtsi2ss %esi,%xmm5
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm7,%xmm5
addss  %xmm4,%xmm5
movzbl (%r14),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
movss  0xd2c(%rip),%xmm1
subss  %xmm0,%xmm1
subss  %xmm3,%xmm5
mulss  %xmm6,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm0,%xmm5
mulss  %xmm1,%xmm2
addss  %xmm5,%xmm2
cvttss2si %xmm2,%edx
mov    %dl,(%r14)
mov    %rcx,%rdx
or     $0x1,%rdx
movzbl (%rbx,%rdx,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
lea    0x5(%rcx),%esi
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%esi
sub    %edx,%esi
xorps  %xmm3,%xmm3
cvtsi2ss %esi,%xmm3
mulss  %xmm7,%xmm3
mov    %rax,%rdx
or     $0x1,%rdx
movzbl (%rbx,%rdx,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
addss  %xmm2,%xmm3
lea    0x5(%rax),%esi
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%esi
sub    %edx,%esi
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
movzbl 0x1(%r14),%edx
xorps  %xmm5,%xmm5
cvtsi2ss %edx,%xmm5
mulss  %xmm7,%xmm2
addss  %xmm4,%xmm2
subss  %xmm3,%xmm2
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm1,%xmm5
addss  %xmm2,%xmm5
cvttss2si %xmm5,%edx
mov    %dl,0x1(%r14)
mov    %rcx,%rdx
or     $0x2,%rdx
movzbl (%rbx,%rdx,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
add    $0x6,%ecx
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%ecx
sub    %edx,%ecx
xorps  %xmm3,%xmm3
cvtsi2ss %ecx,%xmm3
mulss  %xmm7,%xmm3
mov    %rax,%rcx
or     $0x2,%rcx
movzbl (%rbx,%rcx,1),%ecx
xorps  %xmm4,%xmm4
cvtsi2ss %ecx,%xmm4
addss  %xmm2,%xmm3
add    $0x6,%eax
cltq
movzbl (%rbx,%rax,1),%eax
sub    %ecx,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movzbl 0x2(%r14),%eax
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
mulss  %xmm7,%xmm2
addss  %xmm4,%xmm2
subss  %xmm3,%xmm2
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm1,%xmm5
addss  %xmm2,%xmm5
cvttss2si %xmm5,%eax
mov    %al,0x2(%r14)
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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