#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*/ limpa();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ puts(char *);
int /*<<< orphan*/ scanf(char *, int *);
void euleriano(int *vert, int *adj, int cont, int cont2) {
  limpa();
  int vert_cop[cont], adj_cop[cont2], i, j,
      k = 0, vet_in, vet_sai, euleriano[cont], vazio = 0, soma_grau = 0,
      soma_grau2 = 0, aux = 0;
  for (i = 0; i < cont; i++) {
    printf("%i ", adj[k]);
    vert_cop[i] = vert[i];
    for (j = 0; j < vert[i]; j++) {
      adj_cop[k] = adj[k];
      k++;
    }
  }
  k = 0;
  for (i = 0; i < cont; i++) {
    if (vert_cop[i] % 2 != 0) {
      printf("\nO grafo possui o vertice %i com grau impar!\nPortanto nao "
             "temos um caminho euleriano\n",
             i + 1);
      return;
    }
  }
  puts("O grafo possui todos os vertices com grau par!\nProcurando o caminho "
       "euleriano...");
  printf("Digite o vetor de inicio\n::>");
  scanf("%i", &vet_in);
  limpa();
  vet_sai = vet_in;
  do {
    puts("Entrada 1");
    for (i = 0; i < vet_sai - 1; i++) {
      soma_grau += vert[i];
    }
    puts("\nEntrada 2");
    while (adj[soma_grau] == 0) {
      soma_grau++;
    }
    puts("Entrada 3");
    for (i = 0; i < adj[soma_grau] - 1; i++) {
      soma_grau2 += vert[i];
    }
    puts("Entrada 4");
    aux = adj[soma_grau];
    puts("Entrada 5");
    while (adj[soma_grau2] != vet_sai) {
      soma_grau2++;
    }
    puts("Entrada 6");
    euleriano[k] = vet_sai;
    puts("Entrada 7");
    adj[soma_grau2] = 0;
    puts("Entrada 8");
    adj[soma_grau] = 0;
    puts("Entrada 9");
    vert_cop[adj[soma_grau] - 1]--;
    puts("Entrada 10");
    vert_cop[vet_sai - 1]--;
    puts("Entrada 11");
    vet_sai = aux;
    puts("Entrada 12");
    soma_grau2 = 0;
    puts("Entrada 13");
    soma_grau = 0;
    puts("Entrada 14");
    vazio = 0;
    puts("Entrada 15");
    for (i = 0; i < cont2 - 1; i++) {
      if (adj[i] == 0) {
        vazio++;
      }
    }
    puts("Entrada 16");
    k++;
    euleriano[k] = vet_sai;
  } while (vazio != cont2 - 1);
  if (vet_in == vet_sai) {
    printf("Caminho euleriano encontrado\n");
    for (i = 0; i < k; i++) {
      printf("%i ->", euleriano[i]);
    }
    printf("%i\n", euleriano[i]);
  }
}


x86 assembly (clang, -O0):
<euleriano>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
xor    %eax,%eax
call   1050 <limpa@plt>
mov    -0x14(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1287 <euleriano+0x147>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xdf1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x80(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1274 <euleriano+0x134>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1233 <euleriano+0xf3>
jmp    1279 <euleriano+0x139>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f1 <euleriano+0xb1>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12f0 <euleriano+0x1b0>
mov    -0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12dd <euleriano+0x19d>
mov    -0x34(%rbp),%esi
add    $0x1,%esi
lea    0xd3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x64(%rbp)
jmp    160a <euleriano+0x4ca>
jmp    12e2 <euleriano+0x1a2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1295 <euleriano+0x155>
lea    0xd63(%rip),%rdi
call   1030 <puts@plt>
lea    0xda8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xdb7(%rip),%rdi
lea    -0x40(%rbp),%rsi
call   1060 <scanf@plt>
mov    $0x0,%al
call   1050 <limpa@plt>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
lea    0xd9d(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    136a <euleriano+0x22a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133a <euleriano+0x1fa>
lea    0xd64(%rip),%rdi
call   1030 <puts@plt>
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1396 <euleriano+0x256>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1376 <euleriano+0x236>
lea    0xd43(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13e1 <euleriano+0x2a1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a9 <euleriano+0x269>
lea    0xd02(%rip),%rdi
call   1030 <puts@plt>
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
lea    0xcf2(%rip),%rdi
call   1030 <puts@plt>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x44(%rbp),%eax
je     1429 <euleriano+0x2e9>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1407 <euleriano+0x2c7>
lea    0xcce(%rip),%rdi
call   1030 <puts@plt>
mov    -0x70(%rbp),%rax
mov    -0x44(%rbp),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
lea    0xcbe(%rip),%rdi
call   1030 <puts@plt>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
lea    0xcad(%rip),%rdi
call   1030 <puts@plt>
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
lea    0xc9c(%rip),%rdi
call   1030 <puts@plt>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
lea    0xc7c(%rip),%rdi
call   1030 <puts@plt>
mov    -0x80(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
lea    0xc65(%rip),%rdi
call   1030 <puts@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0x44(%rbp)
lea    0xc5e(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x5c(%rbp)
lea    0xc56(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x58(%rbp)
lea    0xc4e(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x54(%rbp)
lea    0xc46(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1562 <euleriano+0x422>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    154f <euleriano+0x40f>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1554 <euleriano+0x414>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1523 <euleriano+0x3e3>
lea    0xbff(%rip),%rdi
call   1030 <puts@plt>
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x3c(%rbp)
mov    -0x44(%rbp),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1327 <euleriano+0x1e7>
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jne    1603 <euleriano+0x4c3>
lea    0xbca(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    15ea <euleriano+0x4aa>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xbbc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15b7 <euleriano+0x477>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xb9b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<euleriano>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rcx,-0x58(%rbp)
mov    %edx,%ebx
mov    %rsi,-0x38(%rbp)
mov    %rdi,%r15
xor    %eax,%eax
call   1050 <limpa@plt>
mov    %ebx,%r14d
mov    %rsp,%rcx
lea    0xf(,%r14,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
test   %ebx,%ebx
jle    1203 <euleriano+0xc3>
mov    %ebx,-0x40(%rbp)
xor    %ebx,%ebx
xor    %r12d,%r12d
mov    -0x38(%rbp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r12d,%r12
mov    0x0(%r13,%r12,4),%esi
lea    0xe41(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x60(%rbp),%rcx
mov    (%r15,%rbx,4),%eax
mov    %eax,(%rcx,%rbx,4)
test   %eax,%eax
mov    $0x0,%edx
cmovs  %edx,%eax
add    %eax,%r12d
add    $0x1,%rbx
cmp    %rbx,%r14
jne    11b0 <euleriano+0x70>
cmpl   $0x0,-0x40(%rbp)
jle    1203 <euleriano+0xc3>
xor    %esi,%esi
nop
testb  $0x1,(%rcx,%rsi,4)
jne    180a <euleriano+0x6ca>
add    $0x1,%rsi
cmp    %rsi,%r14
jne    11f0 <euleriano+0xb0>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
lea    0xe46(%rip),%rdi
call   1030 <puts@plt>
lea    0xe8b(%rip),%rdi
xor    %r12d,%r12d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe97(%rip),%rdi
lea    -0x2c(%rbp),%rsi
call   1060 <scanf@plt>
xor    %eax,%eax
call   1050 <limpa@plt>
mov    -0x2c(%rbp),%esi
mov    -0x58(%rbp),%rax
lea    -0x1(%rax),%r14d
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x80(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x78(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
lea    0x2(%rbx),%rdx
mov    %rax,%rcx
mov    %rax,-0x70(%rbp)
and    %rax,%rdx
mov    %rdx,-0x68(%rbp)
lea    0x10(%r15),%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x88(%rbp)
mov    $0x1,%eax
mov    %r14,-0x90(%rbp)
jmp    12cf <euleriano+0x18f>
nopl   (%rax)
lea    0xec1(%rip),%rdi
call   1030 <puts@plt>
mov    -0x40(%rbp),%rcx
lea    0x1(%rcx),%r12
mov    -0x44(%rbp),%esi
mov    %esi,0x4(%r13,%rcx,4)
mov    -0xa0(%rbp),%rdx
lea    0x1(%rdx),%eax
cmp    %r14d,%ebx
je     179b <euleriano+0x65b>
mov    %esi,%r14d
mov    %r12,-0x40(%rbp)
mov    %rax,-0xa0(%rbp)
lea    0xde7(%rip),%rdi
call   1030 <puts@plt>
lea    -0x1(%r14),%r8d
mov    $0x0,%ebx
cmp    $0x2,%r14d
jl     142d <euleriano+0x2ed>
mov    %r8d,%eax
cmp    $0x8,%r8d
jae    1310 <euleriano+0x1d0>
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    1420 <euleriano+0x2e0>
xchg   %ax,%ax
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    133e <euleriano+0x1fe>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    13c1 <euleriano+0x281>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%r15,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r15,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r15,%rsi,4),%xmm1
movdqu 0x30(%r15,%rsi,4),%xmm3
movdqu 0x40(%r15,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r15,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r15,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r15,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1360 <euleriano+0x220>
test   %rdx,%rdx
je     13fc <euleriano+0x2bc>
mov    -0x50(%rbp),%rdi
lea    (%rdi,%rsi,4),%rsi
shl    $0x5,%rdx
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,%rdx
jne    13e0 <euleriano+0x2a0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rax,%rcx
je     142d <euleriano+0x2ed>
nopl   0x0(%rax,%rax,1)
add    (%r15,%rcx,4),%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1420 <euleriano+0x2e0>
mov    %r8d,-0x48(%rbp)
lea    0xc9d(%rip),%rdi
call   1030 <puts@plt>
movslq %ebx,%rax
mov    -0x88(%rbp),%rcx
lea    (%rcx,%rax,4),%r12
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0x4(%r12)
lea    0x4(%r12),%r12
je     1450 <euleriano+0x310>
lea    0xc7c(%rip),%rdi
call   1030 <puts@plt>
mov    (%r12),%eax
xor    %r13d,%r13d
cmp    $0x2,%eax
jl     15ad <euleriano+0x46d>
add    $0xffffffff,%eax
cmp    $0x8,%eax
jae    1490 <euleriano+0x350>
xor    %ecx,%ecx
xor    %r13d,%r13d
jmp    15a0 <euleriano+0x460>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    14be <euleriano+0x37e>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    1541 <euleriano+0x401>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%r15,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r15,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r15,%rsi,4),%xmm1
movdqu 0x30(%r15,%rsi,4),%xmm3
movdqu 0x40(%r15,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r15,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r15,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r15,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    14e0 <euleriano+0x3a0>
test   %rdx,%rdx
je     157c <euleriano+0x43c>
mov    -0x50(%rbp),%rdi
lea    (%rdi,%rsi,4),%rsi
shl    $0x5,%rdx
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,%rdx
jne    1560 <euleriano+0x420>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r13d
cmp    %rax,%rcx
je     15ad <euleriano+0x46d>
nopl   0x0(%rax)
add    (%r15,%rcx,4),%r13d
add    $0x1,%rcx
cmp    %rcx,%rax
jne    15a0 <euleriano+0x460>
lea    0xb36(%rip),%rdi
call   1030 <puts@plt>
mov    (%r12),%eax
mov    %eax,-0x44(%rbp)
lea    0xb2d(%rip),%rdi
call   1030 <puts@plt>
movslq %r13d,%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
add    $0x4,%rbx
cmp    %r14d,(%rax)
jne    15e0 <euleriano+0x4a0>
lea    0xb0b(%rip),%rdi
call   1030 <puts@plt>
mov    -0x98(%rbp),%r13
mov    -0x40(%rbp),%rax
mov    %r14d,0x0(%r13,%rax,4)
lea    0xaf9(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,-0x4(%rbx)
lea    0xaf0(%rip),%rdi
call   1030 <puts@plt>
movl   $0x0,(%r12)
lea    0xae6(%rip),%rdi
call   1030 <puts@plt>
movslq (%r12),%rax
mov    -0x60(%rbp),%rbx
addl   $0xffffffff,-0x4(%rbx,%rax,4)
lea    0xad7(%rip),%rdi
call   1030 <puts@plt>
movslq -0x48(%rbp),%rax
addl   $0xffffffff,(%rbx,%rax,4)
lea    0xace(%rip),%rdi
call   1030 <puts@plt>
lea    0xacd(%rip),%rdi
call   1030 <puts@plt>
lea    0xacc(%rip),%rdi
call   1030 <puts@plt>
lea    0xacb(%rip),%rdi
call   1030 <puts@plt>
lea    0xaca(%rip),%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
cmpl   $0x2,-0x58(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x90(%rbp),%r14
jl     12a0 <euleriano+0x160>
cmp    $0x8,%r14d
jae    16c0 <euleriano+0x580>
xor    %eax,%eax
xor    %ebx,%ebx
jmp    1770 <euleriano+0x630>
xchg   %ax,%ax
cmpq   $0x0,-0x78(%rbp)
je     1785 <euleriano+0x645>
pxor   %xmm0,%xmm0
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
pxor   %xmm1,%xmm1
pxor   %xmm6,%xmm6
nopl   (%rax)
movdqu (%rdx,%rax,4),%xmm2
movdqu 0x10(%rdx,%rax,4),%xmm3
movdqu 0x20(%rdx,%rax,4),%xmm4
movdqu 0x30(%rdx,%rax,4),%xmm5
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
pcmpeqd %xmm6,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm6,%xmm4
psubd  %xmm4,%xmm0
pcmpeqd %xmm6,%xmm5
psubd  %xmm5,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    16e0 <euleriano+0x5a0>
testb  $0x1,-0x70(%rbp)
je     1742 <euleriano+0x602>
movdqu (%rdx,%rax,4),%xmm2
movdqu 0x10(%rdx,%rax,4),%xmm3
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
pcmpeqd %xmm6,%xmm3
psubd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
mov    -0x80(%rbp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
je     12a0 <euleriano+0x160>
nopl   0x0(%rax)
cmpl   $0x1,(%rdx,%rax,4)
adc    $0x0,%ebx
add    $0x1,%rax
cmp    %rax,%r14
jne    1770 <euleriano+0x630>
jmp    12a0 <euleriano+0x160>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
pxor   %xmm6,%xmm6
testb  $0x1,-0x70(%rbp)
jne    1727 <euleriano+0x5e7>
jmp    1742 <euleriano+0x602>
cmp    %esi,-0x2c(%rbp)
jne    17fb <euleriano+0x6bb>
lea    0x9d6(%rip),%rdi
mov    %rcx,%r12
mov    %rdx,%rbx
call   1030 <puts@plt>
add    $0x1,%r12d
mov    %ebx,%r15d
lea    0x9b3(%rip),%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    17d0 <euleriano+0x690>
mov    0x0(%r13,%r12,4),%esi
lea    0x985(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%esi
lea    0x7f0(%rip),%rdi
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <printf@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%i \00"
@.str.1 = [86 x i8] c"\0AO grafo possui o vertice %i com grau impar!\0APortanto nao temos um caminho euleriano\0A\00"
@.str.2 = [81 x i8] c"O grafo possui todos os vertices com grau par!\0AProcurando o caminho euleriano...\00"
@.str.3 = [29 x i8] c"Digite o vetor de inicio\0A::>\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [10 x i8] c"Entrada 1\00"
@.str.6 = [11 x i8] c"\0AEntrada 2\00"
@.str.7 = [10 x i8] c"Entrada 3\00"
@.str.8 = [10 x i8] c"Entrada 4\00"
@.str.9 = [10 x i8] c"Entrada 5\00"
@.str.10 = [10 x i8] c"Entrada 6\00"
@.str.11 = [10 x i8] c"Entrada 7\00"
@.str.12 = [10 x i8] c"Entrada 8\00"
@.str.13 = [10 x i8] c"Entrada 9\00"
@.str.14 = [11 x i8] c"Entrada 10\00"
@.str.15 = [11 x i8] c"Entrada 11\00"
@.str.16 = [11 x i8] c"Entrada 12\00"
@.str.17 = [11 x i8] c"Entrada 13\00"
@.str.18 = [11 x i8] c"Entrada 14\00"
@.str.19 = [11 x i8] c"Entrada 15\00"
@.str.20 = [11 x i8] c"Entrada 16\00"
@.str.21 = [30 x i8] c"Caminho euleriano encontrado\0A\00"
@.str.22 = [6 x i8] c"%i ->\00"
@.str.23 = [4 x i8] c"%i\0A\00"
define void @euleriano(i32* %0, i32* %1, i32 %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i64
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i64
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%23 = call i32 (...) @limpa()
%24 = load i32, i32* %7
%25 = zext i32 %24 to i64
%26 = call i8* @llvm.stacksave()
store i8* %26, i8** %9
%27 = alloca i32, i64 %25
store i64 %25, i64* %10
%28 = load i32, i32* %8
%29 = zext i32 %28 to i64
%30 = alloca i32, i64 %29
store i64 %29, i64* %11
store i32 0, i32* %14
%31 = load i32, i32* %7
%32 = zext i32 %31 to i64
%33 = alloca i32, i64 %32
store i64 %32, i64* %17
store i32 0, i32* %18
store i32 0, i32* %19
store i32 0, i32* %20
store i32 0, i32* %21
store i32 0, i32* %12
br label %34
34: ; preds = %76, %4
%35 = load i32, i32* %12
%36 = load i32, i32* %7
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %79
38: ; preds = %34
%39 = load i32*, i32** %6
%40 = load i32, i32* %14
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %39, i64 %41
%43 = load i32, i32* %42
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %43)
%45 = load i32*, i32** %5
%46 = load i32, i32* %12
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
%49 = load i32, i32* %48
%50 = load i32, i32* %12
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %27, i64 %51
store i32 %49, i32* %52
store i32 0, i32* %13
br label %53
53: ; preds = %72, %38
%54 = load i32, i32* %13
%55 = load i32*, i32** %5
%56 = load i32, i32* %12
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
%59 = load i32, i32* %58
%60 = icmp slt i32 %54, %59
br i1 %60, label %61, label %75
61: ; preds = %53
%62 = load i32*, i32** %6
%63 = load i32, i32* %14
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
%66 = load i32, i32* %65
%67 = load i32, i32* %14
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %30, i64 %68
store i32 %66, i32* %69
%70 = load i32, i32* %14
%71 = add nsw i32 %70, 1
store i32 %71, i32* %14
br label %72
72: ; preds = %61
%73 = load i32, i32* %13
%74 = add nsw i32 %73, 1
store i32 %74, i32* %13
br label %53
75: ; preds = %53
br label %76
76: ; preds = %75
%77 = load i32, i32* %12
%78 = add nsw i32 %77, 1
store i32 %78, i32* %12
br label %34
79: ; preds = %34
store i32 0, i32* %14
store i32 0, i32* %12
br label %80
80: ; preds = %96, %79
%81 = load i32, i32* %12
%82 = load i32, i32* %7
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %99
84: ; preds = %80
%85 = load i32, i32* %12
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %27, i64 %86
%88 = load i32, i32* %87
%89 = srem i32 %88, 2
%90 = icmp ne i32 %89, 0
br i1 %90, label %91, label %95
91: ; preds = %84
%92 = load i32, i32* %12
%93 = add nsw i32 %92, 1
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.1, i64 0, i64 0), i32 %93)
store i32 1, i32* %22
br label %274
95: ; preds = %84
br label %96
96: ; preds = %95
%97 = load i32, i32* %12
%98 = add nsw i32 %97, 1
store i32 %98, i32* %12
br label %80
99: ; preds = %80
%100 = call i32 @puts(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.2, i64 0, i64 0))
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0))
%102 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %15)
%103 = call i32 (...) @limpa()
%104 = load i32, i32* %15
store i32 %104, i32* %16
br label %105
105: ; preds = %243, %99
%106 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %12
br label %107
107: ; preds = %120, %105
%108 = load i32, i32* %12
%109 = load i32, i32* %16
%110 = sub nsw i32 %109, 1
%111 = icmp slt i32 %108, %110
br i1 %111, label %112, label %123
112: ; preds = %107
%113 = load i32*, i32** %5
%114 = load i32, i32* %12
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = load i32, i32* %19
%119 = add nsw i32 %118, %117
store i32 %119, i32* %19
br label %120
120: ; preds = %112
%121 = load i32, i32* %12
%122 = add nsw i32 %121, 1
store i32 %122, i32* %12
br label %107
123: ; preds = %107
%124 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i64 0, i64 0))
br label %125
125: ; preds = %132, %123
%126 = load i32*, i32** %6
%127 = load i32, i32* %19
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
%130 = load i32, i32* %129
%131 = icmp eq i32 %130, 0
br i1 %131, label %132, label %135
132: ; preds = %125
%133 = load i32, i32* %19
%134 = add nsw i32 %133, 1
store i32 %134, i32* %19
br label %125
135: ; preds = %125
%136 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %12
br label %137
137: ; preds = %154, %135
%138 = load i32, i32* %12
%139 = load i32*, i32** %6
%140 = load i32, i32* %19
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = sub nsw i32 %143, 1
%145 = icmp slt i32 %138, %144
br i1 %145, label %146, label %157
146: ; preds = %137
%147 = load i32*, i32** %5
%148 = load i32, i32* %12
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i32, i32* %147, i64 %149
%151 = load i32, i32* %150
%152 = load i32, i32* %20
%153 = add nsw i32 %152, %151
store i32 %153, i32* %20
br label %154
154: ; preds = %146
%155 = load i32, i32* %12
%156 = add nsw i32 %155, 1
store i32 %156, i32* %12
br label %137
157: ; preds = %137
%158 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0))
%159 = load i32*, i32** %6
%160 = load i32, i32* %19
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %159, i64 %161
%163 = load i32, i32* %162
store i32 %163, i32* %21
%164 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
br label %165
165: ; preds = %173, %157
%166 = load i32*, i32** %6
%167 = load i32, i32* %20
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %166, i64 %168
%170 = load i32, i32* %169
%171 = load i32, i32* %16
%172 = icmp ne i32 %170, %171
br i1 %172, label %173, label %176
173: ; preds = %165
%174 = load i32, i32* %20
%175 = add nsw i32 %174, 1
store i32 %175, i32* %20
br label %165
176: ; preds = %165
%177 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%178 = load i32, i32* %16
%179 = load i32, i32* %14
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %33, i64 %180
store i32 %178, i32* %181
%182 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
%183 = load i32*, i32** %6
%184 = load i32, i32* %20
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
store i32 0, i32* %186
%187 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
%188 = load i32*, i32** %6
%189 = load i32, i32* %19
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %188, i64 %190
store i32 0, i32* %191
%192 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%193 = load i32*, i32** %6
%194 = load i32, i32* %19
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32, i32* %193, i64 %195
%197 = load i32, i32* %196
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %27, i64 %199
%201 = load i32, i32* %200
%202 = add nsw i32 %201, -1
store i32 %202, i32* %200
%203 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i64 0, i64 0))
%204 = load i32, i32* %16
%205 = sub nsw i32 %204, 1
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %27, i64 %206
%208 = load i32, i32* %207
%209 = add nsw i32 %208, -1
store i32 %209, i32* %207
%210 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0))
%211 = load i32, i32* %21
store i32 %211, i32* %16
%212 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
store i32 0, i32* %20
%213 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0))
store i32 0, i32* %19
%214 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.18, i64 0, i64 0))
store i32 0, i32* %18
%215 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.19, i64 0, i64 0))
store i32 0, i32* %12
br label %216
216: ; preds = %232, %176
%217 = load i32, i32* %12
%218 = load i32, i32* %8
%219 = sub nsw i32 %218, 1
%220 = icmp slt i32 %217, %219
br i1 %220, label %221, label %235
221: ; preds = %216
%222 = load i32*, i32** %6
%223 = load i32, i32* %12
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
%226 = load i32, i32* %225
%227 = icmp eq i32 %226, 0
br i1 %227, label %228, label %231
228: ; preds = %221
%229 = load i32, i32* %18
%230 = add nsw i32 %229, 1
store i32 %230, i32* %18
br label %231
231: ; preds = %228, %221
br label %232
232: ; preds = %231
%233 = load i32, i32* %12
%234 = add nsw i32 %233, 1
store i32 %234, i32* %12
br label %216
235: ; preds = %216
%236 = call i32 @puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0))
%237 = load i32, i32* %14
%238 = add nsw i32 %237, 1
store i32 %238, i32* %14
%239 = load i32, i32* %16
%240 = load i32, i32* %14
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %33, i64 %241
store i32 %239, i32* %242
br label %243
243: ; preds = %235
%244 = load i32, i32* %18
%245 = load i32, i32* %8
%246 = sub nsw i32 %245, 1
%247 = icmp ne i32 %244, %246
br i1 %247, label %105, label %248
248: ; preds = %243
%249 = load i32, i32* %15
%250 = load i32, i32* %16
%251 = icmp eq i32 %249, %250
br i1 %251, label %252, label %273
252: ; preds = %248
%253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.21, i64 0, i64 0))
store i32 0, i32* %12
br label %254
254: ; preds = %264, %252
%255 = load i32, i32* %12
%256 = load i32, i32* %14
%257 = icmp slt i32 %255, %256
br i1 %257, label %258, label %267
258: ; preds = %254
%259 = load i32, i32* %12
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %33, i64 %260
%262 = load i32, i32* %261
%263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0), i32 %262)
br label %264
264: ; preds = %258
%265 = load i32, i32* %12
%266 = add nsw i32 %265, 1
store i32 %266, i32* %12
br label %254
267: ; preds = %254
%268 = load i32, i32* %12
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32, i32* %33, i64 %269
%271 = load i32, i32* %270
%272 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.23, i64 0, i64 0), i32 %271)
br label %273
273: ; preds = %267, %248
store i32 0, i32* %22
br label %274
274: ; preds = %273, %91
%275 = load i8*, i8** %9
%276 = load i32, i32* %22
switch i32 %276, label %278 [
i32 0, label %277
i32 1, label %277
]
277: ; preds = %274, %274
ret void
278: ; preds = %274
unreachable
}

LLVM IR (-O2):
@.str = [4 x i8] c"%i \00"
@.str.1 = [86 x i8] c"\0AO grafo possui o vertice %i com grau impar!\0APortanto nao temos um caminho euleriano\0A\00"
@.str.2 = [81 x i8] c"O grafo possui todos os vertices com grau par!\0AProcurando o caminho euleriano...\00"
@.str.3 = [29 x i8] c"Digite o vetor de inicio\0A::>\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [10 x i8] c"Entrada 1\00"
@.str.6 = [11 x i8] c"\0AEntrada 2\00"
@.str.7 = [10 x i8] c"Entrada 3\00"
@.str.8 = [10 x i8] c"Entrada 4\00"
@.str.9 = [10 x i8] c"Entrada 5\00"
@.str.10 = [10 x i8] c"Entrada 6\00"
@.str.11 = [10 x i8] c"Entrada 7\00"
@.str.12 = [10 x i8] c"Entrada 8\00"
@.str.13 = [10 x i8] c"Entrada 9\00"
@.str.14 = [11 x i8] c"Entrada 10\00"
@.str.15 = [11 x i8] c"Entrada 11\00"
@.str.16 = [11 x i8] c"Entrada 12\00"
@.str.17 = [11 x i8] c"Entrada 13\00"
@.str.18 = [11 x i8] c"Entrada 14\00"
@.str.19 = [11 x i8] c"Entrada 15\00"
@.str.20 = [11 x i8] c"Entrada 16\00"
@.str.22 = [6 x i8] c"%i ->\00"
@.str.23 = [4 x i8] c"%i\0A\00"
@str = [29 x i8] c"Caminho euleriano encontrado\00"
define void @euleriano(i32* nocapture %0, i32* nocapture %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = tail call i32 (...) @limpa()
%7 = zext i32 %2 to i64
%8 = alloca i32, i64 %7
%9 = bitcast i32* %5 to i8*
%10 = alloca i32, i64 %7
%11 = icmp sgt i32 %2, 0
br i1 %11, label %13, label %41
12: ; preds = %13
br i1 %11, label %28, label %41
13: ; preds = %4, %13
%14 = phi i64 [ %26, %13 ], [ 0, %4 ]
%15 = phi i32 [ %25, %13 ], [ 0, %4 ]
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i32, i32* %1, i64 %16
%18 = load i32, i32* %17
%19 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %18)
%20 = getelementptr inbounds i32, i32* %0, i64 %14
%21 = load i32, i32* %20
%22 = getelementptr inbounds i32, i32* %8, i64 %14
store i32 %21, i32* %22
%23 = icmp sgt i32 %21, 0
%24 = select i1 %23, i32 %21, i32 0
%25 = add i32 %15, %24
%26 = add nuw nsw i64 %14, 1
%27 = icmp eq i64 %26, %7
br i1 %27, label %12, label %13
28: ; preds = %12, %38
%29 = phi i64 [ %39, %38 ], [ 0, %12 ]
%30 = getelementptr inbounds i32, i32* %8, i64 %29
%31 = load i32, i32* %30
%32 = and i32 %31, 1
%33 = icmp eq i32 %32, 0
br i1 %33, label %38, label %34
34: ; preds = %28
%35 = trunc i64 %29 to i32
%36 = add nuw nsw i32 %35, 1
%37 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @.str.1, i64 0, i64 0), i32 %36)
br label %404
38: ; preds = %28
%39 = add nuw nsw i64 %29, 1
%40 = icmp eq i64 %39, %7
br i1 %40, label %41, label %28
41: ; preds = %38, %4, %12
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @.str.2, i64 0, i64 0))
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0))
%44 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %5)
%45 = call i32 (...) @limpa()
%46 = load i32, i32* %5
%47 = add i32 %3, -1
%48 = icmp sgt i32 %3, 1
%49 = zext i32 %47 to i64
%50 = and i64 %49, 4294967288
%51 = add nsw i64 %50, -8
%52 = lshr exact i64 %51, 3
%53 = add nuw nsw i64 %52, 1
%54 = icmp ult i32 %47, 8
%55 = and i64 %49, 4294967288
%56 = and i64 %53, 1
%57 = icmp eq i64 %51, 0
%58 = and i64 %53, 4611686018427387902
%59 = icmp eq i64 %56, 0
%60 = icmp eq i64 %55, %49
br label %61
61: ; preds = %380, %41
%62 = phi i64 [ %383, %380 ], [ 0, %41 ]
%63 = phi i32 [ %276, %380 ], [ %46, %41 ]
%64 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
%65 = add i32 %63, -1
%66 = icmp sgt i32 %63, 1
br i1 %66, label %67, label %162
67: ; preds = %61
%68 = zext i32 %65 to i64
%69 = icmp ult i32 %65, 8
br i1 %69, label %151, label %70
70: ; preds = %67
%71 = and i64 %68, 4294967288
%72 = add nsw i64 %71, -8
%73 = lshr exact i64 %72, 3
%74 = add nuw nsw i64 %73, 1
%75 = and i64 %74, 3
%76 = icmp ult i64 %72, 24
br i1 %76, label %122, label %77
77: ; preds = %70
%78 = and i64 %74, 4611686018427387900
br label %79
79: ; preds = %79, %77
%80 = phi i64 [ 0, %77 ], [ %119, %79 ]
%81 = phi <4 x i32> [ zeroinitializer, %77 ], [ %117, %79 ]
%82 = phi <4 x i32> [ zeroinitializer, %77 ], [ %118, %79 ]
%83 = phi i64 [ 0, %77 ], [ %120, %79 ]
%84 = getelementptr inbounds i32, i32* %0, i64 %80
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr inbounds i32, i32* %84, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = add <4 x i32> %86, %81
%91 = add <4 x i32> %89, %82
%92 = or i64 %80, 8
%93 = getelementptr inbounds i32, i32* %0, i64 %92
%94 = bitcast i32* %93 to <4 x i32>*
%95 = load <4 x i32>, <4 x i32>* %94
%96 = getelementptr inbounds i32, i32* %93, i64 4
%97 = bitcast i32* %96 to <4 x i32>*
%98 = load <4 x i32>, <4 x i32>* %97
%99 = add <4 x i32> %95, %90
%100 = add <4 x i32> %98, %91
%101 = or i64 %80, 16
%102 = getelementptr inbounds i32, i32* %0, i64 %101
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr inbounds i32, i32* %102, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = add <4 x i32> %104, %99
%109 = add <4 x i32> %107, %100
%110 = or i64 %80, 24
%111 = getelementptr inbounds i32, i32* %0, i64 %110
%112 = bitcast i32* %111 to <4 x i32>*
%113 = load <4 x i32>, <4 x i32>* %112
%114 = getelementptr inbounds i32, i32* %111, i64 4
%115 = bitcast i32* %114 to <4 x i32>*
%116 = load <4 x i32>, <4 x i32>* %115
%117 = add <4 x i32> %113, %108
%118 = add <4 x i32> %116, %109
%119 = add nuw i64 %80, 32
%120 = add i64 %83, 4
%121 = icmp eq i64 %120, %78
br i1 %121, label %122, label %79
122: ; preds = %79, %70
%123 = phi <4 x i32> [ undef, %70 ], [ %117, %79 ]
%124 = phi <4 x i32> [ undef, %70 ], [ %118, %79 ]
%125 = phi i64 [ 0, %70 ], [ %119, %79 ]
%126 = phi <4 x i32> [ zeroinitializer, %70 ], [ %117, %79 ]
%127 = phi <4 x i32> [ zeroinitializer, %70 ], [ %118, %79 ]
%128 = icmp eq i64 %75, 0
br i1 %128, label %145, label %129
129: ; preds = %122, %129
%130 = phi i64 [ %142, %129 ], [ %125, %122 ]
%131 = phi <4 x i32> [ %140, %129 ], [ %126, %122 ]
%132 = phi <4 x i32> [ %141, %129 ], [ %127, %122 ]
%133 = phi i64 [ %143, %129 ], [ 0, %122 ]
%134 = getelementptr inbounds i32, i32* %0, i64 %130
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = getelementptr inbounds i32, i32* %134, i64 4
%138 = bitcast i32* %137 to <4 x i32>*
%139 = load <4 x i32>, <4 x i32>* %138
%140 = add <4 x i32> %136, %131
%141 = add <4 x i32> %139, %132
%142 = add nuw i64 %130, 8
%143 = add i64 %133, 1
%144 = icmp eq i64 %143, %75
br i1 %144, label %145, label %129
145: ; preds = %129, %122
%146 = phi <4 x i32> [ %123, %122 ], [ %140, %129 ]
%147 = phi <4 x i32> [ %124, %122 ], [ %141, %129 ]
%148 = add <4 x i32> %147, %146
%149 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %148)
%150 = icmp eq i64 %71, %68
br i1 %150, label %162, label %151
151: ; preds = %67, %145
%152 = phi i64 [ 0, %67 ], [ %71, %145 ]
%153 = phi i32 [ 0, %67 ], [ %149, %145 ]
br label %154
154: ; preds = %151, %154
%155 = phi i64 [ %160, %154 ], [ %152, %151 ]
%156 = phi i32 [ %159, %154 ], [ %153, %151 ]
%157 = getelementptr inbounds i32, i32* %0, i64 %155
%158 = load i32, i32* %157
%159 = add nsw i32 %158, %156
%160 = add nuw nsw i64 %155, 1
%161 = icmp eq i64 %160, %68
br i1 %161, label %162, label %154
162: ; preds = %154, %145, %61
%163 = phi i32 [ 0, %61 ], [ %149, %145 ], [ %159, %154 ]
%164 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i64 0, i64 0))
%165 = sext i32 %163 to i64
br label %166
166: ; preds = %166, %162
%167 = phi i64 [ %171, %166 ], [ %165, %162 ]
%168 = getelementptr inbounds i32, i32* %1, i64 %167
%169 = load i32, i32* %168
%170 = icmp eq i32 %169, 0
%171 = add i64 %167, 1
br i1 %170, label %166, label %172
172: ; preds = %166
%173 = getelementptr inbounds i32, i32* %1, i64 %167
%174 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0))
%175 = load i32, i32* %173
%176 = icmp sgt i32 %175, 1
br i1 %176, label %177, label %273
177: ; preds = %172
%178 = add nsw i32 %175, -1
%179 = zext i32 %178 to i64
%180 = icmp ult i32 %178, 8
br i1 %180, label %262, label %181
181: ; preds = %177
%182 = and i64 %179, 4294967288
%183 = add nsw i64 %182, -8
%184 = lshr exact i64 %183, 3
%185 = add nuw nsw i64 %184, 1
%186 = and i64 %185, 3
%187 = icmp ult i64 %183, 24
br i1 %187, label %233, label %188
188: ; preds = %181
%189 = and i64 %185, 4611686018427387900
br label %190
190: ; preds = %190, %188
%191 = phi i64 [ 0, %188 ], [ %230, %190 ]
%192 = phi <4 x i32> [ zeroinitializer, %188 ], [ %228, %190 ]
%193 = phi <4 x i32> [ zeroinitializer, %188 ], [ %229, %190 ]
%194 = phi i64 [ 0, %188 ], [ %231, %190 ]
%195 = getelementptr inbounds i32, i32* %0, i64 %191
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = getelementptr inbounds i32, i32* %195, i64 4
%199 = bitcast i32* %198 to <4 x i32>*
%200 = load <4 x i32>, <4 x i32>* %199
%201 = add <4 x i32> %197, %192
%202 = add <4 x i32> %200, %193
%203 = or i64 %191, 8
%204 = getelementptr inbounds i32, i32* %0, i64 %203
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = getelementptr inbounds i32, i32* %204, i64 4
%208 = bitcast i32* %207 to <4 x i32>*
%209 = load <4 x i32>, <4 x i32>* %208
%210 = add <4 x i32> %206, %201
%211 = add <4 x i32> %209, %202
%212 = or i64 %191, 16
%213 = getelementptr inbounds i32, i32* %0, i64 %212
%214 = bitcast i32* %213 to <4 x i32>*
%215 = load <4 x i32>, <4 x i32>* %214
%216 = getelementptr inbounds i32, i32* %213, i64 4
%217 = bitcast i32* %216 to <4 x i32>*
%218 = load <4 x i32>, <4 x i32>* %217
%219 = add <4 x i32> %215, %210
%220 = add <4 x i32> %218, %211
%221 = or i64 %191, 24
%222 = getelementptr inbounds i32, i32* %0, i64 %221
%223 = bitcast i32* %222 to <4 x i32>*
%224 = load <4 x i32>, <4 x i32>* %223
%225 = getelementptr inbounds i32, i32* %222, i64 4
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = add <4 x i32> %224, %219
%229 = add <4 x i32> %227, %220
%230 = add nuw i64 %191, 32
%231 = add i64 %194, 4
%232 = icmp eq i64 %231, %189
br i1 %232, label %233, label %190
233: ; preds = %190, %181
%234 = phi <4 x i32> [ undef, %181 ], [ %228, %190 ]
%235 = phi <4 x i32> [ undef, %181 ], [ %229, %190 ]
%236 = phi i64 [ 0, %181 ], [ %230, %190 ]
%237 = phi <4 x i32> [ zeroinitializer, %181 ], [ %228, %190 ]
%238 = phi <4 x i32> [ zeroinitializer, %181 ], [ %229, %190 ]
%239 = icmp eq i64 %186, 0
br i1 %239, label %256, label %240
240: ; preds = %233, %240
%241 = phi i64 [ %253, %240 ], [ %236, %233 ]
%242 = phi <4 x i32> [ %251, %240 ], [ %237, %233 ]
%243 = phi <4 x i32> [ %252, %240 ], [ %238, %233 ]
%244 = phi i64 [ %254, %240 ], [ 0, %233 ]
%245 = getelementptr inbounds i32, i32* %0, i64 %241
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = getelementptr inbounds i32, i32* %245, i64 4
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = add <4 x i32> %247, %242
%252 = add <4 x i32> %250, %243
%253 = add nuw i64 %241, 8
%254 = add i64 %244, 1
%255 = icmp eq i64 %254, %186
br i1 %255, label %256, label %240
256: ; preds = %240, %233
%257 = phi <4 x i32> [ %234, %233 ], [ %251, %240 ]
%258 = phi <4 x i32> [ %235, %233 ], [ %252, %240 ]
%259 = add <4 x i32> %258, %257
%260 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %259)
%261 = icmp eq i64 %182, %179
br i1 %261, label %273, label %262
262: ; preds = %177, %256
%263 = phi i64 [ 0, %177 ], [ %182, %256 ]
%264 = phi i32 [ 0, %177 ], [ %260, %256 ]
br label %265
265: ; preds = %262, %265
%266 = phi i64 [ %271, %265 ], [ %263, %262 ]
%267 = phi i32 [ %270, %265 ], [ %264, %262 ]
%268 = getelementptr inbounds i32, i32* %0, i64 %266
%269 = load i32, i32* %268
%270 = add nsw i32 %269, %267
%271 = add nuw nsw i64 %266, 1
%272 = icmp eq i64 %271, %179
br i1 %272, label %273, label %265
273: ; preds = %265, %256, %172
%274 = phi i32 [ 0, %172 ], [ %260, %256 ], [ %270, %265 ]
%275 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0))
%276 = load i32, i32* %173
%277 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
%278 = sext i32 %274 to i64
br label %279
279: ; preds = %279, %273
%280 = phi i64 [ %284, %279 ], [ %278, %273 ]
%281 = getelementptr inbounds i32, i32* %1, i64 %280
%282 = load i32, i32* %281
%283 = icmp eq i32 %282, %63
%284 = add i64 %280, 1
br i1 %283, label %285, label %279
285: ; preds = %279
%286 = getelementptr inbounds i32, i32* %1, i64 %280
%287 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%288 = getelementptr inbounds i32, i32* %10, i64 %62
store i32 %63, i32* %288
%289 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %286
%290 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %173
%291 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%292 = load i32, i32* %173
%293 = add nsw i32 %292, -1
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %8, i64 %294
%296 = load i32, i32* %295
%297 = add nsw i32 %296, -1
store i32 %297, i32* %295
%298 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i64 0, i64 0))
%299 = sext i32 %65 to i64
%300 = getelementptr inbounds i32, i32* %8, i64 %299
%301 = load i32, i32* %300
%302 = add nsw i32 %301, -1
store i32 %302, i32* %300
%303 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0))
%304 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
%305 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0))
%306 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.18, i64 0, i64 0))
%307 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.19, i64 0, i64 0))
br i1 %48, label %308, label %380
308: ; preds = %285
br i1 %54, label %367, label %309
309: ; preds = %308
br i1 %57, label %343, label %310
310: ; preds = %309, %310
%311 = phi i64 [ %340, %310 ], [ 0, %309 ]
%312 = phi <4 x i32> [ %338, %310 ], [ zeroinitializer, %309 ]
%313 = phi <4 x i32> [ %339, %310 ], [ zeroinitializer, %309 ]
%314 = phi i64 [ %341, %310 ], [ 0, %309 ]
%315 = getelementptr inbounds i32, i32* %1, i64 %311
%316 = bitcast i32* %315 to <4 x i32>*
%317 = load <4 x i32>, <4 x i32>* %316
%318 = getelementptr inbounds i32, i32* %315, i64 4
%319 = bitcast i32* %318 to <4 x i32>*
%320 = load <4 x i32>, <4 x i32>* %319
%321 = icmp eq <4 x i32> %317, zeroinitializer
%322 = icmp eq <4 x i32> %320, zeroinitializer
%323 = zext <4 x i1> %321 to <4 x i32>
%324 = zext <4 x i1> %322 to <4 x i32>
%325 = add <4 x i32> %312, %323
%326 = add <4 x i32> %313, %324
%327 = or i64 %311, 8
%328 = getelementptr inbounds i32, i32* %1, i64 %327
%329 = bitcast i32* %328 to <4 x i32>*
%330 = load <4 x i32>, <4 x i32>* %329
%331 = getelementptr inbounds i32, i32* %328, i64 4
%332 = bitcast i32* %331 to <4 x i32>*
%333 = load <4 x i32>, <4 x i32>* %332
%334 = icmp eq <4 x i32> %330, zeroinitializer
%335 = icmp eq <4 x i32> %333, zeroinitializer
%336 = zext <4 x i1> %334 to <4 x i32>
%337 = zext <4 x i1> %335 to <4 x i32>
%338 = add <4 x i32> %325, %336
%339 = add <4 x i32> %326, %337
%340 = add nuw i64 %311, 16
%341 = add i64 %314, 2
%342 = icmp eq i64 %341, %58
br i1 %342, label %343, label %310
343: ; preds = %310, %309
%344 = phi <4 x i32> [ undef, %309 ], [ %338, %310 ]
%345 = phi <4 x i32> [ undef, %309 ], [ %339, %310 ]
%346 = phi i64 [ 0, %309 ], [ %340, %310 ]
%347 = phi <4 x i32> [ zeroinitializer, %309 ], [ %338, %310 ]
%348 = phi <4 x i32> [ zeroinitializer, %309 ], [ %339, %310 ]
br i1 %59, label %362, label %349
349: ; preds = %343
%350 = getelementptr inbounds i32, i32* %1, i64 %346
%351 = bitcast i32* %350 to <4 x i32>*
%352 = load <4 x i32>, <4 x i32>* %351
%353 = getelementptr inbounds i32, i32* %350, i64 4
%354 = bitcast i32* %353 to <4 x i32>*
%355 = load <4 x i32>, <4 x i32>* %354
%356 = icmp eq <4 x i32> %352, zeroinitializer
%357 = icmp eq <4 x i32> %355, zeroinitializer
%358 = zext <4 x i1> %356 to <4 x i32>
%359 = zext <4 x i1> %357 to <4 x i32>
%360 = add <4 x i32> %347, %358
%361 = add <4 x i32> %348, %359
br label %362
362: ; preds = %343, %349
%363 = phi <4 x i32> [ %344, %343 ], [ %360, %349 ]
%364 = phi <4 x i32> [ %345, %343 ], [ %361, %349 ]
%365 = add <4 x i32> %364, %363
%366 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %365)
br i1 %60, label %380, label %367
367: ; preds = %308, %362
%368 = phi i64 [ 0, %308 ], [ %55, %362 ]
%369 = phi i32 [ 0, %308 ], [ %366, %362 ]
br label %370
370: ; preds = %367, %370
%371 = phi i64 [ %378, %370 ], [ %368, %367 ]
%372 = phi i32 [ %377, %370 ], [ %369, %367 ]
%373 = getelementptr inbounds i32, i32* %1, i64 %371
%374 = load i32, i32* %373
%375 = icmp eq i32 %374, 0
%376 = zext i1 %375 to i32
%377 = add nuw nsw i32 %372, %376
%378 = add nuw nsw i64 %371, 1
%379 = icmp eq i64 %378, %49
br i1 %379, label %380, label %370
380: ; preds = %370, %362, %285
%381 = phi i32 [ 0, %285 ], [ %366, %362 ], [ %377, %370 ]
%382 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0))
%383 = add nuw i64 %62, 1
%384 = getelementptr inbounds i32, i32* %10, i64 %383
store i32 %276, i32* %384
%385 = icmp eq i32 %381, %47
br i1 %385, label %386, label %61
386: ; preds = %380
%387 = load i32, i32* %5
%388 = icmp eq i32 %387, %276
br i1 %388, label %389, label %404
389: ; preds = %386
%390 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str, i64 0, i64 0))
%391 = add i64 %62, 1
%392 = and i64 %391, 4294967295
br label %393
393: ; preds = %389, %393
%394 = phi i64 [ 0, %389 ], [ %398, %393 ]
%395 = getelementptr inbounds i32, i32* %10, i64 %394
%396 = load i32, i32* %395
%397 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0), i32 %396)
%398 = add nuw nsw i64 %394, 1
%399 = icmp eq i64 %398, %392
br i1 %399, label %400, label %393
400: ; preds = %393
%401 = getelementptr inbounds i32, i32* %10, i64 %392
%402 = load i32, i32* %401
%403 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.23, i64 0, i64 0), i32 %402)
br label %404
404: ; preds = %386, %400, %34
ret void
}