#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 */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  int i, j, n;
  float x[10], y[10], f[10][10], h, s, p = 1.0, u, a;
  printf("Enter the value of n\n");
  scanf("%d", &n);
  printf("Enter the x values\n");
  for (i = 1; i <= n; i++)
    scanf("%f", &x[i]);
  printf("Enter the y values\n");
  for (i = 1; i <= n; i++)
    scanf("%f", &y[i]);
  printf("Enter the interpolating point");
  scanf("%f", &a);
  h = x[1] - x[0];
  u = (a - x[n]) / h;
  s = y[n];
  for (j = 0; j <= n; j++)
    f[0][j] = y[j];
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      f[i][j] = f[i - 1][j] - f[i - 1][j - 1];
  for (i = 1; i <= n; i++) {
    p = p * (u + i - 1) / i;
    s += p * f[i][n];
  }
  printf("\n%f\n", s);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
movl   $0x0,-0x4(%rbp)
movss  0xec6(%rip),%xmm0
movss  %xmm0,-0x20c(%rbp)
ff
lea    0xebb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xec3(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xeb4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11ae <main+0x8e>
movslq -0x8(%rbp),%rax
lea    -0x40(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe98(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1177 <main+0x57>
lea    0xe7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11fa <main+0xda>
movslq -0x8(%rbp),%rax
lea    -0x70(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe4c(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11c3 <main+0xa3>
lea    0xe47(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe22(%rip),%rdi
lea    -0x214(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movss  -0x3c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x204(%rbp)
ff
movss  -0x214(%rbp),%xmm0
ff
movslq -0x10(%rbp),%rax
subss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x204(%rbp),%xmm0
ff
movss  %xmm0,-0x210(%rbp)
ff
movslq -0x10(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x208(%rbp)
ff
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     129b <main+0x17b>
movslq -0xc(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movslq -0xc(%rbp),%rax
movss  %xmm0,-0x200(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    126a <main+0x14a>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1341 <main+0x221>
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     132e <main+0x20e>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12b4 <main+0x194>
jmp    1333 <main+0x213>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12a2 <main+0x182>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     13d7 <main+0x2b7>
movss  -0x20c(%rbp),%xmm0
ff
movss  -0x210(%rbp),%xmm1
ff
cvtsi2ssl -0x8(%rbp),%xmm2
addss  %xmm2,%xmm1
movss  0xc8b(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x20c(%rbp)
ff
movss  -0x20c(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x208(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x208(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1348 <main+0x228>
movss  -0x208(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xc7c(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x218,%rsp
lea    0xedc(%rip),%rdi
call   1030 <puts@plt>
lea    0xea7(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xed2(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    11af <main+0x6f>
lea    0x24(%rsp),%r15
lea    0xe7f(%rip),%r14
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%rbx
add    $0x4,%r15
cmp    %rax,%rbx
jl     1190 <main+0x50>
lea    0xea3(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    11ef <main+0xaf>
lea    0x54(%rsp),%r15
lea    0xe3d(%rip),%r14
xor    %ebx,%ebx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%rbx
add    $0x4,%r15
cmp    %rax,%rbx
jl     11d0 <main+0x90>
lea    0xe18(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe07(%rip),%rdi
lea    0x1c(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0xc(%rsp),%r14
movss  0x50(%rsp,%r14,4),%xmm5
test   %r14,%r14
js     14d5 <main+0x395>
movss  %xmm5,0x10(%rsp)
movss  0x24(%rsp),%xmm0
subss  0x20(%rsp),%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x1c(%rsp),%xmm0
mov    %r14d,%r15d
subss  0x20(%rsp,%r14,4),%xmm0
movss  %xmm0,0x18(%rsp)
lea    0x4(,%r15,4),%rdx
lea    0x80(%rsp),%rbx
lea    0x50(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <memcpy@plt>
test   %r14d,%r14d
je     1409 <main+0x2c9>
movss  0x18(%rsp),%xmm6
divss  0x14(%rsp),%xmm6
lea    0x1(%r15),%rax
lea    0xb4(%rsp),%rcx
add    $0xfffffffffffffffe,%r15
mov    $0x1,%r12d
xor    %r11d,%r11d
movss  0x10(%rsp),%xmm5
jmp    12cd <main+0x18d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x1,%r11
add    $0x2c,%rcx
add    $0xffffffffffffffff,%r15
add    $0x28,%rbx
cmp    %rax,%r12
je     13e3 <main+0x2a3>
mov    %r11,%rdx
not    %rdx
lea    (%rdx,%rax,1),%r9
lea    -0x1(%r12),%rdi
lea    (%rdi,%rdi,4),%rdi
lea    (%rsp,%rdi,8),%r8
add    $0x80,%r8
movss  -0x4(%r8,%r12,4),%xmm0
cmp    $0x2,%r9
jae    1300 <main+0x1c0>
mov    %r12,%rdx
jmp    13c0 <main+0x280>
add    %rax,%rdx
add    $0xfffffffffffffffe,%rdx
mov    %rdx,%r10
shr    %r10
add    $0x1,%r10
shufps $0x0,%xmm0,%xmm0
cmp    $0x2,%rdx
jae    1320 <main+0x1e0>
xor    %edi,%edi
jmp    1375 <main+0x235>
nop
mov    %r15,%rdx
shr    %rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
movaps %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x30(%rcx,%rdi,4),%xmm2
movsd  -0x28(%rcx,%rdi,4),%xmm0
movaps %xmm0,%xmm3
shufps $0x10,%xmm2,%xmm3
shufps $0x10,%xmm1,%xmm2
shufps $0x22,%xmm3,%xmm2
movups -0x30(%rcx,%rdi,4),%xmm1
subps  %xmm2,%xmm1
movups %xmm1,-0x8(%rcx,%rdi,4)
add    $0x4,%rdi
movaps %xmm0,%xmm1
add    $0xfffffffffffffffe,%rdx
jne    1340 <main+0x200>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
test   $0x1,%r10b
je     13af <main+0x26f>
add    %r12,%rdi
movsd  (%r8,%rdi,4),%xmm1
movaps %xmm1,%xmm2
shufps $0x10,%xmm0,%xmm2
shufps $0xe2,%xmm0,%xmm2
movaps %xmm1,%xmm0
subps  %xmm2,%xmm1
lea    (%r12,%r12,4),%rsi
lea    (%rsp,%rsi,8),%rsi
add    $0x80,%rsi
movlps %xmm1,(%rsi,%rdi,4)
cmp    %rdx,%r9
je     12b0 <main+0x170>
add    %r12,%rdx
shufps $0x55,%xmm0,%xmm0
nop
movss  (%rbx,%rdx,4),%xmm1
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,0x28(%rbx,%rdx,4)
add    $0x1,%rdx
movaps %xmm1,%xmm0
cmp    %rdx,%rax
jne    13c0 <main+0x280>
jmp    12b0 <main+0x170>
test   %r14d,%r14d
je     14d5 <main+0x395>
mov    %eax,%ecx
add    $0xffffffffffffffff,%rax
cmp    $0x2,%ecx
jne    1414 <main+0x2d4>
movss  0xc01(%rip),%xmm0
mov    $0x1,%ecx
jmp    149e <main+0x35e>
movss  0x10(%rsp),%xmm5
jmp    14d5 <main+0x395>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rsp,%r14,4),%rsi
add    $0xd0,%rsi
movss  0xbd2(%rip),%xmm0
mov    $0x1,%ecx
movss  0xbc9(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
movaps %xmm6,%xmm3
addss  %xmm2,%xmm3
addss  %xmm1,%xmm3
mulss  %xmm0,%xmm3
divss  %xmm2,%xmm3
movss  -0x28(%rsi),%xmm2
lea    0x1(%rcx),%rdi
xorps  %xmm4,%xmm4
cvtsi2ss %edi,%xmm4
mulss  %xmm3,%xmm2
addss  %xmm5,%xmm2
movaps %xmm6,%xmm0
addss  %xmm4,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm3,%xmm0
divss  %xmm4,%xmm0
movss  (%rsi),%xmm5
mulss  %xmm0,%xmm5
addss  %xmm2,%xmm5
add    $0x2,%rcx
add    $0x50,%rsi
cmp    %rdx,%rdi
jne    1440 <main+0x300>
test   $0x1,%al
je     14d5 <main+0x395>
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
addss  %xmm1,%xmm6
addss  0xb4f(%rip),%xmm6
mulss  %xmm6,%xmm0
divss  %xmm1,%xmm0
lea    (%rcx,%rcx,4),%rax
lea    (%rsp,%rax,8),%rax
add    $0x80,%rax
mulss  (%rax,%r14,4),%xmm0
addss  %xmm0,%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
lea    0xb49(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [22 x i8] c"Enter the value of n\0A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [20 x i8] c"Enter the x values\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [20 x i8] c"Enter the y values\0A\00"
@.str.5 = [30 x i8] c"Enter the interpolating point\00"
@.str.6 = [5 x i8] c"\0A%f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [10 x float]
%6 = alloca [10 x float]
%7 = alloca [10 x [10 x float]]
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
store i32 0, i32* %1
store float 1.000000e+00, float* %10
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
%14 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %2
br label %16
16: ; preds = %25, %0
%17 = load i32, i32* %2
%18 = load i32, i32* %4
%19 = icmp sle i32 %17, %18
br i1 %19, label %20, label %28
20: ; preds = %16
%21 = load i32, i32* %2
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %22
%24 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %23)
br label %25
25: ; preds = %20
%26 = load i32, i32* %2
%27 = add nsw i32 %26, 1
store i32 %27, i32* %2
br label %16
28: ; preds = %16
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0))
store i32 1, i32* %2
br label %30
30: ; preds = %39, %28
%31 = load i32, i32* %2
%32 = load i32, i32* %4
%33 = icmp sle i32 %31, %32
br i1 %33, label %34, label %42
34: ; preds = %30
%35 = load i32, i32* %2
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %36
%38 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %37)
br label %39
39: ; preds = %34
%40 = load i32, i32* %2
%41 = add nsw i32 %40, 1
store i32 %41, i32* %2
br label %30
42: ; preds = %30
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0))
%44 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %12)
%45 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 1
%46 = load float, float* %45
%47 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 0
%48 = load float, float* %47
%49 = fsub float %46, %48
store float %49, float* %8
%50 = load float, float* %12
%51 = load i32, i32* %4
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %52
%54 = load float, float* %53
%55 = fsub float %50, %54
%56 = load float, float* %8
%57 = fdiv float %55, %56
store float %57, float* %11
%58 = load i32, i32* %4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %59
%61 = load float, float* %60
store float %61, float* %9
store i32 0, i32* %3
br label %62
62: ; preds = %75, %42
%63 = load i32, i32* %3
%64 = load i32, i32* %4
%65 = icmp sle i32 %63, %64
br i1 %65, label %66, label %78
66: ; preds = %62
%67 = load i32, i32* %3
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %68
%70 = load float, float* %69
%71 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 0
%72 = load i32, i32* %3
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [10 x float], [10 x float]* %71, i64 0, i64 %73
store float %70, float* %74
br label %75
75: ; preds = %66
%76 = load i32, i32* %3
%77 = add nsw i32 %76, 1
store i32 %77, i32* %3
br label %62
78: ; preds = %62
store i32 1, i32* %2
br label %79
79: ; preds = %118, %78
%80 = load i32, i32* %2
%81 = load i32, i32* %4
%82 = icmp sle i32 %80, %81
br i1 %82, label %83, label %121
83: ; preds = %79
%84 = load i32, i32* %2
store i32 %84, i32* %3
br label %85
85: ; preds = %114, %83
%86 = load i32, i32* %3
%87 = load i32, i32* %4
%88 = icmp sle i32 %86, %87
br i1 %88, label %89, label %117
89: ; preds = %85
%90 = load i32, i32* %2
%91 = sub nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 %92
%94 = load i32, i32* %3
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [10 x float], [10 x float]* %93, i64 0, i64 %95
%97 = load float, float* %96
%98 = load i32, i32* %2
%99 = sub nsw i32 %98, 1
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 %100
%102 = load i32, i32* %3
%103 = sub nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [10 x float], [10 x float]* %101, i64 0, i64 %104
%106 = load float, float* %105
%107 = fsub float %97, %106
%108 = load i32, i32* %2
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 %109
%111 = load i32, i32* %3
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [10 x float], [10 x float]* %110, i64 0, i64 %112
store float %107, float* %113
br label %114
114: ; preds = %89
%115 = load i32, i32* %3
%116 = add nsw i32 %115, 1
store i32 %116, i32* %3
br label %85
117: ; preds = %85
br label %118
118: ; preds = %117
%119 = load i32, i32* %2
%120 = add nsw i32 %119, 1
store i32 %120, i32* %2
br label %79
121: ; preds = %79
store i32 1, i32* %2
br label %122
122: ; preds = %147, %121
%123 = load i32, i32* %2
%124 = load i32, i32* %4
%125 = icmp sle i32 %123, %124
br i1 %125, label %126, label %150
126: ; preds = %122
%127 = load float, float* %10
%128 = load float, float* %11
%129 = load i32, i32* %2
%130 = sitofp i32 %129 to float
%131 = fadd float %128, %130
%132 = fsub float %131, 1.000000e+00
%133 = fmul float %127, %132
%134 = load i32, i32* %2
%135 = sitofp i32 %134 to float
%136 = fdiv float %133, %135
store float %136, float* %10
%137 = load float, float* %10
%138 = load i32, i32* %2
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 %139
%141 = load i32, i32* %4
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [10 x float], [10 x float]* %140, i64 0, i64 %142
%144 = load float, float* %143
%145 = load float, float* %9
%146 = call float @llvm.fmuladd.f32(float %137, float %144, float %145)
store float %146, float* %9
br label %147
147: ; preds = %126
%148 = load i32, i32* %2
%149 = add nsw i32 %148, 1
store i32 %149, i32* %2
br label %122
150: ; preds = %122
%151 = load float, float* %9
%152 = fpext float %151 to double
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %152)
%154 = load i32, i32* %1
ret i32 %154
}

LLVM IR (-O2):
@.str.1 = [3 x i8] c"%d\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.5 = [30 x i8] c"Enter the interpolating point\00"
@.str.6 = [5 x i8] c"\0A%f\0A\00"
@str = [21 x i8] c"Enter the value of n\00"
@str.7 = [19 x i8] c"Enter the x values\00"
@str.8 = [19 x i8] c"Enter the y values\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10 x float]
%3 = alloca [10 x float]
%4 = bitcast [10 x float]* %3 to i8*
%5 = alloca [10 x [10 x float]]
%6 = bitcast [10 x [10 x float]]* %5 to i8*
%7 = alloca float
%8 = bitcast i32* %1 to i8*
%9 = bitcast [10 x float]* %2 to i8*
%10 = bitcast float* %7 to i8*
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str, i64 0, i64 0))
%12 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%13 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.7, i64 0, i64 0))
%14 = load i32, i32* %1
%15 = icmp slt i32 %14, 1
br i1 %15, label %24, label %16
16: ; preds = %0, %16
%17 = phi i64 [ %20, %16 ], [ 1, %0 ]
%18 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 %17
%19 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %18)
%20 = add nuw nsw i64 %17, 1
%21 = load i32, i32* %1
%22 = sext i32 %21 to i64
%23 = icmp slt i64 %17, %22
br i1 %23, label %16, label %24
24: ; preds = %16, %0
%25 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.8, i64 0, i64 0))
%26 = load i32, i32* %1
%27 = icmp slt i32 %26, 1
br i1 %27, label %36, label %28
28: ; preds = %24, %28
%29 = phi i64 [ %32, %28 ], [ 1, %24 ]
%30 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 %29
%31 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %30)
%32 = add nuw nsw i64 %29, 1
%33 = load i32, i32* %1
%34 = sext i32 %33 to i64
%35 = icmp slt i64 %29, %34
br i1 %35, label %28, label %36
36: ; preds = %28, %24
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0))
%38 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %7)
%39 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 1
%40 = load float, float* %39
%41 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 0
%42 = load float, float* %41
%43 = fsub float %40, %42
%44 = load float, float* %7
%45 = load i32, i32* %1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 %46
%48 = load float, float* %47
%49 = fsub float %44, %48
%50 = fdiv float %49, %43
%51 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 %46
%52 = load float, float* %51
%53 = icmp slt i32 %45, 0
br i1 %53, label %192, label %54
54: ; preds = %36
%55 = zext i32 %45 to i64
%56 = shl nuw nsw i64 %55, 2
%57 = add nuw nsw i64 %56, 4
%58 = icmp eq i32 %45, 0
br i1 %58, label %192, label %59
59: ; preds = %54
%60 = add nuw i32 %45, 1
%61 = zext i32 %60 to i64
br label %62
62: ; preds = %145, %59
%63 = phi i64 [ %148, %145 ], [ 0, %59 ]
%64 = phi i64 [ %146, %145 ], [ 1, %59 ]
%65 = xor i64 %63, -1
%66 = add i64 %65, %61
%67 = add i64 %66, -2
%68 = lshr i64 %67, 1
%69 = add nuw i64 %68, 1
%70 = xor i64 %63, -1
%71 = add i64 %70, %61
%72 = add nsw i64 %64, -1
%73 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %72, i64 %72
%74 = load float, float* %73
%75 = icmp ult i64 %71, 2
br i1 %75, label %126, label %76
76: ; preds = %62
%77 = and i64 %71, -2
%78 = add i64 %64, %77
%79 = insertelement <2 x float> poison, float %74, i64 1
%80 = and i64 %69, 1
%81 = icmp ult i64 %67, 2
br i1 %81, label %108, label %82
82: ; preds = %76
%83 = and i64 %69, -2
br label %84
84: ; preds = %84, %82
%85 = phi i64 [ 0, %82 ], [ %105, %84 ]
%86 = phi <2 x float> [ %79, %82 ], [ %100, %84 ]
%87 = phi i64 [ 0, %82 ], [ %106, %84 ]
%88 = add i64 %64, %85
%89 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %72, i64 %88
%90 = bitcast float* %89 to <2 x float>*
%91 = load <2 x float>, <2 x float>* %90
%92 = shufflevector <2 x float> %86, <2 x float> %91, <2 x i32> <i32 1, i32 2>
%93 = fsub <2 x float> %91, %92
%94 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %64, i64 %88
%95 = bitcast float* %94 to <2 x float>*
store <2 x float> %93, <2 x float>* %95
%96 = or i64 %85, 2
%97 = add i64 %64, %96
%98 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %72, i64 %97
%99 = bitcast float* %98 to <2 x float>*
%100 = load <2 x float>, <2 x float>* %99
%101 = shufflevector <2 x float> %91, <2 x float> %100, <2 x i32> <i32 1, i32 2>
%102 = fsub <2 x float> %100, %101
%103 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %64, i64 %97
%104 = bitcast float* %103 to <2 x float>*
store <2 x float> %102, <2 x float>* %104
%105 = add nuw i64 %85, 4
%106 = add nuw i64 %87, 2
%107 = icmp eq i64 %106, %83
br i1 %107, label %108, label %84
108: ; preds = %84, %76
%109 = phi <2 x float> [ undef, %76 ], [ %100, %84 ]
%110 = phi i64 [ 0, %76 ], [ %105, %84 ]
%111 = phi <2 x float> [ %79, %76 ], [ %100, %84 ]
%112 = icmp eq i64 %80, 0
br i1 %112, label %122, label %113
113: ; preds = %108
%114 = add i64 %64, %110
%115 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %72, i64 %114
%116 = bitcast float* %115 to <2 x float>*
%117 = load <2 x float>, <2 x float>* %116
%118 = shufflevector <2 x float> %111, <2 x float> %117, <2 x i32> <i32 1, i32 2>
%119 = fsub <2 x float> %117, %118
%120 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %64, i64 %114
%121 = bitcast float* %120 to <2 x float>*
store <2 x float> %119, <2 x float>* %121
br label %122
122: ; preds = %108, %113
%123 = phi <2 x float> [ %109, %108 ], [ %117, %113 ]
%124 = icmp eq i64 %71, %77
%125 = extractelement <2 x float> %123, i64 1
br i1 %124, label %145, label %126
126: ; preds = %62, %122
%127 = phi float [ %125, %122 ], [ %74, %62 ]
%128 = phi i64 [ %78, %122 ], [ %64, %62 ]
br label %136
129: ; preds = %145
br i1 %58, label %192, label %130
130: ; preds = %129
%131 = add nsw i64 %61, -1
%132 = and i64 %131, 1
%133 = icmp eq i32 %60, 2
br i1 %133, label %176, label %134
134: ; preds = %130
%135 = and i64 %131, -2
br label %149
136: ; preds = %126, %136
%137 = phi float [ %140, %136 ], [ %127, %126 ]
%138 = phi i64 [ %143, %136 ], [ %128, %126 ]
%139 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %72, i64 %138
%140 = load float, float* %139
%141 = fsub float %140, %137
%142 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %64, i64 %138
store float %141, float* %142
%143 = add nuw nsw i64 %138, 1
%144 = icmp eq i64 %143, %61
br i1 %144, label %145, label %136
145: ; preds = %136, %122
%146 = add nuw nsw i64 %64, 1
%147 = icmp eq i64 %146, %61
%148 = add i64 %63, 1
br i1 %147, label %129, label %62
149: ; preds = %149, %134
%150 = phi i64 [ 1, %134 ], [ %173, %149 ]
%151 = phi float [ 1.000000e+00, %134 ], [ %169, %149 ]
%152 = phi float [ %52, %134 ], [ %172, %149 ]
%153 = phi i64 [ 0, %134 ], [ %174, %149 ]
%154 = trunc i64 %150 to i32
%155 = sitofp i32 %154 to float
%156 = fadd float %50, %155
%157 = fadd float %156, -1.000000e+00
%158 = fmul float %151, %157
%159 = fdiv float %158, %155
%160 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %150, i64 %46
%161 = load float, float* %160
%162 = call float @llvm.fmuladd.f32(float %159, float %161, float %152)
%163 = add nuw nsw i64 %150, 1
%164 = trunc i64 %163 to i32
%165 = sitofp i32 %164 to float
%166 = fadd float %50, %165
%167 = fadd float %166, -1.000000e+00
%168 = fmul float %159, %167
%169 = fdiv float %168, %165
%170 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %163, i64 %46
%171 = load float, float* %170
%172 = call float @llvm.fmuladd.f32(float %169, float %171, float %162)
%173 = add nuw nsw i64 %150, 2
%174 = add i64 %153, 2
%175 = icmp eq i64 %174, %135
br i1 %175, label %176, label %149
176: ; preds = %149, %130
%177 = phi float [ undef, %130 ], [ %172, %149 ]
%178 = phi i64 [ 1, %130 ], [ %173, %149 ]
%179 = phi float [ 1.000000e+00, %130 ], [ %169, %149 ]
%180 = phi float [ %52, %130 ], [ %172, %149 ]
%181 = icmp eq i64 %132, 0
br i1 %181, label %192, label %182
182: ; preds = %176
%183 = trunc i64 %178 to i32
%184 = sitofp i32 %183 to float
%185 = fadd float %50, %184
%186 = fadd float %185, -1.000000e+00
%187 = fmul float %179, %186
%188 = fdiv float %187, %184
%189 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %5, i64 0, i64 %178, i64 %46
%190 = load float, float* %189
%191 = call float @llvm.fmuladd.f32(float %188, float %190, float %180)
br label %192
192: ; preds = %182, %176, %54, %36, %129
%193 = phi float [ %52, %129 ], [ %52, %36 ], [ %52, %54 ], [ %177, %176 ], [ %191, %182 ]
%194 = fpext float %193 to double
%195 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %194)
ret i32 0
}