#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ fputc(char, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(char **);
char **malloc(int);
int strlen(char *);
void om_text_print_bidimentional_map(FILE *fp, int xlen, int ylen,
                                     char **xlabel, char **ylabel, int *value) {
  char *asciipal = " .-+#";
  int pallen = strlen(asciipal);
  int x, y, l, max = 0;
  l = xlen * ylen;
  for (x = 0; x < l; x++)
    if (max < value[x])
      max = value[x];
  if (max == 0)
    max++;
  for (y = 0; y < ylen; y++) {
    fprintf(fp, "%15s: ", ylabel[y]);
    for (x = 0; x < xlen; x++) {
      int coloridx;
      int val = value[(y * xlen) + x];
      coloridx = ((pallen - 1) * val) / max;
      fputc(asciipal[coloridx], fp);
    }
    fprintf(fp, "\n");
  }
  fprintf(fp, "\n");
  {
    char **p = malloc(sizeof(char *) * xlen);
    for (x = 0; x < xlen; x++)
      p[x] = xlabel[x];
    while (1) {
      int sentinel = 0;
      fprintf(fp, "%15s  ", "");
      for (x = 0; x < xlen; x++) {
        if (*(p[x]) != '\0') {
          fputc(*(p[x]), fp);
          p[x]++;
          sentinel++;
        } else {
          fputc(' ', fp);
        }
      }
      fputc('\n', fp);
      if (sentinel == 0)
        break;
    }
    free(p);
  }
}


x86 assembly (clang, -O0):
<om_text_print_bidimentional_map>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
lea    0xe8b(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    11de <om_text_print_bidimentional_map+0x8e>
mov    -0x44(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11cb <om_text_print_bidimentional_map+0x7b>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
jmp    11d0 <om_text_print_bidimentional_map+0x80>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    119d <om_text_print_bidimentional_map+0x4d>
cmpl   $0x0,-0x44(%rbp)
jne    11f1 <om_text_print_bidimentional_map+0xa1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12a2 <om_text_print_bidimentional_map+0x152>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xdeb(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1282 <om_text_print_bidimentional_map+0x132>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
imul   -0x4c(%rbp),%eax
cltd
idivl  -0x44(%rbp)
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x8(%rbp),%rsi
movsbl %al,%edi
call   1050 <fputc@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1229 <om_text_print_bidimentional_map+0xd9>
mov    -0x8(%rbp),%rdi
lea    0xd80(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11f8 <om_text_print_bidimentional_map+0xa8>
mov    -0x8(%rbp),%rdi
lea    0xd60(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1300 <om_text_print_bidimentional_map+0x1b0>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12ce <om_text_print_bidimentional_map+0x17e>
jmp    1305 <om_text_print_bidimentional_map+0x1b5>
movl   $0x0,-0x5c(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xcf8(%rip),%rsi
lea    0xcf0(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ad <om_text_print_bidimentional_map+0x25d>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     138c <om_text_print_bidimentional_map+0x23c>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%al
mov    -0x8(%rbp),%rsi
movsbl %al,%edi
call   1050 <fputc@plt>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    $0x1,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    139a <om_text_print_bidimentional_map+0x24a>
mov    -0x8(%rbp),%rsi
mov    $0x20,%edi
call   1050 <fputc@plt>
jmp    139f <om_text_print_bidimentional_map+0x24f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    132c <om_text_print_bidimentional_map+0x1dc>
mov    -0x8(%rbp),%rsi
mov    $0xa,%edi
call   1050 <fputc@plt>
cmpl   $0x0,-0x5c(%rbp)
jne    13ca <om_text_print_bidimentional_map+0x27a>
jmp    13cf <om_text_print_bidimentional_map+0x27f>
jmp    1305 <om_text_print_bidimentional_map+0x1b5>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<om_text_print_bidimentional_map>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%rbx
mov    %r8,0x38(%rsp)
mov    %rcx,0x20(%rsp)
mov    %edx,%r12d
mov    %esi,%ebp
mov    %rdi,%r15
lea    0xe76(%rip),%rdi
call   1040 <strlen@plt>
mov    %r12d,%ecx
mov    %rbp,0x10(%rsp)
imul   %ebp,%ecx
test   %ecx,%ecx
jle    12f5 <om_text_print_bidimentional_map+0x195>
mov    %ecx,%ebp
cmp    $0x8,%ecx
jae    11b2 <om_text_print_bidimentional_map+0x52>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    12e0 <om_text_print_bidimentional_map+0x180>
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     14ce <om_text_print_bidimentional_map+0x36e>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
movdqu (%rbx,%rsi,4),%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm3
movdqu 0x20(%rbx,%rsi,4),%xmm4
movdqu 0x30(%rbx,%rsi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm0
pandn  %xmm2,%xmm6
por    %xmm0,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm6
pandn  %xmm4,%xmm0
por    %xmm6,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11e0 <om_text_print_bidimentional_map+0x80>
test   $0x1,%dl
je     1289 <om_text_print_bidimentional_map+0x129>
movdqu (%rbx,%rsi,4),%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm4,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rbp,%rcx
je     12f1 <om_text_print_bidimentional_map+0x191>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
cmp    %edx,%esi
cmovl  %edx,%esi
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    12e0 <om_text_print_bidimentional_map+0x180>
test   %esi,%esi
jne    12fa <om_text_print_bidimentional_map+0x19a>
mov    $0x1,%esi
mov    %esi,0x1c(%rsp)
mov    %eax,0xc(%rsp)
mov    0x10(%rsp),%ebp
test   %r12d,%r12d
jle    13ee <om_text_print_bidimentional_map+0x28e>
addl   $0xffffffff,0xc(%rsp)
movslq 0x10(%rsp),%rax
mov    %r12d,%ecx
mov    %rcx,0x28(%rsp)
shl    $0x2,%rax
mov    %rax,0x30(%rsp)
xor    %ecx,%ecx
mov    0x1c(%rsp),%r12d
jmp    136c <om_text_print_bidimentional_map+0x20c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
mov    %r14,%rsi
call   1050 <fputc@plt>
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
add    0x30(%rsp),%r13
cmp    0x28(%rsp),%rcx
mov    %r13,%rbx
mov    %r14,%r15
je     13ee <om_text_print_bidimentional_map+0x28e>
mov    0x38(%rsp),%rax
mov    %rcx,0x40(%rsp)
mov    (%rax,%rcx,8),%rdx
mov    %r15,%rdi
lea    0xc82(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
cmpl   $0x0,0x10(%rsp)
mov    %rbx,%r13
lea    0xc66(%rip),%rcx
mov    %r15,%r14
mov    0xc(%rsp),%edx
jle    1340 <om_text_print_bidimentional_map+0x1e0>
xor    %ebx,%ebx
mov    %edx,0xc(%rsp)
nopl   0x0(%rax)
mov    0x0(%r13,%rbx,4),%eax
imul   %edx,%eax
cltd
idiv   %r12d
cltq
movsbl (%rax,%rcx,1),%edi
mov    %r14,%rsi
mov    %r13,%r15
mov    %r14,%r13
mov    %rcx,%r14
call   1050 <fputc@plt>
mov    0xc(%rsp),%edx
mov    %r14,%rcx
mov    %r13,%r14
mov    %r15,%r13
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    13b0 <om_text_print_bidimentional_map+0x250>
jmp    1340 <om_text_print_bidimentional_map+0x1e0>
mov    $0xa,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
mov    0x10(%rsp),%rbx
lea    0x0(,%rbx,8),%edi
call   1080 <malloc@plt>
mov    %rax,%r14
test   %ebx,%ebx
jle    1441 <om_text_print_bidimentional_map+0x2e1>
lea    0x0(,%rbp,8),%rdx
mov    %r14,%rdi
mov    0x20(%rsp),%rsi
call   1070 <memcpy@plt>
jmp    1441 <om_text_print_bidimentional_map+0x2e1>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
test   %ebx,%ebx
je     14b8 <om_text_print_bidimentional_map+0x358>
mov    %r15,%rdi
lea    0xbc2(%rip),%rsi
lea    0xbc1(%rip),%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
cmpl   $0x0,0x10(%rsp)
jle    14ab <om_text_print_bidimentional_map+0x34b>
xor    %r13d,%r13d
xor    %ebx,%ebx
jmp    1486 <om_text_print_bidimentional_map+0x326>
nopw   0x0(%rax,%rax,1)
mov    $0x20,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
add    $0x1,%r13
cmp    %r13,%rbp
je     1430 <om_text_print_bidimentional_map+0x2d0>
mov    (%r14,%r13,8),%r12
movzbl (%r12),%eax
test   %al,%al
je     1470 <om_text_print_bidimentional_map+0x310>
movsbl %al,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
add    $0x1,%r12
mov    %r12,(%r14,%r13,8)
add    $0x1,%ebx
jmp    147d <om_text_print_bidimentional_map+0x31d>
mov    $0xa,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
mov    %r14,%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    1256 <om_text_print_bidimentional_map+0xf6>
jmp    1289 <om_text_print_bidimentional_map+0x129>

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

LLVM IR (-O2):
@.str = [6 x i8] c" .-+#\00"
@.str.1 = [7 x i8] c"%15s: \00"
@.str.3 = [7 x i8] c"%15s \00"
@.str.4 = [1 x i8] zeroinitializer
define void @om_text_print_bidimentional_map(i32* %0, i32 %1, i32 %2, i8** nocapture %3, i8** nocapture %4, i32* nocapture %5) {
%7 = bitcast i8** %3 to i8*
%8 = tail call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%9 = mul i32 %2, %1
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %92
11: ; preds = %6
%12 = zext i32 %9 to i64
%13 = icmp ult i32 %9, 8
br i1 %13, label %77, label %14
14: ; preds = %11
%15 = and i64 %12, 4294967288
%16 = add nsw i64 %15, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %52, label %21
21: ; preds = %14
%22 = and i64 %18, 4611686018427387902
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %49, %23 ]
%25 = phi <4 x i32> [ zeroinitializer, %21 ], [ %47, %23 ]
%26 = phi <4 x i32> [ zeroinitializer, %21 ], [ %48, %23 ]
%27 = phi i64 [ 0, %21 ], [ %50, %23 ]
%28 = getelementptr inbounds i32, i32* %5, i64 %24
%29 = bitcast i32* %28 to <4 x i32>*
%30 = load <4 x i32>, <4 x i32>* %29
%31 = getelementptr inbounds i32, i32* %28, i64 4
%32 = bitcast i32* %31 to <4 x i32>*
%33 = load <4 x i32>, <4 x i32>* %32
%34 = icmp slt <4 x i32> %25, %30
%35 = icmp slt <4 x i32> %26, %33
%36 = select <4 x i1> %34, <4 x i32> %30, <4 x i32> %25
%37 = select <4 x i1> %35, <4 x i32> %33, <4 x i32> %26
%38 = or i64 %24, 8
%39 = getelementptr inbounds i32, i32* %5, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = icmp slt <4 x i32> %36, %41
%46 = icmp slt <4 x i32> %37, %44
%47 = select <4 x i1> %45, <4 x i32> %41, <4 x i32> %36
%48 = select <4 x i1> %46, <4 x i32> %44, <4 x i32> %37
%49 = add nuw i64 %24, 16
%50 = add i64 %27, 2
%51 = icmp eq i64 %50, %22
br i1 %51, label %52, label %23
52: ; preds = %23, %14
%53 = phi <4 x i32> [ undef, %14 ], [ %47, %23 ]
%54 = phi <4 x i32> [ undef, %14 ], [ %48, %23 ]
%55 = phi i64 [ 0, %14 ], [ %49, %23 ]
%56 = phi <4 x i32> [ zeroinitializer, %14 ], [ %47, %23 ]
%57 = phi <4 x i32> [ zeroinitializer, %14 ], [ %48, %23 ]
%58 = icmp eq i64 %19, 0
br i1 %58, label %70, label %59
59: ; preds = %52
%60 = getelementptr inbounds i32, i32* %5, i64 %55
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = getelementptr inbounds i32, i32* %60, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = icmp slt <4 x i32> %56, %62
%67 = icmp slt <4 x i32> %57, %65
%68 = select <4 x i1> %66, <4 x i32> %62, <4 x i32> %56
%69 = select <4 x i1> %67, <4 x i32> %65, <4 x i32> %57
br label %70
70: ; preds = %52, %59
%71 = phi <4 x i32> [ %53, %52 ], [ %68, %59 ]
%72 = phi <4 x i32> [ %54, %52 ], [ %69, %59 ]
%73 = icmp sgt <4 x i32> %71, %72
%74 = select <4 x i1> %73, <4 x i32> %71, <4 x i32> %72
%75 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %74)
%76 = icmp eq i64 %15, %12
br i1 %76, label %89, label %77
77: ; preds = %11, %70
%78 = phi i64 [ 0, %11 ], [ %15, %70 ]
%79 = phi i32 [ 0, %11 ], [ %75, %70 ]
br label %80
80: ; preds = %77, %80
%81 = phi i64 [ %87, %80 ], [ %78, %77 ]
%82 = phi i32 [ %86, %80 ], [ %79, %77 ]
%83 = getelementptr inbounds i32, i32* %5, i64 %81
%84 = load i32, i32* %83
%85 = icmp slt i32 %82, %84
%86 = select i1 %85, i32 %84, i32 %82
%87 = add nuw nsw i64 %81, 1
%88 = icmp eq i64 %87, %12
br i1 %88, label %89, label %80
89: ; preds = %80, %70
%90 = phi i32 [ %75, %70 ], [ %86, %80 ]
%91 = icmp eq i32 %90, 0
br i1 %91, label %92, label %93
92: ; preds = %6, %89
br label %93
93: ; preds = %89, %92
%94 = phi i32 [ 1, %92 ], [ %90, %89 ]
%95 = icmp sgt i32 %2, 0
br i1 %95, label %96, label %126
96: ; preds = %93
%97 = icmp sgt i32 %1, 0
%98 = add nsw i32 %8, -1
%99 = sext i32 %1 to i64
%100 = zext i32 %2 to i64
%101 = zext i32 %1 to i64
br label %102
102: ; preds = %96, %122
%103 = phi i64 [ 0, %96 ], [ %124, %122 ]
%104 = getelementptr inbounds i8*, i8** %4, i64 %103
%105 = load i8*, i8** %104
%106 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i8* %105)
br i1 %97, label %107, label %122
107: ; preds = %102
%108 = mul nsw i64 %103, %99
br label %109
109: ; preds = %107, %109
%110 = phi i64 [ 0, %107 ], [ %120, %109 ]
%111 = add nsw i64 %110, %108
%112 = getelementptr inbounds i32, i32* %5, i64 %111
%113 = load i32, i32* %112
%114 = mul nsw i32 %113, %98
%115 = sdiv i32 %114, %94
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [6 x i8], [6 x i8]* @.str, i64 0, i64 %116
%118 = load i8, i8* %117
%119 = tail call i32 @fputc(i8 signext %118, i32* %0)
%120 = add nuw nsw i64 %110, 1
%121 = icmp eq i64 %120, %101
br i1 %121, label %122, label %109
122: ; preds = %109, %102
%123 = tail call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 10, i32* %0)
%124 = add nuw nsw i64 %103, 1
%125 = icmp eq i64 %124, %100
br i1 %125, label %126, label %102
126: ; preds = %122, %93
%127 = tail call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 10, i32* %0)
%128 = shl i32 %1, 3
%129 = tail call i8** @malloc(i32 %128)
%130 = icmp sgt i32 %1, 0
br i1 %130, label %131, label %135
131: ; preds = %126
%132 = bitcast i8** %129 to i8*
%133 = zext i32 %1 to i64
%134 = shl nuw nsw i64 %133, 3
br label %135
135: ; preds = %131, %126
%136 = zext i32 %1 to i64
br label %137
137: ; preds = %135, %158
%138 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0))
br i1 %130, label %141, label %139
139: ; preds = %137
%140 = tail call i32 @fputc(i8 signext 10, i32* %0)
br label %161
141: ; preds = %137, %154
%142 = phi i64 [ %156, %154 ], [ 0, %137 ]
%143 = phi i32 [ %155, %154 ], [ 0, %137 ]
%144 = getelementptr inbounds i8*, i8** %129, i64 %142
%145 = load i8*, i8** %144
%146 = load i8, i8* %145
%147 = icmp eq i8 %146, 0
br i1 %147, label %152, label %148
148: ; preds = %141
%149 = tail call i32 @fputc(i8 signext %146, i32* %0)
%150 = getelementptr inbounds i8, i8* %145, i64 1
store i8* %150, i8** %144
%151 = add nsw i32 %143, 1
br label %154
152: ; preds = %141
%153 = tail call i32 @fputc(i8 signext 32, i32* %0)
br label %154
154: ; preds = %148, %152
%155 = phi i32 [ %151, %148 ], [ %143, %152 ]
%156 = add nuw nsw i64 %142, 1
%157 = icmp eq i64 %156, %136
br i1 %157, label %158, label %141
158: ; preds = %154
%159 = tail call i32 @fputc(i8 signext 10, i32* %0)
%160 = icmp eq i32 %155, 0
br i1 %160, label %161, label %137
161: ; preds = %158, %139
%162 = tail call i32 @free(i8** %129)
ret void
}