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

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