#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*/ getchar();
int /*<<< orphan*/ iniB(double *, double *);
int /*<<< orphan*/ iniMatriz(double **, double *);
int /*<<< orphan*/ inicializaciones(double *, double *, double *, double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, double *);
int /*<<< orphan*/ solSistema(double **, double *, double *);
double spline(double, double *, double *, double *, double *, double *);
int /*<<< orphan*/ system(char *);
int main() {
  double X[5] = {0, 2, 3, 5, 6.1};
  double Y[5] = {2.51, 4.04, 4.7, 5.54, 5.8};
  double h[5 - 1];
  double A[5 - 1];
  double a[5 - 1];
  double b[5 - 1];
  double c[5 - 1];
  double d[5 - 1];
  double **matriz;
  double v[5];
  double B[5];
  double x;
  double estimacion;
  int i;
  matriz = (double **)malloc(5 * sizeof(int *));
  for (i = 0; i < 5; i++)
    matriz[i] = (double *)malloc(5 * sizeof(int));
  inicializaciones(h, X, Y, A);
  iniB(B, A);
  iniMatriz(matriz, h);
  solSistema(matriz, B, v);
  for (i = 0; i < 5 - 1; i++) {
    a[i] = (v[i + 1] - v[i]) / (6 * h[i]);
    b[i] = v[i] / 2;
    c[i] = A[i] - ((2 * v[i] + v[i + 1]) / 6) * h[i];
    d[i] = Y[i];
  }
  printf("dame el punto a estimar-->\n x:");
  scanf("%lf", &x);
  getchar();
  estimacion = spline(x, X, a, b, c, d);
  printf("estimacion--> %lf\n", estimacion);
  getchar();
  system("PAUSE");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1060 <memset@plt>
movsd  0xe66(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe51(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xe3c(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xe27(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1060 <memset@plt>
movsd  0xe02(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xded(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xdd8(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xdc3(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xdae(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    $0x28,%edi
call   1090 <malloc@plt>
mov    %rax,-0x128(%rbp)
movl   $0x0,-0x194(%rbp)
cmpl   $0x5,-0x194(%rbp)
jge    12b2 <main+0x102>
mov    $0x14,%edi
call   1090 <malloc@plt>
mov    %rax,%rdx
mov    -0x128(%rbp),%rax
movslq -0x194(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1272 <main+0xc2>
lea    -0x80(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x60(%rbp),%rdx
lea    -0xa0(%rbp),%rcx
call   10c0 <inicializaciones@plt>
lea    -0x180(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
call   1070 <iniB@plt>
mov    -0x128(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1050 <iniMatriz@plt>
mov    -0x128(%rbp),%rdi
lea    -0x180(%rbp),%rsi
lea    -0x150(%rbp),%rdx
call   10b0 <solSistema@plt>
movl   $0x0,-0x194(%rbp)
cmpl   $0x4,-0x194(%rbp)
jge    144c <main+0x29c>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movslq -0x194(%rbp),%rax
subsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movslq -0x194(%rbp),%rax
movsd  0xcf7(%rip),%xmm1
mulsd  -0x80(%rbp,%rax,8),%xmm1
divsd  %xmm1,%xmm0
movslq -0x194(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
movslq -0x194(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movsd  0xcbd(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x194(%rbp),%rax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
movslq -0x194(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x194(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
mov    -0x194(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x150(%rbp,%rax,8),%xmm2
ff ff
addsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  0xc6d(%rip),%xmm2
divsd  %xmm2,%xmm0
movslq -0x194(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x194(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
movslq -0x194(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0x194(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1311 <main+0x161>
lea    0xbfd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc0e(%rip),%rdi
lea    -0x188(%rbp),%rsi
call   10a0 <scanf@plt>
mov    $0x0,%al
call   1080 <getchar@plt>
movsd  -0x188(%rbp),%xmm0
ff
lea    -0x30(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
lea    -0xe0(%rbp),%rdx
lea    -0x100(%rbp),%rcx
lea    -0x120(%rbp),%r8
call   10d0 <spline@plt>
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
lea    0xbbb(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    $0x0,%al
call   1080 <getchar@plt>
lea    0xbb9(%rip),%rdi
call   1030 <system@plt>
xor    %eax,%eax
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x190,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xe41(%rip),%xmm0
movups %xmm0,0x78(%rsp)
movaps 0xe45(%rip),%xmm0
movups %xmm0,0x88(%rsp)
movaps 0xe46(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe4a(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movabs $0x4017333333333333,%rax
33 17 40
mov    %rax,0x30(%rsp)
mov    $0x28,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    $0x14,%edi
call   1080 <malloc@plt>
mov    %rax,(%rbx)
mov    $0x14,%edi
call   1080 <malloc@plt>
mov    %rax,0x8(%rbx)
mov    $0x14,%edi
call   1080 <malloc@plt>
mov    %rax,0x10(%rbx)
mov    $0x14,%edi
call   1080 <malloc@plt>
mov    %rax,0x18(%rbx)
mov    $0x14,%edi
call   1080 <malloc@plt>
mov    %rax,0x20(%rbx)
lea    0x140(%rsp),%r15
lea    0x70(%rsp),%r14
lea    0x10(%rsp),%rdx
lea    0x120(%rsp),%r12
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rcx
call   10b0 <inicializaciones@plt>
lea    0x160(%rsp),%r13
mov    %r13,%rdi
mov    %r12,%rsi
call   1060 <iniB@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
call   1050 <iniMatriz@plt>
lea    0x40(%rsp),%rdx
mov    %rbx,%rdi
mov    %r13,%rsi
call   10a0 <solSistema@plt>
movaps 0x10(%rsp),%xmm0
movaps 0x20(%rsp),%xmm1
movaps %xmm0,0xa0(%rsp)
movaps %xmm1,0xb0(%rsp)
movapd 0x40(%rsp),%xmm1
movupd 0x48(%rsp),%xmm0
unpcklpd %xmm0,%xmm1
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
movapd 0xd64(%rip),%xmm3
movapd 0x140(%rsp),%xmm4
movapd %xmm1,%xmm5
addpd  %xmm1,%xmm1
addpd  %xmm0,%xmm1
movapd 0xd67(%rip),%xmm6
divpd  %xmm6,%xmm1
mulpd  %xmm4,%xmm1
mulpd  %xmm3,%xmm4
divpd  %xmm4,%xmm2
movapd 0x150(%rsp),%xmm4
movapd %xmm2,0x100(%rsp)
movapd 0xd2d(%rip),%xmm2
mulpd  %xmm2,%xmm5
movapd %xmm5,0xe0(%rsp)
addpd  0x120(%rsp),%xmm1
movapd %xmm1,0xc0(%rsp)
movupd 0x58(%rsp),%xmm1
shufpd $0x1,%xmm1,%xmm0
movapd %xmm1,%xmm5
subpd  %xmm0,%xmm5
mulpd  %xmm4,%xmm3
divpd  %xmm3,%xmm5
movapd %xmm5,0x110(%rsp)
mulpd  %xmm0,%xmm2
movapd %xmm2,0xf0(%rsp)
addpd  %xmm0,%xmm0
addpd  %xmm1,%xmm0
divpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm0
addpd  0x130(%rsp),%xmm0
movapd %xmm0,0xd0(%rsp)
lea    0xcd4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xce5(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1090 <scanf@plt>
xor    %eax,%eax
call   1070 <getchar@plt>
movsd  0x8(%rsp),%xmm0
lea    0x100(%rsp),%rsi
lea    0xe0(%rsp),%rdx
lea    0xc0(%rsp),%rcx
lea    0xa0(%rsp),%r8
mov    %r14,%rdi
call   10c0 <spline@plt>
lea    0xca3(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1070 <getchar@plt>
lea    0xca1(%rip),%rdi
call   1030 <system@plt>
xor    %eax,%eax
add    $0x190,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [31 x i8] c"dame el punto a estimar-->\0A x:\00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [19 x i8] c"estimacion--> %lf\0A\00"
@.str.3 = [6 x i8] c"PAUSE\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [5 x double]
%3 = alloca [5 x double]
%4 = alloca [4 x double]
%5 = alloca [4 x double]
%6 = alloca [4 x double]
%7 = alloca [4 x double]
%8 = alloca [4 x double]
%9 = alloca [4 x double]
%10 = alloca double**
%11 = alloca [5 x double]
%12 = alloca [5 x double]
%13 = alloca double
%14 = alloca double
%15 = alloca i32
store i32 0, i32* %1
%16 = bitcast [5 x double]* %2 to i8*
%17 = bitcast i8* %16 to [5 x double]*
%18 = getelementptr inbounds [5 x double], [5 x double]* %17, i32 0, i32 1
store double 2.000000e+00, double* %18
%19 = getelementptr inbounds [5 x double], [5 x double]* %17, i32 0, i32 2
store double 3.000000e+00, double* %19
%20 = getelementptr inbounds [5 x double], [5 x double]* %17, i32 0, i32 3
store double 5.000000e+00, double* %20
%21 = getelementptr inbounds [5 x double], [5 x double]* %17, i32 0, i32 4
store double 6.100000e+00, double* %21
%22 = bitcast [5 x double]* %3 to i8*
%23 = bitcast i8* %22 to [5 x double]*
%24 = getelementptr inbounds [5 x double], [5 x double]* %23, i32 0, i32 0
store double 2.510000e+00, double* %24
%25 = getelementptr inbounds [5 x double], [5 x double]* %23, i32 0, i32 1
store double 4.040000e+00, double* %25
%26 = getelementptr inbounds [5 x double], [5 x double]* %23, i32 0, i32 2
store double 4.700000e+00, double* %26
%27 = getelementptr inbounds [5 x double], [5 x double]* %23, i32 0, i32 3
store double 5.540000e+00, double* %27
%28 = getelementptr inbounds [5 x double], [5 x double]* %23, i32 0, i32 4
store double 5.800000e+00, double* %28
%29 = call i64 @malloc(i32 40)
%30 = inttoptr i64 %29 to double**
store double** %30, double*** %10
store i32 0, i32* %15
br label %31
31: ; preds = %41, %0
%32 = load i32, i32* %15
%33 = icmp slt i32 %32, 5
br i1 %33, label %34, label %44
34: ; preds = %31
%35 = call i64 @malloc(i32 20)
%36 = inttoptr i64 %35 to double*
%37 = load double**, double*** %10
%38 = load i32, i32* %15
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double*, double** %37, i64 %39
store double* %36, double** %40
br label %41
41: ; preds = %34
%42 = load i32, i32* %15
%43 = add nsw i32 %42, 1
store i32 %43, i32* %15
br label %31
44: ; preds = %31
%45 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 0
%46 = getelementptr inbounds [5 x double], [5 x double]* %2, i64 0, i64 0
%47 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 0
%48 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 0
%49 = call i32 @inicializaciones(double* %45, double* %46, double* %47, double* %48)
%50 = getelementptr inbounds [5 x double], [5 x double]* %12, i64 0, i64 0
%51 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 0
%52 = call i32 @iniB(double* %50, double* %51)
%53 = load double**, double*** %10
%54 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 0
%55 = call i32 @iniMatriz(double** %53, double* %54)
%56 = load double**, double*** %10
%57 = getelementptr inbounds [5 x double], [5 x double]* %12, i64 0, i64 0
%58 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 0
%59 = call i32 @solSistema(double** %56, double* %57, double* %58)
store i32 0, i32* %15
br label %60
60: ; preds = %122, %44
%61 = load i32, i32* %15
%62 = icmp slt i32 %61, 4
br i1 %62, label %63, label %125
63: ; preds = %60
%64 = load i32, i32* %15
%65 = add nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %66
%68 = load double, double* %67
%69 = load i32, i32* %15
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %70
%72 = load double, double* %71
%73 = fsub double %68, %72
%74 = load i32, i32* %15
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 %75
%77 = load double, double* %76
%78 = fmul double 6.000000e+00, %77
%79 = fdiv double %73, %78
%80 = load i32, i32* %15
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %81
store double %79, double* %82
%83 = load i32, i32* %15
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %84
%86 = load double, double* %85
%87 = fdiv double %86, 2.000000e+00
%88 = load i32, i32* %15
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 %89
store double %87, double* %90
%91 = load i32, i32* %15
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 %92
%94 = load double, double* %93
%95 = load i32, i32* %15
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %96
%98 = load double, double* %97
%99 = load i32, i32* %15
%100 = add nsw i32 %99, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %101
%103 = load double, double* %102
%104 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %98, double %103)
%105 = fdiv double %104, 6.000000e+00
%106 = load i32, i32* %15
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 %107
%109 = load double, double* %108
%110 = fneg double %105
%111 = call double @llvm.fmuladd.f64(double %110, double %109, double %94)
%112 = load i32, i32* %15
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 %113
store double %111, double* %114
%115 = load i32, i32* %15
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 %116
%118 = load double, double* %117
%119 = load i32, i32* %15
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 %120
store double %118, double* %121
br label %122
122: ; preds = %63
%123 = load i32, i32* %15
%124 = add nsw i32 %123, 1
store i32 %124, i32* %15
br label %60
125: ; preds = %60
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%127 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %13)
%128 = call i32 (...) @getchar()
%129 = load double, double* %13
%130 = getelementptr inbounds [5 x double], [5 x double]* %2, i64 0, i64 0
%131 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 0
%132 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%133 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 0
%134 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 0
%135 = call double @spline(double %129, double* %130, double* %131, double* %132, double* %133, double* %134)
store double %135, double* %14
%136 = load double, double* %14
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), double %136)
%138 = call i32 (...) @getchar()
%139 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [31 x i8] c"dame el punto a estimar-->\0A x:\00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [19 x i8] c"estimacion--> %lf\0A\00"
@.str.3 = [6 x i8] c"PAUSE\00"
define i32 @main() {
%1 = alloca [5 x double]
%2 = alloca [5 x double]
%3 = bitcast [5 x double]* %2 to i8*
%4 = alloca [4 x double]
%5 = alloca [4 x double]
%6 = alloca [4 x double]
%7 = alloca [4 x double]
%8 = alloca [4 x double]
%9 = alloca [4 x double]
%10 = bitcast [4 x double]* %9 to i8*
%11 = alloca [5 x double]
%12 = alloca [5 x double]
%13 = alloca double
%14 = bitcast [5 x double]* %1 to i8*
%15 = getelementptr inbounds [5 x double], [5 x double]* %1, i64 0, i64 1
%16 = bitcast double* %15 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 3.000000e+00>, <2 x double>* %16
%17 = getelementptr inbounds [5 x double], [5 x double]* %1, i64 0, i64 3
%18 = bitcast double* %17 to <2 x double>*
store <2 x double> <double 5.000000e+00, double 6.100000e+00>, <2 x double>* %18
%19 = getelementptr inbounds [5 x double], [5 x double]* %2, i64 0, i64 0
%20 = bitcast [5 x double]* %2 to <2 x double>*
store <2 x double> <double 2.510000e+00, double 4.040000e+00>, <2 x double>* %20
%21 = getelementptr inbounds [5 x double], [5 x double]* %2, i64 0, i64 2
%22 = bitcast double* %21 to <2 x double>*
store <2 x double> <double 4.700000e+00, double 5.540000e+00>, <2 x double>* %22
%23 = getelementptr inbounds [5 x double], [5 x double]* %2, i64 0, i64 4
store double 5.800000e+00, double* %23
%24 = bitcast [4 x double]* %4 to i8*
%25 = bitcast [4 x double]* %5 to i8*
%26 = bitcast [4 x double]* %6 to i8*
%27 = bitcast [4 x double]* %7 to i8*
%28 = bitcast [4 x double]* %8 to i8*
%29 = bitcast [5 x double]* %11 to i8*
%30 = bitcast [5 x double]* %12 to i8*
%31 = bitcast double* %13 to i8*
%32 = tail call i64 @malloc(i32 40)
%33 = inttoptr i64 %32 to double**
%34 = tail call i64 @malloc(i32 20)
%35 = inttoptr i64 %34 to double*
store double* %35, double** %33
%36 = tail call i64 @malloc(i32 20)
%37 = inttoptr i64 %36 to double*
%38 = getelementptr inbounds double*, double** %33, i64 1
store double* %37, double** %38
%39 = tail call i64 @malloc(i32 20)
%40 = inttoptr i64 %39 to double*
%41 = getelementptr inbounds double*, double** %33, i64 2
store double* %40, double** %41
%42 = tail call i64 @malloc(i32 20)
%43 = inttoptr i64 %42 to double*
%44 = getelementptr inbounds double*, double** %33, i64 3
store double* %43, double** %44
%45 = tail call i64 @malloc(i32 20)
%46 = inttoptr i64 %45 to double*
%47 = getelementptr inbounds double*, double** %33, i64 4
store double* %46, double** %47
%48 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 0
%49 = getelementptr inbounds [5 x double], [5 x double]* %1, i64 0, i64 0
%50 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 0
%51 = call i32 @inicializaciones(double* %48, double* %49, double* %19, double* %50)
%52 = getelementptr inbounds [5 x double], [5 x double]* %12, i64 0, i64 0
%53 = call i32 @iniB(double* %52, double* %50)
%54 = call i32 @iniMatriz(double** %33, double* %48)
%55 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 0
%56 = call i32 @solSistema(double** %33, double* %52, double* %55)
%57 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 1
%58 = bitcast [5 x double]* %11 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 0
%61 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%62 = bitcast double* %57 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = bitcast [4 x double]* %4 to <2 x double>*
%65 = load <2 x double>, <2 x double>* %64
%66 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 0
%67 = shufflevector <2 x double> %59, <2 x double> %63, <2 x i32> <i32 0, i32 2>
%68 = fsub <2 x double> %63, %67
%69 = fmul <2 x double> %65, <double 6.000000e+00, double 6.000000e+00>
%70 = fdiv <2 x double> %68, %69
%71 = bitcast [4 x double]* %6 to <2 x double>*
store <2 x double> %70, <2 x double>* %71
%72 = fmul <2 x double> %67, <double 5.000000e-01, double 5.000000e-01>
%73 = bitcast [4 x double]* %7 to <2 x double>*
store <2 x double> %72, <2 x double>* %73
%74 = bitcast [4 x double]* %5 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %63)
%77 = fdiv <2 x double> %76, <double -6.000000e+00, double -6.000000e+00>
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %77, <2 x double> %65, <2 x double> %75)
%79 = bitcast [4 x double]* %8 to <2 x double>*
store <2 x double> %78, <2 x double>* %79
%80 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 3
%81 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 2
%82 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 2
%83 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 2
%84 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 2
%85 = bitcast double* %80 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = bitcast double* %81 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = getelementptr inbounds [4 x double], [4 x double]* %8, i64 0, i64 2
%90 = shufflevector <2 x double> %63, <2 x double> %86, <2 x i32> <i32 1, i32 2>
%91 = fsub <2 x double> %86, %90
%92 = fmul <2 x double> %88, <double 6.000000e+00, double 6.000000e+00>
%93 = fdiv <2 x double> %91, %92
%94 = bitcast double* %82 to <2 x double>*
store <2 x double> %93, <2 x double>* %94
%95 = fmul <2 x double> %90, <double 5.000000e-01, double 5.000000e-01>
%96 = bitcast double* %83 to <2 x double>*
store <2 x double> %95, <2 x double>* %96
%97 = bitcast double* %84 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %86)
%100 = fdiv <2 x double> %99, <double -6.000000e+00, double -6.000000e+00>
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %100, <2 x double> %88, <2 x double> %98)
%102 = bitcast double* %89 to <2 x double>*
store <2 x double> %101, <2 x double>* %102
%103 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%104 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %13)
%105 = call i32 (...) @getchar()
%106 = load double, double* %13
%107 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 0
%108 = call double @spline(double %106, double* %49, double* %60, double* %61, double* %66, double* %107)
%109 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), double %108)
%110 = call i32 (...) @getchar()
%111 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
ret i32 0
}