main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // er12
unsigned int *v4; // r13
__int64 v5; // rdx
__int64 v6; // rcx
unsigned int *v7; // rbp
unsigned int i; // ebx
int v9; // eax
int v10; // er8
int result; // eax
int v12; // er8
int v13; // er8
int v14; // eax
int v15; // er8
_BYTE v16[88]; // [rsp+0h] [rbp-58h] BYREF

v3 = 0;
v4 = (unsigned int *)v16;
introduce_array(v16, argv, envp);
puts("\n\n");
do
{
v7 = v4;
for ( i = 0; i != 3; ++i )
{
v9 = maximocol(v16, v3, v5, v6, *v7);
if ( v10 == v9 )
{
v14 = minimofil(v16, i);
if ( v15 == v14 )
printf("\nFILA %d COLUMNA %d ES PUNTO DE SILLA", v3, i);
}
result = maximofil(v16, i);
if ( result == v12 )
{
result = minimocol(v16, v3);
if ( result == v13 )
result = printf("\nFILA %d COLUMNA %d ES PUNTO DE SILLA", v3, i);
}
++v7;
}
++v3;
v4 += 3;
}
while ( v3 != 3 );
return result;
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // er12
unsigned int *v4; // r13
__int64 v5; // rdx
__int64 v6; // rcx
unsigned int *v7; // rbp
unsigned int i; // ebx
int v9; // eax
int v10; // er8
int result; // eax
int v12; // er8
int v13; // er8
int v14; // eax
int v15; // er8
_BYTE v16[88]; // [rsp+0h] [rbp-58h] BYREF

v3 = 0;
v4 = (unsigned int *)v16;
func7(v16, argv, envp);
puts("\n\n");
do
{
v7 = v4;
for ( i = 0; i != 3; ++i )
{
v9 = func11(v16, v3, v5, v6, *v7);
if ( v10 == v9 )
{
v14 = func8(v16, i);
if ( v15 == v14 )
printf("\nFILA %d COLUMNA %d ES PUNTO DE SILLA", v3, i);
}
result = func10(v16, i);
if ( result == v12 )
{
result = func9(v16, v3);
if ( result == v13 )
result = printf("\nFILA %d COLUMNA %d ES PUNTO DE SILLA", v3, i);
}
++v7;
}
++v3;
v4 += 3;
}
while ( v3 != 3 );
return result;
}

original_code:
void main (void)
{
int filas, columnas;
int array [3] [3];
introduce_array (array);
printf ("\n\n\n");
for (filas=0; filas<3; filas++)
 for (columnas=0; columnas<3; columnas++)
                {
  if (array [filas] [columnas]==maximocol (array, filas) &&
   array [filas] [columnas]==minimofil (array,columnas))
   printf ("\nFILA %d  COLUMNA %d  ES PUNTO DE SILLA",filas,columnas);
  if (array [filas] [columnas]==maximofil (array, columnas) &&
   array [filas] [columnas]==minimocol (array,filas))
   printf ("\nFILA %d  COLUMNA %d  ES PUNTO DE SILLA",filas,columnas);
                }
}

canonical_original_code:
void main()
{
int filas; int columnas;
int array[3][3];
introduce_array (array);
printf ("\n\n\n");
for (filas=0; filas<3; filas++)
 for (columnas=0; columnas<3; columnas++)
                {
  if (array [filas] [columnas]==maximocol (array, filas) &&
   array [filas] [columnas]==minimofil (array,columnas))
   printf ("\nFILA %d  COLUMNA %d  ES PUNTO DE SILLA",filas,columnas);
  if (array [filas] [columnas]==maximofil (array, columnas) &&
   array [filas] [columnas]==minimocol (array,filas))
   printf ("\nFILA %d  COLUMNA %d  ES PUNTO DE SILLA",filas,columnas);
                }
}

variable_types:
array
int [3][3]


repo: jrbarrio/FundamentosProgramacionI

decompiled_code:
int __fastcall introduce_array(unsigned int *a1)
{
unsigned int *v1; // r12
unsigned int *v2; // rbp
unsigned int *v3; // rbx
unsigned int *v4; // rbp
__int64 v5; // rsi
int result; // eax

v1 = a1 + 9;
v2 = a1;
v3 = a1;
do
{
__isoc99_scanf();
__isoc99_scanf();
__isoc99_scanf();
v2 += 3;
}
while ( v2 != v1 );
while ( 1 )
{
v4 = v3 + 3;
putchar(10);
do
{
v5 = *v3++;
result = printf("%4d", v5);
}
while ( v4 != v3 );
if ( v4 == v1 )
break;
v3 = v4;
}
return result;
}

canonical_decompiled_code:
int __fastcall func7(unsigned int *a1)
{
unsigned int *v1; // r12
unsigned int *v2; // rbp
unsigned int *v3; // rbx
unsigned int *v4; // rbp
__int64 v5; // rsi
int result; // eax

v1 = a1 + 9;
v2 = a1;
v3 = a1;
do
{
__isoc99_scanf();
__isoc99_scanf();
__isoc99_scanf();
v2 += 3;
}
while ( v2 != v1 );
while ( 1 )
{
v4 = v3 + 3;
putchar(10);
do
{
v5 = *v3++;
result = printf("%4d", v5);
}
while ( v4 != v3 );
if ( v4 == v1 )
break;
v3 = v4;
}
return result;
}

original_code:
void introduce_array (int array [] [3])
{
int filas, columnas;
for (filas=0;filas<3;filas++)
 {
 for (columnas=0;columnas<3;columnas++)
  scanf ("%d",*(array+filas)+columnas);
        }
for (filas=0;filas<3;filas++)
 {
        printf ("\n");
 for (columnas=0;columnas<3;columnas++)
  printf ("%4d",*(*(array+filas)+columnas));
        }
}

canonical_original_code:
void introduce_array(int array[][3])
{
int filas; int columnas;
for (filas=0;filas<3;filas++)
 {
 for (columnas=0;columnas<3;columnas++)
  scanf ("%d",*(array+filas)+columnas);
        }
for (filas=0;filas<3;filas++)
 {
        printf ("\n");
 for (columnas=0;columnas<3;columnas++)
  printf ("%4d",*(*(array+filas)+columnas));
        }
}

variable_types:
array
int [][3]

variable_types: filas int

variable_types: columnas int

return_type: void


decompiled_code:
void *nuevo_elemento()
{
void *v0; // r12

v0 = malloc(0x48uLL);
printf("\nMARCA --->");
__isoc99_scanf();
__isoc99_scanf();
printf("\nMODELO --->");
__isoc99_scanf();
__isoc99_scanf();
printf("\nPRECIO --->");
__isoc99_scanf();
__isoc99_scanf();
return v0;
}

canonical_decompiled_code:
void *func7()
{
void *v0; // r12

v0 = malloc(0x48uLL);
printf("\nMARCA --->");
__isoc99_scanf();
__isoc99_scanf();
printf("\nMODELO --->");
__isoc99_scanf();
__isoc99_scanf();
printf("\nPRECIO --->");
__isoc99_scanf();
__isoc99_scanf();
return v0;
}

original_code:
struct nodo *nuevo_elemento(void) {
  char tmp;
  struct nodo *nuevo;
  nuevo = (struct nodo *) malloc(sizeof(struct nodo));
  printf("\nMARCA --->");
  scanf("%s", nuevo->info.marca);
  scanf("%c", &tmp);
  printf("\nMODELO --->");
  scanf("%s", nuevo->info.modelo);
  scanf("%c", &tmp);
  printf("\nPRECIO --->");
  scanf("%f", &(nuevo->info.precio));
  scanf("%c", &tmp);
  return(nuevo);
}

canonical_original_code:
struct nodo *nuevo_elemento() {
  char tmp;
  struct nodo *nuevo;
  nuevo = (struct nodo *) malloc(sizeof(struct nodo));
  printf("\nMARCA --->");
  scanf("%s", nuevo->info.marca);
  scanf("%c", &tmp);
  printf("\nMODELO --->");
  scanf("%s", nuevo->info.modelo);
  scanf("%c", &tmp);
  printf("\nPRECIO --->");
  scanf("%f", &(nuevo->info.precio));
  scanf("%c", &tmp);
  return(nuevo);
}

variable_types: tmp char

variable_types: struct nodo { struct informacion { char marca[30]; char modelo[30]; float precio; } info; struct nodo *enlace; } *

user_defined_types: struct nodo { struct informacion info; struct nodo *enlace; }


compara

decompiled_code:
__int64 __fastcall compara(__int64 a1, __int64 a2)
{
__int64 result; // rax
float v3; // xmm0_4
float v4; // xmm1_4
__int64 v5; // rdx

result = a2;
if ( a2 )
{
v3 = *(float *)(a2 + 60);
v4 = *(float *)(a1 + 60);
if ( v4 <= v3 )
{
while ( v3 > v4 )
{
v5 = *(_QWORD *)(result + 64);
if ( !v5 )
break;
v3 = *(float *)(v5 + 60);
result = *(_QWORD *)(result + 64);
}
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 a1, __int64 a2)
{
__int64 result; // rax
float v3; // xmm0_4
float v4; // xmm1_4
__int64 v5; // rdx

result = a2;
if ( a2 )
{
v3 = *(float *)(a2 + 60);
v4 = *(float *)(a1 + 60);
if ( v4 <= v3 )
{
while ( v3 > v4 )
{
v5 = *(_QWORD *)(result + 64);
if ( !v5 )
break;
v3 = *(float *)(v5 + 60);
result = *(_QWORD *)(result + 64);
}
}
}
return result;
}

original_code:
struct nodo *compara(struct nodo *nuevo, struct nodo *cabeza) {
  struct nodo *anterior, *recorre;
  if (cabeza == (struct nodo *) ((void *)0)) {
    anterior = cabeza;
  } else {
   if (cabeza->info.precio < nuevo->info.precio) {
    anterior = cabeza;
   } else {
    recorre = cabeza;
      while (recorre != (struct nodo *)((void *)0)
          && (recorre->info.precio > nuevo->info.precio)) {
        anterior = recorre;
     recorre = recorre->enlace;
      }
      if (recorre != (struct nodo *)((void *)0)) {
     anterior = recorre;
    }
    }
  }
  return (anterior);
}

canonical_original_code:
struct nodo *compara(struct nodo *nuevo, struct nodo *cabeza) {
  struct nodo *anterior; struct nodo *recorre;
  if (cabeza == (struct nodo *) ((void *)0)) {
    anterior = cabeza;
  } else {
   if (cabeza->info.precio < nuevo->info.precio) {
    anterior = cabeza;
   } else {
    recorre = cabeza;
      while (recorre != (struct nodo *)((void *)0)
          && (recorre->info.precio > nuevo->info.precio)) {
        anterior = recorre;
     recorre = recorre->enlace;
      }
      if (recorre != (struct nodo *)((void *)0)) {
     anterior = recorre;
    }
    }
  }
  return (anterior);
}

variable_types:
nuevo
struct nodo *

variable_types:
cabeza
struct nodo *

return_type: struct nodo { struct informacion { char marca[30]; char modelo[30]; float precio; } info; struct nodo *enlace; } *


ainade

decompiled_code:
__int64 __fastcall ainade(__int64 *a1)
{
void *v2; // rax
__int64 v3; // rsi
__int64 v4; // rdi
__int64 v5; // rax

v2 = nuevo_elemento();
v3 = *a1;
v4 = (__int64)v2;
v5 = compara((__int64)v2, v3);
return inserta(v4, v5, a1);
}

original_code:
void ainade(struct nodo **cabeza) {
  struct nodo *nuevo, *anterior;
  nuevo = nuevo_elemento();
  anterior = compara(nuevo, *cabeza);
  inserta(nuevo, anterior, cabeza);
}

canonical_original_code:
void ainade(struct nodo **cabeza) {
  struct nodo *nuevo; struct nodo *anterior;
  nuevo = nuevo_elemento();
  anterior = compara(nuevo, *cabeza);
  inserta(nuevo, anterior, cabeza);
}

variable_types: struct nodo { struct informacion { char marca[30]; char modelo[30]; float precio; } info; struct nodo *enlace; } **


listar

decompiled_code:
int __fastcall listar(__int64 *a1)
{
__int64 v1; // rbx

v1 = *a1;
if ( *a1 )
{
do
{
puts("\n\n");
printf("MARCA --->");
puts((const char *)v1);
printf("\nMODELO --->");
puts((const char *)(v1 + 30));
printf("\nPRECIO ---> %.0f", *(float *)(v1 + 60));
v1 = *(_QWORD *)(v1 + 64);
printf("\nPULSE UNA TECLA PARA CONTINUAR");
getchar();
__isoc99_scanf();
}
while ( v1 );
}
else
{
printf("\nLISTA VACIA");
}
printf("\nFIN DE LA LISTA.PULSE UNA TECLA.");
return getchar();
}

canonical_decompiled_code:
int __fastcall func11(__int64 *a1)
{
__int64 v1; // rbx

v1 = *a1;
if ( *a1 )
{
do
{
puts("\n\n");
printf("MARCA --->");
puts((const char *)v1);
printf("\nMODELO --->");
puts((const char *)(v1 + 30));
printf("\nPRECIO ---> %.0f", *(float *)(v1 + 60));
v1 = *(_QWORD *)(v1 + 64);
printf("\nPULSE UNA TECLA PARA CONTINUAR");
getchar();
__isoc99_scanf();
}
while ( v1 );
}
else
{
printf("\nLISTA VACIA");
}
printf("\nFIN DE LA LISTA.PULSE UNA TECLA.");
return getchar();
}

original_code:
void listar (struct nodo **cabeza) {
  struct nodo *recorre;
  char siguiente, tmp;
  if (*cabeza == (struct nodo *)((void *)0)) {
   printf ("\nLISTA VACIA");
  } else {
   recorre = *cabeza;
   while (recorre != (struct nodo *)((void *)0)) {
    printf ("\n\n\n");
    printf ("MARCA --->");
    puts (recorre->info.marca);
    printf ("\nMODELO --->");
    puts (recorre->info.modelo);
    printf ("\nPRECIO ---> %.0f",recorre->info.precio);
      recorre = recorre->enlace;
    printf ("\nPULSE UNA TECLA PARA CONTINUAR");
    siguiente = getchar();
    scanf("%c",&tmp);
    }
   }
  printf ("\nFIN DE LA LISTA.PULSE UNA TECLA.");
  siguiente = getchar();
}

canonical_original_code:
void listar(struct nodo **cabeza) {
  struct nodo *recorre;
  char siguiente; char tmp;
  if (*cabeza == (struct nodo *)((void *)0)) {
   printf ("\nLISTA VACIA");
  } else {
   recorre = *cabeza;
   while (recorre != (struct nodo *)((void *)0)) {
    printf ("\n\n\n");
    printf ("MARCA --->");
    puts (recorre->info.marca);
    printf ("\nMODELO --->");
    puts (recorre->info.modelo);
    printf ("\nPRECIO ---> %.0f",recorre->info.precio);
      recorre = recorre->enlace;
    printf ("\nPULSE UNA TECLA PARA CONTINUAR");
    siguiente = getchar();
    scanf("%c",&tmp);
    }
   }
  printf ("\nFIN DE LA LISTA.PULSE UNA TECLA.");
  siguiente = getchar();
}

variable_types: siguiente char

user_defined_types: struct informacion { char marca[30]; char modelo[30]; float precio; }


main

canonical_name: main

decompiled_code:
// local variable allocation has failed, the output may be wrong!
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // eax
__int64 v5; // rdx
__int64 v6[2]; // [rsp+8h] [rbp-10h] BYREF

v6[0] = 0LL;
do
{
while ( 1 )
{
v3 = opciones(*(_QWORD *)&argc, argv, envp);
if ( v3 != 1 )
break;
LABEL_7:
*(_QWORD *)&argc = v6;
ainade(v6);
}
while ( v3 == 2 )
{
*(_QWORD *)&argc = v6;
listar(v6);
v3 = opciones(v6, argv, v5);
if ( v3 == 1 )
goto LABEL_7;
}
}
while ( v3 );
return printf("\n\n\nFIN DEL PROGRAMA");
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // eax
__int64 v5; // rdx
__int64 v6[2]; // [rsp+8h] [rbp-10h] BYREF

v6[0] = 0LL;
do
{
while ( 1 )
{
v3 = func12(*(_QWORD *)&argc, argv, envp);
if ( v3 != 1 )
break;
LABEL_7:
*(_QWORD *)&argc = v6;
func10(v6);
}
while ( v3 == 2 )
{
*(_QWORD *)&argc = v6;
func11(v6);
v3 = func12(v6, argv, v5);
if ( v3 == 1 )
goto LABEL_7;
}
}
while ( v3 );
return printf("\n\n\nFIN DEL PROGRAMA");
}

original_code:
void main(void) {
  int opcion;
  struct nodo *cabeza;
  cabeza = (struct nodo *) ((void *)0);
  do {
   opcion = opciones();
   switch (opcion) {
    case 1:
     ainade(&cabeza);
     break;
    case 2:
     listar(&cabeza);
     break;
   }
  }
  while (opcion != 0);
  printf ("\n\n\nFIN DEL PROGRAMA");
}

canonical_original_code:
void main() {
  int opcion;
  struct nodo *cabeza;
  cabeza = (struct nodo *) ((void *)0);
  do {
   opcion = opciones();
   switch (opcion) {
    case 1:
     ainade(&cabeza);
     break;
    case 2:
     listar(&cabeza);
     break;
   }
  }
  while (opcion != 0);
  printf ("\n\n\nFIN DEL PROGRAMA");
}

variable_types: opcion int


decompiled_code:
__int64 __fastcall coge_elemento(__int64 *a1, __int64 *a2)
{
__int64 v2; // rax
__int64 result; // rax

v2 = *a1;
*a2 = *a1;
*a1 = *(_QWORD *)(v2 + 16);
result = *a2;
*(_QWORD *)(*a2 + 16) = 0LL;
return result;
}

original_code:
void coge_elemento(PUNT_NODO *entrada, PUNT_NODO *elemento) {
    *elemento = *entrada;
    *entrada = (*entrada)->enlace;
    (*elemento)->enlace = (PUNT_NODO) ((void *)0);
}

canonical_original_code:
void coge_elemento(struct nodo **entrada, struct nodo **elemento) {
    *elemento = *entrada;
    *entrada = (*entrada)->enlace;
    (*elemento)->enlace = (PUNT_NODO) ((void *)0);
}

variable_types: struct nodo { char info[13]; struct nodo *enlace; } **

variable_types:
elemento
struct nodo **


decompiled_code:
void __noreturn calcula_salida()
{
BUG();
}

canonical_decompiled_code:
void __noreturn func9()
{
BUG();
}

original_code:
void calcula_salida(PUNT_NODO elemento, CADENA_5 vector_rutado[],
        char *puerta, char *prioridad, short *encontrado) {
    char direccion[5];
    char dir_destino[5];
    short caracter, indice;
    for (caracter = 0; caracter < 4; caracter++) {
        direccion[4] = '\0';
        encontrado = 0;
        indice = 0;
        while (!*encontrado && indice < 6) {
            for (caracter = 0; caracter < 4; caracter++) {
                dir_destino[caracter] = vector_rutado[indice][caracter];
            }
            dir_destino[4] = '\0';
            if (strcmp(direccion, dir_destino) == 0) {
                *encontrado = 1;
            }
            indice++;
        }
        if (*encontrado) {
            *puerta = vector_rutado[indice - 1][4];
        }
        prioridad = elemento->info[8];
    }
}

canonical_original_code:
void calcula_salida(struct nodo *elemento, char vector_rutado[][6], char *puerta, char *prioridad, short *encontrado) {
    char direccion[5];
    char dir_destino[5];
    short caracter; short indice;
    for (caracter = 0; caracter < 4; caracter++) {
        direccion[4] = '\0';
        encontrado = 0;
        indice = 0;
        while (!*encontrado && indice < 6) {
            for (caracter = 0; caracter < 4; caracter++) {
                dir_destino[caracter] = vector_rutado[indice][caracter];
            }
            dir_destino[4] = '\0';
            if (strcmp(direccion, dir_destino) == 0) {
                *encontrado = 1;
            }
            indice++;
        }
        if (*encontrado) {
            *puerta = vector_rutado[indice - 1][4];
        }
        prioridad = elemento->info[8];
    }
}

variable_types: struct nodo { char info[13]; struct nodo *enlace; } *

variable_types:
puerta
char *

variable_types:
prioridad
char *

variable_types:
encontrado
short *

variable_types:
direccion
char [5]

variable_types: caracter short

variable_types: indice short


decompiled_code:
__int64 __fastcall inserta_en_cabeza(__int64 a1, __int64 a2)
{
*(_QWORD *)(a2 + 16) = a1;
return a2;
}

original_code:
PUNT_NODO inserta_en_cabeza(PUNT_NODO cabeza, PUNT_NODO elemento) {
    elemento->enlace = cabeza;
    cabeza = elemento;
    return (cabeza);
}

canonical_original_code:
struct nodo *inserta_en_cabeza(struct nodo *cabeza, struct nodo *elemento) {
    elemento->enlace = cabeza;
    cabeza = elemento;
    return (cabeza);
}

variable_types:
elemento
struct nodo *

return_type: struct nodo { char info[13]; struct nodo *enlace; } *


decompiled_code:
int pulsa_enter()
{
int result; // eax

printf("Pulsa la tecla ENTER para continuar");
do
result = getchar();
while ( result != 13 );
return result;
}

canonical_decompiled_code:
int func16()
{
int result; // eax

printf("Pulsa la tecla ENTER para continuar");
do
result = getchar();
while ( result != 13 );
return result;
}

original_code:
void pulsa_enter(void) {
    printf("Pulsa la tecla ENTER para continuar");
    while (getchar() != '\r');
}

canonical_original_code:
void pulsa_enter() {
    printf("Pulsa la tecla ENTER para continuar");
    while (getchar() != '\r');
}


decompiled_code:
int __fastcall visualiza_lista(char *s)
{
char *v1; // rbx

if ( s )
{
v1 = s;
do
{
puts(v1);
v1 = (char *)*((_QWORD *)v1 + 2);
}
while ( v1 );
}
return pulsa_enter();
}

canonical_decompiled_code:
int __fastcall func17(char *s)
{
char *v1; // rbx

if ( s )
{
v1 = s;
do
{
puts(v1);
v1 = (char *)*((_QWORD *)v1 + 2);
}
while ( v1 );
}
return func16();
}

original_code:
void visualiza_lista(PUNT_NODO cabeza) {
    PUNT_NODO recorre;
    recorre = cabeza;
    while (recorre != (PUNT_NODO) ((void *)0)) {
        puts (recorre->info);
        recorre = recorre->enlace;
    }
    pulsa_enter();
}

canonical_original_code:
void visualiza_lista(struct nodo *cabeza) {
    struct nodo *recorre;
    recorre = cabeza;
    while (recorre != (PUNT_NODO) ((void *)0)) {
        puts (recorre->info);
        recorre = recorre->enlace;
    }
    pulsa_enter();
}

user_defined_types: struct nodo { char info[13]; struct nodo *enlace; }


decompiled_code:
int __fastcall visualiza_listas(char *s, char *a2, char *a3, char *a4)
{
puts("LISTA DE ENTRADA\n");
visualiza_lista(s);
puts("LISTA DE SALIDA_!\n");
visualiza_lista(a2);
puts("LISTA DE SALIDA_2\n");
visualiza_lista(a3);
puts("LISTA DE ERROR\n");
return visualiza_lista(a4);
}

canonical_decompiled_code:
int __fastcall func18(char *s, char *a2, char *a3, char *a4)
{
puts("LISTA DE ENTRADA\n");
func17(s);
puts("LISTA DE SALIDA_!\n");
func17(a2);
puts("LISTA DE SALIDA_2\n");
func17(a3);
puts("LISTA DE ERROR\n");
return func17(a4);
}

original_code:
void visualiza_listas(PUNT_NODO entrada, PUNT_NODO salida_1,
        PUNT_NODO salida_2, PUNT_NODO error) {
    printf("LISTA DE ENTRADA\n\n");
    visualiza_lista(entrada);
    printf("LISTA DE SALIDA_!\n\n");
    visualiza_lista(salida_1);
    printf("LISTA DE SALIDA_2\n\n");
    visualiza_lista(salida_2);
    printf("LISTA DE ERROR\n\n");
    visualiza_lista(error);
}

canonical_original_code:
void visualiza_listas(struct nodo *entrada, struct nodo *salida_1, struct nodo *salida_2, struct nodo *error) {
    printf("LISTA DE ENTRADA\n\n");
    visualiza_lista(entrada);
    printf("LISTA DE SALIDA_!\n\n");
    visualiza_lista(salida_1);
    printf("LISTA DE SALIDA_2\n\n");
    visualiza_lista(salida_2);
    printf("LISTA DE ERROR\n\n");
    visualiza_lista(error);
}

variable_types:
error
struct nodo *


decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
char v3; // [rsp+Ch] [rbp-7Ch] BYREF
char v4; // [rsp+Dh] [rbp-7Bh] BYREF
char v5[2]; // [rsp+Eh] [rbp-7Ah] BYREF
char v6[8]; // [rsp+10h] [rbp-78h] BYREF
char v7; // [rsp+18h] [rbp-70h] BYREF
char v8; // [rsp+20h] [rbp-68h] BYREF
char v9; // [rsp+28h] [rbp-60h] BYREF
char v10; // [rsp+30h] [rbp-58h] BYREF
char v11[8]; // [rsp+38h] [rbp-50h] BYREF
char v12[8]; // [rsp+40h] [rbp-48h] BYREF
__int64 v13; // [rsp+48h] [rbp-40h] BYREF
char v14[56]; // [rsp+50h] [rbp-38h] BYREF

inicializa_listas(
(unsigned int)"ENTRADA.DAT",
(unsigned int)v6,
(unsigned int)&v7,
(unsigned int)&v8,
(unsigned int)&v9,
(unsigned int)&v10,
(__int64)v11,
(__int64)v12);
vuelca_fichero_rutado_a_array("RUTADO.DAT", v14);
coge_elemento(v6, &v13);
calcula_salida(v13, v14, &v3, &v4, v5);
}

canonical_decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
char v3; // [rsp+Ch] [rbp-7Ch] BYREF
char v4; // [rsp+Dh] [rbp-7Bh] BYREF
char v5[2]; // [rsp+Eh] [rbp-7Ah] BYREF
char v6[8]; // [rsp+10h] [rbp-78h] BYREF
char v7; // [rsp+18h] [rbp-70h] BYREF
char v8; // [rsp+20h] [rbp-68h] BYREF
char v9; // [rsp+28h] [rbp-60h] BYREF
char v10; // [rsp+30h] [rbp-58h] BYREF
char v11[8]; // [rsp+38h] [rbp-50h] BYREF
char v12[8]; // [rsp+40h] [rbp-48h] BYREF
__int64 v13; // [rsp+48h] [rbp-40h] BYREF
char v14[56]; // [rsp+50h] [rbp-38h] BYREF

inicializa_listas(
(unsigned int)"ENTRADA.DAT",
(unsigned int)v6,
(unsigned int)&v7,
(unsigned int)&v8,
(unsigned int)&v9,
(unsigned int)&v10,
(__int64)v11,
(__int64)v12);
func7("RUTADO.DAT", v14);
func8(v6, &v13);
func9(v13, v14, &v3, &v4, v5);
}

original_code:
void main(void) {
    CADENA nomf_entrada = "ENTRADA.DAT";
    CADENA nomf_rutado = "RUTADO.DAT";
    CADENA nomf_errores = "ERRORES.DAT";
    PUNT_NODO entrada, salida_1, ultimo_1, salida_2, ultimo_2, error, ultimo_e,
            elemento;
    CADENA_5 vector_rutado[6];
    int num_errores = 0;
    char puerta, prioridad;
    short encontrado;
    inicializa_listas(nomf_entrada, &entrada, &salida_1, &ultimo_1, &salida_2,
            &ultimo_2, &error, &ultimo_e);
    vuelca_fichero_rutado_a_array(nomf_rutado, vector_rutado);
    while (num_errores <= 3) {
        coge_elemento(&entrada, &elemento);
        calcula_salida(elemento, vector_rutado, &puerta, &prioridad,
                &encontrado);
        if (encontrado) {
            switch (puerta) {
                case '1':
                    inserta_nodo(&salida_1, &ultimo_1, elemento, prioridad);
                    break;
                case '2':
                    inserta_nodo(&salida_2, &ultimo_2, elemento, prioridad);
            }
        } else {
            inserta_nodo(&error, &ultimo_e, elemento, prioridad);
            num_errores++;
        }
    }
    visualiza_listas(entrada, salida_1, salida_2, error);
    vuelca_lista_a_fichero_errores(error, nomf_errores);
    visualiza_fichero_errores(nomf_errores);
}

canonical_original_code:
void main() {
    char *nomf_entrada = "ENTRADA.DAT";
    char *nomf_rutado = "RUTADO.DAT";
    char *nomf_errores = "ERRORES.DAT";
    struct nodo *entrada; struct nodo *salida_1; struct nodo *ultimo_1; struct nodo *salida_2; struct nodo *ultimo_2; struct nodo *error; struct nodo *ultimo_e; struct nodo *elemento;
    char vector_rutado[6][6];
    int num_errores = 0;
    char puerta; char prioridad;
    short encontrado;
    inicializa_listas(nomf_entrada, &entrada, &salida_1, &ultimo_1, &salida_2,
            &ultimo_2, &error, &ultimo_e);
    vuelca_fichero_rutado_a_array(nomf_rutado, vector_rutado);
    while (num_errores <= 3) {
        coge_elemento(&entrada, &elemento);
        calcula_salida(elemento, vector_rutado, &puerta, &prioridad,
                &encontrado);
        if (encontrado) {
            switch (puerta) {
                case '1':
                    inserta_nodo(&salida_1, &ultimo_1, elemento, prioridad);
                    break;
                case '2':
                    inserta_nodo(&salida_2, &ultimo_2, elemento, prioridad);
            }
        } else {
            inserta_nodo(&error, &ultimo_e, elemento, prioridad);
            num_errores++;
        }
    }
    visualiza_listas(entrada, salida_1, salida_2, error);
    vuelca_lista_a_fichero_errores(error, nomf_errores);
    visualiza_fichero_errores(nomf_errores);
}

variable_types: puerta char

variable_types: prioridad char

variable_types: encontrado short


decompiled_code:
__int64 __fastcall inserta_en_cola(_QWORD *a1, __int64 *a2, __int64 a3)
{
__int64 result; // rax

if ( *a1 )
{
result = *a2;
*(_QWORD *)(*a2 + 16) = a3;
}
else
{
*a1 = a3;
}
*a2 = a3;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func10(_QWORD *a1, __int64 *a2, __int64 a3)
{
__int64 result; // rax

if ( *a1 )
{
result = *a2;
*(_QWORD *)(*a2 + 16) = a3;
}
else
{
*a1 = a3;
}
*a2 = a3;
return result;
}

original_code:
void inserta_en_cola(PUNT_NODO *cabeza, PUNT_NODO *ultimo,
        PUNT_NODO nuevo) {
    if (*cabeza == (PUNT_NODO) ((void *)0)) {
        *cabeza = nuevo;
    } else {
        (*ultimo)->enlace = nuevo;
    }
    *ultimo = nuevo;
}

canonical_original_code:
void inserta_en_cola(struct nodo **cabeza, struct nodo **ultimo, struct nodo *nuevo) {
    if (*cabeza == (PUNT_NODO) ((void *)0)) {
        *cabeza = nuevo;
    } else {
        (*ultimo)->enlace = nuevo;
    }
    *ultimo = nuevo;
}

variable_types:
ultimo
struct nodo **

variable_types:
nuevo
struct nodo *


decompiled_code:
void __fastcall inserta_nodo(__int64 *a1, __int64 *a2, __int64 a3, char a4)
{
__int64 v4; // rax
__int64 *v5; // r8

if ( a4 == 48 )
{
inserta_en_cola(a1, a2, a3);
}
else if ( a4 == 49 )
{
v4 = inserta_en_cabeza(*a1, a3);
*v5 = v4;
}
}

original_code:
void inserta_nodo(PUNT_NODO *cabeza, PUNT_NODO *ultimo, PUNT_NODO elemento,
        char prioridad) {
    switch (prioridad) {
        case '0':
          inserta_en_cola(cabeza, ultimo, elemento);
          break;
        case '1':
            *cabeza = inserta_en_cabeza(*cabeza, elemento);
    }
}

canonical_original_code:
void inserta_nodo(struct nodo **cabeza, struct nodo **ultimo, struct nodo *elemento, char prioridad) {
    switch (prioridad) {
        case '0':
          inserta_en_cola(cabeza, ultimo, elemento);
          break;
        case '1':
            *cabeza = inserta_en_cabeza(*cabeza, elemento);
    }
}


intercambia

decompiled_code:
__int64 __fastcall intercambia(_DWORD *a1, _DWORD *a2)
{
__int64 result; // rax

result = (unsigned int)*a1;
*a1 = *a2;
*a2 = result;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func9(_DWORD *a1, _DWORD *a2)
{
__int64 result; // rax

result = (unsigned int)*a1;
*a1 = *a2;
*a2 = result;
return result;
}

original_code:
void intercambia(int *dato_1, int *dato_2) {
  int temporal;
  temporal = *dato_1;
  *dato_1 = *dato_2;
  *dato_2 = temporal;
}

variable_types: temporal int


decompiled_code:
int __fastcall intercambia_datos(unsigned int *a1, unsigned int *a2)
{
intercambia(a1, a2);
return visualiza(*a1, *a2);
}

canonical_decompiled_code:
int __fastcall func10(unsigned int *a1, unsigned int *a2)
{
func9(a1, a2);
return func8(*a1, *a2);
}

original_code:
void intercambia_datos(int *dato_1, int *dato_2) {
  intercambia(dato_1, dato_2);
  visualiza(*dato_1, *dato_2);
}


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v4; // [rsp+8h] [rbp-10h] BYREF
int v5[3]; // [rsp+Ch] [rbp-Ch] BYREF

pide_datos(&v4, v5, envp);
visualiza(v4, (unsigned int)v5[0]);
intercambia(&v4, v5);
return visualiza(v4, (unsigned int)v5[0]);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v4; // [rsp+8h] [rbp-10h] BYREF
int v5[3]; // [rsp+Ch] [rbp-Ch] BYREF

func7(&v4, v5, envp);
func8(v4, (unsigned int)v5[0]);
func9(&v4, v5);
return func8(v4, (unsigned int)v5[0]);
}

original_code:
void main(void) {
  int dato_1, dato_2;
  pide_datos(&dato_1, &dato_2);
  visualiza(dato_1, dato_2);
  intercambia(&dato_1, &dato_2);
  visualiza(dato_1, dato_2);
}

canonical_original_code:
void main() {
  int dato_1; int dato_2;
  pide_datos(&dato_1, &dato_2);
  visualiza(dato_1, dato_2);
  intercambia(&dato_1, &dato_2);
  visualiza(dato_1, dato_2);
}


decompiled_code:
__int64 pide_datos()
{
printf("Introduce dato 1: ");
__isoc99_scanf();
printf("Introduce dato 2: ");
return __isoc99_scanf();
}

canonical_decompiled_code:
__int64 func7()
{
printf("Introduce dato 1: ");
__isoc99_scanf();
printf("Introduce dato 2: ");
return __isoc99_scanf();
}

original_code:
void pide_datos(int *dato_1, int *dato_2) {
  printf("Introduce dato 1: ");
  scanf("%d", dato_1);
  printf("Introduce dato 2: ");
  scanf("%d", dato_2);
}


visualiza

decompiled_code:
int __fastcall visualiza(unsigned int a1, unsigned int a2)
{
return printf("\ndato 1: %d\ndato 2: %d\n", a1, a2);
}

canonical_decompiled_code:
int __fastcall func8(unsigned int a1, unsigned int a2)
{
return printf("\ndato 1: %d\ndato 2: %d\n", a1, a2);
}

original_code:
void visualiza(int dato_1, int dato_2) {
  printf("\ndato 1: %d\ndato 2: %d\n", dato_1, dato_2);
}


decompiled_code:
__int64 lee_operacion()
{
unsigned int v1; // [rsp+Ch] [rbp-Ch]

puts("1. SUMA");
puts("2. RESTA");
puts("3. PRODUCTO");
printf("\n\nElige operacion ---> ");
__isoc99_scanf();
return v1;
}

canonical_decompiled_code:
__int64 func7()
{
unsigned int v1; // [rsp+Ch] [rbp-Ch]

puts("1. SUMA");
puts("2. RESTA");
puts("3. PRODUCTO");
printf("\n\nElige operacion ---> ");
__isoc99_scanf();
return v1;
}

original_code:
int lee_operacion(void) {
    int operacion;
    printf("1. SUMA\n");
    printf("2. RESTA\n");
    printf("3. PRODUCTO\n");
    printf("\n\nElige operacion ---> ");
    scanf("%d", &operacion);
    return (operacion);
}

canonical_original_code:
int lee_operacion() {
    int operacion;
    printf("1. SUMA\n");
    printf("2. RESTA\n");
    printf("3. PRODUCTO\n");
    printf("\n\nElige operacion ---> ");
    scanf("%d", &operacion);
    return (operacion);
}

variable_types: operacion int

return_type: int


decompiled_code:
__int64 __fastcall digito_suma(_DWORD *a1)
{
_DWORD *v1; // rdx
int v2; // eax

v1 = a1 + 8;
v2 = 0;
do
v2 += *a1++;
while ( a1 != v1 );
return (unsigned int)(v2 % 10);
}

canonical_decompiled_code:
__int64 __fastcall func9(_DWORD *a1)
{
_DWORD *v1; // rdx
int v2; // eax

v1 = a1 + 8;
v2 = 0;
do
v2 += *a1++;
while ( a1 != v1 );
return (unsigned int)(v2 % 10);
}

original_code:
int digito_suma(int vector[]) {
    int indice, suma;
    for (indice = 0, suma = 0; indice < 9 - 1; indice++) {
        suma += vector[indice];
    }
    return (suma % 10);
}

canonical_original_code:
int digito_suma(int vector[]) {
    int indice; int suma;
    for (indice = 0, suma = 0; indice < 9 - 1; indice++) {
        suma += vector[indice];
    }
    return (suma % 10);
}

variable_types:
vector
int []

variable_types: indice int

variable_types: suma int


decompiled_code:
__int64 __fastcall digito_resta(int *a1)
{
int v1; // edx
_DWORD *v2; // rax
_DWORD *v3; // rdi

v1 = *a1;
v2 = a1 + 1;
v3 = a1 + 8;
do
v1 -= *v2++;
while ( v2 != v3 );
return (unsigned int)(v1 % 10);
}

canonical_decompiled_code:
__int64 __fastcall func10(int *a1)
{
int v1; // edx
_DWORD *v2; // rax
_DWORD *v3; // rdi

v1 = *a1;
v2 = a1 + 1;
v3 = a1 + 8;
do
v1 -= *v2++;
while ( v2 != v3 );
return (unsigned int)(v1 % 10);
}

original_code:
int digito_resta(int vector[]) {
    int indice, resta;
    for (indice = 1, resta = vector[0]; indice < 9 - 1; indice++) {
        resta -= vector[indice];
    }
    return (resta % 10);
}

canonical_original_code:
int digito_resta(int vector[]) {
    int indice; int resta;
    for (indice = 1, resta = vector[0]; indice < 9 - 1; indice++) {
        resta -= vector[indice];
    }
    return (resta % 10);
}

variable_types: resta int


decompiled_code:
__int64 __fastcall digito_producto(int *a1)
{
int *v1; // rdx
__int64 v2; // rcx
__int64 v3; // rax

v1 = a1 + 9;
v2 = 1LL;
do
{
v3 = *a1++;
v2 *= v3;
}
while ( v1 != a1 );
return v2 % 10;
}

original_code:
int digito_producto(int vector[]) {
    int indice;
    long producto;
    for (indice = 0, producto = 1; indice < 9; indice++) {
        producto *= vector[indice];
    }
    return ((int) (producto % 10));
}

variable_types: producto long


decompiled_code:
_BOOL8 __fastcall comprueba_validez(int *a1, int a2)
{
int v2; // eax
_BOOL8 result; // rax
int v4; // eax
__int64 v5; // r9
int v6; // eax
__int64 v7; // r9
int v8; // eax
__int64 v9; // r9

switch ( a2 )
{
case 2:
v4 = digito_resta(a1);
result = *(_DWORD *)(v5 + 32) == v4;
break;
case 3:
v8 = digito_producto(a1);
result = *(_DWORD *)(v9 + 32) == v8;
break;
case 1:
v6 = digito_suma(a1);
result = *(_DWORD *)(v7 + 32) == v6;
break;
default:
result = a1[8] == v2;
break;
}
return result;
}

canonical_decompiled_code:
_BOOL8 __fastcall func12(int *a1, int a2)
{
int v2; // eax
_BOOL8 result; // rax
int v4; // eax
__int64 v5; // r9
int v6; // eax
__int64 v7; // r9
int v8; // eax
__int64 v9; // r9

switch ( a2 )
{
case 2:
v4 = func10(a1);
result = *(_DWORD *)(v5 + 32) == v4;
break;
case 3:
v8 = func11(a1);
result = *(_DWORD *)(v9 + 32) == v8;
break;
case 1:
v6 = func9(a1);
result = *(_DWORD *)(v7 + 32) == v6;
break;
default:
result = a1[8] == v2;
break;
}
return result;
}

original_code:
int comprueba_validez(int vector[], int operacion) {
    int digito, validez = 0;
    switch (operacion) {
        case 1:
            digito = digito_suma(vector);
            break;
        case 2:
            digito = digito_resta(vector);
            break;
        case 3:
            digito = digito_producto(vector);
            break;
    }
    if (digito == vector[8]) {
        validez = 1;
    }
    return (validez);
}

canonical_original_code:
int comprueba_validez(int vector[], int operacion) {
    int digito; int validez = 0;
    switch (operacion) {
        case 1:
            digito = digito_suma(vector);
            break;
        case 2:
            digito = digito_resta(vector);
            break;
        case 3:
            digito = digito_producto(vector);
            break;
    }
    if (digito == vector[8]) {
        validez = 1;
    }
    return (validez);
}

variable_types: digito int

variable_types: validez int


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // ebp
_BYTE v5[56]; // [rsp+0h] [rbp-38h] BYREF

v3 = lee_operacion(argc, argv, envp);
lee_vector(v5);
visualiza_vector(v5);
if ( v3 - 1 > 2 )
return printf("EL CODIGO DE OPERACION ES INCORRECTO");
if ( (unsigned int)comprueba_validez(v5, v3) )
return printf("EL NUMERO DE LA CUENTA ES VALIDO");
return printf("EL NUMERO DE LA CUENTA NO ES VALIDO");
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // ebp
_BYTE v5[56]; // [rsp+0h] [rbp-38h] BYREF

v3 = func7(argc, argv, envp);
func8(v5);
func13(v5);
if ( v3 - 1 > 2 )
return printf("EL CODIGO DE OPERACION ES INCORRECTO");
if ( (unsigned int)func12(v5, v3) )
return printf("EL NUMERO DE LA CUENTA ES VALIDO");
return printf("EL NUMERO DE LA CUENTA NO ES VALIDO");
}

original_code:
void main(void) {
    int operacion;
    int vector[9];
    operacion = lee_operacion();
    lee_vector(vector);
    visualiza_vector(vector);
    if (operacion >= 1 && operacion <= 3) {
        if (comprueba_validez(vector, operacion)) {
            printf("EL NUMERO DE LA CUENTA ES VALIDO");
        } else {
            printf("EL NUMERO DE LA CUENTA NO ES VALIDO");
        }
    } else {
        printf("EL CODIGO DE OPERACION ES INCORRECTO");
    }
}

canonical_original_code:
void main() {
    int operacion;
    int vector[9];
    operacion = lee_operacion();
    lee_vector(vector);
    visualiza_vector(vector);
    if (operacion >= 1 && operacion <= 3) {
        if (comprueba_validez(vector, operacion)) {
            printf("EL NUMERO DE LA CUENTA ES VALIDO");
        } else {
            printf("EL NUMERO DE LA CUENTA NO ES VALIDO");
        }
    } else {
        printf("EL CODIGO DE OPERACION ES INCORRECTO");
    }
}

variable_types:
vector
int [9]


decompiled_code:
__int64 __fastcall lee_vector(__int64 a1)
{
__int64 v1; // rbx
__int64 result; // rax

v1 = a1;
puts("INTRODUCE UNO A UNO LOS 9 DIGITOS DEL NUMERO DE CUENTA");
do
{
v1 += 4LL;
result = __isoc99_scanf();
}
while ( v1 != a1 + 36 );
return result;
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 a1)
{
__int64 v1; // rbx
__int64 result; // rax

v1 = a1;
puts("INTRODUCE UNO A UNO LOS 9 DIGITOS DEL NUMERO DE CUENTA");
do
{
v1 += 4LL;
result = __isoc99_scanf();
}
while ( v1 != a1 + 36 );
return result;
}

original_code:
void lee_vector(int vector[]) {
    int indice;
    printf("INTRODUCE UNO A UNO LOS 9 DIGITOS DEL NUMERO DE CUENTA\n");
    for (indice = 0; indice < 9; indice++) {
        scanf("%d", &vector[indice]);
    }
}


decompiled_code:
int __fastcall visualiza_vector(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi

v1 = a1;
do
{
v2 = *v1++;
printf("%d", v2);
}
while ( v1 != a1 + 9 );
return puts("\n");
}

canonical_decompiled_code:
int __fastcall func13(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi

v1 = a1;
do
{
v2 = *v1++;
printf("%d", v2);
}
while ( v1 != a1 + 9 );
return puts("\n");
}

original_code:
void visualiza_vector(int vector[]) {
    int indice;
    for (indice = 0; indice < 9; indice++) {
        printf("%d", vector[indice]);
    }
    printf("\n\n");
}


decompiled_code:
__int64 __fastcall lee_vectores(__int64 a1, __int64 a2)
{
printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY X\n", 10LL);
lee_vector(a1);
printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY Y\n", 10LL);
return lee_vector(a2);
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 a1, __int64 a2)
{
printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY X\n", 10LL);
func7(a1);
printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY Y\n", 10LL);
return func7(a2);
}

original_code:
void lee_vectores(int vector_x[], int vector_y[]) {
    printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY X\n", 10);
    lee_vector(vector_x);
    printf("INTRODUCE LOS %d ELEMENTOS DEL ARRAY Y\n", 10);
    lee_vector(vector_y);
}


decompiled_code:
int __fastcall cuenta_elementos(unsigned int *a1)
{
unsigned int v1; // er13
unsigned int v2; // ebp
unsigned int *v3; // rbx
unsigned int *v4; // r12
unsigned int v5; // eax

v1 = 0;
v2 = 0;
v3 = a1;
v4 = a1 + 10;
printf("ELEMENTOS DEL ARRAY Z");
do
{
while ( 1 )
{
printf("%5d", *v3);
v5 = *v3;
if ( *v3 == 1 )
break;
++v3;
v2 += v5 == -1;
if ( v3 == v4 )
goto LABEL_5;
}
++v3;
++v1;
}
while ( v3 != v4 );
LABEL_5:
printf("\n\n%d ELEMENTOS DE X QUE SON MAYORES QUE LOS CORRESPONDIENTES DE Y", v1);
return printf("\n\n%d ELEMENTOS DE X QUE SON MENORES QUE LOS CORRESPONDIENTES DE Y", v2);
}

canonical_decompiled_code:
int __fastcall func11(unsigned int *a1)
{
unsigned int v1; // er13
unsigned int v2; // ebp
unsigned int *v3; // rbx
unsigned int *v4; // r12
unsigned int v5; // eax

v1 = 0;
v2 = 0;
v3 = a1;
v4 = a1 + 10;
printf("ELEMENTOS DEL ARRAY Z");
do
{
while ( 1 )
{
printf("%5d", *v3);
v5 = *v3;
if ( *v3 == 1 )
break;
++v3;
v2 += v5 == -1;
if ( v3 == v4 )
goto LABEL_5;
}
++v3;
++v1;
}
while ( v3 != v4 );
LABEL_5:
printf("\n\n%d ELEMENTOS DE X QUE SON MAYORES QUE LOS CORRESPONDIENTES DE Y", v1);
return printf("\n\n%d ELEMENTOS DE X QUE SON MENORES QUE LOS CORRESPONDIENTES DE Y", v2);
}

original_code:
void cuenta_elementos(int vector[]) {
    int indice, mayores, menores;
    printf("ELEMENTOS DEL ARRAY Z");
    for (indice = 0, mayores = 0, menores = 0; indice < 10; indice++) {
        printf("%5d", vector[indice]);
        if (vector[indice] == 1) {
            mayores++;
        } else {
            if (vector[indice] == -1) {
                menores++;
            }
        }
    }
    printf("\n\n%d ELEMENTOS DE X QUE SON MAYORES QUE LOS CORRESPONDIENTES DE Y", mayores);
    printf("\n\n%d ELEMENTOS DE X QUE SON MENORES QUE LOS CORRESPONDIENTES DE Y", menores);
}

canonical_original_code:
void cuenta_elementos(int vector[]) {
    int indice; int mayores; int menores;
    printf("ELEMENTOS DEL ARRAY Z");
    for (indice = 0, mayores = 0, menores = 0; indice < 10; indice++) {
        printf("%5d", vector[indice]);
        if (vector[indice] == 1) {
            mayores++;
        } else {
            if (vector[indice] == -1) {
                menores++;
            }
        }
    }
    printf("\n\n%d ELEMENTOS DE X QUE SON MAYORES QUE LOS CORRESPONDIENTES DE Y", mayores);
    printf("\n\n%d ELEMENTOS DE X QUE SON MENORES QUE LOS CORRESPONDIENTES DE Y", menores);
}

variable_types: mayores int

variable_types: menores int


decompiled_code:
int __fastcall visualiza_vectores(unsigned int *a1, unsigned int *a2, unsigned int *a3)
{
printf("ELEMENTOS DEL ARRAY X");
visualiza_vector(a1);
printf("ELEMENTOS DEL ARRAY Y");
visualiza_vector(a2);
return cuenta_elementos(a3);
}

canonical_decompiled_code:
int __fastcall func12(unsigned int *a1, unsigned int *a2, unsigned int *a3)
{
printf("ELEMENTOS DEL ARRAY X");
func10(a1);
printf("ELEMENTOS DEL ARRAY Y");
func10(a2);
return func11(a3);
}

original_code:
void visualiza_vectores(int vector_x[], int vector_y[], int vector_z[]) {
    printf("ELEMENTOS DEL ARRAY X");
    visualiza_vector(vector_x);
    printf("ELEMENTOS DEL ARRAY Y");
    visualiza_vector(vector_y);
    cuenta_elementos(vector_z);
}


decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BYTE v4[48]; // [rsp+0h] [rbp-98h] BYREF
char v5[48]; // [rsp+30h] [rbp-68h] BYREF
char v6[56]; // [rsp+60h] [rbp-38h] BYREF

lee_vectores(v4, v5, envp);
compara_vectores(v4, v5, v6);
return visualiza_vectores(v4, v5, v6);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BYTE v4[48]; // [rsp+0h] [rbp-98h] BYREF
char v5[48]; // [rsp+30h] [rbp-68h] BYREF
char v6[56]; // [rsp+60h] [rbp-38h] BYREF

func8(v4, v5, envp);
func9(v4, v5, v6);
return func12(v4, v5, v6);
}

original_code:
void main() {
    int vector_x[10], vector_y[10], vector_z[10];
    lee_vectores(vector_x, vector_y);
    compara_vectores(vector_x, vector_y, vector_z);
    visualiza_vectores(vector_x, vector_y, vector_z);
}

canonical_original_code:
void main() {
    int vector_x[10]; int vector_y[10]; int vector_z[10];
    lee_vectores(vector_x, vector_y);
    compara_vectores(vector_x, vector_y, vector_z);
    visualiza_vectores(vector_x, vector_y, vector_z);
}


decompiled_code:
__int64 __fastcall lee_vector(__int64 a1)
{
__int64 v1; // rbx
__int64 result; // rax

v1 = a1;
do
{
v1 += 4LL;
result = __isoc99_scanf();
}
while ( v1 != a1 + 40 );
return result;
}

canonical_decompiled_code:
__int64 __fastcall func7(__int64 a1)
{
__int64 v1; // rbx
__int64 result; // rax

v1 = a1;
do
{
v1 += 4LL;
result = __isoc99_scanf();
}
while ( v1 != a1 + 40 );
return result;
}

original_code:
void lee_vector(int vector[]) {
    int indice;
    for (indice = 0; indice < 10; indice++) {
        scanf("%d", &vector[indice]);
    }
}


decompiled_code:
int __fastcall visualiza_vector(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi

v1 = a1;
do
{
v2 = *v1++;
printf("%5d", v2);
}
while ( v1 != a1 + 10 );
return puts("\n");
}

canonical_decompiled_code:
int __fastcall func10(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi

v1 = a1;
do
{
v2 = *v1++;
printf("%5d", v2);
}
while ( v1 != a1 + 10 );
return puts("\n");
}

original_code:
void visualiza_vector(int vector[]) {
    int indice = 0;
    for (indice = 0; indice < 10; indice++) {
        printf("%5d", vector[indice]);
    }
    printf("\n\n");
}


calcula

decompiled_code:
void __fastcall calcula(float *a1, int a2, float a3)
{
float v4; // xmm0_4

if ( a2 > 0 )
{
v4 = *a1;
do
{
v4 = v4 * a3;
--a2;
}
while ( a2 );
*a1 = v4;
}
}

canonical_decompiled_code:
void __fastcall func7(float *a1, int a2, float a3)
{
float v4; // xmm0_4

if ( a2 > 0 )
{
v4 = *a1;
do
{
v4 = v4 * a3;
--a2;
}
while ( a2 );
*a1 = v4;
}
}

original_code:
void calcula (float *altura, float factor,int orden)
{
for (; orden>0; orden --)
 *altura= *altura * factor;
}

canonical_original_code:
void calcula(float *altura, float factor, int orden)
{
for (; orden>0; orden --)
 *altura= *altura * factor;
}

variable_types:
altura
float *

variable_types: factor float

variable_types: orden int


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // ebp
__int64 v4; // rsi
int v6[5]; // [rsp+4h] [rbp-14h] BYREF

v3 = 1;
printf("INTRODUCE LA ALTURA INICIAL --->");
__isoc99_scanf();
printf("INTRODUCE EL FACTOR DE REBOTE --->");
__isoc99_scanf();
printf("INTRODUCE LA NUEVA ALTURA --->");
__isoc99_scanf();
do
{
v4 = v3++;
calcula(v6, v4, *(float *)&v6[1]);
}
while ( *(float *)v6 > *(float *)&v6[2] );
printf("LA PRIMERA ALTURA INFERIOR A LA DADA ES --->%f\n", *(float *)v6);
return printf("EL NUMERO DE ORDEN DEL REBOTE ES --->%d\n", v3);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // ebp
__int64 v4; // rsi
int v6[5]; // [rsp+4h] [rbp-14h] BYREF

v3 = 1;
printf("INTRODUCE LA ALTURA INICIAL --->");
__isoc99_scanf();
printf("INTRODUCE EL FACTOR DE REBOTE --->");
__isoc99_scanf();
printf("INTRODUCE LA NUEVA ALTURA --->");
__isoc99_scanf();
do
{
v4 = v3++;
func7(v6, v4, *(float *)&v6[1]);
}
while ( *(float *)v6 > *(float *)&v6[2] );
printf("LA PRIMERA ALTURA INFERIOR A LA DADA ES --->%f\n", *(float *)v6);
return printf("EL NUMERO DE ORDEN DEL REBOTE ES --->%d\n", v3);
}

original_code:
void main (void)
{
int orden=1 ;
float altura,factor,nueva;
printf ("INTRODUCE LA ALTURA INICIAL --->");
scanf ("%f",&altura);
printf ("INTRODUCE EL FACTOR DE REBOTE --->");
scanf ("%f",&factor);
printf ("INTRODUCE LA NUEVA ALTURA --->");
scanf ("%f",&nueva);
do
 {
 calcula (&altura,factor,orden);
 orden ++ ;
 }
while (altura>nueva);
printf ("LA PRIMERA ALTURA INFERIOR A LA DADA ES --->%f\n",altura);
printf ("EL NUMERO DE ORDEN DEL REBOTE ES --->%d\n",orden);
}

canonical_original_code:
void main()
{
int orden = 1;
float altura; float factor; float nueva;
printf ("INTRODUCE LA ALTURA INICIAL --->");
scanf ("%f",&altura);
printf ("INTRODUCE EL FACTOR DE REBOTE --->");
scanf ("%f",&factor);
printf ("INTRODUCE LA NUEVA ALTURA --->");
scanf ("%f",&nueva);
do
 {
 calcula (&altura,factor,orden);
 orden ++ ;
 }
while (altura>nueva);
printf ("LA PRIMERA ALTURA INFERIOR A LA DADA ES --->%f\n",altura);
printf ("EL NUMERO DE ORDEN DEL REBOTE ES --->%d\n",orden);
}

variable_types: altura float

variable_types: nueva float


decompiled_code:
int __fastcall introduce_puntuaciones(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
int result; // eax
char v5; // [rsp+Fh] [rbp-39h] BYREF
__int64 v6; // [rsp+10h] [rbp-38h] BYREF
__int64 v7; // [rsp+18h] [rbp-30h] BYREF
__int64 v8; // [rsp+20h] [rbp-28h] BYREF
__int64 v9[4]; // [rsp+28h] [rbp-20h] BYREF

*a3 = 0LL;
*a2 = 0LL;
*a1 = 0LL;
do
{
while ( 1 )
{
pide_datos((void **)&v6, &v5);
if ( v5 != 89 )
break;
inserta_nodo(a2, &v8, v6);
LABEL_4:
result = pregunta();
if ( (_BYTE)result == 78 )
return result;
}
if ( v5 != 90 )
{
if ( v5 == 88 )
inserta_nodo(a1, &v7, v6);
goto LABEL_4;
}
inserta_nodo(a3, v9, v6);
result = pregunta();
}
while ( (_BYTE)result != 78 );
return result;
}

canonical_decompiled_code:
int __fastcall func5(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
int result; // eax
char v5; // [rsp+Fh] [rbp-39h] BYREF
__int64 v6; // [rsp+10h] [rbp-38h] BYREF
__int64 v7; // [rsp+18h] [rbp-30h] BYREF
__int64 v8; // [rsp+20h] [rbp-28h] BYREF
__int64 v9[4]; // [rsp+28h] [rbp-20h] BYREF

*a3 = 0LL;
*a2 = 0LL;
*a1 = 0LL;
do
{
while ( 1 )
{
func2((void **)&v6, &v5);
if ( v5 != 89 )
break;
func3(a2, &v8, v6);
LABEL_4:
result = func4();
if ( (_BYTE)result == 78 )
return result;
}
if ( v5 != 90 )
{
if ( v5 == 88 )
func3(a1, &v7, v6);
goto LABEL_4;
}
func3(a3, v9, v6);
result = func4();
}
while ( (_BYTE)result != 78 );
return result;
}

original_code:
void introduce_puntuaciones(PUNT_NODO_PUNTUACIONES *p_juez_1,
        PUNT_NODO_PUNTUACIONES *p_juez_2, PUNT_NODO_PUNTUACIONES *p_juez_3) {
    PUNT_NODO_PUNTUACIONES nuevo, ultimo_1, ultimo_2, ultimo_3;
    char juez;
    char respuesta;
    *p_juez_1 = *p_juez_2 = *p_juez_3 = (PUNT_NODO_PUNTUACIONES) ((void *)0);
    do {
        pide_datos(&nuevo, &juez);
        switch (juez) {
            case 'X':
                inserta_nodo(p_juez_1, &ultimo_1, nuevo);
                break;
            case 'Y':
                inserta_nodo(p_juez_2, &ultimo_2, nuevo);
                break;
            case 'Z':
                inserta_nodo(p_juez_3, &ultimo_3, nuevo);
                break;
        }
        respuesta = pregunta();
    } while (respuesta != 'N');
}

canonical_original_code:
void introduce_puntuaciones(struct nodo_puntuaciones **p_juez_1, struct nodo_puntuaciones **p_juez_2, struct nodo_puntuaciones **p_juez_3) {
    struct nodo_puntuaciones *nuevo; struct nodo_puntuaciones *ultimo_1; struct nodo_puntuaciones *ultimo_2; struct nodo_puntuaciones *ultimo_3;
    char juez;
    char respuesta;
    *p_juez_1 = *p_juez_2 = *p_juez_3 = (PUNT_NODO_PUNTUACIONES) ((void *)0);
    do {
        pide_datos(&nuevo, &juez);
        switch (juez) {
            case 'X':
                inserta_nodo(p_juez_1, &ultimo_1, nuevo);
                break;
            case 'Y':
                inserta_nodo(p_juez_2, &ultimo_2, nuevo);
                break;
            case 'Z':
                inserta_nodo(p_juez_3, &ultimo_3, nuevo);
                break;
        }
        respuesta = pregunta();
    } while (respuesta != 'N');
}

variable_types: struct nodo_puntuaciones { struct ficha_puntuaciones { int numero; short sabor; } info; struct nodo_puntuaciones *enlace; } **

variable_types: juez char

variable_types: respuesta char

user_defined_types: struct nodo_puntuaciones { struct ficha_puntuaciones info; struct nodo_puntuaciones *enlace; }


decompiled_code:
__int64 __fastcall busca_nodo(__int64 a1, _DWORD *a2)
{
__int64 result; // rax

result = a1;
if ( !a1 )
return 0LL;
do
{
if ( *(_DWORD *)result == *a2 )
break;
result = *(_QWORD *)(result + 16);
}
while ( result );
return result;
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1, _DWORD *a2)
{
__int64 result; // rax

result = a1;
if ( !a1 )
return 0LL;
do
{
if ( *(_DWORD *)result == *a2 )
break;
result = *(_QWORD *)(result + 16);
}
while ( result );
return result;
}

original_code:
PUNT_NODO_PUNTUACIONES busca_nodo(PUNT_NODO_PUNTUACIONES cabeza,
        PUNT_NODO_PUNTUACIONES viejo_1) {
    PUNT_NODO_PUNTUACIONES recorre;
    recorre = cabeza;
    while (recorre != (PUNT_NODO_PUNTUACIONES) ((void *)0)
            && recorre->info.numero != viejo_1->info.numero) {
        recorre = recorre->enlace;
    }
    return (recorre);
}

canonical_original_code:
struct nodo_puntuaciones *busca_nodo(struct nodo_puntuaciones *cabeza, struct nodo_puntuaciones *viejo_1) {
    struct nodo_puntuaciones *recorre;
    recorre = cabeza;
    while (recorre != (PUNT_NODO_PUNTUACIONES) ((void *)0)
            && recorre->info.numero != viejo_1->info.numero) {
        recorre = recorre->enlace;
    }
    return (recorre);
}

variable_types:
cabeza
struct nodo_puntuaciones *

variable_types: struct nodo_puntuaciones { struct ficha_puntuaciones { int numero; short sabor; } info; struct nodo_puntuaciones *enlace; } *


decompiled_code:
__int64 __fastcall elimina_nodo(__int64 *a1, __int64 a2, _DWORD *a3)
{
__int64 v3; // rax
__int64 *v4; // r8
__int64 *v5; // rcx
__int64 result; // rax
__int64 *v7; // rcx

v3 = busca_nodo(*a1, a3);
*v4 = v3;
result = elimina(*v5, (__int64)v4);
*v7 = result;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 *a1, __int64 a2, _DWORD *a3)
{
__int64 v3; // rax
__int64 *v4; // r8
__int64 *v5; // rcx
__int64 result; // rax
__int64 *v7; // rcx

v3 = func6(*a1, a3);
*v4 = v3;
result = func7(*v5, (__int64)v4);
*v7 = result;
return result;
}

original_code:
void elimina_nodo(PUNT_NODO_PUNTUACIONES *p_cabeza,
        PUNT_NODO_PUNTUACIONES *p_viejo,
        PUNT_NODO_PUNTUACIONES viejo_1) {
    *p_viejo = busca_nodo(*p_cabeza, viejo_1);
    *p_cabeza = elimina(*p_cabeza, p_viejo);
}

canonical_original_code:
void elimina_nodo(struct nodo_puntuaciones **p_cabeza, struct nodo_puntuaciones **p_viejo, struct nodo_puntuaciones *viejo_1) {
    *p_viejo = busca_nodo(*p_cabeza, viejo_1);
    *p_cabeza = elimina(*p_cabeza, p_viejo);
}

user_defined_types: struct ficha_puntuaciones { int numero; short sabor; }


original_code:
PUNT_NODO_CLASIFICACION busca_posicion(PUNT_NODO_CLASIFICACION cabeza,
        PUNT_NODO_CLASIFICACION nuevo) {
    PUNT_NODO_CLASIFICACION recorre;
    int encontrado = 0;
    recorre = cabeza;
    while (recorre != (PUNT_NODO_CLASIFICACION) ((void *)0) && !encontrado) {
        if (recorre->info.puntuacion < nuevo->info.puntuacion) {
            encontrado = 1;
        } else {
            if (recorre->info.puntuacion == nuevo->info.puntuacion
                    && recorre->info.numero > nuevo->info.numero) {
                encontrado = 1;
            } else {
                recorre = recorre->enlace;
            }
        }
    }
    return (recorre);
}

canonical_original_code:
struct nodo_clasificacion *busca_posicion(struct nodo_clasificacion *cabeza, struct nodo_clasificacion *nuevo) {
    struct nodo_clasificacion *recorre;
    int encontrado = 0;
    recorre = cabeza;
    while (recorre != (PUNT_NODO_CLASIFICACION) ((void *)0) && !encontrado) {
        if (recorre->info.puntuacion < nuevo->info.puntuacion) {
            encontrado = 1;
        } else {
            if (recorre->info.puntuacion == nuevo->info.puntuacion
                    && recorre->info.numero > nuevo->info.numero) {
                encontrado = 1;
            } else {
                recorre = recorre->enlace;
            }
        }
    }
    return (recorre);
}

variable_types:
cabeza
struct nodo_clasificacion *

variable_types:
nuevo
struct nodo_clasificacion *

variable_types: struct nodo_clasificacion { struct ficha_clasificacion { char nombre[21]; char poblacion[21]; int numero; int puntuacion; } info; struct nodo_clasificacion *enlace; } *

variable_types: encontrado int

user_defined_types: struct nodo_clasificacion { struct ficha_clasificacion info; struct nodo_clasificacion *enlace; }


original_code:
PUNT_NODO_CLASIFICACION inserta_en_orden(PUNT_NODO_CLASIFICACION cabeza,
        PUNT_NODO_CLASIFICACION nuevo, PUNT_NODO_CLASIFICACION posicion) {
    PUNT_NODO_CLASIFICACION anterior;
    if (posicion == cabeza) {
        nuevo->enlace = cabeza;
        cabeza = nuevo;
    } else {
        anterior = cabeza;
        while(anterior->enlace != posicion) {
            anterior = anterior->enlace;
        }
        nuevo->enlace = posicion;
        anterior->enlace = nuevo;
    }
    return (cabeza);
}

canonical_original_code:
struct nodo_clasificacion *inserta_en_orden(struct nodo_clasificacion *cabeza, struct nodo_clasificacion *nuevo, struct nodo_clasificacion *posicion) {
    struct nodo_clasificacion *anterior;
    if (posicion == cabeza) {
        nuevo->enlace = cabeza;
        cabeza = nuevo;
    } else {
        anterior = cabeza;
        while(anterior->enlace != posicion) {
            anterior = anterior->enlace;
        }
        nuevo->enlace = posicion;
        anterior->enlace = nuevo;
    }
    return (cabeza);
}

variable_types:
posicion
struct nodo_clasificacion *

return_type: struct nodo_clasificacion { struct ficha_clasificacion { char nombre[21]; char poblacion[21]; int numero; int puntuacion; } info; struct nodo_clasificacion *enlace; } *


decompiled_code:
__int64 __fastcall crea_clasificacion(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 v4; // rbx
__int64 v6; // rbp
_DWORD *v7; // r9
_DWORD *v8; // r9
void *v9; // r9
char *v10; // rsi
__int64 v11; // rax
__int64 result; // rax
__int64 v13; // [rsp+0h] [rbp-38h] BYREF
__int64 v14; // [rsp+8h] [rbp-30h] BYREF
void *v15; // [rsp+10h] [rbp-28h] BYREF
void *v16; // [rsp+18h] [rbp-20h] BYREF

v14 = a2;
v13 = a3;
if ( !a1 )
return 0LL;
v4 = a1;
v6 = 0LL;
do
{
v7 = (_DWORD *)v4;
v4 = *(_QWORD *)(v4 + 16);
elimina_nodo(&v14, (__int64)&v15, v7);
elimina_nodo(&v13, (__int64)&v16, v8);
v10 = crea_nodo(v9, v15, v16, a4);
v11 = busca_posicion(v6, (__int64)v10);
result = inserta_en_orden(v6, (__int64)v10, v11);
v6 = result;
}
while ( v4 );
return result;
}

original_code:
PUNT_NODO_CLASIFICACION crea_clasificacion(PUNT_NODO_PUNTUACIONES juez_1,
        PUNT_NODO_PUNTUACIONES juez_2, PUNT_NODO_PUNTUACIONES juez_3,
        FICHA_INSCRIPCION vector_inscripciones[]) {
    PUNT_NODO_CLASIFICACION nuevo, posicion;
    PUNT_NODO_CLASIFICACION ganador = (PUNT_NODO_CLASIFICACION) ((void *)0);
    PUNT_NODO_PUNTUACIONES viejo_1, viejo_2, viejo_3;
    while (juez_1 != (PUNT_NODO_PUNTUACIONES) ((void *)0)) {
        viejo_1 = juez_1;
        juez_1 = juez_1->enlace;
        elimina_nodo(&juez_2, &viejo_2, viejo_1);
        elimina_nodo(&juez_3, &viejo_3, viejo_1);
        nuevo = crea_nodo(viejo_1, viejo_2, viejo_3, vector_inscripciones);
        posicion = busca_posicion(ganador, nuevo);
        ganador = inserta_en_orden(ganador, nuevo, posicion);
    }
    return (ganador);
}

canonical_original_code:
struct nodo_clasificacion *crea_clasificacion(struct nodo_puntuaciones *juez_1, struct nodo_puntuaciones *juez_2, struct nodo_puntuaciones *juez_3, struct ficha_inscripcion vector_inscripciones[]) {
    struct nodo_clasificacion *nuevo; struct nodo_clasificacion *posicion;
    struct nodo_clasificacion *ganador = (PUNT_NODO_CLASIFICACION) ((void *)0);
    struct nodo_puntuaciones *viejo_1; struct nodo_puntuaciones *viejo_2; struct nodo_puntuaciones *viejo_3;
    while (juez_1 != (PUNT_NODO_PUNTUACIONES) ((void *)0)) {
        viejo_1 = juez_1;
        juez_1 = juez_1->enlace;
        elimina_nodo(&juez_2, &viejo_2, viejo_1);
        elimina_nodo(&juez_3, &viejo_3, viejo_1);
        nuevo = crea_nodo(viejo_1, viejo_2, viejo_3, vector_inscripciones);
        posicion = busca_posicion(ganador, nuevo);
        ganador = inserta_en_orden(ganador, nuevo, posicion);
    }
    return (ganador);
}

variable_types: struct ficha_inscripcion { char nombre[21]; char poblacion[21]; int numero; } []

user_defined_types: struct ficha_clasificacion { char nombre[21]; char poblacion[21]; int numero; int puntuacion; }


decompiled_code:
void *__fastcall pide_datos(void **a1, _BYTE *a2)
{
void *result; // rax

printf("\n\nIDENTIFICADOR DE JUEZ --->");
*a2 = getchar();
*a1 = malloc(0x18uLL);
printf("\nNUMERO --->");
_isoc99_scanf("%d", *a1);
printf("\nSABOR --->");
_isoc99_scanf("%d", (char *)*a1 + 4);
printf("\nPUNTO --->");
_isoc99_scanf("%d", (char *)*a1 + 6);
printf("\nPRESENTACION --->");
_isoc99_scanf("%d", (char *)*a1 + 8);
result = *a1;
*((_QWORD *)*a1 + 2) = 0LL;
return result;
}

canonical_decompiled_code:
void *__fastcall func2(void **a1, _BYTE *a2)
{
void *result; // rax

printf("\n\nIDENTIFICADOR DE JUEZ --->");
*a2 = getchar();
*a1 = malloc(0x18uLL);
printf("\nNUMERO --->");
_isoc99_scanf("%d", *a1);
printf("\nSABOR --->");
_isoc99_scanf("%d", (char *)*a1 + 4);
printf("\nPUNTO --->");
_isoc99_scanf("%d", (char *)*a1 + 6);
printf("\nPRESENTACION --->");
_isoc99_scanf("%d", (char *)*a1 + 8);
result = *a1;
*((_QWORD *)*a1 + 2) = 0LL;
return result;
}

original_code:
void pide_datos(PUNT_NODO_PUNTUACIONES *p_nuevo, char *juez) {
    printf("\n\nIDENTIFICADOR DE JUEZ --->");
    *juez = getchar();
    *p_nuevo = (PUNT_NODO_PUNTUACIONES) malloc(sizeof (NODO_PUNTUACIONES));
    printf("\nNUMERO --->");
    scanf("%d", &(*p_nuevo)->info.numero);
    printf("\nSABOR --->");
    scanf("%d", &(*p_nuevo)->info.sabor);
    printf("\nPUNTO --->");
    scanf("%d", &(*p_nuevo)->info.punto);
    printf("\nPRESENTACION --->");
    scanf("%d", &(*p_nuevo)->info.presentacion);
    (*p_nuevo)->enlace = (PUNT_NODO_PUNTUACIONES) ((void *)0);
}

canonical_original_code:
void pide_datos(struct nodo_puntuaciones **p_nuevo, char *juez) {
    printf("\n\nIDENTIFICADOR DE JUEZ --->");
    *juez = getchar();
    *p_nuevo = (struct nodo_puntuaciones *) malloc(sizeof (NODO_PUNTUACIONES));
    printf("\nNUMERO --->");
    scanf("%d", &(*p_nuevo)->info.numero);
    printf("\nSABOR --->");
    scanf("%d", &(*p_nuevo)->info.sabor);
    printf("\nPUNTO --->");
    scanf("%d", &(*p_nuevo)->info.punto);
    printf("\nPRESENTACION --->");
    scanf("%d", &(*p_nuevo)->info.presentacion);
    (*p_nuevo)->enlace = (PUNT_NODO_PUNTUACIONES) ((void *)0);
}

variable_types:
juez
char *


decompiled_code:
__int64 __fastcall inserta_nodo(_QWORD *a1, __int64 *a2, __int64 a3)
{
__int64 result; // rax

if ( *a1 )
{
result = *a2;
*(_QWORD *)(*a2 + 16) = a3;
}
else
{
*a1 = a3;
}
*a2 = a3;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func3(_QWORD *a1, __int64 *a2, __int64 a3)
{
__int64 result; // rax

if ( *a1 )
{
result = *a2;
*(_QWORD *)(*a2 + 16) = a3;
}
else
{
*a1 = a3;
}
*a2 = a3;
return result;
}

original_code:
void inserta_nodo(PUNT_NODO_PUNTUACIONES *p_cabeza,
        PUNT_NODO_PUNTUACIONES *p_ultimo,
        PUNT_NODO_PUNTUACIONES nuevo) {
    if (*p_cabeza == (PUNT_NODO_PUNTUACIONES) ((void *)0)) {
        *p_cabeza = nuevo;
    } else {
        (*p_ultimo)->enlace = nuevo;
    }
    *p_ultimo = nuevo;
}

canonical_original_code:
void inserta_nodo(struct nodo_puntuaciones **p_cabeza, struct nodo_puntuaciones **p_ultimo, struct nodo_puntuaciones *nuevo) {
    if (*p_cabeza == (PUNT_NODO_PUNTUACIONES) ((void *)0)) {
        *p_cabeza = nuevo;
    } else {
        (*p_ultimo)->enlace = nuevo;
    }
    *p_ultimo = nuevo;
}

variable_types:
nuevo
struct nodo_puntuaciones *


elimina

original_code:
PUNT_NODO_PUNTUACIONES elimina(PUNT_NODO_PUNTUACIONES cabeza,
        PUNT_NODO_PUNTUACIONES viejo) {
    PUNT_NODO_PUNTUACIONES anterior;
    if (viejo == cabeza) {
        cabeza = cabeza->enlace;
    } else {
        anterior = cabeza;
        while (anterior->enlace != viejo) {
            anterior = anterior->enlace;
        }
        anterior->enlace = viejo->enlace;
    }
    viejo->enlace = (PUNT_NODO_PUNTUACIONES) ((void *)0);
    return (cabeza);
}

canonical_original_code:
struct nodo_puntuaciones *elimina(struct nodo_puntuaciones *cabeza, struct nodo_puntuaciones *viejo) {
    struct nodo_puntuaciones *anterior;
    if (viejo == cabeza) {
        cabeza = cabeza->enlace;
    } else {
        anterior = cabeza;
        while (anterior->enlace != viejo) {
            anterior = anterior->enlace;
        }
        anterior->enlace = viejo->enlace;
    }
    viejo->enlace = (PUNT_NODO_PUNTUACIONES) ((void *)0);
    return (cabeza);
}

variable_types:
viejo
struct nodo_puntuaciones *

return_type: struct nodo_puntuaciones { struct ficha_puntuaciones { int numero; short sabor; } info; struct nodo_puntuaciones *enlace; } *


original_code:
PUNT_NODO_CLASIFICACION crea_nodo(PUNT_NODO_PUNTUACIONES viejo_1,
        PUNT_NODO_PUNTUACIONES viejo_2, PUNT_NODO_PUNTUACIONES viejo_3,
        FICHA_INSCRIPCION vector_inscripciones[]) {
    PUNT_NODO_CLASIFICACION nuevo;
    nuevo = (PUNT_NODO_CLASIFICACION) malloc(sizeof (NODO_CLASIFICACION));
    strcpy(nuevo->info.nombre, vector_inscripciones[viejo_1->info.numero - 1].nombre);
    strcpy(nuevo->info.nombre, vector_inscripciones[viejo_1->info.numero - 1].poblacion);
    nuevo->info.numero = viejo_1->info.numero;
    nuevo->info.puntuacion = viejo_1->info.sabor + viejo_1->info.punto + viejo_1->info.presentacion
            + viejo_2->info.sabor + viejo_2->info.punto + viejo_2->info.presentacion
            + viejo_3->info.sabor + viejo_3->info.punto + viejo_3->info.presentacion;
    nuevo->enlace = (PUNT_NODO_CLASIFICACION) ((void *)0);
    free (viejo_1);
    free (viejo_2);
    free (viejo_3);
    return (nuevo);
}

canonical_original_code:
struct nodo_clasificacion *crea_nodo(struct nodo_puntuaciones *viejo_1, struct nodo_puntuaciones *viejo_2, struct nodo_puntuaciones *viejo_3, struct ficha_inscripcion vector_inscripciones[]) {
    struct nodo_clasificacion *nuevo;
    nuevo = (struct nodo_clasificacion *) malloc(sizeof (NODO_CLASIFICACION));
    strcpy(nuevo->info.nombre, vector_inscripciones[viejo_1->info.numero - 1].nombre);
    strcpy(nuevo->info.nombre, vector_inscripciones[viejo_1->info.numero - 1].poblacion);
    nuevo->info.numero = viejo_1->info.numero;
    nuevo->info.puntuacion = viejo_1->info.sabor + viejo_1->info.punto + viejo_1->info.presentacion
            + viejo_2->info.sabor + viejo_2->info.punto + viejo_2->info.presentacion
            + viejo_3->info.sabor + viejo_3->info.punto + viejo_3->info.presentacion;
    nuevo->enlace = (PUNT_NODO_CLASIFICACION) ((void *)0);
    free (viejo_1);
    free (viejo_2);
    free (viejo_3);
    return (nuevo);
}

user_defined_types: struct ficha_inscripcion { char nombre[21]; char poblacion[21]; int numero; }


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax
void *v4; // rax
int v5; // [rsp+4h] [rbp-3874h] BYREF
__int64 v6; // [rsp+8h] [rbp-3870h] BYREF
__int64 v7; // [rsp+10h] [rbp-3868h] BYREF
__int64 v8; // [rsp+18h] [rbp-3860h] BYREF
__int64 v9; // [rsp+20h] [rbp-3858h] BYREF
char filename[8]; // [rsp+28h] [rbp-3850h] BYREF
char v11[14408]; // [rsp+30h] [rbp-3848h] BYREF

v9 = 0x50495243534E49LL;
strcpy(filename, "GANADOR");
vuelca_fichero_inscripciones_a_vector((const char *)&v9, (__int64)v11, &v5);
if ( v5 )
{
printf("ERROR AL INTENTAR ABRIR EL FICHERO PARA LEER");
result = getchar();
}
else
{
introduce_puntuaciones(&v6, &v7, &v8);
v4 = (void *)crea_clasificacion(v6, v7, v8, (__int64)v11);
result = vuelca_lista_a_fichero_clasificacion(v4, filename);
}
return result;
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax
void *v4; // rax
int v5; // [rsp+4h] [rbp-3874h] BYREF
__int64 v6; // [rsp+8h] [rbp-3870h] BYREF
__int64 v7; // [rsp+10h] [rbp-3868h] BYREF
__int64 v8; // [rsp+18h] [rbp-3860h] BYREF
__int64 v9; // [rsp+20h] [rbp-3858h] BYREF
char filename[8]; // [rsp+28h] [rbp-3850h] BYREF
char v11[14408]; // [rsp+30h] [rbp-3848h] BYREF

v9 = 0x50495243534E49LL;
strcpy(filename, "GANADOR");
func0((const char *)&v9, (__int64)v11, &v5);
if ( v5 )
{
printf("ERROR AL INTENTAR ABRIR EL FICHERO PARA LEER");
result = getchar();
}
else
{
func5(&v6, &v7, &v8);
v4 = (void *)func12(v6, v7, v8, (__int64)v11);
result = func1(v4, filename);
}
return result;
}

original_code:
void main (void) {
    char nomf_inscripciones[] = "INSCRIP";
    char nomf_clasificacion[] = "GANADOR";
    FICHA_INSCRIPCION vector_inscripciones[300];
    PUNT_NODO_PUNTUACIONES juez_1, juez_2, juez_3;
    PUNT_NODO_CLASIFICACION ganador;
    int error;
    vuelca_fichero_inscripciones_a_vector(nomf_inscripciones,
            vector_inscripciones, &error);
    if (error) {
        printf("ERROR AL INTENTAR ABRIR EL FICHERO PARA LEER");
        getchar();
    } else {
        introduce_puntuaciones(&juez_1, &juez_2, &juez_3);
        ganador = crea_clasificacion(juez_1, juez_2, juez_3,
                vector_inscripciones);
        vuelca_lista_a_fichero_clasificacion(ganador, nomf_clasificacion);
    }
}

canonical_original_code:
void main() {
    char nomf_inscripciones[] = "INSCRIP";
    char nomf_clasificacion[] = "GANADOR";
    struct ficha_inscripcion vector_inscripciones[300];
    struct nodo_puntuaciones *juez_1; struct nodo_puntuaciones *juez_2; struct nodo_puntuaciones *juez_3;
    struct nodo_clasificacion *ganador;
    int error;
    vuelca_fichero_inscripciones_a_vector(nomf_inscripciones,
            vector_inscripciones, &error);
    if (error) {
        printf("ERROR AL INTENTAR ABRIR EL FICHERO PARA LEER");
        getchar();
    } else {
        introduce_puntuaciones(&juez_1, &juez_2, &juez_3);
        ganador = crea_clasificacion(juez_1, juez_2, juez_3,
                vector_inscripciones);
        vuelca_lista_a_fichero_clasificacion(ganador, nomf_clasificacion);
    }
}

variable_types: struct ficha_inscripcion { char nombre[21]; char poblacion[21]; int numero; } [300]

variable_types: error int


inferiores

decompiled_code:
__int64 __fastcall inferiores(int a1)
{
int v1; // edi
__int64 result; // rax

v1 = a1 - 1;
if ( !v1 )
return 0LL;
LODWORD(result) = v1;
do
result = (unsigned int)(--v1 + result);
while ( v1 );
return result;
}

canonical_decompiled_code:
__int64 __fastcall func7(int a1)
{
int v1; // edi
__int64 result; // rax

v1 = a1 - 1;
if ( !v1 )
return 0LL;
LODWORD(result) = v1;
do
result = (unsigned int)(--v1 + result);
while ( v1 );
return result;
}

original_code:
int inferiores (int centro )
{
int inferiores;
centro --;
for (inferiores = centro; centro != 0;)
 {
 centro --;
 inferiores = inferiores + centro;
 }
return (inferiores) ;
}

canonical_original_code:
int inferiores(int centro)
{
int inferiores;
centro --;
for (inferiores = centro; centro != 0;)
 {
 centro --;
 inferiores = inferiores + centro;
 }
return (inferiores) ;
}

variable_types: centro int

variable_types: inferiores int


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rdi
int result; // eax
unsigned int v5[3]; // [rsp+Ch] [rbp-Ch] BYREF

printf("INTRODUCIR UN NUMERO N --->");
__isoc99_scanf();
v3 = v5[0];
do
{
comprueba(v3, v5);
result = v5[0];
v3 = v5[0] - 1;
v5[0] = v3;
}
while ( (_DWORD)v3 );
return result;
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rdi
int result; // eax
unsigned int v5[3]; // [rsp+Ch] [rbp-Ch] BYREF

printf("INTRODUCIR UN NUMERO N --->");
__isoc99_scanf();
v3 = v5[0];
do
{
func8(v3, v5);
result = v5[0];
v3 = v5[0] - 1;
v5[0] = v3;
}
while ( (_DWORD)v3 );
return result;
}

original_code:
void main (void)
{
int numero;
printf ("INTRODUCIR UN NUMERO N --->");
scanf ("%d",&numero);
do
 {
 comprueba (numero );
 numero -- ;
 }
while (numero != 0);
}

canonical_original_code:
void main()
{
int numero;
printf ("INTRODUCIR UN NUMERO N --->");
scanf ("%d",&numero);
do
 {
 comprueba (numero );
 numero -- ;
 }
while (numero != 0);
}

variable_types: numero int


comprueba

decompiled_code:
int __fastcall comprueba(unsigned int a1)
{
int v1; // edx
int v2; // ecx
int result; // eax

v2 = inferiores(a1);
result = v1;
do
result += ++v1;
while ( v2 > result );
if ( v2 == result )
result = printf("EL NUMERO %d ES UN CENTRO NUMERICO \n", a1);
return result;
}

canonical_decompiled_code:
int __fastcall func8(unsigned int a1)
{
int v1; // edx
int v2; // ecx
int result; // eax

v2 = func7(a1);
result = v1;
do
result += ++v1;
while ( v2 > result );
if ( v2 == result )
result = printf("EL NUMERO %d ES UN CENTRO NUMERICO \n", a1);
return result;
}

original_code:
void comprueba (int numero )
{
int centro = numero ;
int superiores = ++numero ;
do
 {
 numero++ ;
 superiores = superiores + numero ;
 }
while (superiores < inferiores (centro)) ;
if ( superiores ==inferiores (centro) )
 printf ("EL NUMERO %d ES UN CENTRO NUMERICO \n",centro);
}

canonical_original_code:
void comprueba(int numero)
{
int centro = numero;
int superiores = ++numero;
do
 {
 numero++ ;
 superiores = superiores + numero ;
 }
while (superiores < inferiores (centro)) ;
if ( superiores ==inferiores (centro) )
 printf ("EL NUMERO %d ES UN CENTRO NUMERICO \n",centro);
}

variable_types: superiores int


potencia

decompiled_code:
float __fastcall potencia(int a1, float result)
{
float v2; // xmm1_4

v2 = result;
if ( a1 <= 0 )
return 1.0;
for ( ; a1 != 1; --a1 )
result = result * v2;
return result;
}

canonical_decompiled_code:
float __fastcall func7(int a1, float result)
{
float v2; // xmm1_4

v2 = result;
if ( a1 <= 0 )
return 1.0;
for ( ; a1 != 1; --a1 )
result = result * v2;
return result;
}

original_code:
float potencia (float numero, int grado)
{
float potencia ;
if (grado>0)
 {
 for (potencia = numero ; grado > 1;grado --)
  potencia = potencia*numero;
 }
else
 potencia =1;
return (potencia);
}

canonical_original_code:
float potencia(float numero, int grado)
{
float potencia;
if (grado>0)
 {
 for (potencia = numero ; grado > 1;grado --)
  potencia = potencia*numero;
 }
else
 potencia =1;
return (potencia);
}

variable_types: numero float

variable_types: grado int

variable_types: potencia float

return_type: float


factorial

decompiled_code:
__int64 __fastcall factorial(int a1)
{
__int64 result; // rax

result = 1LL;
if ( a1 > 1 )
{
LODWORD(result) = a1;
do
result = (unsigned int)(--a1 * result);
while ( a1 != 1 );
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func8(int a1)
{
__int64 result; // rax

result = 1LL;
if ( a1 > 1 )
{
LODWORD(result) = a1;
do
result = (unsigned int)(--a1 * result);
while ( a1 != 1 );
}
return result;
}

original_code:
int factorial (int grado)
{
int factorial ;
if (grado >0)
 for (factorial =grado;grado>1 ; )
  {
  grado --;
  factorial = factorial*grado;
  }
else
 factorial=1;
return (factorial);
}

canonical_original_code:
int factorial(int grado)
{
int factorial;
if (grado >0)
 for (factorial =grado;grado>1 ; )
  {
  grado --;
  factorial = factorial*grado;
  }
else
 factorial=1;
return (factorial);
}

variable_types: factorial int


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
double v3; // xmm1_8
unsigned int v4; // edx
double v5; // xmm2_8
double v6; // xmm4_8
double v7; // xmm0_8
unsigned int v8; // edx
int v9; // eax
int v10; // ecx
int v12[3]; // [rsp+Ch] [rbp-Ch] BYREF

printf("INTRODUZCA LA X --->");
__isoc99_scanf();
v4 = 0;
v5 = 0.0;
*(_QWORD *)&v6 = (unsigned int)v12[0];
do
{
v7 = potencia(v4, v12, v6, v3, v5, 0.0005);
*(float *)&v7 = factorial(v8, v12, v8 + 2, v7, 0.0);
*(float *)&v7 = *(float *)&v7 / (float)v9;
HIDWORD(v3) = 0;
*(float *)&v3 = (float)v10 * *(float *)&v7;
*(float *)&v5 = *(float *)&v5 + *(float *)&v3;
}
while ( *(float *)&v7 > 0.0005 );
return printf("EL COSENO DE X ES --->%f", *(float *)&v5);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
double v3; // xmm1_8
unsigned int v4; // edx
double v5; // xmm2_8
double v6; // xmm4_8
double v7; // xmm0_8
unsigned int v8; // edx
int v9; // eax
int v10; // ecx
int v12[3]; // [rsp+Ch] [rbp-Ch] BYREF

printf("INTRODUZCA LA X --->");
__isoc99_scanf();
v4 = 0;
v5 = 0.0;
*(_QWORD *)&v6 = (unsigned int)v12[0];
do
{
v7 = func7(v4, v12, v6, v3, v5, 0.0005);
*(float *)&v7 = func8(v8, v12, v8 + 2, v7, 0.0);
*(float *)&v7 = *(float *)&v7 / (float)v9;
HIDWORD(v3) = 0;
*(float *)&v3 = (float)v10 * *(float *)&v7;
*(float *)&v5 = *(float *)&v5 + *(float *)&v3;
}
while ( *(float *)&v7 > 0.0005 );
return printf("EL COSENO DE X ES --->%f", *(float *)&v5);
}

original_code:
void main (void)
{
float numero;
float coseno = 0;
int grado = 0 ;
float termino;
int signo = 1 ;
printf ("INTRODUZCA LA X --->");
scanf ("%f",&numero);
do
 {
 termino= potencia (numero,grado)/factorial (grado) ;
 coseno = coseno + signo*termino ;
 signo = -signo ;
 grado = grado + 2 ;
 }
while (termino > 0.0005 );
printf ("EL COSENO DE X ES --->%f",coseno);
}

canonical_original_code:
void main()
{
float numero;
float coseno = 0;
int grado = 0;
float termino;
int signo = 1;
printf ("INTRODUZCA LA X --->");
scanf ("%f",&numero);
do
 {
 termino= potencia (numero,grado)/factorial (grado) ;
 coseno = coseno + signo*termino ;
 signo = -signo ;
 grado = grado + 2 ;
 }
while (termino > 0.0005 );
printf ("EL COSENO DE X ES --->%f",coseno);
}

variable_types: coseno float

variable_types: termino float

variable_types: signo int


suma

decompiled_code:
__int64 __fastcall suma(unsigned int *a1)
{
unsigned int *v1; // rax
int v2; // er12

v1 = a1;
v2 = 0;
do
v2 += *v1++;
while ( v1 != a1 + 8 );
printf("\n%d LA SUMA ES %d", *a1, (unsigned int)v2);
for ( ; v2 > 10; v2 -= 10 )
;
return (unsigned int)v2;
}

canonical_decompiled_code:
__int64 __fastcall func7(unsigned int *a1)
{
unsigned int *v1; // rax
int v2; // er12

v1 = a1;
v2 = 0;
do
v2 += *v1++;
while ( v1 != a1 + 8 );
printf("\n%d LA SUMA ES %d", *a1, (unsigned int)v2);
for ( ; v2 > 10; v2 -= 10 )
;
return (unsigned int)v2;
}

original_code:
int suma (int cuenta [])
{
int indi, suma;
for (indi=0, suma=0; indi+1<9; indi++)
 suma = suma + cuenta [indi];
printf ("\n%d      LA SUMA ES %d", cuenta [0], suma);
for (;suma>10;)
 suma=suma-10;
return (suma);
}

canonical_original_code:
int suma(int cuenta[])
{
int indi; int suma;
for (indi=0, suma=0; indi+1<9; indi++)
 suma = suma + cuenta [indi];
printf ("\n%d      LA SUMA ES %d", cuenta [0], suma);
for (;suma>10;)
 suma=suma-10;
return (suma);
}

variable_types:
cuenta
int []

variable_types: indi int

variable_types: suma int


resta

decompiled_code:
__int64 __fastcall resta(__int64 a1)
{
int *v1; // rax
int *v2; // rdi
__int64 v3; // rdx
int v4; // ebx
int v5; // ebp
__int64 result; // rax

v1 = (int *)(a1 + 4);
v2 = (int *)(a1 + 32);
LODWORD(v3) = *(v2 - 8);
do
{
v4 = *v1++;
v5 = v3;
v3 = (unsigned int)(v3 - v4);
}
while ( v1 != v2 );
printf("\n%d LA RESTA ES %d", (unsigned int)*(v2 - 8), v3);
for ( result = (unsigned int)(v4 - v5); (int)result > 10; result = (unsigned int)(result - 10) )
;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 a1)
{
int *v1; // rax
int *v2; // rdi
__int64 v3; // rdx
int v4; // ebx
int v5; // ebp
__int64 result; // rax

v1 = (int *)(a1 + 4);
v2 = (int *)(a1 + 32);
LODWORD(v3) = *(v2 - 8);
do
{
v4 = *v1++;
v5 = v3;
v3 = (unsigned int)(v3 - v4);
}
while ( v1 != v2 );
printf("\n%d LA RESTA ES %d", (unsigned int)*(v2 - 8), v3);
for ( result = (unsigned int)(v4 - v5); (int)result > 10; result = (unsigned int)(result - 10) )
;
return result;
}

original_code:
int resta (int cuenta [])
{
int indi, resta;
for (indi=1, resta =cuenta [0]; indi+1<9; indi++)
 resta = resta - cuenta [indi];
printf ("\n%d      LA RESTA ES %d", cuenta [0], resta);
resta = -resta;
for (;resta>10;)
 resta=resta-10;
return (resta);
}

canonical_original_code:
int resta(int cuenta[])
{
int indi; int resta;
for (indi=1, resta =cuenta [0]; indi+1<9; indi++)
 resta = resta - cuenta [indi];
printf ("\n%d      LA RESTA ES %d", cuenta [0], resta);
resta = -resta;
for (;resta>10;)
 resta=resta-10;
return (resta);
}

variable_types: resta int


multi

decompiled_code:
__int64 __fastcall multi(unsigned int *a1)
{
unsigned int *v1; // rax
int v2; // er12

v1 = a1;
v2 = 1;
do
v2 *= *v1++;
while ( v1 != a1 + 8 );
printf("\n%d LA MULTIPLICACION ES %d", *a1, (unsigned int)v2);
for ( ; v2 > 10; v2 -= 10 )
;
return (unsigned int)v2;
}

canonical_decompiled_code:
__int64 __fastcall func9(unsigned int *a1)
{
unsigned int *v1; // rax
int v2; // er12

v1 = a1;
v2 = 1;
do
v2 *= *v1++;
while ( v1 != a1 + 8 );
printf("\n%d LA MULTIPLICACION ES %d", *a1, (unsigned int)v2);
for ( ; v2 > 10; v2 -= 10 )
;
return (unsigned int)v2;
}

original_code:
int multi (int cuenta [])
{
int multi, indi;
for (indi=0, multi =1 ; indi+1<9; indi++)
 multi = multi * cuenta [indi];
printf ("\n%d      LA MULTIPLICACION ES %d", cuenta [0], multi);
for (;multi>10;)
 multi=multi-10;
return (multi);
}

canonical_original_code:
int multi(int cuenta[])
{
int multi; int indi;
for (indi=0, multi =1 ; indi+1<9; indi++)
 multi = multi * cuenta [indi];
printf ("\n%d      LA MULTIPLICACION ES %d", cuenta [0], multi);
for (;multi>10;)
 multi=multi-10;
return (multi);
}

variable_types: multi int


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
char *v3; // rbx
int result; // eax
int v5; // ebx
int v6; // ebx
int v7; // ebx
int v8; // ebx
int v9; // ebx
int v10; // ebx
int v11; // ebx
int v12; // ebx
int v13; // ebx
int vars0[8]; // [rsp+0h] [rbp+0h] BYREF
int vars20; // [rsp+20h] [rbp+20h]
char vars24[36]; // [rsp+24h] [rbp+24h] BYREF

v3 = (char *)vars0;
do
{
v3 += 4;
__isoc99_scanf();
}
while ( v3 != vars24 );
do
printf("%d", (unsigned int)vars0[0]);
while ( vars0 != (int *)vars24 );
result = vars0[0];
if ( vars0[0] == 1 )
{
v5 = vars20;
if ( v5 == (unsigned int)suma(vars0) )
{
printf("\nLA CUENTA ES VALIDA");
result = vars0[0];
}
else
{
v6 = vars20;
if ( v6 == (unsigned int)resta(vars0) || (v7 = vars20, v7 == (unsigned int)multi(vars0)) )
{
printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
result = vars0[0];
}
else
{
printf("\nLA CUENTA NO ES VALIDA");
result = vars0[0];
}
}
}
if ( result == 2 )
{
v11 = vars20;
if ( v11 == (unsigned int)resta(vars0) )
{
printf("\nLA CUENTA ES VALIDA");
result = vars0[0];
}
else
{
v12 = vars20;
if ( v12 == (unsigned int)suma(vars0) || (v13 = vars20, v13 == (unsigned int)multi(vars0)) )
{
printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
result = vars0[0];
}
else
{
printf("\nLA CUENTA NO ES VALIDA");
result = vars0[0];
}
}
}
if ( result == 3 )
{
v8 = vars20;
if ( v8 == (unsigned int)multi(vars0) )
{
result = printf("\nLA CUENTA ES VALIDA");
}
else
{
v9 = vars20;
if ( v9 == (unsigned int)resta(vars0) || (v10 = vars20, v10 == (unsigned int)suma(vars0)) )
result = printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
else
result = printf("\nLA CUENTA NO ES VALIDA");
}
}
return result;
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
char *v3; // rbx
int result; // eax
int v5; // ebx
int v6; // ebx
int v7; // ebx
int v8; // ebx
int v9; // ebx
int v10; // ebx
int v11; // ebx
int v12; // ebx
int v13; // ebx
int vars0[8]; // [rsp+0h] [rbp+0h] BYREF
int vars20; // [rsp+20h] [rbp+20h]
char vars24[36]; // [rsp+24h] [rbp+24h] BYREF

v3 = (char *)vars0;
do
{
v3 += 4;
__isoc99_scanf();
}
while ( v3 != vars24 );
do
printf("%d", (unsigned int)vars0[0]);
while ( vars0 != (int *)vars24 );
result = vars0[0];
if ( vars0[0] == 1 )
{
v5 = vars20;
if ( v5 == (unsigned int)func7(vars0) )
{
printf("\nLA CUENTA ES VALIDA");
result = vars0[0];
}
else
{
v6 = vars20;
if ( v6 == (unsigned int)func8(vars0) || (v7 = vars20, v7 == (unsigned int)func9(vars0)) )
{
printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
result = vars0[0];
}
else
{
printf("\nLA CUENTA NO ES VALIDA");
result = vars0[0];
}
}
}
if ( result == 2 )
{
v11 = vars20;
if ( v11 == (unsigned int)func8(vars0) )
{
printf("\nLA CUENTA ES VALIDA");
result = vars0[0];
}
else
{
v12 = vars20;
if ( v12 == (unsigned int)func7(vars0) || (v13 = vars20, v13 == (unsigned int)func9(vars0)) )
{
printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
result = vars0[0];
}
else
{
printf("\nLA CUENTA NO ES VALIDA");
result = vars0[0];
}
}
}
if ( result == 3 )
{
v8 = vars20;
if ( v8 == (unsigned int)func9(vars0) )
{
result = printf("\nLA CUENTA ES VALIDA");
}
else
{
v9 = vars20;
if ( v9 == (unsigned int)func8(vars0) || (v10 = vars20, v10 == (unsigned int)func7(vars0)) )
result = printf("\nEL CODIGO DE OPERACION ES INCORRECTO");
else
result = printf("\nLA CUENTA NO ES VALIDA");
}
}
return result;
}

original_code:
void main (void)
{
int indice;
int cuenta [9];
for (indice=0; indice<9; indice++)
 scanf ("%d", &cuenta [indice]);
for (indice=0; indice<9; indice++)
 printf ("%d", cuenta [indice]);
if (cuenta [0]==1)
 {
 if (cuenta [9 -1]==suma (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==resta (cuenta ) || cuenta [9 -1]== multi (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
if (cuenta [0]==2)
 {
 if (cuenta [9 -1]==resta (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==suma (cuenta ) || cuenta [9 -1]== multi (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
if (cuenta [0]==3)
 {
 if (cuenta [9 -1]==multi (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==resta (cuenta ) || cuenta [9 -1]== suma (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
}

canonical_original_code:
void main()
{
int indice;
int cuenta[9];
for (indice=0; indice<9; indice++)
 scanf ("%d", &cuenta [indice]);
for (indice=0; indice<9; indice++)
 printf ("%d", cuenta [indice]);
if (cuenta [0]==1)
 {
 if (cuenta [9 -1]==suma (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==resta (cuenta ) || cuenta [9 -1]== multi (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
if (cuenta [0]==2)
 {
 if (cuenta [9 -1]==resta (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==suma (cuenta ) || cuenta [9 -1]== multi (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
if (cuenta [0]==3)
 {
 if (cuenta [9 -1]==multi (cuenta ))
  printf ("\nLA CUENTA ES VALIDA");
 else
  {
  if (cuenta [9 -1]==resta (cuenta ) || cuenta [9 -1]== suma (cuenta ))
   printf ("\nEL CODIGO DE OPERACION ES INCORRECTO");
  else
   printf ("\nLA CUENTA NO ES VALIDA");
  }
 }
}

variable_types: indice int

variable_types:
cuenta
int [9]


decompiled_code:
void *crea_array()
{
char *v0; // rbx

v0 = (char *)&array_0;
do
{
v0 += 4;
__isoc99_scanf();
}
while ( v0 != (char *)&end );
return &array_0;
}

canonical_decompiled_code:
void *func7()
{
char *v0; // rbx

v0 = (char *)&array_0;
do
{
v0 += 4;
__isoc99_scanf();
}
while ( v0 != (char *)&end );
return &array_0;
}

original_code:
int *crea_array(void) {
  static int array[10];
  int indice = 0;
  do {
    scanf("%d", &array[indice++]);
  } while (indice < 10);
  return array;
}

canonical_original_code:
int *crea_array() {
  static int array[10];
  int indice = 0;
  do {
    scanf("%d", &array[indice++]);
  } while (indice < 10);
  return array;
}

variable_types:
array
int [10]

return_type: int *


decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rax

v3 = crea_array(argc, argv, envp);
return visualiza_array(v3);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rax

v3 = func7(argc, argv, envp);
return func8(v3);
}

original_code:
void main(void) {
  int *puntero;
  puntero = crea_array();
  visualiza_array(puntero);
}

canonical_original_code:
void main() {
  int *puntero;
  puntero = crea_array();
  visualiza_array(puntero);
}

variable_types:
puntero
int *


decompiled_code:
int __fastcall visualiza_array(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi
int result; // eax

v1 = a1;
do
{
v2 = *v1++;
result = printf("%6d", v2);
}
while ( v1 != a1 + 10 );
return result;
}

canonical_decompiled_code:
int __fastcall func8(unsigned int *a1)
{
unsigned int *v1; // rbx
__int64 v2; // rsi
int result; // eax

v1 = a1;
do
{
v2 = *v1++;
result = printf("%6d", v2);
}
while ( v1 != a1 + 10 );
return result;
}

original_code:
void visualiza_array(int numeros[]) {
  int indice;
  for (indice = 0; indice < 10; indice++) {
    printf("%6d", *(numeros + indice));
  }
}

variable_types:
numeros
int []


estrella

original_code:
float estrella (int cielo [] [20],int indice1,int indice2)
{
float suma;
 suma= cielo [indice1+1] [indice2] + cielo [indice1-1] [indice2] + cielo [indice1] [indice2] +
 cielo [indice1+1] [indice2+1] + cielo [indice1-1] [indice2+1] + cielo [indice1] [indice2+1] +
 cielo [indice1+1] [indice2-1] + cielo [indice1-1] [indice2-1] + cielo [indice1] [indice2-1];
return (suma);
}

canonical_original_code:
float estrella(int cielo[][20], int indice1, int indice2)
{
float suma;
 suma= cielo [indice1+1] [indice2] + cielo [indice1-1] [indice2] + cielo [indice1] [indice2] +
 cielo [indice1+1] [indice2+1] + cielo [indice1-1] [indice2+1] + cielo [indice1] [indice2+1] +
 cielo [indice1+1] [indice2-1] + cielo [indice1-1] [indice2-1] + cielo [indice1] [indice2-1];
return (suma);
}

variable_types:
cielo
int [][20]

variable_types: suma float


main

original_code:
void main (void)
{
int cielo [20] [20];
char plano [20] [20];
int filas, columnas;
int indice1, indice2;
introduce_array (cielo, &filas, &columnas);
for (indice1=0; indice1<filas; indice1++)
 for (indice2=0; indice2<columnas; indice2++)
  {
  if (indice1==0 || indice1==filas-1 || indice2==0 || indice2==columnas-1)
   plano [indice1] [indice2]=' ';
  if (indice1!=0 && indice1!=filas-1 && indice2!=0 && indice2!=columnas-1)
   {
   if (estrella (cielo , indice1, indice2)/9>6.0)
    plano [indice1] [indice2]='*';
   else
    plano [indice1] [indice2]='.';
   }
  }
for (indice1=0; indice1<filas; indice1++)
 {
 printf ("\n");
 for (indice2=0; indice2<columnas; indice2++)
  printf ("  %c",plano [indice1] [indice2]);
 }
}

canonical_original_code:
void main()
{
int cielo[20][20];
char plano[20][20];
int filas; int columnas;
int indice1; int indice2;
introduce_array (cielo, &filas, &columnas);
for (indice1=0; indice1<filas; indice1++)
 for (indice2=0; indice2<columnas; indice2++)
  {
  if (indice1==0 || indice1==filas-1 || indice2==0 || indice2==columnas-1)
   plano [indice1] [indice2]=' ';
  if (indice1!=0 && indice1!=filas-1 && indice2!=0 && indice2!=columnas-1)
   {
   if (estrella (cielo , indice1, indice2)/9>6.0)
    plano [indice1] [indice2]='*';
   else
    plano [indice1] [indice2]='.';
   }
  }
for (indice1=0; indice1<filas; indice1++)
 {
 printf ("\n");
 for (indice2=0; indice2<columnas; indice2++)
  printf ("  %c",plano [indice1] [indice2]);
 }
}

variable_types:
cielo
int [20][20]

variable_types:
plano
char [20][20]

variable_types: filas int

variable_types: columnas int


decompiled_code:
int __fastcall introduce_array(__int64 a1, int *a2, int *a3)
{
int result; // eax
int v6; // er15
int i; // ebx

do
{
printf("INTRODUZCA EL NUMERO DE COLUMNAS --->");
__isoc99_scanf();
}
while ( *a3 > 20 );
do
{
printf("INTRODUZCA EL NUMERO DE FILAS --->");
__isoc99_scanf();
}
while ( *a2 > 20 );
result = puts("\nINTRODUZCA LOS ELEMENTOS DEL ARRAY");
if ( *a2 > 0 )
{
v6 = 0;
do
{
result = *a3;
for ( i = 0; *a3 > i; result = printf("VALOR NO VALIDO. INTRODUZCA OTRO") )
{
while ( 1 )
{
result = __isoc99_scanf();
if ( *(_DWORD *)(a1 + 4LL * i) > 0x14u )
break;
if ( *a3 <= ++i )
goto LABEL_10;
}
}
LABEL_10:
++v6;
a1 += 80LL;
}
while ( *a2 > v6 );
}
return result;
}

canonical_decompiled_code:
int __fastcall func7(__int64 a1, int *a2, int *a3)
{
int result; // eax
int v6; // er15
int i; // ebx

do
{
printf("INTRODUZCA EL NUMERO DE COLUMNAS --->");
__isoc99_scanf();
}
while ( *a3 > 20 );
do
{
printf("INTRODUZCA EL NUMERO DE FILAS --->");
__isoc99_scanf();
}
while ( *a2 > 20 );
result = puts("\nINTRODUZCA LOS ELEMENTOS DEL ARRAY");
if ( *a2 > 0 )
{
v6 = 0;
do
{
result = *a3;
for ( i = 0; *a3 > i; result = printf("VALOR NO VALIDO. INTRODUZCA OTRO") )
{
while ( 1 )
{
result = __isoc99_scanf();
if ( *(_DWORD *)(a1 + 4LL * i) > 0x14u )
break;
if ( *a3 <= ++i )
goto LABEL_10;
}
}
LABEL_10:
++v6;
a1 += 80LL;
}
while ( *a2 > v6 );
}
return result;
}

original_code:
void introduce_array (int cielo [] [20],int *filas, int *columnas)
{
int indice1, indice2;
do
 {
 printf ("INTRODUZCA EL NUMERO DE COLUMNAS --->");
 scanf ("%d",columnas);
 }
while (*columnas>20);
do
 {
 printf ("INTRODUZCA EL NUMERO DE FILAS --->");
 scanf ("%d",filas);
 }
while (*filas>20);
printf ("\nINTRODUZCA LOS ELEMENTOS DEL ARRAY\n");
for (indice1=0; indice1<*filas; indice1++)
 for (indice2=0; indice2<*columnas; indice2++)
  {
  scanf ("%d",&cielo [indice1] [indice2]);
  if (cielo [indice1] [indice2]<0 || cielo [indice1] [indice2]>20)
   {
   printf ("VALOR NO VALIDO. INTRODUZCA OTRO");
   indice2--;
   }
  }
}

canonical_original_code:
void introduce_array(int cielo[][20], int *filas, int *columnas)
{
int indice1; int indice2;
do
 {
 printf ("INTRODUZCA EL NUMERO DE COLUMNAS --->");
 scanf ("%d",columnas);
 }
while (*columnas>20);
do
 {
 printf ("INTRODUZCA EL NUMERO DE FILAS --->");
 scanf ("%d",filas);
 }
while (*filas>20);
printf ("\nINTRODUZCA LOS ELEMENTOS DEL ARRAY\n");
for (indice1=0; indice1<*filas; indice1++)
 for (indice2=0; indice2<*columnas; indice2++)
  {
  scanf ("%d",&cielo [indice1] [indice2]);
  if (cielo [indice1] [indice2]<0 || cielo [indice1] [indice2]>20)
   {
   printf ("VALOR NO VALIDO. INTRODUZCA OTRO");
   indice2--;
   }
  }
}

variable_types:
filas
int *

variable_types:
columnas
int *


mayusculas

decompiled_code:
size_t __fastcall mayusculas(char *a1)
{
size_t result; // rax
__int64 v2; // rcx

result = strlen(a1);
if ( (int)result > 0 )
{
v2 = (__int64)&a1[(unsigned int)(result - 1) + 1];
do
{
result = (unsigned __int8)*a1;
if ( (unsigned __int8)(result - 97) <= 0x19u )
{
result = (unsigned int)(result - 32);
*a1 = result;
}
++a1;
}
while ( a1 != (char *)v2 );
}
return result;
}

canonical_decompiled_code:
size_t __fastcall func8(char *a1)
{
size_t result; // rax
__int64 v2; // rcx

result = strlen(a1);
if ( (int)result > 0 )
{
v2 = (__int64)&a1[(unsigned int)(result - 1) + 1];
do
{
result = (unsigned __int8)*a1;
if ( (unsigned __int8)(result - 97) <= 0x19u )
{
result = (unsigned int)(result - 32);
*a1 = result;
}
++a1;
}
while ( a1 != (char *)v2 );
}
return result;
}

original_code:
void mayusculas(char cadena[]) {
  int indice, num_elem;
  num_elem = strlen(cadena);
  for (indice = 0; indice < num_elem; indice ++) {
  if (cadena[indice] >= 97 && cadena[indice] <= 122) {
    cadena[indice] = cadena[indice] - 32;
   }
 }
}

canonical_original_code:
void mayusculas(char cadena[]) {
  int indice; int num_elem;
  num_elem = strlen(cadena);
  for (indice = 0; indice < num_elem; indice ++) {
  if (cadena[indice] >= 97 && cadena[indice] <= 122) {
    cadena[indice] = cadena[indice] - 32;
   }
 }
}

variable_types:
cadena
char []


main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4[120]; // [rsp+0h] [rbp-78h] BYREF

introduce(v4, argv, envp);
puts(v4);
mayusculas(v4);
puts(v4);
puts(v4);
return comprueba(v4);
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4[120]; // [rsp+0h] [rbp-78h] BYREF

func7(v4, argv, envp);
puts(v4);
func8(v4);
puts(v4);
puts(v4);
return func9(v4);
}

original_code:
void main (void) {
  char cadena [100];
  introduce(cadena);
  puts(cadena);
  mayusculas(cadena);
  puts(cadena);
  puts(cadena);
  comprueba(cadena);
}

canonical_original_code:
void main() {
  char cadena[100];
  introduce(cadena);
  puts(cadena);
  mayusculas(cadena);
  puts(cadena);
  puts(cadena);
  comprueba(cadena);
}

variable_types:
cadena
char [100]


comprueba

decompiled_code:
int __fastcall comprueba(const char *a1)
{
__int64 v1; // rax
__int64 v2; // rdx
int v3; // ecx
int result; // eax

LODWORD(v1) = strlen(a1) - 1;
if ( (int)v1 < 0 )
goto LABEL_8;
v1 = (int)v1;
v2 = 0LL;
v3 = 1;
do
{
if ( a1[v2] != a1[v1] )
v3 = 0;
++v2;
--v1;
}
while ( (int)v2 <= (int)v1 );
if ( v3 )
LABEL_8:
result = printf("\n\nES UN PALINDROMO");
else
result = printf("\n\nNO ES UN PALINDROMO");
return result;
}

canonical_decompiled_code:
int __fastcall func9(const char *a1)
{
__int64 v1; // rax
__int64 v2; // rdx
int v3; // ecx
int result; // eax

LODWORD(v1) = strlen(a1) - 1;
if ( (int)v1 < 0 )
goto LABEL_8;
v1 = (int)v1;
v2 = 0LL;
v3 = 1;
do
{
if ( a1[v2] != a1[v1] )
v3 = 0;
++v2;
--v1;
}
while ( (int)v2 <= (int)v1 );
if ( v3 )
LABEL_8:
result = printf("\n\nES UN PALINDROMO");
else
result = printf("\n\nNO ES UN PALINDROMO");
return result;
}

original_code:
void comprueba(char cadena []) {
  int indice_1, indice_2, comprueba = 1;
  indice_2 = strlen(cadena) - 1;
  for (indice_1 = 0; indice_1 <= indice_2; indice_1++, indice_2--) {
    if (cadena[indice_1] != cadena[indice_2]) {
    comprueba = 0;
   }
  }
  if (comprueba) {
    printf("\n\nES UN PALINDROMO");
  } else {
    printf("\n\nNO ES UN PALINDROMO");
  }
}

canonical_original_code:
void comprueba(char cadena[]) {
  int indice_1; int indice_2; int comprueba = 1;
  indice_2 = strlen(cadena) - 1;
  for (indice_1 = 0; indice_1 <= indice_2; indice_1++, indice_2--) {
    if (cadena[indice_1] != cadena[indice_2]) {
    comprueba = 0;
   }
  }
  if (comprueba) {
    printf("\n\nES UN PALINDROMO");
  } else {
    printf("\n\nNO ES UN PALINDROMO");
  }
}

variable_types: comprueba int


main

repo: jreisinger/hithere

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
const char **v3; // rbx
const char **v4; // rbp
const char *v5; // rsi

if ( argc == 1 )
{
puts("hi there, world!");
}
else
{
printf("hi there");
if ( argc > 1 )
{
v3 = argv + 1;
v4 = &argv[(unsigned int)(argc - 2) + 2];
do
{
v5 = *v3++;
printf(", %s", v5);
}
while ( v3 != v4 );
}
putchar(10);
}
return 0;
}

original_code:
int main(int argc, char **argv)
{
    if (argc == 1)
        printf("hi there, world!\n");
    else {
        printf("hi there");
        for (int i = 1; i < argc; ++i)
            printf(", %s", argv[i]);
        printf("\n");
    }
    return 0;
}

variable_types: argc int

variable_types:
argv
char **

variable_types: i int


repo: jrenner/renbits

variable_types:
word
char [40]

variable_types:
buff
char [100]


original_code:
void dec_to_bin(long n){
    int num_of_bits;
    if(n < 128 && n >= -128)
        num_of_bits = 8;
    else if(n < 32768 && n >= -32768)
        num_of_bits = 16;
    else if(n < 8388608 && n >= -8388608)
        num_of_bits = 24;
    else if(n < 2147483648 && n >= -2147483648)
        num_of_bits = 32;
    else{
        printf("Number out of bounds: %ld\n", n);
        exit(1);
    }
    int spaces = (num_of_bits / 4) - 1;
    int j = num_of_bits - 1;
    long check = 1;
    for(;j > 0; j--)
        check = check << 1;
    char *buff = malloc(sizeof(char) * (num_of_bits + 1 + spaces));
    int i = 0;
    while(check)
    {
        if ((i % 5) == 0)
            buff[i++] = ' ';
        if(n & check){
            buff[i++] = '1';
        }
        else
            buff[i++] = '0';
        check = check>>1;
    }
    buff[i]= '\0';
    printf("%40s -> %d-BIT integer: %ld", buff, num_of_bits, n);
    if(n >= 0 && n <= 255)
        printf(" char: %c", (int)n);
    printf("\n");
    free(buff);
}

variable_types: n long

variable_types: spaces int

variable_types: j int

variable_types: check long

variable_types:
buff
char *