#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[2], 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') {
    while (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') {
        ghost[1]++;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0]][ghost[1] - 1] != '0') {
        ghost[1]--;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0] + 1][ghost[1]] != '0') {
        ghost[0]++;
        marca_ghost(maze, ghost);
        print_maze(maze);
      } else if (maze[ghost[0]][ghost[1] - 1] != '0') {
        ghost[1]--;
        marca_ghost(maze, ghost);
        print_maze(maze);
      }
    }
    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));
    }
    if (maze[vet[2]][vet[3]] != '0') {
      dist[1] =
          sqrt(pow((vet[2] - target[0]), 2) + pow((vet[3] - target[1]), 2));
    }
    if (maze[vet[4]][vet[5]] != '0') {
      dist[2] =
          sqrt(pow((vet[4] - target[0]), 2) + pow((vet[5] - target[1]), 2));
    }
    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 = vet[i];
        } else if (dist[j] > dist[i]) {
          menor = vet[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    1892 <anda+0x742>
jmp    1250 <anda+0x100>
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    $0x37,%ecx
mov    %al,-0x62(%rbp)
jne    130f <anda+0x1bf>
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    $0x37,%ecx
mov    %al,-0x62(%rbp)
jne    130f <anda+0x1bf>
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    $0x37,%ecx
mov    %al,-0x62(%rbp)
jne    130f <anda+0x1bf>
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
setne  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    131f <anda+0x1cf>
jmp    147c <anda+0x32c>
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     1373 <anda+0x223>
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    1477 <anda+0x327>
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     13c7 <anda+0x277>
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    1472 <anda+0x322>
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     1419 <anda+0x2c9>
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    146d <anda+0x31d>
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     1468 <anda+0x318>
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    146d <anda+0x31d>
jmp    1472 <anda+0x322>
jmp    1477 <anda+0x327>
jmp    1250 <anda+0x100>
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     152c <anda+0x3dc>
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     152c <anda+0x3dc>
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     152c <anda+0x3dc>
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    1584 <anda+0x434>
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     15e7 <anda+0x497>
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)
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     1641 <anda+0x4f1>
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)
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     169b <anda+0x54b>
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)
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     16fb <anda+0x5ab>
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)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    178f <anda+0x63f>
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    177c <anda+0x62c>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
movslq -0x38(%rbp),%rcx
cmp    -0x30(%rbp,%rcx,4),%eax
jge    1743 <anda+0x5f3>
movslq -0x34(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1769 <anda+0x619>
movslq -0x38(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
movslq -0x34(%rbp),%rcx
cmp    -0x30(%rbp,%rcx,4),%eax
jle    1764 <anda+0x614>
movslq -0x38(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1769 <anda+0x619>
jmp    176e <anda+0x61e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1713 <anda+0x5c3>
jmp    1781 <anda+0x631>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1702 <anda+0x5b2>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    17cc <anda+0x67c>
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    188d <anda+0x73d>
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1809 <anda+0x6b9>
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    1888 <anda+0x738>
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1846 <anda+0x6f6>
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    1883 <anda+0x733>
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    187e <anda+0x72e>
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    1883 <anda+0x733>
jmp    1888 <anda+0x738>
jmp    188d <anda+0x73d>
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    $0x48,%rsp
mov    %rdx,0x10(%rsp)
mov    %rsi,%r13
mov    %rdi,%r15
xor    %ebp,%ebp
jmp    1194 <anda+0x44>
nopl   (%rax)
movslq (%r15),%rax
movslq 0x4(%r15),%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
sub    %rax,%rdx
sub    %rax,%rdx
add    %r13,%rdx
movb   $0x42,0x2(%rcx,%rdx,1)
mov    %r13,%rdi
call   1070 <print_maze@plt>
mov    (%r15),%r12d
mov    0x4(%r15),%ebx
movslq %r12d,%rdx
movslq %ebx,%rax
mov    %rdx,%rcx
shl    $0x5,%rcx
sub    %rdx,%rcx
sub    %rdx,%rcx
add    %r13,%rcx
cmpb   $0x54,0x1(%rax,%rcx,1)
jne    11e0 <anda+0x90>
cmpb   $0x54,-0x1(%rax,%rcx,1)
jne    11e0 <anda+0x90>
cmpb   $0x54,0x1e(%rax,%rcx,1)
jne    11e0 <anda+0x90>
cmpb   $0x54,-0x1e(%rax,%rcx,1)
je     152e <anda+0x3de>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,0x44(%rsp)
jmp    1211 <anda+0xc1>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ebx
mov    %ebx,0x4(%r15)
mov    %r13,%rdi
mov    %r15,%rsi
call   1030 <marca_ghost@plt>
mov    %r13,%rdi
call   1070 <print_maze@plt>
mov    (%r15),%r12d
mov    0x4(%r15),%ebx
movslq %r12d,%rax
movslq %ebx,%rbp
mov    %rax,%r14
shl    $0x5,%r14
sub    %rax,%r14
sub    %rax,%r14
add    %r13,%r14
cmpb   $0x37,0x1(%rbp,%r14,1)
jne    1270 <anda+0x120>
cmpb   $0x37,-0x1(%rbp,%r14,1)
jne    1270 <anda+0x120>
lea    0x1(%rax),%rcx
mov    %rcx,%rdx
shl    $0x5,%rdx
sub    %rcx,%rdx
sub    %rcx,%rdx
add    %r13,%rdx
cmpb   $0x37,0x0(%rbp,%rdx,1)
jne    1270 <anda+0x120>
lea    -0x1(%rax),%rcx
mov    %rcx,%rdx
shl    $0x5,%rdx
sub    %rcx,%rdx
sub    %rcx,%rdx
add    %r13,%rdx
cmpb   $0x37,0x0(%rbp,%rdx,1)
je     12e0 <anda+0x190>
nopl   (%rax)
lea    -0x1(%rax),%rcx
mov    %rcx,%rdx
shl    $0x5,%rdx
sub    %rcx,%rdx
sub    %rcx,%rdx
add    %r13,%rdx
cmpb   $0x30,0x0(%rbp,%rdx,1)
jne    11f0 <anda+0xa0>
cmpb   $0x30,-0x1(%rbp,%r14,1)
jne    12d0 <anda+0x180>
add    $0x1,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
add    %r13,%rcx
cmpb   $0x30,0x0(%rbp,%rcx,1)
je     120a <anda+0xba>
add    $0x1,%r12d
mov    %r12d,(%r15)
jmp    11f7 <anda+0xa7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%ebx
jmp    11f3 <anda+0xa3>
nopl   0x0(%rax,%rax,1)
lea    0x2(%rbx),%eax
mov    %eax,0x1c(%rsp)
lea    -0x2(%rbx),%eax
mov    %eax,0x4(%rsp)
lea    0x20(%rsp),%rdi
call   1040 <zera_vetor@plt>
cmpb   $0x30,0x2(%rbp,%r14,1)
je     1342 <anda+0x1f2>
mov    0x10(%rsp),%rax
mov    (%rax),%eax
mov    %r12d,%edi
sub    %eax,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,0x8(%rsp)
mov    0x1c(%rsp),%edi
mov    0x10(%rsp),%rax
sub    0x4(%rax),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    0x8(%rsp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    %eax,0x20(%rsp)
lea    0x2(%r12),%esi
mov    0x4(%rsp),%edi
movslq %edi,%rax
cmpb   $0x30,(%rax,%r14,1)
je     13a0 <anda+0x250>
mov    0x10(%rsp),%r14
mov    (%r14),%eax
mov    %r12d,%edi
sub    %eax,%edi
mov    %esi,0x8(%rsp)
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,0x38(%rsp)
mov    0x4(%rsp),%edi
sub    0x4(%r14),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    0x38(%rsp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    0x8(%rsp),%esi
mov    0x4(%rsp),%edi
mov    %eax,0x24(%rsp)
lea    -0x2(%r12),%edx
movslq %esi,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
add    %r13,%rcx
cmpb   $0x30,0x0(%rbp,%rcx,1)
je     1405 <anda+0x2b5>
mov    0x10(%rsp),%r14
sub    (%r14),%esi
mov    %esi,%edi
mov    $0x2,%esi
mov    %edx,0x8(%rsp)
call   1050 <pow@plt>
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
sub    0x4(%r14),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    0x38(%rsp),%rdi
add    %rax,%rdi
call   1060 <sqrt@plt>
mov    0x8(%rsp),%edx
mov    0x4(%rsp),%edi
mov    %eax,0x28(%rsp)
movslq %edx,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
add    %r13,%rcx
cmpb   $0x30,0x0(%rbp,%rcx,1)
je     1459 <anda+0x309>
mov    0x10(%rsp),%r14
sub    (%r14),%edx
mov    %edx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %rax,%rbp
sub    0x4(%r14),%ebx
mov    %ebx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
add    %rax,%rbp
mov    %rbp,%rdi
call   1060 <sqrt@plt>
mov    0x4(%rsp),%edi
mov    %eax,0x2c(%rsp)
mov    0x20(%rsp),%esi
mov    0x24(%rsp),%eax
cmp    %eax,%esi
mov    0x44(%rsp),%ebp
cmovl  %r12d,%ebp
mov    0x28(%rsp),%ecx
cmp    %ecx,%esi
cmovl  %r12d,%ebp
mov    0x2c(%rsp),%edx
cmp    %edx,%esi
cmovl  %r12d,%ebp
cmp    %esi,%eax
mov    0x1c(%rsp),%ebx
cmovl  %ebx,%ebp
cmp    %ecx,%eax
cmovl  %ebx,%ebp
cmp    %edx,%eax
cmovl  %ebx,%ebp
cmp    %esi,%ecx
cmovl  %r12d,%ebp
cmp    %eax,%ecx
cmovl  %r12d,%ebp
cmp    %edx,%ecx
cmovl  %r12d,%ebp
cmp    %esi,%edx
cmovl  %edi,%ebp
cmp    %eax,%edx
cmovl  %edi,%ebp
cmp    %ecx,%edx
cmovl  %edi,%ebp
cmp    %esi,%ebp
je     1170 <anda+0x20>
cmp    %eax,%ebp
jne    14e0 <anda+0x390>
movslq (%r15),%rax
movslq 0x4(%r15),%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
sub    %rax,%rdx
sub    %rax,%rdx
add    %r13,%rdx
movb   $0x42,-0x2(%rcx,%rdx,1)
jmp    118c <anda+0x3c>
cmp    %ecx,%ebp
jne    1505 <anda+0x3b5>
movslq (%r15),%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
movslq 0x4(%r15),%rax
add    %r13,%rcx
movb   $0x42,0x3c(%rax,%rcx,1)
jmp    118c <anda+0x3c>
cmp    %edx,%ebp
jne    1194 <anda+0x44>
movslq (%r15),%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
movslq 0x4(%r15),%rax
add    %r13,%rcx
movb   $0x42,-0x3c(%rax,%rcx,1)
jmp    118c <anda+0x3c>
add    $0x48,%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 = %622, %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 %623
78: ; preds = %76
br label %79
79: ; preds = %260, %78
%80 = load [30 x i8]*, [30 x i8]** %5
%81 = load i32*, i32** %4
%82 = getelementptr inbounds i32, i32* %81, i64 0
%83 = load i32, i32* %82
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [30 x i8], [30 x i8]* %80, i64 %84
%86 = load i32*, i32** %4
%87 = getelementptr inbounds i32, i32* %86, i64 1
%88 = load i32, i32* %87
%89 = add nsw i32 %88, 1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [30 x i8], [30 x i8]* %85, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = icmp ne i32 %93, 55
br i1 %94, label %143, label %95
95: ; preds = %79
%96 = load [30 x i8]*, [30 x i8]** %5
%97 = load i32*, i32** %4
%98 = getelementptr inbounds i32, i32* %97, i64 0
%99 = load i32, i32* %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [30 x i8], [30 x i8]* %96, i64 %100
%102 = load i32*, i32** %4
%103 = getelementptr inbounds i32, i32* %102, i64 1
%104 = load i32, i32* %103
%105 = sub nsw i32 %104, 1
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [30 x i8], [30 x i8]* %101, i64 0, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp ne i32 %109, 55
br i1 %110, label %143, label %111
111: ; preds = %95
%112 = load [30 x i8]*, [30 x i8]** %5
%113 = load i32*, i32** %4
%114 = getelementptr inbounds i32, i32* %113, i64 0
%115 = load i32, i32* %114
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [30 x i8], [30 x i8]* %112, i64 %117
%119 = load i32*, i32** %4
%120 = getelementptr inbounds i32, i32* %119, i64 1
%121 = load i32, i32* %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [30 x i8], [30 x i8]* %118, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = icmp ne i32 %125, 55
br i1 %126, label %143, label %127
127: ; preds = %111
%128 = load [30 x i8]*, [30 x i8]** %5
%129 = load i32*, i32** %4
%130 = getelementptr inbounds i32, i32* %129, i64 0
%131 = load i32, i32* %130
%132 = sub nsw i32 %131, 1
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [30 x i8], [30 x i8]* %128, i64 %133
%135 = load i32*, i32** %4
%136 = getelementptr inbounds i32, i32* %135, i64 1
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [30 x i8], [30 x i8]* %134, i64 0, i64 %138
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = icmp ne i32 %141, 55
br label %143
143: ; preds = %127, %111, %95, %79
%144 = phi i1 [ true, %111 ], [ true, %95 ], [ true, %79 ], [ %142, %127 ]
br i1 %144, label %145, label %261
145: ; preds = %143
%146 = load [30 x i8]*, [30 x i8]** %5
%147 = load i32*, i32** %4
%148 = getelementptr inbounds i32, i32* %147, i64 0
%149 = load i32, i32* %148
%150 = sub nsw i32 %149, 1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [30 x i8], [30 x i8]* %146, i64 %151
%153 = load i32*, i32** %4
%154 = getelementptr inbounds i32, i32* %153, i64 1
%155 = load i32, i32* %154
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [30 x i8], [30 x i8]* %152, i64 0, i64 %156
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp ne i32 %159, 48
br i1 %160, label %161, label %173
161: ; preds = %145
%162 = load i32*, i32** %4
%163 = getelementptr inbounds i32, i32* %162, i64 1
%164 = load i32, i32* %163
%165 = add nsw i32 %164, 1
store i32 %165, i32* %163
%166 = load [30 x i8]*, [30 x i8]** %5
%167 = bitcast [30 x i8]* %166 to i8**
%168 = load i32*, i32** %4
%169 = call i32 @marca_ghost(i8** %167, i32* %168)
%170 = load [30 x i8]*, [30 x i8]** %5
%171 = bitcast [30 x i8]* %170 to i8**
%172 = call i32 @print_maze(i8** %171)
br label %260
173: ; preds = %145
%174 = load [30 x i8]*, [30 x i8]** %5
%175 = load i32*, i32** %4
%176 = getelementptr inbounds i32, i32* %175, i64 0
%177 = load i32, i32* %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [30 x i8], [30 x i8]* %174, i64 %178
%180 = load i32*, i32** %4
%181 = getelementptr inbounds i32, i32* %180, i64 1
%182 = load i32, i32* %181
%183 = sub nsw i32 %182, 1
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds [30 x i8], [30 x i8]* %179, i64 0, i64 %184
%186 = load i8, i8* %185
%187 = sext i8 %186 to i32
%188 = icmp ne i32 %187, 48
br i1 %188, label %189, label %201
189: ; preds = %173
%190 = load i32*, i32** %4
%191 = getelementptr inbounds i32, i32* %190, i64 1
%192 = load i32, i32* %191
%193 = add nsw i32 %192, -1
store i32 %193, i32* %191
%194 = load [30 x i8]*, [30 x i8]** %5
%195 = bitcast [30 x i8]* %194 to i8**
%196 = load i32*, i32** %4
%197 = call i32 @marca_ghost(i8** %195, i32* %196)
%198 = load [30 x i8]*, [30 x i8]** %5
%199 = bitcast [30 x i8]* %198 to i8**
%200 = call i32 @print_maze(i8** %199)
br label %259
201: ; preds = %173
%202 = load [30 x i8]*, [30 x i8]** %5
%203 = load i32*, i32** %4
%204 = getelementptr inbounds i32, i32* %203, i64 0
%205 = load i32, i32* %204
%206 = add nsw i32 %205, 1
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [30 x i8], [30 x i8]* %202, i64 %207
%209 = load i32*, i32** %4
%210 = getelementptr inbounds i32, i32* %209, i64 1
%211 = load i32, i32* %210
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [30 x i8], [30 x i8]* %208, i64 0, i64 %212
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %215, 48
br i1 %216, label %217, label %229
217: ; preds = %201
%218 = load i32*, i32** %4
%219 = getelementptr inbounds i32, i32* %218, i64 0
%220 = load i32, i32* %219
%221 = add nsw i32 %220, 1
store i32 %221, i32* %219
%222 = load [30 x i8]*, [30 x i8]** %5
%223 = bitcast [30 x i8]* %222 to i8**
%224 = load i32*, i32** %4
%225 = call i32 @marca_ghost(i8** %223, i32* %224)
%226 = load [30 x i8]*, [30 x i8]** %5
%227 = bitcast [30 x i8]* %226 to i8**
%228 = call i32 @print_maze(i8** %227)
br label %258
229: ; preds = %201
%230 = load [30 x i8]*, [30 x i8]** %5
%231 = load i32*, i32** %4
%232 = getelementptr inbounds i32, i32* %231, i64 0
%233 = load i32, i32* %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [30 x i8], [30 x i8]* %230, i64 %234
%236 = load i32*, i32** %4
%237 = getelementptr inbounds i32, i32* %236, i64 1
%238 = load i32, i32* %237
%239 = sub nsw i32 %238, 1
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [30 x i8], [30 x i8]* %235, i64 0, i64 %240
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp ne i32 %243, 48
br i1 %244, label %245, label %257
245: ; preds = %229
%246 = load i32*, i32** %4
%247 = getelementptr inbounds i32, i32* %246, i64 1
%248 = load i32, i32* %247
%249 = add nsw i32 %248, -1
store i32 %249, i32* %247
%250 = load [30 x i8]*, [30 x i8]** %5
%251 = bitcast [30 x i8]* %250 to i8**
%252 = load i32*, i32** %4
%253 = call i32 @marca_ghost(i8** %251, i32* %252)
%254 = load [30 x i8]*, [30 x i8]** %5
%255 = bitcast [30 x i8]* %254 to i8**
%256 = call i32 @print_maze(i8** %255)
br label %257
257: ; preds = %245, %229
br label %258
258: ; preds = %257, %217
br label %259
259: ; preds = %258, %189
br label %260
260: ; preds = %259, %161
br label %79
261: ; preds = %143
%262 = load [30 x i8]*, [30 x i8]** %5
%263 = load i32*, i32** %4
%264 = getelementptr inbounds i32, i32* %263, i64 0
%265 = load i32, i32* %264
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [30 x i8], [30 x i8]* %262, i64 %266
%268 = load i32*, i32** %4
%269 = getelementptr inbounds i32, i32* %268, i64 1
%270 = load i32, i32* %269
%271 = add nsw i32 %270, 1
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [30 x i8], [30 x i8]* %267, i64 0, i64 %272
%274 = load i8, i8* %273
%275 = sext i8 %274 to i32
%276 = icmp eq i32 %275, 55
br i1 %276, label %325, label %277
277: ; preds = %261
%278 = load [30 x i8]*, [30 x i8]** %5
%279 = load i32*, i32** %4
%280 = getelementptr inbounds i32, i32* %279, i64 0
%281 = load i32, i32* %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [30 x i8], [30 x i8]* %278, i64 %282
%284 = load i32*, i32** %4
%285 = getelementptr inbounds i32, i32* %284, i64 1
%286 = load i32, i32* %285
%287 = sub nsw i32 %286, 1
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [30 x i8], [30 x i8]* %283, i64 0, i64 %288
%290 = load i8, i8* %289
%291 = sext i8 %290 to i32
%292 = icmp eq i32 %291, 55
br i1 %292, label %325, label %293
293: ; preds = %277
%294 = load [30 x i8]*, [30 x i8]** %5
%295 = load i32*, i32** %4
%296 = getelementptr inbounds i32, i32* %295, i64 0
%297 = load i32, i32* %296
%298 = add nsw i32 %297, 1
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [30 x i8], [30 x i8]* %294, i64 %299
%301 = load i32*, i32** %4
%302 = getelementptr inbounds i32, i32* %301, i64 1
%303 = load i32, i32* %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [30 x i8], [30 x i8]* %300, i64 0, i64 %304
%306 = load i8, i8* %305
%307 = sext i8 %306 to i32
%308 = icmp eq i32 %307, 55
br i1 %308, label %325, label %309
309: ; preds = %293
%310 = load [30 x i8]*, [30 x i8]** %5
%311 = load i32*, i32** %4
%312 = getelementptr inbounds i32, i32* %311, i64 0
%313 = load i32, i32* %312
%314 = sub nsw i32 %313, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [30 x i8], [30 x i8]* %310, i64 %315
%317 = load i32*, i32** %4
%318 = getelementptr inbounds i32, i32* %317, i64 1
%319 = load i32, i32* %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [30 x i8], [30 x i8]* %316, i64 0, i64 %320
%322 = load i8, i8* %321
%323 = sext i8 %322 to i32
%324 = icmp eq i32 %323, 55
br i1 %324, label %325, label %362
325: ; preds = %309, %293, %277, %261
%326 = load i32*, i32** %4
%327 = getelementptr inbounds i32, i32* %326, i64 0
%328 = load i32, i32* %327
%329 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
store i32 %328, i32* %329
%330 = load i32*, i32** %4
%331 = getelementptr inbounds i32, i32* %330, i64 1
%332 = load i32, i32* %331
%333 = add nsw i32 %332, 2
%334 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
store i32 %333, i32* %334
%335 = load i32*, i32** %4
%336 = getelementptr inbounds i32, i32* %335, i64 0
%337 = load i32, i32* %336
%338 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
store i32 %337, i32* %338
%339 = load i32*, i32** %4
%340 = getelementptr inbounds i32, i32* %339, i64 1
%341 = load i32, i32* %340
%342 = sub nsw i32 %341, 2
%343 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
store i32 %342, i32* %343
%344 = load i32*, i32** %4
%345 = getelementptr inbounds i32, i32* %344, i64 0
%346 = load i32, i32* %345
%347 = add nsw i32 %346, 2
%348 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
store i32 %347, i32* %348
%349 = load i32*, i32** %4
%350 = getelementptr inbounds i32, i32* %349, i64 1
%351 = load i32, i32* %350
%352 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
store i32 %351, i32* %352
%353 = load i32*, i32** %4
%354 = getelementptr inbounds i32, i32* %353, i64 0
%355 = load i32, i32* %354
%356 = sub nsw i32 %355, 2
%357 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
store i32 %356, i32* %357
%358 = load i32*, i32** %4
%359 = getelementptr inbounds i32, i32* %358, i64 1
%360 = load i32, i32* %359
%361 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
store i32 %360, i32* %361
br label %362
362: ; preds = %325, %309
%363 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
%364 = call i32 @zera_vetor(i32* %363)
%365 = load [30 x i8]*, [30 x i8]** %5
%366 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
%367 = load i32, i32* %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds [30 x i8], [30 x i8]* %365, i64 %368
%370 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
%371 = load i32, i32* %370
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [30 x i8], [30 x i8]* %369, i64 0, i64 %372
%374 = load i8, i8* %373
%375 = sext i8 %374 to i32
%376 = icmp ne i32 %375, 48
br i1 %376, label %377, label %395
377: ; preds = %362
%378 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
%379 = load i32, i32* %378
%380 = load i32*, i32** %6
%381 = getelementptr inbounds i32, i32* %380, i64 0
%382 = load i32, i32* %381
%383 = sub nsw i32 %379, %382
%384 = call i64 @pow(i32 %383, i32 2)
%385 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 1
%386 = load i32, i32* %385
%387 = load i32*, i32** %6
%388 = getelementptr inbounds i32, i32* %387, i64 1
%389 = load i32, i32* %388
%390 = sub nsw i32 %386, %389
%391 = call i64 @pow(i32 %390, i32 2)
%392 = add nsw i64 %384, %391
%393 = call i32 @sqrt(i64 %392)
%394 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
store i32 %393, i32* %394
br label %395
395: ; preds = %377, %362
%396 = load [30 x i8]*, [30 x i8]** %5
%397 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
%398 = load i32, i32* %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds [30 x i8], [30 x i8]* %396, i64 %399
%401 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
%402 = load i32, i32* %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [30 x i8], [30 x i8]* %400, i64 0, i64 %403
%405 = load i8, i8* %404
%406 = sext i8 %405 to i32
%407 = icmp ne i32 %406, 48
br i1 %407, label %408, label %426
408: ; preds = %395
%409 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 2
%410 = load i32, i32* %409
%411 = load i32*, i32** %6
%412 = getelementptr inbounds i32, i32* %411, i64 0
%413 = load i32, i32* %412
%414 = sub nsw i32 %410, %413
%415 = call i64 @pow(i32 %414, i32 2)
%416 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 3
%417 = load i32, i32* %416
%418 = load i32*, i32** %6
%419 = getelementptr inbounds i32, i32* %418, i64 1
%420 = load i32, i32* %419
%421 = sub nsw i32 %417, %420
%422 = call i64 @pow(i32 %421, i32 2)
%423 = add nsw i64 %415, %422
%424 = call i32 @sqrt(i64 %423)
%425 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 1
store i32 %424, i32* %425
br label %426
426: ; preds = %408, %395
%427 = load [30 x i8]*, [30 x i8]** %5
%428 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
%429 = load i32, i32* %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds [30 x i8], [30 x i8]* %427, i64 %430
%432 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
%433 = load i32, i32* %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds [30 x i8], [30 x i8]* %431, i64 0, i64 %434
%436 = load i8, i8* %435
%437 = sext i8 %436 to i32
%438 = icmp ne i32 %437, 48
br i1 %438, label %439, label %457
439: ; preds = %426
%440 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 4
%441 = load i32, i32* %440
%442 = load i32*, i32** %6
%443 = getelementptr inbounds i32, i32* %442, i64 0
%444 = load i32, i32* %443
%445 = sub nsw i32 %441, %444
%446 = call i64 @pow(i32 %445, i32 2)
%447 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 5
%448 = load i32, i32* %447
%449 = load i32*, i32** %6
%450 = getelementptr inbounds i32, i32* %449, i64 1
%451 = load i32, i32* %450
%452 = sub nsw i32 %448, %451
%453 = call i64 @pow(i32 %452, i32 2)
%454 = add nsw i64 %446, %453
%455 = call i32 @sqrt(i64 %454)
%456 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 2
store i32 %455, i32* %456
br label %457
457: ; preds = %439, %426
%458 = load [30 x i8]*, [30 x i8]** %5
%459 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
%460 = load i32, i32* %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds [30 x i8], [30 x i8]* %458, i64 %461
%463 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
%464 = load i32, i32* %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds [30 x i8], [30 x i8]* %462, i64 0, i64 %465
%467 = load i8, i8* %466
%468 = sext i8 %467 to i32
%469 = icmp ne i32 %468, 48
br i1 %469, label %470, label %488
470: ; preds = %457
%471 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 6
%472 = load i32, i32* %471
%473 = load i32*, i32** %6
%474 = getelementptr inbounds i32, i32* %473, i64 0
%475 = load i32, i32* %474
%476 = sub nsw i32 %472, %475
%477 = call i64 @pow(i32 %476, i32 2)
%478 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 7
%479 = load i32, i32* %478
%480 = load i32*, i32** %6
%481 = getelementptr inbounds i32, i32* %480, i64 1
%482 = load i32, i32* %481
%483 = sub nsw i32 %479, %482
%484 = call i64 @pow(i32 %483, i32 2)
%485 = add nsw i64 %477, %484
%486 = call i32 @sqrt(i64 %485)
%487 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 3
store i32 %486, i32* %487
br label %488
488: ; preds = %470, %457
store i32 0, i32* %8
br label %489
489: ; preds = %532, %488
%490 = load i32, i32* %8
%491 = icmp slt i32 %490, 4
br i1 %491, label %492, label %535
492: ; preds = %489
store i32 0, i32* %9
br label %493
493: ; preds = %528, %492
%494 = load i32, i32* %9
%495 = icmp slt i32 %494, 4
br i1 %495, label %496, label %531
496: ; preds = %493
%497 = load i32, i32* %8
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %498
%500 = load i32, i32* %499
%501 = load i32, i32* %9
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %502
%504 = load i32, i32* %503
%505 = icmp slt i32 %500, %504
br i1 %505, label %506, label %511
506: ; preds = %496
%507 = load i32, i32* %8
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 %508
%510 = load i32, i32* %509
store i32 %510, i32* %10
br label %527
511: ; preds = %496
%512 = load i32, i32* %9
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %513
%515 = load i32, i32* %514
%516 = load i32, i32* %8
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 %517
%519 = load i32, i32* %518
%520 = icmp sgt i32 %515, %519
br i1 %520, label %521, label %526
521: ; preds = %511
%522 = load i32, i32* %9
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 %523
%525 = load i32, i32* %524
store i32 %525, i32* %10
br label %526
526: ; preds = %521, %511
br label %527
527: ; preds = %526, %506
br label %528
528: ; preds = %527
%529 = load i32, i32* %9
%530 = add nsw i32 %529, 1
store i32 %530, i32* %9
br label %493
531: ; preds = %493
br label %532
532: ; preds = %531
%533 = load i32, i32* %8
%534 = add nsw i32 %533, 1
store i32 %534, i32* %8
br label %489
535: ; preds = %489
%536 = load i32, i32* %10
%537 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
%538 = load i32, i32* %537
%539 = icmp eq i32 %536, %538
br i1 %539, label %540, label %556
540: ; preds = %535
%541 = load [30 x i8]*, [30 x i8]** %5
%542 = load i32*, i32** %4
%543 = getelementptr inbounds i32, i32* %542, i64 0
%544 = load i32, i32* %543
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds [30 x i8], [30 x i8]* %541, i64 %545
%547 = load i32*, i32** %4
%548 = getelementptr inbounds i32, i32* %547, i64 1
%549 = load i32, i32* %548
%550 = add nsw i32 %549, 2
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds [30 x i8], [30 x i8]* %546, i64 0, i64 %551
store i8 66, i8* %552
%553 = load [30 x i8]*, [30 x i8]** %5
%554 = bitcast [30 x i8]* %553 to i8**
%555 = call i32 @print_maze(i8** %554)
br label %622
556: ; preds = %535
%557 = load i32, i32* %10
%558 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 1
%559 = load i32, i32* %558
%560 = icmp eq i32 %557, %559
br i1 %560, label %561, label %577
561: ; preds = %556
%562 = load [30 x i8]*, [30 x i8]** %5
%563 = load i32*, i32** %4
%564 = getelementptr inbounds i32, i32* %563, i64 0
%565 = load i32, i32* %564
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds [30 x i8], [30 x i8]* %562, i64 %566
%568 = load i32*, i32** %4
%569 = getelementptr inbounds i32, i32* %568, i64 1
%570 = load i32, i32* %569
%571 = sub nsw i32 %570, 2
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds [30 x i8], [30 x i8]* %567, i64 0, i64 %572
store i8 66, i8* %573
%574 = load [30 x i8]*, [30 x i8]** %5
%575 = bitcast [30 x i8]* %574 to i8**
%576 = call i32 @print_maze(i8** %575)
br label %621
577: ; preds = %556
%578 = load i32, i32* %10
%579 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 2
%580 = load i32, i32* %579
%581 = icmp eq i32 %578, %580
br i1 %581, label %582, label %598
582: ; preds = %577
%583 = load [30 x i8]*, [30 x i8]** %5
%584 = load i32*, i32** %4
%585 = getelementptr inbounds i32, i32* %584, i64 0
%586 = load i32, i32* %585
%587 = add nsw i32 %586, 2
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds [30 x i8], [30 x i8]* %583, i64 %588
%590 = load i32*, i32** %4
%591 = getelementptr inbounds i32, i32* %590, i64 1
%592 = load i32, i32* %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [30 x i8], [30 x i8]* %589, i64 0, i64 %593
store i8 66, i8* %594
%595 = load [30 x i8]*, [30 x i8]** %5
%596 = bitcast [30 x i8]* %595 to i8**
%597 = call i32 @print_maze(i8** %596)
br label %620
598: ; preds = %577
%599 = load i32, i32* %10
%600 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 3
%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 = sub nsw i32 %607, 2
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds [30 x i8], [30 x i8]* %604, i64 %609
%611 = load i32*, i32** %4
%612 = getelementptr inbounds i32, i32* %611, i64 1
%613 = load i32, i32* %612
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds [30 x i8], [30 x i8]* %610, 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 %619
619: ; preds = %603, %598
br label %620
620: ; preds = %619, %582
br label %621
621: ; preds = %620, %561
br label %622
622: ; preds = %621, %540
br label %12
623: ; 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 = bitcast [30 x i8]* %1 to i8**
%8 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%9 = getelementptr inbounds i32, i32* %2, i64 1
%10 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%11 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%12 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
br label %13
13: ; preds = %208, %3
%14 = phi i32 [ 0, %3 ], [ %188, %208 ]
%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 = icmp eq i8 %21, 84
br i1 %22, label %23, label %42
23: ; preds = %13
%24 = add nsw i32 %17, -1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %16, i64 %25
%27 = load i8, i8* %26
%28 = icmp eq i8 %27, 84
br i1 %28, label %29, label %42
29: ; preds = %23
%30 = add nsw i32 %15, 1
%31 = sext i32 %30 to i64
%32 = sext i32 %17 to i64
%33 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %31, i64 %32
%34 = load i8, i8* %33
%35 = icmp eq i8 %34, 84
br i1 %35, label %36, label %42
36: ; preds = %29
%37 = add nsw i32 %15, -1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %38, i64 %32
%40 = load i8, i8* %39
%41 = icmp eq i8 %40, 84
br i1 %41, label %229, label %42
42: ; preds = %13, %23, %29, %36
br label %43
43: ; preds = %42, %96
%44 = phi i32 [ %98, %96 ], [ %17, %42 ]
%45 = phi i32 [ %97, %96 ], [ %15, %42 ]
%46 = sext i32 %45 to i64
%47 = add nsw i32 %44, 1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %46, i64 %48
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 55
br i1 %51, label %52, label %71
52: ; preds = %43
%53 = add nsw i32 %44, -1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %46, i64 %54
%56 = load i8, i8* %55
%57 = icmp eq i8 %56, 55
br i1 %57, label %58, label %71
58: ; preds = %52
%59 = add nsw i32 %45, 1
%60 = sext i32 %59 to i64
%61 = sext i32 %44 to i64
%62 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %60, i64 %61
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, 55
br i1 %64, label %65, label %71
65: ; preds = %58
%66 = add nsw i32 %45, -1
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %67, i64 %61
%69 = load i8, i8* %68
%70 = icmp eq i8 %69, 55
br i1 %70, label %99, label %71
71: ; preds = %43, %52, %58, %65
%72 = add nsw i32 %45, -1
%73 = sext i32 %72 to i64
%74 = sext i32 %44 to i64
%75 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %73, i64 %74
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, 48
br i1 %77, label %79, label %78
78: ; preds = %71
store i32 %47, i32* %6
br label %93
79: ; preds = %71
%80 = add nsw i32 %44, -1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %46, i64 %81
%83 = load i8, i8* %82
%84 = icmp eq i8 %83, 48
br i1 %84, label %86, label %85
85: ; preds = %79
store i32 %80, i32* %6
br label %93
86: ; preds = %79
%87 = add nsw i32 %45, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %88, i64 %74
%90 = load i8, i8* %89
%91 = icmp eq i8 %90, 48
br i1 %91, label %96, label %92
92: ; preds = %86
store i32 %87, i32* %0
br label %93
93: ; preds = %78, %92, %85
%94 = call i32 @marca_ghost(i8** %7, i32* %0)
%95 = call i32 @print_maze(i8** %7)
br label %96
96: ; preds = %93, %86
%97 = load i32, i32* %0
%98 = load i32, i32* %6
br label %43
99: ; preds = %65
%100 = add nsw i32 %44, 2
%101 = add nsw i32 %44, -2
%102 = add nsw i32 %45, 2
%103 = add nsw i32 %45, -2
%104 = call i32 @zera_vetor(i32* %8)
%105 = sext i32 %100 to i64
%106 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %46, i64 %105
%107 = load i8, i8* %106
%108 = icmp eq i8 %107, 48
br i1 %108, label %118, label %109
109: ; preds = %99
%110 = load i32, i32* %2
%111 = sub nsw i32 %45, %110
%112 = call i64 @pow(i32 %111, i32 2)
%113 = load i32, i32* %9
%114 = sub nsw i32 %100, %113
%115 = call i64 @pow(i32 %114, i32 2)
%116 = add nsw i64 %115, %112
%117 = call i32 @sqrt(i64 %116)
store i32 %117, i32* %8
br label %118
118: ; preds = %109, %99
%119 = sext i32 %101 to i64
%120 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %46, i64 %119
%121 = load i8, i8* %120
%122 = icmp eq i8 %121, 48
br i1 %122, label %132, label %123
123: ; preds = %118
%124 = load i32, i32* %2
%125 = sub nsw i32 %45, %124
%126 = call i64 @pow(i32 %125, i32 2)
%127 = load i32, i32* %9
%128 = sub nsw i32 %101, %127
%129 = call i64 @pow(i32 %128, i32 2)
%130 = add nsw i64 %129, %126
%131 = call i32 @sqrt(i64 %130)
store i32 %131, i32* %10
br label %132
132: ; preds = %123, %118
%133 = sext i32 %102 to i64
%134 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %133, i64 %61
%135 = load i8, i8* %134
%136 = icmp eq i8 %135, 48
br i1 %136, label %146, label %137
137: ; preds = %132
%138 = load i32, i32* %2
%139 = sub nsw i32 %102, %138
%140 = call i64 @pow(i32 %139, i32 2)
%141 = load i32, i32* %9
%142 = sub nsw i32 %44, %141
%143 = call i64 @pow(i32 %142, i32 2)
%144 = add nsw i64 %143, %140
%145 = call i32 @sqrt(i64 %144)
store i32 %145, i32* %11
br label %146
146: ; preds = %137, %132
%147 = sext i32 %103 to i64
%148 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %147, i64 %61
%149 = load i8, i8* %148
%150 = icmp eq i8 %149, 48
br i1 %150, label %160, label %151
151: ; preds = %146
%152 = load i32, i32* %2
%153 = sub nsw i32 %103, %152
%154 = call i64 @pow(i32 %153, i32 2)
%155 = load i32, i32* %9
%156 = sub nsw i32 %44, %155
%157 = call i64 @pow(i32 %156, i32 2)
%158 = add nsw i64 %157, %154
%159 = call i32 @sqrt(i64 %158)
store i32 %159, i32* %12
br label %160
160: ; preds = %146, %151
%161 = load i32, i32* %8
%162 = load i32, i32* %10
%163 = icmp slt i32 %161, %162
%164 = load i32, i32* %11
%165 = icmp slt i32 %161, %164
%166 = load i32, i32* %12
%167 = icmp slt i32 %161, %166
%168 = select i1 %167, i1 true, i1 %165
%169 = select i1 %168, i1 true, i1 %163
%170 = select i1 %169, i32 %45, i32 %14
%171 = icmp slt i32 %162, %161
%172 = icmp slt i32 %162, %164
%173 = icmp slt i32 %162, %166
%174 = select i1 %173, i1 true, i1 %172
%175 = select i1 %174, i1 true, i1 %171
%176 = select i1 %175, i32 %100, i32 %170
%177 = icmp slt i32 %164, %161
%178 = icmp slt i32 %164, %162
%179 = icmp slt i32 %164, %166
%180 = select i1 %179, i1 true, i1 %178
%181 = select i1 %180, i1 true, i1 %177
%182 = select i1 %181, i32 %45, i32 %176
%183 = icmp slt i32 %166, %161
%184 = icmp slt i32 %166, %162
%185 = icmp slt i32 %166, %164
%186 = select i1 %185, i1 true, i1 %184
%187 = select i1 %186, i1 true, i1 %183
%188 = select i1 %187, i32 %101, i32 %182
%189 = icmp eq i32 %188, %161
br i1 %189, label %190, label %198
190: ; preds = %160
%191 = load i32, i32* %0
%192 = sext i32 %191 to i64
%193 = load i32, i32* %6
%194 = add nsw i32 %193, 2
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %192, i64 %195
store i8 66, i8* %196
%197 = call i32 @print_maze(i8** %7)
br label %208
198: ; preds = %160
%199 = icmp eq i32 %188, %162
br i1 %199, label %200, label %209
200: ; preds = %198
%201 = load i32, i32* %0
%202 = sext i32 %201 to i64
%203 = load i32, i32* %6
%204 = add nsw i32 %203, -2
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %202, i64 %205
store i8 66, i8* %206
%207 = call i32 @print_maze(i8** %7)
br label %208
208: ; preds = %200, %219, %221, %211, %190
br label %13
209: ; preds = %198
%210 = icmp eq i32 %188, %164
br i1 %210, label %211, label %219
211: ; preds = %209
%212 = load i32, i32* %0
%213 = add nsw i32 %212, 2
%214 = sext i32 %213 to i64
%215 = load i32, i32* %6
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 %214, i64 %216
store i8 66, i8* %217
%218 = call i32 @print_maze(i8** %7)
br label %208
219: ; preds = %209
%220 = icmp eq i32 %188, %166
br i1 %220, label %221, label %208
221: ; preds = %219
%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
%228 = call i32 @print_maze(i8** %7)
br label %208
229: ; preds = %36
ret void
}