#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 *, char *, ...);
void main() {
  double x, y, x_5, y_5, u_5, v_5;
  double u = 0.714251, v = 98765.9, w = 0.111111 * 1e-4;
  double suma_8, mult_8, resta_8, resta_mult_8;
  double suma_5, mult_5, resta_5, resta_mult_5;
  double error_suma, error_r_suma, error_mult, error_r_mult;
  double error_resta, error_r_resta, error_resta_mult, error_r_resta_mult;
  int x_int, y_int, v_int, u_in, suma_int, mult_int, resta_int, resta_mult_int;
  x = 0.714285714285714285;
  y = 0.333333333333333333;
  x_int = x * 1e5;
  y_int = y * 1e5;
  x_5 = x_int * 1e-5;
  y_5 = y_int * 1e-5;
  suma_int = (x + y) * 1e7;
  suma_8 = suma_int * 1e-7;
  suma_int = (x_5 + y_5) * 1e4;
  suma_5 = suma_int * 1e-4;
  error_suma = (suma_8 - suma_5);
  error_r_suma = error_suma / suma_8;
  mult_int = (x * y) * 1e8;
  mult_8 = mult_int * 1e-8;
  mult_int = (x_5 * y_5) * 1e5;
  mult_5 = mult_int * 1e-5;
  error_mult = (mult_8 - mult_5);
  error_r_mult = error_mult / mult_8;
  resta_int = (x - u) * 1e8;
  resta_8 = resta_int * 1e-8;
  u_in = u * 1e5;
  u_5 = u_in * 1e-5;
  resta_int = (x_5 - u_5) * 1e5;
  resta_5 = resta_int * 1e-5;
  error_resta = (resta_8 - resta_5);
  error_r_resta = error_resta / resta_8;
  resta_mult_int = ((x - u) * v) * 1e8;
  resta_mult_8 = resta_mult_int * 1e-8;
  v_int = v;
  v_5 = v_int * 1e-5;
  resta_mult_int = ((x_5 - u_5) * v_5) * 1e5;
  resta_mult_5 = resta_mult_int * 1e-5;
  error_resta_mult = (resta_mult_8 - resta_mult_5);
  error_r_resta_mult = error_resta_mult / resta_mult_8;
  char a_8[] = "Valor_a_8";
  char a_5[] = "Aritmética_de_máquina";
  char err[] = "Error_absoluto";
  char err_r[] = "Error_relativo";
  char sum[] = "x+y", mul[] = "x*y", res[] = "x-u", res_mul[] = "(x-u)*v",
       op[] = "Operación";
  printf("%s \t \t %s \t \t %s \t \t %s \t \t %s\n", op, a_8, a_5, err, err_r);
  printf("%s \t \t %0.8e \t \t %1.5e \t \t %0.8e \t \t \t %0.8e\n", sum, suma_8,
         suma_5, error_suma, error_r_suma);
  printf("%s \t \t %0.8e \t \t %1.5e \t \t %0.8e \t \t \t %0.8e\n", mul, mult_8,
         mult_5, error_mult, error_r_mult);
  printf("%s \t \t %0.8e \t \t %1.5e \t \t %0.8e \t \t \t %0.8e\n", res,
         resta_8, resta_5, error_resta, error_r_resta);
  printf("%s \t \t %0.8e \t \t %1.5e \t \t %0.8e \t \t \t %0.8e\n", res_mul,
         resta_mult_8, resta_mult_5, error_resta_mult, error_r_resta_mult);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
movsd  0xf3d(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xf28(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xf13(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xefe(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  0xee9(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0xea4(%rip),%xmm0
mulsd  -0x8(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xcc(%rbp)
movsd  0xe8d(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xd0(%rbp)
cvtsi2sdl -0xcc(%rbp),%xmm0
ff
movsd  0xe66(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
cvtsi2sdl -0xd0(%rbp),%xmm0
ff
movsd  0xe4d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x8(%rbp),%xmm0
addsd  -0x10(%rbp),%xmm0
movsd  0xe6a(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xdc(%rbp)
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  0xe44(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x18(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  0xe21(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xdc(%rbp)
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  0xdfb(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  0xdb1(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe0(%rbp)
cvtsi2sdl -0xe0(%rbp),%xmm0
ff
movsd  0xd8b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  0xd68(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe0(%rbp)
cvtsi2sdl -0xe0(%rbp),%xmm0
ff
movsd  0xd42(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  0xd18(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe4(%rbp)
cvtsi2sdl -0xe4(%rbp),%xmm0
ff
movsd  0xcf2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xcd9(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xd8(%rbp)
cvtsi2sdl -0xd8(%rbp),%xmm0
ff
movsd  0xcb2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  0xc9f(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe4(%rbp)
cvtsi2sdl -0xe4(%rbp),%xmm0
ff
movsd  0xc79(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xc4a(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe8(%rbp)
cvtsi2sdl -0xe8(%rbp),%xmm0
ff
movsd  0xc24(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
cvttsd2si -0x40(%rbp),%eax
mov    %eax,-0xd4(%rbp)
cvtsi2sdl -0xd4(%rbp),%xmm0
ff
movsd  0xbf0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  0xbd8(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe8(%rbp)
cvtsi2sdl -0xe8(%rbp),%xmm0
ff
movsd  0xbb2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0xbdd(%rip),%rax
mov    %rax,-0xf2(%rbp)
mov    0xbd7(%rip),%ax
mov    %ax,-0xea(%rbp)
mov    0xc59(%rip),%rax
mov    %rax,-0x110(%rbp)
mov    0xc53(%rip),%rax
mov    %rax,-0x108(%rbp)
mov    0xc4d(%rip),%rax
mov    %rax,-0x100(%rbp)
mov    0xba1(%rip),%rax
mov    %rax,-0x11f(%rbp)
mov    0xb9c(%rip),%eax
mov    %eax,-0x117(%rbp)
mov    0xb93(%rip),%ax
mov    %ax,-0x113(%rbp)
mov    0xb88(%rip),%al
mov    %al,-0x111(%rbp)
mov    0xb7c(%rip),%rax
mov    %rax,-0x12e(%rbp)
mov    0xb77(%rip),%eax
mov    %eax,-0x126(%rbp)
mov    0xb6e(%rip),%ax
mov    %ax,-0x122(%rbp)
mov    0xb63(%rip),%al
mov    %al,-0x120(%rbp)
mov    0xb58(%rip),%eax
mov    %eax,-0x132(%rbp)
mov    0xb50(%rip),%eax
mov    %eax,-0x136(%rbp)
mov    0xb48(%rip),%eax
mov    %eax,-0x13a(%rbp)
mov    0xb3f(%rip),%rax
mov    %rax,-0x142(%rbp)
mov    0xb39(%rip),%rax
mov    %rax,-0x14d(%rbp)
mov    0xb33(%rip),%ax
mov    %ax,-0x145(%rbp)
mov    0xb28(%rip),%al
mov    %al,-0x143(%rbp)
lea    -0x14d(%rbp),%rsi
lea    -0xf2(%rbp),%rdx
lea    -0x110(%rbp),%rcx
lea    -0x11f(%rbp),%r8
lea    -0x12e(%rbp),%r9
lea    0xaf9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x132(%rbp),%rsi
movsd  -0x50(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm3
ff
lea    0xaea(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    -0x136(%rbp),%rsi
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
lea    0xabb(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    -0x13a(%rbp),%rsi
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm3
ff
lea    0xa8c(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    -0x142(%rbp),%rsi
movsd  -0x68(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm3
ff
lea    0xa5a(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x80,%rsp
movabs $0x5f615f726f6c6156,%rax
5f 61 5f
mov    %rax,0x18(%rsp)
movw   $0x38,0x20(%rsp)
movaps 0xfcb(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movabs $0x616e697571a1c3,%rax
mov    %rax,0x70(%rsp)
movabs $0x6f74756c6f7362,%rax
mov    %rax,0x57(%rsp)
movabs $0x62615f726f727245,%rax
5f 61 62
mov    %rax,0x50(%rsp)
movabs $0x6f766974616c65,%rax
mov    %rax,0x47(%rsp)
movabs $0x65725f726f727245,%rax
5f 72 65
mov    %rax,0x40(%rsp)
movl   $0x792b78,0x14(%rsp)
movl   $0x792a78,0x10(%rsp)
movl   $0x752d78,0xc(%rsp)
movabs $0x762a29752d7828,%rax
mov    %rax,0x38(%rsp)
movabs $0xc36963617265704f,%rax
63 69 c3
mov    %rax,0x28(%rsp)
movl   $0x6eb3c3,0x2f(%rsp)
lea    0xee1(%rip),%rdi
lea    0x28(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x60(%rsp),%rcx
lea    0x50(%rsp),%r8
lea    0x40(%rsp),%r9
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xeda(%rip),%rbx
lea    0x14(%rsp),%rsi
movsd  0xe02(%rip),%xmm0
movsd  0xe02(%rip),%xmm1
movsd  0xe02(%rip),%xmm2
movsd  0xe02(%rip),%xmm3
mov    %rbx,%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0x10(%rsp),%rsi
movsd  0xdf3(%rip),%xmm0
movsd  0xdf3(%rip),%xmm1
movsd  0xdf3(%rip),%xmm2
movsd  0xdf3(%rip),%xmm3
mov    %rbx,%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xc(%rsp),%rsi
movsd  0xde4(%rip),%xmm0
movsd  0xde4(%rip),%xmm1
movsd  0xde4(%rip),%xmm2
movsd  0xde4(%rip),%xmm3
mov    %rbx,%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0x38(%rsp),%rsi
movsd  0xdd5(%rip),%xmm0
movsd  0xdd5(%rip),%xmm2
movsd  0xdd5(%rip),%xmm3
mov    %rbx,%rdi
movsd  0xda2(%rip),%xmm1
mov    $0x4,%al
call   1030 <printf@plt>
add    $0x80,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@__const.main.a_8 = [10 x i8] c"Valor_a_8\00"
@__const.main.a_5 = [24 x i8] c"Aritm\C3\A9tica_de_m\C3\A1quina\00"
@__const.main.err = [15 x i8] c"Error_absoluto\00"
@__const.main.err_r = [15 x i8] c"Error_relativo\00"
@__const.main.sum = [4 x i8] c"x+y\00"
@__const.main.mul = [4 x i8] c"x*y\00"
@__const.main.res = [4 x i8] c"x-u\00"
@__const.main.res_mul = [8 x i8] c"(x-u)*v\00"
@__const.main.op = [11 x i8] c"Operaci\C3\B3n\00"
@.str = [32 x i8] c"%s \09 \09 %s \09 \09 %s \09 \09 %s \09 \09 %s\0A\00"
@.str.1 = [46 x i8] c"%s \09 \09 %0.8e \09 \09 %1.5e \09 \09 %0.8e \09 \09 \09 %0.8e\0A\00"
define void @main() {
%1 = alloca double
%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 double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca [10 x i8]
%35 = alloca [24 x i8]
%36 = alloca [15 x i8]
%37 = alloca [15 x i8]
%38 = alloca [4 x i8]
%39 = alloca [4 x i8]
%40 = alloca [4 x i8]
%41 = alloca [8 x i8]
%42 = alloca [11 x i8]
store double 7.142510e-01, double* %7
store double 0x40F81CDE66666666, double* %8
store double 0x3EE74D39F4B75A47, double* %9
store double 0x3FE6DB6DB6DB6DB7, double* %1
store double 0x3FD5555555555555, double* %2
%43 = load double, double* %1
%44 = fmul double %43, 1.000000e+05
%45 = fptosi double %44 to i32
store i32 %45, i32* %26
%46 = load double, double* %2
%47 = fmul double %46, 1.000000e+05
%48 = fptosi double %47 to i32
store i32 %48, i32* %27
%49 = load i32, i32* %26
%50 = sitofp i32 %49 to double
%51 = fmul double %50, 1.000000e-05
store double %51, double* %3
%52 = load i32, i32* %27
%53 = sitofp i32 %52 to double
%54 = fmul double %53, 1.000000e-05
store double %54, double* %4
%55 = load double, double* %1
%56 = load double, double* %2
%57 = fadd double %55, %56
%58 = fmul double %57, 1.000000e+07
%59 = fptosi double %58 to i32
store i32 %59, i32* %30
%60 = load i32, i32* %30
%61 = sitofp i32 %60 to double
%62 = fmul double %61, 0x3E7AD7F29ABCAF48
store double %62, double* %10
%63 = load double, double* %3
%64 = load double, double* %4
%65 = fadd double %63, %64
%66 = fmul double %65, 1.000000e+04
%67 = fptosi double %66 to i32
store i32 %67, i32* %30
%68 = load i32, i32* %30
%69 = sitofp i32 %68 to double
%70 = fmul double %69, 1.000000e-04
store double %70, double* %14
%71 = load double, double* %10
%72 = load double, double* %14
%73 = fsub double %71, %72
store double %73, double* %18
%74 = load double, double* %18
%75 = load double, double* %10
%76 = fdiv double %74, %75
store double %76, double* %19
%77 = load double, double* %1
%78 = load double, double* %2
%79 = fmul double %77, %78
%80 = fmul double %79, 1.000000e+08
%81 = fptosi double %80 to i32
store i32 %81, i32* %31
%82 = load i32, i32* %31
%83 = sitofp i32 %82 to double
%84 = fmul double %83, 1.000000e-08
store double %84, double* %11
%85 = load double, double* %3
%86 = load double, double* %4
%87 = fmul double %85, %86
%88 = fmul double %87, 1.000000e+05
%89 = fptosi double %88 to i32
store i32 %89, i32* %31
%90 = load i32, i32* %31
%91 = sitofp i32 %90 to double
%92 = fmul double %91, 1.000000e-05
store double %92, double* %15
%93 = load double, double* %11
%94 = load double, double* %15
%95 = fsub double %93, %94
store double %95, double* %20
%96 = load double, double* %20
%97 = load double, double* %11
%98 = fdiv double %96, %97
store double %98, double* %21
%99 = load double, double* %1
%100 = load double, double* %7
%101 = fsub double %99, %100
%102 = fmul double %101, 1.000000e+08
%103 = fptosi double %102 to i32
store i32 %103, i32* %32
%104 = load i32, i32* %32
%105 = sitofp i32 %104 to double
%106 = fmul double %105, 1.000000e-08
store double %106, double* %12
%107 = load double, double* %7
%108 = fmul double %107, 1.000000e+05
%109 = fptosi double %108 to i32
store i32 %109, i32* %29
%110 = load i32, i32* %29
%111 = sitofp i32 %110 to double
%112 = fmul double %111, 1.000000e-05
store double %112, double* %5
%113 = load double, double* %3
%114 = load double, double* %5
%115 = fsub double %113, %114
%116 = fmul double %115, 1.000000e+05
%117 = fptosi double %116 to i32
store i32 %117, i32* %32
%118 = load i32, i32* %32
%119 = sitofp i32 %118 to double
%120 = fmul double %119, 1.000000e-05
store double %120, double* %16
%121 = load double, double* %12
%122 = load double, double* %16
%123 = fsub double %121, %122
store double %123, double* %22
%124 = load double, double* %22
%125 = load double, double* %12
%126 = fdiv double %124, %125
store double %126, double* %23
%127 = load double, double* %1
%128 = load double, double* %7
%129 = fsub double %127, %128
%130 = load double, double* %8
%131 = fmul double %129, %130
%132 = fmul double %131, 1.000000e+08
%133 = fptosi double %132 to i32
store i32 %133, i32* %33
%134 = load i32, i32* %33
%135 = sitofp i32 %134 to double
%136 = fmul double %135, 1.000000e-08
store double %136, double* %13
%137 = load double, double* %8
%138 = fptosi double %137 to i32
store i32 %138, i32* %28
%139 = load i32, i32* %28
%140 = sitofp i32 %139 to double
%141 = fmul double %140, 1.000000e-05
store double %141, double* %6
%142 = load double, double* %3
%143 = load double, double* %5
%144 = fsub double %142, %143
%145 = load double, double* %6
%146 = fmul double %144, %145
%147 = fmul double %146, 1.000000e+05
%148 = fptosi double %147 to i32
store i32 %148, i32* %33
%149 = load i32, i32* %33
%150 = sitofp i32 %149 to double
%151 = fmul double %150, 1.000000e-05
store double %151, double* %17
%152 = load double, double* %13
%153 = load double, double* %17
%154 = fsub double %152, %153
store double %154, double* %24
%155 = load double, double* %24
%156 = load double, double* %13
%157 = fdiv double %155, %156
store double %157, double* %25
%158 = bitcast [10 x i8]* %34 to i8*
%159 = bitcast [24 x i8]* %35 to i8*
%160 = bitcast [15 x i8]* %36 to i8*
%161 = bitcast [15 x i8]* %37 to i8*
%162 = bitcast [4 x i8]* %38 to i8*
%163 = bitcast [4 x i8]* %39 to i8*
%164 = bitcast [4 x i8]* %40 to i8*
%165 = bitcast [8 x i8]* %41 to i8*
%166 = bitcast [11 x i8]* %42 to i8*
%167 = getelementptr inbounds [11 x i8], [11 x i8]* %42, i64 0, i64 0
%168 = getelementptr inbounds [10 x i8], [10 x i8]* %34, i64 0, i64 0
%169 = getelementptr inbounds [24 x i8], [24 x i8]* %35, i64 0, i64 0
%170 = getelementptr inbounds [15 x i8], [15 x i8]* %36, i64 0, i64 0
%171 = getelementptr inbounds [15 x i8], [15 x i8]* %37, i64 0, i64 0
%172 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* %167, i8* %168, i8* %169, i8* %170, i8* %171)
%173 = getelementptr inbounds [4 x i8], [4 x i8]* %38, i64 0, i64 0
%174 = load double, double* %10
%175 = load double, double* %14
%176 = load double, double* %18
%177 = load double, double* %19
%178 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %173, double %174, double %175, double %176, double %177)
%179 = getelementptr inbounds [4 x i8], [4 x i8]* %39, i64 0, i64 0
%180 = load double, double* %11
%181 = load double, double* %15
%182 = load double, double* %20
%183 = load double, double* %21
%184 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %179, double %180, double %181, double %182, double %183)
%185 = getelementptr inbounds [4 x i8], [4 x i8]* %40, i64 0, i64 0
%186 = load double, double* %12
%187 = load double, double* %16
%188 = load double, double* %22
%189 = load double, double* %23
%190 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %185, double %186, double %187, double %188, double %189)
%191 = getelementptr inbounds [8 x i8], [8 x i8]* %41, i64 0, i64 0
%192 = load double, double* %13
%193 = load double, double* %17
%194 = load double, double* %24
%195 = load double, double* %25
%196 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %191, double %192, double %193, double %194, double %195)
ret void
}

LLVM IR (-O2):
@__const.main.a_8 = [10 x i8] c"Valor_a_8\00"
@__const.main.a_5 = [24 x i8] c"Aritm\C3\A9tica_de_m\C3\A1quina\00"
@__const.main.err = [15 x i8] c"Error_absoluto\00"
@__const.main.err_r = [15 x i8] c"Error_relativo\00"
@__const.main.op = [11 x i8] c"Operaci\C3\B3n\00"
@.str = [32 x i8] c"%s \09 \09 %s \09 \09 %s \09 \09 %s \09 \09 %s\0A\00"
@.str.1 = [46 x i8] c"%s \09 \09 %0.8e \09 \09 %1.5e \09 \09 %0.8e \09 \09 \09 %0.8e\0A\00"
define void @main() {
%1 = alloca [10 x i8]
%2 = alloca [24 x i8]
%3 = alloca [15 x i8]
%4 = alloca [15 x i8]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i64
%9 = alloca [11 x i8]
%10 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 0
%11 = getelementptr inbounds [24 x i8], [24 x i8]* %2, i64 0, i64 0
%12 = getelementptr inbounds [15 x i8], [15 x i8]* %3, i64 0, i64 0
%13 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 0
%14 = bitcast i32* %5 to i8*
store i32 7940984, i32* %5
%15 = bitcast i32* %6 to i8*
store i32 7940728, i32* %6
%16 = bitcast i32* %7 to i8*
store i32 7679352, i32* %7
%17 = bitcast i64* %8 to i8*
store i64 33260404799797288, i64* %8
%18 = getelementptr inbounds [11 x i8], [11 x i8]* %9, i64 0, i64 0
%19 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* %18, i8* %10, i8* %11, i8* %12, i8* %13)
%20 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %14, double 0x3FF0C30C23FAB10B, double 1.047600e+00, double 0x3EF3EC460ED70000, double 0x3EF3047179C244F0)
%21 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %15, double 0x3FCE79E78D178025, double 0x3FCE79BBADC0980C, double 0x3ED5EFAB740C8000, double 0x3EF7087413CA3623)
%22 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %16, double 3.471000e-05, double 2.000000e-05, double 0x3EEED95F016D3D6E, double 0x3FDB1F7E316A4789)
%23 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8* %17, double 0x400B6DBF5F50F363, double 2.000000e-05, double 0x400B6DB4E2F62EF1, double 0x3FEFFFF3C44491BA)
ret void
}