#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 */
typedef int uint8_t;

/* Variables and functions */
int ipol(uint8_t *src, int x, int y) {
  int int_x = x >> 16;
  int int_y = y >> 16;
  int frac_x = x & 0xFFFF;
  int frac_y = y & 0xFFFF;
  int s00 = src[(int_x & 255) + 256 * (int_y & 255)];
  int s01 = src[((int_x + 1) & 255) + 256 * (int_y & 255)];
  int s10 = src[(int_x & 255) + 256 * ((int_y + 1) & 255)];
  int s11 = src[((int_x + 1) & 255) + 256 * ((int_y + 1) & 255)];
  int s0 = (((1 << 16) - frac_x) * s00 + frac_x * s01) >> 8;
  int s1 = (((1 << 16) - frac_x) * s10 + frac_x * s11) >> 8;
  return (((1 << 16) - frac_y) * s0 + frac_y * s1) >> 24;
}


x86 assembly (clang, -O0):
<ipol>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x10,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
sar    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
and    $0xffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
and    $0xffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%edx
and    $0xff,%edx
shl    $0x8,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%edx
and    $0xff,%edx
shl    $0x8,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
and    $0xff,%edx
shl    $0x8,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
and    $0xff,%edx
shl    $0x8,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    $0x10000,%eax
sub    -0x1c(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %eax,-0x34(%rbp)
mov    $0x10000,%eax
sub    -0x1c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %eax,-0x38(%rbp)
mov    $0x10000,%eax
sub    -0x20(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
sar    $0x18,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ipol>:
movzwl %si,%eax
sar    $0x10,%esi
movzwl %dx,%r8d
movzbl %sil,%r9d
sar    $0x8,%edx
mov    %edx,%ecx
and    $0xff00,%ecx
lea    (%rcx,%r9,1),%r10d
add    $0x1,%esi
movzbl %sil,%esi
or     %esi,%ecx
add    $0x100,%edx
and    $0xff00,%edx
or     %edx,%r9d
or     %esi,%edx
mov    $0x10000,%r11d
mov    $0x10000,%esi
sub    %eax,%esi
mov    (%rdi,%r10,4),%r10d
imul   %esi,%r10d
mov    (%rdi,%rcx,4),%ecx
imul   %eax,%ecx
add    %r10d,%ecx
imul   (%rdi,%r9,4),%esi
imul   (%rdi,%rdx,4),%eax
sar    $0x8,%ecx
add    %esi,%eax
sar    $0x8,%eax
sub    %r8d,%r11d
imul   %ecx,%r11d
imul   %r8d,%eax
add    %r11d,%eax
sar    $0x18,%eax
ret

LLVM IR (-O0):
define i32 @ipol(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%17 = load i32, i32* %5
%18 = ashr i32 %17, 16
store i32 %18, i32* %7
%19 = load i32, i32* %6
%20 = ashr i32 %19, 16
store i32 %20, i32* %8
%21 = load i32, i32* %5
%22 = and i32 %21, 65535
store i32 %22, i32* %9
%23 = load i32, i32* %6
%24 = and i32 %23, 65535
store i32 %24, i32* %10
%25 = load i32*, i32** %4
%26 = load i32, i32* %7
%27 = and i32 %26, 255
%28 = load i32, i32* %8
%29 = and i32 %28, 255
%30 = mul nsw i32 256, %29
%31 = add nsw i32 %27, %30
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %25, i64 %32
%34 = load i32, i32* %33
store i32 %34, i32* %11
%35 = load i32*, i32** %4
%36 = load i32, i32* %7
%37 = add nsw i32 %36, 1
%38 = and i32 %37, 255
%39 = load i32, i32* %8
%40 = and i32 %39, 255
%41 = mul nsw i32 256, %40
%42 = add nsw i32 %38, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %35, i64 %43
%45 = load i32, i32* %44
store i32 %45, i32* %12
%46 = load i32*, i32** %4
%47 = load i32, i32* %7
%48 = and i32 %47, 255
%49 = load i32, i32* %8
%50 = add nsw i32 %49, 1
%51 = and i32 %50, 255
%52 = mul nsw i32 256, %51
%53 = add nsw i32 %48, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %46, i64 %54
%56 = load i32, i32* %55
store i32 %56, i32* %13
%57 = load i32*, i32** %4
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
%60 = and i32 %59, 255
%61 = load i32, i32* %8
%62 = add nsw i32 %61, 1
%63 = and i32 %62, 255
%64 = mul nsw i32 256, %63
%65 = add nsw i32 %60, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %57, i64 %66
%68 = load i32, i32* %67
store i32 %68, i32* %14
%69 = load i32, i32* %9
%70 = sub nsw i32 65536, %69
%71 = load i32, i32* %11
%72 = mul nsw i32 %70, %71
%73 = load i32, i32* %9
%74 = load i32, i32* %12
%75 = mul nsw i32 %73, %74
%76 = add nsw i32 %72, %75
%77 = ashr i32 %76, 8
store i32 %77, i32* %15
%78 = load i32, i32* %9
%79 = sub nsw i32 65536, %78
%80 = load i32, i32* %13
%81 = mul nsw i32 %79, %80
%82 = load i32, i32* %9
%83 = load i32, i32* %14
%84 = mul nsw i32 %82, %83
%85 = add nsw i32 %81, %84
%86 = ashr i32 %85, 8
store i32 %86, i32* %16
%87 = load i32, i32* %10
%88 = sub nsw i32 65536, %87
%89 = load i32, i32* %15
%90 = mul nsw i32 %88, %89
%91 = load i32, i32* %10
%92 = load i32, i32* %16
%93 = mul nsw i32 %91, %92
%94 = add nsw i32 %90, %93
%95 = ashr i32 %94, 24
ret i32 %95
}

LLVM IR (-O2):
define i32 @ipol(i32* nocapture %0, i32 %1, i32 %2) {
%4 = ashr i32 %1, 16
%5 = and i32 %1, 65535
%6 = and i32 %2, 65535
%7 = and i32 %4, 255
%8 = ashr i32 %2, 8
%9 = and i32 %8, 65280
%10 = or i32 %9, %7
%11 = zext i32 %10 to i64
%12 = getelementptr inbounds i32, i32* %0, i64 %11
%13 = load i32, i32* %12
%14 = add nsw i32 %4, 1
%15 = and i32 %14, 255
%16 = or i32 %15, %9
%17 = zext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %0, i64 %17
%19 = load i32, i32* %18
%20 = add nsw i32 %8, 256
%21 = and i32 %20, 65280
%22 = or i32 %21, %7
%23 = zext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %0, i64 %23
%25 = load i32, i32* %24
%26 = or i32 %21, %15
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %0, i64 %27
%29 = load i32, i32* %28
%30 = sub nuw nsw i32 65536, %5
%31 = mul nsw i32 %13, %30
%32 = mul nsw i32 %19, %5
%33 = add nsw i32 %32, %31
%34 = ashr i32 %33, 8
%35 = mul nsw i32 %25, %30
%36 = mul nsw i32 %29, %5
%37 = add nsw i32 %36, %35
%38 = ashr i32 %37, 8
%39 = sub nuw nsw i32 65536, %6
%40 = mul nsw i32 %34, %39
%41 = mul nsw i32 %38, %6
%42 = add nsw i32 %41, %40
%43 = ashr i32 %42, 24
ret i32 %43
}