#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__ floor(float);
float getval_interp(float fx, float fy, int x0, int x1, int y0, int y1,
                    float *f, float pixignr, char *fmap) {
  int ix, iy;
  int id1, id2, id3, id4;
  int npx;
  float v1, v2, v3, v4;
  float a1, a2, b1, b2;
  *fmap = 0;
  if (fx >= x0 && fx <= x1 && fy >= y0 && fy <= y1) {
    npx = x1 - x0 + 1;
    ix = (int)floor(fx) - x0;
    iy = (int)floor(fy) - y0;
    a1 = fx - ix;
    a2 = fy - iy - y0;
    id1 = ix + npx * iy;
    id2 = id1 + 1;
    id3 = id2 + npx;
    id4 = id3 - 1;
    a1 = fx - ix;
    a2 = fy - iy - y0;
    if (a1 == 0) {
      id2 = id1;
      id3 = id4;
    }
    if (a2 == 0) {
      id4 = id1;
      id3 = id2;
    }
    v1 = f[id1];
    v2 = f[id2];
    v3 = f[id3];
    v4 = f[id4];
    if (v1 != pixignr && v2 != pixignr && v3 != pixignr && v4 != pixignr) {
      b1 = (v2 - v1) * a1 + v1;
      b2 = (v3 - v4) * a1 + v4;
      *fmap = 1;
      return (b2 - b1) * a2 + b1;
    }
  }
  return pixignr;
}


x86 assembly (clang, -O0):
<getval_interp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movss  %xmm0,-0x8(%rbp)
movss  %xmm1,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
movss  -0x8(%rbp),%xmm0
cvtsi2ssl -0x10(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jb     13af <getval_interp+0x29f>
movss  -0x8(%rbp),%xmm1
cvtsi2ssl -0x14(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     13af <getval_interp+0x29f>
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jb     13af <getval_interp+0x29f>
movss  -0xc(%rbp),%xmm1
cvtsi2ssl -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     13af <getval_interp+0x29f>
mov    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movss  -0x8(%rbp),%xmm0
call   1030 <floor@plt>
sub    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movss  -0xc(%rbp),%xmm0
call   1030 <floor@plt>
sub    -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
movss  -0x8(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x54(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movss  -0x8(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1268 <getval_interp+0x158>
jp     1268 <getval_interp+0x158>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    128b <getval_interp+0x17b>
jp     128b <getval_interp+0x17b>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jne    12ed <getval_interp+0x1dd>
jp     12ed <getval_interp+0x1dd>
jmp    13aa <getval_interp+0x29a>
movss  -0x5c(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jne    1307 <getval_interp+0x1f7>
jp     1307 <getval_interp+0x1f7>
jmp    13aa <getval_interp+0x29a>
movss  -0x60(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jne    1321 <getval_interp+0x211>
jp     1321 <getval_interp+0x211>
jmp    13aa <getval_interp+0x29a>
movss  -0x64(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jne    133b <getval_interp+0x22b>
jp     133b <getval_interp+0x22b>
jmp    13aa <getval_interp+0x29a>
movss  -0x5c(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x38(%rbp),%rax
movb   $0x1,(%rax)
movss  -0x74(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    13b9 <getval_interp+0x2a9>
jmp    13af <getval_interp+0x29f>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getval_interp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
cvtsi2ss %edi,%xmm3
movb   $0x0,(%r9)
ucomiss %xmm3,%xmm0
jb     127a <getval_interp+0x16a>
mov    %esi,%ebx
xorps  %xmm3,%xmm3
cvtsi2ss %esi,%xmm3
ucomiss %xmm0,%xmm3
jb     127a <getval_interp+0x16a>
mov    %edx,%r12d
cvtsi2ss %edx,%xmm4
ucomiss %xmm4,%xmm1
jb     127a <getval_interp+0x16a>
xorps  %xmm3,%xmm3
cvtsi2ss %ecx,%xmm3
ucomiss %xmm1,%xmm3
jb     127a <getval_interp+0x16a>
mov    %edi,%ebp
mov    %r9,%r14
mov    %r8,%r15
sub    %edi,%ebx
lea    0x1(%rbx),%eax
mov    %eax,0x4(%rsp)
movaps %xmm0,0x10(%rsp)
movss  %xmm1,(%rsp)
movss  %xmm2,0xc(%rsp)
movss  %xmm4,0x8(%rsp)
call   1030 <floor@plt>
mov    %rax,%r13
sub    %ebp,%r13d
movss  (%rsp),%xmm0
call   1030 <floor@plt>
movss  0xc(%rsp),%xmm2
movss  (%rsp),%xmm5
movaps 0x10(%rsp),%xmm0
xorps  %xmm3,%xmm3
cvtsi2ss %r13d,%xmm3
sub    %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss  %xmm1,%xmm5
imul   0x4(%rsp),%eax
lea    (%rax,%r13,1),%edx
add    $0x1,%edx
add    %r13d,%eax
lea    (%rbx,%rax,1),%ecx
add    $0x2,%ecx
lea    (%rbx,%rax,1),%esi
add    $0x1,%esi
subss  %xmm3,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
mov    %esi,%edi
cmovne %ecx,%edi
cmovp  %ecx,%edi
mov    %eax,%ecx
cmovne %edx,%ecx
cmovp  %edx,%ecx
subss  0x8(%rsp),%xmm5
ucomiss %xmm1,%xmm5
movslq %eax,%rbp
cmovne %esi,%eax
cmovp  %esi,%eax
mov    %ecx,%edx
cmovne %edi,%edx
cmovp  %edi,%edx
movss  (%r15,%rbp,4),%xmm4
ucomiss %xmm2,%xmm4
jne    121f <getval_interp+0x10f>
jnp    127a <getval_interp+0x16a>
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm6
ucomiss %xmm2,%xmm6
jne    122f <getval_interp+0x11f>
jnp    127a <getval_interp+0x16a>
movslq %edx,%rcx
movss  (%r15,%rcx,4),%xmm1
ucomiss %xmm2,%xmm1
jne    123f <getval_interp+0x12f>
jnp    127a <getval_interp+0x16a>
cltq
movss  (%r15,%rax,4),%xmm3
ucomiss %xmm2,%xmm3
jne    124e <getval_interp+0x13e>
jnp    127a <getval_interp+0x16a>
unpcklps %xmm6,%xmm1
unpcklps %xmm4,%xmm3
subps  %xmm3,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
movb   $0x1,(%r14)
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
subss  %xmm1,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
jmp    127d <getval_interp+0x16d>
movaps %xmm2,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float @getval_interp(float %0, float %1, i32 %2, i32 %3, i32 %4, i32 %5, float* %6, float %7, i8* %8) {
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float*
%18 = alloca float
%19 = alloca i8*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
store float %0, float* %11
store float %1, float* %12
store i32 %2, i32* %13
store i32 %3, i32* %14
store i32 %4, i32* %15
store i32 %5, i32* %16
store float* %6, float** %17
store float %7, float* %18
store i8* %8, i8** %19
%35 = load i8*, i8** %19
store i8 0, i8* %35
%36 = load float, float* %11
%37 = load i32, i32* %13
%38 = sitofp i32 %37 to float
%39 = fcmp oge float %36, %38
br i1 %39, label %40, label %172
40: ; preds = %9
%41 = load float, float* %11
%42 = load i32, i32* %14
%43 = sitofp i32 %42 to float
%44 = fcmp ole float %41, %43
br i1 %44, label %45, label %172
45: ; preds = %40
%46 = load float, float* %12
%47 = load i32, i32* %15
%48 = sitofp i32 %47 to float
%49 = fcmp oge float %46, %48
br i1 %49, label %50, label %172
50: ; preds = %45
%51 = load float, float* %12
%52 = load i32, i32* %16
%53 = sitofp i32 %52 to float
%54 = fcmp ole float %51, %53
br i1 %54, label %55, label %172
55: ; preds = %50
%56 = load i32, i32* %14
%57 = load i32, i32* %13
%58 = sub nsw i32 %56, %57
%59 = add nsw i32 %58, 1
store i32 %59, i32* %26
%60 = load float, float* %11
%61 = call i64 @floor(float %60)
%62 = trunc i64 %61 to i32
%63 = load i32, i32* %13
%64 = sub nsw i32 %62, %63
store i32 %64, i32* %20
%65 = load float, float* %12
%66 = call i64 @floor(float %65)
%67 = trunc i64 %66 to i32
%68 = load i32, i32* %15
%69 = sub nsw i32 %67, %68
store i32 %69, i32* %21
%70 = load float, float* %11
%71 = load i32, i32* %20
%72 = sitofp i32 %71 to float
%73 = fsub float %70, %72
store float %73, float* %31
%74 = load float, float* %12
%75 = load i32, i32* %21
%76 = sitofp i32 %75 to float
%77 = fsub float %74, %76
%78 = load i32, i32* %15
%79 = sitofp i32 %78 to float
%80 = fsub float %77, %79
store float %80, float* %32
%81 = load i32, i32* %20
%82 = load i32, i32* %26
%83 = load i32, i32* %21
%84 = mul nsw i32 %82, %83
%85 = add nsw i32 %81, %84
store i32 %85, i32* %22
%86 = load i32, i32* %22
%87 = add nsw i32 %86, 1
store i32 %87, i32* %23
%88 = load i32, i32* %23
%89 = load i32, i32* %26
%90 = add nsw i32 %88, %89
store i32 %90, i32* %24
%91 = load i32, i32* %24
%92 = sub nsw i32 %91, 1
store i32 %92, i32* %25
%93 = load float, float* %11
%94 = load i32, i32* %20
%95 = sitofp i32 %94 to float
%96 = fsub float %93, %95
store float %96, float* %31
%97 = load float, float* %12
%98 = load i32, i32* %21
%99 = sitofp i32 %98 to float
%100 = fsub float %97, %99
%101 = load i32, i32* %15
%102 = sitofp i32 %101 to float
%103 = fsub float %100, %102
store float %103, float* %32
%104 = load float, float* %31
%105 = fcmp oeq float %104, 0.000000e+00
br i1 %105, label %106, label %109
106: ; preds = %55
%107 = load i32, i32* %22
store i32 %107, i32* %23
%108 = load i32, i32* %25
store i32 %108, i32* %24
br label %109
109: ; preds = %106, %55
%110 = load float, float* %32
%111 = fcmp oeq float %110, 0.000000e+00
br i1 %111, label %112, label %115
112: ; preds = %109
%113 = load i32, i32* %22
store i32 %113, i32* %25
%114 = load i32, i32* %23
store i32 %114, i32* %24
br label %115
115: ; preds = %112, %109
%116 = load float*, float** %17
%117 = load i32, i32* %22
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %116, i64 %118
%120 = load float, float* %119
store float %120, float* %27
%121 = load float*, float** %17
%122 = load i32, i32* %23
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
%125 = load float, float* %124
store float %125, float* %28
%126 = load float*, float** %17
%127 = load i32, i32* %24
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float, float* %129
store float %130, float* %29
%131 = load float*, float** %17
%132 = load i32, i32* %25
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %131, i64 %133
%135 = load float, float* %134
store float %135, float* %30
%136 = load float, float* %27
%137 = load float, float* %18
%138 = fcmp une float %136, %137
br i1 %138, label %139, label %171
139: ; preds = %115
%140 = load float, float* %28
%141 = load float, float* %18
%142 = fcmp une float %140, %141
br i1 %142, label %143, label %171
143: ; preds = %139
%144 = load float, float* %29
%145 = load float, float* %18
%146 = fcmp une float %144, %145
br i1 %146, label %147, label %171
147: ; preds = %143
%148 = load float, float* %30
%149 = load float, float* %18
%150 = fcmp une float %148, %149
br i1 %150, label %151, label %171
151: ; preds = %147
%152 = load float, float* %28
%153 = load float, float* %27
%154 = fsub float %152, %153
%155 = load float, float* %31
%156 = load float, float* %27
%157 = call float @llvm.fmuladd.f32(float %154, float %155, float %156)
store float %157, float* %33
%158 = load float, float* %29
%159 = load float, float* %30
%160 = fsub float %158, %159
%161 = load float, float* %31
%162 = load float, float* %30
%163 = call float @llvm.fmuladd.f32(float %160, float %161, float %162)
store float %163, float* %34
%164 = load i8*, i8** %19
store i8 1, i8* %164
%165 = load float, float* %34
%166 = load float, float* %33
%167 = fsub float %165, %166
%168 = load float, float* %32
%169 = load float, float* %33
%170 = call float @llvm.fmuladd.f32(float %167, float %168, float %169)
store float %170, float* %10
br label %174
171: ; preds = %147, %143, %139, %115
br label %172
172: ; preds = %171, %50, %45, %40, %9
%173 = load float, float* %18
store float %173, float* %10
br label %174
174: ; preds = %172, %151
%175 = load float, float* %10
ret float %175
}

LLVM IR (-O2):
define float @getval_interp(float %0, float %1, i32 %2, i32 %3, i32 %4, i32 %5, float* nocapture %6, float %7, i8* nocapture writeonly %8) {
store i8 0, i8* %8
%10 = sitofp i32 %2 to float
%11 = fcmp ugt float %10, %0
%12 = sitofp i32 %3 to float
%13 = fcmp ult float %12, %0
%14 = or i1 %11, %13
br i1 %14, label %78, label %15
15: ; preds = %9
%16 = sitofp i32 %4 to float
%17 = fcmp ugt float %16, %1
%18 = sitofp i32 %5 to float
%19 = fcmp ult float %18, %1
%20 = or i1 %17, %19
br i1 %20, label %78, label %21
21: ; preds = %15
%22 = sub nsw i32 %3, %2
%23 = add nsw i32 %22, 1
%24 = tail call i64 @floor(float %0)
%25 = trunc i64 %24 to i32
%26 = sub nsw i32 %25, %2
%27 = tail call i64 @floor(float %1)
%28 = trunc i64 %27 to i32
%29 = sub nsw i32 %28, %4
%30 = sitofp i32 %26 to float
%31 = sitofp i32 %29 to float
%32 = fsub float %1, %31
%33 = mul nsw i32 %29, %23
%34 = add nsw i32 %33, %26
%35 = add nsw i32 %34, 1
%36 = add nsw i32 %35, %23
%37 = add i32 %35, %22
%38 = fsub float %0, %30
%39 = fsub float %32, %16
%40 = fcmp oeq float %38, 0.000000e+00
%41 = select i1 %40, i32 %37, i32 %36
%42 = select i1 %40, i32 %34, i32 %35
%43 = fcmp oeq float %39, 0.000000e+00
%44 = select i1 %43, i32 %34, i32 %37
%45 = select i1 %43, i32 %42, i32 %41
%46 = sext i32 %34 to i64
%47 = getelementptr inbounds float, float* %6, i64 %46
%48 = load float, float* %47
%49 = sext i32 %42 to i64
%50 = getelementptr inbounds float, float* %6, i64 %49
%51 = load float, float* %50
%52 = sext i32 %45 to i64
%53 = getelementptr inbounds float, float* %6, i64 %52
%54 = load float, float* %53
%55 = sext i32 %44 to i64
%56 = getelementptr inbounds float, float* %6, i64 %55
%57 = load float, float* %56
%58 = fcmp une float %48, %7
%59 = fcmp une float %51, %7
%60 = select i1 %58, i1 %59, i1 false
%61 = fcmp une float %54, %7
%62 = select i1 %60, i1 %61, i1 false
%63 = fcmp une float %57, %7
%64 = select i1 %62, i1 %63, i1 false
br i1 %64, label %65, label %78
65: ; preds = %21
%66 = insertelement <2 x float> poison, float %54, i64 0
%67 = insertelement <2 x float> %66, float %51, i64 1
%68 = insertelement <2 x float> poison, float %57, i64 0
%69 = insertelement <2 x float> %68, float %48, i64 1
%70 = fsub <2 x float> %67, %69
%71 = insertelement <2 x float> poison, float %38, i64 0
%72 = shufflevector <2 x float> %71, <2 x float> poison, <2 x i32> zeroinitializer
%73 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %70, <2 x float> %72, <2 x float> %69)
store i8 1, i8* %8
%74 = extractelement <2 x float> %73, i64 0
%75 = extractelement <2 x float> %73, i64 1
%76 = fsub float %74, %75
%77 = tail call float @llvm.fmuladd.f32(float %76, float %39, float %75)
br label %78
78: ; preds = %9, %15, %21, %65
%79 = phi float [ %77, %65 ], [ %7, %21 ], [ %7, %15 ], [ %7, %9 ]
ret float %79
}