#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ __fpurge(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ limpa();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ puts(char *);
scalar_t__ realloc(int *, int);
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ stdin;
void submenu(int *vert, int *adj, int cont, int cont2) {
  FILE *fp;
  int opcao, i, j, k = 0;
  do {
    limpa();
    puts("Digite 1 para mostrar o grafo\n");
    puts("Digite 2 para remover um vertice\n");
    puts("Digite 0 para voltar ao menu anterior");
    printf("::>");
    scanf("%i", &opcao);
    if (opcao == 1) {
      limpa();
      k = 0;
      for (i = 0; i < cont; i++) {
        printf("Indice:%i Grau: %i Vizinhos: ", i + 1, vert[i]);
        for (j = 0; j < vert[i]; j++) {
          printf("%i ", adj[k]);
          k++;
        }
        puts("\n");
      }
      puts("Digite algo para continuar...");
      __fpurge(stdin);
      getchar();
    } else if (opcao == 2) {
      int vet_exclusao, aux, aux2, soma_grau = 0;
      limpa();
      printf("Digite o vertice que deseja excluir\n::>");
      scanf("%i", &vet_exclusao);
      vet_exclusao--;
      if (vet_exclusao >= cont || vet_exclusao <= 0) {
        puts("Valor invalido\nDigite algo para continuar...");
        __fpurge(stdin);
        getchar();
      } else {
        aux = vert[vet_exclusao];
        aux2 = aux;
        k = 0;
        for (i = 0; i < cont; i++) {
          for (j = 0; j < vert[i]; j++) {
            if (adj[k] == vet_exclusao + 1) {
              adj[k] = 0;
              vert[i]--;
              aux++;
            }
            k++;
          }
        }
        vert[vet_exclusao] = 0;
        for (i = 0; i < vet_exclusao; i++) {
          soma_grau += vert[i];
        }
        for (i = 0; i < aux2; i++) {
          adj[soma_grau] = 0;
          soma_grau++;
        }
        for (i = 0; i < cont; i++) {
          for (j = 0; j < cont - 1; j++) {
            if (vert[j] == 0) {
              aux2 = vert[j + 1];
              vert[j + 1] = vert[j];
              vert[j] = aux2;
            }
          }
        }
        for (i = 0; i < cont2; i++) {
          for (j = 0; j < cont2 - 1; j++) {
            if (adj[j] == 0) {
              aux2 = adj[j + 1];
              adj[j + 1] = adj[j];
              adj[j] = aux2;
            }
          }
        }
        cont--;
        vert = (int *)realloc(vert, sizeof(int) * cont);
        for (i = 0; i < cont2; i++) {
          if (adj[i] == vet_exclusao + 1) {
            adj[j] = 0;
          }
        }
        for (i = 0; i < cont2; i++) {
          for (j = 0; j < cont2 - 1; j++) {
            if (adj[j] == 0) {
              aux2 = adj[j + 1];
              adj[j + 1] = adj[j];
              adj[j] = aux2;
            }
          }
        }
        cont2 -= aux;
        adj = (int *)realloc(adj, sizeof(int) * cont2);
        for (i = 0; i < cont2; i++) {
          if (adj[i] > vet_exclusao) {
            adj[i]--;
          }
        }
        fp = fopen("entrada.txt", "w");
        if (fp) {
          k = 0;
          for (i = 0; i < cont; i++) {
            fprintf(fp, "%i: ", i + 1);
            for (j = 0; j < vert[i]; j++) {
              fprintf(fp, "%i ", adj[k]);
              k++;
            }
            fprintf(fp, "\n");
          }
        }
        fclose(fp);
        puts("Vertice removido com sucesso!\nDigite algo para continuar...");
        __fpurge(stdin);
        getchar();
      }
    } else if (opcao == 0) {
      return;
    }
  } while (opcao != 0);
}


x86 assembly (clang, -O0):
<submenu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x30(%rbp)
mov    $0x0,%al
call   1090 <limpa@plt>
lea    0xe35(%rip),%rdi
call   1030 <puts@plt>
lea    0xe48(%rip),%rdi
call   1030 <puts@plt>
lea    0xe5e(%rip),%rdi
call   1030 <puts@plt>
lea    0xec1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xe6a(%rip),%rdi
lea    -0x24(%rbp),%rsi
call   10b0 <scanf@plt>
cmpl   $0x1,-0x24(%rbp)
jne    12db <submenu+0x13b>
mov    $0x0,%al
call   1090 <limpa@plt>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b5 <submenu+0x115>
mov    -0x28(%rbp),%esi
add    $0x1,%esi
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xe21(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    129b <submenu+0xfb>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe0b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1257 <submenu+0xb7>
lea    0xd9d(%rip),%rdi
call   1030 <puts@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1225 <submenu+0x85>
lea    0xe56(%rip),%rdi
call   1030 <puts@plt>
mov    0x2d20(%rip),%rax
mov    (%rax),%edi
call   1040 <__fpurge@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
jmp    184d <submenu+0x6ad>
cmpl   $0x2,-0x24(%rbp)
jne    1834 <submenu+0x694>
movl   $0x0,-0x40(%rbp)
mov    $0x0,%al
call   1090 <limpa@plt>
lea    0xd92(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xd5f(%rip),%rdi
lea    -0x34(%rbp),%rsi
call   10b0 <scanf@plt>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1330 <submenu+0x190>
cmpl   $0x0,-0x34(%rbp)
jg     1356 <submenu+0x1b6>
lea    0xd7d(%rip),%rdi
call   1030 <puts@plt>
mov    0x2ca5(%rip),%rax
mov    (%rax),%edi
call   1040 <__fpurge@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
jmp    182f <submenu+0x68f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    140b <submenu+0x26b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13f8 <submenu+0x258>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    13e1 <submenu+0x241>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138b <submenu+0x1eb>
jmp    13fd <submenu+0x25d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1378 <submenu+0x1d8>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    144c <submenu+0x2ac>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1421 <submenu+0x281>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1485 <submenu+0x2e5>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1453 <submenu+0x2b3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1524 <submenu+0x384>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1511 <submenu+0x371>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    14fe <submenu+0x35e>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1503 <submenu+0x363>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    149f <submenu+0x2ff>
jmp    1516 <submenu+0x376>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    148c <submenu+0x2ec>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15c3 <submenu+0x423>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15b0 <submenu+0x410>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    159d <submenu+0x3fd>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15a2 <submenu+0x402>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    153e <submenu+0x39e>
jmp    15b5 <submenu+0x415>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    152b <submenu+0x38b>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   10a0 <realloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1631 <submenu+0x491>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    161e <submenu+0x47e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1623 <submenu+0x483>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15ea <submenu+0x44a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16d0 <submenu+0x530>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16bd <submenu+0x51d>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    16aa <submenu+0x50a>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    16af <submenu+0x50f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164b <submenu+0x4ab>
jmp    16c2 <submenu+0x522>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1638 <submenu+0x498>
mov    -0x38(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   10a0 <realloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    173d <submenu+0x59d>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jle    172a <submenu+0x58a>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    172f <submenu+0x58f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16f9 <submenu+0x559>
lea    0x99d(%rip),%rdi
lea    0x9a2(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     1805 <submenu+0x665>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1800 <submenu+0x660>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%edx
add    $0x1,%edx
lea    0x965(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17e0 <submenu+0x640>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0x8c6(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1798 <submenu+0x5f8>
mov    -0x20(%rbp),%rdi
lea    0x854(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176d <submenu+0x5cd>
jmp    1805 <submenu+0x665>
mov    -0x20(%rbp),%rdi
call   1050 <fclose@plt>
lea    0x8df(%rip),%rdi
call   1030 <puts@plt>
mov    0x27c7(%rip),%rax
mov    (%rax),%edi
call   1040 <__fpurge@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
jmp    1848 <submenu+0x6a8>
cmpl   $0x0,-0x24(%rbp)
jne    1843 <submenu+0x6a3>
jmp    185c <submenu+0x6bc>
jmp    1848 <submenu+0x6a8>
jmp    184d <submenu+0x6ad>
jmp    1852 <submenu+0x6b2>
cmpl   $0x0,-0x24(%rbp)
jne    11bd <submenu+0x1d>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<submenu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,0x10(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,%r14
mov    %rdi,%r12
lea    0xe1b(%rip),%r15
lea    0xe33(%rip),%rbp
lea    0xe4e(%rip),%rbx
lea    0xe8e(%rip),%r13
jmp    1242 <submenu+0x82>
nopl   0x0(%rax)
lea    0xf0b(%rip),%rdi
call   1030 <puts@plt>
mov    0x2dd5(%rip),%rax
mov    (%rax),%edi
call   1040 <__fpurge@plt>
xor    %eax,%eax
call   1090 <getchar@plt>
lea    0xdd8(%rip),%r15
lea    0xdf0(%rip),%rbp
lea    0xe0b(%rip),%rbx
mov    0x1c(%rsp),%eax
test   %eax,%eax
je     1b46 <submenu+0x986>
xor    %eax,%eax
call   10b0 <limpa@plt>
mov    %r15,%rdi
call   1030 <puts@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0xe48(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xdf1(%rip),%rdi
lea    0x1c(%rsp),%rsi
call   10d0 <scanf@plt>
mov    0x1c(%rsp),%eax
cmp    $0x1,%eax
je     12a0 <submenu+0xe0>
cmp    $0x2,%eax
je     1350 <submenu+0x190>
test   %eax,%eax
jne    123a <submenu+0x7a>
jmp    1b46 <submenu+0x986>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <limpa@plt>
cmpl   $0x0,0x8(%rsp)
jle    1200 <submenu+0x40>
mov    0x8(%rsp),%eax
mov    %rax,0x28(%rsp)
xor    %ebp,%ebp
xor    %ebx,%ebx
mov    %r14,0x20(%rsp)
jmp    12ea <submenu+0x12a>
cs nopw 0x0(%rax,%rax,1)
lea    0xd68(%rip),%rdi
call   1030 <puts@plt>
mov    %r15,%rbp
cmp    0x28(%rsp),%r15
je     1200 <submenu+0x40>
lea    0x1(%rbp),%r15
mov    (%r12,%rbp,4),%edx
lea    0xd71(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,(%r12,%rbp,4)
jle    12d0 <submenu+0x110>
mov    %ebx,0x30(%rsp)
movslq %ebx,%rax
lea    (%r14,%rax,4),%r14
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,4),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    (%r12,%rbp,4),%ebx
jl     1320 <submenu+0x160>
mov    0x30(%rsp),%eax
add    %ebx,%eax
mov    %eax,%ebx
mov    0x20(%rsp),%r14
jmp    12d0 <submenu+0x110>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <limpa@plt>
lea    0xd2e(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcfb(%rip),%rdi
mov    %rsp,%rsi
call   10d0 <scanf@plt>
mov    (%rsp),%ecx
lea    -0x1(%rcx),%eax
mov    %eax,(%rsp)
mov    0x8(%rsp),%r9
cmp    %r9d,%ecx
jg     13fb <submenu+0x23b>
cmp    $0x2,%ecx
jl     13fb <submenu+0x23b>
mov    %eax,%ecx
mov    (%r12,%rcx,4),%edx
mov    %edx,%r15d
test   %r9d,%r9d
jle    1410 <submenu+0x250>
mov    %r9d,%r8d
xor    %ecx,%ecx
mov    %edx,%r15d
xor    %esi,%esi
jmp    13bb <submenu+0x1fb>
cs nopw 0x0(%rax,%rax,1)
add    %ebp,%esi
add    $0x1,%rcx
cmp    %r8,%rcx
je     140d <submenu+0x24d>
mov    (%r12,%rcx,4),%edi
test   %edi,%edi
jle    13b2 <submenu+0x1f2>
movslq %esi,%rbp
lea    (%r14,%rbp,4),%rbx
xor    %ebp,%ebp
jmp    13d8 <submenu+0x218>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %edi,%ebp
jge    13b0 <submenu+0x1f0>
mov    (%rsp),%eax
add    $0x1,%eax
cmp    %eax,(%rbx,%rbp,4)
jne    13d0 <submenu+0x210>
movl   $0x0,(%rbx,%rbp,4)
mov    (%r12,%rcx,4),%edi
add    $0xffffffff,%edi
mov    %edi,(%r12,%rcx,4)
add    $0x1,%r15d
jmp    13d0 <submenu+0x210>
mov    %r15,%r13
lea    0xcaf(%rip),%rdi
mov    %r9d,%r15d
jmp    1b15 <submenu+0x955>
mov    (%rsp),%eax
cltq
movl   $0x0,(%r12,%rax,4)
mov    (%rsp),%eax
test   %eax,%eax
jle    142f <submenu+0x26f>
cmp    $0x8,%eax
jae    1436 <submenu+0x276>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1530 <submenu+0x370>
xor    %esi,%esi
jmp    153d <submenu+0x37d>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1461 <submenu+0x2a1>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
jmp    14d1 <submenu+0x311>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
nop
movdqu (%r12,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r12,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r12,%rdi,4),%xmm1
movdqu 0x30(%r12,%rdi,4),%xmm3
movdqu 0x40(%r12,%rdi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r12,%rdi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r12,%rdi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r12,%rdi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1470 <submenu+0x2b0>
test   %rbp,%rbp
je     150c <submenu+0x34c>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    14f0 <submenu+0x330>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rax,%rcx
je     153d <submenu+0x37d>
nopl   0x0(%rax,%rax,1)
add    (%r12,%rcx,4),%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1530 <submenu+0x370>
test   %edx,%edx
jle    1558 <submenu+0x398>
movslq %esi,%rax
lea    (%r14,%rax,4),%rdi
shl    $0x2,%rdx
xor    %esi,%esi
call   1070 <memset@plt>
mov    0x8(%rsp),%r9
test   %r9d,%r9d
mov    0x10(%rsp),%r8
jle    1612 <submenu+0x452>
lea    -0x1(%r9),%eax
mov    %eax,%ecx
and    $0xfffffffe,%ecx
xor    %edx,%edx
jmp    158c <submenu+0x3cc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%edx
cmp    %r9d,%edx
je     1612 <submenu+0x452>
cmp    $0x1,%r9d
je     1580 <submenu+0x3c0>
cmp    $0x1,%eax
jne    15c0 <submenu+0x400>
xor    %esi,%esi
test   $0x1,%al
je     1580 <submenu+0x3c0>
cmpl   $0x0,(%r12,%rsi,4)
jne    1580 <submenu+0x3c0>
mov    0x4(%r12,%rsi,4),%edi
movl   $0x0,0x4(%r12,%rsi,4)
mov    %edi,(%r12,%rsi,4)
jmp    1580 <submenu+0x3c0>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    15d8 <submenu+0x418>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rsi,%rdi
cmp    %rsi,%rcx
je     1599 <submenu+0x3d9>
cmpl   $0x0,(%r12,%rdi,4)
jne    15f1 <submenu+0x431>
mov    0x4(%r12,%rdi,4),%esi
movl   $0x0,0x4(%r12,%rdi,4)
mov    %esi,(%r12,%rdi,4)
lea    0x2(%rdi),%rsi
cmpl   $0x0,0x4(%r12,%rdi,4)
jne    15d0 <submenu+0x410>
mov    0x8(%r12,%rdi,4),%ebp
movl   $0x0,0x8(%r12,%rdi,4)
mov    %ebp,0x4(%r12,%rdi,4)
jmp    15d0 <submenu+0x410>
test   %r8d,%r8d
jle    17d8 <submenu+0x618>
lea    -0x1(%r8),%eax
mov    %eax,%ebp
and    $0xfffffffe,%ebp
xor    %ecx,%ecx
jmp    163c <submenu+0x47c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
cmp    %r8d,%ecx
je     16d2 <submenu+0x512>
mov    $0x0,%ebx
cmp    $0x1,%r8d
je     1630 <submenu+0x470>
cmp    $0x1,%eax
jne    1680 <submenu+0x4c0>
xor    %edx,%edx
mov    %eax,%ebx
test   $0x1,%al
je     1630 <submenu+0x470>
cmpl   $0x0,(%r14,%rdx,4)
mov    %eax,%ebx
jne    1630 <submenu+0x470>
mov    0x4(%r14,%rdx,4),%esi
movl   $0x0,0x4(%r14,%rdx,4)
mov    %esi,(%r14,%rdx,4)
mov    %eax,%ebx
jmp    1630 <submenu+0x470>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
jmp    1698 <submenu+0x4d8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rsi
cmp    %rdx,%rbp
je     164e <submenu+0x48e>
cmpl   $0x0,(%r14,%rsi,4)
jne    16b1 <submenu+0x4f1>
mov    0x4(%r14,%rsi,4),%edx
movl   $0x0,0x4(%r14,%rsi,4)
mov    %edx,(%r14,%rsi,4)
lea    0x2(%rsi),%rdx
cmpl   $0x0,0x4(%r14,%rsi,4)
jne    1690 <submenu+0x4d0>
mov    0x8(%r14,%rsi,4),%edi
movl   $0x0,0x8(%r14,%rsi,4)
mov    %edi,0x4(%r14,%rsi,4)
jmp    1690 <submenu+0x4d0>
lea    -0x1(%r9),%eax
mov    %eax,0x4(%rsp)
lea    -0x4(,%r9,4),%esi
ff
mov    %r12,%rdi
call   10c0 <realloc@plt>
mov    0x10(%rsp),%r8
mov    %rax,%r12
test   %r8d,%r8d
jle    17d2 <submenu+0x612>
movslq %ebx,%rax
mov    %r8d,%ecx
cmp    $0x1,%r8d
jne    18b1 <submenu+0x6f1>
xor    %edx,%edx
test   $0x1,%cl
je     1726 <submenu+0x566>
mov    (%rsp),%ecx
add    $0x1,%ecx
cmp    %ecx,(%r14,%rdx,4)
jne    1726 <submenu+0x566>
movl   $0x0,(%r14,%rax,4)
test   %r8d,%r8d
jle    17d2 <submenu+0x612>
lea    -0x1(%r8),%eax
xor    %ecx,%ecx
jmp    174c <submenu+0x58c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
cmp    %r8d,%ecx
je     17d2 <submenu+0x612>
cmp    $0x1,%r8d
je     1740 <submenu+0x580>
cmp    $0x1,%eax
jne    1780 <submenu+0x5c0>
xor    %edx,%edx
test   $0x1,%al
je     1740 <submenu+0x580>
cmpl   $0x0,(%r14,%rdx,4)
jne    1740 <submenu+0x580>
mov    0x4(%r14,%rdx,4),%esi
movl   $0x0,0x4(%r14,%rdx,4)
mov    %esi,(%r14,%rdx,4)
jmp    1740 <submenu+0x580>
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
jmp    1798 <submenu+0x5d8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rsi
cmp    %rdx,%rbp
je     1759 <submenu+0x599>
cmpl   $0x0,(%r14,%rsi,4)
jne    17b1 <submenu+0x5f1>
mov    0x4(%r14,%rsi,4),%edx
movl   $0x0,0x4(%r14,%rsi,4)
mov    %edx,(%r14,%rsi,4)
lea    0x2(%rsi),%rdx
cmpl   $0x0,0x4(%r14,%rsi,4)
jne    1790 <submenu+0x5d0>
mov    0x8(%r14,%rsi,4),%edi
movl   $0x0,0x8(%r14,%rsi,4)
mov    %edi,0x4(%r14,%rsi,4)
jmp    1790 <submenu+0x5d0>
mov    0x4(%rsp),%ebx
jmp    17f4 <submenu+0x634>
lea    -0x1(%r9),%ebx
lea    -0x4(,%r9,4),%esi
ff
mov    %r12,%rdi
call   10c0 <realloc@plt>
mov    0x10(%rsp),%r8
mov    %rax,%r12
sub    %r15d,%r8d
mov    %r8,0x10(%rsp)
lea    0x0(,%r8,4),%esi
mov    %r14,%rdi
call   10c0 <realloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,%r14
test   %ecx,%ecx
jle    1a1f <submenu+0x85f>
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     1846 <submenu+0x686>
lea    (%r14,%rax,4),%rcx
mov    %rsp,%rdx
cmp    %rcx,%rdx
setb   %cl
lea    0x4(%rsp),%rdx
cmp    %rdx,%r14
jae    18f8 <submenu+0x738>
test   %cl,%cl
je     18f8 <submenu+0x738>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     1866 <submenu+0x6a6>
mov    (%r14,%rcx,4),%edx
cmp    (%rsp),%edx
jle    185f <submenu+0x69f>
add    $0xffffffff,%edx
mov    %edx,(%r14,%rcx,4)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
jne    188d <submenu+0x6cd>
jmp    1a1f <submenu+0x85f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rdx
cmp    %rdx,%rax
je     1a1f <submenu+0x85f>
mov    (%r14,%rdx,4),%ecx
cmp    (%rsp),%ecx
jle    189d <submenu+0x6dd>
add    $0xffffffff,%ecx
mov    %ecx,(%r14,%rdx,4)
mov    0x4(%r14,%rdx,4),%ecx
cmp    (%rsp),%ecx
jle    1880 <submenu+0x6c0>
add    $0xffffffff,%ecx
mov    %ecx,0x4(%r14,%rdx,4)
jmp    1880 <submenu+0x6c0>
mov    %ecx,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
jmp    18cd <submenu+0x70d>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     170d <submenu+0x54d>
mov    (%rsp),%edi
add    $0x1,%edi
cmp    %edi,(%r14,%rdx,4)
jne    18e1 <submenu+0x721>
movl   $0x0,(%r14,%rax,4)
mov    (%rsp),%edi
add    $0x1,%edi
cmp    %edi,0x4(%r14,%rdx,4)
jne    18c0 <submenu+0x700>
movl   $0x0,(%r14,%rax,4)
jmp    18c0 <submenu+0x700>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
pshufd $0x0,(%rsp),%xmm0
xor    %edx,%edx
jmp    191d <submenu+0x75d>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
je     1a16 <submenu+0x856>
movdqu (%r14,%rdx,4),%xmm2
movdqu 0x10(%r14,%rdx,4),%xmm1
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
movd   %xmm3,%esi
test   $0x1,%sil
je     1947 <submenu+0x787>
movd   %xmm2,%esi
add    $0xffffffff,%esi
mov    %esi,(%r14,%rdx,4)
pextrw $0x2,%xmm3,%esi
test   $0x1,%sil
je     1963 <submenu+0x7a3>
pshufd $0x55,%xmm2,%xmm4
movd   %xmm4,%esi
add    $0xffffffff,%esi
mov    %esi,0x4(%r14,%rdx,4)
pextrw $0x4,%xmm3,%esi
test   $0x1,%sil
je     197f <submenu+0x7bf>
pshufd $0xee,%xmm2,%xmm4
movd   %xmm4,%esi
add    $0xffffffff,%esi
mov    %esi,0x8(%r14,%rdx,4)
pextrw $0x6,%xmm3,%esi
test   $0x1,%sil
je     199b <submenu+0x7db>
pshufd $0xff,%xmm2,%xmm2
movd   %xmm2,%esi
add    $0xffffffff,%esi
mov    %esi,0xc(%r14,%rdx,4)
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
movd   %xmm2,%esi
test   $0x1,%sil
je     19b9 <submenu+0x7f9>
movd   %xmm1,%esi
add    $0xffffffff,%esi
mov    %esi,0x10(%r14,%rdx,4)
pextrw $0x2,%xmm2,%esi
test   $0x1,%sil
je     19d5 <submenu+0x815>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%esi
add    $0xffffffff,%esi
mov    %esi,0x14(%r14,%rdx,4)
pextrw $0x4,%xmm2,%esi
test   $0x1,%sil
je     19f1 <submenu+0x831>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%esi
add    $0xffffffff,%esi
mov    %esi,0x18(%r14,%rdx,4)
pextrw $0x6,%xmm2,%esi
test   $0x1,%sil
je     1910 <submenu+0x750>
pshufd $0xff,%xmm1,%xmm1
movd   %xmm1,%esi
add    $0xffffffff,%esi
mov    %esi,0x1c(%r14,%rdx,4)
jmp    1910 <submenu+0x750>
cmp    %rax,%rcx
jne    1848 <submenu+0x688>
mov    %ebx,0x4(%rsp)
lea    0x6b7(%rip),%rdi
lea    0x6bc(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,%r15
test   %rax,%rax
je     1aec <submenu+0x92c>
cmpl   $0x2,0x8(%rsp)
jl     1aec <submenu+0x92c>
mov    0x4(%rsp),%eax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
xor    %ebx,%ebx
mov    %r14,0x20(%rsp)
jmp    1a8c <submenu+0x8cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
call   1080 <fputc@plt>
mov    0x30(%rsp),%rax
mov    %rax,%rbp
cmp    0x8(%rsp),%rax
je     1aec <submenu+0x92c>
lea    0x1(%rbp),%rdx
mov    %r15,%rdi
lea    0x655(%rip),%rsi
mov    %rdx,0x30(%rsp)
xor    %eax,%eax
call   10a0 <fprintf@plt>
cmpl   $0x0,(%r12,%rbp,4)
jle    1a70 <submenu+0x8b0>
mov    %ebx,0x28(%rsp)
movslq %ebx,%rax
lea    (%r14,%rax,4),%rbx
mov    %r13,%r14
xor    %r13d,%r13d
xchg   %ax,%ax
mov    (%rbx,%r13,4),%edx
mov    %r15,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10a0 <fprintf@plt>
add    $0x1,%r13
cmp    (%r12,%rbp,4),%r13d
jl     1ac0 <submenu+0x900>
mov    0x28(%rsp),%ebx
add    %r13d,%ebx
mov    %r14,%r13
mov    0x20(%rsp),%r14
jmp    1a70 <submenu+0x8b0>
mov    %r15,%rdi
call   1050 <fclose@plt>
lea    0x5f9(%rip),%rdi
lea    0x4fe(%rip),%r13
lea    0x516(%rip),%rbp
lea    0x531(%rip),%rbx
mov    0x4(%rsp),%r15d
call   1030 <puts@plt>
mov    0x24c7(%rip),%rax
mov    (%rax),%edi
call   1040 <__fpurge@plt>
xor    %eax,%eax
call   1090 <getchar@plt>
mov    %r15d,%eax
mov    %rax,0x8(%rsp)
mov    %r13,%r15
lea    0x547(%rip),%r13
jmp    1236 <submenu+0x76>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [31 x i8] c"Digite 1 para mostrar o grafo\0A\00"
@.str.1 = [34 x i8] c"Digite 2 para remover um vertice\0A\00"
@.str.2 = [38 x i8] c"Digite 0 para voltar ao menu anterior\00"
@.str.3 = [4 x i8] c"::>\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [30 x i8] c"Indice:%i Grau: %i Vizinhos: \00"
@.str.6 = [4 x i8] c"%i \00"
@.str.7 = [2 x i8] c"\0A\00"
@.str.8 = [30 x i8] c"Digite algo para continuar...\00"
@stdin = global i32 0
@.str.9 = [40 x i8] c"Digite o vertice que deseja excluir\0A::>\00"
@.str.10 = [45 x i8] c"Valor invalido\0ADigite algo para continuar...\00"
@.str.11 = [12 x i8] c"entrada.txt\00"
@.str.12 = [2 x i8] c"w\00"
@.str.13 = [5 x i8] c"%i: \00"
@.str.14 = [60 x i8] c"Vertice removido com sucesso!\0ADigite algo para continuar...\00"
define void @submenu(i32* %0, i32* %1, i32 %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32 0, i32* %13
br label %18
18: ; preds = %446, %4
%19 = call i32 (...) @limpa()
%20 = call i32 @puts(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%21 = call i32 @puts(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
%22 = call i32 @puts(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%24 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %10)
%25 = load i32, i32* %10
%26 = icmp eq i32 %25, 1
br i1 %26, label %27, label %72
27: ; preds = %18
%28 = call i32 (...) @limpa()
store i32 0, i32* %13
store i32 0, i32* %11
br label %29
29: ; preds = %64, %27
%30 = load i32, i32* %11
%31 = load i32, i32* %7
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %67
33: ; preds = %29
%34 = load i32, i32* %11
%35 = add nsw i32 %34, 1
%36 = load i32*, i32** %5
%37 = load i32, i32* %11
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
%40 = load i32, i32* %39
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0), i32 %35, i32 %40)
store i32 0, i32* %12
br label %42
42: ; preds = %59, %33
%43 = load i32, i32* %12
%44 = load i32*, i32** %5
%45 = load i32, i32* %11
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
%48 = load i32, i32* %47
%49 = icmp slt i32 %43, %48
br i1 %49, label %50, label %62
50: ; preds = %42
%51 = load i32*, i32** %6
%52 = load i32, i32* %13
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %51, i64 %53
%55 = load i32, i32* %54
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %55)
%57 = load i32, i32* %13
%58 = add nsw i32 %57, 1
store i32 %58, i32* %13
br label %59
59: ; preds = %50
%60 = load i32, i32* %12
%61 = add nsw i32 %60, 1
store i32 %61, i32* %12
br label %42
62: ; preds = %42
%63 = call i32 @puts(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %64
64: ; preds = %62
%65 = load i32, i32* %11
%66 = add nsw i32 %65, 1
store i32 %66, i32* %11
br label %29
67: ; preds = %29
%68 = call i32 @puts(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0))
%69 = load i32, i32* @stdin
%70 = call i32 @__fpurge(i32 %69)
%71 = call i32 (...) @getchar()
br label %445
72: ; preds = %18
%73 = load i32, i32* %10
%74 = icmp eq i32 %73, 2
br i1 %74, label %75, label %439
75: ; preds = %72
store i32 0, i32* %17
%76 = call i32 (...) @limpa()
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0))
%78 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %14)
%79 = load i32, i32* %14
%80 = add nsw i32 %79, -1
store i32 %80, i32* %14
%81 = load i32, i32* %14
%82 = load i32, i32* %7
%83 = icmp sge i32 %81, %82
br i1 %83, label %87, label %84
84: ; preds = %75
%85 = load i32, i32* %14
%86 = icmp sle i32 %85, 0
br i1 %86, label %87, label %92
87: ; preds = %84, %75
%88 = call i32 @puts(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.10, i64 0, i64 0))
%89 = load i32, i32* @stdin
%90 = call i32 @__fpurge(i32 %89)
%91 = call i32 (...) @getchar()
br label %438
92: ; preds = %84
%93 = load i32*, i32** %5
%94 = load i32, i32* %14
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
store i32 %97, i32* %15
%98 = load i32, i32* %15
store i32 %98, i32* %16
store i32 0, i32* %13
store i32 0, i32* %11
br label %99
99: ; preds = %141, %92
%100 = load i32, i32* %11
%101 = load i32, i32* %7
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %144
103: ; preds = %99
store i32 0, i32* %12
br label %104
104: ; preds = %137, %103
%105 = load i32, i32* %12
%106 = load i32*, i32** %5
%107 = load i32, i32* %11
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %106, i64 %108
%110 = load i32, i32* %109
%111 = icmp slt i32 %105, %110
br i1 %111, label %112, label %140
112: ; preds = %104
%113 = load i32*, i32** %6
%114 = load i32, i32* %13
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = load i32, i32* %14
%119 = add nsw i32 %118, 1
%120 = icmp eq i32 %117, %119
br i1 %120, label %121, label %134
121: ; preds = %112
%122 = load i32*, i32** %6
%123 = load i32, i32* %13
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
store i32 0, i32* %125
%126 = load i32*, i32** %5
%127 = load i32, i32* %11
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
%130 = load i32, i32* %129
%131 = add nsw i32 %130, -1
store i32 %131, i32* %129
%132 = load i32, i32* %15
%133 = add nsw i32 %132, 1
store i32 %133, i32* %15
br label %134
134: ; preds = %121, %112
%135 = load i32, i32* %13
%136 = add nsw i32 %135, 1
store i32 %136, i32* %13
br label %137
137: ; preds = %134
%138 = load i32, i32* %12
%139 = add nsw i32 %138, 1
store i32 %139, i32* %12
br label %104
140: ; preds = %104
br label %141
141: ; preds = %140
%142 = load i32, i32* %11
%143 = add nsw i32 %142, 1
store i32 %143, i32* %11
br label %99
144: ; preds = %99
%145 = load i32*, i32** %5
%146 = load i32, i32* %14
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
store i32 0, i32* %148
store i32 0, i32* %11
br label %149
149: ; preds = %161, %144
%150 = load i32, i32* %11
%151 = load i32, i32* %14
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %164
153: ; preds = %149
%154 = load i32*, i32** %5
%155 = load i32, i32* %11
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32, i32* %154, i64 %156
%158 = load i32, i32* %157
%159 = load i32, i32* %17
%160 = add nsw i32 %159, %158
store i32 %160, i32* %17
br label %161
161: ; preds = %153
%162 = load i32, i32* %11
%163 = add nsw i32 %162, 1
store i32 %163, i32* %11
br label %149
164: ; preds = %149
store i32 0, i32* %11
br label %165
165: ; preds = %176, %164
%166 = load i32, i32* %11
%167 = load i32, i32* %16
%168 = icmp slt i32 %166, %167
br i1 %168, label %169, label %179
169: ; preds = %165
%170 = load i32*, i32** %6
%171 = load i32, i32* %17
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %170, i64 %172
store i32 0, i32* %173
%174 = load i32, i32* %17
%175 = add nsw i32 %174, 1
store i32 %175, i32* %17
br label %176
176: ; preds = %169
%177 = load i32, i32* %11
%178 = add nsw i32 %177, 1
store i32 %178, i32* %11
br label %165
179: ; preds = %165
store i32 0, i32* %11
br label %180
180: ; preds = %224, %179
%181 = load i32, i32* %11
%182 = load i32, i32* %7
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %227
184: ; preds = %180
store i32 0, i32* %12
br label %185
185: ; preds = %220, %184
%186 = load i32, i32* %12
%187 = load i32, i32* %7
%188 = sub nsw i32 %187, 1
%189 = icmp slt i32 %186, %188
br i1 %189, label %190, label %223
190: ; preds = %185
%191 = load i32*, i32** %5
%192 = load i32, i32* %12
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %191, i64 %193
%195 = load i32, i32* %194
%196 = icmp eq i32 %195, 0
br i1 %196, label %197, label %219
197: ; preds = %190
%198 = load i32*, i32** %5
%199 = load i32, i32* %12
%200 = add nsw i32 %199, 1
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32, i32* %198, i64 %201
%203 = load i32, i32* %202
store i32 %203, i32* %16
%204 = load i32*, i32** %5
%205 = load i32, i32* %12
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %204, i64 %206
%208 = load i32, i32* %207
%209 = load i32*, i32** %5
%210 = load i32, i32* %12
%211 = add nsw i32 %210, 1
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i32, i32* %209, i64 %212
store i32 %208, i32* %213
%214 = load i32, i32* %16
%215 = load i32*, i32** %5
%216 = load i32, i32* %12
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32, i32* %215, i64 %217
store i32 %214, i32* %218
br label %219
219: ; preds = %197, %190
br label %220
220: ; preds = %219
%221 = load i32, i32* %12
%222 = add nsw i32 %221, 1
store i32 %222, i32* %12
br label %185
223: ; preds = %185
br label %224
224: ; preds = %223
%225 = load i32, i32* %11
%226 = add nsw i32 %225, 1
store i32 %226, i32* %11
br label %180
227: ; preds = %180
store i32 0, i32* %11
br label %228
228: ; preds = %272, %227
%229 = load i32, i32* %11
%230 = load i32, i32* %8
%231 = icmp slt i32 %229, %230
br i1 %231, label %232, label %275
232: ; preds = %228
store i32 0, i32* %12
br label %233
233: ; preds = %268, %232
%234 = load i32, i32* %12
%235 = load i32, i32* %8
%236 = sub nsw i32 %235, 1
%237 = icmp slt i32 %234, %236
br i1 %237, label %238, label %271
238: ; preds = %233
%239 = load i32*, i32** %6
%240 = load i32, i32* %12
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %239, i64 %241
%243 = load i32, i32* %242
%244 = icmp eq i32 %243, 0
br i1 %244, label %245, label %267
245: ; preds = %238
%246 = load i32*, i32** %6
%247 = load i32, i32* %12
%248 = add nsw i32 %247, 1
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %246, i64 %249
%251 = load i32, i32* %250
store i32 %251, i32* %16
%252 = load i32*, i32** %6
%253 = load i32, i32* %12
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
%256 = load i32, i32* %255
%257 = load i32*, i32** %6
%258 = load i32, i32* %12
%259 = add nsw i32 %258, 1
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %257, i64 %260
store i32 %256, i32* %261
%262 = load i32, i32* %16
%263 = load i32*, i32** %6
%264 = load i32, i32* %12
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %263, i64 %265
store i32 %262, i32* %266
br label %267
267: ; preds = %245, %238
br label %268
268: ; preds = %267
%269 = load i32, i32* %12
%270 = add nsw i32 %269, 1
store i32 %270, i32* %12
br label %233
271: ; preds = %233
br label %272
272: ; preds = %271
%273 = load i32, i32* %11
%274 = add nsw i32 %273, 1
store i32 %274, i32* %11
br label %228
275: ; preds = %228
%276 = load i32, i32* %7
%277 = add nsw i32 %276, -1
store i32 %277, i32* %7
%278 = load i32*, i32** %5
%279 = load i32, i32* %7
%280 = sext i32 %279 to i64
%281 = mul i64 4, %280
%282 = trunc i64 %281 to i32
%283 = call i64 @realloc(i32* %278, i32 %282)
%284 = inttoptr i64 %283 to i32*
store i32* %284, i32** %5
store i32 0, i32* %11
br label %285
285: ; preds = %304, %275
%286 = load i32, i32* %11
%287 = load i32, i32* %8
%288 = icmp slt i32 %286, %287
br i1 %288, label %289, label %307
289: ; preds = %285
%290 = load i32*, i32** %6
%291 = load i32, i32* %11
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %290, i64 %292
%294 = load i32, i32* %293
%295 = load i32, i32* %14
%296 = add nsw i32 %295, 1
%297 = icmp eq i32 %294, %296
br i1 %297, label %298, label %303
298: ; preds = %289
%299 = load i32*, i32** %6
%300 = load i32, i32* %12
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i32, i32* %299, i64 %301
store i32 0, i32* %302
br label %303
303: ; preds = %298, %289
br label %304
304: ; preds = %303
%305 = load i32, i32* %11
%306 = add nsw i32 %305, 1
store i32 %306, i32* %11
br label %285
307: ; preds = %285
store i32 0, i32* %11
br label %308
308: ; preds = %352, %307
%309 = load i32, i32* %11
%310 = load i32, i32* %8
%311 = icmp slt i32 %309, %310
br i1 %311, label %312, label %355
312: ; preds = %308
store i32 0, i32* %12
br label %313
313: ; preds = %348, %312
%314 = load i32, i32* %12
%315 = load i32, i32* %8
%316 = sub nsw i32 %315, 1
%317 = icmp slt i32 %314, %316
br i1 %317, label %318, label %351
318: ; preds = %313
%319 = load i32*, i32** %6
%320 = load i32, i32* %12
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %319, i64 %321
%323 = load i32, i32* %322
%324 = icmp eq i32 %323, 0
br i1 %324, label %325, label %347
325: ; preds = %318
%326 = load i32*, i32** %6
%327 = load i32, i32* %12
%328 = add nsw i32 %327, 1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i32, i32* %326, i64 %329
%331 = load i32, i32* %330
store i32 %331, i32* %16
%332 = load i32*, i32** %6
%333 = load i32, i32* %12
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i32, i32* %332, i64 %334
%336 = load i32, i32* %335
%337 = load i32*, i32** %6
%338 = load i32, i32* %12
%339 = add nsw i32 %338, 1
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds i32, i32* %337, i64 %340
store i32 %336, i32* %341
%342 = load i32, i32* %16
%343 = load i32*, i32** %6
%344 = load i32, i32* %12
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i32, i32* %343, i64 %345
store i32 %342, i32* %346
br label %347
347: ; preds = %325, %318
br label %348
348: ; preds = %347
%349 = load i32, i32* %12
%350 = add nsw i32 %349, 1
store i32 %350, i32* %12
br label %313
351: ; preds = %313
br label %352
352: ; preds = %351
%353 = load i32, i32* %11
%354 = add nsw i32 %353, 1
store i32 %354, i32* %11
br label %308
355: ; preds = %308
%356 = load i32, i32* %15
%357 = load i32, i32* %8
%358 = sub nsw i32 %357, %356
store i32 %358, i32* %8
%359 = load i32*, i32** %6
%360 = load i32, i32* %8
%361 = sext i32 %360 to i64
%362 = mul i64 4, %361
%363 = trunc i64 %362 to i32
%364 = call i64 @realloc(i32* %359, i32 %363)
%365 = inttoptr i64 %364 to i32*
store i32* %365, i32** %6
store i32 0, i32* %11
br label %366
366: ; preds = %386, %355
%367 = load i32, i32* %11
%368 = load i32, i32* %8
%369 = icmp slt i32 %367, %368
br i1 %369, label %370, label %389
370: ; preds = %366
%371 = load i32*, i32** %6
%372 = load i32, i32* %11
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds i32, i32* %371, i64 %373
%375 = load i32, i32* %374
%376 = load i32, i32* %14
%377 = icmp sgt i32 %375, %376
br i1 %377, label %378, label %385
378: ; preds = %370
%379 = load i32*, i32** %6
%380 = load i32, i32* %11
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i32, i32* %379, i64 %381
%383 = load i32, i32* %382
%384 = add nsw i32 %383, -1
store i32 %384, i32* %382
br label %385
385: ; preds = %378, %370
br label %386
386: ; preds = %385
%387 = load i32, i32* %11
%388 = add nsw i32 %387, 1
store i32 %388, i32* %11
br label %366
389: ; preds = %366
%390 = call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
store i32* %390, i32** %9
%391 = load i32*, i32** %9
%392 = icmp ne i32* %391, null
br i1 %392, label %393, label %431
393: ; preds = %389
store i32 0, i32* %13
store i32 0, i32* %11
br label %394
394: ; preds = %427, %393
%395 = load i32, i32* %11
%396 = load i32, i32* %7
%397 = icmp slt i32 %395, %396
br i1 %397, label %398, label %430
398: ; preds = %394
%399 = load i32*, i32** %9
%400 = load i32, i32* %11
%401 = add nsw i32 %400, 1
%402 = call i32 (i32*, i8*, ...) @fprintf(i32* %399, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %401)
store i32 0, i32* %12
br label %403
403: ; preds = %421, %398
%404 = load i32, i32* %12
%405 = load i32*, i32** %5
%406 = load i32, i32* %11
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
%409 = load i32, i32* %408
%410 = icmp slt i32 %404, %409
br i1 %410, label %411, label %424
411: ; preds = %403
%412 = load i32*, i32** %9
%413 = load i32*, i32** %6
%414 = load i32, i32* %13
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %413, i64 %415
%417 = load i32, i32* %416
%418 = call i32 (i32*, i8*, ...) @fprintf(i32* %412, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %417)
%419 = load i32, i32* %13
%420 = add nsw i32 %419, 1
store i32 %420, i32* %13
br label %421
421: ; preds = %411
%422 = load i32, i32* %12
%423 = add nsw i32 %422, 1
store i32 %423, i32* %12
br label %403
424: ; preds = %403
%425 = load i32*, i32** %9
%426 = call i32 (i32*, i8*, ...) @fprintf(i32* %425, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %427
427: ; preds = %424
%428 = load i32, i32* %11
%429 = add nsw i32 %428, 1
store i32 %429, i32* %11
br label %394
430: ; preds = %394
br label %431
431: ; preds = %430, %389
%432 = load i32*, i32** %9
%433 = call i32 @fclose(i32* %432)
%434 = call i32 @puts(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.14, i64 0, i64 0))
%435 = load i32, i32* @stdin
%436 = call i32 @__fpurge(i32 %435)
%437 = call i32 (...) @getchar()
br label %438
438: ; preds = %431, %87
br label %444
439: ; preds = %72
%440 = load i32, i32* %10
%441 = icmp eq i32 %440, 0
br i1 %441, label %442, label %443
442: ; preds = %439
br label %449
443: ; preds = %439
br label %444
444: ; preds = %443, %438
br label %445
445: ; preds = %444, %67
br label %446
446: ; preds = %445
%447 = load i32, i32* %10
%448 = icmp ne i32 %447, 0
br i1 %448, label %18, label %449
449: ; preds = %442, %446
ret void
}

LLVM IR (-O2):
@.str = [31 x i8] c"Digite 1 para mostrar o grafo\0A\00"
@.str.1 = [34 x i8] c"Digite 2 para remover um vertice\0A\00"
@.str.2 = [38 x i8] c"Digite 0 para voltar ao menu anterior\00"
@.str.3 = [4 x i8] c"::>\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [30 x i8] c"Indice:%i Grau: %i Vizinhos: \00"
@.str.6 = [4 x i8] c"%i \00"
@.str.7 = [2 x i8] c"\0A\00"
@.str.8 = [30 x i8] c"Digite algo para continuar...\00"
@stdin = global i32 0
@.str.9 = [40 x i8] c"Digite o vertice que deseja excluir\0A::>\00"
@.str.10 = [45 x i8] c"Valor invalido\0ADigite algo para continuar...\00"
@.str.11 = [12 x i8] c"entrada.txt\00"
@.str.12 = [2 x i8] c"w\00"
@.str.13 = [5 x i8] c"%i: \00"
@.str.14 = [60 x i8] c"Vertice removido com sucesso!\0ADigite algo para continuar...\00"
define void @submenu(i32* %0, i32* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = bitcast i32* %5 to i8*
%8 = bitcast i32* %6 to i8*
%9 = getelementptr inbounds i32, i32* %6, i64 1
%10 = bitcast i32* %9 to i8*
br label %11
11: ; preds = %596, %4
%12 = phi i32* [ %1, %4 ], [ %598, %596 ]
%13 = phi i32 [ %2, %4 ], [ %599, %596 ]
%14 = phi i32 [ %3, %4 ], [ %600, %596 ]
%15 = phi i32* [ %0, %4 ], [ %601, %596 ]
%16 = call i32 (...) @limpa()
%17 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%18 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
%19 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%21 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %5)
%22 = load i32, i32* %5
switch i32 %22, label %596 [
i32 1, label %23
i32 2, label %61
i32 0, label %603
]
23: ; preds = %11
%24 = call i32 (...) @limpa()
%25 = icmp sgt i32 %13, 0
br i1 %25, label %26, label %56
26: ; preds = %23
%27 = zext i32 %13 to i64
br label %28
28: ; preds = %26, %52
%29 = phi i64 [ 0, %26 ], [ %31, %52 ]
%30 = phi i32 [ 0, %26 ], [ %53, %52 ]
%31 = add nuw nsw i64 %29, 1
%32 = getelementptr inbounds i32, i32* %15, i64 %29
%33 = load i32, i32* %32
%34 = trunc i64 %31 to i32
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0), i32 %34, i32 %33)
%36 = load i32, i32* %32
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %52
38: ; preds = %28
%39 = sext i32 %30 to i64
br label %40
40: ; preds = %38, %40
%41 = phi i64 [ %39, %38 ], [ %46, %40 ]
%42 = phi i32 [ 0, %38 ], [ %47, %40 ]
%43 = getelementptr inbounds i32, i32* %12, i64 %41
%44 = load i32, i32* %43
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %44)
%46 = add nsw i64 %41, 1
%47 = add nuw nsw i32 %42, 1
%48 = load i32, i32* %32
%49 = icmp slt i32 %47, %48
br i1 %49, label %40, label %50
50: ; preds = %40
%51 = trunc i64 %46 to i32
br label %52
52: ; preds = %50, %28
%53 = phi i32 [ %30, %28 ], [ %51, %50 ]
%54 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%55 = icmp eq i64 %31, %27
br i1 %55, label %56, label %28
56: ; preds = %52, %23
%57 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0))
%58 = load i32, i32* @stdin
%59 = call i32 @__fpurge(i32 %58)
%60 = call i32 (...) @getchar()
br label %590
61: ; preds = %11
%62 = call i32 (...) @limpa()
%63 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0))
%64 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %6)
%65 = load i32, i32* %6
%66 = add nsw i32 %65, -1
store i32 %66, i32* %6
%67 = icmp sgt i32 %65, %13
%68 = icmp slt i32 %65, 2
%69 = or i1 %67, %68
br i1 %69, label %580, label %70
70: ; preds = %61
%71 = zext i32 %66 to i64
%72 = getelementptr inbounds i32, i32* %15, i64 %71
%73 = load i32, i32* %72
%74 = icmp sgt i32 %13, 0
br i1 %74, label %75, label %115
75: ; preds = %70
%76 = zext i32 %13 to i64
br label %77
77: ; preds = %75, %108
%78 = phi i64 [ 0, %75 ], [ %111, %108 ]
%79 = phi i32 [ %73, %75 ], [ %110, %108 ]
%80 = phi i32 [ 0, %75 ], [ %109, %108 ]
%81 = getelementptr inbounds i32, i32* %15, i64 %78
%82 = load i32, i32* %81
%83 = icmp sgt i32 %82, 0
br i1 %83, label %84, label %108
84: ; preds = %77
%85 = sext i32 %80 to i64
br label %86
86: ; preds = %84, %100
%87 = phi i32 [ %82, %84 ], [ %101, %100 ]
%88 = phi i64 [ %85, %84 ], [ %103, %100 ]
%89 = phi i32 [ %79, %84 ], [ %102, %100 ]
%90 = phi i32 [ 0, %84 ], [ %104, %100 ]
%91 = getelementptr inbounds i32, i32* %12, i64 %88
%92 = load i32, i32* %91
%93 = load i32, i32* %6
%94 = add nsw i32 %93, 1
%95 = icmp eq i32 %92, %94
br i1 %95, label %96, label %100
96: ; preds = %86
store i32 0, i32* %91
%97 = load i32, i32* %81
%98 = add nsw i32 %97, -1
store i32 %98, i32* %81
%99 = add nsw i32 %89, 1
br label %100
100: ; preds = %96, %86
%101 = phi i32 [ %98, %96 ], [ %87, %86 ]
%102 = phi i32 [ %99, %96 ], [ %89, %86 ]
%103 = add nsw i64 %88, 1
%104 = add nuw nsw i32 %90, 1
%105 = icmp slt i32 %104, %101
br i1 %105, label %86, label %106
106: ; preds = %100
%107 = trunc i64 %103 to i32
br label %108
108: ; preds = %106, %77
%109 = phi i32 [ %80, %77 ], [ %107, %106 ]
%110 = phi i32 [ %79, %77 ], [ %102, %106 ]
%111 = add nuw nsw i64 %78, 1
%112 = icmp eq i64 %111, %76
br i1 %112, label %113, label %77
113: ; preds = %108
%114 = load i32, i32* %6
br label %115
115: ; preds = %113, %70
%116 = phi i32 [ %66, %70 ], [ %114, %113 ]
%117 = phi i32 [ %73, %70 ], [ %110, %113 ]
%118 = sext i32 %116 to i64
%119 = getelementptr inbounds i32, i32* %15, i64 %118
store i32 0, i32* %119
%120 = load i32, i32* %6
%121 = icmp sgt i32 %120, 0
br i1 %121, label %122, label %209
122: ; preds = %115
%123 = zext i32 %120 to i64
%124 = icmp ult i32 %120, 8
br i1 %124, label %206, label %125
125: ; preds = %122
%126 = and i64 %123, 4294967288
%127 = add nsw i64 %126, -8
%128 = lshr exact i64 %127, 3
%129 = add nuw nsw i64 %128, 1
%130 = and i64 %129, 3
%131 = icmp ult i64 %127, 24
br i1 %131, label %177, label %132
132: ; preds = %125
%133 = and i64 %129, 4611686018427387900
br label %134
134: ; preds = %134, %132
%135 = phi i64 [ 0, %132 ], [ %174, %134 ]
%136 = phi <4 x i32> [ zeroinitializer, %132 ], [ %172, %134 ]
%137 = phi <4 x i32> [ zeroinitializer, %132 ], [ %173, %134 ]
%138 = phi i64 [ 0, %132 ], [ %175, %134 ]
%139 = getelementptr inbounds i32, i32* %15, i64 %135
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr inbounds i32, i32* %139, i64 4
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = add <4 x i32> %141, %136
%146 = add <4 x i32> %144, %137
%147 = or i64 %135, 8
%148 = getelementptr inbounds i32, i32* %15, i64 %147
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = getelementptr inbounds i32, i32* %148, i64 4
%152 = bitcast i32* %151 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = add <4 x i32> %150, %145
%155 = add <4 x i32> %153, %146
%156 = or i64 %135, 16
%157 = getelementptr inbounds i32, i32* %15, i64 %156
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = getelementptr inbounds i32, i32* %157, i64 4
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = add <4 x i32> %159, %154
%164 = add <4 x i32> %162, %155
%165 = or i64 %135, 24
%166 = getelementptr inbounds i32, i32* %15, i64 %165
%167 = bitcast i32* %166 to <4 x i32>*
%168 = load <4 x i32>, <4 x i32>* %167
%169 = getelementptr inbounds i32, i32* %166, i64 4
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = add <4 x i32> %168, %163
%173 = add <4 x i32> %171, %164
%174 = add nuw i64 %135, 32
%175 = add i64 %138, 4
%176 = icmp eq i64 %175, %133
br i1 %176, label %177, label %134
177: ; preds = %134, %125
%178 = phi <4 x i32> [ undef, %125 ], [ %172, %134 ]
%179 = phi <4 x i32> [ undef, %125 ], [ %173, %134 ]
%180 = phi i64 [ 0, %125 ], [ %174, %134 ]
%181 = phi <4 x i32> [ zeroinitializer, %125 ], [ %172, %134 ]
%182 = phi <4 x i32> [ zeroinitializer, %125 ], [ %173, %134 ]
%183 = icmp eq i64 %130, 0
br i1 %183, label %200, label %184
184: ; preds = %177, %184
%185 = phi i64 [ %197, %184 ], [ %180, %177 ]
%186 = phi <4 x i32> [ %195, %184 ], [ %181, %177 ]
%187 = phi <4 x i32> [ %196, %184 ], [ %182, %177 ]
%188 = phi i64 [ %198, %184 ], [ 0, %177 ]
%189 = getelementptr inbounds i32, i32* %15, i64 %185
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = getelementptr inbounds i32, i32* %189, i64 4
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = add <4 x i32> %191, %186
%196 = add <4 x i32> %194, %187
%197 = add nuw i64 %185, 8
%198 = add i64 %188, 1
%199 = icmp eq i64 %198, %130
br i1 %199, label %200, label %184
200: ; preds = %184, %177
%201 = phi <4 x i32> [ %178, %177 ], [ %195, %184 ]
%202 = phi <4 x i32> [ %179, %177 ], [ %196, %184 ]
%203 = add <4 x i32> %202, %201
%204 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %203)
%205 = icmp eq i64 %126, %123
br i1 %205, label %209, label %206
206: ; preds = %122, %200
%207 = phi i64 [ 0, %122 ], [ %126, %200 ]
%208 = phi i32 [ 0, %122 ], [ %204, %200 ]
br label %218
209: ; preds = %218, %200, %115
%210 = phi i32 [ 0, %115 ], [ %204, %200 ], [ %223, %218 ]
%211 = icmp sgt i32 %73, 0
br i1 %211, label %212, label %226
212: ; preds = %209
%213 = sext i32 %210 to i64
%214 = getelementptr i32, i32* %12, i64 %213
%215 = bitcast i32* %214 to i8*
%216 = zext i32 %73 to i64
%217 = shl nuw nsw i64 %216, 2
br label %226
218: ; preds = %206, %218
%219 = phi i64 [ %224, %218 ], [ %207, %206 ]
%220 = phi i32 [ %223, %218 ], [ %208, %206 ]
%221 = getelementptr inbounds i32, i32* %15, i64 %219
%222 = load i32, i32* %221
%223 = add nsw i32 %222, %220
%224 = add nuw nsw i64 %219, 1
%225 = icmp eq i64 %224, %123
br i1 %225, label %209, label %218
226: ; preds = %212, %209
br i1 %74, label %227, label %235
227: ; preds = %226
%228 = add nsw i32 %13, -1
%229 = icmp eq i32 %13, 1
%230 = zext i32 %228 to i64
%231 = and i64 %230, 1
%232 = icmp eq i32 %228, 1
%233 = and i64 %230, 4294967294
%234 = icmp eq i64 %231, 0
br label %249
235: ; preds = %283, %226
%236 = icmp sgt i32 %14, 0
br i1 %236, label %241, label %237
237: ; preds = %235
%238 = add nsw i32 %13, -1
%239 = shl i32 %238, 2
%240 = call i64 @realloc(i32* %15, i32 %239)
br label %413
241: ; preds = %235
%242 = add nsw i32 %14, -1
%243 = icmp eq i32 %14, 1
%244 = zext i32 %242 to i64
%245 = and i64 %244, 1
%246 = icmp eq i32 %242, 1
%247 = and i64 %244, 4294967294
%248 = icmp eq i64 %245, 0
br label %286
249: ; preds = %227, %283
%250 = phi i32 [ 0, %227 ], [ %284, %283 ]
br i1 %229, label %283, label %251
251: ; preds = %249
br i1 %232, label %273, label %252
252: ; preds = %251, %270
%253 = phi i64 [ %266, %270 ], [ 0, %251 ]
%254 = phi i64 [ %271, %270 ], [ 0, %251 ]
%255 = getelementptr inbounds i32, i32* %15, i64 %253
%256 = load i32, i32* %255
%257 = icmp eq i32 %256, 0
%258 = or i64 %253, 1
br i1 %257, label %259, label %262
259: ; preds = %252
%260 = getelementptr inbounds i32, i32* %15, i64 %258
%261 = load i32, i32* %260
store i32 0, i32* %260
store i32 %261, i32* %255
br label %262
262: ; preds = %252, %259
%263 = getelementptr inbounds i32, i32* %15, i64 %258
%264 = load i32, i32* %263
%265 = icmp eq i32 %264, 0
%266 = add nuw nsw i64 %253, 2
br i1 %265, label %267, label %270
267: ; preds = %262
%268 = getelementptr inbounds i32, i32* %15, i64 %266
%269 = load i32, i32* %268
store i32 0, i32* %268
store i32 %269, i32* %263
br label %270
270: ; preds = %267, %262
%271 = add i64 %254, 2
%272 = icmp eq i64 %271, %233
br i1 %272, label %273, label %252
273: ; preds = %270, %251
%274 = phi i64 [ 0, %251 ], [ %266, %270 ]
br i1 %234, label %283, label %275
275: ; preds = %273
%276 = getelementptr inbounds i32, i32* %15, i64 %274
%277 = load i32, i32* %276
%278 = icmp eq i32 %277, 0
br i1 %278, label %279, label %283
279: ; preds = %275
%280 = add nuw nsw i64 %274, 1
%281 = getelementptr inbounds i32, i32* %15, i64 %280
%282 = load i32, i32* %281
store i32 0, i32* %281
store i32 %282, i32* %276
br label %283
283: ; preds = %273, %279, %275, %249
%284 = add nuw nsw i32 %250, 1
%285 = icmp eq i32 %284, %13
br i1 %285, label %235, label %249
286: ; preds = %241, %320
%287 = phi i32 [ 0, %241 ], [ %322, %320 ]
br i1 %243, label %320, label %288
288: ; preds = %286
br i1 %246, label %310, label %289
289: ; preds = %288, %307
%290 = phi i64 [ %303, %307 ], [ 0, %288 ]
%291 = phi i64 [ %308, %307 ], [ 0, %288 ]
%292 = getelementptr inbounds i32, i32* %12, i64 %290
%293 = load i32, i32* %292
%294 = icmp eq i32 %293, 0
%295 = or i64 %290, 1
br i1 %294, label %296, label %299
296: ; preds = %289
%297 = getelementptr inbounds i32, i32* %12, i64 %295
%298 = load i32, i32* %297
store i32 0, i32* %297
store i32 %298, i32* %292
br label %299
299: ; preds = %289, %296
%300 = getelementptr inbounds i32, i32* %12, i64 %295
%301 = load i32, i32* %300
%302 = icmp eq i32 %301, 0
%303 = add nuw nsw i64 %290, 2
br i1 %302, label %304, label %307
304: ; preds = %299
%305 = getelementptr inbounds i32, i32* %12, i64 %303
%306 = load i32, i32* %305
store i32 0, i32* %305
store i32 %306, i32* %300
br label %307
307: ; preds = %304, %299
%308 = add i64 %291, 2
%309 = icmp eq i64 %308, %247
br i1 %309, label %310, label %289
310: ; preds = %307, %288
%311 = phi i64 [ 0, %288 ], [ %303, %307 ]
br i1 %248, label %320, label %312
312: ; preds = %310
%313 = getelementptr inbounds i32, i32* %12, i64 %311
%314 = load i32, i32* %313
%315 = icmp eq i32 %314, 0
br i1 %315, label %316, label %320
316: ; preds = %312
%317 = add nuw nsw i64 %311, 1
%318 = getelementptr inbounds i32, i32* %12, i64 %317
%319 = load i32, i32* %318
store i32 0, i32* %318
store i32 %319, i32* %313
br label %320
320: ; preds = %310, %316, %312, %286
%321 = phi i32 [ 0, %286 ], [ %242, %312 ], [ %242, %316 ], [ %242, %310 ]
%322 = add nuw nsw i32 %287, 1
%323 = icmp eq i32 %322, %14
br i1 %323, label %324, label %286
324: ; preds = %320
%325 = add nsw i32 %13, -1
%326 = shl i32 %325, 2
%327 = call i64 @realloc(i32* %15, i32 %326)
br i1 %236, label %328, label %413
328: ; preds = %324
%329 = sext i32 %321 to i64
%330 = getelementptr inbounds i32, i32* %12, i64 %329
%331 = zext i32 %14 to i64
%332 = and i64 %331, 1
%333 = icmp eq i32 %14, 1
br i1 %333, label %336, label %334
334: ; preds = %328
%335 = and i64 %331, 4294967294
br label %355
336: ; preds = %372, %328
%337 = phi i64 [ 0, %328 ], [ %373, %372 ]
%338 = icmp eq i64 %332, 0
br i1 %338, label %346, label %339
339: ; preds = %336
%340 = getelementptr inbounds i32, i32* %12, i64 %337
%341 = load i32, i32* %340
%342 = load i32, i32* %6
%343 = add nsw i32 %342, 1
%344 = icmp eq i32 %341, %343
br i1 %344, label %345, label %346
345: ; preds = %339
store i32 0, i32* %330
br label %346
346: ; preds = %339, %345, %336
br i1 %236, label %347, label %413
347: ; preds = %346
%348 = add nsw i32 %14, -1
%349 = icmp eq i32 %14, 1
%350 = zext i32 %348 to i64
%351 = and i64 %350, 1
%352 = icmp eq i32 %348, 1
%353 = and i64 %350, 4294967294
%354 = icmp eq i64 %351, 0
br label %376
355: ; preds = %372, %334
%356 = phi i64 [ 0, %334 ], [ %373, %372 ]
%357 = phi i64 [ 0, %334 ], [ %374, %372 ]
%358 = getelementptr inbounds i32, i32* %12, i64 %356
%359 = load i32, i32* %358
%360 = load i32, i32* %6
%361 = add nsw i32 %360, 1
%362 = icmp eq i32 %359, %361
br i1 %362, label %363, label %364
363: ; preds = %355
store i32 0, i32* %330
br label %364
364: ; preds = %355, %363
%365 = or i64 %356, 1
%366 = getelementptr inbounds i32, i32* %12, i64 %365
%367 = load i32, i32* %366
%368 = load i32, i32* %6
%369 = add nsw i32 %368, 1
%370 = icmp eq i32 %367, %369
br i1 %370, label %371, label %372
371: ; preds = %364
store i32 0, i32* %330
br label %372
372: ; preds = %371, %364
%373 = add nuw nsw i64 %356, 2
%374 = add i64 %357, 2
%375 = icmp eq i64 %374, %335
br i1 %375, label %336, label %355
376: ; preds = %347, %410
%377 = phi i32 [ 0, %347 ], [ %411, %410 ]
br i1 %349, label %410, label %378
378: ; preds = %376
br i1 %352, label %400, label %379
379: ; preds = %378, %397
%380 = phi i64 [ %393, %397 ], [ 0, %378 ]
%381 = phi i64 [ %398, %397 ], [ 0, %378 ]
%382 = getelementptr inbounds i32, i32* %12, i64 %380
%383 = load i32, i32* %382
%384 = icmp eq i32 %383, 0
%385 = or i64 %380, 1
br i1 %384, label %386, label %389
386: ; preds = %379
%387 = getelementptr inbounds i32, i32* %12, i64 %385
%388 = load i32, i32* %387
store i32 0, i32* %387
store i32 %388, i32* %382
br label %389
389: ; preds = %379, %386
%390 = getelementptr inbounds i32, i32* %12, i64 %385
%391 = load i32, i32* %390
%392 = icmp eq i32 %391, 0
%393 = add nuw nsw i64 %380, 2
br i1 %392, label %394, label %397
394: ; preds = %389
%395 = getelementptr inbounds i32, i32* %12, i64 %393
%396 = load i32, i32* %395
store i32 0, i32* %395
store i32 %396, i32* %390
br label %397
397: ; preds = %394, %389
%398 = add i64 %381, 2
%399 = icmp eq i64 %398, %353
br i1 %399, label %400, label %379
400: ; preds = %397, %378
%401 = phi i64 [ 0, %378 ], [ %393, %397 ]
br i1 %354, label %410, label %402
402: ; preds = %400
%403 = getelementptr inbounds i32, i32* %12, i64 %401
%404 = load i32, i32* %403
%405 = icmp eq i32 %404, 0
br i1 %405, label %406, label %410
406: ; preds = %402
%407 = add nuw nsw i64 %401, 1
%408 = getelementptr inbounds i32, i32* %12, i64 %407
%409 = load i32, i32* %408
store i32 0, i32* %408
store i32 %409, i32* %403
br label %410
410: ; preds = %400, %406, %402, %376
%411 = add nuw nsw i32 %377, 1
%412 = icmp eq i32 %411, %14
br i1 %412, label %413, label %376
413: ; preds = %410, %324, %237, %346
%414 = phi i32 [ %325, %346 ], [ %325, %324 ], [ %238, %237 ], [ %325, %410 ]
%415 = phi i64 [ %327, %346 ], [ %327, %324 ], [ %240, %237 ], [ %327, %410 ]
%416 = inttoptr i64 %415 to i32*
%417 = sub nsw i32 %14, %117
%418 = shl i32 %417, 2
%419 = call i64 @realloc(i32* %12, i32 %418)
%420 = inttoptr i64 %419 to i32*
%421 = inttoptr i64 %419 to i8*
%422 = icmp sgt i32 %417, 0
br i1 %422, label %423, label %544
423: ; preds = %413
%424 = zext i32 %417 to i64
%425 = icmp ult i32 %417, 8
br i1 %425, label %507, label %426
426: ; preds = %423
%427 = getelementptr i32, i32* %420, i64 %424
%428 = icmp ult i8* %421, %10
%429 = icmp ult i32* %6, %427
%430 = and i1 %428, %429
br i1 %430, label %507, label %431
431: ; preds = %426
%432 = and i64 %424, 4294967288
%433 = load i32, i32* %6
%434 = insertelement <4 x i32> poison, i32 %433, i64 0
%435 = shufflevector <4 x i32> %434, <4 x i32> poison, <4 x i32> zeroinitializer
%436 = insertelement <4 x i32> poison, i32 %433, i64 0
%437 = shufflevector <4 x i32> %436, <4 x i32> poison, <4 x i32> zeroinitializer
br label %438
438: ; preds = %502, %431
%439 = phi i64 [ 0, %431 ], [ %503, %502 ]
%440 = or i64 %439, 4
%441 = getelementptr inbounds i32, i32* %420, i64 %439
%442 = bitcast i32* %441 to <4 x i32>*
%443 = load <4 x i32>, <4 x i32>* %442
%444 = getelementptr inbounds i32, i32* %441, i64 4
%445 = bitcast i32* %444 to <4 x i32>*
%446 = load <4 x i32>, <4 x i32>* %445
%447 = icmp sgt <4 x i32> %443, %435
%448 = icmp sgt <4 x i32> %446, %437
%449 = extractelement <4 x i1> %447, i64 0
br i1 %449, label %450, label %454
450: ; preds = %438
%451 = extractelement <4 x i32> %443, i64 0
%452 = add nsw i32 %451, -1
%453 = getelementptr inbounds i32, i32* %420, i64 %439
store i32 %452, i32* %453
br label %454
454: ; preds = %450, %438
%455 = extractelement <4 x i1> %447, i64 1
br i1 %455, label %456, label %461
456: ; preds = %454
%457 = or i64 %439, 1
%458 = extractelement <4 x i32> %443, i64 1
%459 = add nsw i32 %458, -1
%460 = getelementptr inbounds i32, i32* %420, i64 %457
store i32 %459, i32* %460
br label %461
461: ; preds = %456, %454
%462 = extractelement <4 x i1> %447, i64 2
br i1 %462, label %463, label %468
463: ; preds = %461
%464 = or i64 %439, 2
%465 = extractelement <4 x i32> %443, i64 2
%466 = add nsw i32 %465, -1
%467 = getelementptr inbounds i32, i32* %420, i64 %464
store i32 %466, i32* %467
br label %468
468: ; preds = %463, %461
%469 = extractelement <4 x i1> %447, i64 3
br i1 %469, label %470, label %475
470: ; preds = %468
%471 = or i64 %439, 3
%472 = extractelement <4 x i32> %443, i64 3
%473 = add nsw i32 %472, -1
%474 = getelementptr inbounds i32, i32* %420, i64 %471
store i32 %473, i32* %474
br label %475
475: ; preds = %470, %468
%476 = extractelement <4 x i1> %448, i64 0
br i1 %476, label %477, label %481
477: ; preds = %475
%478 = extractelement <4 x i32> %446, i64 0
%479 = add nsw i32 %478, -1
%480 = getelementptr inbounds i32, i32* %420, i64 %440
store i32 %479, i32* %480
br label %481
481: ; preds = %477, %475
%482 = extractelement <4 x i1> %448, i64 1
br i1 %482, label %483, label %488
483: ; preds = %481
%484 = or i64 %439, 5
%485 = extractelement <4 x i32> %446, i64 1
%486 = add nsw i32 %485, -1
%487 = getelementptr inbounds i32, i32* %420, i64 %484
store i32 %486, i32* %487
br label %488
488: ; preds = %483, %481
%489 = extractelement <4 x i1> %448, i64 2
br i1 %489, label %490, label %495
490: ; preds = %488
%491 = or i64 %439, 6
%492 = extractelement <4 x i32> %446, i64 2
%493 = add nsw i32 %492, -1
%494 = getelementptr inbounds i32, i32* %420, i64 %491
store i32 %493, i32* %494
br label %495
495: ; preds = %490, %488
%496 = extractelement <4 x i1> %448, i64 3
br i1 %496, label %497, label %502
497: ; preds = %495
%498 = or i64 %439, 7
%499 = extractelement <4 x i32> %446, i64 3
%500 = add nsw i32 %499, -1
%501 = getelementptr inbounds i32, i32* %420, i64 %498
store i32 %500, i32* %501
br label %502
502: ; preds = %497, %495
%503 = add nuw i64 %439, 8
%504 = icmp eq i64 %503, %432
br i1 %504, label %505, label %438
505: ; preds = %502
%506 = icmp eq i64 %432, %424
br i1 %506, label %544, label %507
507: ; preds = %426, %423, %505
%508 = phi i64 [ 0, %426 ], [ 0, %423 ], [ %432, %505 ]
%509 = xor i64 %508, -1
%510 = and i64 %424, 1
%511 = icmp eq i64 %510, 0
br i1 %511, label %521, label %512
512: ; preds = %507
%513 = getelementptr inbounds i32, i32* %420, i64 %508
%514 = load i32, i32* %513
%515 = load i32, i32* %6
%516 = icmp sgt i32 %514, %515
br i1 %516, label %517, label %519
517: ; preds = %512
%518 = add nsw i32 %514, -1
store i32 %518, i32* %513
br label %519
519: ; preds = %517, %512
%520 = or i64 %508, 1
br label %521
521: ; preds = %519, %507
%522 = phi i64 [ %508, %507 ], [ %520, %519 ]
%523 = sub nsw i64 0, %424
%524 = icmp eq i64 %509, %523
br i1 %524, label %544, label %525
525: ; preds = %521, %541
%526 = phi i64 [ %542, %541 ], [ %522, %521 ]
%527 = getelementptr inbounds i32, i32* %420, i64 %526
%528 = load i32, i32* %527
%529 = load i32, i32* %6
%530 = icmp sgt i32 %528, %529
br i1 %530, label %531, label %533
531: ; preds = %525
%532 = add nsw i32 %528, -1
store i32 %532, i32* %527
br label %533
533: ; preds = %525, %531
%534 = add nuw nsw i64 %526, 1
%535 = getelementptr inbounds i32, i32* %420, i64 %534
%536 = load i32, i32* %535
%537 = load i32, i32* %6
%538 = icmp sgt i32 %536, %537
br i1 %538, label %539, label %541
539: ; preds = %533
%540 = add nsw i32 %536, -1
store i32 %540, i32* %535
br label %541
541: ; preds = %539, %533
%542 = add nuw nsw i64 %526, 2
%543 = icmp eq i64 %542, %424
br i1 %543, label %544, label %525
544: ; preds = %521, %541, %505, %413
%545 = call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
%546 = icmp ne i32* %545, null
%547 = icmp sgt i32 %13, 1
%548 = select i1 %546, i1 %547, i1 false
br i1 %548, label %549, label %578
549: ; preds = %544
%550 = zext i32 %414 to i64
br label %551
551: ; preds = %549, %574
%552 = phi i64 [ 0, %549 ], [ %554, %574 ]
%553 = phi i32 [ 0, %549 ], [ %575, %574 ]
%554 = add nuw nsw i64 %552, 1
%555 = trunc i64 %554 to i32
%556 = call i32 (i32*, i8*, ...) @fprintf(i32* %545, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %555)
%557 = getelementptr inbounds i32, i32* %416, i64 %552
%558 = load i32, i32* %557
%559 = icmp sgt i32 %558, 0
br i1 %559, label %560, label %574
560: ; preds = %551
%561 = sext i32 %553 to i64
br label %562
562: ; preds = %560, %562
%563 = phi i64 [ %561, %560 ], [ %568, %562 ]
%564 = phi i32 [ 0, %560 ], [ %569, %562 ]
%565 = getelementptr inbounds i32, i32* %420, i64 %563
%566 = load i32, i32* %565
%567 = call i32 (i32*, i8*, ...) @fprintf(i32* %545, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %566)
%568 = add nsw i64 %563, 1
%569 = add nuw nsw i32 %564, 1
%570 = load i32, i32* %557
%571 = icmp slt i32 %569, %570
br i1 %571, label %562, label %572
572: ; preds = %562
%573 = trunc i64 %568 to i32
br label %574
574: ; preds = %572, %551
%575 = phi i32 [ %553, %551 ], [ %573, %572 ]
%576 = call i32 @fputc(i32 10, i32* %545)
%577 = icmp eq i64 %554, %550
br i1 %577, label %578, label %551
578: ; preds = %574, %544
%579 = call i32 @fclose(i32* %545)
br label %580
580: ; preds = %61, %578
%581 = phi i8* [ getelementptr inbounds ([60 x i8], [60 x i8]* @.str.14, i64 0, i64 0), %578 ], [ getelementptr inbounds ([45 x i8], [45 x i8]* @.str.10, i64 0, i64 0), %61 ]
%582 = phi i32* [ %420, %578 ], [ %12, %61 ]
%583 = phi i32 [ %414, %578 ], [ %13, %61 ]
%584 = phi i32 [ %417, %578 ], [ %14, %61 ]
%585 = phi i32* [ %416, %578 ], [ %15, %61 ]
%586 = call i32 @puts(i8* dereferenceable(1) %581)
%587 = load i32, i32* @stdin
%588 = call i32 @__fpurge(i32 %587)
%589 = call i32 (...) @getchar()
br label %590
590: ; preds = %580, %56
%591 = phi i32* [ %582, %580 ], [ %12, %56 ]
%592 = phi i32 [ %583, %580 ], [ %13, %56 ]
%593 = phi i32 [ %584, %580 ], [ %14, %56 ]
%594 = phi i32* [ %585, %580 ], [ %15, %56 ]
%595 = load i32, i32* %5
br label %596
596: ; preds = %590, %11
%597 = phi i32 [ %595, %590 ], [ %22, %11 ]
%598 = phi i32* [ %591, %590 ], [ %12, %11 ]
%599 = phi i32 [ %592, %590 ], [ %13, %11 ]
%600 = phi i32 [ %593, %590 ], [ %14, %11 ]
%601 = phi i32* [ %594, %590 ], [ %15, %11 ]
%602 = icmp eq i32 %597, 0
br i1 %602, label %603, label %11
603: ; preds = %596, %11
ret void
}