#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_b32(unsigned char *sl, int w, int h, float x, float y, float o,
                 unsigned char *v, int is_atop) {
  int i, j, b, l, m, n;
  float k;
  float p[4], p1[4], p2[4], p3[4], p4[4];
  float alpha = 1.0;
  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 (b = 3; b > -1; b--) {
    for (i = 0; i < 4; i++) {
      l = m + (i + n) * w;
      p1[i] = sl[4 * l + b];
      p2[i] = sl[4 * (l + 1) + b];
      p3[i] = sl[4 * (l + 2) + b];
      p4[i] = sl[4 * (l + 3) + b];
    }
    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.0f)
      p[3] = 0.0f;
    if (p[3] > 255.0f)
      p[3] = 255.0f;
    if (b == 3) {
      float alpha_sl = (float)p[3] / 255.0f * o;
      float alpha_v = (float)v[3] / 255.0f;
      alpha = alpha_sl + alpha_v - alpha_sl * alpha_v;
      v[3] = is_atop ? p[3] : (255 * alpha);
      alpha = alpha_sl / alpha;
    } else {
      v[b] = v[b] * (1.0f - alpha) + p[3] * alpha;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<interpBC_b32>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  %xmm2,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movss  0xebc(%rip),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x14(%rbp),%xmm0
call   1030 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    116d <interpBC_b32+0x5d>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x5,%eax
cmp    -0xc(%rbp),%eax
jle    1185 <interpBC_b32+0x75>
mov    -0xc(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x40(%rbp)
movss  -0x18(%rbp),%xmm0
call   1030 <ceilf@plt>
sub    $0x2,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    11a6 <interpBC_b32+0x96>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x5,%eax
cmp    -0x10(%rbp),%eax
jle    11be <interpBC_b32+0xae>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x44(%rbp)
movl   $0x3,-0x38(%rbp)
cmpl   $0xffffffff,-0x38(%rbp)
jle    1652 <interpBC_b32+0x542>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    12a5 <interpBC_b32+0x195>
mov    -0x40(%rbp),%eax
mov    -0x30(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    %edx,%ecx
mov    -0xc(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%esi
mov    %ecx,%edx
mov    %esi,%ecx
lea    (%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%esi
mov    %ecx,%edx
mov    %esi,%ecx
lea    0x4(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%esi
mov    %ecx,%edx
mov    %esi,%ecx
lea    0x8(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%esi
mov    %ecx,%edx
mov    %esi,%ecx
lea    0xc(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d6 <interpBC_b32+0xc6>
movl   $0x1,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    140b <interpBC_b32+0x2fb>
movl   $0x3,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     13f8 <interpBC_b32+0x2e8>
movss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x44(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movslq -0x30(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm1
movss  -0x48(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x70(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x30(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
movss  -0x48(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x80(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x80(%rbp,%rax,4)
movslq -0x30(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movss  -0x48(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x90(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
movslq -0x30(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x48(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0xa0(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    12bd <interpBC_b32+0x1ad>
jmp    13fd <interpBC_b32+0x2ed>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ac <interpBC_b32+0x19c>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x58(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    14d2 <interpBC_b32+0x3c2>
movl   $0x3,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     14bf <interpBC_b32+0x3af>
movslq -0x30(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm1
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x40(%rbp),%xmm2
subss  %xmm2,%xmm0
cvtsi2ssl -0x34(%rbp),%xmm2
divss  %xmm2,%xmm0
movslq -0x30(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm2
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x60(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1451 <interpBC_b32+0x341>
jmp    14c4 <interpBC_b32+0x3b4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1440 <interpBC_b32+0x330>
xorps  %xmm0,%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    14e7 <interpBC_b32+0x3d7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  0xb10(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    150a <interpBC_b32+0x3fa>
movss  0xaff(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
cmpl   $0x3,-0x38(%rbp)
jne    15f9 <interpBC_b32+0x4e9>
movss  -0x54(%rbp),%xmm0
movss  0xae3(%rip),%xmm1
divss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xaba(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
addss  -0xac(%rbp),%xmm1
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
cmpl   $0x0,-0x2c(%rbp)
je     15af <interpBC_b32+0x49f>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
jmp    15c7 <interpBC_b32+0x4b7>
movss  0xa4d(%rip),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
movss  -0xa8(%rbp),%xmm0
ff
divss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
jmp    163f <interpBC_b32+0x52f>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movss  -0xa4(%rbp),%xmm3
ff
movss  0x9e7(%rip),%xmm2
subss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1644 <interpBC_b32+0x534>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    11c5 <interpBC_b32+0xb5>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpBC_b32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r8d,0x2c(%rsp)
mov    %rcx,%rbx
movss  %xmm2,0x28(%rsp)
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
mov    %edx,%r12d
mov    %esi,%r15d
mov    %rdi,0x8(%rsp)
call   1030 <ceilf@plt>
cmp    $0x3,%eax
mov    $0x2,%ebp
cmovl  %ebp,%eax
lea    -0x2(%rax),%ecx
add    $0x3,%eax
lea    -0x4(%r15),%r14d
cmp    %r15d,%eax
cmovle %ecx,%r14d
movaps 0x30(%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
cvtsi2ss %eax,%xmm3
xorps  %xmm2,%xmm2
cvtsi2ss %r14d,%xmm2
mov    %eax,%ecx
imul   %r15d,%ecx
add    %r14d,%ecx
lea    0x1(%rax),%esi
imul   %r15d,%esi
lea    (%rsi,%r14,1),%r8d
lea    0x2(%rax),%edi
imul   %r15d,%edi
lea    (%rdi,%r14,1),%r9d
add    $0x3,%eax
imul   %r15d,%eax
lea    (%rax,%r14,1),%edx
mov    %edx,0x20(%rsp)
shl    $0x2,%r14d
lea    (%r14,%rsi,4),%edx
add    $0xc,%edx
mov    %edx,0x18(%rsp)
lea    0x8(%r14,%rsi,4),%edx
mov    %edx,0x10(%rsp)
lea    0x4(%r14,%rsi,4),%r12d
lea    0xc(%r14,%rdi,4),%r13d
lea    0x8(%r14,%rdi,4),%r15d
lea    0x4(%r14,%rdi,4),%edi
lea    0xc(%r14,%rax,4),%esi
lea    0x8(%r14,%rax,4),%ebp
lea    0x4(%r14,%rax,4),%r14d
lea    0x0(,%rcx,4),%edx
movslq %edx,%r11
movslq %r8d,%r10
movslq %r9d,%r9
movslq 0x20(%rsp),%r8
lea    0xc(,%rcx,4),%edx
movslq %edx,%rdx
mov    0x8(%rsp),%rax
lea    0x3(%rdx,%rax,1),%rdx
mov    %rdx,0x20(%rsp)
lea    0x8(,%rcx,4),%edx
movslq %edx,%rdx
lea    0x3(%rdx,%rax,1),%rdx
mov    %rdx,0x68(%rsp)
lea    0x4(,%rcx,4),%ecx
movslq %ecx,%rcx
lea    0x3(%rcx,%rax,1),%rcx
mov    %rcx,0x60(%rsp)
movslq 0x18(%rsp),%rcx
lea    0x3(%rcx,%rax,1),%rcx
mov    %rcx,0x18(%rsp)
movslq 0x10(%rsp),%rcx
lea    0x3(%rcx,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
movslq %r12d,%rcx
lea    0x3(%rcx,%rax,1),%rcx
mov    %rcx,0x58(%rsp)
movslq %r13d,%rcx
lea    0x3(%rcx,%rax,1),%rcx
mov    %rcx,0x50(%rsp)
movslq %r15d,%rcx
lea    0x3(%rcx,%rax,1),%r12
movslq %edi,%rdx
lea    0x3(%rdx,%rax,1),%r15
movslq %esi,%rsi
lea    0x3(%rsi,%rax,1),%rsi
movslq %ebp,%rdi
lea    0x3(%rdi,%rax,1),%rdi
movslq %r14d,%rbp
lea    0x3(%rbp,%rax,1),%rbp
lea    0x3(%rax,%r8,4),%r14
lea    0x3(%rax,%r9,4),%r13
lea    0x3(%rax,%r10,4),%r8
lea    0x3(%r11,%rax,1),%r9
movss  0xd32(%rip),%xmm8
movaps 0x30(%rsp),%xmm4
movaps %xmm4,%xmm15
addss  %xmm8,%xmm15
subss  %xmm3,%xmm15
movss  0xd1b(%rip),%xmm1
addss  %xmm4,%xmm1
subss  %xmm3,%xmm1
movss  0xd0f(%rip),%xmm0
addss  %xmm0,%xmm4
subss  %xmm3,%xmm4
movaps %xmm4,%xmm10
movss  0xcff(%rip),%xmm4
movaps %xmm15,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm1,%xmm4
movss  0xcee(%rip),%xmm9
movaps %xmm15,%xmm6
movaps 0x40(%rsp),%xmm7
movaps %xmm7,%xmm3
shufps $0x0,%xmm7,%xmm3
addps  0xce7(%rip),%xmm3
divss  %xmm9,%xmm6
addss  %xmm7,%xmm0
subss  %xmm2,%xmm0
movss  %xmm0,0x8(%rsp)
addss  %xmm8,%xmm7
subss  %xmm2,%xmm7
shufps $0x0,%xmm2,%xmm2
subps  %xmm2,%xmm3
movaps 0xccd(%rip),%xmm0
movaps %xmm3,0x90(%rsp)
mulps  %xmm3,%xmm0
movaps %xmm0,0x80(%rsp)
divss  %xmm9,%xmm7
movaps %xmm7,0x40(%rsp)
shufps $0x0,%xmm6,%xmm6
movaps %xmm6,0xa0(%rsp)
shufps $0x0,%xmm5,%xmm5
movaps %xmm5,0xb0(%rsp)
shufps $0x0,%xmm15,%xmm15
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0x70(%rsp)
shufps $0x0,%xmm4,%xmm4
movaps %xmm4,0xc0(%rsp)
shufps $0x0,%xmm10,%xmm10
movaps %xmm10,0x30(%rsp)
movss  0xc4e(%rip),%xmm14
pxor   %xmm13,%xmm13
movss  0xc44(%rip),%xmm10
xor    %r10d,%r10d
jmp    141d <interpBC_b32+0x30d>
nopl   0x0(%rax)
movzbl 0x3(%rbx,%r10,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0xc1f(%rip),%xmm1
subss  %xmm14,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm14,%xmm3
addss  %xmm1,%xmm3
cvttss2si %xmm3,%eax
mov    %al,0x3(%rbx,%r10,1)
mov    %r11,%r10
cmp    $0xfffffffffffffffc,%r11
je     16d7 <interpBC_b32+0x5c7>
mov    0x60(%rsp),%rax
movzbl (%rax,%r10,1),%eax
movzbl (%r9,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm6
mov    0x58(%rsp),%rax
movzbl (%rax,%r10,1),%eax
movzbl (%r8,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
mov    0x18(%rsp),%rax
movzbl (%rax,%r10,1),%eax
mov    0x10(%rsp),%rcx
movzbl (%rcx,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm3
movzbl (%r15,%r10,1),%eax
movzbl 0x0(%r13,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm5
mov    0x50(%rsp),%rax
movzbl (%rax,%r10,1),%eax
movzbl (%r12,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm8
movzbl 0x0(%rbp,%r10,1),%eax
movzbl (%r14,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm1
movzbl (%rsi,%r10,1),%eax
movzbl (%rdi,%r10,1),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
mov    0x20(%rsp),%rax
movzbl (%rax,%r10,1),%edx
movd   %ecx,%xmm11
mov    0x68(%rsp),%rax
movzbl (%rax,%r10,1),%eax
shl    $0x8,%eax
or     %edx,%eax
punpcklbw %xmm13,%xmm6
punpcklwd %xmm13,%xmm6
cvtdq2ps %xmm6,%xmm12
punpcklbw %xmm13,%xmm4
punpcklwd %xmm13,%xmm4
cvtdq2ps %xmm4,%xmm9
punpcklbw %xmm13,%xmm3
punpcklwd %xmm13,%xmm3
cvtdq2ps %xmm3,%xmm6
punpcklbw %xmm13,%xmm5
punpcklwd %xmm13,%xmm5
cvtdq2ps %xmm5,%xmm3
punpcklbw %xmm13,%xmm8
punpcklwd %xmm13,%xmm8
cvtdq2ps %xmm8,%xmm0
punpcklbw %xmm13,%xmm1
punpcklwd %xmm13,%xmm1
cvtdq2ps %xmm1,%xmm4
punpcklbw %xmm13,%xmm11
punpcklwd %xmm13,%xmm11
cvtdq2ps %xmm11,%xmm2
movaps %xmm4,%xmm1
subps  %xmm3,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm4,%xmm1
movaps %xmm2,%xmm5
subps  %xmm0,%xmm5
mulps  %xmm15,%xmm5
addps  %xmm2,%xmm5
movaps %xmm3,%xmm4
subps  %xmm9,%xmm4
movaps 0x70(%rsp),%xmm2
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movaps %xmm0,%xmm3
subps  %xmm6,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movaps %xmm9,%xmm0
subps  %xmm12,%xmm0
movd   %eax,%xmm2
punpcklbw %xmm13,%xmm2
punpcklwd %xmm13,%xmm2
cvtdq2ps %xmm2,%xmm8
movaps 0x30(%rsp),%xmm2
mulps  %xmm2,%xmm0
addps  %xmm9,%xmm0
movaps %xmm6,%xmm7
subps  %xmm8,%xmm7
mulps  %xmm2,%xmm7
addps  %xmm6,%xmm7
movaps %xmm1,%xmm2
subps  %xmm4,%xmm2
movaps 0xb0(%rsp),%xmm6
mulps  %xmm6,%xmm2
addps  %xmm1,%xmm2
movaps %xmm5,%xmm1
subps  %xmm3,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm5,%xmm1
movaps %xmm4,%xmm5
subps  %xmm0,%xmm5
movaps 0xc0(%rsp),%xmm6
mulps  %xmm6,%xmm5
addps  %xmm4,%xmm5
movaps %xmm3,%xmm0
subps  %xmm7,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm3,%xmm0
movaps %xmm2,%xmm3
subps  %xmm5,%xmm3
movaps 0xa0(%rsp),%xmm4
mulps  %xmm4,%xmm3
addps  %xmm2,%xmm3
movaps %xmm1,%xmm2
subps  %xmm0,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm1,%xmm2
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
mulss  0x8(%rsp),%xmm1
addss  %xmm3,%xmm1
shufps $0x10,%xmm2,%xmm3
shufps $0xe2,%xmm2,%xmm3
movaps %xmm2,%xmm0
subps  %xmm3,%xmm0
mulps  0x90(%rsp),%xmm0
addps  %xmm2,%xmm0
shufps $0xd4,%xmm0,%xmm1
shufps $0x52,%xmm0,%xmm1
movaps %xmm0,%xmm2
subps  %xmm1,%xmm2
mulps  0x80(%rsp),%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
mulss  0x40(%rsp),%xmm1
addss  %xmm2,%xmm1
xorps  %xmm3,%xmm3
ucomiss %xmm1,%xmm3
ja     1679 <interpBC_b32+0x569>
ucomiss %xmm10,%xmm1
movaps %xmm1,%xmm3
jbe    1679 <interpBC_b32+0x569>
movaps %xmm10,%xmm3
mov    %r10,%r11
sub    $0x1,%r11
jae    13e0 <interpBC_b32+0x2d0>
movaps %xmm3,%xmm14
divss  %xmm10,%xmm14
mulss  0x28(%rsp),%xmm14
movzbl 0x3(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  %xmm10,%xmm0
movaps %xmm14,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm14,%xmm0
subss  %xmm0,%xmm1
cmpl   $0x0,0x2c(%rsp)
jne    16c6 <interpBC_b32+0x5b6>
movaps %xmm1,%xmm3
mulss  %xmm10,%xmm3
cvttss2si %xmm3,%eax
mov    %al,0x3(%rbx)
divss  %xmm1,%xmm14
jmp    1410 <interpBC_b32+0x300>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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