#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 CLOCKS_PER_SEC;
unsigned int atoi(char *);
int clock();
int /*<<< orphan*/ exit(int);
scalar_t__ malloc(unsigned int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, unsigned int *);
scalar_t__ sqrt(unsigned int);
void main(int argc, char *argv[]) {
  unsigned int xNumIngU, xNumIngK;
  unsigned int nRaiz, mDiv;
  unsigned int cNumJ, cNumN;
  unsigned int *tabla;
  unsigned long long aRes;
  if (argc == 1) {
    printf("Ingrese u: ");
    scanf("%d", &xNumIngU);
    printf("Ingrese k: ");
    scanf("%d", &xNumIngK);
  } else {
    xNumIngU = atoi(argv[1]);
    xNumIngK = atoi(argv[2]);
  }
  int nTiempo = clock();
  tabla = (unsigned int *)malloc(xNumIngU * sizeof(unsigned int));
  if (tabla == NULL) {
    printf("\nError en la asignacion de memoria.\n");
    exit(1);
  }
  for (cNumN = 1; xNumIngU >= cNumN; ++cNumN) {
    tabla[cNumN] = 0;
    nRaiz = (unsigned int)sqrt(cNumN);
    for (cNumJ = 1; nRaiz >= cNumJ; ++cNumJ) {
      if (cNumN % cNumJ == 0) {
        tabla[cNumN] += 2;
      }
    }
    if (nRaiz * nRaiz == cNumN) {
      --tabla[cNumN];
    }
  }
  printf("\nTabla de divisores creada.\n");
  mDiv = xNumIngU;
  tabla[0] = xNumIngU;
  aRes = 0;
  xNumIngU = xNumIngU - xNumIngK + 1;
  for (cNumN = 1; xNumIngU >= cNumN; ++cNumN) {
    if (tabla[xNumIngK] >= mDiv) {
      mDiv = tabla[xNumIngK];
    } else if (tabla[cNumN - 1] == mDiv) {
      mDiv = 0;
      for (cNumJ = cNumN; xNumIngK >= cNumJ; ++cNumJ) {
        if (tabla[cNumJ] > mDiv) {
          mDiv = tabla[cNumJ];
        }
      }
    }
    ++xNumIngK;
    aRes += mDiv;
  }
  nTiempo = clock() - nTiempo;
  printf("\nEl resultado es: %lld\n", aRes);
  printf("Tiempo de ejecucion: %.3f\n", (double)nTiempo / CLOCKS_PER_SEC);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    11ca <main+0x5a>
lea    0xe70(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe6e(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1060 <scanf@plt>
lea    0xe61(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe50(%rip),%rdi
lea    -0x18(%rbp),%rsi
call   1060 <scanf@plt>
jmp    11ea <main+0x7a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x18(%rbp)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1229 <main+0xb9>
lea    0xe03(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jb     12cf <main+0x15f>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%edi
call   1080 <sqrt@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jb     129c <main+0x12c>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
cmp    $0x0,%edx
jne    1289 <main+0x119>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x2,%edx
mov    %edx,(%rax,%rcx,4)
jmp    128e <main+0x11e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    125c <main+0xec>
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    12bc <main+0x14c>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    12c1 <main+0x151>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1230 <main+0xc0>
lea    0xd6a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jb     13c8 <main+0x258>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
jb     1338 <main+0x1c8>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
jmp    13a6 <main+0x236>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
jne    13a1 <main+0x231>
movl   $0x0,-0x20(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jb     139c <main+0x22c>
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
jbe    1389 <main+0x219>
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
jmp    138e <main+0x21e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    135d <main+0x1ed>
jmp    13a1 <main+0x231>
jmp    13a6 <main+0x236>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1307 <main+0x197>
mov    $0x0,%al
call   1030 <clock@plt>
sub    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rsi
lea    0xc7d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cvtsi2sdl -0x3c(%rbp),%xmm0
mov    0x2bf5(%rip),%rax
divsd  (%rax),%xmm0
lea    0xc77(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
cmp    $0x1,%edi
jne    11d2 <main+0x52>
lea    0xe76(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe74(%rip),%rbx
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
call   1070 <scanf@plt>
lea    0xe63(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc(%rsp),%rsi
mov    %rbx,%rdi
call   1070 <scanf@plt>
jmp    11ef <main+0x6f>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1080 <atoi@plt>
mov    %eax,0x8(%rsp)
mov    0x10(%rbx),%rdi
call   1080 <atoi@plt>
mov    %eax,0xc(%rsp)
xor    %eax,%eax
call   1040 <clock@plt>
mov    %eax,%r14d
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1617 <main+0x497>
mov    %rax,%r12
cmpl   $0x0,0x8(%rsp)
je     12d5 <main+0x155>
mov    $0x1,%edi
jmp    123f <main+0xbf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebp
mov    %ebp,%edi
cmp    %ebp,0x8(%rsp)
jb     12d5 <main+0x155>
mov    %edi,%ebp
movl   $0x0,(%r12,%rbp,4)
call   1090 <sqrt@plt>
mov    %rax,%rcx
test   %ecx,%ecx
je     1280 <main+0x100>
mov    $0x1,%ebx
cmp    $0x1,%ecx
jne    1290 <main+0x110>
test   $0x1,%cl
je     1280 <main+0x100>
mov    %ebp,%eax
xor    %edx,%edx
div    %ebx
test   %edx,%edx
jne    1280 <main+0x100>
addl   $0x2,(%r12,%rbp,4)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   %ecx,%ecx
cmp    %ebp,%ecx
jne    1230 <main+0xb0>
addl   $0xffffffff,(%r12,%rbp,4)
jmp    1230 <main+0xb0>
xchg   %ax,%ax
mov    %ecx,%esi
and    $0xfffffffe,%esi
neg    %esi
mov    $0x1,%edi
jmp    12b2 <main+0x132>
xchg   %ax,%ax
mov    %edi,%ebx
add    $0x2,%ebx
lea    (%rsi,%rdi,1),%eax
add    $0x2,%eax
mov    %ebx,%edi
cmp    $0x1,%eax
je     125f <main+0xdf>
mov    %ebp,%eax
xor    %edx,%edx
div    %edi
test   %edx,%edx
jne    12c1 <main+0x141>
addl   $0x2,(%r12,%rbp,4)
lea    0x1(%rdi),%ebx
mov    %ebp,%eax
xor    %edx,%edx
div    %ebx
test   %edx,%edx
jne    12a0 <main+0x120>
addl   $0x2,(%r12,%rbp,4)
jmp    12a0 <main+0x120>
lea    0xd82(%rip),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%ebp
mov    %ebp,(%r12)
mov    0x8(%rsp),%ecx
mov    0xc(%rsp),%eax
sub    %eax,%ecx
xor    %r10d,%r10d
inc    %ecx
mov    %ecx,0x8(%rsp)
jne    134d <main+0x1cd>
xor    %r13d,%r13d
xor    %eax,%eax
call   1040 <clock@plt>
mov    %eax,%ebx
sub    %r14d,%ebx
lea    0xd17(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mov    0x2cbc(%rip),%rax
divsd  (%rax),%xmm0
lea    0xd0c(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%ecx
mov    %rcx,0x20(%rsp)
lea    0x1(%rax),%ecx
mov    $0x1,%r11d
mov    $0x9,%ebx
mov    $0x2,%r8d
mov    $0xfffffff7,%r15d
movdqa 0xc8a(%rip),%xmm0
mov    %rcx,0x18(%rsp)
mov    %ecx,%r9d
xor    %r13d,%r13d
mov    %r14d,0x10(%rsp)
jmp    13bf <main+0x23f>
mov    0x10(%rsp),%r14d
nopl   (%rax)
add    $0x1,%eax
mov    %eax,0xc(%rsp)
mov    %esi,%ecx
add    %rcx,%r13
lea    0x1(%r11),%rcx
add    $0x1,%ebx
add    $0x1,%r9d
add    $0x1,%r8d
add    $0xffffffff,%r15d
mov    %esi,%ebp
cmp    0x20(%rsp),%r11
mov    %rcx,%r11
jae    1301 <main+0x181>
cmp    %r8d,%r9d
mov    %r8d,%edx
cmova  %r9d,%edx
mov    %r10d,%ecx
mov    0x18(%rsp),%rsi
add    %ecx,%esi
lea    0x2(%rcx),%edi
cmp    %edi,%esi
cmova  %esi,%edi
lea    0x1(%rcx),%r10d
mov    %eax,%eax
mov    (%r12,%rax,4),%esi
cmp    %ebp,%esi
jae    1390 <main+0x210>
mov    %ebp,%esi
cmp    %ebp,-0x4(%r12,%r11,4)
jne    1390 <main+0x210>
xor    %esi,%esi
cmp    %rax,%r11
ja     1390 <main+0x210>
not    %ecx
lea    (%rdi,%rcx,1),%ebp
xor    %esi,%esi
mov    %ebp,0x14(%rsp)
cmp    $0x8,%ebp
jb     143f <main+0x2bf>
lea    -0x1(%rdi),%ebp
cmp    %r10d,%ebp
jb     1437 <main+0x2b7>
add    %edi,%ecx
add    $0xfffffff8,%ecx
mov    %ecx,%ebp
shr    $0x3,%ebp
add    $0x1,%ebp
cmp    $0x8,%ecx
jae    1447 <main+0x2c7>
pxor   %xmm1,%xmm1
xor    %r14d,%r14d
pxor   %xmm2,%xmm2
mov    0x14(%rsp),%edi
jmp    151f <main+0x39f>
mov    %r11d,%edx
jmp    1600 <main+0x480>
mov    %r11d,%edx
jmp    1600 <main+0x480>
add    %r15d,%edx
shr    $0x3,%edx
add    $0x1,%edx
and    $0xfffffffe,%edx
pxor   %xmm1,%xmm1
xor    %r14d,%r14d
mov    %ebx,%esi
pxor   %xmm2,%xmm2
mov    0x14(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x8(%rsi),%ecx
movdqu (%r12,%rcx,4),%xmm4
movdqu 0x10(%r12,%rcx,4),%xmm5
movdqa %xmm1,%xmm6
pxor   %xmm0,%xmm6
movdqa %xmm4,%xmm3
pxor   %xmm0,%xmm3
pcmpgtd %xmm6,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm1,%xmm3
por    %xmm4,%xmm3
movdqa %xmm2,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm5,%xmm4
pxor   %xmm0,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm4,%xmm5
pandn  %xmm2,%xmm4
por    %xmm5,%xmm4
mov    %esi,%ecx
movdqu (%r12,%rcx,4),%xmm2
movdqu 0x10(%r12,%rcx,4),%xmm5
movdqa %xmm3,%xmm6
pxor   %xmm0,%xmm6
movdqa %xmm2,%xmm1
pxor   %xmm0,%xmm1
pcmpgtd %xmm6,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm3,%xmm1
por    %xmm2,%xmm1
movdqa %xmm4,%xmm3
pxor   %xmm0,%xmm3
movdqa %xmm5,%xmm2
pxor   %xmm0,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm5
pandn  %xmm4,%xmm2
por    %xmm5,%xmm2
add    $0x10,%r14d
add    $0x10,%esi
add    $0xfffffffe,%edx
jne    1470 <main+0x2f0>
mov    %edi,%edx
and    $0xfffffff8,%edx
test   $0x1,%bpl
je     1582 <main+0x402>
add    %r11d,%r14d
movdqu (%r12,%r14,4),%xmm3
movdqu 0x10(%r12,%r14,4),%xmm4
movdqa %xmm1,%xmm5
pxor   %xmm0,%xmm5
movdqa %xmm3,%xmm6
pxor   %xmm0,%xmm6
pcmpgtd %xmm5,%xmm6
pand   %xmm6,%xmm3
pandn  %xmm1,%xmm6
por    %xmm3,%xmm6
movdqa %xmm2,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm4,%xmm3
pxor   %xmm0,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm2,%xmm3
por    %xmm4,%xmm3
movdqa %xmm6,%xmm1
movdqa %xmm3,%xmm2
movdqa %xmm2,%xmm3
pxor   %xmm0,%xmm3
movdqa %xmm1,%xmm4
pxor   %xmm0,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm1
pandn  %xmm2,%xmm4
por    %xmm1,%xmm4
pshufd $0xee,%xmm4,%xmm1
movdqa %xmm4,%xmm2
pxor   %xmm0,%xmm2
movdqa %xmm1,%xmm3
pxor   %xmm0,%xmm3
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm4
pandn  %xmm1,%xmm2
por    %xmm4,%xmm2
pshufd $0x55,%xmm2,%xmm1
movdqa %xmm2,%xmm3
pxor   %xmm0,%xmm3
movdqa %xmm1,%xmm4
pxor   %xmm0,%xmm4
pcmpgtd %xmm4,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movd   %xmm3,%esi
cmp    %edx,%edi
je     1388 <main+0x208>
add    %r11d,%edx
mov    0x10(%rsp),%r14d
mov    %edx,%ecx
mov    (%r12,%rcx,4),%ecx
cmp    %esi,%ecx
cmova  %ecx,%esi
add    $0x1,%edx
cmp    %edx,%eax
jae    1600 <main+0x480>
jmp    1390 <main+0x210>
lea    0xa5c(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
@.str = [12 x i8] c"Ingrese u: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [12 x i8] c"Ingrese k: \00"
@.str.3 = [37 x i8] c"\0AError en la asignacion de memoria.\0A\00"
@.str.4 = [29 x i8] c"\0ATabla de divisores creada.\0A\00"
@.str.5 = [24 x i8] c"\0AEl resultado es: %lld\0A\00"
@.str.6 = [27 x i8] c"Tiempo de ejecucion: %.3f\0A\00"
@CLOCKS_PER_SEC = global double 0.000000e+00
define void @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i64
%13 = alloca i32
store i32 %0, i32* %3
store i8** %1, i8*** %4
%14 = load i32, i32* %3
%15 = icmp eq i32 %14, 1
br i1 %15, label %16, label %21
16: ; preds = %2
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%18 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %5)
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
%20 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %6)
br label %30
21: ; preds = %2
%22 = load i8**, i8*** %4
%23 = getelementptr inbounds i8*, i8** %22, i64 1
%24 = load i8*, i8** %23
%25 = call i32 @atoi(i8* %24)
store i32 %25, i32* %5
%26 = load i8**, i8*** %4
%27 = getelementptr inbounds i8*, i8** %26, i64 2
%28 = load i8*, i8** %27
%29 = call i32 @atoi(i8* %28)
store i32 %29, i32* %6
br label %30
30: ; preds = %21, %16
%31 = call i32 (...) @clock()
store i32 %31, i32* %13
%32 = load i32, i32* %5
%33 = zext i32 %32 to i64
%34 = mul i64 %33, 4
%35 = trunc i64 %34 to i32
%36 = call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to i32*
store i32* %37, i32** %11
%38 = load i32*, i32** %11
%39 = icmp eq i32* %38, null
br i1 %39, label %40, label %43
40: ; preds = %30
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.3, i64 0, i64 0))
%42 = call i32 @exit(i32 1)
unreachable
43: ; preds = %30
store i32 1, i32* %10
br label %44
44: ; preds = %90, %43
%45 = load i32, i32* %5
%46 = load i32, i32* %10
%47 = icmp uge i32 %45, %46
br i1 %47, label %48, label %93
48: ; preds = %44
%49 = load i32*, i32** %11
%50 = load i32, i32* %10
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
store i32 0, i32* %52
%53 = load i32, i32* %10
%54 = call i64 @sqrt(i32 %53)
%55 = trunc i64 %54 to i32
store i32 %55, i32* %7
store i32 1, i32* %9
br label %56
56: ; preds = %73, %48
%57 = load i32, i32* %7
%58 = load i32, i32* %9
%59 = icmp uge i32 %57, %58
br i1 %59, label %60, label %76
60: ; preds = %56
%61 = load i32, i32* %10
%62 = load i32, i32* %9
%63 = urem i32 %61, %62
%64 = icmp eq i32 %63, 0
br i1 %64, label %65, label %72
65: ; preds = %60
%66 = load i32*, i32** %11
%67 = load i32, i32* %10
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
%70 = load i32, i32* %69
%71 = add i32 %70, 2
store i32 %71, i32* %69
br label %72
72: ; preds = %65, %60
br label %73
73: ; preds = %72
%74 = load i32, i32* %9
%75 = add i32 %74, 1
store i32 %75, i32* %9
br label %56
76: ; preds = %56
%77 = load i32, i32* %7
%78 = load i32, i32* %7
%79 = mul i32 %77, %78
%80 = load i32, i32* %10
%81 = icmp eq i32 %79, %80
br i1 %81, label %82, label %89
82: ; preds = %76
%83 = load i32*, i32** %11
%84 = load i32, i32* %10
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %83, i64 %85
%87 = load i32, i32* %86
%88 = add i32 %87, -1
store i32 %88, i32* %86
br label %89
89: ; preds = %82, %76
br label %90
90: ; preds = %89
%91 = load i32, i32* %10
%92 = add i32 %91, 1
store i32 %92, i32* %10
br label %44
93: ; preds = %44
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0))
%95 = load i32, i32* %5
store i32 %95, i32* %8
%96 = load i32, i32* %5
%97 = load i32*, i32** %11
%98 = getelementptr inbounds i32, i32* %97, i64 0
store i32 %96, i32* %98
store i64 0, i64* %12
%99 = load i32, i32* %5
%100 = load i32, i32* %6
%101 = sub i32 %99, %100
%102 = add i32 %101, 1
store i32 %102, i32* %5
store i32 1, i32* %10
br label %103
103: ; preds = %163, %93
%104 = load i32, i32* %5
%105 = load i32, i32* %10
%106 = icmp uge i32 %104, %105
br i1 %106, label %107, label %166
107: ; preds = %103
%108 = load i32*, i32** %11
%109 = load i32, i32* %6
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
%112 = load i32, i32* %111
%113 = load i32, i32* %8
%114 = icmp uge i32 %112, %113
br i1 %114, label %115, label %121
115: ; preds = %107
%116 = load i32*, i32** %11
%117 = load i32, i32* %6
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %116, i64 %118
%120 = load i32, i32* %119
store i32 %120, i32* %8
br label %156
121: ; preds = %107
%122 = load i32*, i32** %11
%123 = load i32, i32* %10
%124 = sub i32 %123, 1
%125 = zext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %122, i64 %125
%127 = load i32, i32* %126
%128 = load i32, i32* %8
%129 = icmp eq i32 %127, %128
br i1 %129, label %130, label %155
130: ; preds = %121
store i32 0, i32* %8
%131 = load i32, i32* %10
store i32 %131, i32* %9
br label %132
132: ; preds = %151, %130
%133 = load i32, i32* %6
%134 = load i32, i32* %9
%135 = icmp uge i32 %133, %134
br i1 %135, label %136, label %154
136: ; preds = %132
%137 = load i32*, i32** %11
%138 = load i32, i32* %9
%139 = zext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %137, i64 %139
%141 = load i32, i32* %140
%142 = load i32, i32* %8
%143 = icmp ugt i32 %141, %142
br i1 %143, label %144, label %150
144: ; preds = %136
%145 = load i32*, i32** %11
%146 = load i32, i32* %9
%147 = zext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = load i32, i32* %148
store i32 %149, i32* %8
br label %150
150: ; preds = %144, %136
br label %151
151: ; preds = %150
%152 = load i32, i32* %9
%153 = add i32 %152, 1
store i32 %153, i32* %9
br label %132
154: ; preds = %132
br label %155
155: ; preds = %154, %121
br label %156
156: ; preds = %155, %115
%157 = load i32, i32* %6
%158 = add i32 %157, 1
store i32 %158, i32* %6
%159 = load i32, i32* %8
%160 = zext i32 %159 to i64
%161 = load i64, i64* %12
%162 = add i64 %161, %160
store i64 %162, i64* %12
br label %163
163: ; preds = %156
%164 = load i32, i32* %10
%165 = add i32 %164, 1
store i32 %165, i32* %10
br label %103
166: ; preds = %103
%167 = call i32 (...) @clock()
%168 = load i32, i32* %13
%169 = sub nsw i32 %167, %168
store i32 %169, i32* %13
%170 = load i64, i64* %12
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.5, i64 0, i64 0), i64 %170)
%172 = load i32, i32* %13
%173 = sitofp i32 %172 to double
%174 = load double, double* @CLOCKS_PER_SEC
%175 = fdiv double %173, %174
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.6, i64 0, i64 0), double %175)
ret void
}

LLVM IR (-O2):
@.str = [12 x i8] c"Ingrese u: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [12 x i8] c"Ingrese k: \00"
@.str.5 = [24 x i8] c"\0AEl resultado es: %lld\0A\00"
@.str.6 = [27 x i8] c"Tiempo de ejecucion: %.3f\0A\00"
@CLOCKS_PER_SEC = global double 0.000000e+00
@str = [28 x i8] c"\0ATabla de divisores creada.\00"
@str.7 = [36 x i8] c"\0AError en la asignacion de memoria.\00"
define void @main(i32 %0, i8** nocapture %1) {
%3 = alloca i32
%4 = alloca i32
%5 = bitcast i32* %3 to i8*
%6 = bitcast i32* %4 to i8*
%7 = icmp eq i32 %0, 1
br i1 %7, label %8, label %13
8: ; preds = %2
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
%11 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
%12 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
br label %20
13: ; preds = %2
%14 = getelementptr inbounds i8*, i8** %1, i64 1
%15 = load i8*, i8** %14
%16 = tail call i32 @atoi(i8* %15)
store i32 %16, i32* %3
%17 = getelementptr inbounds i8*, i8** %1, i64 2
%18 = load i8*, i8** %17
%19 = tail call i32 @atoi(i8* %18)
store i32 %19, i32* %4
br label %20
20: ; preds = %13, %8
%21 = call i32 (...) @clock()
%22 = load i32, i32* %3
%23 = shl i32 %22, 2
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to i32*
%26 = icmp eq i64 %24, 0
br i1 %26, label %30, label %27
27: ; preds = %20
%28 = load i32, i32* %3
%29 = icmp eq i32 %28, 0
br i1 %29, label %83, label %33
30: ; preds = %20
%31 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.7, i64 0, i64 0))
%32 = call i32 @exit(i32 1)
unreachable
33: ; preds = %27, %79
%34 = phi i32 [ %80, %79 ], [ 1, %27 ]
%35 = zext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %25, i64 %35
store i32 0, i32* %36
%37 = call i64 @sqrt(i32 %34)
%38 = trunc i64 %37 to i32
%39 = icmp eq i32 %38, 0
br i1 %39, label %73, label %40
40: ; preds = %33
%41 = and i32 %38, 1
%42 = icmp eq i32 %38, 1
br i1 %42, label %64, label %43
43: ; preds = %40
%44 = and i32 %38, -2
br label %45
45: ; preds = %60, %43
%46 = phi i32 [ 1, %43 ], [ %61, %60 ]
%47 = phi i32 [ 0, %43 ], [ %62, %60 ]
%48 = urem i32 %34, %46
%49 = icmp eq i32 %48, 0
br i1 %49, label %50, label %53
50: ; preds = %45
%51 = load i32, i32* %36
%52 = add i32 %51, 2
store i32 %52, i32* %36
br label %53
53: ; preds = %45, %50
%54 = add nuw i32 %46, 1
%55 = urem i32 %34, %54
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %60
57: ; preds = %53
%58 = load i32, i32* %36
%59 = add i32 %58, 2
store i32 %59, i32* %36
br label %60
60: ; preds = %57, %53
%61 = add nuw i32 %46, 2
%62 = add i32 %47, 2
%63 = icmp eq i32 %62, %44
br i1 %63, label %64, label %45
64: ; preds = %60, %40
%65 = phi i32 [ 1, %40 ], [ %61, %60 ]
%66 = icmp eq i32 %41, 0
br i1 %66, label %73, label %67
67: ; preds = %64
%68 = urem i32 %34, %65
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %73
70: ; preds = %67
%71 = load i32, i32* %36
%72 = add i32 %71, 2
store i32 %72, i32* %36
br label %73
73: ; preds = %64, %70, %67, %33
%74 = mul i32 %38, %38
%75 = icmp eq i32 %74, %34
br i1 %75, label %76, label %79
76: ; preds = %73
%77 = load i32, i32* %36
%78 = add i32 %77, -1
store i32 %78, i32* %36
br label %79
79: ; preds = %73, %76
%80 = add i32 %34, 1
%81 = load i32, i32* %3
%82 = icmp ult i32 %81, %80
br i1 %82, label %83, label %33
83: ; preds = %79, %27
%84 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%85 = load i32, i32* %3
store i32 %85, i32* %25
%86 = load i32, i32* %3
%87 = load i32, i32* %4
%88 = sub i32 %86, %87
%89 = add i32 %88, 1
store i32 %89, i32* %3
%90 = icmp eq i32 %89, 0
br i1 %90, label %222, label %91
91: ; preds = %83
%92 = zext i32 %89 to i64
%93 = add i32 %87, 1
br label %94
94: ; preds = %91, %214
%95 = phi i32 [ 0, %91 ], [ %221, %214 ]
%96 = phi i32 [ %87, %91 ], [ %216, %214 ]
%97 = phi i64 [ 1, %91 ], [ %219, %214 ]
%98 = phi i64 [ 0, %91 ], [ %218, %214 ]
%99 = phi i32 [ %85, %91 ], [ %215, %214 ]
%100 = add i32 %93, %95
%101 = add i32 %95, 2
%102 = call i32 @llvm.umax.i32(i32 %100, i32 %101)
%103 = xor i32 %95, -1
%104 = add i32 %102, %103
%105 = add i32 %104, -8
%106 = lshr i32 %105, 3
%107 = add nuw nsw i32 %106, 1
%108 = add i32 %93, %95
%109 = add i32 %95, 2
%110 = call i32 @llvm.umax.i32(i32 %108, i32 %109)
%111 = xor i32 %95, -1
%112 = add i32 %110, %111
%113 = add i32 %93, %95
%114 = add i32 %95, 2
%115 = call i32 @llvm.umax.i32(i32 %113, i32 %114)
%116 = add i32 %95, 1
%117 = zext i32 %96 to i64
%118 = getelementptr inbounds i32, i32* %25, i64 %117
%119 = load i32, i32* %118
%120 = icmp ult i32 %119, %99
br i1 %120, label %121, label %214
121: ; preds = %94
%122 = add nsw i64 %97, -1
%123 = getelementptr inbounds i32, i32* %25, i64 %122
%124 = load i32, i32* %123
%125 = icmp eq i32 %124, %99
br i1 %125, label %126, label %214
126: ; preds = %121
%127 = icmp ugt i64 %97, %117
br i1 %127, label %214, label %128
128: ; preds = %126
%129 = trunc i64 %97 to i32
%130 = icmp ult i32 %112, 8
%131 = add i32 %115, -1
%132 = icmp ult i32 %131, %116
%133 = select i1 %130, i1 true, i1 %132
br i1 %133, label %201, label %134
134: ; preds = %128
%135 = and i32 %112, -8
%136 = add i32 %135, %129
%137 = and i32 %107, 1
%138 = icmp ult i32 %105, 8
br i1 %138, label %174, label %139
139: ; preds = %134
%140 = and i32 %107, 1073741822
br label %141
141: ; preds = %141, %139
%142 = phi i32 [ 0, %139 ], [ %171, %141 ]
%143 = phi <4 x i32> [ zeroinitializer, %139 ], [ %169, %141 ]
%144 = phi <4 x i32> [ zeroinitializer, %139 ], [ %170, %141 ]
%145 = phi i32 [ 0, %139 ], [ %172, %141 ]
%146 = add i32 %142, %129
%147 = zext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %25, i64 %147
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = getelementptr inbounds i32, i32* %148, i64 4
%152 = bitcast i32* %151 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = icmp ugt <4 x i32> %150, %143
%155 = icmp ugt <4 x i32> %153, %144
%156 = select <4 x i1> %154, <4 x i32> %150, <4 x i32> %143
%157 = select <4 x i1> %155, <4 x i32> %153, <4 x i32> %144
%158 = or i32 %142, 8
%159 = add i32 %158, %129
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %25, i64 %160
%162 = bitcast i32* %161 to <4 x i32>*
%163 = load <4 x i32>, <4 x i32>* %162
%164 = getelementptr inbounds i32, i32* %161, i64 4
%165 = bitcast i32* %164 to <4 x i32>*
%166 = load <4 x i32>, <4 x i32>* %165
%167 = icmp ugt <4 x i32> %163, %156
%168 = icmp ugt <4 x i32> %166, %157
%169 = select <4 x i1> %167, <4 x i32> %163, <4 x i32> %156
%170 = select <4 x i1> %168, <4 x i32> %166, <4 x i32> %157
%171 = add nuw i32 %142, 16
%172 = add i32 %145, 2
%173 = icmp eq i32 %172, %140
br i1 %173, label %174, label %141
174: ; preds = %141, %134
%175 = phi <4 x i32> [ undef, %134 ], [ %169, %141 ]
%176 = phi <4 x i32> [ undef, %134 ], [ %170, %141 ]
%177 = phi i32 [ 0, %134 ], [ %171, %141 ]
%178 = phi <4 x i32> [ zeroinitializer, %134 ], [ %169, %141 ]
%179 = phi <4 x i32> [ zeroinitializer, %134 ], [ %170, %141 ]
%180 = icmp eq i32 %137, 0
br i1 %180, label %194, label %181
181: ; preds = %174
%182 = add i32 %177, %129
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %25, i64 %183
%185 = bitcast i32* %184 to <4 x i32>*
%186 = load <4 x i32>, <4 x i32>* %185
%187 = getelementptr inbounds i32, i32* %184, i64 4
%188 = bitcast i32* %187 to <4 x i32>*
%189 = load <4 x i32>, <4 x i32>* %188
%190 = icmp ugt <4 x i32> %186, %178
%191 = icmp ugt <4 x i32> %189, %179
%192 = select <4 x i1> %190, <4 x i32> %186, <4 x i32> %178
%193 = select <4 x i1> %191, <4 x i32> %189, <4 x i32> %179
br label %194
194: ; preds = %174, %181
%195 = phi <4 x i32> [ %175, %174 ], [ %192, %181 ]
%196 = phi <4 x i32> [ %176, %174 ], [ %193, %181 ]
%197 = icmp ugt <4 x i32> %195, %196
%198 = select <4 x i1> %197, <4 x i32> %195, <4 x i32> %196
%199 = call i32 @llvm.vector.reduce.umax.v4i32(<4 x i32> %198)
%200 = icmp eq i32 %112, %135
br i1 %200, label %214, label %201
201: ; preds = %128, %194
%202 = phi i32 [ 0, %128 ], [ %199, %194 ]
%203 = phi i32 [ %129, %128 ], [ %136, %194 ]
br label %204
204: ; preds = %201, %204
%205 = phi i32 [ %211, %204 ], [ %202, %201 ]
%206 = phi i32 [ %212, %204 ], [ %203, %201 ]
%207 = zext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %25, i64 %207
%209 = load i32, i32* %208
%210 = icmp ugt i32 %209, %205
%211 = select i1 %210, i32 %209, i32 %205
%212 = add i32 %206, 1
%213 = icmp ult i32 %96, %212
br i1 %213, label %214, label %204
214: ; preds = %204, %194, %126, %94, %121
%215 = phi i32 [ %99, %121 ], [ %119, %94 ], [ 0, %126 ], [ %199, %194 ], [ %211, %204 ]
%216 = add i32 %96, 1
store i32 %216, i32* %4
%217 = zext i32 %215 to i64
%218 = add i64 %98, %217
%219 = add nuw nsw i64 %97, 1
%220 = icmp ult i64 %97, %92
%221 = add i32 %95, 1
br i1 %220, label %94, label %222
222: ; preds = %214, %83
%223 = phi i64 [ 0, %83 ], [ %218, %214 ]
%224 = call i32 (...) @clock()
%225 = sub nsw i32 %224, %21
%226 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.5, i64 0, i64 0), i64 %223)
%227 = sitofp i32 %225 to double
%228 = load double, double* @CLOCKS_PER_SEC
%229 = fdiv double %227, %228
%230 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.6, i64 0, i64 0), double %229)
ret void
}