#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 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    $0x90,%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)
movss  -0x14(%rbp),%xmm0
call   1030 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jge    1159 <interpBC_b+0x49>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x5,%eax
cmp    -0xc(%rbp),%eax
jle    1171 <interpBC_b+0x61>
mov    -0xc(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
movss  -0x18(%rbp),%xmm0
call   1030 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    1192 <interpBC_b+0x82>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
cmp    -0x10(%rbp),%eax
jle    11aa <interpBC_b+0x9a>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    124d <interpBC_b+0x13d>
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
add    %edx,%ecx
mov    -0xc(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rax
movzbl 0x1(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rax
movzbl 0x2(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rax
movzbl 0x3(%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b1 <interpBC_b+0xa1>
movl   $0x1,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    13a7 <interpBC_b+0x297>
movl   $0x3,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jl     1394 <interpBC_b+0x284>
movss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movslq -0x2c(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm1
movss  -0x40(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm2
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x60(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm1
movss  -0x40(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm2
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x70(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
movss  -0x40(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm2
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x80(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movss  -0x40(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1265 <interpBC_b+0x155>
jmp    1399 <interpBC_b+0x289>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1254 <interpBC_b+0x144>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    146b <interpBC_b+0x35b>
movl   $0x3,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jl     1458 <interpBC_b+0x348>
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x38(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x30(%rbp),%xmm2
divss  %xmm2,%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm2
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x50(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ea <interpBC_b+0x2da>
jmp    145d <interpBC_b+0x34d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13d9 <interpBC_b+0x2c9>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1489 <interpBC_b+0x379>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb66(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    14b1 <interpBC_b+0x3a1>
movss  0xb5c(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
cvttss2si -0x44(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
xor    %eax,%eax
add    $0x90,%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) {
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca [4 x float]
%22 = alloca [4 x float]
%23 = alloca [4 x float]
%24 = alloca [4 x float]
%25 = alloca [4 x float]
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store float %3, float* %11
store float %4, float* %12
store float %5, float* %13
store i8* %6, i8** %14
%26 = load float, float* %11
%27 = call i64 @ceilf(float %26)
%28 = trunc i64 %27 to i32
%29 = sub nsw i32 %28, 2
store i32 %29, i32* %18
%30 = load i32, i32* %18
%31 = icmp slt i32 %30, 0
br i1 %31, label %32, label %33
32: ; preds = %7
store i32 0, i32* %18
br label %33
33: ; preds = %32, %7
%34 = load i32, i32* %18
%35 = add nsw i32 %34, 5
%36 = load i32, i32* %9
%37 = icmp sgt i32 %35, %36
br i1 %37, label %38, label %41
38: ; preds = %33
%39 = load i32, i32* %9
%40 = sub nsw i32 %39, 4
store i32 %40, i32* %18
br label %41
41: ; preds = %38, %33
%42 = load float, float* %12
%43 = call i64 @ceilf(float %42)
%44 = trunc i64 %43 to i32
%45 = sub nsw i32 %44, 2
store i32 %45, i32* %19
%46 = load i32, i32* %19
%47 = icmp slt i32 %46, 0
br i1 %47, label %48, label %49
48: ; preds = %41
store i32 0, i32* %19
br label %49
49: ; preds = %48, %41
%50 = load i32, i32* %19
%51 = add nsw i32 %50, 5
%52 = load i32, i32* %10
%53 = icmp sgt i32 %51, %52
br i1 %53, label %54, label %57
54: ; preds = %49
%55 = load i32, i32* %10
%56 = sub nsw i32 %55, 4
store i32 %56, i32* %19
br label %57
57: ; preds = %54, %49
store i32 0, i32* %15
br label %58
58: ; preds = %108, %57
%59 = load i32, i32* %15
%60 = icmp slt i32 %59, 4
br i1 %60, label %61, label %111
61: ; preds = %58
%62 = load i32, i32* %18
%63 = load i32, i32* %15
%64 = load i32, i32* %19
%65 = add nsw i32 %63, %64
%66 = load i32, i32* %9
%67 = mul nsw i32 %65, %66
%68 = add nsw i32 %62, %67
store i32 %68, i32* %17
%69 = load i8*, i8** %8
%70 = load i32, i32* %17
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8, i8* %72
%74 = uitofp i8 %73 to float
%75 = load i32, i32* %15
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 %76
store float %74, float* %77
%78 = load i8*, i8** %8
%79 = load i32, i32* %17
%80 = add nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %78, i64 %81
%83 = load i8, i8* %82
%84 = uitofp i8 %83 to float
%85 = load i32, i32* %15
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 %86
store float %84, float* %87
%88 = load i8*, i8** %8
%89 = load i32, i32* %17
%90 = add nsw i32 %89, 2
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %88, i64 %91
%93 = load i8, i8* %92
%94 = uitofp i8 %93 to float
%95 = load i32, i32* %15
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 %96
store float %94, float* %97
%98 = load i8*, i8** %8
%99 = load i32, i32* %17
%100 = add nsw i32 %99, 3
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %98, i64 %101
%103 = load i8, i8* %102
%104 = uitofp i8 %103 to float
%105 = load i32, i32* %15
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 %106
store float %104, float* %107
br label %108
108: ; preds = %61
%109 = load i32, i32* %15
%110 = add nsw i32 %109, 1
store i32 %110, i32* %15
br label %58
111: ; preds = %58
store i32 1, i32* %16
br label %112
112: ; preds = %211, %111
%113 = load i32, i32* %16
%114 = icmp slt i32 %113, 4
br i1 %114, label %115, label %214
115: ; preds = %112
store i32 3, i32* %15
br label %116
116: ; preds = %207, %115
%117 = load i32, i32* %15
%118 = load i32, i32* %16
%119 = icmp sge i32 %117, %118
br i1 %119, label %120, label %210
120: ; preds = %116
%121 = load float, float* %12
%122 = load i32, i32* %15
%123 = sitofp i32 %122 to float
%124 = fsub float %121, %123
%125 = load i32, i32* %19
%126 = sitofp i32 %125 to float
%127 = fsub float %124, %126
%128 = load i32, i32* %16
%129 = sitofp i32 %128 to float
%130 = fdiv float %127, %129
store float %130, float* %20
%131 = load i32, i32* %15
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 %132
%134 = load float, float* %133
%135 = load float, float* %20
%136 = load i32, i32* %15
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 %137
%139 = load float, float* %138
%140 = load i32, i32* %15
%141 = sub nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 %142
%144 = load float, float* %143
%145 = fsub float %139, %144
%146 = call float @llvm.fmuladd.f32(float %135, float %145, float %134)
%147 = load i32, i32* %15
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 %148
store float %146, float* %149
%150 = load i32, i32* %15
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 %151
%153 = load float, float* %152
%154 = load float, float* %20
%155 = load i32, i32* %15
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 %156
%158 = load float, float* %157
%159 = load i32, i32* %15
%160 = sub nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 %161
%163 = load float, float* %162
%164 = fsub float %158, %163
%165 = call float @llvm.fmuladd.f32(float %154, float %164, float %153)
%166 = load i32, i32* %15
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 %167
store float %165, float* %168
%169 = load i32, i32* %15
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 %170
%172 = load float, float* %171
%173 = load float, float* %20
%174 = load i32, i32* %15
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 %175
%177 = load float, float* %176
%178 = load i32, i32* %15
%179 = sub nsw i32 %178, 1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 %180
%182 = load float, float* %181
%183 = fsub float %177, %182
%184 = call float @llvm.fmuladd.f32(float %173, float %183, float %172)
%185 = load i32, i32* %15
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 %186
store float %184, float* %187
%188 = load i32, i32* %15
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 %189
%191 = load float, float* %190
%192 = load float, float* %20
%193 = load i32, i32* %15
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 %194
%196 = load float, float* %195
%197 = load i32, i32* %15
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 %199
%201 = load float, float* %200
%202 = fsub float %196, %201
%203 = call float @llvm.fmuladd.f32(float %192, float %202, float %191)
%204 = load i32, i32* %15
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 %205
store float %203, float* %206
br label %207
207: ; preds = %120
%208 = load i32, i32* %15
%209 = add nsw i32 %208, -1
store i32 %209, i32* %15
br label %116
210: ; preds = %116
br label %211
211: ; preds = %210
%212 = load i32, i32* %16
%213 = add nsw i32 %212, 1
store i32 %213, i32* %16
br label %112
214: ; preds = %112
%215 = getelementptr inbounds [4 x float], [4 x float]* %22, i64 0, i64 3
%216 = load float, float* %215
%217 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 0
store float %216, float* %217
%218 = getelementptr inbounds [4 x float], [4 x float]* %23, i64 0, i64 3
%219 = load float, float* %218
%220 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 1
store float %219, float* %220
%221 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 3
%222 = load float, float* %221
%223 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 2
store float %222, float* %223
%224 = getelementptr inbounds [4 x float], [4 x float]* %25, i64 0, i64 3
%225 = load float, float* %224
%226 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
store float %225, float* %226
store i32 1, i32* %16
br label %227
227: ; preds = %268, %214
%228 = load i32, i32* %16
%229 = icmp slt i32 %228, 4
br i1 %229, label %230, label %271
230: ; preds = %227
store i32 3, i32* %15
br label %231
231: ; preds = %264, %230
%232 = load i32, i32* %15
%233 = load i32, i32* %16
%234 = icmp sge i32 %232, %233
br i1 %234, label %235, label %267
235: ; preds = %231
%236 = load i32, i32* %15
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 %237
%239 = load float, float* %238
%240 = load float, float* %11
%241 = load i32, i32* %15
%242 = sitofp i32 %241 to float
%243 = fsub float %240, %242
%244 = load i32, i32* %18
%245 = sitofp i32 %244 to float
%246 = fsub float %243, %245
%247 = load i32, i32* %16
%248 = sitofp i32 %247 to float
%249 = fdiv float %246, %248
%250 = load i32, i32* %15
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 %251
%253 = load float, float* %252
%254 = load i32, i32* %15
%255 = sub nsw i32 %254, 1
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 %256
%258 = load float, float* %257
%259 = fsub float %253, %258
%260 = call float @llvm.fmuladd.f32(float %249, float %259, float %239)
%261 = load i32, i32* %15
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 %262
store float %260, float* %263
br label %264
264: ; preds = %235
%265 = load i32, i32* %15
%266 = add nsw i32 %265, -1
store i32 %266, i32* %15
br label %231
267: ; preds = %231
br label %268
268: ; preds = %267
%269 = load i32, i32* %16
%270 = add nsw i32 %269, 1
store i32 %270, i32* %16
br label %227
271: ; preds = %227
%272 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
%273 = load float, float* %272
%274 = fpext float %273 to double
%275 = fcmp olt double %274, 0.000000e+00
br i1 %275, label %276, label %278
276: ; preds = %271
%277 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
store float 0.000000e+00, float* %277
br label %278
278: ; preds = %276, %271
%279 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
%280 = load float, float* %279
%281 = fpext float %280 to double
%282 = fcmp ogt double %281, 2.560000e+02
br i1 %282, label %283, label %285
283: ; preds = %278
%284 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
store float 2.550000e+02, float* %284
br label %285
285: ; preds = %283, %278
%286 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 3
%287 = load float, float* %286
%288 = fptoui float %287 to i8
%289 = load i8*, i8** %14
store i8 %288, i8* %289
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) {
%8 = tail call i64 @ceilf(float %3)
%9 = trunc i64 %8 to i32
%10 = icmp sgt i32 %9, 2
%11 = select i1 %10, i32 %9, i32 2
%12 = add nsw i32 %11, -2
%13 = add nuw nsw i32 %11, 3
%14 = icmp sgt i32 %13, %1
%15 = add nsw i32 %1, -4
%16 = select i1 %14, i32 %15, i32 %12
%17 = tail call i64 @ceilf(float %4)
%18 = trunc i64 %17 to i32
%19 = icmp sgt i32 %18, 2
%20 = select i1 %19, i32 %18, i32 2
%21 = add nsw i32 %20, -2
%22 = add nuw nsw i32 %20, 3
%23 = icmp sgt i32 %22, %2
%24 = add nsw i32 %2, -4
%25 = select i1 %23, i32 %24, i32 %21
%26 = sext i32 %25 to i64
%27 = sext i32 %1 to i64
%28 = sext i32 %16 to i64
%29 = mul nsw i64 %26, %27
%30 = add nsw i64 %29, %28
%31 = add nsw i64 %26, 1
%32 = mul nsw i64 %31, %27
%33 = add nsw i64 %32, %28
%34 = getelementptr inbounds i8, i8* %0, i64 %33
%35 = bitcast i8* %34 to <2 x i8>*
%36 = load <2 x i8>, <2 x i8>* %35
%37 = uitofp <2 x i8> %36 to <2 x float>
%38 = add nsw i64 %33, 2
%39 = getelementptr inbounds i8, i8* %0, i64 %38
%40 = bitcast i8* %39 to <2 x i8>*
%41 = load <2 x i8>, <2 x i8>* %40
%42 = uitofp <2 x i8> %41 to <2 x float>
%43 = add nsw i64 %26, 2
%44 = mul nsw i64 %43, %27
%45 = add nsw i64 %44, %28
%46 = getelementptr inbounds i8, i8* %0, i64 %45
%47 = bitcast i8* %46 to <2 x i8>*
%48 = load <2 x i8>, <2 x i8>* %47
%49 = uitofp <2 x i8> %48 to <2 x float>
%50 = add nsw i64 %45, 2
%51 = getelementptr inbounds i8, i8* %0, i64 %50
%52 = bitcast i8* %51 to <2 x i8>*
%53 = load <2 x i8>, <2 x i8>* %52
%54 = uitofp <2 x i8> %53 to <2 x float>
%55 = add nsw i64 %26, 3
%56 = mul nsw i64 %55, %27
%57 = add nsw i64 %56, %28
%58 = getelementptr inbounds i8, i8* %0, i64 %57
%59 = bitcast i8* %58 to <2 x i8>*
%60 = load <2 x i8>, <2 x i8>* %59
%61 = uitofp <2 x i8> %60 to <2 x float>
%62 = add nsw i64 %57, 2
%63 = getelementptr inbounds i8, i8* %0, i64 %62
%64 = bitcast i8* %63 to <2 x i8>*
%65 = load <2 x i8>, <2 x i8>* %64
%66 = uitofp <2 x i8> %65 to <2 x float>
%67 = sitofp i32 %25 to float
%68 = add nsw i64 %30, 2
%69 = getelementptr inbounds i8, i8* %0, i64 %68
%70 = bitcast i8* %69 to <2 x i8>*
%71 = load <2 x i8>, <2 x i8>* %70
%72 = uitofp <2 x i8> %71 to <2 x float>
%73 = getelementptr inbounds i8, i8* %0, i64 %30
%74 = bitcast i8* %73 to <2 x i8>*
%75 = load <2 x i8>, <2 x i8>* %74
%76 = uitofp <2 x i8> %75 to <2 x float>
%77 = fadd float %4, -3.000000e+00
%78 = fsub float %77, %67
%79 = fsub <2 x float> %61, %49
%80 = insertelement <2 x float> poison, float %78, i64 0
%81 = shufflevector <2 x float> %80, <2 x float> poison, <2 x i32> zeroinitializer
%82 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %81, <2 x float> %79, <2 x float> %61)
%83 = fsub <2 x float> %66, %54
%84 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %81, <2 x float> %83, <2 x float> %66)
%85 = fadd float %4, -2.000000e+00
%86 = fsub float %85, %67
%87 = fsub <2 x float> %49, %37
%88 = insertelement <2 x float> poison, float %86, i64 0
%89 = shufflevector <2 x float> %88, <2 x float> poison, <2 x i32> zeroinitializer
%90 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %87, <2 x float> %49)
%91 = fsub <2 x float> %54, %42
%92 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %91, <2 x float> %54)
%93 = fadd float %4, -1.000000e+00
%94 = fsub float %93, %67
%95 = fsub <2 x float> %37, %76
%96 = insertelement <2 x float> poison, float %94, i64 0
%97 = shufflevector <2 x float> %96, <2 x float> poison, <2 x i32> zeroinitializer
%98 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %97, <2 x float> %95, <2 x float> %37)
%99 = fsub <2 x float> %42, %72
%100 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %97, <2 x float> %99, <2 x float> %42)
%101 = fadd float %4, -3.000000e+00
%102 = fsub float %101, %67
%103 = fmul float %102, 5.000000e-01
%104 = fsub <2 x float> %82, %90
%105 = insertelement <2 x float> poison, float %103, i64 0
%106 = shufflevector <2 x float> %105, <2 x float> poison, <2 x i32> zeroinitializer
%107 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %106, <2 x float> %104, <2 x float> %82)
%108 = fsub <2 x float> %84, %92
%109 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %106, <2 x float> %108, <2 x float> %84)
%110 = fadd float %4, -2.000000e+00
%111 = fsub float %110, %67
%112 = fmul float %111, 5.000000e-01
%113 = fsub <2 x float> %90, %98
%114 = insertelement <2 x float> poison, float %112, i64 0
%115 = shufflevector <2 x float> %114, <2 x float> poison, <2 x i32> zeroinitializer
%116 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %115, <2 x float> %113, <2 x float> %90)
%117 = fsub <2 x float> %92, %100
%118 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %115, <2 x float> %117, <2 x float> %92)
%119 = fadd float %4, -3.000000e+00
%120 = fsub float %119, %67
%121 = fdiv float %120, 3.000000e+00
%122 = fsub <2 x float> %107, %116
%123 = insertelement <2 x float> poison, float %121, i64 0
%124 = shufflevector <2 x float> %123, <2 x float> poison, <2 x i32> zeroinitializer
%125 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %122, <2 x float> %107)
%126 = fsub <2 x float> %109, %118
%127 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %126, <2 x float> %109)
%128 = sitofp i32 %16 to float
%129 = insertelement <2 x float> poison, float %3, i64 0
%130 = shufflevector <2 x float> %129, <2 x float> poison, <2 x i32> zeroinitializer
%131 = fadd <2 x float> %130, <float -2.000000e+00, float -3.000000e+00>
%132 = insertelement <2 x float> poison, float %128, i64 0
%133 = shufflevector <2 x float> %132, <2 x float> poison, <2 x i32> zeroinitializer
%134 = fsub <2 x float> %131, %133
%135 = extractelement <2 x float> %125, i64 1
%136 = shufflevector <2 x float> %125, <2 x float> %127, <2 x i32> <i32 1, i32 2>
%137 = fsub <2 x float> %127, %136
%138 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %134, <2 x float> %137, <2 x float> %127)
%139 = fadd float %3, -1.000000e+00
%140 = fsub float %139, %128
%141 = extractelement <2 x float> %125, i64 0
%142 = fsub float %135, %141
%143 = tail call float @llvm.fmuladd.f32(float %140, float %142, float %135)
%144 = fadd <2 x float> %130, <float -2.000000e+00, float -3.000000e+00>
%145 = fsub <2 x float> %144, %133
%146 = fmul <2 x float> %145, <float 5.000000e-01, float 5.000000e-01>
%147 = insertelement <2 x float> poison, float %143, i64 0
%148 = shufflevector <2 x float> %147, <2 x float> %138, <2 x i32> <i32 0, i32 2>
%149 = fsub <2 x float> %138, %148
%150 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %146, <2 x float> %149, <2 x float> %138)
%151 = fadd float %3, -3.000000e+00
%152 = fsub float %151, %128
%153 = fdiv float %152, 3.000000e+00
%154 = extractelement <2 x float> %150, i64 0
%155 = extractelement <2 x float> %150, i64 1
%156 = fsub float %155, %154
%157 = tail call float @llvm.fmuladd.f32(float %153, float %156, float %155)
%158 = fcmp olt float %157, 0.000000e+00
br i1 %158, label %162, label %159
159: ; preds = %7
%160 = fcmp ogt float %157, 2.560000e+02
br i1 %160, label %161, label %162
161: ; preds = %159
br label %162
162: ; preds = %7, %161, %159
%163 = phi float [ 2.550000e+02, %161 ], [ %157, %159 ], [ 0.000000e+00, %7 ]
%164 = fptoui float %163 to i8
store i8 %164, i8* %6
ret i32 0
}