#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 scalar_t__ volatile uint8_t;
typedef scalar_t__ volatile int8_t;
typedef scalar_t__ volatile int16_t;

/* Variables and functions */
uint8_t Interp1D(volatile uint8_t table[10][2], uint8_t adcVal) {
  uint8_t i = 0;
  if (adcVal > table[10 - 1][0]) {
    return table[10 - 1][1];
  } else if (adcVal < table[0][0]) {
    return table[0][1];
  } else {
    for (i = 0; i < 10 - 1; ++i) {
      if (adcVal < table[i][0])
        break;
    }
    uint8_t deltaX = table[i][0] - table[i - 1][0];
    if (!deltaX)
      return 0;
    int8_t deltaY = table[i][1] - table[i - 1][1];
    if (!deltaY)
      return table[i][1];
    return table[i - 1][1] +
           ((int16_t)(adcVal - table[i - 1][0]) * deltaY) / deltaX;
  }
}


x86 assembly (clang, -O0):
<Interp1D>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x90(%rcx),%rcx
cmp    %rcx,%rax
jle    1140 <Interp1D+0x40>
mov    -0x10(%rbp),%rax
mov    0x98(%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    12b1 <Interp1D+0x1b1>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
cmp    %rcx,%rax
jge    1165 <Interp1D+0x65>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    12b1 <Interp1D+0x1b1>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    $0x9,%rax
jge    11b5 <Interp1D+0xb5>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    (%rcx),%rcx
cmp    %rcx,%rax
jge    119f <Interp1D+0x9f>
jmp    11b5 <Interp1D+0xb5>
jmp    11a4 <Interp1D+0xa4>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    116d <Interp1D+0x6d>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    $0x0,%rax
jne    11ff <Interp1D+0xff>
movq   $0x0,-0x8(%rbp)
jmp    12b1 <Interp1D+0x1b1>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    0x8(%rcx),%rcx
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    $0x0,%rax
jne    125a <Interp1D+0x15a>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    12b1 <Interp1D+0x1b1>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    -0x30(%rbp),%rcx
imul   %rcx,%rax
mov    -0x28(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Interp1D>:
mov    %rsi,-0x18(%rsp)
movq   $0x0,-0x20(%rsp)
mov    -0x18(%rsp),%rax
cmp    0x90(%rdi),%rax
jle    1124 <Interp1D+0x24>
mov    0x98(%rdi),%rax
ret
mov    -0x18(%rsp),%rax
cmp    (%rdi),%rax
jge    1133 <Interp1D+0x33>
mov    0x8(%rdi),%rax
ret
movq   $0x0,-0x20(%rsp)
mov    -0x20(%rsp),%rax
cmp    $0x8,%rax
jg     1175 <Interp1D+0x75>
nopw   0x0(%rax,%rax,1)
mov    -0x18(%rsp),%rax
mov    -0x20(%rsp),%rcx
shl    $0x4,%rcx
cmp    (%rdi,%rcx,1),%rax
jl     1175 <Interp1D+0x75>
addq   $0x1,-0x20(%rsp)
mov    -0x20(%rsp),%rax
cmp    $0x9,%rax
jl     1150 <Interp1D+0x50>
mov    -0x20(%rsp),%rax
shl    $0x4,%rax
mov    (%rdi,%rax,1),%rax
mov    -0x20(%rsp),%rcx
shl    $0x4,%rcx
sub    -0x10(%rcx,%rdi,1),%rax
mov    %rax,-0x8(%rsp)
cmpq   $0x0,-0x8(%rsp)
je     1207 <Interp1D+0x107>
mov    -0x20(%rsp),%rax
shl    $0x4,%rax
mov    0x8(%rdi,%rax,1),%rax
mov    -0x20(%rsp),%rcx
shl    $0x4,%rcx
sub    -0x8(%rcx,%rdi,1),%rax
mov    %rax,-0x10(%rsp)
cmpq   $0x0,-0x10(%rsp)
mov    -0x20(%rsp),%rax
je     120a <Interp1D+0x10a>
shl    $0x4,%rax
mov    -0x8(%rax,%rdi,1),%rcx
mov    -0x18(%rsp),%rax
mov    -0x20(%rsp),%rdx
shl    $0x4,%rdx
sub    -0x10(%rdx,%rdi,1),%rax
imul   -0x10(%rsp),%rax
mov    -0x8(%rsp),%rsi
mov    %rax,%rdx
or     %rsi,%rdx
shr    $0x20,%rdx
je     1214 <Interp1D+0x114>
cqto
idiv   %rsi
add    %rcx,%rax
ret
xor    %eax,%eax
ret
shl    $0x4,%rax
mov    0x8(%rdi,%rax,1),%rax
ret
xor    %edx,%edx
div    %esi
add    %rcx,%rax
ret

LLVM IR (-O0):
define i64 @Interp1D([2 x i64]* %0, i64 %1) {
%3 = alloca i64
%4 = alloca [2 x i64]*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
store [2 x i64]* %0, [2 x i64]** %4
store volatile i64 %1, i64* %5
store volatile i64 0, i64* %6
%9 = load volatile i64, i64* %5
%10 = load [2 x i64]*, [2 x i64]** %4
%11 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 9
%12 = getelementptr inbounds [2 x i64], [2 x i64]* %11, i64 0, i64 0
%13 = load volatile i64, i64* %12
%14 = icmp sgt i64 %9, %13
br i1 %14, label %15, label %20
15: ; preds = %2
%16 = load [2 x i64]*, [2 x i64]** %4
%17 = getelementptr inbounds [2 x i64], [2 x i64]* %16, i64 9
%18 = getelementptr inbounds [2 x i64], [2 x i64]* %17, i64 0, i64 1
%19 = load volatile i64, i64* %18
store i64 %19, i64* %3
br label %106
20: ; preds = %2
%21 = load volatile i64, i64* %5
%22 = load [2 x i64]*, [2 x i64]** %4
%23 = getelementptr inbounds [2 x i64], [2 x i64]* %22, i64 0
%24 = getelementptr inbounds [2 x i64], [2 x i64]* %23, i64 0, i64 0
%25 = load volatile i64, i64* %24
%26 = icmp slt i64 %21, %25
br i1 %26, label %27, label %32
27: ; preds = %20
%28 = load [2 x i64]*, [2 x i64]** %4
%29 = getelementptr inbounds [2 x i64], [2 x i64]* %28, i64 0
%30 = getelementptr inbounds [2 x i64], [2 x i64]* %29, i64 0, i64 1
%31 = load volatile i64, i64* %30
store i64 %31, i64* %3
br label %106
32: ; preds = %20
store volatile i64 0, i64* %6
br label %33
33: ; preds = %46, %32
%34 = load volatile i64, i64* %6
%35 = icmp slt i64 %34, 9
br i1 %35, label %36, label %49
36: ; preds = %33
%37 = load volatile i64, i64* %5
%38 = load [2 x i64]*, [2 x i64]** %4
%39 = load volatile i64, i64* %6
%40 = getelementptr inbounds [2 x i64], [2 x i64]* %38, i64 %39
%41 = getelementptr inbounds [2 x i64], [2 x i64]* %40, i64 0, i64 0
%42 = load volatile i64, i64* %41
%43 = icmp slt i64 %37, %42
br i1 %43, label %44, label %45
44: ; preds = %36
br label %49
45: ; preds = %36
br label %46
46: ; preds = %45
%47 = load volatile i64, i64* %6
%48 = add nsw i64 %47, 1
store volatile i64 %48, i64* %6
br label %33
49: ; preds = %44, %33
%50 = load [2 x i64]*, [2 x i64]** %4
%51 = load volatile i64, i64* %6
%52 = getelementptr inbounds [2 x i64], [2 x i64]* %50, i64 %51
%53 = getelementptr inbounds [2 x i64], [2 x i64]* %52, i64 0, i64 0
%54 = load volatile i64, i64* %53
%55 = load [2 x i64]*, [2 x i64]** %4
%56 = load volatile i64, i64* %6
%57 = sub nsw i64 %56, 1
%58 = getelementptr inbounds [2 x i64], [2 x i64]* %55, i64 %57
%59 = getelementptr inbounds [2 x i64], [2 x i64]* %58, i64 0, i64 0
%60 = load volatile i64, i64* %59
%61 = sub nsw i64 %54, %60
store volatile i64 %61, i64* %7
%62 = load volatile i64, i64* %7
%63 = icmp ne i64 %62, 0
br i1 %63, label %65, label %64
64: ; preds = %49
store i64 0, i64* %3
br label %106
65: ; preds = %49
%66 = load [2 x i64]*, [2 x i64]** %4
%67 = load volatile i64, i64* %6
%68 = getelementptr inbounds [2 x i64], [2 x i64]* %66, i64 %67
%69 = getelementptr inbounds [2 x i64], [2 x i64]* %68, i64 0, i64 1
%70 = load volatile i64, i64* %69
%71 = load [2 x i64]*, [2 x i64]** %4
%72 = load volatile i64, i64* %6
%73 = sub nsw i64 %72, 1
%74 = getelementptr inbounds [2 x i64], [2 x i64]* %71, i64 %73
%75 = getelementptr inbounds [2 x i64], [2 x i64]* %74, i64 0, i64 1
%76 = load volatile i64, i64* %75
%77 = sub nsw i64 %70, %76
store volatile i64 %77, i64* %8
%78 = load volatile i64, i64* %8
%79 = icmp ne i64 %78, 0
br i1 %79, label %86, label %80
80: ; preds = %65
%81 = load [2 x i64]*, [2 x i64]** %4
%82 = load volatile i64, i64* %6
%83 = getelementptr inbounds [2 x i64], [2 x i64]* %81, i64 %82
%84 = getelementptr inbounds [2 x i64], [2 x i64]* %83, i64 0, i64 1
%85 = load volatile i64, i64* %84
store i64 %85, i64* %3
br label %106
86: ; preds = %65
%87 = load [2 x i64]*, [2 x i64]** %4
%88 = load volatile i64, i64* %6
%89 = sub nsw i64 %88, 1
%90 = getelementptr inbounds [2 x i64], [2 x i64]* %87, i64 %89
%91 = getelementptr inbounds [2 x i64], [2 x i64]* %90, i64 0, i64 1
%92 = load volatile i64, i64* %91
%93 = load volatile i64, i64* %5
%94 = load [2 x i64]*, [2 x i64]** %4
%95 = load volatile i64, i64* %6
%96 = sub nsw i64 %95, 1
%97 = getelementptr inbounds [2 x i64], [2 x i64]* %94, i64 %96
%98 = getelementptr inbounds [2 x i64], [2 x i64]* %97, i64 0, i64 0
%99 = load volatile i64, i64* %98
%100 = sub nsw i64 %93, %99
%101 = load volatile i64, i64* %8
%102 = mul nsw i64 %100, %101
%103 = load volatile i64, i64* %7
%104 = sdiv i64 %102, %103
%105 = add nsw i64 %92, %104
store i64 %105, i64* %3
br label %106
106: ; preds = %86, %80, %64, %27, %15
%107 = load i64, i64* %3
ret i64 %107
}

LLVM IR (-O2):
define i64 @Interp1D([2 x i64]* %0, i64 %1) {
%3 = alloca i64
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
store volatile i64 %1, i64* %3
%7 = bitcast i64* %4 to i8*
store volatile i64 0, i64* %4
%8 = load volatile i64, i64* %3
%9 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 9, i64 0
%10 = load volatile i64, i64* %9
%11 = icmp sgt i64 %8, %10
br i1 %11, label %12, label %15
12: ; preds = %2
%13 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 9, i64 1
%14 = load volatile i64, i64* %13
br label %84
15: ; preds = %2
%16 = load volatile i64, i64* %3
%17 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 0, i64 0
%18 = load volatile i64, i64* %17
%19 = icmp slt i64 %16, %18
br i1 %19, label %20, label %23
20: ; preds = %15
%21 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 0, i64 1
%22 = load volatile i64, i64* %21
br label %84
23: ; preds = %15
store volatile i64 0, i64* %4
%24 = load volatile i64, i64* %4
%25 = icmp slt i64 %24, 9
br i1 %25, label %26, label %37
26: ; preds = %23, %32
%27 = load volatile i64, i64* %3
%28 = load volatile i64, i64* %4
%29 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %28, i64 0
%30 = load volatile i64, i64* %29
%31 = icmp slt i64 %27, %30
br i1 %31, label %37, label %32
32: ; preds = %26
%33 = load volatile i64, i64* %4
%34 = add nsw i64 %33, 1
store volatile i64 %34, i64* %4
%35 = load volatile i64, i64* %4
%36 = icmp slt i64 %35, 9
br i1 %36, label %26, label %37
37: ; preds = %32, %26, %23
%38 = bitcast i64* %5 to i8*
%39 = load volatile i64, i64* %4
%40 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %39, i64 0
%41 = load volatile i64, i64* %40
%42 = load volatile i64, i64* %4
%43 = add nsw i64 %42, -1
%44 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %43, i64 0
%45 = load volatile i64, i64* %44
%46 = sub nsw i64 %41, %45
store volatile i64 %46, i64* %5
%47 = load volatile i64, i64* %5
%48 = icmp eq i64 %47, 0
br i1 %48, label %82, label %49
49: ; preds = %37
%50 = bitcast i64* %6 to i8*
%51 = load volatile i64, i64* %4
%52 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %51, i64 1
%53 = load volatile i64, i64* %52
%54 = load volatile i64, i64* %4
%55 = add nsw i64 %54, -1
%56 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %55, i64 1
%57 = load volatile i64, i64* %56
%58 = sub nsw i64 %53, %57
store volatile i64 %58, i64* %6
%59 = load volatile i64, i64* %6
%60 = icmp eq i64 %59, 0
%61 = load volatile i64, i64* %4
br i1 %60, label %62, label %65
62: ; preds = %49
%63 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %61, i64 1
%64 = load volatile i64, i64* %63
br label %80
65: ; preds = %49
%66 = add nsw i64 %61, -1
%67 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %66, i64 1
%68 = load volatile i64, i64* %67
%69 = load volatile i64, i64* %3
%70 = load volatile i64, i64* %4
%71 = add nsw i64 %70, -1
%72 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i64 %71, i64 0
%73 = load volatile i64, i64* %72
%74 = sub nsw i64 %69, %73
%75 = load volatile i64, i64* %6
%76 = mul nsw i64 %74, %75
%77 = load volatile i64, i64* %5
%78 = sdiv i64 %76, %77
%79 = add nsw i64 %78, %68
br label %80
80: ; preds = %65, %62
%81 = phi i64 [ %79, %65 ], [ %64, %62 ]
br label %82
82: ; preds = %37, %80
%83 = phi i64 [ %81, %80 ], [ 0, %37 ]
br label %84
84: ; preds = %82, %20, %12
%85 = phi i64 [ %14, %12 ], [ %22, %20 ], [ %83, %82 ]
ret i64 %85
}