#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 *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main(void) {
  int n, m;
  printf("%s\n", "ingrese n");
  scanf("%d", &n);
  printf("%s\n", "ingrese m");
  scanf("%d", &m);
  int arre[n][m];
  int valor = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      printf("ingrese valor %d%d\n", i, j);
      scanf("%d", &valor);
      arre[i][j] = valor;
    }
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      printf("%d", arre[i][j]);
    }
    printf("\n");
  }
  int arre2[n][m];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      arre2[i][j] = 0;
    }
  }
  int x = 0;
  int y = 0;
  for (int i = (n - 1); i >= 0; i--) {
    for (int j = (m - 1); j >= 0; j--) {
      valor = arre[i][j];
      printf("v%d\n", valor);
      arre2[x][y] = valor;
      y++;
    }
    x++;
    y = 0;
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      printf("%d", arre2[i][j]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
mov    %rdi,-0x98(%rbp)
lea    0xebd(%rip),%rsi
xor    %eax,%eax
mov    %al,-0x89(%rbp)
call   1030 <printf@plt>
lea    0xeb3(%rip),%rdi
mov    %rdi,-0x88(%rbp)
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x98(%rbp),%rdi
mov    -0x89(%rbp),%al
lea    0xe92(%rip),%rsi
call   1030 <printf@plt>
mov    -0x88(%rbp),%rdi
lea    -0xc(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x80(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x18(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x78(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1262 <main+0x142>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124f <main+0x12f>
mov    -0x30(%rbp),%esi
mov    -0x34(%rbp),%edx
lea    0xe12(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdf7(%rip),%rdi
lea    -0x2c(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x80(%rbp),%rsi
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%edx
movslq -0x30(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f0 <main+0xd0>
jmp    1254 <main+0x134>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11dd <main+0xbd>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12de <main+0x1be>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12c2 <main+0x1a2>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x38(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd61(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    127c <main+0x15c>
lea    0xd64(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1269 <main+0x149>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0xa8(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1387 <main+0x267>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1374 <main+0x254>
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1332 <main+0x212>
jmp    1379 <main+0x259>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    131f <main+0x1ff>
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jl     1449 <main+0x329>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x68(%rbp)
jl     142b <main+0x30b>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x64(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%esi
lea    0xc49(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa8(%rbp),%rsi
mov    -0xa0(%rbp),%rax
mov    -0x2c(%rbp),%edx
movslq -0x5c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
jmp    13b1 <main+0x291>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    139e <main+0x27e>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14cb <main+0x3ab>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14af <main+0x38f>
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rdx
movslq -0x6c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xb74(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1463 <main+0x343>
lea    0xb77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1450 <main+0x330>
movl   $0x0,-0x4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
lea    0xe98(%rip),%rdi
call   1040 <puts@plt>
lea    0xe96(%rip),%rbx
lea    -0x30(%rbp),%rsi
mov    %rbx,%rdi
call   1070 <scanf@plt>
lea    0xe86(%rip),%rdi
call   1040 <puts@plt>
lea    -0x2c(%rbp),%rsi
mov    %rbx,%rdi
call   1070 <scanf@plt>
mov    %rsp,-0x78(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%edx
mov    %rdx,%rcx
mov    %rdx,-0x68(%rbp)
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
movl   $0x0,-0x3c(%rbp)
mov    -0x30(%rbp),%ecx
test   %ecx,%ecx
jle    147d <main+0x32d>
mov    -0x2c(%rbp),%eax
mov    -0x68(%rbp),%rdx
lea    0x0(,%rdx,4),%rdx
mov    %rdx,-0x38(%rbp)
lea    0xe25(%rip),%r15
lea    0xe11(%rip),%r12
mov    -0x60(%rbp),%r13
xor    %r14d,%r14d
jmp    1220 <main+0xd0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
movslq %ecx,%rdx
add    -0x38(%rbp),%r13
cmp    %rdx,%r14
jge    1265 <main+0x115>
test   %eax,%eax
jle    1210 <main+0xc0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
lea    -0x3c(%rbp),%rsi
call   1070 <scanf@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,0x0(%r13,%rbx,4)
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1230 <main+0xe0>
mov    -0x30(%rbp),%ecx
jmp    1210 <main+0xc0>
test   %ecx,%ecx
jle    147d <main+0x32d>
lea    0xd96(%rip),%r14
mov    -0x60(%rbp),%r13
xor    %r15d,%r15d
jmp    129b <main+0x14b>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r15
movslq -0x30(%rbp),%r12
add    -0x38(%rbp),%r13
cmp    %r12,%r15
jge    12ce <main+0x17e>
cmpl   $0x0,-0x2c(%rbp)
jle    1280 <main+0x130>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     12b0 <main+0x160>
jmp    1280 <main+0x130>
mov    %r12d,%edx
mov    -0x2c(%rbp),%esi
mov    %rsi,%rax
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r15
sub    %rax,%r15
mov    %r15,%rsp
test   %r12d,%r12d
jle    147d <main+0x32d>
lea    0x0(,%rsi,4),%rcx
lea    -0x1(%rdx),%rax
mov    %edx,%r14d
and    $0x3,%r14d
cmp    $0x3,%rax
mov    %rcx,-0x58(%rbp)
mov    %rdx,-0x70(%rbp)
mov    %rsi,-0x38(%rbp)
jae    1492 <main+0x342>
xor    %r13d,%r13d
test   %r14,%r14
je     1360 <main+0x210>
imul   %rsi,%r13
lea    (%r15,%r13,4),%rbx
mov    -0x58(%rbp),%r13
jmp    1349 <main+0x1f9>
nopl   0x0(%rax,%rax,1)
add    %r13,%rbx
add    $0xffffffffffffffff,%r14
je     1360 <main+0x210>
test   %esi,%esi
jle    1340 <main+0x1f0>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    -0x38(%rbp),%rsi
jmp    1340 <main+0x1f0>
test   %r12d,%r12d
jle    140c <main+0x2bc>
lea    0xcbb(%rip),%rbx
mov    %r15,-0x38(%rbp)
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x48(%rbp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addq   $0xffffffffffffffff,-0x48(%rbp)
test   %esi,%esi
jle    13e5 <main+0x295>
mov    -0x48(%rbp),%rax
imul   -0x68(%rbp),%rax
mov    -0x60(%rbp),%rcx
lea    (%rcx,%rax,4),%r14
mov    %esi,%r13d
add    $0xffffffffffffffff,%r13
mov    -0x38(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%eax
mov    (%r14,%rax,4),%esi
mov    %esi,-0x3c(%rbp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,(%r12)
add    $0x4,%r12
add    $0xffffffffffffffff,%r13
jb     13c0 <main+0x270>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
cmp    -0x70(%rbp),%rax
je     1408 <main+0x2b8>
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%esi
mov    -0x38(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1390 <main+0x240>
mov    -0x30(%rbp),%r12d
test   %r12d,%r12d
mov    -0x58(%rbp),%r13
jle    147d <main+0x32d>
lea    0xbee(%rip),%r12
xor    %r14d,%r14d
jmp    144a <main+0x2fa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq -0x30(%rbp),%rax
add    %r13,%r15
cmp    %rax,%r14
jge    147d <main+0x32d>
cmpl   $0x0,-0x2c(%rbp)
jle    1430 <main+0x2e0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,4),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1460 <main+0x310>
jmp    1430 <main+0x2e0>
mov    -0x78(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%edx
mov    %rdx,-0x50(%rbp)
mov    %rsi,%rax
shl    $0x4,%rax
mov    %rax,-0x48(%rbp)
lea    0x0(,%rsi,8),%rax
mov    %rax,-0x88(%rbp)
lea    (%rcx,%rcx,2),%rax
mov    %rax,-0x80(%rbp)
xor    %r13d,%r13d
mov    %r15,%rbx
mov    %r14,-0x90(%rbp)
jmp    14e2 <main+0x392>
nopw   0x0(%rax,%rax,1)
add    $0x4,%r13
add    -0x48(%rbp),%rbx
cmp    %r13,-0x50(%rbp)
je     1325 <main+0x1d5>
test   %esi,%esi
jle    14d0 <main+0x380>
mov    %rbx,%rdi
xor    %esi,%esi
mov    -0x58(%rbp),%r14
mov    %r14,%rdx
call   1060 <memset@plt>
lea    (%rbx,%r14,1),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1060 <memset@plt>
mov    -0x88(%rbp),%rax
lea    (%rbx,%rax,1),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1060 <memset@plt>
mov    -0x80(%rbp),%rax
lea    (%rbx,%rax,1),%rdi
xor    %esi,%esi
mov    %r14,%rdx
mov    -0x90(%rbp),%r14
call   1060 <memset@plt>
mov    -0x38(%rbp),%rsi
jmp    14d0 <main+0x380>

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

LLVM IR (-O2):
@.str.1 = [10 x i8] c"ingrese n\00"
@.str.2 = [3 x i8] c"%d\00"
@.str.3 = [10 x i8] c"ingrese m\00"
@.str.4 = [20 x i8] c"ingrese valor %d%d\0A\00"
@.str.6 = [5 x i8] c"v%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = bitcast i32* %1 to i8*
%5 = bitcast i32* %2 to i8*
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %1)
%8 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%9 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %2)
%10 = load i32, i32* %1
%11 = zext i32 %10 to i64
%12 = load i32, i32* %2
%13 = zext i32 %12 to i64
%14 = call i8* @llvm.stacksave()
%15 = mul nuw i64 %13, %11
%16 = alloca i32, i64 %15
%17 = bitcast i32* %3 to i8*
store i32 0, i32* %3
%18 = load i32, i32* %1
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %170
20: ; preds = %0
%21 = load i32, i32* %2
br label %22
22: ; preds = %20, %35
%23 = phi i32 [ %18, %20 ], [ %36, %35 ]
%24 = phi i32 [ %21, %20 ], [ %37, %35 ]
%25 = phi i64 [ 0, %20 ], [ %38, %35 ]
%26 = icmp sgt i32 %24, 0
br i1 %26, label %27, label %35
27: ; preds = %22
%28 = mul nuw nsw i64 %25, %13
%29 = getelementptr inbounds i32, i32* %16, i64 %28
%30 = trunc i64 %25 to i32
br label %41
31: ; preds = %35
%32 = icmp sgt i32 %36, 0
br i1 %32, label %52, label %170
33: ; preds = %41
%34 = load i32, i32* %1
br label %35
35: ; preds = %33, %22
%36 = phi i32 [ %34, %33 ], [ %23, %22 ]
%37 = phi i32 [ %49, %33 ], [ %24, %22 ]
%38 = add nuw nsw i64 %25, 1
%39 = sext i32 %36 to i64
%40 = icmp slt i64 %38, %39
br i1 %40, label %22, label %31
41: ; preds = %27, %41
%42 = phi i64 [ 0, %27 ], [ %48, %41 ]
%43 = trunc i64 %42 to i32
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0), i32 %30, i32 %43)
%45 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %3)
%46 = load i32, i32* %3
%47 = getelementptr inbounds i32, i32* %29, i64 %42
store i32 %46, i32* %47
%48 = add nuw nsw i64 %42, 1
%49 = load i32, i32* %2
%50 = sext i32 %49 to i64
%51 = icmp slt i64 %48, %50
br i1 %51, label %41, label %33
52: ; preds = %31, %74
%53 = phi i64 [ %76, %74 ], [ 0, %31 ]
%54 = load i32, i32* %2
%55 = icmp sgt i32 %54, 0
br i1 %55, label %56, label %74
56: ; preds = %52
%57 = mul nuw nsw i64 %53, %13
%58 = getelementptr inbounds i32, i32* %16, i64 %57
br label %80
59: ; preds = %74
%60 = zext i32 %77 to i64
%61 = load i32, i32* %2
%62 = zext i32 %61 to i64
%63 = mul nuw i64 %62, %60
%64 = alloca i32, i64 %63
%65 = icmp sgt i32 %77, 0
br i1 %65, label %66, label %170
66: ; preds = %59
%67 = icmp sgt i32 %61, 0
%68 = shl nuw nsw i64 %62, 2
%69 = add nsw i64 %60, -1
%70 = and i64 %60, 3
%71 = icmp ult i64 %69, 3
br i1 %71, label %108, label %72
72: ; preds = %66
%73 = and i64 %60, 4294967292
br label %89
74: ; preds = %80, %52
%75 = call i32 @putchar(i32 10)
%76 = add nuw nsw i64 %53, 1
%77 = load i32, i32* %1
%78 = sext i32 %77 to i64
%79 = icmp slt i64 %76, %78
br i1 %79, label %52, label %59
80: ; preds = %56, %80
%81 = phi i64 [ 0, %56 ], [ %85, %80 ]
%82 = getelementptr inbounds i32, i32* %58, i64 %81
%83 = load i32, i32* %82
%84 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %83)
%85 = add nuw nsw i64 %81, 1
%86 = load i32, i32* %2
%87 = sext i32 %86 to i64
%88 = icmp slt i64 %85, %87
br i1 %88, label %80, label %74
89: ; preds = %125, %72
%90 = phi i64 [ 0, %72 ], [ %126, %125 ]
%91 = phi i64 [ 0, %72 ], [ %127, %125 ]
br i1 %67, label %92, label %125
92: ; preds = %89
%93 = mul nuw nsw i64 %90, %62
%94 = getelementptr i32, i32* %64, i64 %93
%95 = bitcast i32* %94 to i8*
%96 = or i64 %90, 1
%97 = mul nuw nsw i64 %96, %62
%98 = getelementptr i32, i32* %64, i64 %97
%99 = bitcast i32* %98 to i8*
%100 = or i64 %90, 2
%101 = mul nuw nsw i64 %100, %62
%102 = getelementptr i32, i32* %64, i64 %101
%103 = bitcast i32* %102 to i8*
%104 = or i64 %90, 3
%105 = mul nuw nsw i64 %104, %62
%106 = getelementptr i32, i32* %64, i64 %105
%107 = bitcast i32* %106 to i8*
br label %125
108: ; preds = %125, %66
%109 = phi i64 [ 0, %66 ], [ %126, %125 ]
%110 = icmp eq i64 %70, 0
br i1 %110, label %122, label %111
111: ; preds = %108, %118
%112 = phi i64 [ %119, %118 ], [ %109, %108 ]
%113 = phi i64 [ %120, %118 ], [ 0, %108 ]
br i1 %67, label %114, label %118
114: ; preds = %111
%115 = mul nuw nsw i64 %112, %62
%116 = getelementptr i32, i32* %64, i64 %115
%117 = bitcast i32* %116 to i8*
br label %118
118: ; preds = %114, %111
%119 = add nuw nsw i64 %112, 1
%120 = add i64 %113, 1
%121 = icmp eq i64 %120, %70
br i1 %121, label %122, label %111
122: ; preds = %118, %108
br i1 %65, label %123, label %131
123: ; preds = %122
%124 = zext i32 %77 to i64
br label %134
125: ; preds = %89, %92
%126 = add nuw nsw i64 %90, 4
%127 = add i64 %91, 4
%128 = icmp eq i64 %127, %73
br i1 %128, label %108, label %89
129: ; preds = %146
%130 = load i32, i32* %1
br label %131
131: ; preds = %129, %122
%132 = phi i32 [ %130, %129 ], [ %77, %122 ]
%133 = icmp sgt i32 %132, 0
br i1 %133, label %163, label %170
134: ; preds = %149, %123
%135 = phi i32 [ %61, %123 ], [ %150, %149 ]
%136 = phi i64 [ 0, %123 ], [ %147, %149 ]
%137 = phi i64 [ %124, %123 ], [ %138, %149 ]
%138 = add nsw i64 %137, -1
%139 = icmp sgt i32 %135, 0
br i1 %139, label %140, label %146
140: ; preds = %134
%141 = mul nsw i64 %138, %13
%142 = getelementptr inbounds i32, i32* %16, i64 %141
%143 = mul nuw nsw i64 %136, %62
%144 = getelementptr inbounds i32, i32* %64, i64 %143
%145 = zext i32 %135 to i64
br label %151
146: ; preds = %151, %134
%147 = add nuw nsw i64 %136, 1
%148 = icmp eq i64 %147, %60
br i1 %148, label %129, label %149
149: ; preds = %146
%150 = load i32, i32* %2
br label %134
151: ; preds = %140, %151
%152 = phi i64 [ 0, %140 ], [ %161, %151 ]
%153 = phi i64 [ %145, %140 ], [ %154, %151 ]
%154 = add nsw i64 %153, -1
%155 = and i64 %154, 4294967295
%156 = getelementptr inbounds i32, i32* %142, i64 %155
%157 = load i32, i32* %156
store i32 %157, i32* %3
%158 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i32 %157)
%159 = load i32, i32* %3
%160 = getelementptr inbounds i32, i32* %144, i64 %152
store i32 %159, i32* %160
%161 = add nuw nsw i64 %152, 1
%162 = icmp eq i64 %161, %145
br i1 %162, label %146, label %151
163: ; preds = %131, %171
%164 = phi i64 [ %173, %171 ], [ 0, %131 ]
%165 = load i32, i32* %2
%166 = icmp sgt i32 %165, 0
br i1 %166, label %167, label %171
167: ; preds = %163
%168 = mul nuw nsw i64 %164, %62
%169 = getelementptr inbounds i32, i32* %64, i64 %168
br label %177
170: ; preds = %171, %0, %31, %59, %131
ret i32 0
171: ; preds = %177, %163
%172 = call i32 @putchar(i32 10)
%173 = add nuw nsw i64 %164, 1
%174 = load i32, i32* %1
%175 = sext i32 %174 to i64
%176 = icmp slt i64 %173, %175
br i1 %176, label %163, label %170
177: ; preds = %167, %177
%178 = phi i64 [ 0, %167 ], [ %182, %177 ]
%179 = getelementptr inbounds i32, i32* %169, i64 %178
%180 = load i32, i32* %179
%181 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %180)
%182 = add nuw nsw i64 %178, 1
%183 = load i32, i32* %2
%184 = sext i32 %183 to i64
%185 = icmp slt i64 %182, %184
br i1 %185, label %177, label %171
}