#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__ ceilf(float);
int interpBC_b(unsigned char *sl, int w, int h, float x, float y, float o,
               unsigned char *v, int is_alpha) {
  int i, j, l, m, n;
  float k;
  float p[4], p1[4], p2[4], p3[4], p4[4];
  m = (int)ceilf(x) - 2;
  if (m < 0)
    m = 0;
  if ((m + 5) > w)
    m = w - 4;
  n = (int)ceilf(y) - 2;
  if (n < 0)
    n = 0;
  if ((n + 5) > h)
    n = h - 4;
  for (i = 0; i < 4; i++) {
    l = m + (i + n) * w;
    p1[i] = sl[l];
    p2[i] = sl[l + 1];
    p3[i] = sl[l + 2];
    p4[i] = sl[l + 3];
  }
  for (j = 1; j < 4; j++)
    for (i = 3; i >= j; i--) {
      k = (y - i - n) / j;
      p1[i] = p1[i] + k * (p1[i] - p1[i - 1]);
      p2[i] = p2[i] + k * (p2[i] - p2[i - 1]);
      p3[i] = p3[i] + k * (p3[i] - p3[i - 1]);
      p4[i] = p4[i] + k * (p4[i] - p4[i - 1]);
    }
  p[0] = p1[3];
  p[1] = p2[3];
  p[2] = p3[3];
  p[3] = p4[3];
  for (j = 1; j < 4; j++)
    for (i = 3; i >= j; i--)
      p[i] = p[i] + (x - i - m) / j * (p[i] - p[i - 1]);
  if (p[3] < 0.0)
    p[3] = 0.0;
  if (p[3] > 256.0)
    p[3] = 255.0;
  *v = p[3];
  return 0;
}


x86 assembly (clang, -O0):
<interpBC_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    115d <interpBC_b+0x4d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
cmp    -0xc(%rbp),%eax
jle    1175 <interpBC_b+0x65>
mov    -0xc(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x3c(%rbp)
movss  -0x18(%rbp),%xmm0
call   1030 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    1196 <interpBC_b+0x86>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x5,%eax
cmp    -0x10(%rbp),%eax
jle    11ae <interpBC_b+0x9e>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    1254 <interpBC_b+0x144>
mov    -0x3c(%rbp),%eax
mov    -0x30(%rbp),%ecx
mov    -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0xc(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x8(%rbp),%rcx
movslq -0x38(%rbp),%rax
movzbl 0x1(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
mov    -0x8(%rbp),%rcx
movslq -0x38(%rbp),%rax
movzbl 0x2(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%rcx
movslq -0x38(%rbp),%rax
movzbl 0x3(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b5 <interpBC_b+0xa5>
movl   $0x1,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    13ba <interpBC_b+0x2aa>
movl   $0x3,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     13a7 <interpBC_b+0x297>
movss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movslq -0x30(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm1
movss  -0x44(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x70(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x30(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
movss  -0x44(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x80(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
movslq -0x30(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movss  -0x44(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
movslq -0x30(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x44(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0xa0(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    126c <interpBC_b+0x15c>
jmp    13ac <interpBC_b+0x29c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    125b <interpBC_b+0x14b>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x58(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1481 <interpBC_b+0x371>
movl   $0x3,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     146e <interpBC_b+0x35e>
movslq -0x30(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm1
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x34(%rbp),%xmm2
divss  %xmm2,%xmm0
movslq -0x30(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x60(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1400 <interpBC_b+0x2f0>
jmp    1473 <interpBC_b+0x363>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ef <interpBC_b+0x2df>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    149f <interpBC_b+0x38f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb50(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    14c7 <interpBC_b+0x3b7>
movss  0xb46(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
cvttss2si -0x54(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpBC_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r14
movaps %xmm1,(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %edx,%r12d
mov    %esi,%r13d
mov    %rdi,%r15
call   1030 <ceilf@plt>
cmp    $0x3,%eax
mov    $0x2,%ebx
cmovl  %ebx,%eax
lea    -0x2(%rax),%ecx
add    $0x3,%eax
lea    -0x4(%r13),%ebp
cmp    %r13d,%eax
cmovle %ecx,%ebp
movaps (%rsp),%xmm0
call   1030 <ceilf@plt>
cmp    $0x3,%eax
cmovge %eax,%ebx
lea    -0x2(%rbx),%eax
add    $0x3,%ebx
lea    -0x4(%r12),%ecx
cmp    %r12d,%ebx
cmovle %eax,%ecx
movslq %ecx,%rdx
movslq %r13d,%rcx
movslq %ebp,%rax
lea    0x1(%rdx),%rsi
imul   %rcx,%rsi
add    %rax,%rsi
movzwl (%r15,%rsi,1),%edi
movd   %edi,%xmm0
lea    0x2(%rdx),%rdi
lea    0x3(%rdx),%rbx
cvtsi2ss %edx,%xmm7
imul   %rcx,%rdx
add    %rax,%rdx
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm10
movzwl 0x2(%r15,%rsi,1),%esi
movd   %esi,%xmm0
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm9
imul   %rcx,%rdi
add    %rax,%rdi
movzwl (%r15,%rdi,1),%esi
movd   %esi,%xmm0
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm0
movzwl 0x2(%r15,%rdi,1),%esi
movd   %esi,%xmm1
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
cvtdq2ps %xmm1,%xmm1
imul   %rcx,%rbx
add    %rax,%rbx
movzwl (%r15,%rbx,1),%ecx
movd   %ecx,%xmm3
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
cvtdq2ps %xmm3,%xmm3
movzwl 0x2(%r15,%rbx,1),%ecx
movd   %ecx,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
cvtdq2ps %xmm4,%xmm6
movzwl 0x2(%r15,%rdx,1),%ecx
movd   %ecx,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
cvtdq2ps %xmm4,%xmm11
movzwl (%r15,%rdx,1),%ecx
movd   %ecx,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
cvtdq2ps %xmm4,%xmm12
movss  0xda3(%rip),%xmm8
movaps (%rsp),%xmm4
movaps %xmm4,%xmm14
addss  %xmm8,%xmm14
subss  %xmm7,%xmm14
movaps %xmm3,%xmm5
subps  %xmm0,%xmm5
movaps %xmm14,%xmm2
shufps $0x0,%xmm14,%xmm2
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movaps %xmm6,%xmm15
subps  %xmm1,%xmm15
mulps  %xmm2,%xmm15
addps  %xmm6,%xmm15
movss  0xd68(%rip),%xmm3
addss  %xmm4,%xmm3
subss  %xmm7,%xmm3
movaps %xmm0,%xmm6
subps  %xmm10,%xmm6
movaps %xmm3,%xmm2
shufps $0x0,%xmm3,%xmm2
mulps  %xmm2,%xmm6
addps  %xmm0,%xmm6
movaps %xmm1,%xmm0
subps  %xmm9,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0xd3a(%rip),%xmm13
movaps %xmm4,%xmm2
addss  %xmm13,%xmm2
subss  %xmm7,%xmm2
movaps %xmm10,%xmm1
subps  %xmm12,%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm1
movaps %xmm2,%xmm4
addps  %xmm10,%xmm1
movaps %xmm9,%xmm2
subps  %xmm11,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm9,%xmm2
movss  0xd04(%rip),%xmm9
movaps %xmm14,%xmm4
mulss  %xmm9,%xmm4
movaps %xmm5,%xmm7
subps  %xmm6,%xmm7
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm7
addps  %xmm5,%xmm7
movaps %xmm15,%xmm5
subps  %xmm0,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm15,%xmm5
mulss  %xmm9,%xmm3
movaps %xmm6,%xmm4
subps  %xmm1,%xmm4
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movaps %xmm0,%xmm6
subps  %xmm2,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm0,%xmm6
movss  0xcb8(%rip),%xmm3
divss  %xmm3,%xmm14
movaps %xmm7,%xmm1
subps  %xmm4,%xmm1
shufps $0x0,%xmm14,%xmm14
mulps  %xmm14,%xmm1
addps  %xmm7,%xmm1
movaps %xmm5,%xmm0
subps  %xmm6,%xmm0
mulps  %xmm14,%xmm0
addps  %xmm5,%xmm0
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
movaps 0x10(%rsp),%xmm4
movaps %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm2
addps  0xc8a(%rip),%xmm2
addss  %xmm4,%xmm13
subss  %xmm5,%xmm13
addss  %xmm8,%xmm4
subss  %xmm5,%xmm4
movaps %xmm4,%xmm7
shufps $0x0,%xmm5,%xmm5
subps  %xmm5,%xmm2
movaps %xmm1,%xmm4
shufps $0x55,%xmm1,%xmm4
movaps %xmm0,%xmm5
shufps $0x10,%xmm1,%xmm5
shufps $0xe2,%xmm1,%xmm5
movaps %xmm0,%xmm6
subps  %xmm5,%xmm6
mulps  %xmm2,%xmm6
addps  %xmm0,%xmm6
movaps %xmm4,%xmm0
subss  %xmm1,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm4,%xmm0
mulps  0xc48(%rip),%xmm2
unpcklps %xmm6,%xmm0
movaps %xmm6,%xmm4
subps  %xmm0,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movaps %xmm7,%xmm2
divss  %xmm3,%xmm2
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
movaps %xmm0,%xmm1
subss  %xmm4,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
ja     1430 <interpBC_b+0x320>
ucomiss 0xbf1(%rip),%xmm1
movaps %xmm1,%xmm0
jbe    1430 <interpBC_b+0x320>
movss  0xbe8(%rip),%xmm0
cvttss2si %xmm0,%eax
mov    %al,(%r14)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @interpBC_b(i8* nocapture %0, i32 %1, i32 %2, float %3, float %4, float %5, i8* nocapture writeonly %6, i32 %7) {
%9 = tail call i64 @ceilf(float %3)
%10 = trunc i64 %9 to i32
%11 = icmp sgt i32 %10, 2
%12 = select i1 %11, i32 %10, i32 2
%13 = add nsw i32 %12, -2
%14 = add nuw nsw i32 %12, 3
%15 = icmp sgt i32 %14, %1
%16 = add nsw i32 %1, -4
%17 = select i1 %15, i32 %16, i32 %13
%18 = tail call i64 @ceilf(float %4)
%19 = trunc i64 %18 to i32
%20 = icmp sgt i32 %19, 2
%21 = select i1 %20, i32 %19, i32 2
%22 = add nsw i32 %21, -2
%23 = add nuw nsw i32 %21, 3
%24 = icmp sgt i32 %23, %2
%25 = add nsw i32 %2, -4
%26 = select i1 %24, i32 %25, i32 %22
%27 = sext i32 %26 to i64
%28 = sext i32 %1 to i64
%29 = sext i32 %17 to i64
%30 = mul nsw i64 %27, %28
%31 = add nsw i64 %30, %29
%32 = add nsw i64 %27, 1
%33 = mul nsw i64 %32, %28
%34 = add nsw i64 %33, %29
%35 = getelementptr inbounds i8, i8* %0, i64 %34
%36 = bitcast i8* %35 to <2 x i8>*
%37 = load <2 x i8>, <2 x i8>* %36
%38 = uitofp <2 x i8> %37 to <2 x float>
%39 = add nsw i64 %34, 2
%40 = getelementptr inbounds i8, i8* %0, i64 %39
%41 = bitcast i8* %40 to <2 x i8>*
%42 = load <2 x i8>, <2 x i8>* %41
%43 = uitofp <2 x i8> %42 to <2 x float>
%44 = add nsw i64 %27, 2
%45 = mul nsw i64 %44, %28
%46 = add nsw i64 %45, %29
%47 = getelementptr inbounds i8, i8* %0, i64 %46
%48 = bitcast i8* %47 to <2 x i8>*
%49 = load <2 x i8>, <2 x i8>* %48
%50 = uitofp <2 x i8> %49 to <2 x float>
%51 = add nsw i64 %46, 2
%52 = getelementptr inbounds i8, i8* %0, i64 %51
%53 = bitcast i8* %52 to <2 x i8>*
%54 = load <2 x i8>, <2 x i8>* %53
%55 = uitofp <2 x i8> %54 to <2 x float>
%56 = add nsw i64 %27, 3
%57 = mul nsw i64 %56, %28
%58 = add nsw i64 %57, %29
%59 = getelementptr inbounds i8, i8* %0, i64 %58
%60 = bitcast i8* %59 to <2 x i8>*
%61 = load <2 x i8>, <2 x i8>* %60
%62 = uitofp <2 x i8> %61 to <2 x float>
%63 = add nsw i64 %58, 2
%64 = getelementptr inbounds i8, i8* %0, i64 %63
%65 = bitcast i8* %64 to <2 x i8>*
%66 = load <2 x i8>, <2 x i8>* %65
%67 = uitofp <2 x i8> %66 to <2 x float>
%68 = sitofp i32 %26 to float
%69 = add nsw i64 %31, 2
%70 = getelementptr inbounds i8, i8* %0, i64 %69
%71 = bitcast i8* %70 to <2 x i8>*
%72 = load <2 x i8>, <2 x i8>* %71
%73 = uitofp <2 x i8> %72 to <2 x float>
%74 = getelementptr inbounds i8, i8* %0, i64 %31
%75 = bitcast i8* %74 to <2 x i8>*
%76 = load <2 x i8>, <2 x i8>* %75
%77 = uitofp <2 x i8> %76 to <2 x float>
%78 = fadd float %4, -3.000000e+00
%79 = fsub float %78, %68
%80 = fsub <2 x float> %62, %50
%81 = insertelement <2 x float> poison, float %79, i64 0
%82 = shufflevector <2 x float> %81, <2 x float> poison, <2 x i32> zeroinitializer
%83 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %82, <2 x float> %80, <2 x float> %62)
%84 = fsub <2 x float> %67, %55
%85 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %82, <2 x float> %84, <2 x float> %67)
%86 = fadd float %4, -2.000000e+00
%87 = fsub float %86, %68
%88 = fsub <2 x float> %50, %38
%89 = insertelement <2 x float> poison, float %87, i64 0
%90 = shufflevector <2 x float> %89, <2 x float> poison, <2 x i32> zeroinitializer
%91 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %90, <2 x float> %88, <2 x float> %50)
%92 = fsub <2 x float> %55, %43
%93 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %90, <2 x float> %92, <2 x float> %55)
%94 = fadd float %4, -1.000000e+00
%95 = fsub float %94, %68
%96 = fsub <2 x float> %38, %77
%97 = insertelement <2 x float> poison, float %95, i64 0
%98 = shufflevector <2 x float> %97, <2 x float> poison, <2 x i32> zeroinitializer
%99 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %96, <2 x float> %38)
%100 = fsub <2 x float> %43, %73
%101 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %100, <2 x float> %43)
%102 = fadd float %4, -3.000000e+00
%103 = fsub float %102, %68
%104 = fmul float %103, 5.000000e-01
%105 = fsub <2 x float> %83, %91
%106 = insertelement <2 x float> poison, float %104, i64 0
%107 = shufflevector <2 x float> %106, <2 x float> poison, <2 x i32> zeroinitializer
%108 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %107, <2 x float> %105, <2 x float> %83)
%109 = fsub <2 x float> %85, %93
%110 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %107, <2 x float> %109, <2 x float> %85)
%111 = fadd float %4, -2.000000e+00
%112 = fsub float %111, %68
%113 = fmul float %112, 5.000000e-01
%114 = fsub <2 x float> %91, %99
%115 = insertelement <2 x float> poison, float %113, i64 0
%116 = shufflevector <2 x float> %115, <2 x float> poison, <2 x i32> zeroinitializer
%117 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %114, <2 x float> %91)
%118 = fsub <2 x float> %93, %101
%119 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %118, <2 x float> %93)
%120 = fadd float %4, -3.000000e+00
%121 = fsub float %120, %68
%122 = fdiv float %121, 3.000000e+00
%123 = fsub <2 x float> %108, %117
%124 = insertelement <2 x float> poison, float %122, i64 0
%125 = shufflevector <2 x float> %124, <2 x float> poison, <2 x i32> zeroinitializer
%126 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %125, <2 x float> %123, <2 x float> %108)
%127 = fsub <2 x float> %110, %119
%128 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %125, <2 x float> %127, <2 x float> %110)
%129 = sitofp i32 %17 to float
%130 = insertelement <2 x float> poison, float %3, i64 0
%131 = shufflevector <2 x float> %130, <2 x float> poison, <2 x i32> zeroinitializer
%132 = fadd <2 x float> %131, <float -2.000000e+00, float -3.000000e+00>
%133 = insertelement <2 x float> poison, float %129, i64 0
%134 = shufflevector <2 x float> %133, <2 x float> poison, <2 x i32> zeroinitializer
%135 = fsub <2 x float> %132, %134
%136 = extractelement <2 x float> %126, i64 1
%137 = shufflevector <2 x float> %126, <2 x float> %128, <2 x i32> <i32 1, i32 2>
%138 = fsub <2 x float> %128, %137
%139 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %135, <2 x float> %138, <2 x float> %128)
%140 = fadd float %3, -1.000000e+00
%141 = fsub float %140, %129
%142 = extractelement <2 x float> %126, i64 0
%143 = fsub float %136, %142
%144 = tail call float @llvm.fmuladd.f32(float %141, float %143, float %136)
%145 = fadd <2 x float> %131, <float -2.000000e+00, float -3.000000e+00>
%146 = fsub <2 x float> %145, %134
%147 = fmul <2 x float> %146, <float 5.000000e-01, float 5.000000e-01>
%148 = insertelement <2 x float> poison, float %144, i64 0
%149 = shufflevector <2 x float> %148, <2 x float> %139, <2 x i32> <i32 0, i32 2>
%150 = fsub <2 x float> %139, %149
%151 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %147, <2 x float> %150, <2 x float> %139)
%152 = fadd float %3, -3.000000e+00
%153 = fsub float %152, %129
%154 = fdiv float %153, 3.000000e+00
%155 = extractelement <2 x float> %151, i64 0
%156 = extractelement <2 x float> %151, i64 1
%157 = fsub float %156, %155
%158 = tail call float @llvm.fmuladd.f32(float %154, float %157, float %156)
%159 = fcmp olt float %158, 0.000000e+00
br i1 %159, label %163, label %160
160: ; preds = %8
%161 = fcmp ogt float %158, 2.560000e+02
br i1 %161, label %162, label %163
162: ; preds = %160
br label %163
163: ; preds = %8, %162, %160
%164 = phi float [ 2.550000e+02, %162 ], [ %158, %160 ], [ 0.000000e+00, %8 ]
%165 = fptoui float %164 to i8
store i8 %165, i8* %6
ret i32 0
}