#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 */
double f(double, double);
double fabs(double);
double freal(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, double, ...);
int /*<<< orphan*/ system(char *);
int main() {
  double a = 0;
  double b = 1;
  double h1 = 0.1;
  double h2 = 0.01;
  double h3 = 0.001;
  double *X;
  double *Y;
  double *sol;
  double *error;
  int i;
  int n;
  n = (b - a) / h1 + 1;
  printf("n:%d\n", n);
  X = (double *)malloc((n + 1) * sizeof(double));
  Y = (double *)malloc((n + 1) * sizeof(double));
  sol = (double *)malloc((n + 1) * sizeof(double));
  error = (double *)malloc((n + 1) * sizeof(double));
  X[0] = a;
  Y[0] = 4;
  sol[0] = freal(X[0]);
  for (i = 1; i < n + 1; i++) {
    X[i] = X[i - 1] + h1;
    Y[i] = Y[i - 1] + f(X[i - 1], Y[i - 1]) * h1;
    sol[i] = freal(X[i]);
    error[i] = fabs(sol[i] - Y[i]);
  }
  printf("Para x=1 y con h=%lf:\n error:%lf\n", h1, error[n]);
  free(X);
  free(Y);
  free(sol);
  free(error);
  n = (b - a) / h2 + 1;
  printf("n:%d\n", n);
  X = (double *)malloc((n + 1) * sizeof(double));
  Y = (double *)malloc((n + 1) * sizeof(double));
  sol = (double *)malloc((n + 1) * sizeof(double));
  error = (double *)malloc((n + 1) * sizeof(double));
  X[0] = a;
  Y[0] = 4;
  sol[0] = freal(X[0]);
  for (i = 1; i < n + 1; i++) {
    X[i] = X[i - 1] + h2;
    Y[i] = Y[i - 1] + f(X[i - 1], Y[i - 1]) * h2;
    sol[i] = freal(X[i]);
    error[i] = fabs(sol[i] - Y[i]);
  }
  printf("Para x=1 y con h=%lf:\n error:%lf\n", h2, error[n]);
  free(X);
  free(Y);
  free(sol);
  free(error);
  n = (b - a) / h3 + 1;
  printf("n:%d\n", n);
  X = (double *)malloc((n + 1) * sizeof(double));
  Y = (double *)malloc((n + 1) * sizeof(double));
  sol = (double *)malloc((n + 1) * sizeof(double));
  error = (double *)malloc((n + 1) * sizeof(double));
  X[0] = a;
  Y[0] = 4;
  sol[0] = freal(X[0]);
  for (i = 1; i < n + 1; i++) {
    X[i] = X[i - 1] + h3;
    Y[i] = Y[i - 1] + f(X[i - 1], Y[i - 1]) * h3;
    sol[i] = freal(X[i]);
    error[i] = fabs(sol[i] - Y[i]);
  }
  printf("Para x=1 y con h=%lf:\n error:%lf\n", h3, error[n]);
  free(X);
  free(Y);
  free(sol);
  free(error);
  system("PAUSE");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0xe89(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xe94(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xe7f(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe6a(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  0xe46(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x58(%rbp)
cvtsi2sdl -0x58(%rbp),%xmm0
lea    0xe67(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movsd  0xdab(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1368 <main+0x208>
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x20(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1050 <f@plt>
movsd  -0x60(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xce7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1275 <main+0x115>
movsd  -0x20(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xcc5(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x18(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  0xc45(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x58(%rbp)
cvtsi2sdl -0x58(%rbp),%xmm0
lea    0xc66(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movsd  0xbaa(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1569 <main+0x409>
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1050 <f@plt>
movsd  -0x68(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xae6(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1476 <main+0x316>
movsd  -0x28(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xac4(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x18(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  0xa44(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x58(%rbp)
cvtsi2sdl -0x58(%rbp),%xmm0
lea    0xa65(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movsd  0x9a9(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    176a <main+0x60a>
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1050 <f@plt>
movsd  -0x70(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <freal@plt>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x8e5(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1677 <main+0x517>
movsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x8c3(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
lea    0x8b3(%rip),%rdi
call   1060 <system@plt>
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xece(%rip),%rdi
movsd  0xe86(%rip),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x60,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    $0x60,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    $0x60,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    $0x60,%edi
call   1080 <malloc@plt>
mov    %rax,%r12
movq   $0x0,(%r14)
movabs $0x4010000000000000,%r13
mov    %r13,(%rbx)
movsd  (%r14),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,(%r15)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,1),%xmm0
movapd %xmm0,%xmm1
movsd  0xe16(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r14,%rbp,1)
movsd  (%rbx,%rbp,1),%xmm1
movsd  %xmm1,(%rsp)
call   1050 <f@plt>
mulsd  0xdf4(%rip),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,1)
movsd  0x8(%r14,%rbp,1),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,0x8(%r15,%rbp,1)
subsd  0x8(%rbx,%rbp,1),%xmm0
andpd  0xdf0(%rip),%xmm0
movlpd %xmm0,0x8(%r12,%rbp,1)
add    $0x8,%rbp
cmp    $0x58,%rbp
jne    11e0 <main+0x80>
movsd  0x58(%r12),%xmm1
lea    0xde7(%rip),%rdi
movsd  0xda1(%rip),%xmm0
mov    $0x2,%al
call   1070 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
lea    0xdab(%rip),%rdi
movsd  0xd73(%rip),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x330,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    $0x330,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    $0x330,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    $0x330,%edi
call   1080 <malloc@plt>
mov    %rax,%r12
movq   $0x0,(%r14)
mov    %r13,(%rbx)
movsd  (%r14),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,(%r15)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rbp,1),%xmm0
movapd %xmm0,%xmm1
movsd  0xd06(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r14,%rbp,1)
movsd  (%rbx,%rbp,1),%xmm1
movsd  %xmm1,(%rsp)
call   1050 <f@plt>
mulsd  0xce4(%rip),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,1)
movsd  0x8(%r14,%rbp,1),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,0x8(%r15,%rbp,1)
subsd  0x8(%rbx,%rbp,1),%xmm0
andpd  0xcd0(%rip),%xmm0
movlpd %xmm0,0x8(%r12,%rbp,1)
add    $0x8,%rbp
cmp    $0x328,%rbp
jne    1300 <main+0x1a0>
movsd  0x328(%r12),%xmm1
lea    0xcc1(%rip),%rdi
movsd  0xc8b(%rip),%xmm0
mov    $0x2,%al
call   1070 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
lea    0xc85(%rip),%rdi
movsd  0xc5d(%rip),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x1f50,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    $0x1f50,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    $0x1f50,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    $0x1f50,%edi
call   1080 <malloc@plt>
mov    %rax,%r12
movq   $0x0,(%r14)
mov    %r13,(%rbx)
movsd  (%r14),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,(%r15)
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%r14,%rbp,1),%xmm0
movapd %xmm0,%xmm1
movsd  0xbf6(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r14,%rbp,1)
movsd  (%rbx,%rbp,1),%xmm1
movsd  %xmm1,(%rsp)
call   1050 <f@plt>
mulsd  0xbd4(%rip),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,1)
movsd  0x8(%r14,%rbp,1),%xmm0
call   1040 <freal@plt>
movsd  %xmm0,0x8(%r15,%rbp,1)
subsd  0x8(%rbx,%rbp,1),%xmm0
andpd  0xbb0(%rip),%xmm0
movlpd %xmm0,0x8(%r12,%rbp,1)
add    $0x8,%rbp
cmp    $0x1f48,%rbp
jne    1420 <main+0x2c0>
movsd  0x1f48(%r12),%xmm1
lea    0xba1(%rip),%rdi
movsd  0xb7b(%rip),%xmm0
mov    $0x2,%al
call   1070 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
lea    0xb8d(%rip),%rdi
call   1060 <system@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"n:%d\0A\00"
@.str.1 = [34 x i8] c"Para x=1 y con h=%lf:\0A error:%lf\0A\00"
@.str.2 = [6 x i8] c"PAUSE\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
store i32 0, i32* %1
store double 0.000000e+00, double* %2
store double 1.000000e+00, double* %3
store double 1.000000e-01, double* %4
store double 1.000000e-02, double* %5
store double 1.000000e-03, double* %6
%13 = load double, double* %3
%14 = load double, double* %2
%15 = fsub double %13, %14
%16 = load double, double* %4
%17 = fdiv double %15, %16
%18 = fadd double %17, 1.000000e+00
%19 = fptosi double %18 to i32
store i32 %19, i32* %12
%20 = load i32, i32* %12
%21 = sitofp i32 %20 to double
%22 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double %21)
%23 = load i32, i32* %12
%24 = add nsw i32 %23, 1
%25 = sext i32 %24 to i64
%26 = mul i64 %25, 8
%27 = trunc i64 %26 to i32
%28 = call i64 @malloc(i32 %27)
%29 = inttoptr i64 %28 to double*
store double* %29, double** %7
%30 = load i32, i32* %12
%31 = add nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 8
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to double*
store double* %36, double** %8
%37 = load i32, i32* %12
%38 = add nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = mul i64 %39, 8
%41 = trunc i64 %40 to i32
%42 = call i64 @malloc(i32 %41)
%43 = inttoptr i64 %42 to double*
store double* %43, double** %9
%44 = load i32, i32* %12
%45 = add nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = mul i64 %46, 8
%48 = trunc i64 %47 to i32
%49 = call i64 @malloc(i32 %48)
%50 = inttoptr i64 %49 to double*
store double* %50, double** %10
%51 = load double, double* %2
%52 = load double*, double** %7
%53 = getelementptr inbounds double, double* %52, i64 0
store double %51, double* %53
%54 = load double*, double** %8
%55 = getelementptr inbounds double, double* %54, i64 0
store double 4.000000e+00, double* %55
%56 = load double*, double** %7
%57 = getelementptr inbounds double, double* %56, i64 0
%58 = load double, double* %57
%59 = call double @freal(double %58)
%60 = load double*, double** %9
%61 = getelementptr inbounds double, double* %60, i64 0
store double %59, double* %61
store i32 1, i32* %11
br label %62
62: ; preds = %131, %0
%63 = load i32, i32* %11
%64 = load i32, i32* %12
%65 = add nsw i32 %64, 1
%66 = icmp slt i32 %63, %65
br i1 %66, label %67, label %134
67: ; preds = %62
%68 = load double*, double** %7
%69 = load i32, i32* %11
%70 = sub nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %68, i64 %71
%73 = load double, double* %72
%74 = load double, double* %4
%75 = fadd double %73, %74
%76 = load double*, double** %7
%77 = load i32, i32* %11
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
store double %75, double* %79
%80 = load double*, double** %8
%81 = load i32, i32* %11
%82 = sub nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %80, i64 %83
%85 = load double, double* %84
%86 = load double*, double** %7
%87 = load i32, i32* %11
%88 = sub nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %86, i64 %89
%91 = load double, double* %90
%92 = load double*, double** %8
%93 = load i32, i32* %11
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %92, i64 %95
%97 = load double, double* %96
%98 = call double @f(double %91, double %97)
%99 = load double, double* %4
%100 = call double @llvm.fmuladd.f64(double %98, double %99, double %85)
%101 = load double*, double** %8
%102 = load i32, i32* %11
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
store double %100, double* %104
%105 = load double*, double** %7
%106 = load i32, i32* %11
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = call double @freal(double %109)
%111 = load double*, double** %9
%112 = load i32, i32* %11
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %111, i64 %113
store double %110, double* %114
%115 = load double*, double** %9
%116 = load i32, i32* %11
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %8
%121 = load i32, i32* %11
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
%124 = load double, double* %123
%125 = fsub double %119, %124
%126 = call double @llvm.fabs.f64(double %125)
%127 = load double*, double** %10
%128 = load i32, i32* %11
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
store double %126, double* %130
br label %131
131: ; preds = %67
%132 = load i32, i32* %11
%133 = add nsw i32 %132, 1
store i32 %133, i32* %11
br label %62
134: ; preds = %62
%135 = load double, double* %4
%136 = load double*, double** %10
%137 = load i32, i32* %12
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double %135, double %140)
%142 = load double*, double** %7
%143 = call i32 @free(double* %142)
%144 = load double*, double** %8
%145 = call i32 @free(double* %144)
%146 = load double*, double** %9
%147 = call i32 @free(double* %146)
%148 = load double*, double** %10
%149 = call i32 @free(double* %148)
%150 = load double, double* %3
%151 = load double, double* %2
%152 = fsub double %150, %151
%153 = load double, double* %5
%154 = fdiv double %152, %153
%155 = fadd double %154, 1.000000e+00
%156 = fptosi double %155 to i32
store i32 %156, i32* %12
%157 = load i32, i32* %12
%158 = sitofp i32 %157 to double
%159 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double %158)
%160 = load i32, i32* %12
%161 = add nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = mul i64 %162, 8
%164 = trunc i64 %163 to i32
%165 = call i64 @malloc(i32 %164)
%166 = inttoptr i64 %165 to double*
store double* %166, double** %7
%167 = load i32, i32* %12
%168 = add nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = mul i64 %169, 8
%171 = trunc i64 %170 to i32
%172 = call i64 @malloc(i32 %171)
%173 = inttoptr i64 %172 to double*
store double* %173, double** %8
%174 = load i32, i32* %12
%175 = add nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = mul i64 %176, 8
%178 = trunc i64 %177 to i32
%179 = call i64 @malloc(i32 %178)
%180 = inttoptr i64 %179 to double*
store double* %180, double** %9
%181 = load i32, i32* %12
%182 = add nsw i32 %181, 1
%183 = sext i32 %182 to i64
%184 = mul i64 %183, 8
%185 = trunc i64 %184 to i32
%186 = call i64 @malloc(i32 %185)
%187 = inttoptr i64 %186 to double*
store double* %187, double** %10
%188 = load double, double* %2
%189 = load double*, double** %7
%190 = getelementptr inbounds double, double* %189, i64 0
store double %188, double* %190
%191 = load double*, double** %8
%192 = getelementptr inbounds double, double* %191, i64 0
store double 4.000000e+00, double* %192
%193 = load double*, double** %7
%194 = getelementptr inbounds double, double* %193, i64 0
%195 = load double, double* %194
%196 = call double @freal(double %195)
%197 = load double*, double** %9
%198 = getelementptr inbounds double, double* %197, i64 0
store double %196, double* %198
store i32 1, i32* %11
br label %199
199: ; preds = %268, %134
%200 = load i32, i32* %11
%201 = load i32, i32* %12
%202 = add nsw i32 %201, 1
%203 = icmp slt i32 %200, %202
br i1 %203, label %204, label %271
204: ; preds = %199
%205 = load double*, double** %7
%206 = load i32, i32* %11
%207 = sub nsw i32 %206, 1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %205, i64 %208
%210 = load double, double* %209
%211 = load double, double* %5
%212 = fadd double %210, %211
%213 = load double*, double** %7
%214 = load i32, i32* %11
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
store double %212, double* %216
%217 = load double*, double** %8
%218 = load i32, i32* %11
%219 = sub nsw i32 %218, 1
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %217, i64 %220
%222 = load double, double* %221
%223 = load double*, double** %7
%224 = load i32, i32* %11
%225 = sub nsw i32 %224, 1
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %223, i64 %226
%228 = load double, double* %227
%229 = load double*, double** %8
%230 = load i32, i32* %11
%231 = sub nsw i32 %230, 1
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %229, i64 %232
%234 = load double, double* %233
%235 = call double @f(double %228, double %234)
%236 = load double, double* %5
%237 = call double @llvm.fmuladd.f64(double %235, double %236, double %222)
%238 = load double*, double** %8
%239 = load i32, i32* %11
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
store double %237, double* %241
%242 = load double*, double** %7
%243 = load i32, i32* %11
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %242, i64 %244
%246 = load double, double* %245
%247 = call double @freal(double %246)
%248 = load double*, double** %9
%249 = load i32, i32* %11
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %248, i64 %250
store double %247, double* %251
%252 = load double*, double** %9
%253 = load i32, i32* %11
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %252, i64 %254
%256 = load double, double* %255
%257 = load double*, double** %8
%258 = load i32, i32* %11
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
%262 = fsub double %256, %261
%263 = call double @llvm.fabs.f64(double %262)
%264 = load double*, double** %10
%265 = load i32, i32* %11
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %264, i64 %266
store double %263, double* %267
br label %268
268: ; preds = %204
%269 = load i32, i32* %11
%270 = add nsw i32 %269, 1
store i32 %270, i32* %11
br label %199
271: ; preds = %199
%272 = load double, double* %5
%273 = load double*, double** %10
%274 = load i32, i32* %12
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
%278 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double %272, double %277)
%279 = load double*, double** %7
%280 = call i32 @free(double* %279)
%281 = load double*, double** %8
%282 = call i32 @free(double* %281)
%283 = load double*, double** %9
%284 = call i32 @free(double* %283)
%285 = load double*, double** %10
%286 = call i32 @free(double* %285)
%287 = load double, double* %3
%288 = load double, double* %2
%289 = fsub double %287, %288
%290 = load double, double* %6
%291 = fdiv double %289, %290
%292 = fadd double %291, 1.000000e+00
%293 = fptosi double %292 to i32
store i32 %293, i32* %12
%294 = load i32, i32* %12
%295 = sitofp i32 %294 to double
%296 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double %295)
%297 = load i32, i32* %12
%298 = add nsw i32 %297, 1
%299 = sext i32 %298 to i64
%300 = mul i64 %299, 8
%301 = trunc i64 %300 to i32
%302 = call i64 @malloc(i32 %301)
%303 = inttoptr i64 %302 to double*
store double* %303, double** %7
%304 = load i32, i32* %12
%305 = add nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = mul i64 %306, 8
%308 = trunc i64 %307 to i32
%309 = call i64 @malloc(i32 %308)
%310 = inttoptr i64 %309 to double*
store double* %310, double** %8
%311 = load i32, i32* %12
%312 = add nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = mul i64 %313, 8
%315 = trunc i64 %314 to i32
%316 = call i64 @malloc(i32 %315)
%317 = inttoptr i64 %316 to double*
store double* %317, double** %9
%318 = load i32, i32* %12
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = mul i64 %320, 8
%322 = trunc i64 %321 to i32
%323 = call i64 @malloc(i32 %322)
%324 = inttoptr i64 %323 to double*
store double* %324, double** %10
%325 = load double, double* %2
%326 = load double*, double** %7
%327 = getelementptr inbounds double, double* %326, i64 0
store double %325, double* %327
%328 = load double*, double** %8
%329 = getelementptr inbounds double, double* %328, i64 0
store double 4.000000e+00, double* %329
%330 = load double*, double** %7
%331 = getelementptr inbounds double, double* %330, i64 0
%332 = load double, double* %331
%333 = call double @freal(double %332)
%334 = load double*, double** %9
%335 = getelementptr inbounds double, double* %334, i64 0
store double %333, double* %335
store i32 1, i32* %11
br label %336
336: ; preds = %405, %271
%337 = load i32, i32* %11
%338 = load i32, i32* %12
%339 = add nsw i32 %338, 1
%340 = icmp slt i32 %337, %339
br i1 %340, label %341, label %408
341: ; preds = %336
%342 = load double*, double** %7
%343 = load i32, i32* %11
%344 = sub nsw i32 %343, 1
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %342, i64 %345
%347 = load double, double* %346
%348 = load double, double* %6
%349 = fadd double %347, %348
%350 = load double*, double** %7
%351 = load i32, i32* %11
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
store double %349, double* %353
%354 = load double*, double** %8
%355 = load i32, i32* %11
%356 = sub nsw i32 %355, 1
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %354, i64 %357
%359 = load double, double* %358
%360 = load double*, double** %7
%361 = load i32, i32* %11
%362 = sub nsw i32 %361, 1
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %360, i64 %363
%365 = load double, double* %364
%366 = load double*, double** %8
%367 = load i32, i32* %11
%368 = sub nsw i32 %367, 1
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %366, i64 %369
%371 = load double, double* %370
%372 = call double @f(double %365, double %371)
%373 = load double, double* %6
%374 = call double @llvm.fmuladd.f64(double %372, double %373, double %359)
%375 = load double*, double** %8
%376 = load i32, i32* %11
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %375, i64 %377
store double %374, double* %378
%379 = load double*, double** %7
%380 = load i32, i32* %11
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double, double* %379, i64 %381
%383 = load double, double* %382
%384 = call double @freal(double %383)
%385 = load double*, double** %9
%386 = load i32, i32* %11
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %385, i64 %387
store double %384, double* %388
%389 = load double*, double** %9
%390 = load i32, i32* %11
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %389, i64 %391
%393 = load double, double* %392
%394 = load double*, double** %8
%395 = load i32, i32* %11
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = fsub double %393, %398
%400 = call double @llvm.fabs.f64(double %399)
%401 = load double*, double** %10
%402 = load i32, i32* %11
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
store double %400, double* %404
br label %405
405: ; preds = %341
%406 = load i32, i32* %11
%407 = add nsw i32 %406, 1
store i32 %407, i32* %11
br label %336
408: ; preds = %336
%409 = load double, double* %6
%410 = load double*, double** %10
%411 = load i32, i32* %12
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds double, double* %410, i64 %412
%414 = load double, double* %413
%415 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double %409, double %414)
%416 = load double*, double** %7
%417 = call i32 @free(double* %416)
%418 = load double*, double** %8
%419 = call i32 @free(double* %418)
%420 = load double*, double** %9
%421 = call i32 @free(double* %420)
%422 = load double*, double** %10
%423 = call i32 @free(double* %422)
%424 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
%425 = load i32, i32* %1
ret i32 %425
}

LLVM IR (-O2):
@.str = [6 x i8] c"n:%d\0A\00"
@.str.1 = [34 x i8] c"Para x=1 y con h=%lf:\0A error:%lf\0A\00"
@.str.2 = [6 x i8] c"PAUSE\00"
define i32 @main() {
%1 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double 1.100000e+01)
%2 = tail call i64 @malloc(i32 96)
%3 = inttoptr i64 %2 to double*
%4 = tail call i64 @malloc(i32 96)
%5 = inttoptr i64 %4 to double*
%6 = tail call i64 @malloc(i32 96)
%7 = inttoptr i64 %6 to double*
%8 = tail call i64 @malloc(i32 96)
%9 = inttoptr i64 %8 to double*
store double 0.000000e+00, double* %3
store double 4.000000e+00, double* %5
%10 = load double, double* %3
%11 = tail call double @freal(double %10)
store double %11, double* %7
br label %12
12: ; preds = %0, %12
%13 = phi i64 [ 1, %0 ], [ %31, %12 ]
%14 = add nsw i64 %13, -1
%15 = getelementptr inbounds double, double* %3, i64 %14
%16 = load double, double* %15
%17 = fadd double %16, 1.000000e-01
%18 = getelementptr inbounds double, double* %3, i64 %13
store double %17, double* %18
%19 = getelementptr inbounds double, double* %5, i64 %14
%20 = load double, double* %19
%21 = tail call double @f(double %16, double %20)
%22 = tail call double @llvm.fmuladd.f64(double %21, double 1.000000e-01, double %20)
%23 = getelementptr inbounds double, double* %5, i64 %13
store double %22, double* %23
%24 = load double, double* %18
%25 = tail call double @freal(double %24)
%26 = getelementptr inbounds double, double* %7, i64 %13
store double %25, double* %26
%27 = load double, double* %23
%28 = fsub double %25, %27
%29 = tail call double @llvm.fabs.f64(double %28)
%30 = getelementptr inbounds double, double* %9, i64 %13
store double %29, double* %30
%31 = add nuw nsw i64 %13, 1
%32 = icmp eq i64 %31, 12
br i1 %32, label %33, label %12
33: ; preds = %12
%34 = getelementptr inbounds double, double* %9, i64 11
%35 = load double, double* %34
%36 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double 1.000000e-01, double %35)
%37 = tail call i32 @free(double* %3)
%38 = tail call i32 @free(double* %5)
%39 = tail call i32 @free(double* %7)
%40 = tail call i32 @free(double* %9)
%41 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double 1.010000e+02)
%42 = tail call i64 @malloc(i32 816)
%43 = inttoptr i64 %42 to double*
%44 = tail call i64 @malloc(i32 816)
%45 = inttoptr i64 %44 to double*
%46 = tail call i64 @malloc(i32 816)
%47 = inttoptr i64 %46 to double*
%48 = tail call i64 @malloc(i32 816)
%49 = inttoptr i64 %48 to double*
store double 0.000000e+00, double* %43
store double 4.000000e+00, double* %45
%50 = load double, double* %43
%51 = tail call double @freal(double %50)
store double %51, double* %47
br label %52
52: ; preds = %33, %52
%53 = phi i64 [ 1, %33 ], [ %71, %52 ]
%54 = add nsw i64 %53, -1
%55 = getelementptr inbounds double, double* %43, i64 %54
%56 = load double, double* %55
%57 = fadd double %56, 1.000000e-02
%58 = getelementptr inbounds double, double* %43, i64 %53
store double %57, double* %58
%59 = getelementptr inbounds double, double* %45, i64 %54
%60 = load double, double* %59
%61 = tail call double @f(double %56, double %60)
%62 = tail call double @llvm.fmuladd.f64(double %61, double 1.000000e-02, double %60)
%63 = getelementptr inbounds double, double* %45, i64 %53
store double %62, double* %63
%64 = load double, double* %58
%65 = tail call double @freal(double %64)
%66 = getelementptr inbounds double, double* %47, i64 %53
store double %65, double* %66
%67 = load double, double* %63
%68 = fsub double %65, %67
%69 = tail call double @llvm.fabs.f64(double %68)
%70 = getelementptr inbounds double, double* %49, i64 %53
store double %69, double* %70
%71 = add nuw nsw i64 %53, 1
%72 = icmp eq i64 %71, 102
br i1 %72, label %73, label %52
73: ; preds = %52
%74 = getelementptr inbounds double, double* %49, i64 101
%75 = load double, double* %74
%76 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double 1.000000e-02, double %75)
%77 = tail call i32 @free(double* %43)
%78 = tail call i32 @free(double* %45)
%79 = tail call i32 @free(double* %47)
%80 = tail call i32 @free(double* %49)
%81 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), double 1.001000e+03)
%82 = tail call i64 @malloc(i32 8016)
%83 = inttoptr i64 %82 to double*
%84 = tail call i64 @malloc(i32 8016)
%85 = inttoptr i64 %84 to double*
%86 = tail call i64 @malloc(i32 8016)
%87 = inttoptr i64 %86 to double*
%88 = tail call i64 @malloc(i32 8016)
%89 = inttoptr i64 %88 to double*
store double 0.000000e+00, double* %83
store double 4.000000e+00, double* %85
%90 = load double, double* %83
%91 = tail call double @freal(double %90)
store double %91, double* %87
br label %92
92: ; preds = %73, %92
%93 = phi i64 [ 1, %73 ], [ %111, %92 ]
%94 = add nsw i64 %93, -1
%95 = getelementptr inbounds double, double* %83, i64 %94
%96 = load double, double* %95
%97 = fadd double %96, 1.000000e-03
%98 = getelementptr inbounds double, double* %83, i64 %93
store double %97, double* %98
%99 = getelementptr inbounds double, double* %85, i64 %94
%100 = load double, double* %99
%101 = tail call double @f(double %96, double %100)
%102 = tail call double @llvm.fmuladd.f64(double %101, double 1.000000e-03, double %100)
%103 = getelementptr inbounds double, double* %85, i64 %93
store double %102, double* %103
%104 = load double, double* %98
%105 = tail call double @freal(double %104)
%106 = getelementptr inbounds double, double* %87, i64 %93
store double %105, double* %106
%107 = load double, double* %103
%108 = fsub double %105, %107
%109 = tail call double @llvm.fabs.f64(double %108)
%110 = getelementptr inbounds double, double* %89, i64 %93
store double %109, double* %110
%111 = add nuw nsw i64 %93, 1
%112 = icmp eq i64 %111, 1002
br i1 %112, label %113, label %92
113: ; preds = %92
%114 = getelementptr inbounds double, double* %89, i64 1001
%115 = load double, double* %114
%116 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), double 1.000000e-03, double %115)
%117 = tail call i32 @free(double* %83)
%118 = tail call i32 @free(double* %85)
%119 = tail call i32 @free(double* %87)
%120 = tail call i32 @free(double* %89)
%121 = tail call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
ret i32 0
}