#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 pow(int, int);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  double A[100][100];
  double B[100];
  double x[100];
  double k;
  int i, j, l;
  for (i = 0; i < 100; i++) {
    A[i][i + 1] = 2;
    A[i][i] = 4;
    A[i + 1][i] = 1;
    for (j = 0; j < 100; j++) {
      if ((A[i][j] != 2) && (A[i][j] != 4) && (A[i][j] != 1)) {
        A[i][j] = 0;
      }
    }
  }
  for (l = 0; l < 100; l++) {
    B[l] = pow((l + 1), 2) / 10.;
  }
  for (i = 1; i < 100; i++) {
    k = -A[i][i - 1] / A[i - 1][i - 1];
    A[i][i] = A[i][i] + k * A[i - 1][i];
    B[i] = B[i] + k * B[i - 1];
  }
  printf("Los resultados son:\n");
  x[100 - 1] = B[100 - 1] / A[100 - 1][100 - 1];
  for (i = 100 - 2; i >= 0; i--) {
    x[i] = (B[i] - A[i][i + 1] * x[i + 1]) / A[i][i];
  }
  for (i = 0; i < 100; i++)
    printf("x[%d] = %.0f\t", i, x[i]);
  getchar();
  getchar();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x13ef0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x13edc(%rbp)
cmpl   $0x64,-0x13edc(%rbp)
jge    131a <main+0x1ea>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
mov    -0x13edc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xe93(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
movsd  0xe5f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13edc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
movsd  0xe26(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x13ee0(%rbp)
cmpl   $0x64,-0x13ee0(%rbp)
jge    1301 <main+0x1d1>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13ee0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xdee(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    123f <main+0x10f>
jp     123f <main+0x10f>
jmp    12e8 <main+0x1b8>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13ee0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xda5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1280 <main+0x150>
jp     1280 <main+0x150>
jmp    12e8 <main+0x1b8>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13ee0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd5c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12c1 <main+0x191>
jp     12c1 <main+0x191>
jmp    12e8 <main+0x1b8>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13ee0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12ed <main+0x1bd>
mov    -0x13ee0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13ee0(%rbp)
jmp    11f1 <main+0xc1>
jmp    1306 <main+0x1d6>
mov    -0x13edc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13edc(%rbp)
jmp    114c <main+0x1c>
movl   $0x0,-0x13ee4(%rbp)
cmpl   $0x64,-0x13ee4(%rbp)
jge    1378 <main+0x248>
mov    -0x13ee4(%rbp),%edi
add    $0x1,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  0xcb0(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x13ee4(%rbp),%rax
movsd  %xmm0,-0x13bb0(%rbp,%rax,8)
fe ff
mov    -0x13ee4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13ee4(%rbp)
jmp    1324 <main+0x1f4>
movl   $0x1,-0x13edc(%rbp)
cmpl   $0x64,-0x13edc(%rbp)
jge    14de <main+0x3ae>
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
mov    -0x13edc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x13edc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
mov    -0x13edc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x13ed8(%rbp)
ff
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x13ed8(%rbp),%xmm0
ff
mov    -0x13edc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x13edc(%rbp),%rax
movsd  -0x13bb0(%rbp,%rax,8),%xmm1
fe ff
movsd  -0x13ed8(%rbp),%xmm0
ff
mov    -0x13edc(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x13bb0(%rbp,%rax,8),%xmm2
fe ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x13edc(%rbp),%rax
movsd  %xmm0,-0x13bb0(%rbp,%rax,8)
fe ff
mov    -0x13edc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13edc(%rbp)
jmp    1382 <main+0x252>
lea    0xb3b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x13898(%rbp),%xmm0
ff
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x13bb8(%rbp)
movl   $0x62,-0x13edc(%rbp)
cmpl   $0x0,-0x13edc(%rbp)
jl     15cc <main+0x49c>
movslq -0x13edc(%rbp),%rax
movsd  -0x13bb0(%rbp,%rax,8),%xmm1
fe ff
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
mov    -0x13edc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x13edc(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x13ed0(%rbp,%rax,8),%xmm2
fe ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x13edc(%rbp),%rcx
lea    -0x13890(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x13edc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movslq -0x13edc(%rbp),%rax
movsd  %xmm0,-0x13ed0(%rbp,%rax,8)
fe ff
mov    -0x13edc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x13edc(%rbp)
jmp    150b <main+0x3db>
movl   $0x0,-0x13edc(%rbp)
cmpl   $0x64,-0x13edc(%rbp)
jge    161b <main+0x4eb>
mov    -0x13edc(%rbp),%esi
movslq -0x13edc(%rbp),%rax
movsd  -0x13ed0(%rbp,%rax,8),%xmm0
fe ff
lea    0xa35(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x13edc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13edc(%rbp)
jmp    15d6 <main+0x4a6>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    $0x0,%al
call   1040 <getchar@plt>
xor    %eax,%eax
add    $0x13ef0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0x13ec8,%rsp
lea    0x640(%rsp),%rax
xor    %edx,%edx
movapd 0xea5(%rip),%xmm0
movabs $0x3ff0000000000000,%rcx
movapd 0xea3(%rip),%xmm1
movapd 0xeab(%rip),%xmm2
movapd 0xeb3(%rip),%xmm3
nopl   (%rax)
imul   $0x320,%rdx,%rsi
add    %rsp,%rsi
add    $0x640,%rsi
movupd %xmm0,(%rsi,%rdx,8)
mov    %rcx,0x320(%rsi,%rdx,8)
add    $0x1,%rdx
mov    $0x2,%esi
nopw   0x0(%rax,%rax,1)
movapd -0x10(%rax,%rsi,8),%xmm4
movapd (%rax,%rsi,8),%xmm5
movapd %xmm4,%xmm6
cmpneqpd %xmm1,%xmm6
movapd %xmm4,%xmm7
cmpneqpd %xmm2,%xmm7
andpd  %xmm6,%xmm7
movapd %xmm4,%xmm6
cmpneqpd %xmm3,%xmm6
andpd  %xmm7,%xmm6
andnpd %xmm4,%xmm6
movapd %xmm6,-0x10(%rax,%rsi,8)
movapd %xmm5,%xmm4
cmpneqpd %xmm1,%xmm4
movapd %xmm5,%xmm6
cmpneqpd %xmm2,%xmm6
andpd  %xmm4,%xmm6
movapd %xmm5,%xmm4
cmpneqpd %xmm3,%xmm4
andpd  %xmm6,%xmm4
andnpd %xmm5,%xmm4
movapd %xmm4,(%rax,%rsi,8)
add    $0x4,%rsi
cmp    $0x66,%rsi
jne    11b0 <main+0x70>
add    $0x320,%rax
cmp    $0x64,%rdx
jne    1180 <main+0x40>
mov    $0x1,%ebx
mov    $0x2,%ebp
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xdf5(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rsp,%rbx,8)
mov    %ebp,%edi
mov    $0x2,%esi
call   1060 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  0xdd0(%rip),%xmm0
movsd  %xmm0,(%rsp,%rbx,8)
add    $0x2,%rbx
add    $0x2,%ebp
cmp    $0x65,%rbx
jne    1240 <main+0x100>
movsd  0x640(%rsp),%xmm2
movsd  (%rsp),%xmm0
lea    0x968(%rsp),%rax
xor    %ecx,%ecx
movapd 0xd8e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rax),%xmm3
xorpd  %xmm1,%xmm3
divsd  %xmm2,%xmm3
mulsd  %xmm3,%xmm0
mulsd  -0x320(%rax),%xmm3
ff
addsd  (%rax),%xmm3
movsd  %xmm3,(%rax)
addsd  0x8(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rsp,%rcx,8)
add    $0x1,%rcx
add    $0x328,%rax
movapd %xmm3,%xmm2
cmp    $0x63,%rcx
jne    12c0 <main+0x180>
lea    0xd5e(%rip),%rdi
call   1030 <puts@plt>
movsd  0x318(%rsp),%xmm0
divsd  0x13eb8(%rsp),%xmm0
movsd  %xmm0,0x638(%rsp)
lea    0x13b98(%rsp),%rax
mov    $0x62,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  (%rax),%xmm0
movsd  (%rsp,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
divsd  -0x8(%rax),%xmm1
movsd  %xmm1,0x320(%rsp,%rcx,8)
add    $0xfffffffffffffcd8,%rax
movapd %xmm1,%xmm0
add    $0xffffffffffffffff,%rcx
jb     1340 <main+0x200>
xor    %ebx,%ebx
lea    0xce4(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x320(%rsp,%rbx,8),%xmm0
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x64,%rbx
jne    1380 <main+0x240>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
add    $0x13ec8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@.str = [21 x i8] c"Los resultados son:\0A\00"
@.str.1 = [14 x i8] c"x[%d] = %.0f\09\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x [100 x double]]
%3 = alloca [100 x double]
%4 = alloca [100 x double]
%5 = alloca double
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %6
br label %9
9: ; preds = %75, %0
%10 = load i32, i32* %6
%11 = icmp slt i32 %10, 100
br i1 %11, label %12, label %78
12: ; preds = %9
%13 = load i32, i32* %6
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %14
%16 = load i32, i32* %6
%17 = add nsw i32 %16, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [100 x double], [100 x double]* %15, i64 0, i64 %18
store double 2.000000e+00, double* %19
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %21
%23 = load i32, i32* %6
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [100 x double], [100 x double]* %22, i64 0, i64 %24
store double 4.000000e+00, double* %25
%26 = load i32, i32* %6
%27 = add nsw i32 %26, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %28
%30 = load i32, i32* %6
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [100 x double], [100 x double]* %29, i64 0, i64 %31
store double 1.000000e+00, double* %32
store i32 0, i32* %7
br label %33
33: ; preds = %71, %12
%34 = load i32, i32* %7
%35 = icmp slt i32 %34, 100
br i1 %35, label %36, label %74
36: ; preds = %33
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %38
%40 = load i32, i32* %7
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [100 x double], [100 x double]* %39, i64 0, i64 %41
%43 = load double, double* %42
%44 = fcmp une double %43, 2.000000e+00
br i1 %44, label %45, label %70
45: ; preds = %36
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %47
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [100 x double], [100 x double]* %48, i64 0, i64 %50
%52 = load double, double* %51
%53 = fcmp une double %52, 4.000000e+00
br i1 %53, label %54, label %70
54: ; preds = %45
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %56
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [100 x double], [100 x double]* %57, i64 0, i64 %59
%61 = load double, double* %60
%62 = fcmp une double %61, 1.000000e+00
br i1 %62, label %63, label %70
63: ; preds = %54
%64 = load i32, i32* %6
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %65
%67 = load i32, i32* %7
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [100 x double], [100 x double]* %66, i64 0, i64 %68
store double 0.000000e+00, double* %69
br label %70
70: ; preds = %63, %54, %45, %36
br label %71
71: ; preds = %70
%72 = load i32, i32* %7
%73 = add nsw i32 %72, 1
store i32 %73, i32* %7
br label %33
74: ; preds = %33
br label %75
75: ; preds = %74
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
store i32 %77, i32* %6
br label %9
78: ; preds = %9
store i32 0, i32* %8
br label %79
79: ; preds = %91, %78
%80 = load i32, i32* %8
%81 = icmp slt i32 %80, 100
br i1 %81, label %82, label %94
82: ; preds = %79
%83 = load i32, i32* %8
%84 = add nsw i32 %83, 1
%85 = call i32 @pow(i32 %84, i32 2)
%86 = sitofp i32 %85 to double
%87 = fdiv double %86, 1.000000e+01
%88 = load i32, i32* %8
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %89
store double %87, double* %90
br label %91
91: ; preds = %82
%92 = load i32, i32* %8
%93 = add nsw i32 %92, 1
store i32 %93, i32* %8
br label %79
94: ; preds = %79
store i32 1, i32* %6
br label %95
95: ; preds = %155, %94
%96 = load i32, i32* %6
%97 = icmp slt i32 %96, 100
br i1 %97, label %98, label %158
98: ; preds = %95
%99 = load i32, i32* %6
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %100
%102 = load i32, i32* %6
%103 = sub nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [100 x double], [100 x double]* %101, i64 0, i64 %104
%106 = load double, double* %105
%107 = fneg double %106
%108 = load i32, i32* %6
%109 = sub nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %110
%112 = load i32, i32* %6
%113 = sub nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [100 x double], [100 x double]* %111, i64 0, i64 %114
%116 = load double, double* %115
%117 = fdiv double %107, %116
store double %117, double* %5
%118 = load i32, i32* %6
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %119
%121 = load i32, i32* %6
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [100 x double], [100 x double]* %120, i64 0, i64 %122
%124 = load double, double* %123
%125 = load double, double* %5
%126 = load i32, i32* %6
%127 = sub nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %128
%130 = load i32, i32* %6
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [100 x double], [100 x double]* %129, i64 0, i64 %131
%133 = load double, double* %132
%134 = call double @llvm.fmuladd.f64(double %125, double %133, double %124)
%135 = load i32, i32* %6
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %136
%138 = load i32, i32* %6
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [100 x double], [100 x double]* %137, i64 0, i64 %139
store double %134, double* %140
%141 = load i32, i32* %6
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %142
%144 = load double, double* %143
%145 = load double, double* %5
%146 = load i32, i32* %6
%147 = sub nsw i32 %146, 1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %148
%150 = load double, double* %149
%151 = call double @llvm.fmuladd.f64(double %145, double %150, double %144)
%152 = load i32, i32* %6
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %153
store double %151, double* %154
br label %155
155: ; preds = %98
%156 = load i32, i32* %6
%157 = add nsw i32 %156, 1
store i32 %157, i32* %6
br label %95
158: ; preds = %95
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
%160 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 99
%161 = load double, double* %160
%162 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 99
%163 = getelementptr inbounds [100 x double], [100 x double]* %162, i64 0, i64 99
%164 = load double, double* %163
%165 = fdiv double %161, %164
%166 = getelementptr inbounds [100 x double], [100 x double]* %4, i64 0, i64 99
store double %165, double* %166
store i32 98, i32* %6
br label %167
167: ; preds = %201, %158
%168 = load i32, i32* %6
%169 = icmp sge i32 %168, 0
br i1 %169, label %170, label %204
170: ; preds = %167
%171 = load i32, i32* %6
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %172
%174 = load double, double* %173
%175 = load i32, i32* %6
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %176
%178 = load i32, i32* %6
%179 = add nsw i32 %178, 1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [100 x double], [100 x double]* %177, i64 0, i64 %180
%182 = load double, double* %181
%183 = load i32, i32* %6
%184 = add nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [100 x double], [100 x double]* %4, i64 0, i64 %185
%187 = load double, double* %186
%188 = fneg double %182
%189 = call double @llvm.fmuladd.f64(double %188, double %187, double %174)
%190 = load i32, i32* %6
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %2, i64 0, i64 %191
%193 = load i32, i32* %6
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [100 x double], [100 x double]* %192, i64 0, i64 %194
%196 = load double, double* %195
%197 = fdiv double %189, %196
%198 = load i32, i32* %6
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [100 x double], [100 x double]* %4, i64 0, i64 %199
store double %197, double* %200
br label %201
201: ; preds = %170
%202 = load i32, i32* %6
%203 = add nsw i32 %202, -1
store i32 %203, i32* %6
br label %167
204: ; preds = %167
store i32 0, i32* %6
br label %205
205: ; preds = %215, %204
%206 = load i32, i32* %6
%207 = icmp slt i32 %206, 100
br i1 %207, label %208, label %218
208: ; preds = %205
%209 = load i32, i32* %6
%210 = load i32, i32* %6
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [100 x double], [100 x double]* %4, i64 0, i64 %211
%213 = load double, double* %212
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i32 %209, double %213)
br label %215
215: ; preds = %208
%216 = load i32, i32* %6
%217 = add nsw i32 %216, 1
store i32 %217, i32* %6
br label %205
218: ; preds = %205
%219 = call i32 (...) @getchar()
%220 = call i32 (...) @getchar()
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [14 x i8] c"x[%d] = %.0f\09\00"
@str = [20 x i8] c"Los resultados son:\00"
define i32 @main() {
%1 = alloca [100 x [100 x double]]
%2 = alloca [100 x double]
%3 = alloca [100 x double]
%4 = bitcast [100 x [100 x double]]* %1 to i8*
%5 = bitcast [100 x double]* %2 to i8*
%6 = bitcast [100 x double]* %3 to i8*
br label %7
7: ; preds = %0, %38
%8 = phi i64 [ 0, %0 ], [ %9, %38 ]
%9 = add nuw nsw i64 %8, 1
%10 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %8, i64 %8
%11 = bitcast double* %10 to <2 x double>*
store <2 x double> <double 4.000000e+00, double 2.000000e+00>, <2 x double>* %11
%12 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %9, i64 %8
store double 1.000000e+00, double* %12
br label %13
13: ; preds = %13, %7
%14 = phi i64 [ 0, %7 ], [ %36, %13 ]
%15 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %8, i64 %14
%16 = bitcast double* %15 to <2 x double>*
%17 = load <2 x double>, <2 x double>* %16
%18 = fcmp une <2 x double> %17, <double 2.000000e+00, double 2.000000e+00>
%19 = fcmp une <2 x double> %17, <double 4.000000e+00, double 4.000000e+00>
%20 = and <2 x i1> %18, %19
%21 = fcmp une <2 x double> %17, <double 1.000000e+00, double 1.000000e+00>
%22 = and <2 x i1> %21, %20
%23 = select <2 x i1> %22, <2 x double> zeroinitializer, <2 x double> %17
%24 = bitcast double* %15 to <2 x double>*
store <2 x double> %23, <2 x double>* %24
%25 = or i64 %14, 2
%26 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %8, i64 %25
%27 = bitcast double* %26 to <2 x double>*
%28 = load <2 x double>, <2 x double>* %27
%29 = fcmp une <2 x double> %28, <double 2.000000e+00, double 2.000000e+00>
%30 = fcmp une <2 x double> %28, <double 4.000000e+00, double 4.000000e+00>
%31 = and <2 x i1> %29, %30
%32 = fcmp une <2 x double> %28, <double 1.000000e+00, double 1.000000e+00>
%33 = and <2 x i1> %32, %31
%34 = select <2 x i1> %33, <2 x double> zeroinitializer, <2 x double> %28
%35 = bitcast double* %26 to <2 x double>*
store <2 x double> %34, <2 x double>* %35
%36 = add nuw nsw i64 %14, 4
%37 = icmp eq i64 %36, 100
br i1 %37, label %38, label %13
38: ; preds = %13
%39 = icmp eq i64 %9, 100
br i1 %39, label %40, label %7
40: ; preds = %38, %40
%41 = phi i64 [ %48, %40 ], [ 0, %38 ]
%42 = or i64 %41, 1
%43 = trunc i64 %42 to i32
%44 = tail call i32 @pow(i32 %43, i32 2)
%45 = sitofp i32 %44 to double
%46 = fdiv double %45, 1.000000e+01
%47 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 %41
store double %46, double* %47
%48 = add nuw nsw i64 %41, 2
%49 = trunc i64 %48 to i32
%50 = tail call i32 @pow(i32 %49, i32 2)
%51 = sitofp i32 %50 to double
%52 = fdiv double %51, 1.000000e+01
%53 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 %42
store double %52, double* %53
%54 = icmp eq i64 %48, 100
br i1 %54, label %55, label %40
55: ; preds = %40
%56 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 0, i64 0
%57 = load double, double* %56
%58 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 0
%59 = load double, double* %58
br label %60
60: ; preds = %55, %60
%61 = phi double [ %59, %55 ], [ %76, %60 ]
%62 = phi double [ %57, %55 ], [ %73, %60 ]
%63 = phi i64 [ 1, %55 ], [ %77, %60 ]
%64 = add nsw i64 %63, -1
%65 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %63, i64 %64
%66 = load double, double* %65
%67 = fneg double %66
%68 = fdiv double %67, %62
%69 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %63, i64 %63
%70 = load double, double* %69
%71 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %64, i64 %63
%72 = load double, double* %71
%73 = tail call double @llvm.fmuladd.f64(double %68, double %72, double %70)
store double %73, double* %69
%74 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 %63
%75 = load double, double* %74
%76 = tail call double @llvm.fmuladd.f64(double %68, double %61, double %75)
store double %76, double* %74
%77 = add nuw nsw i64 %63, 1
%78 = icmp eq i64 %77, 100
br i1 %78, label %79, label %60
79: ; preds = %60
%80 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str, i64 0, i64 0))
%81 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 99
%82 = load double, double* %81
%83 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 99, i64 99
%84 = load double, double* %83
%85 = fdiv double %82, %84
%86 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 99
store double %85, double* %86
br label %87
87: ; preds = %79, %87
%88 = phi double [ %85, %79 ], [ %99, %87 ]
%89 = phi i64 [ 98, %79 ], [ %101, %87 ]
%90 = getelementptr inbounds [100 x double], [100 x double]* %2, i64 0, i64 %89
%91 = load double, double* %90
%92 = add nuw nsw i64 %89, 1
%93 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %89, i64 %92
%94 = load double, double* %93
%95 = fneg double %94
%96 = tail call double @llvm.fmuladd.f64(double %95, double %88, double %91)
%97 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %1, i64 0, i64 %89, i64 %89
%98 = load double, double* %97
%99 = fdiv double %96, %98
%100 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %89
store double %99, double* %100
%101 = add nsw i64 %89, -1
%102 = icmp eq i64 %89, 0
br i1 %102, label %103, label %87
103: ; preds = %87, %103
%104 = phi i64 [ %109, %103 ], [ 0, %87 ]
%105 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %104
%106 = load double, double* %105
%107 = trunc i64 %104 to i32
%108 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i32 %107, double %106)
%109 = add nuw nsw i64 %104, 1
%110 = icmp eq i64 %109, 100
br i1 %110, label %111, label %103
111: ; preds = %103
%112 = tail call i32 (...) @getchar()
%113 = tail call i32 (...) @getchar()
ret i32 0
}