#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*/ marca_ghost(char **, int *);
scalar_t__ pow(int, int);
int /*<<< orphan*/ print_maze(char **);
int sqrt(scalar_t__);
int /*<<< orphan*/ zera_vetor(int *);
void anda(int ghost[3], char maze[23][30], int target[2]) {
  int dist[4], i = 0, j = 0, menor = 0, vet[8];
  while (maze[ghost[0]][ghost[1] + 1] != 'T' ||
         maze[ghost[0]][ghost[1] - 1] != 'T' ||
         maze[ghost[0] + 1][ghost[1]] != 'T' ||
         maze[ghost[0] - 1][ghost[1]] != 'T') {
    if (maze[ghost[0]][ghost[1] + 1] != '7' ||
        maze[ghost[0]][ghost[1] - 1] != '7' ||
        maze[ghost[0] + 1][ghost[1]] != '7' ||
        maze[ghost[0] - 1][ghost[1]] != '7') {
      if (maze[ghost[0] - 1][ghost[1]] != '0' &&
          maze[ghost[0] - 1][ghost[1]] != 'B') {
        ghost[0]--;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0]][ghost[1] - 1] != '0' &&
                 maze[ghost[0]][ghost[1] - 1] != 'B') {
        ghost[1]--;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0] + 1][ghost[1]] != '0' &&
                 maze[ghost[0] + 1][ghost[1]] != 'B') {
        ghost[0]++;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0]][ghost[1] + 1] != '0' &&
                 maze[ghost[0]][ghost[1] + 1] != 'B') {
        ghost[1]++;
        marca_ghost(maze, ghost);
        print_maze(maze);
      }
    } else if (maze[ghost[0]][ghost[1] + 1] == '7' ||
               (maze[ghost[0]][ghost[1] - 1] == '7') ||
               (maze[ghost[0] + 1][ghost[1]] == '7') ||
               (maze[ghost[0] - 1][ghost[1]] == '7')) {
      vet[0] = ghost[0];
      vet[1] = ghost[1] + 2;
      vet[2] = ghost[0];
      vet[3] = ghost[1] - 2;
      vet[4] = ghost[0] + 2;
      vet[5] = ghost[1];
      vet[6] = ghost[0] - 2;
      vet[7] = ghost[1];
      zera_vetor(dist);
      if (maze[vet[0]][vet[1]] != '0') {
        dist[0] =
            sqrt(pow((vet[0] - target[0]), 2) + pow((vet[1] - target[1]), 2));
      } else if (maze[vet[2]][vet[3]] != '0') {
        dist[1] =
            sqrt(pow((vet[2] - target[0]), 2) + pow((vet[3] - target[1]), 2));
      } else if (maze[vet[4]][vet[5]] != '0') {
        dist[2] =
            sqrt(pow((vet[4] - target[0]), 2) + pow((vet[5] - target[1]), 2));
      } else if (maze[vet[6]][vet[7]] != '0') {
        dist[3] =
            sqrt(pow((vet[6] - target[0]), 2) + pow((vet[7] - target[1]), 2));
      }
      for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
          if (dist[i] < dist[j]) {
            menor = dist[i];
          } else if (dist[j] < dist[i]) {
            menor = dist[j];
          }
        }
      }
      if (menor == dist[0]) {
        maze[ghost[0]][ghost[1] + 2] = 'B';
        print_maze(maze);
      } else if (menor == dist[1]) {
        maze[ghost[0]][ghost[1] - 2] = 'B';
        print_maze(maze);
      } else if (menor == dist[2]) {
        maze[ghost[0] + 2][ghost[1]] = 'B';
        print_maze(maze);
      } else if (menor == dist[3]) {
        maze[ghost[0] - 2][ghost[1]] = 'B';
        print_maze(maze);
      }
    }
  }
}


x86 assembly (clang, -O0):
<anda>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x54,%ecx
mov    %al,-0x61(%rbp)
jne    123b <anda+0xeb>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x54,%ecx
mov    %al,-0x61(%rbp)
jne    123b <anda+0xeb>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x54,%ecx
mov    %al,-0x61(%rbp)
jne    123b <anda+0xeb>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x54,%eax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    124b <anda+0xfb>
jmp    1944 <anda+0x7f4>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
jne    12fb <anda+0x1ab>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
jne    12fb <anda+0x1ab>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
jne    12fb <anda+0x1ab>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
je     1506 <anda+0x3b6>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     1379 <anda+0x229>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x42,%eax
je     1379 <anda+0x229>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <marca_ghost@plt>
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    1501 <anda+0x3b1>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     13f9 <anda+0x2a9>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x42,%eax
je     13f9 <anda+0x2a9>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <marca_ghost@plt>
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    14fc <anda+0x3ac>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     1477 <anda+0x327>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x42,%eax
je     1477 <anda+0x327>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <marca_ghost@plt>
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    14f7 <anda+0x3a7>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     14f2 <anda+0x3a2>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x42,%eax
je     14f2 <anda+0x3a2>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <marca_ghost@plt>
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    14f7 <anda+0x3a7>
jmp    14fc <anda+0x3ac>
jmp    1501 <anda+0x3b1>
jmp    193f <anda+0x7ef>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
je     15b6 <anda+0x466>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
je     15b6 <anda+0x466>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
je     15b6 <anda+0x466>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
jne    193a <anda+0x7ea>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
sub    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
sub    $0x2,%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x44(%rbp)
lea    -0x30(%rbp),%rdi
call   1040 <zera_vetor@plt>
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     1676 <anda+0x526>
mov    -0x60(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    (%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,-0x70(%rbp)
mov    -0x5c(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    0x4(%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    -0x70(%rbp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    %eax,-0x30(%rbp)
jmp    17a3 <anda+0x653>
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     16d5 <anda+0x585>
mov    -0x58(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    (%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,-0x78(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    0x4(%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    -0x78(%rbp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    %eax,-0x2c(%rbp)
jmp    179e <anda+0x64e>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     1734 <anda+0x5e4>
mov    -0x50(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    (%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,-0x80(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    0x4(%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    -0x80(%rbp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    %eax,-0x28(%rbp)
jmp    1799 <anda+0x649>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
je     1794 <anda+0x644>
mov    -0x48(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    (%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,-0x88(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x18(%rbp),%rax
sub    0x4(%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    -0x88(%rbp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    %eax,-0x24(%rbp)
jmp    1799 <anda+0x649>
jmp    179e <anda+0x64e>
jmp    17a3 <anda+0x653>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1837 <anda+0x6e7>
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    1824 <anda+0x6d4>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
movslq -0x38(%rbp),%rcx
cmp    -0x30(%rbp,%rcx,4),%eax
jge    17eb <anda+0x69b>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1811 <anda+0x6c1>
movslq -0x38(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
movslq -0x34(%rbp),%rcx
cmp    -0x30(%rbp,%rcx,4),%eax
jge    180c <anda+0x6bc>
movslq -0x38(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1811 <anda+0x6c1>
jmp    1816 <anda+0x6c6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17bb <anda+0x66b>
jmp    1829 <anda+0x6d9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17aa <anda+0x65a>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1874 <anda+0x724>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x42,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    1935 <anda+0x7e5>
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    18b1 <anda+0x761>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x42,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    1930 <anda+0x7e0>
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    18ee <anda+0x79e>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movb   $0x42,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    192b <anda+0x7db>
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1926 <anda+0x7d6>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movb   $0x42,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
call   1070 <print_maze@plt>
jmp    192b <anda+0x7db>
jmp    1930 <anda+0x7e0>
jmp    1935 <anda+0x7e5>
jmp    193a <anda+0x7ea>
jmp    193f <anda+0x7ef>
jmp    117c <anda+0x2c>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<anda>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x8(%rsp)
mov    %rsi,%r15
mov    %rdi,%r13
xor    %r14d,%r14d
nopl   0x0(%rax)
movslq 0x0(%r13),%r12
movslq 0x4(%r13),%rbx
lea    0x1(%rbx),%r8
mov    %r12,%rbp
shl    $0x5,%rbp
sub    %r12,%rbp
sub    %r12,%rbp
add    %r15,%rbp
mov    0x1(%rbx,%rbp,1),%dl
lea    -0x1(%rbx),%r9
lea    (%rbx,%rbp,1),%rsi
add    $0xffffffffffffffff,%rsi
lea    0x1(%r12),%r10d
lea    (%rbx,%rbp,1),%rax
add    $0x1e,%rax
lea    -0x1(%r12),%r11d
lea    (%rbx,%rbp,1),%rdi
add    $0xffffffffffffffe2,%rdi
cs nopw 0x0(%rax,%rax,1)
cmp    $0x37,%dl
je     11e0 <anda+0x90>
cmp    $0x54,%dl
jne    11f0 <anda+0xa0>
cmpb   $0x54,(%rsi)
jne    11f0 <anda+0xa0>
cmpb   $0x54,(%rax)
jne    11f0 <anda+0xa0>
cmpb   $0x54,(%rdi)
jne    11f0 <anda+0xa0>
jmp    14fa <anda+0x3aa>
xchg   %ax,%ax
cmpb   $0x37,(%rsi)
jne    11f0 <anda+0xa0>
cmpb   $0x37,(%rax)
jne    11f0 <anda+0xa0>
cmpb   $0x37,(%rdi)
je     126c <anda+0x11c>
nop
movzbl (%rdi),%ecx
cmp    $0x30,%cl
je     11fd <anda+0xad>
cmp    $0x42,%cl
jne    1230 <anda+0xe0>
movzbl (%rsi),%ecx
cmp    $0x30,%cl
je     120a <anda+0xba>
cmp    $0x42,%cl
jne    1240 <anda+0xf0>
movzbl (%rax),%ecx
cmp    $0x30,%cl
je     1217 <anda+0xc7>
cmp    $0x42,%cl
jne    1250 <anda+0x100>
cmp    $0x30,%dl
je     11c0 <anda+0x70>
cmp    $0x42,%dl
je     11c0 <anda+0x70>
mov    %r8d,0x4(%r13)
jmp    1254 <anda+0x104>
nopw   0x0(%rax,%rax,1)
mov    %r11d,0x0(%r13)
jmp    1254 <anda+0x104>
cs nopw 0x0(%rax,%rax,1)
mov    %r9d,0x4(%r13)
jmp    1254 <anda+0x104>
cs nopw 0x0(%rax,%rax,1)
mov    %r10d,0x0(%r13)
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <marca_ghost@plt>
mov    %r15,%rdi
call   1070 <print_maze@plt>
jmp    1170 <anda+0x20>
lea    0x10(%rsp),%rdi
call   1040 <zera_vetor@plt>
cmpb   $0x30,0x2(%rbx,%rbp,1)
jne    130c <anda+0x1bc>
lea    -0x2(%rbx),%rcx
cmpb   $0x30,(%rcx,%rbp,1)
jne    134e <anda+0x1fe>
lea    0x2(%r12),%rdi
mov    %rdi,%rax
shl    $0x5,%rax
sub    %rdi,%rax
sub    %rdi,%rax
add    %r15,%rax
cmpb   $0x30,(%rbx,%rax,1)
jne    1390 <anda+0x240>
add    $0xfffffffffffffffe,%r12
mov    %r12,%rax
shl    $0x5,%rax
sub    %r12,%rax
sub    %r12,%rax
add    %r15,%rax
cmpb   $0x30,(%rbx,%rax,1)
je     13c6 <anda+0x276>
mov    0x8(%rsp),%rax
sub    (%rax),%r12d
mov    %r12d,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%rax
sub    0x4(%rax),%ebx
mov    %ebx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
add    %rax,%rbp
mov    %rbp,%rdi
call   1060 <sqrt@plt>
mov    %eax,0x1c(%rsp)
jmp    13c6 <anda+0x276>
add    $0x2,%ebx
mov    0x8(%rsp),%rax
mov    (%rax),%eax
sub    %eax,%r12d
mov    %r12d,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%rax
sub    0x4(%rax),%ebx
mov    %ebx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
add    %rax,%rbp
mov    %rbp,%rdi
call   1060 <sqrt@plt>
mov    %eax,0x10(%rsp)
jmp    13c6 <anda+0x276>
mov    0x8(%rsp),%rax
mov    (%rax),%eax
sub    %eax,%r12d
mov    %rcx,%rbp
mov    %r12d,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,%rbx
mov    0x8(%rsp),%rax
sub    0x4(%rax),%ebp
mov    %ebp,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
add    %rax,%rbx
mov    %rbx,%rdi
call   1060 <sqrt@plt>
mov    %eax,0x14(%rsp)
jmp    13c6 <anda+0x276>
mov    0x8(%rsp),%r12
sub    (%r12),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,%rbp
sub    0x4(%r12),%ebx
mov    %ebx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
add    %rax,%rbp
mov    %rbp,%rdi
call   1060 <sqrt@plt>
mov    %eax,0x18(%rsp)
mov    0x10(%rsp),%edx
mov    0x14(%rsp),%eax
cmp    %edx,%eax
cmovl  %eax,%r14d
cmovg  %edx,%r14d
mov    0x18(%rsp),%ecx
cmp    %edx,%ecx
cmovl  %ecx,%r14d
cmovg  %edx,%r14d
mov    0x1c(%rsp),%esi
cmp    %edx,%esi
cmovl  %esi,%r14d
cmovg  %edx,%r14d
cmp    %eax,%edx
cmovl  %edx,%r14d
cmovg  %eax,%r14d
cmp    %eax,%ecx
cmovl  %ecx,%r14d
cmovg  %eax,%r14d
cmp    %eax,%esi
cmovl  %esi,%r14d
cmovg  %eax,%r14d
cmp    %ecx,%edx
cmovl  %edx,%r14d
cmovg  %ecx,%r14d
cmp    %ecx,%eax
cmovl  %eax,%r14d
cmovg  %ecx,%r14d
cmp    %ecx,%esi
cmovl  %esi,%r14d
cmovg  %ecx,%r14d
cmp    %esi,%edx
cmovl  %edx,%r14d
cmovg  %esi,%r14d
cmp    %esi,%eax
cmovl  %eax,%r14d
cmovg  %esi,%r14d
cmp    %esi,%ecx
cmovl  %ecx,%r14d
cmovg  %esi,%r14d
cmp    %edx,%r14d
jne    1478 <anda+0x328>
movslq 0x0(%r13),%rax
movslq 0x4(%r13),%rcx
mov    %rax,%rsi
shl    $0x5,%rsi
sub    %rax,%rsi
sub    %rax,%rsi
add    %r15,%rsi
movb   $0x42,0x2(%rcx,%rsi,1)
mov    %edx,%r14d
jmp    125f <anda+0x10f>
cmp    %eax,%r14d
jne    14a2 <anda+0x352>
movslq 0x0(%r13),%rcx
movslq 0x4(%r13),%rdx
mov    %rcx,%rsi
shl    $0x5,%rsi
sub    %rcx,%rsi
sub    %rcx,%rsi
add    %r15,%rsi
movb   $0x42,-0x2(%rdx,%rsi,1)
mov    %eax,%r14d
jmp    125f <anda+0x10f>
cmp    %ecx,%r14d
jne    14cc <anda+0x37c>
movslq 0x0(%r13),%rax
mov    %rax,%rdx
shl    $0x5,%rdx
sub    %rax,%rdx
sub    %rax,%rdx
movslq 0x4(%r13),%rax
add    %r15,%rdx
movb   $0x42,0x3c(%rax,%rdx,1)
mov    %ecx,%r14d
jmp    125f <anda+0x10f>
cmp    %esi,%r14d
jne    1170 <anda+0x20>
movslq 0x0(%r13),%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
movslq 0x4(%r13),%rax
add    %r15,%rcx
movb   $0x42,-0x3c(%rax,%rcx,1)
mov    %esi,%r14d
jmp    125f <anda+0x10f>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @anda(i32* %0, [30 x i8]* %1, i32* %2) {
%4 = alloca i32*
%5 = alloca [30 x i8]*
%6 = alloca i32*
%7 = alloca [4 x i32]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [8 x i32]
store i32* %0, i32** %4
store [30 x i8]* %1, [30 x i8]** %5
store i32* %2, i32** %6
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
br label %12
12: ; preds = %687, %3
%13 = load [30 x i8]*, [30 x i8]** %5
%14 = load i32*, i32** %4
%15 = getelementptr inbounds i32, i32* %14, i64 0
%16 = load i32, i32* %15
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [30 x i8], [30 x i8]* %13, i64 %17
%19 = load i32*, i32** %4
%20 = getelementptr inbounds i32, i32* %19, i64 1
%21 = load i32, i32* %20
%22 = add nsw i32 %21, 1
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [30 x i8], [30 x i8]* %18, i64 0, i64 %23
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp ne i32 %26, 84
br i1 %27, label %76, label %28
28: ; preds = %12
%29 = load [30 x i8]*, [30 x i8]** %5
%30 = load i32*, i32** %4
%31 = getelementptr inbounds i32, i32* %30, i64 0
%32 = load i32, i32* %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [30 x i8], [30 x i8]* %29, i64 %33
%35 = load i32*, i32** %4
%36 = getelementptr inbounds i32, i32* %35, i64 1
%37 = load i32, i32* %36
%38 = sub nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [30 x i8], [30 x i8]* %34, i64 0, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = icmp ne i32 %42, 84
br i1 %43, label %76, label %44
44: ; preds = %28
%45 = load [30 x i8]*, [30 x i8]** %5
%46 = load i32*, i32** %4
%47 = getelementptr inbounds i32, i32* %46, i64 0
%48 = load i32, i32* %47
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [30 x i8], [30 x i8]* %45, i64 %50
%52 = load i32*, i32** %4
%53 = getelementptr inbounds i32, i32* %52, i64 1
%54 = load i32, i32* %53
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [30 x i8], [30 x i8]* %51, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp ne i32 %58, 84
br i1 %59, label %76, label %60
60: ; preds = %44
%61 = load [30 x i8]*, [30 x i8]** %5
%62 = load i32*, i32** %4
%63 = getelementptr inbounds i32, i32* %62, i64 0
%64 = load i32, i32* %63
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [30 x i8], [30 x i8]* %61, i64 %66
%68 = load i32*, i32** %4
%69 = getelementptr inbounds i32, i32* %68, i64 1
%70 = load i32, i32* %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [30 x i8], [30 x i8]* %67, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp ne i32 %74, 84
br label %76
76: ; preds = %60, %44, %28, %12
%77 = phi i1 [ true, %44 ], [ true, %28 ], [ true, %12 ], [ %75, %60 ]
br i1 %77, label %78, label %688
78: ; preds = %76
%79 = load [30 x i8]*, [30 x i8]** %5
%80 = load i32*, i32** %4
%81 = getelementptr inbounds i32, i32* %80, i64 0
%82 = load i32, i32* %81
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [30 x i8], [30 x i8]* %79, i64 %83
%85 = load i32*, i32** %4
%86 = getelementptr inbounds i32, i32* %85, i64 1
%87 = load i32, i32* %86
%88 = add nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [30 x i8], [30 x i8]* %84, i64 0, i64 %89
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = icmp ne i32 %92, 55
br i1 %93, label %142, label %94
94: ; preds = %78
%95 = load [30 x i8]*, [30 x i8]** %5
%96 = load i32*, i32** %4
%97 = getelementptr inbounds i32, i32* %96, i64 0
%98 = load i32, i32* %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [30 x i8], [30 x i8]* %95, i64 %99
%101 = load i32*, i32** %4
%102 = getelementptr inbounds i32, i32* %101, i64 1
%103 = load i32, i32* %102
%104 = sub nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [30 x i8], [30 x i8]* %100, i64 0, i64 %105
%107 = load i8, i8* %106
%108 = sext i8 %107 to i32
%109 = icmp ne i32 %108, 55
br i1 %109, label %142, label %110
110: ; preds = %94
%111 = load [30 x i8]*, [30 x i8]** %5
%112 = load i32*, i32** %4
%113 = getelementptr inbounds i32, i32* %112, i64 0
%114 = load i32, i32* %113
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [30 x i8], [30 x i8]* %111, i64 %116
%118 = load i32*, i32** %4
%119 = getelementptr inbounds i32, i32* %118, i64 1
%120 = load i32, i32* %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [30 x i8], [30 x i8]* %117, i64 0, i64 %121
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp ne i32 %124, 55
br i1 %125, label %142, label %126
126: ; preds = %110
%127 = load [30 x i8]*, [30 x i8]** %5
%128 = load i32*, i32** %4
%129 = getelementptr inbounds i32, i32* %128, i64 0
%130 = load i32, i32* %129
%131 = sub nsw i32 %130, 1
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [30 x i8], [30 x i8]* %127, i64 %132
%134 = load i32*, i32** %4
%135 = getelementptr inbounds i32, i32* %134, i64 1
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [30 x i8], [30 x i8]* %133, i64 0, i64 %137
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = icmp ne i32 %140, 55
br i1 %141, label %142, label %322
142: ; preds = %126, %110, %94, %78
%143 = load [30 x i8]*, [30 x i8]** %5
%144 = load i32*, i32** %4
%145 = getelementptr inbounds i32, i32* %144, i64 0
%146 = load i32, i32* %145
%147 = sub nsw i32 %146, 1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [30 x i8], [30 x i8]* %143, i64 %148
%150 = load i32*, i32** %4
%151 = getelementptr inbounds i32, i32* %150, i64 1
%152 = load i32, i32* %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [30 x i8], [30 x i8]* %149, i64 0, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = icmp ne i32 %156, 48
br i1 %157, label %158, label %186
158: ; preds = %142
%159 = load [30 x i8]*, [30 x i8]** %5
%160 = load i32*, i32** %4
%161 = getelementptr inbounds i32, i32* %160, i64 0
%162 = load i32, i32* %161
%163 = sub nsw i32 %162, 1
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [30 x i8], [30 x i8]* %159, i64 %164
%166 = load i32*, i32** %4
%167 = getelementptr inbounds i32, i32* %166, i64 1
%168 = load i32, i32* %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [30 x i8], [30 x i8]* %165, i64 0, i64 %169
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp ne i32 %172, 66
br i1 %173, label %174, label %186
174: ; preds = %158
%175 = load i32*, i32** %4
%176 = getelementptr inbounds i32, i32* %175, i64 0
%177 = load i32, i32* %176
%178 = add nsw i32 %177, -1
store i32 %178, i32* %176
%179 = load [30 x i8]*, [30 x i8]** %5
%180 = bitcast [30 x i8]* %179 to i8**
%181 = load i32*, i32** %4
%182 = call i32 @marca_ghost(i8** %180, i32* %181)
%183 = load [30 x i8]*, [30 x i8]** %5
%184 = bitcast [30 x i8]* %183 to i8**
%185 = call i32 @print_maze(i8** %184)
br label %321
186: ; preds = %158, %142
%187 = load [30 x i8]*, [30 x i8]** %5
%188 = load i32*, i32** %4
%189 = getelementptr inbounds i32, i32* %188, i64 0
%190 = load i32, i32* %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [30 x i8], [30 x i8]* %187, i64 %191
%193 = load i32*, i32** %4
%194 = getelementptr inbounds i32, i32* %193, i64 1
%195 = load i32, i32* %194
%196 = sub nsw i32 %195, 1
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [30 x i8], [30 x i8]* %192, i64 0, i64 %197
%199 = load i8, i8* %198
%200 = sext i8 %199 to i32
%201 = icmp ne i32 %200, 48
br i1 %201, label %202, label %230
202: ; preds = %186
%203 = load [30 x i8]*, [30 x i8]** %5
%204 = load i32*, i32** %4
%205 = getelementptr inbounds i32, i32* %204, i64 0
%206 = load i32, i32* %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [30 x i8], [30 x i8]* %203, i64 %207
%209 = load i32*, i32** %4
%210 = getelementptr inbounds i32, i32* %209, i64 1
%211 = load i32, i32* %210
%212 = sub nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [30 x i8], [30 x i8]* %208, i64 0, i64 %213
%215 = load i8, i8* %214
%216 = sext i8 %215 to i32
%217 = icmp ne i32 %216, 66
br i1 %217, label %218, label %230
218: ; preds = %202
%219 = load i32*, i32** %4
%220 = getelementptr inbounds i32, i32* %219, i64 1
%221 = load i32, i32* %220
%222 = add nsw i32 %221, -1
store i32 %222, i32* %220
%223 = load [30 x i8]*, [30 x i8]** %5
%224 = bitcast [30 x i8]* %223 to i8**
%225 = load i32*, i32** %4
%226 = call i32 @marca_ghost(i8** %224, i32* %225)
%227 = load [30 x i8]*, [30 x i8]** %5
%228 = bitcast [30 x i8]* %227 to i8**
%229 = call i32 @print_maze(i8** %228)
br label %320
230: ; preds = %202, %186
%231 = load [30 x i8]*, [30 x i8]** %5
%232 = load i32*, i32** %4
%233 = getelementptr inbounds i32, i32* %232, i64 0
%234 = load i32, i32* %233
%235 = add nsw i32 %234, 1
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [30 x i8], [30 x i8]* %231, i64 %236
%238 = load i32*, i32** %4
%239 = getelementptr inbounds i32, i32* %238, i64 1
%240 = load i32, i32* %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [30 x i8], [30 x i8]* %237, i64 0, i64 %241
%243 = load i8, i8* %242
%244 = sext i8 %243 to i32
%245 = icmp ne i32 %244, 48
br i1 %245, label %246, label %274
246: ; preds = %230
%247 = load [30 x i8]*, [30 x i8]** %5
%248 = load i32*, i32** %4
%249 = getelementptr inbounds i32, i32* %248, i64 0
%250 = load i32, i32* %249
%251 = add nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [30 x i8], [30 x i8]* %247, i64 %252
%254 = load i32*, i32** %4
%255 = getelementptr inbounds i32, i32* %254, i64 1
%256 = load i32, i32* %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [30 x i8], [30 x i8]* %253, i64 0, i64 %257
%259 = load i8, i8* %258
%260 = sext i8 %259 to i32
%261 = icmp ne i32 %260, 66
br i1 %261, label %262, label %274
262: ; preds = %246
%263 = load i32*, i32** %4
%264 = getelementptr inbounds i32, i32* %263, i64 0
%265 = load i32, i32* %264
%266 = add nsw i32 %265, 1
store i32 %266, i32* %264
%267 = load [30 x i8]*, [30 x i8]** %5
%268 = bitcast [30 x i8]* %267 to i8**
%269 = load i32*, i32** %4
%270 = call i32 @marca_ghost(i8** %268, i32* %269)
%271 = load [30 x i8]*, [30 x i8]** %5
%272 = bitcast [30 x i8]* %271 to i8**
%273 = call i32 @print_maze(i8** %272)
br label %319
274: ; preds = %246, %230
%275 = load [30 x i8]*, [30 x i8]** %5
%276 = load i32*, i32** %4
%277 = getelementptr inbounds i32, i32* %276, i64 0
%278 = load i32, i32* %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [30 x i8], [30 x i8]* %275, i64 %279
%281 = load i32*, i32** %4
%282 = getelementptr inbounds i32, i32* %281, i64 1
%283 = load i32, i32* %282
%284 = add nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [30 x i8], [30 x i8]* %280, i64 0, i64 %285
%287 = load i8, i8* %286
%288 = sext i8 %287 to i32
%289 = icmp ne i32 %288, 48
br i1 %289, label %290, label %318
290: ; preds = %274
%291 = load [30 x i8]*, [30 x i8]** %5
%292 = load i32*, i32** %4
%293 = getelementptr inbounds i32, i32* %292, i64 0
%294 = load i32, i32* %293
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [30 x i8], [30 x i8]* %291, i64 %295
%297 = load i32*, i32** %4
%298 = getelementptr inbounds i32, i32* %297, i64 1
%299 = load i32, i32* %298
%300 = add nsw i32 %299, 1
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [30 x i8], [30 x i8]* %296, i64 0, i64 %301
%303 = load i8, i8* %302
%304 = sext i8 %303 to i32
%305 = icmp ne i32 %304, 66
br i1 %305, label %306, label %318
306: ; preds = %290
%307 = load i32*, i32** %4
%308 = getelementptr inbounds i32, i32* %307, i64 1
%309 = load i32, i32* %308
%310 = add nsw i32 %309, 1
store i32 %310, i32* %308
%311 = load [30 x i8]*, [30 x i8]** %5
%312 = bitcast [30 x i8]* %311 to i8**
%313 = load i32*, i32** %4
%314 = call i32 @marca_ghost(i8** %312, i32* %313)
%315 = load [30 x i8]*, [30 x i8]** %5
%316 = bitcast [30 x i8]* %315 to i8**
%317 = call i32 @print_maze(i8** %316)
br label %318
318: ; preds = %306, %290, %274
br label %319
319: ; preds = %318, %262
br label %320
320: ; preds = %319, %218
br label %321
321: ; preds = %320, %174
br label %687
322: ; preds = %126
%323 = load [30 x i8]*, [30 x i8]** %5
%324 = load i32*, i32** %4
%325 = getelementptr inbounds i32, i32* %324, i64 0
%326 = load i32, i32* %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [30 x i8], [30 x i8]* %323, i64 %327
%329 = load i32*, i32** %4
%330 = getelementptr inbounds i32, i32* %329, i64 1
%331 = load i32, i32* %330
%332 = add nsw i32 %331, 1
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [30 x i8], [30 x i8]* %328, i64 0, i64 %333
%335 = load i8, i8* %334
%336 = sext i8 %335 to i32
%337 = icmp eq i32 %336, 55
br i1 %337, label %386, label %338
338: ; preds = %322
%339 = load [30 x i8]*, [30 x i8]** %5
%340 = load i32*, i32** %4
%341 = getelementptr inbounds i32, i32* %340, i64 0
%342 = load i32, i32* %341
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [30 x i8], [30 x i8]* %339, i64 %343
%345 = load i32*, i32** %4
%346 = getelementptr inbounds i32, i32* %345, i64 1
%347 = load i32, i32* %346
%348 = sub nsw i32 %347, 1
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [30 x i8], [30 x i8]* %344, i64 0, i64 %349
%351 = load i8, i8* %350
%352 = sext i8 %351 to i32
%353 = icmp eq i32 %352, 55
br i1 %353, label %386, label %354
354: ; preds = %338
%355 = load [30 x i8]*, [30 x i8]** %5
%356 = load i32*, i32** %4
%357 = getelementptr inbounds i32, i32* %356, i64 0
%358 = load i32, i32* %357
%359 = add nsw i32 %358, 1
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds [30 x i8], [30 x i8]* %355, i64 %360
%362 = load i32*, i32** %4
%363 = getelementptr inbounds i32, i32* %362, i64 1
%364 = load i32, i32* %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [30 x i8], [30 x i8]* %361, i64 0, i64 %365
%367 = load i8, i8* %366
%368 = sext i8 %367 to i32
%369 = icmp eq i32 %368, 55
br i1 %369, label %386, label %370
370: ; preds = %354
%371 = load [30 x i8]*, [30 x i8]** %5
%372 = load i32*, i32** %4
%373 = getelementptr inbounds i32, i32* %372, i64 0
%374 = load i32, i32* %373
%375 = sub nsw i32 %374, 1
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [30 x i8], [30 x i8]* %371, i64 %376
%378 = load i32*, i32** %4
%379 = getelementptr inbounds i32, i32* %378, i64 1
%380 = load i32, i32* %379
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [30 x i8], [30 x i8]* %377, i64 0, i64 %381
%383 = load i8, i8* %382
%384 = sext i8 %383 to i32
%385 = icmp eq i32 %384, 55
br i1 %385, label %386, label %686
386: ; preds = %370, %354, %338, %322
%387 = load i32*, i32** %4
%388 = getelementptr inbounds i32, i32* %387, i64 0
%389 = load i32, i32* %388
%390 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
store i32 %389, i32* %390
%391 = load i32*, i32** %4
%392 = getelementptr inbounds i32, i32* %391, i64 1
%393 = load i32, i32* %392
%394 = add nsw i32 %393, 2
%395 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
store i32 %394, i32* %395
%396 = load i32*, i32** %4
%397 = getelementptr inbounds i32, i32* %396, i64 0
%398 = load i32, i32* %397
%399 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
store i32 %398, i32* %399
%400 = load i32*, i32** %4
%401 = getelementptr inbounds i32, i32* %400, i64 1
%402 = load i32, i32* %401
%403 = sub nsw i32 %402, 2
%404 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
store i32 %403, i32* %404
%405 = load i32*, i32** %4
%406 = getelementptr inbounds i32, i32* %405, i64 0
%407 = load i32, i32* %406
%408 = add nsw i32 %407, 2
%409 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
store i32 %408, i32* %409
%410 = load i32*, i32** %4
%411 = getelementptr inbounds i32, i32* %410, i64 1
%412 = load i32, i32* %411
%413 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
store i32 %412, i32* %413
%414 = load i32*, i32** %4
%415 = getelementptr inbounds i32, i32* %414, i64 0
%416 = load i32, i32* %415
%417 = sub nsw i32 %416, 2
%418 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
store i32 %417, i32* %418
%419 = load i32*, i32** %4
%420 = getelementptr inbounds i32, i32* %419, i64 1
%421 = load i32, i32* %420
%422 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
store i32 %421, i32* %422
%423 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
%424 = call i32 @zera_vetor(i32* %423)
%425 = load [30 x i8]*, [30 x i8]** %5
%426 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
%427 = load i32, i32* %426
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds [30 x i8], [30 x i8]* %425, i64 %428
%430 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
%431 = load i32, i32* %430
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [30 x i8], [30 x i8]* %429, i64 0, i64 %432
%434 = load i8, i8* %433
%435 = sext i8 %434 to i32
%436 = icmp ne i32 %435, 48
br i1 %436, label %437, label %455
437: ; preds = %386
%438 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
%439 = load i32, i32* %438
%440 = load i32*, i32** %6
%441 = getelementptr inbounds i32, i32* %440, i64 0
%442 = load i32, i32* %441
%443 = sub nsw i32 %439, %442
%444 = call i64 @pow(i32 %443, i32 2)
%445 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
%446 = load i32, i32* %445
%447 = load i32*, i32** %6
%448 = getelementptr inbounds i32, i32* %447, i64 1
%449 = load i32, i32* %448
%450 = sub nsw i32 %446, %449
%451 = call i64 @pow(i32 %450, i32 2)
%452 = add nsw i64 %444, %451
%453 = call i32 @sqrt(i64 %452)
%454 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
store i32 %453, i32* %454
br label %551
455: ; preds = %386
%456 = load [30 x i8]*, [30 x i8]** %5
%457 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
%458 = load i32, i32* %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds [30 x i8], [30 x i8]* %456, i64 %459
%461 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
%462 = load i32, i32* %461
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds [30 x i8], [30 x i8]* %460, i64 0, i64 %463
%465 = load i8, i8* %464
%466 = sext i8 %465 to i32
%467 = icmp ne i32 %466, 48
br i1 %467, label %468, label %486
468: ; preds = %455
%469 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
%470 = load i32, i32* %469
%471 = load i32*, i32** %6
%472 = getelementptr inbounds i32, i32* %471, i64 0
%473 = load i32, i32* %472
%474 = sub nsw i32 %470, %473
%475 = call i64 @pow(i32 %474, i32 2)
%476 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
%477 = load i32, i32* %476
%478 = load i32*, i32** %6
%479 = getelementptr inbounds i32, i32* %478, i64 1
%480 = load i32, i32* %479
%481 = sub nsw i32 %477, %480
%482 = call i64 @pow(i32 %481, i32 2)
%483 = add nsw i64 %475, %482
%484 = call i32 @sqrt(i64 %483)
%485 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 1
store i32 %484, i32* %485
br label %550
486: ; preds = %455
%487 = load [30 x i8]*, [30 x i8]** %5
%488 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
%489 = load i32, i32* %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds [30 x i8], [30 x i8]* %487, i64 %490
%492 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
%493 = load i32, i32* %492
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds [30 x i8], [30 x i8]* %491, i64 0, i64 %494
%496 = load i8, i8* %495
%497 = sext i8 %496 to i32
%498 = icmp ne i32 %497, 48
br i1 %498, label %499, label %517
499: ; preds = %486
%500 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
%501 = load i32, i32* %500
%502 = load i32*, i32** %6
%503 = getelementptr inbounds i32, i32* %502, i64 0
%504 = load i32, i32* %503
%505 = sub nsw i32 %501, %504
%506 = call i64 @pow(i32 %505, i32 2)
%507 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
%508 = load i32, i32* %507
%509 = load i32*, i32** %6
%510 = getelementptr inbounds i32, i32* %509, i64 1
%511 = load i32, i32* %510
%512 = sub nsw i32 %508, %511
%513 = call i64 @pow(i32 %512, i32 2)
%514 = add nsw i64 %506, %513
%515 = call i32 @sqrt(i64 %514)
%516 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 2
store i32 %515, i32* %516
br label %549
517: ; preds = %486
%518 = load [30 x i8]*, [30 x i8]** %5
%519 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
%520 = load i32, i32* %519
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds [30 x i8], [30 x i8]* %518, i64 %521
%523 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
%524 = load i32, i32* %523
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [30 x i8], [30 x i8]* %522, i64 0, i64 %525
%527 = load i8, i8* %526
%528 = sext i8 %527 to i32
%529 = icmp ne i32 %528, 48
br i1 %529, label %530, label %548
530: ; preds = %517
%531 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
%532 = load i32, i32* %531
%533 = load i32*, i32** %6
%534 = getelementptr inbounds i32, i32* %533, i64 0
%535 = load i32, i32* %534
%536 = sub nsw i32 %532, %535
%537 = call i64 @pow(i32 %536, i32 2)
%538 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
%539 = load i32, i32* %538
%540 = load i32*, i32** %6
%541 = getelementptr inbounds i32, i32* %540, i64 1
%542 = load i32, i32* %541
%543 = sub nsw i32 %539, %542
%544 = call i64 @pow(i32 %543, i32 2)
%545 = add nsw i64 %537, %544
%546 = call i32 @sqrt(i64 %545)
%547 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 3
store i32 %546, i32* %547
br label %548
548: ; preds = %530, %517
br label %549
549: ; preds = %548, %499
br label %550
550: ; preds = %549, %468
br label %551
551: ; preds = %550, %437
store i32 0, i32* %8
br label %552
552: ; preds = %595, %551
%553 = load i32, i32* %8
%554 = icmp slt i32 %553, 4
br i1 %554, label %555, label %598
555: ; preds = %552
store i32 0, i32* %9
br label %556
556: ; preds = %591, %555
%557 = load i32, i32* %9
%558 = icmp slt i32 %557, 4
br i1 %558, label %559, label %594
559: ; preds = %556
%560 = load i32, i32* %8
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %561
%563 = load i32, i32* %562
%564 = load i32, i32* %9
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %565
%567 = load i32, i32* %566
%568 = icmp slt i32 %563, %567
br i1 %568, label %569, label %574
569: ; preds = %559
%570 = load i32, i32* %8
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %571
%573 = load i32, i32* %572
store i32 %573, i32* %10
br label %590
574: ; preds = %559
%575 = load i32, i32* %9
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %576
%578 = load i32, i32* %577
%579 = load i32, i32* %8
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %580
%582 = load i32, i32* %581
%583 = icmp slt i32 %578, %582
br i1 %583, label %584, label %589
584: ; preds = %574
%585 = load i32, i32* %9
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %586
%588 = load i32, i32* %587
store i32 %588, i32* %10
br label %589
589: ; preds = %584, %574
br label %590
590: ; preds = %589, %569
br label %591
591: ; preds = %590
%592 = load i32, i32* %9
%593 = add nsw i32 %592, 1
store i32 %593, i32* %9
br label %556
594: ; preds = %556
br label %595
595: ; preds = %594
%596 = load i32, i32* %8
%597 = add nsw i32 %596, 1
store i32 %597, i32* %8
br label %552
598: ; preds = %552
%599 = load i32, i32* %10
%600 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
%601 = load i32, i32* %600
%602 = icmp eq i32 %599, %601
br i1 %602, label %603, label %619
603: ; preds = %598
%604 = load [30 x i8]*, [30 x i8]** %5
%605 = load i32*, i32** %4
%606 = getelementptr inbounds i32, i32* %605, i64 0
%607 = load i32, i32* %606
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds [30 x i8], [30 x i8]* %604, i64 %608
%610 = load i32*, i32** %4
%611 = getelementptr inbounds i32, i32* %610, i64 1
%612 = load i32, i32* %611
%613 = add nsw i32 %612, 2
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds [30 x i8], [30 x i8]* %609, i64 0, i64 %614
store i8 66, i8* %615
%616 = load [30 x i8]*, [30 x i8]** %5
%617 = bitcast [30 x i8]* %616 to i8**
%618 = call i32 @print_maze(i8** %617)
br label %685
619: ; preds = %598
%620 = load i32, i32* %10
%621 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 1
%622 = load i32, i32* %621
%623 = icmp eq i32 %620, %622
br i1 %623, label %624, label %640
624: ; preds = %619
%625 = load [30 x i8]*, [30 x i8]** %5
%626 = load i32*, i32** %4
%627 = getelementptr inbounds i32, i32* %626, i64 0
%628 = load i32, i32* %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds [30 x i8], [30 x i8]* %625, i64 %629
%631 = load i32*, i32** %4
%632 = getelementptr inbounds i32, i32* %631, i64 1
%633 = load i32, i32* %632
%634 = sub nsw i32 %633, 2
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds [30 x i8], [30 x i8]* %630, i64 0, i64 %635
store i8 66, i8* %636
%637 = load [30 x i8]*, [30 x i8]** %5
%638 = bitcast [30 x i8]* %637 to i8**
%639 = call i32 @print_maze(i8** %638)
br label %684
640: ; preds = %619
%641 = load i32, i32* %10
%642 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 2
%643 = load i32, i32* %642
%644 = icmp eq i32 %641, %643
br i1 %644, label %645, label %661
645: ; preds = %640
%646 = load [30 x i8]*, [30 x i8]** %5
%647 = load i32*, i32** %4
%648 = getelementptr inbounds i32, i32* %647, i64 0
%649 = load i32, i32* %648
%650 = add nsw i32 %649, 2
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds [30 x i8], [30 x i8]* %646, i64 %651
%653 = load i32*, i32** %4
%654 = getelementptr inbounds i32, i32* %653, i64 1
%655 = load i32, i32* %654
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds [30 x i8], [30 x i8]* %652, i64 0, i64 %656
store i8 66, i8* %657
%658 = load [30 x i8]*, [30 x i8]** %5
%659 = bitcast [30 x i8]* %658 to i8**
%660 = call i32 @print_maze(i8** %659)
br label %683
661: ; preds = %640
%662 = load i32, i32* %10
%663 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 3
%664 = load i32, i32* %663
%665 = icmp eq i32 %662, %664
br i1 %665, label %666, label %682
666: ; preds = %661
%667 = load [30 x i8]*, [30 x i8]** %5
%668 = load i32*, i32** %4
%669 = getelementptr inbounds i32, i32* %668, i64 0
%670 = load i32, i32* %669
%671 = sub nsw i32 %670, 2
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds [30 x i8], [30 x i8]* %667, i64 %672
%674 = load i32*, i32** %4
%675 = getelementptr inbounds i32, i32* %674, i64 1
%676 = load i32, i32* %675
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds [30 x i8], [30 x i8]* %673, i64 0, i64 %677
store i8 66, i8* %678
%679 = load [30 x i8]*, [30 x i8]** %5
%680 = bitcast [30 x i8]* %679 to i8**
%681 = call i32 @print_maze(i8** %680)
br label %682
682: ; preds = %666, %661
br label %683
683: ; preds = %682, %645
br label %684
684: ; preds = %683, %624
br label %685
685: ; preds = %684, %603
br label %686
686: ; preds = %685, %370
br label %687
687: ; preds = %686, %321
br label %12
688: ; preds = %76
ret void
}

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