#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 interpBC2_b(unsigned char *sl, int w, int h, float x, float y, float o,
                unsigned char *v) {
  int i, k, l, m, n;
  float pp, p[4], wx[4], wy[4], xx;
  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;
  xx = y - n;
  wy[0] = (-0.75 * (xx - 5.0) * xx - 6.0) * xx + 3.0;
  xx = xx - 1.0;
  wy[1] = (1.25 * xx - 2.25) * xx * xx + 1.0;
  xx = 1.0 - xx;
  wy[2] = (1.25 * xx - 2.25) * xx * xx + 1.0;
  xx = xx + 1.0;
  wy[3] = (-0.75 * (xx - 5.0) * xx - 6.0) * xx + 3.0;
  xx = x - m;
  wx[0] = (-0.75 * (xx - 5.0) * xx - 6.0) * xx + 3.0;
  xx = xx - 1.0;
  wx[1] = (1.25 * xx - 2.25) * xx * xx + 1.0;
  xx = 1.0 - xx;
  wx[2] = (1.25 * xx - 2.25) * xx * xx + 1.0;
  xx = xx + 1.0;
  wx[3] = (-0.75 * (xx - 5.0) * xx - 6.0) * xx + 3.0;
  k = n * w + m;
  for (i = 0; i < 4; i++) {
    p[i] = 0.0;
    l = k + i;
    p[i] = wy[0] * sl[l];
    l += w;
    p[i] += wy[1] * sl[l];
    l += w;
    p[i] += wy[2] * sl[l];
    l += w;
    p[i] += wy[3] * sl[l];
  }
  pp = wx[0] * p[0];
  pp += wx[1] * p[1];
  pp += wx[2] * p[2];
  pp += wx[3] * p[3];
  if (pp < 0.0)
    pp = 0.0;
  if (pp > 256.0)
    pp = 255.0;
  *v = pp;
  return 0;
}


x86 assembly (clang, -O0):
<interpBC2_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%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 <interpBC2_b+0x49>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x5,%eax
cmp    -0xc(%rbp),%eax
jle    1171 <interpBC2_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 <interpBC2_b+0x82>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
cmp    -0x10(%rbp),%eax
jle    11aa <interpBC2_b+0x9a>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x3c(%rbp)
movss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe4a(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xe36(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe15(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xdf4(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdf6(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xddc(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xda6(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd88(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd72(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd6e(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd38(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd1a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcf4(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xce0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xcbf(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc9e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x38(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc85(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xc71(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc50(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc2f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc31(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc1b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc17(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbe1(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbc3(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbad(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xba9(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb73(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb55(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb2f(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xb1b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xafa(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xad9(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    163b <interpBC2_b+0x52b>
movslq -0x2c(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm2
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm2
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm2
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1548 <interpBC2_b+0x438>
movss  -0x60(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    16bc <interpBC2_b+0x5ac>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x96b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16e4 <interpBC2_b+0x5d4>
movss  0x961(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
cvttss2si -0x40(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpBC2_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r14
movss  %xmm1,(%rsp)
movss  %xmm0,0x4(%rsp)
mov    %edx,%r12d
mov    %esi,%r15d
mov    %rdi,%rbx
call   1030 <ceilf@plt>
cmp    $0x3,%eax
mov    $0x2,%ebp
cmovl  %ebp,%eax
lea    -0x2(%rax),%ecx
add    $0x3,%eax
lea    -0x4(%r15),%r13d
cmp    %r15d,%eax
cmovle %ecx,%r13d
movss  (%rsp),%xmm0
call   1030 <ceilf@plt>
cmp    $0x3,%eax
cmovge %eax,%ebp
lea    -0x2(%rbp),%ecx
add    $0x3,%ebp
lea    -0x4(%r12),%eax
cmp    %r12d,%ebp
cmovle %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  (%rsp),%xmm3
subss  %xmm0,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movsd  0xe6c(%rip),%xmm8
movaps %xmm1,%xmm2
addsd  %xmm8,%xmm2
movsd  0xe64(%rip),%xmm0
mulsd  %xmm0,%xmm2
movapd %xmm0,%xmm14
mulsd  %xmm1,%xmm2
movsd  0xe57(%rip),%xmm0
addsd  %xmm0,%xmm2
movapd %xmm0,%xmm6
mulsd  %xmm1,%xmm2
movsd  0xe4b(%rip),%xmm0
addsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm10
movss  0xe59(%rip),%xmm13
addss  %xmm13,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movsd  0xe2d(%rip),%xmm4
movaps %xmm1,%xmm2
mulsd  %xmm4,%xmm2
movsd  0xe25(%rip),%xmm11
addsd  %xmm11,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movsd  0xe17(%rip),%xmm12
addsd  %xmm12,%xmm2
cvtsd2ss %xmm2,%xmm15
movss  0xe10(%rip),%xmm9
movaps %xmm9,%xmm2
subss  %xmm3,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
movaps %xmm3,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm11,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm12,%xmm5
cvtsd2ss %xmm5,%xmm7
addss  %xmm9,%xmm2
cvtss2sd %xmm2,%xmm2
movaps %xmm2,%xmm3
addsd  %xmm8,%xmm3
mulsd  %xmm14,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm6,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
xorps  %xmm5,%xmm5
cvtsd2ss %xmm3,%xmm5
xorps  %xmm2,%xmm2
cvtsi2ss %r13d,%xmm2
imul   %r15d,%eax
add    %r13d,%eax
movslq %eax,%rcx
movslq %r15d,%rax
movzbl (%rbx,%rcx,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
lea    (%rcx,%rax,1),%rdx
movzbl (%rbx,%rdx,1),%esi
xorps  %xmm6,%xmm6
cvtsi2ss %esi,%xmm6
movss  0x4(%rsp),%xmm14
subss  %xmm2,%xmm14
mulss  %xmm10,%xmm3
mulss  %xmm15,%xmm6
add    %rax,%rdx
movzbl (%rbx,%rdx,1),%esi
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
addss  %xmm3,%xmm6
mulss  %xmm7,%xmm2
addss  %xmm6,%xmm2
add    %rax,%rdx
movzbl (%rbx,%rdx,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
movzbl 0x1(%rbx,%rcx,1),%edx
xorps  %xmm6,%xmm6
cvtsi2ss %edx,%xmm6
mulss  %xmm5,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm10,%xmm6
lea    0x1(%rcx,%rax,1),%rdx
movzbl (%rbx,%rdx,1),%esi
cvtsi2ss %esi,%xmm0
mulss  %xmm15,%xmm0
addss  %xmm6,%xmm0
add    %rax,%rdx
movzbl (%rbx,%rdx,1),%esi
add    %rax,%rdx
xorps  %xmm6,%xmm6
cvtsi2ss %esi,%xmm6
movzbl (%rbx,%rdx,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  %xmm7,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm2
movzbl 0x2(%rbx,%rcx,1),%edx
lea    0x2(%rcx,%rax,1),%rsi
cvtsi2ss %edx,%xmm1
movzbl (%rbx,%rsi,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
addss  %xmm6,%xmm2
mulss  %xmm10,%xmm1
mulss  %xmm15,%xmm0
add    %rax,%rsi
movzbl (%rbx,%rsi,1),%edx
xorps  %xmm6,%xmm6
cvtsi2ss %edx,%xmm6
addss  %xmm1,%xmm0
mulss  %xmm7,%xmm6
addss  %xmm0,%xmm6
add    %rax,%rsi
movzbl (%rbx,%rsi,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movzbl 0x3(%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
mulss  %xmm10,%xmm1
lea    0x3(%rcx,%rax,1),%rcx
movzbl (%rbx,%rcx,1),%edx
xorps  %xmm6,%xmm6
cvtsi2ss %edx,%xmm6
mulss  %xmm15,%xmm6
addss  %xmm1,%xmm6
add    %rax,%rcx
movzbl (%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm7,%xmm1
addss  %xmm14,%xmm13
addss  %xmm6,%xmm1
add    %rax,%rcx
movzbl (%rbx,%rcx,1),%eax
cvtsi2ss %eax,%xmm7
mulss  %xmm5,%xmm7
movaps %xmm9,%xmm5
subss  %xmm13,%xmm5
addss  %xmm5,%xmm9
addss  %xmm1,%xmm7
xorps  %xmm1,%xmm1
cvtss2sd %xmm9,%xmm1
movaps %xmm1,%xmm6
addsd  %xmm8,%xmm6
movsd  0xbe9(%rip),%xmm9
mulsd  %xmm9,%xmm6
mulsd  %xmm1,%xmm6
movsd  0xbdf(%rip),%xmm15
addsd  %xmm15,%xmm6
mulsd  %xmm1,%xmm6
movsd  0xbd5(%rip),%xmm10
addsd  %xmm10,%xmm6
xorps  %xmm1,%xmm1
cvtsd2ss %xmm6,%xmm1
cvtss2sd %xmm5,%xmm5
movaps %xmm5,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm11,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm12,%xmm6
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
mulss  %xmm7,%xmm1
mulss  %xmm0,%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm13,%xmm0
mulsd  %xmm0,%xmm4
addsd  %xmm11,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm12,%xmm4
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
mulss  %xmm2,%xmm0
cvtss2sd %xmm14,%xmm2
addsd  %xmm2,%xmm8
mulsd  %xmm9,%xmm8
mulsd  %xmm2,%xmm8
addsd  %xmm15,%xmm8
mulsd  %xmm2,%xmm8
addsd  %xmm10,%xmm8
xorps  %xmm2,%xmm2
cvtsd2ss %xmm8,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
addss  %xmm5,%xmm2
addss  %xmm1,%xmm2
xorps  %xmm0,%xmm0
maxss  %xmm2,%xmm0
movss  0xb52(%rip),%xmm1
cmpltss %xmm0,%xmm1
movss  0xb49(%rip),%xmm2
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm1,%xmm2
cvttss2si %xmm2,%eax
mov    %al,(%r14)
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @interpBC2_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 = sitofp i32 %25 to float
%27 = fsub float %4, %26
%28 = fpext float %27 to double
%29 = fadd double %28, -5.000000e+00
%30 = fmul double %29, -7.500000e-01
%31 = tail call double @llvm.fmuladd.f64(double %30, double %28, double -6.000000e+00)
%32 = tail call double @llvm.fmuladd.f64(double %31, double %28, double 3.000000e+00)
%33 = fptrunc double %32 to float
%34 = fadd float %27, -1.000000e+00
%35 = fpext float %34 to double
%36 = tail call double @llvm.fmuladd.f64(double %35, double 1.250000e+00, double -2.250000e+00)
%37 = fmul double %36, %35
%38 = tail call double @llvm.fmuladd.f64(double %37, double %35, double 1.000000e+00)
%39 = fptrunc double %38 to float
%40 = fsub float 1.000000e+00, %34
%41 = fpext float %40 to double
%42 = tail call double @llvm.fmuladd.f64(double %41, double 1.250000e+00, double -2.250000e+00)
%43 = fmul double %42, %41
%44 = tail call double @llvm.fmuladd.f64(double %43, double %41, double 1.000000e+00)
%45 = fptrunc double %44 to float
%46 = fadd float %40, 1.000000e+00
%47 = fpext float %46 to double
%48 = fadd double %47, -5.000000e+00
%49 = fmul double %48, -7.500000e-01
%50 = tail call double @llvm.fmuladd.f64(double %49, double %47, double -6.000000e+00)
%51 = tail call double @llvm.fmuladd.f64(double %50, double %47, double 3.000000e+00)
%52 = fptrunc double %51 to float
%53 = sitofp i32 %16 to float
%54 = fsub float %3, %53
%55 = fadd float %54, -1.000000e+00
%56 = fsub float 1.000000e+00, %55
%57 = fadd float %56, 1.000000e+00
%58 = mul nsw i32 %25, %1
%59 = add nsw i32 %58, %16
%60 = sext i32 %59 to i64
%61 = sext i32 %1 to i64
%62 = getelementptr inbounds i8, i8* %0, i64 %60
%63 = load i8, i8* %62
%64 = uitofp i8 %63 to float
%65 = fmul float %33, %64
%66 = add nsw i64 %60, %61
%67 = getelementptr inbounds i8, i8* %0, i64 %66
%68 = load i8, i8* %67
%69 = uitofp i8 %68 to float
%70 = tail call float @llvm.fmuladd.f32(float %39, float %69, float %65)
%71 = add nsw i64 %66, %61
%72 = getelementptr inbounds i8, i8* %0, i64 %71
%73 = load i8, i8* %72
%74 = uitofp i8 %73 to float
%75 = tail call float @llvm.fmuladd.f32(float %45, float %74, float %70)
%76 = add nsw i64 %71, %61
%77 = getelementptr inbounds i8, i8* %0, i64 %76
%78 = load i8, i8* %77
%79 = uitofp i8 %78 to float
%80 = tail call float @llvm.fmuladd.f32(float %52, float %79, float %75)
%81 = add nsw i64 %60, 1
%82 = getelementptr inbounds i8, i8* %0, i64 %81
%83 = load i8, i8* %82
%84 = uitofp i8 %83 to float
%85 = fmul float %33, %84
%86 = add nsw i64 %81, %61
%87 = getelementptr inbounds i8, i8* %0, i64 %86
%88 = load i8, i8* %87
%89 = uitofp i8 %88 to float
%90 = tail call float @llvm.fmuladd.f32(float %39, float %89, float %85)
%91 = add nsw i64 %86, %61
%92 = getelementptr inbounds i8, i8* %0, i64 %91
%93 = load i8, i8* %92
%94 = uitofp i8 %93 to float
%95 = tail call float @llvm.fmuladd.f32(float %45, float %94, float %90)
%96 = add nsw i64 %91, %61
%97 = getelementptr inbounds i8, i8* %0, i64 %96
%98 = load i8, i8* %97
%99 = uitofp i8 %98 to float
%100 = tail call float @llvm.fmuladd.f32(float %52, float %99, float %95)
%101 = add nsw i64 %60, 2
%102 = getelementptr inbounds i8, i8* %0, i64 %101
%103 = load i8, i8* %102
%104 = uitofp i8 %103 to float
%105 = fmul float %33, %104
%106 = add nsw i64 %101, %61
%107 = getelementptr inbounds i8, i8* %0, i64 %106
%108 = load i8, i8* %107
%109 = uitofp i8 %108 to float
%110 = tail call float @llvm.fmuladd.f32(float %39, float %109, float %105)
%111 = add nsw i64 %106, %61
%112 = getelementptr inbounds i8, i8* %0, i64 %111
%113 = load i8, i8* %112
%114 = uitofp i8 %113 to float
%115 = tail call float @llvm.fmuladd.f32(float %45, float %114, float %110)
%116 = add nsw i64 %111, %61
%117 = getelementptr inbounds i8, i8* %0, i64 %116
%118 = load i8, i8* %117
%119 = uitofp i8 %118 to float
%120 = tail call float @llvm.fmuladd.f32(float %52, float %119, float %115)
%121 = add nsw i64 %60, 3
%122 = getelementptr inbounds i8, i8* %0, i64 %121
%123 = load i8, i8* %122
%124 = uitofp i8 %123 to float
%125 = fmul float %33, %124
%126 = add nsw i64 %121, %61
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = load i8, i8* %127
%129 = uitofp i8 %128 to float
%130 = tail call float @llvm.fmuladd.f32(float %39, float %129, float %125)
%131 = add nsw i64 %126, %61
%132 = getelementptr inbounds i8, i8* %0, i64 %131
%133 = load i8, i8* %132
%134 = uitofp i8 %133 to float
%135 = tail call float @llvm.fmuladd.f32(float %45, float %134, float %130)
%136 = add nsw i64 %131, %61
%137 = getelementptr inbounds i8, i8* %0, i64 %136
%138 = load i8, i8* %137
%139 = uitofp i8 %138 to float
%140 = tail call float @llvm.fmuladd.f32(float %52, float %139, float %135)
%141 = fpext float %54 to double
%142 = fpext float %55 to double
%143 = fpext float %56 to double
%144 = fpext float %57 to double
%145 = fadd double %144, -5.000000e+00
%146 = fmul double %145, -7.500000e-01
%147 = tail call double @llvm.fmuladd.f64(double %146, double %144, double -6.000000e+00)
%148 = tail call double @llvm.fmuladd.f64(double %147, double %144, double 3.000000e+00)
%149 = fptrunc double %148 to float
%150 = tail call double @llvm.fmuladd.f64(double %143, double 1.250000e+00, double -2.250000e+00)
%151 = fmul double %150, %143
%152 = tail call double @llvm.fmuladd.f64(double %151, double %143, double 1.000000e+00)
%153 = fptrunc double %152 to float
%154 = tail call double @llvm.fmuladd.f64(double %142, double 1.250000e+00, double -2.250000e+00)
%155 = fmul double %154, %142
%156 = tail call double @llvm.fmuladd.f64(double %155, double %142, double 1.000000e+00)
%157 = fptrunc double %156 to float
%158 = fadd double %141, -5.000000e+00
%159 = fmul double %158, -7.500000e-01
%160 = tail call double @llvm.fmuladd.f64(double %159, double %141, double -6.000000e+00)
%161 = tail call double @llvm.fmuladd.f64(double %160, double %141, double 3.000000e+00)
%162 = fptrunc double %161 to float
%163 = fmul float %80, %162
%164 = tail call float @llvm.fmuladd.f32(float %157, float %100, float %163)
%165 = tail call float @llvm.fmuladd.f32(float %153, float %120, float %164)
%166 = tail call float @llvm.fmuladd.f32(float %149, float %140, float %165)
%167 = fcmp olt float %166, 0.000000e+00
%168 = select i1 %167, float 0.000000e+00, float %166
%169 = fcmp ogt float %168, 2.560000e+02
%170 = select i1 %169, float 2.550000e+02, float %168
%171 = fptoui float %170 to i8
store i8 %171, i8* %6
ret i32 0
}