#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() {
  float f[10][10], x[10], y[10], a, u, h, s, p = 1.0;
  int n, i, j;
  printf("Enter the value of n\n");
  scanf("%d", &n);
  printf("Enter x values\n");
  for (i = 0; i <= n; i++)
    scanf("%f", &x[i]);
  printf("Enter y values\n");
  for (i = 0; i <= n; i++)
    scanf("%f", &y[i]);
  printf("Enter interpolating point\n");
  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 = s + p * f[i][n];
  }
  printf("%6.5f\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,-0x214(%rbp)
ff
lea    0xebb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xec3(%rip),%rdi
lea    -0x218(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xeb1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     11c6 <main+0xa6>
movslq -0x21c(%rbp),%rax
lea    -0x1d0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe82(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    117d <main+0x5d>
lea    0xe63(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     1227 <main+0x107>
movslq -0x21c(%rbp),%rax
lea    -0x200(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe21(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    11de <main+0xbe>
lea    0xe12(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdf1(%rip),%rdi
lea    -0x204(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movss  -0x1cc(%rbp),%xmm0
ff
subss  -0x1d0(%rbp),%xmm0
ff
movss  %xmm0,-0x20c(%rbp)
ff
movss  -0x204(%rbp),%xmm0
ff
movslq -0x218(%rbp),%rax
subss  -0x1d0(%rbp,%rax,4),%xmm0
ff ff
divss  -0x20c(%rbp),%xmm0
ff
movss  %xmm0,-0x208(%rbp)
ff
movslq -0x218(%rbp),%rax
movss  -0x200(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x210(%rbp)
ff
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     12f2 <main+0x1d2>
movslq -0x220(%rbp),%rax
movss  -0x200(%rbp,%rax,4),%xmm0
ff ff
movslq -0x220(%rbp),%rax
movss  %xmm0,-0x1a0(%rbp,%rax,4)
ff ff
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    12ac <main+0x18c>
movl   $0x1,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     13cb <main+0x2ab>
mov    -0x21c(%rbp),%eax
mov    %eax,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     13b2 <main+0x292>
mov    -0x21c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x220(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x21c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0x220(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movslq -0x21c(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x220(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    131a <main+0x1fa>
jmp    13b7 <main+0x297>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    12fc <main+0x1dc>
movl   $0x1,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     147c <main+0x35c>
movss  -0x214(%rbp),%xmm0
ff
movss  -0x208(%rbp),%xmm1
ff
cvtsi2ssl -0x21c(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  0xbf5(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtsi2ssl -0x21c(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x214(%rbp)
ff
movss  -0x210(%rbp),%xmm1
ff
movss  -0x214(%rbp),%xmm0
ff
movslq -0x21c(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x210(%rbp)
ff
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    13d5 <main+0x2b5>
movss  -0x210(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xbcc(%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    0xec0(%rip),%rdi
call   1030 <puts@plt>
lea    0xea7(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xeb6(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
js     11bf <main+0x7f>
mov    $0xffffffffffffffff,%r15
lea    0x20(%rsp),%rbx
lea    0xe78(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%r15
add    $0x4,%rbx
cmp    %rax,%r15
jl     11a0 <main+0x60>
lea    0xe73(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
js     120f <main+0xcf>
mov    $0xffffffffffffffff,%r15
lea    0x50(%rsp),%rbx
lea    0xe26(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%r15
add    $0x4,%rbx
cmp    %rax,%r15
jl     11f0 <main+0xb0>
lea    0xe32(%rip),%rdi
call   1030 <puts@plt>
lea    0xde9(%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     14f5 <main+0x3b5>
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     1429 <main+0x2e9>
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    12ed <main+0x1ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0x1,%r11
add    $0x2c,%rcx
add    $0xffffffffffffffff,%r15
add    $0x28,%rbx
cmp    %rax,%r12
je     1403 <main+0x2c3>
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    1320 <main+0x1e0>
mov    %r12,%rdx
jmp    13e0 <main+0x2a0>
add    %rax,%rdx
add    $0xfffffffffffffffe,%rdx
mov    %rdx,%r10
shr    %r10
add    $0x1,%r10
shufps $0x0,%xmm0,%xmm0
cmp    $0x2,%rdx
jae    1340 <main+0x200>
xor    %edi,%edi
jmp    1395 <main+0x255>
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    1360 <main+0x220>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
test   $0x1,%r10b
je     13cf <main+0x28f>
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     12d0 <main+0x190>
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    13e0 <main+0x2a0>
jmp    12d0 <main+0x190>
test   %r14d,%r14d
je     14f5 <main+0x3b5>
mov    %eax,%ecx
add    $0xffffffffffffffff,%rax
cmp    $0x2,%ecx
jne    1434 <main+0x2f4>
movss  0xbe1(%rip),%xmm0
mov    $0x1,%ecx
jmp    14be <main+0x37e>
movss  0x10(%rsp),%xmm5
jmp    14f5 <main+0x3b5>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rsp,%r14,4),%rsi
add    $0xd0,%rsi
movss  0xbb2(%rip),%xmm0
mov    $0x1,%ecx
movss  0xba9(%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    1460 <main+0x320>
test   $0x1,%al
je     14f5 <main+0x3b5>
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
addss  %xmm1,%xmm6
addss  0xb2f(%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    0xb0b(%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 = [16 x i8] c"Enter x values\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [16 x i8] c"Enter y values\0A\00"
@.str.5 = [27 x i8] c"Enter interpolating point\0A\00"
@.str.6 = [7 x i8] c"%6.5f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10 x [10 x float]]
%3 = alloca [10 x float]
%4 = alloca [10 x float]
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 0, i32* %1
store float 1.000000e+00, float* %9
%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* %10)
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %11
br label %16
16: ; preds = %25, %0
%17 = load i32, i32* %11
%18 = load i32, i32* %10
%19 = icmp sle i32 %17, %18
br i1 %19, label %20, label %28
20: ; preds = %16
%21 = load i32, i32* %11
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [10 x float], [10 x float]* %3, 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* %11
%27 = add nsw i32 %26, 1
store i32 %27, i32* %11
br label %16
28: ; preds = %16
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %11
br label %30
30: ; preds = %39, %28
%31 = load i32, i32* %11
%32 = load i32, i32* %10
%33 = icmp sle i32 %31, %32
br i1 %33, label %34, label %42
34: ; preds = %30
%35 = load i32, i32* %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [10 x float], [10 x float]* %4, 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* %11
%41 = add nsw i32 %40, 1
store i32 %41, i32* %11
br label %30
42: ; preds = %30
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 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* %5)
%45 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 1
%46 = load float, float* %45
%47 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 0
%48 = load float, float* %47
%49 = fsub float %46, %48
store float %49, float* %7
%50 = load float, float* %5
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 %52
%54 = load float, float* %53
%55 = fsub float %50, %54
%56 = load float, float* %7
%57 = fdiv float %55, %56
store float %57, float* %6
%58 = load i32, i32* %10
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 %59
%61 = load float, float* %60
store float %61, float* %8
store i32 0, i32* %12
br label %62
62: ; preds = %75, %42
%63 = load i32, i32* %12
%64 = load i32, i32* %10
%65 = icmp sle i32 %63, %64
br i1 %65, label %66, label %78
66: ; preds = %62
%67 = load i32, i32* %12
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 %68
%70 = load float, float* %69
%71 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %2, i64 0, i64 0
%72 = load i32, i32* %12
%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* %12
%77 = add nsw i32 %76, 1
store i32 %77, i32* %12
br label %62
78: ; preds = %62
store i32 1, i32* %11
br label %79
79: ; preds = %118, %78
%80 = load i32, i32* %11
%81 = load i32, i32* %10
%82 = icmp sle i32 %80, %81
br i1 %82, label %83, label %121
83: ; preds = %79
%84 = load i32, i32* %11
store i32 %84, i32* %12
br label %85
85: ; preds = %114, %83
%86 = load i32, i32* %12
%87 = load i32, i32* %10
%88 = icmp sle i32 %86, %87
br i1 %88, label %89, label %117
89: ; preds = %85
%90 = load i32, i32* %11
%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]]* %2, i64 0, i64 %92
%94 = load i32, i32* %12
%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* %11
%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]]* %2, i64 0, i64 %100
%102 = load i32, i32* %12
%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* %11
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %2, i64 0, i64 %109
%111 = load i32, i32* %12
%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* %12
%116 = add nsw i32 %115, 1
store i32 %116, i32* %12
br label %85
117: ; preds = %85
br label %118
118: ; preds = %117
%119 = load i32, i32* %11
%120 = add nsw i32 %119, 1
store i32 %120, i32* %11
br label %79
121: ; preds = %79
store i32 1, i32* %11
br label %122
122: ; preds = %147, %121
%123 = load i32, i32* %11
%124 = load i32, i32* %10
%125 = icmp sle i32 %123, %124
br i1 %125, label %126, label %150
126: ; preds = %122
%127 = load float, float* %9
%128 = load float, float* %6
%129 = load i32, i32* %11
%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* %11
%135 = sitofp i32 %134 to float
%136 = fdiv float %133, %135
store float %136, float* %9
%137 = load float, float* %8
%138 = load float, float* %9
%139 = load i32, i32* %11
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %2, i64 0, i64 %140
%142 = load i32, i32* %10
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [10 x float], [10 x float]* %141, i64 0, i64 %143
%145 = load float, float* %144
%146 = call float @llvm.fmuladd.f32(float %138, float %145, float %137)
store float %146, float* %8
br label %147
147: ; preds = %126
%148 = load i32, i32* %11
%149 = add nsw i32 %148, 1
store i32 %149, i32* %11
br label %122
150: ; preds = %122
%151 = load float, float* %8
%152 = fpext float %151 to double
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 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.6 = [7 x i8] c"%6.5f\0A\00"
@str = [21 x i8] c"Enter the value of n\00"
@str.7 = [15 x i8] c"Enter x values\00"
@str.8 = [15 x i8] c"Enter y values\00"
@str.9 = [26 x i8] c"Enter interpolating point\00"
define i32 @main() {
%1 = alloca [10 x [10 x float]]
%2 = bitcast [10 x [10 x float]]* %1 to i8*
%3 = alloca [10 x float]
%4 = alloca [10 x float]
%5 = bitcast [10 x float]* %4 to i8*
%6 = alloca float
%7 = alloca i32
%8 = bitcast [10 x float]* %3 to i8*
%9 = bitcast float* %6 to i8*
%10 = bitcast i32* %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* %7)
%13 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.7, i64 0, i64 0))
%14 = load i32, i32* %7
%15 = icmp slt i32 %14, 0
br i1 %15, label %24, label %16
16: ; preds = %0, %16
%17 = phi i64 [ %20, %16 ], [ 0, %0 ]
%18 = getelementptr inbounds [10 x float], [10 x float]* %3, 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* %7
%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 ([15 x i8], [15 x i8]* @str.8, i64 0, i64 0))
%26 = load i32, i32* %7
%27 = icmp slt i32 %26, 0
br i1 %27, label %36, label %28
28: ; preds = %24, %28
%29 = phi i64 [ %32, %28 ], [ 0, %24 ]
%30 = getelementptr inbounds [10 x float], [10 x float]* %4, 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* %7
%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 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.9, 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* %6)
%39 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 1
%40 = load float, float* %39
%41 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 0
%42 = load float, float* %41
%43 = fsub float %40, %42
%44 = load float, float* %6
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [10 x float], [10 x float]* %3, 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]* %4, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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]]* %1, 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 ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %194)
ret i32 0
}