original_code:
void leer_archivo(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  int size;
  char *texto;
  Archivo *arch;
  arch = buscar_archivo(lista, msj->nombre);
  if(arch->indice > arch->tam) {
    if(msj->dato == 'm')
      enviar(cola->disp, 'r', '0', '0', ((void *)0));
    else {
      enviar(cola->anillo, 'r', msj->contador-1, 't', ((void *)0));
    }
  }
  else {
    size = ((msj->otrodato) < (arch->tam - arch->indice) ? (msj->otrodato) : (arch->tam - arch->indice));
    if((texto = (char *) malloc((size+1) * sizeof (char))) == ((void *)0))
      printf("REA: error\n");
    memcpy(texto, &(arch->texto)[arch->indice], size);
    texto[size] = '\0';
    arch->indice += size;
    if(msj->dato == 'm')
      enviarWR(cola->disp,'r', '0', '0', size, texto, ((void *)0));
    else
      enviarWR(cola->anillo, 'r', msj->contador-1, 't', size, texto, ((void *)0));
  }
}

canonical_original_code:
void leer_archivo(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  int size;
  char *texto;
  struct archivo_ *arch;
  arch = buscar_archivo(lista, msj->nombre);
  if(arch->indice > arch->tam) {
    if(msj->dato == 'm')
      enviar(cola->disp, 'r', '0', '0', ((void *)0));
    else {
      enviar(cola->anillo, 'r', msj->contador-1, 't', ((void *)0));
    }
  }
  else {
    size = ((msj->otrodato) < (arch->tam - arch->indice) ? (msj->otrodato) : (arch->tam - arch->indice));
    if((texto = (char *) malloc((size+1) * sizeof (char))) == ((void *)0))
      printf("REA: error\n");
    memcpy(texto, &(arch->texto)[arch->indice], size);
    texto[size] = '\0';
    arch->indice += size;
    if(msj->dato == 'm')
      enviarWR(cola->disp,'r', '0', '0', size, texto, ((void *)0));
    else
      enviarWR(cola->anillo, 'r', msj->contador-1, 't', size, texto, ((void *)0));
  }
}

variable_types: struct colas { int worker; int disp; int anillo; } *

variable_types: size int

variable_types:
texto
char *

variable_types: struct archivo_ { char *nombre; char *texto; int estado; int indice; int tam; struct archivo_ *proximo; } *

user_defined_types: struct msj_ { char tipo; char contador; char dato; int otrodato; char *nombre; char *texto; }


decompiled_code:
__int64 __fastcall cerrar_archivo(__int64 a1, __int64 a2)
{
__int64 result; // rax

result = buscar_archivo(a1, *(_QWORD *)(a2 + 8));
*(_QWORD *)(result + 16) = 0LL;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2)
{
__int64 result; // rax

result = buscar_archivo(a1, *(_QWORD *)(a2 + 8));
*(_QWORD *)(result + 16) = 0LL;
return result;
}

original_code:
void cerrar_archivo(ListaArchivos *lista, Msj *msj)
{
  Archivo *arch;
  arch = buscar_archivo(lista, msj->nombre);
  arch->estado = 0;
  arch->indice = 0;
}

canonical_original_code:
void cerrar_archivo(struct lista_ *lista, struct msj_ *msj)
{
  struct archivo_ *arch;
  arch = buscar_archivo(lista, msj->nombre);
  arch->estado = 0;
  arch->indice = 0;
}

variable_types: struct lista_ { struct archivo_ { char *nombre; char *texto; int estado; int indice; int tam; struct archivo_ *proximo; } *inicio; int t; char worker; } *

variable_types: struct msj_ { char tipo; char contador; char dato; int otrodato; char *nombre; char *texto; } *

return_type: void

user_defined_types: struct lista_ { struct archivo_ *inicio; int t; char worker; }


decompiled_code:
__int64 __fastcall esperar_respuesta(unsigned int *a1, __int64 a2, __int64 a3)
{
__int64 v4; // rax

do
v4 = recibir(*a1);
while ( !(unsigned int)evaluar_msj(a1, v4, a2, a3) );
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func3(unsigned int *a1, __int64 a2, __int64 a3)
{
__int64 v4; // rax

do
v4 = recibir(*a1);
while ( !(unsigned int)func12(a1, v4, a2, a3) );
return 0LL;
}

original_code:
int esperar_respuesta(DescriptorColas *cola, ListaArchivos *lista, char *candidato)
{
  Msj *msj;
  while(1) {
    msj = recibir(cola->worker);
    if(evaluar_msj(cola, msj, lista, candidato))
      break;
  }
  return 0;
}

canonical_original_code:
int esperar_respuesta(struct colas *cola, struct lista_ *lista, char *candidato)
{
  struct msj_ *msj;
  while(1) {
    msj = recibir(cola->worker);
    if(evaluar_msj(cola, msj, lista, candidato))
      break;
  }
  return 0;
}

variable_types:
candidato
char *

return_type: int

user_defined_types: struct colas { int worker; int disp; int anillo; }

user_defined_types: struct archivo_ { char *nombre; char *texto; int estado; int indice; int tam; struct archivo_ *proximo; }


operadorLSD

decompiled_code:
void __fastcall operadorLSD(unsigned int *a1, __int64 a2, __int64 a3)
{
char *v4; // rax
char *v5; // rbp

if ( !malloc(0x200uLL) )
puts("LSD: error");
v4 = (char *)concatenar_archivos(a2);
v5 = v4;
if ( *(_BYTE *)(a3 + 2) == 109 )
{
enviar(a1[2], 108LL, 53LL, 102LL, v4);
esperar_respuesta(a1, a2, 0LL);
free(v5);
}
else
{
strcat(v4, *(const char **)(a3 + 8));
enviar(a1[2], 108LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 102LL, v5);
}
}

canonical_decompiled_code:
void __fastcall func4(unsigned int *a1, __int64 a2, __int64 a3)
{
char *v4; // rax
char *v5; // rbp

if ( !malloc(0x200uLL) )
puts("LSD: error");
v4 = (char *)concatenar_archivos(a2);
v5 = v4;
if ( *(_BYTE *)(a3 + 2) == 109 )
{
enviar(a1[2], 108LL, 53LL, 102LL, v4);
func3(a1, a2, 0LL);
free(v5);
}
else
{
strcat(v4, *(const char **)(a3 + 8));
enviar(a1[2], 108LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 102LL, v5);
}
}

original_code:
void operadorLSD(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  char *nombres;
  if((nombres = (char *) malloc(512 * sizeof (char))) == ((void *)0))
    printf("LSD: error\n");
  nombres = concatenar_archivos(lista);
  if(msj->dato != 'm') {
    strcat(nombres, msj->nombre);
    enviar(cola->anillo, 'l', msj->contador-1, 'f', nombres);
  }
  else {
    enviar(cola->anillo,'l',workers,'f', nombres);
    esperar_respuesta(cola, lista, ((void *)0));
    free(nombres);
  }
}

canonical_original_code:
void operadorLSD(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  char *nombres;
  if((nombres = (char *) malloc(512 * sizeof (char))) == ((void *)0))
    printf("LSD: error\n");
  nombres = concatenar_archivos(lista);
  if(msj->dato != 'm') {
    strcat(nombres, msj->nombre);
    enviar(cola->anillo, 'l', msj->contador-1, 'f', nombres);
  }
  else {
    enviar(cola->anillo,'l',workers,'f', nombres);
    esperar_respuesta(cola, lista, ((void *)0));
    free(nombres);
  }
}

variable_types:
nombres
char *


operadorDEL

decompiled_code:
__int64 __fastcall operadorDEL(unsigned int *a1, __int64 a2, __int64 a3)
{
char v3; // al
__int64 v5; // rax
__int64 v6; // rdi
__int64 v7; // rcx
__int64 result; // rax
__int64 v9; // rax

v3 = *(_BYTE *)(a3 + 2);
if ( v3 == 102 )
{
v9 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v9 )
{
if ( *(_DWORD *)(v9 + 16) )
return enviar(a1[2], 100LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 101LL, *(_QWORD *)(a3 + 8));
eliminar_archivo(a2, *(_QWORD *)(a3 + 8));
return enviar(a1[2], 100LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 116LL, *(_QWORD *)(a3 + 8));
}
return reenvio_msj(a1[2], a3, 100LL);
}
if ( v3 != 109 )
return reenvio_msj(a1[2], a3, 100LL);
v5 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v5 )
{
if ( *(_DWORD *)(v5 + 16) )
{
v6 = a1[1];
v7 = 101LL;
}
else
{
eliminar_archivo(a2, *(_QWORD *)(a3 + 8));
v6 = a1[1];
v7 = 48LL;
}
result = enviar(v6, 100LL, 48LL, v7, 0LL);
}
else
{
enviar(a1[2], 100LL, 53LL, 102LL, *(_QWORD *)(a3 + 8));
result = esperar_respuesta(a1, a2, 0LL);
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func5(unsigned int *a1, __int64 a2, __int64 a3)
{
char v3; // al
__int64 v5; // rax
__int64 v6; // rdi
__int64 v7; // rcx
__int64 result; // rax
__int64 v9; // rax

v3 = *(_BYTE *)(a3 + 2);
if ( v3 == 102 )
{
v9 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v9 )
{
if ( *(_DWORD *)(v9 + 16) )
return enviar(a1[2], 100LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 101LL, *(_QWORD *)(a3 + 8));
eliminar_archivo(a2, *(_QWORD *)(a3 + 8));
return enviar(a1[2], 100LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 116LL, *(_QWORD *)(a3 + 8));
}
return reenvio_msj(a1[2], a3, 100LL);
}
if ( v3 != 109 )
return reenvio_msj(a1[2], a3, 100LL);
v5 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v5 )
{
if ( *(_DWORD *)(v5 + 16) )
{
v6 = a1[1];
v7 = 101LL;
}
else
{
eliminar_archivo(a2, *(_QWORD *)(a3 + 8));
v6 = a1[1];
v7 = 48LL;
}
result = enviar(v6, 100LL, 48LL, v7, 0LL);
}
else
{
enviar(a1[2], 100LL, 53LL, 102LL, *(_QWORD *)(a3 + 8));
result = func3(a1, a2, 0LL);
}
return result;
}

original_code:
void operadorDEL(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  Archivo *arch;
  switch(msj->dato) {
    case 'm':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(arch->estado == 0) {
          eliminar_archivo(lista, msj->nombre);
          enviar(cola->disp, 'd', '0', '0', ((void *)0));
        }
        else
          enviar(cola->disp, 'd', '0', 'e', ((void *)0));
      }
      else {
        enviar(cola->anillo,'d',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 'f':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(arch->estado == 0) {
          eliminar_archivo(lista,msj->nombre);
          enviar(cola->anillo, 'd', msj->contador-1, 't', msj->nombre);
        }
        else {
          enviar(cola->anillo, 'd', msj->contador-1, 'e', msj->nombre);
        }
      }
      else
        reenvio_msj(cola->anillo, msj, 'd');
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'd');
      break;
  }
}

canonical_original_code:
void operadorDEL(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  struct archivo_ *arch;
  switch(msj->dato) {
    case 'm':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(arch->estado == 0) {
          eliminar_archivo(lista, msj->nombre);
          enviar(cola->disp, 'd', '0', '0', ((void *)0));
        }
        else
          enviar(cola->disp, 'd', '0', 'e', ((void *)0));
      }
      else {
        enviar(cola->anillo,'d',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 'f':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(arch->estado == 0) {
          eliminar_archivo(lista,msj->nombre);
          enviar(cola->anillo, 'd', msj->contador-1, 't', msj->nombre);
        }
        else {
          enviar(cola->anillo, 'd', msj->contador-1, 'e', msj->nombre);
        }
      }
      else
        reenvio_msj(cola->anillo, msj, 'd');
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'd');
      break;
  }
}


operadorCRE

decompiled_code:
__int64 __fastcall operadorCRE(unsigned int *a1, __int64 a2, __int64 a3, const char *a4)
{
char v5; // al
__int64 v6; // rdi
const char *v7; // r8
__int64 v8; // rcx
__int64 v9; // rdx
const char *v12; // r14
int v13; // eax

v5 = *(_BYTE *)(a3 + 2);
if ( v5 == 102 )
{
if ( buscar_archivo(a2, *(_QWORD *)(a3 + 8)) )
{
if ( a4 )
{
v12 = *(const char **)(a3 + 8);
v13 = strcmp(a4, v12);
v6 = a1[2];
v7 = v12;
v8 = 101LL;
v9 = (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1);
if ( !v13 )
return enviar(v6, 99LL, v9, v8, v7);
}
else
{
v6 = a1[2];
v7 = *(const char **)(a3 + 8);
v9 = (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1);
}
v8 = 116LL;
return enviar(v6, 99LL, v9, v8, v7);
}
return reenvio_msj(a1[2], a3, 99LL);
}
if ( v5 != 109 )
return reenvio_msj(a1[2], a3, 99LL);
if ( buscar_archivo(a2, *(_QWORD *)(a3 + 8)) )
{
v6 = a1[1];
v7 = 0LL;
v8 = 49LL;
v9 = 48LL;
return enviar(v6, 99LL, v9, v8, v7);
}
enviar(a1[2], 99LL, 53LL, 102LL, *(_QWORD *)(a3 + 8));
return esperar_respuesta(a1, a2, *(_QWORD *)(a3 + 8));
}

original_code:
void operadorCRE(DescriptorColas *cola, ListaArchivos *lista, Msj *msj, char *candidato)
{
  switch(msj->dato) {
    case 'm':
      if(buscar_archivo(lista, msj->nombre) != ((void *)0)) {
        enviar(cola->disp, 'c', '0', '1', ((void *)0));
      }
      else {
        enviar(cola->anillo,'c',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, msj->nombre);
      }
      break;
    case 'f':
      if(buscar_archivo(lista, msj->nombre) != ((void *)0)) {
        if(candidato == ((void *)0))
          enviar(cola->anillo, 'c',msj->contador-1,'t',msj->nombre);
        else {
          if(strcmp(candidato, msj->nombre) == 0)
            enviar(cola->anillo,'c',msj->contador-1,'e',msj->nombre);
          else
            enviar(cola->anillo,'c',msj->contador-1,'t',msj->nombre);
        }
      }
      else {
        reenvio_msj(cola->anillo, msj, 'c');
      }
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'c');
      break;
  }
}

canonical_original_code:
void operadorCRE(struct colas *cola, struct lista_ *lista, struct msj_ *msj, char *candidato)
{
  switch(msj->dato) {
    case 'm':
      if(buscar_archivo(lista, msj->nombre) != ((void *)0)) {
        enviar(cola->disp, 'c', '0', '1', ((void *)0));
      }
      else {
        enviar(cola->anillo,'c',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, msj->nombre);
      }
      break;
    case 'f':
      if(buscar_archivo(lista, msj->nombre) != ((void *)0)) {
        if(candidato == ((void *)0))
          enviar(cola->anillo, 'c',msj->contador-1,'t',msj->nombre);
        else {
          if(strcmp(candidato, msj->nombre) == 0)
            enviar(cola->anillo,'c',msj->contador-1,'e',msj->nombre);
          else
            enviar(cola->anillo,'c',msj->contador-1,'t',msj->nombre);
        }
      }
      else {
        reenvio_msj(cola->anillo, msj, 'c');
      }
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'c');
      break;
  }
}


operadorOPN

decompiled_code:
__int64 __fastcall operadorOPN(unsigned int *a1, __int64 a2, __int64 a3)
{
char v4; // al
__int64 v6; // rdi
__int64 result; // rax
__int64 v8; // rdi
__int64 v9; // rcx

v4 = *(_BYTE *)(a3 + 2);
if ( v4 == 102 )
{
v8 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v8 )
{
if ( !(unsigned int)modificar_estado(v8) )
return enviar(a1[2], 111LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 101LL, *(_QWORD *)(a3 + 8));
v9 = (unsigned int)*(char *)(a2 + 12);
}
else
{
v9 = (unsigned int)*(char *)(a3 + 2);
}
return enviar(a1[2], 111LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), v9, *(_QWORD *)(a3 + 8));
}
if ( v4 != 109 )
return reenvio_msj(a1[2], a3, 111LL);
v6 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v6 )
{
if ( (unsigned int)modificar_estado(v6) )
result = enviar(a1[1], 111LL, (unsigned int)*(char *)(a2 + 12), 48LL, 0LL);
else
result = enviar(a1[1], 111LL, 48LL, 49LL, 0LL);
}
else
{
enviar(a1[2], 111LL, 53LL, 102LL, *(_QWORD *)(a3 + 8));
result = esperar_respuesta(a1, a2, 0LL);
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func7(unsigned int *a1, __int64 a2, __int64 a3)
{
char v4; // al
__int64 v6; // rdi
__int64 result; // rax
__int64 v8; // rdi
__int64 v9; // rcx

v4 = *(_BYTE *)(a3 + 2);
if ( v4 == 102 )
{
v8 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v8 )
{
if ( !(unsigned int)modificar_estado(v8) )
return enviar(a1[2], 111LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), 101LL, *(_QWORD *)(a3 + 8));
v9 = (unsigned int)*(char *)(a2 + 12);
}
else
{
v9 = (unsigned int)*(char *)(a3 + 2);
}
return enviar(a1[2], 111LL, (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1), v9, *(_QWORD *)(a3 + 8));
}
if ( v4 != 109 )
return reenvio_msj(a1[2], a3, 111LL);
v6 = buscar_archivo(a2, *(_QWORD *)(a3 + 8));
if ( v6 )
{
if ( (unsigned int)modificar_estado(v6) )
result = enviar(a1[1], 111LL, (unsigned int)*(char *)(a2 + 12), 48LL, 0LL);
else
result = enviar(a1[1], 111LL, 48LL, 49LL, 0LL);
}
else
{
enviar(a1[2], 111LL, 53LL, 102LL, *(_QWORD *)(a3 + 8));
result = func3(a1, a2, 0LL);
}
return result;
}

original_code:
void operadorOPN(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  Archivo *arch;
  switch(msj->dato) {
    case 'm':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(modificar_estado(arch))
          enviar(cola->disp, 'o', lista->worker, '0', ((void *)0));
        else
          enviar(cola->disp, 'o', '0', '1', ((void *)0));
      }
      else {
        enviar(cola->anillo,'o',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 'f':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(modificar_estado(arch))
          enviar(cola->anillo,'o',msj->contador-1,lista->worker,msj->nombre);
        else
          enviar(cola->anillo,'o',msj->contador-1,'e',msj->nombre);
      }
      else
        enviar(cola->anillo,'o',msj->contador-1,msj->dato,msj->nombre);
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'o');
      break;
  }
}

canonical_original_code:
void operadorOPN(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  struct archivo_ *arch;
  switch(msj->dato) {
    case 'm':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(modificar_estado(arch))
          enviar(cola->disp, 'o', lista->worker, '0', ((void *)0));
        else
          enviar(cola->disp, 'o', '0', '1', ((void *)0));
      }
      else {
        enviar(cola->anillo,'o',workers,'f',msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 'f':
      if((arch = buscar_archivo(lista, msj->nombre)) != ((void *)0)) {
        if(modificar_estado(arch))
          enviar(cola->anillo,'o',msj->contador-1,lista->worker,msj->nombre);
        else
          enviar(cola->anillo,'o',msj->contador-1,'e',msj->nombre);
      }
      else
        enviar(cola->anillo,'o',msj->contador-1,msj->dato,msj->nombre);
      break;
    default:
      reenvio_msj(cola->anillo, msj, 'o');
      break;
  }
}


operadorWRT

decompiled_code:
__int64 __fastcall operadorWRT(unsigned int *a1, __int64 a2, __int64 a3)
{
char v5; // al
char v6; // dl
__int64 v8; // rdi
__int64 v9; // rcx
__int64 v10; // rdx

v5 = *(_BYTE *)(a3 + 2);
v6 = *(_BYTE *)(a2 + 12);
if ( v5 == 109 )
{
if ( *(_BYTE *)(a3 + 1) != v6 )
{
enviarWR(
a1[2],
119LL,
53LL,
(unsigned int)*(char *)(a3 + 1),
*(unsigned int *)(a3 + 4),
*(_QWORD *)(a3 + 8),
*(_QWORD *)(a3 + 16));
return esperar_respuesta(a1, a2, 0LL);
}
escribir_archivo(a2, a3);
v8 = a1[1];
v9 = 48LL;
v10 = 48LL;
}
else
{
if ( v5 == 116 || v5 != v6 )
return reenvio_msj(a1[2], a3, 119LL);
escribir_archivo(a2, a3);
v8 = a1[2];
v9 = 116LL;
v10 = (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1);
}
return enviar(v8, 119LL, v10, v9, 0LL);
}

original_code:
void operadorWRT(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker) {
        escribir_archivo(lista, msj);
        enviar(cola->disp, 'w', '0', '0', ((void *)0));
      }
      else {
        enviarWR(cola->anillo,'w',workers,msj->contador, msj->otrodato, msj->nombre, msj->texto);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 'w');
      break;
    default:
      if(worker == msj->dato) {
        escribir_archivo(lista, msj);
        enviar(cola->anillo, 'w', msj->contador-1, 't', ((void *)0));
      }
      else
        reenvio_msj(cola->anillo, msj, 'w');
      break;
  }
}

canonical_original_code:
void operadorWRT(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker) {
        escribir_archivo(lista, msj);
        enviar(cola->disp, 'w', '0', '0', ((void *)0));
      }
      else {
        enviarWR(cola->anillo,'w',workers,msj->contador, msj->otrodato, msj->nombre, msj->texto);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 'w');
      break;
    default:
      if(worker == msj->dato) {
        escribir_archivo(lista, msj);
        enviar(cola->anillo, 'w', msj->contador-1, 't', ((void *)0));
      }
      else
        reenvio_msj(cola->anillo, msj, 'w');
      break;
  }
}

variable_types: worker char


operadorREA

decompiled_code:
__int64 __fastcall operadorREA(unsigned int *a1, __int64 a2, __int64 a3)
{
char v5; // al
char v6; // dl

v5 = *(_BYTE *)(a3 + 2);
v6 = *(_BYTE *)(a2 + 12);
if ( v5 != 109 )
{
if ( v5 == 116 || v5 != v6 )
return reenvio_msj(a1[2], a3, 114LL);
return leer_archivo((__int64)a1, a2, a3);
}
if ( *(_BYTE *)(a3 + 1) == v6 )
return leer_archivo((__int64)a1, a2, a3);
enviarWR(a1[2], 114LL, 53LL, (unsigned int)*(char *)(a3 + 1), *(unsigned int *)(a3 + 4), *(_QWORD *)(a3 + 8), 0LL);
return esperar_respuesta(a1, a2, 0LL);
}

original_code:
void operadorREA(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker)
        leer_archivo(cola, lista, msj);
      else {
        enviarWR(cola->anillo,'r',workers,msj->contador, msj->otrodato, msj->nombre, ((void *)0));
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 'r');
      break;
    default:
      if(msj->dato == worker)
        leer_archivo(cola, lista, msj);
      else
        reenvio_msj(cola->anillo, msj, 'r');
      break;
  }
}

canonical_original_code:
void operadorREA(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker)
        leer_archivo(cola, lista, msj);
      else {
        enviarWR(cola->anillo,'r',workers,msj->contador, msj->otrodato, msj->nombre, ((void *)0));
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 'r');
      break;
    default:
      if(msj->dato == worker)
        leer_archivo(cola, lista, msj);
      else
        reenvio_msj(cola->anillo, msj, 'r');
      break;
  }
}


operadorCLO

decompiled_code:
__int64 __fastcall operadorCLO(unsigned int *a1, __int64 a2, __int64 a3)
{
char v5; // al
char v6; // dl
__int64 v8; // rdi
__int64 v9; // rcx
__int64 v10; // rdx

v5 = *(_BYTE *)(a3 + 2);
v6 = *(_BYTE *)(a2 + 12);
if ( v5 == 109 )
{
if ( *(_BYTE *)(a3 + 1) != v6 )
{
enviar(a1[2], 115LL, 53LL, (unsigned int)*(char *)(a3 + 1), *(_QWORD *)(a3 + 8));
return esperar_respuesta(a1, a2, 0LL);
}
cerrar_archivo(a2, a3);
v8 = a1[1];
v9 = 48LL;
v10 = 48LL;
}
else
{
if ( v5 == 116 || v5 != v6 )
return reenvio_msj(a1[2], a3, 115LL);
cerrar_archivo(a2, a3);
v8 = a1[2];
v9 = 116LL;
v10 = (unsigned int)(char)(*(_BYTE *)(a3 + 1) - 1);
}
return enviar(v8, 115LL, v10, v9, 0LL);
}

original_code:
void operadorCLO(DescriptorColas *cola, ListaArchivos *lista, Msj *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker) {
        cerrar_archivo(lista, msj);
        enviar(cola->disp, 's', '0', '0', ((void *)0));
      }
      else {
        enviar(cola->anillo,'s',workers,msj->contador,msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 's');
      break;
    default:
      if(msj->dato == worker) {
        cerrar_archivo(lista, msj);
        enviar(cola->anillo,'s',msj->contador-1,'t',((void *)0));
      }
      else
        reenvio_msj(cola->anillo, msj, 's');
      break;
  }
}

canonical_original_code:
void operadorCLO(struct colas *cola, struct lista_ *lista, struct msj_ *msj)
{
  char worker = lista->worker;
  switch(msj->dato) {
    case 'm':
      if(msj->contador == worker) {
        cerrar_archivo(lista, msj);
        enviar(cola->disp, 's', '0', '0', ((void *)0));
      }
      else {
        enviar(cola->anillo,'s',workers,msj->contador,msj->nombre);
        esperar_respuesta(cola, lista, ((void *)0));
      }
      break;
    case 't':
      reenvio_msj(cola->anillo, msj, 's');
      break;
    default:
      if(msj->dato == worker) {
        cerrar_archivo(lista, msj);
        enviar(cola->anillo,'s',msj->contador-1,'t',((void *)0));
      }
      else
        reenvio_msj(cola->anillo, msj, 's');
      break;
  }
}


decompiled_code:
void __fastcall envio_por_anillo(unsigned int *a1, _BYTE *a2, __int64 a3, const char *a4)
{
switch ( *a2 )
{
case 'c':
operadorCRE(a1, a3, (__int64)a2, a4);
break;
case 'd':
operadorDEL(a1, a3, (__int64)a2);
break;
case 'l':
operadorLSD(a1, a3, (__int64)a2);
break;
case 'o':
operadorOPN(a1, a3, (__int64)a2);
break;
case 'r':
operadorREA(a1, a3, (__int64)a2);
break;
case 's':
operadorCLO(a1, a3, (__int64)a2);
break;
case 'w':
operadorWRT(a1, a3, (__int64)a2);
break;
default:
return;
}
}

canonical_decompiled_code:
void __fastcall func11(unsigned int *a1, _BYTE *a2, __int64 a3, const char *a4)
{
switch ( *a2 )
{
case 'c':
func6(a1, a3, (__int64)a2, a4);
break;
case 'd':
func5(a1, a3, (__int64)a2);
break;
case 'l':
func4(a1, a3, (__int64)a2);
break;
case 'o':
func7(a1, a3, (__int64)a2);
break;
case 'r':
func9(a1, a3, (__int64)a2);
break;
case 's':
func10(a1, a3, (__int64)a2);
break;
case 'w':
func8(a1, a3, (__int64)a2);
break;
default:
return;
}
}

original_code:
void envio_por_anillo(DescriptorColas *cola, Msj *msj, ListaArchivos *lista, char *candidato)
{
  switch(msj->tipo) {
    case 'l':
      operadorLSD(cola, lista, msj);
      break;
    case 'd':
      operadorDEL(cola, lista, msj);
      break;
    case 'c':
      operadorCRE(cola, lista, msj, candidato);
      break;
    case 'o':
      operadorOPN(cola, lista, msj);
      break;
    case 'w':
      operadorWRT(cola, lista, msj);
      break;
    case 'r':
      operadorREA(cola, lista, msj);
      break;
    case 's':
      operadorCLO(cola, lista, msj);
      break;
  }
}

canonical_original_code:
void envio_por_anillo(struct colas *cola, struct msj_ *msj, struct lista_ *lista, char *candidato)
{
  switch(msj->tipo) {
    case 'l':
      operadorLSD(cola, lista, msj);
      break;
    case 'd':
      operadorDEL(cola, lista, msj);
      break;
    case 'c':
      operadorCRE(cola, lista, msj, candidato);
      break;
    case 'o':
      operadorOPN(cola, lista, msj);
      break;
    case 'w':
      operadorWRT(cola, lista, msj);
      break;
    case 'r':
      operadorREA(cola, lista, msj);
      break;
    case 's':
      operadorCLO(cola, lista, msj);
      break;
  }
}


decompiled_code:
__int64 __fastcall evaluar_msj(unsigned int *a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 result; // rax
char v5; // al
char v6; // al
__int64 v7; // rdi
char v8; // al
__int64 v9; // rdi

if ( *(_BYTE *)(a2 + 1) == 49 )
{
switch ( *(_BYTE *)a2 )
{
case 'c':
v5 = *(_BYTE *)(a2 + 2);
switch ( v5 )
{
case 'f':
nuevo_archivo(a3, a4);
enviar(a1[1], 99LL, 48LL, 48LL, 0LL);
result = 1LL;
break;
case 't':
enviar(a1[1], 99LL, 48LL, 49LL, 0LL);
result = 1LL;
break;
case 'e':
enviar(a1[1], 99LL, 48LL, 50LL, 0LL);
result = 1LL;
break;
default:
goto LABEL_5;
}
break;
case 'd':
v6 = *(_BYTE *)(a2 + 2);
v7 = a1[1];
if ( v6 == 102 )
{
enviar(v7, 100LL, 48LL, 49LL, 0LL);
result = 1LL;
}
else
{
if ( v6 == 116 )
enviar(v7, 100LL, 48LL, 48LL, 0LL);
else
enviar(v7, 100LL, 48LL, 50LL, 0LL);
result = 1LL;
}
break;
case 'l':
enviar(a1[1], 108LL, 48LL, 102LL, *(_QWORD *)(a2 + 8));
result = 1LL;
break;
case 'o':
v8 = *(_BYTE *)(a2 + 2);
v9 = a1[1];
if ( v8 == 101 )
{
enviar(v9, 111LL, 48LL, 49LL, 0LL);
result = 1LL;
}
else
{
if ( v8 == 102 )
enviar(v9, 111LL, 48LL, 50LL, 0LL);
else
enviar(v9, 111LL, (unsigned int)v8, 48LL, 0LL);
result = 1LL;
}
break;
case 'r':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviarWR(a1[1], 114LL, 48LL, 48LL, *(unsigned int *)(a2 + 4), *(_QWORD *)(a2 + 8), 0LL);
result = 1LL;
}
break;
case 's':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviar(a1[1], 115LL, 48LL, 48LL, 0LL);
result = 1LL;
}
break;
case 'w':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviar(a1[1], 119LL, 48LL, 48LL, 0LL);
result = 1LL;
}
break;
default:
LABEL_5:
result = 1LL;
break;
}
}
else
{
envio_por_anillo(a1, (_BYTE *)a2, a3, 0LL);
liberar_msj(a2);
result = 0LL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func12(unsigned int *a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 result; // rax
char v5; // al
char v6; // al
__int64 v7; // rdi
char v8; // al
__int64 v9; // rdi

if ( *(_BYTE *)(a2 + 1) == 49 )
{
switch ( *(_BYTE *)a2 )
{
case 'c':
v5 = *(_BYTE *)(a2 + 2);
switch ( v5 )
{
case 'f':
nuevo_archivo(a3, a4);
enviar(a1[1], 99LL, 48LL, 48LL, 0LL);
result = 1LL;
break;
case 't':
enviar(a1[1], 99LL, 48LL, 49LL, 0LL);
result = 1LL;
break;
case 'e':
enviar(a1[1], 99LL, 48LL, 50LL, 0LL);
result = 1LL;
break;
default:
goto LABEL_5;
}
break;
case 'd':
v6 = *(_BYTE *)(a2 + 2);
v7 = a1[1];
if ( v6 == 102 )
{
enviar(v7, 100LL, 48LL, 49LL, 0LL);
result = 1LL;
}
else
{
if ( v6 == 116 )
enviar(v7, 100LL, 48LL, 48LL, 0LL);
else
enviar(v7, 100LL, 48LL, 50LL, 0LL);
result = 1LL;
}
break;
case 'l':
enviar(a1[1], 108LL, 48LL, 102LL, *(_QWORD *)(a2 + 8));
result = 1LL;
break;
case 'o':
v8 = *(_BYTE *)(a2 + 2);
v9 = a1[1];
if ( v8 == 101 )
{
enviar(v9, 111LL, 48LL, 49LL, 0LL);
result = 1LL;
}
else
{
if ( v8 == 102 )
enviar(v9, 111LL, 48LL, 50LL, 0LL);
else
enviar(v9, 111LL, (unsigned int)v8, 48LL, 0LL);
result = 1LL;
}
break;
case 'r':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviarWR(a1[1], 114LL, 48LL, 48LL, *(unsigned int *)(a2 + 4), *(_QWORD *)(a2 + 8), 0LL);
result = 1LL;
}
break;
case 's':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviar(a1[1], 115LL, 48LL, 48LL, 0LL);
result = 1LL;
}
break;
case 'w':
result = 1LL;
if ( *(_BYTE *)(a2 + 2) == 116 )
{
enviar(a1[1], 119LL, 48LL, 48LL, 0LL);
result = 1LL;
}
break;
default:
LABEL_5:
result = 1LL;
break;
}
}
else
{
func11(a1, (_BYTE *)a2, a3, 0LL);
liberar_msj(a2);
result = 0LL;
}
return result;
}

original_code:
int evaluar_msj(DescriptorColas *cola, Msj *msj, ListaArchivos *lista, char *candidato)
{
  if(msj->contador == '1') {
    switch(msj->tipo) {
      case 'l':
        enviar(cola->disp, 'l', '0', 'f', msj->nombre);
        break;
      case 'd':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'd', '0', '0', ((void *)0));
            break;
          case 'f':
            enviar(cola->disp, 'd', '0', '1', ((void *)0));
            break;
          default:
            enviar(cola->disp, 'd', '0', '2', ((void *)0));
            break;
        }
        break;
      case 'c':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'c', '0', '1', ((void *)0));
            break;
          case 'f':
            nuevo_archivo(lista, candidato);
            enviar(cola->disp, 'c', '0', '0', ((void *)0));
            break;
          case 'e':
            enviar(cola->disp, 'c', '0', '2', ((void *)0));
            break;
        }
        break;
      case 'o':
        switch(msj->dato) {
          case 'f':
            enviar(cola->disp, 'o', '0', '2', ((void *)0));
            break;
          case 'e':
            enviar(cola->disp, 'o', '0', '1', ((void *)0));
            break;
          default:
            enviar(cola->disp, 'o', msj->dato, '0', ((void *)0));
            break;
        }
        break;
      case 'w':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'w', '0', '0', ((void *)0));
            break;
        }
        break;
      case 'r':
        switch(msj->dato) {
          case 't':
            enviarWR(cola->disp, 'r', '0', '0', msj->otrodato, msj->nombre, ((void *)0));
            break;
        }
        break;
      case 's':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp,'s', '0', '0', ((void *)0));
            break;
        }
        break;
    }
    return 1;
  }
  envio_por_anillo(cola, msj, lista, ((void *)0));
  liberar_msj(msj);
  return 0;
}

canonical_original_code:
int evaluar_msj(struct colas *cola, struct msj_ *msj, struct lista_ *lista, char *candidato)
{
  if(msj->contador == '1') {
    switch(msj->tipo) {
      case 'l':
        enviar(cola->disp, 'l', '0', 'f', msj->nombre);
        break;
      case 'd':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'd', '0', '0', ((void *)0));
            break;
          case 'f':
            enviar(cola->disp, 'd', '0', '1', ((void *)0));
            break;
          default:
            enviar(cola->disp, 'd', '0', '2', ((void *)0));
            break;
        }
        break;
      case 'c':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'c', '0', '1', ((void *)0));
            break;
          case 'f':
            nuevo_archivo(lista, candidato);
            enviar(cola->disp, 'c', '0', '0', ((void *)0));
            break;
          case 'e':
            enviar(cola->disp, 'c', '0', '2', ((void *)0));
            break;
        }
        break;
      case 'o':
        switch(msj->dato) {
          case 'f':
            enviar(cola->disp, 'o', '0', '2', ((void *)0));
            break;
          case 'e':
            enviar(cola->disp, 'o', '0', '1', ((void *)0));
            break;
          default:
            enviar(cola->disp, 'o', msj->dato, '0', ((void *)0));
            break;
        }
        break;
      case 'w':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp, 'w', '0', '0', ((void *)0));
            break;
        }
        break;
      case 'r':
        switch(msj->dato) {
          case 't':
            enviarWR(cola->disp, 'r', '0', '0', msj->otrodato, msj->nombre, ((void *)0));
            break;
        }
        break;
      case 's':
        switch(msj->dato) {
          case 't':
            enviar(cola->disp,'s', '0', '0', ((void *)0));
            break;
        }
        break;
    }
    return 1;
  }
  envio_por_anillo(cola, msj, lista, ((void *)0));
  liberar_msj(msj);
  return 0;
}


decompiled_code:
ssize_t __fastcall responder_al_cliente(int fd, void *buf)
{
size_t v2; // rax

v2 = strlen((const char *)buf);
return write(fd, buf, v2);
}

canonical_decompiled_code:
ssize_t __fastcall func0(int fd, void *buf)
{
size_t v2; // rax

v2 = strlen((const char *)buf);
return write(fd, buf, v2);
}

original_code:
void responder_al_cliente(int conn_s, char mensaje[])
{
  write(conn_s, mensaje, strlen(mensaje));
}

variable_types:
mensaje
char []


decompiled_code:
__int64 eleccion_worker()
{
__int64 v0; // rax
int v1; // ebx
__int64 v2; // rdx
__int64 v3; // rcx
int v4; // er12
__int128 v6; // [rsp+0h] [rbp-38h]
int v7; // [rsp+10h] [rbp-28h]

v0 = 0LL;
v1 = 0;
v2 = bitmap_worker;
v7 = 0;
v6 = 0LL;
do
{
if ( !*(_BYTE *)(v2 + v0) )
{
v3 = v1++;
*((_DWORD *)&v6 + v3) = v0;
}
++v0;
}
while ( v0 != 5 );
if ( v1 )
{
v4 = *((_DWORD *)&v6 + rand() % v1);
pthread_mutex_lock(&m);
*(_BYTE *)(bitmap_worker + v4) = 1;
pthread_mutex_unlock(&m);
}
else
{
v4 = -1;
}
return (unsigned int)v4;
}

canonical_decompiled_code:
__int64 func1()
{
__int64 v0; // rax
int v1; // ebx
__int64 v2; // rdx
__int64 v3; // rcx
int v4; // er12
__int128 v6; // [rsp+0h] [rbp-38h]
int v7; // [rsp+10h] [rbp-28h]

v0 = 0LL;
v1 = 0;
v2 = bitmap_worker;
v7 = 0;
v6 = 0LL;
do
{
if ( !*(_BYTE *)(v2 + v0) )
{
v3 = v1++;
*((_DWORD *)&v6 + v3) = v0;
}
++v0;
}
while ( v0 != 5 );
if ( v1 )
{
v4 = *((_DWORD *)&v6 + rand() % v1);
pthread_mutex_lock(&m);
*(_BYTE *)(bitmap_worker + v4) = 1;
pthread_mutex_unlock(&m);
}
else
{
v4 = -1;
}
return (unsigned int)v4;
}

original_code:
int eleccion_worker()
{
  int i,j,n;
  int aux[5] = {0};
  for(i=0,j=0;i<5;i++) {
    if(bitmap_worker[i]== 0) {
      aux[j] = i;
      j++;
    }
  }
  if(j==0)
    return -1;
  i = rand() % j;
  n = aux[i];
  pthread_mutex_lock(&m);
  bitmap_worker[n] = 1;
  pthread_mutex_unlock(&m);
  return n;
}

canonical_original_code:
int eleccion_worker()
{
  int i; int j; int n;
  int aux[5] = {0};
  for(i=0,j=0;i<5;i++) {
    if(bitmap_worker[i]== 0) {
      aux[j] = i;
      j++;
    }
  }
  if(j==0)
    return -1;
  i = rand() % j;
  n = aux[i];
  pthread_mutex_lock(&m);
  bitmap_worker[n] = 1;
  pthread_mutex_unlock(&m);
  return n;
}

variable_types: i int

variable_types: j int

variable_types: n int

variable_types:
aux
int [5]


decompiled_code:
__int64 __fastcall PS_operadorLSD(unsigned int *a1, int a2)
{
__int64 v2; // rbp
size_t v3; // rax
char dest[536]; // [rsp+0h] [rbp-218h] BYREF

enviar(*a1, 108LL, 48LL, 109LL, 0LL);
v2 = recibir(a1[1]);
strcpy(dest, "OK");
v3 = strlen(dest);
*(_WORD *)stpcpy(&dest[v3], *(const char **)(v2 + 8)) = 10;
responder_al_cliente(a2, dest);
return liberar_msj(v2);
}

canonical_decompiled_code:
__int64 __fastcall func2(unsigned int *a1, int a2)
{
__int64 v2; // rbp
size_t v3; // rax
char dest[536]; // [rsp+0h] [rbp-218h] BYREF

enviar(*a1, 108LL, 48LL, 109LL, 0LL);
v2 = recibir(a1[1]);
strcpy(dest, "OK");
v3 = strlen(dest);
*(_WORD *)stpcpy(&dest[v3], *(const char **)(v2 + 8)) = 10;
func0(a2, dest);
return liberar_msj(v2);
}

original_code:
void PS_operadorLSD(DescriptorColas *cola, long conn_s)
{
  char buffer[512];
  Msj *msj;
  enviar(cola->worker,'l','0','m',((void *)0));
  msj = recibir(cola->disp);
  sprintf(buffer,"OK");
  strcat(buffer,msj->nombre);
  strcat(buffer,"\n");
  responder_al_cliente(conn_s, buffer);
  liberar_msj(msj);
}

canonical_original_code:
void PS_operadorLSD(struct colas *cola, long conn_s)
{
  char buffer[512];
  struct msj_ *msj;
  enviar(cola->worker,'l','0','m',((void *)0));
  msj = recibir(cola->disp);
  sprintf(buffer,"OK");
  strcat(buffer,msj->nombre);
  strcat(buffer,"\n");
  responder_al_cliente(conn_s, buffer);
  liberar_msj(msj);
}

variable_types:
buffer
char [512]


decompiled_code:
__int64 __fastcall PS_operadorDEL(unsigned int *a1, int a2)
{
char *v2; // rax
char *v3; // rbx
__int64 v5; // rbp
char v6; // al
char delim[2]; // [rsp+Eh] [rbp-1Ah] BYREF

strcpy(delim, " ");
v2 = strtok(0LL, delim);
if ( !v2 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v3 = v2;
if ( *v2 == 13 && v2[1] == 10 && !v2[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
enviar(*a1, 100LL, 48LL, 109LL, v3);
v5 = recibir(a1[1]);
v6 = *(_BYTE *)(v5 + 2);
if ( v6 == 48 )
{
responder_al_cliente(a2, &unk_DC8);
}
else if ( v6 == 49 )
{
responder_al_cliente(a2, "ERROR EL ARCHIVO NO EXISTE\n");
}
else
{
responder_al_cliente(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
}
return liberar_msj(v5);
}

canonical_decompiled_code:
__int64 __fastcall func3(unsigned int *a1, int a2)
{
char *v2; // rax
char *v3; // rbx
__int64 v5; // rbp
char v6; // al
char delim[2]; // [rsp+Eh] [rbp-1Ah] BYREF

strcpy(delim, " ");
v2 = strtok(0LL, delim);
if ( !v2 )
return func0(a2, "ERROR DE SINTAXIS\n");
v3 = v2;
if ( *v2 == 13 && v2[1] == 10 && !v2[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return func0(a2, "ERROR DE SINTAXIS\n");
enviar(*a1, 100LL, 48LL, 109LL, v3);
v5 = recibir(a1[1]);
v6 = *(_BYTE *)(v5 + 2);
if ( v6 == 48 )
{
func0(a2, &unk_DC8);
}
else if ( v6 == 49 )
{
func0(a2, "ERROR EL ARCHIVO NO EXISTE\n");
}
else
{
func0(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
}
return liberar_msj(v5);
}

original_code:
void PS_operadorDEL(DescriptorColas *cola, long conn_s)
{
  char *token;
  char delims[] = " ";
  Msj *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)
      && (strtok(((void *)0), delims) == ((void *)0))) {
    enviar(cola->worker,'d','0','m',token);
    msj = recibir(cola->disp);
    switch(msj->dato) {
      case '0':
        responder_al_cliente(conn_s, "OK\n");
        break;
      case '1':
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO NO EXISTE\n");
        break;
      default:
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
        break;
    }
    liberar_msj(msj);
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

canonical_original_code:
void PS_operadorDEL(struct colas *cola, long conn_s)
{
  char *token;
  char delims[] = " ";
  struct msj_ *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)
      && (strtok(((void *)0), delims) == ((void *)0))) {
    enviar(cola->worker,'d','0','m',token);
    msj = recibir(cola->disp);
    switch(msj->dato) {
      case '0':
        responder_al_cliente(conn_s, "OK\n");
        break;
      case '1':
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO NO EXISTE\n");
        break;
      default:
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
        break;
    }
    liberar_msj(msj);
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

variable_types:
token
char *

variable_types:
delims
char []


decompiled_code:
__int64 __fastcall PS_operadorCRE(unsigned int *a1, int a2)
{
char *v2; // rax
char *v3; // rbx
__int64 v5; // rbp
char v6; // al
char delim[2]; // [rsp+Eh] [rbp-1Ah] BYREF

strcpy(delim, " ");
v2 = strtok(0LL, delim);
if ( !v2 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v3 = v2;
if ( *v2 == 13 && v2[1] == 10 && !v2[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
enviar(*a1, 99LL, 48LL, 109LL, v3);
v5 = recibir(a1[1]);
v6 = *(_BYTE *)(v5 + 2);
switch ( v6 )
{
case '1':
responder_al_cliente(a2, "ERROR EL ARCHIVO YA EXISTE\n");
break;
case '2':
responder_al_cliente(a2, "ERROR INTENTE DE NUEVO\n");
break;
case '0':
responder_al_cliente(a2, &unk_DC8);
break;
}
return liberar_msj(v5);
}

canonical_decompiled_code:
__int64 __fastcall func4(unsigned int *a1, int a2)
{
char *v2; // rax
char *v3; // rbx
__int64 v5; // rbp
char v6; // al
char delim[2]; // [rsp+Eh] [rbp-1Ah] BYREF

strcpy(delim, " ");
v2 = strtok(0LL, delim);
if ( !v2 )
return func0(a2, "ERROR DE SINTAXIS\n");
v3 = v2;
if ( *v2 == 13 && v2[1] == 10 && !v2[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return func0(a2, "ERROR DE SINTAXIS\n");
enviar(*a1, 99LL, 48LL, 109LL, v3);
v5 = recibir(a1[1]);
v6 = *(_BYTE *)(v5 + 2);
switch ( v6 )
{
case '1':
func0(a2, "ERROR EL ARCHIVO YA EXISTE\n");
break;
case '2':
func0(a2, "ERROR INTENTE DE NUEVO\n");
break;
case '0':
func0(a2, &unk_DC8);
break;
}
return liberar_msj(v5);
}

original_code:
void PS_operadorCRE(DescriptorColas *cola, long conn_s)
{
  char *token;
  char delims[] = " ";
  Msj *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)
      && (strtok(((void *)0), delims) == ((void *)0))) {
    enviar(cola->worker,'c','0','m',token);
    msj = recibir(cola->disp);
    switch(msj->dato) {
      case '0':
        responder_al_cliente(conn_s, "OK\n");
        break;
      case '1':
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO YA EXISTE\n");
        break;
      case '2':
        responder_al_cliente(conn_s, "ERROR INTENTE DE NUEVO\n");
        break;
    }
    liberar_msj(msj);
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

canonical_original_code:
void PS_operadorCRE(struct colas *cola, long conn_s)
{
  char *token;
  char delims[] = " ";
  struct msj_ *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)
      && (strtok(((void *)0), delims) == ((void *)0))) {
    enviar(cola->worker,'c','0','m',token);
    msj = recibir(cola->disp);
    switch(msj->dato) {
      case '0':
        responder_al_cliente(conn_s, "OK\n");
        break;
      case '1':
        responder_al_cliente(conn_s, "ERROR EL ARCHIVO YA EXISTE\n");
        break;
      case '2':
        responder_al_cliente(conn_s, "ERROR INTENTE DE NUEVO\n");
        break;
    }
    liberar_msj(msj);
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

variable_types: struct colas { int worker; int disp; int anillo; } *


decompiled_code:
__int64 __fastcall PS_operadorOPN(unsigned int *a1, int a2, unsigned int a3)
{
char *v4; // rax
char *v5; // rbp
__int64 v7; // r14
char v8; // al
unsigned int v9; // eax
char delim[2]; // [rsp+4h] [rbp-34h] BYREF
char s[50]; // [rsp+6h] [rbp-32h] BYREF

strcpy(delim, " ");
v4 = strtok(0LL, delim);
if ( !v4 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v5 = v4;
if ( *v4 == 13 && v4[1] == 10 && !v4[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( buscar_descriptor(descriptores, v5, 0LL, 0LL) )
return responder_al_cliente(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
enviar(*a1, 111LL, 48LL, 109LL, v5);
v7 = recibir(a1[1]);
v8 = *(_BYTE *)(v7 + 2);
switch ( v8 )
{
case '1':
responder_al_cliente(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
break;
case '2':
responder_al_cliente(a2, "ERROR EL ARCHIVO NO EXISTE\n");
break;
case '0':
v9 = nuevo_descriptor(descriptores, v5, (unsigned int)(*(char *)(v7 + 1) - 48), a3);
sprintf(s, "OK FD %d\n", v9);
responder_al_cliente(a2, s);
break;
}
return liberar_msj(v7);
}

canonical_decompiled_code:
__int64 __fastcall func5(unsigned int *a1, int a2, unsigned int a3)
{
char *v4; // rax
char *v5; // rbp
__int64 v7; // r14
char v8; // al
unsigned int v9; // eax
char delim[2]; // [rsp+4h] [rbp-34h] BYREF
char s[50]; // [rsp+6h] [rbp-32h] BYREF

strcpy(delim, " ");
v4 = strtok(0LL, delim);
if ( !v4 )
return func0(a2, "ERROR DE SINTAXIS\n");
v5 = v4;
if ( *v4 == 13 && v4[1] == 10 && !v4[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( buscar_descriptor(descriptores, v5, 0LL, 0LL) )
return func0(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
enviar(*a1, 111LL, 48LL, 109LL, v5);
v7 = recibir(a1[1]);
v8 = *(_BYTE *)(v7 + 2);
switch ( v8 )
{
case '1':
func0(a2, "ERROR EL ARCHIVO ESTA ABIERTO\n");
break;
case '2':
func0(a2, "ERROR EL ARCHIVO NO EXISTE\n");
break;
case '0':
v9 = nuevo_descriptor(descriptores, v5, (unsigned int)(*(char *)(v7 + 1) - 48), a3);
sprintf(s, "OK FD %d\n", v9);
func0(a2, s);
break;
}
return liberar_msj(v7);
}

original_code:
void PS_operadorOPN(DescriptorColas *cola, long conn_s, int worker)
{
  char *token;
  char delims[] = " ";
  char buffer[10];
  Msj *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0) && (strtok(((void *)0), delims) == ((void *)0))) {
    if (buscar_descriptor(descriptores, token, 0, 0) != ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
    }
    else {
      enviar(cola->worker,'o','0','m',token);
      msj = recibir(cola->disp);
      switch(msj->dato) {
        case '0':
          sprintf(buffer,"OK FD %d\n", nuevo_descriptor(descriptores, token, msj->contador - '0', worker));
          responder_al_cliente(conn_s, buffer);
          break;
        case '1':
          responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
          break;
        case '2':
          responder_al_cliente(conn_s, "ERROR EL ARCHIVO NO EXISTE\n");
          break;
      }
      liberar_msj(msj);
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

canonical_original_code:
void PS_operadorOPN(struct colas *cola, long conn_s, int worker)
{
  char *token;
  char delims[] = " ";
  char buffer[10];
  struct msj_ *msj;
  if (((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0) && (strtok(((void *)0), delims) == ((void *)0))) {
    if (buscar_descriptor(descriptores, token, 0, 0) != ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
    }
    else {
      enviar(cola->worker,'o','0','m',token);
      msj = recibir(cola->disp);
      switch(msj->dato) {
        case '0':
          sprintf(buffer,"OK FD %d\n", nuevo_descriptor(descriptores, token, msj->contador - '0', worker));
          responder_al_cliente(conn_s, buffer);
          break;
        case '1':
          responder_al_cliente(conn_s, "ERROR EL ARCHIVO ESTA ABIERTO\n");
          break;
        case '2':
          responder_al_cliente(conn_s, "ERROR EL ARCHIVO NO EXISTE\n");
          break;
      }
      liberar_msj(msj);
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

variable_types: worker int

variable_types:
buffer
char [10]


decompiled_code:
__int64 __fastcall iniciar_conexion(const char *a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // er12
char v5[40]; // [rsp+0h] [rbp-28h] BYREF

strcpy(v5, "CON\r\n");
if ( strcmp(a1, v5) )
return (unsigned int)-1;
v2 = eleccion_worker();
v3 = v2;
if ( v2 == -1 )
{
responder_al_cliente(a2, "ERROR SERVIDOR SATURADO\n");
}
else
{
sprintf(&v5[6], "OK ID %d\n", v2);
responder_al_cliente(a2, &v5[6]);
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func6(const char *a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // er12
char v5[40]; // [rsp+0h] [rbp-28h] BYREF

strcpy(v5, "CON\r\n");
if ( strcmp(a1, v5) )
return (unsigned int)-1;
v2 = func1();
v3 = v2;
if ( v2 == -1 )
{
func0(a2, "ERROR SERVIDOR SATURADO\n");
}
else
{
sprintf(&v5[6], "OK ID %d\n", v2);
func0(a2, &v5[6]);
}
return v3;
}

original_code:
int iniciar_conexion(char *a, long conn_s)
{
  char con[6] = "CON\r\n";
  char buffer[10];
  int i;
  if(strcmp (a, con) == 0) {
    i = eleccion_worker();
    if(i == -1) {
      responder_al_cliente(conn_s, "ERROR SERVIDOR SATURADO\n");
    }
    else {
      sprintf(buffer,"OK ID %d\n", i);
      responder_al_cliente(conn_s, buffer);
      return i;
    }
  }
  return -1;
}

variable_types:
a
char *

variable_types:
con
char [6]


decompiled_code:
unsigned __int64 __fastcall string_to_integer(char *nptr)
{
int *v1; // rax
int *v2; // rbp
unsigned __int64 result; // rax
char *endptr; // [rsp+8h] [rbp-20h] BYREF

endptr = nptr;
v1 = _errno_location();
*v1 = 0;
v2 = v1;
result = strtoul(nptr, &endptr, 10);
if ( *v2 || endptr == nptr )
return 0xFFFFFFFFLL;
if ( *endptr )
result = 0xFFFFFFFFLL;
return result;
}

canonical_decompiled_code:
unsigned __int64 __fastcall func7(char *nptr)
{
int *v1; // rax
int *v2; // rbp
unsigned __int64 result; // rax
char *endptr; // [rsp+8h] [rbp-20h] BYREF

endptr = nptr;
v1 = _errno_location();
*v1 = 0;
v2 = v1;
result = strtoul(nptr, &endptr, 10);
if ( *v2 || endptr == nptr )
return 0xFFFFFFFFLL;
if ( *endptr )
result = 0xFFFFFFFFLL;
return result;
}

original_code:
int string_to_integer(char *s)
{
    char* p = s;
    (*__errno_location ()) = 0;
    unsigned int val;
    val = strtoul(s, &p, 10);
    if ((*__errno_location ()) != 0 || s == p || *p != 0)
      return -1;
    return val;
}

canonical_original_code:
int string_to_integer(char *s)
{
    char *p = s;
    (*__errno_location ()) = 0;
    unsigned int val;
    val = strtoul(s, &p, 10);
    if ((*__errno_location ()) != 0 || s == p || *p != 0)
      return -1;
    return val;
}

variable_types:
s
char *

variable_types:
p
char *

variable_types:
val
unsigned int


decompiled_code:
__int64 __fastcall integer_to_char(int a1)
{
return (unsigned int)(a1 + 48);
}

canonical_decompiled_code:
__int64 __fastcall func8(int a1)
{
return (unsigned int)(a1 + 48);
}

original_code:
char integer_to_char(int n)
{
  return (char) (((int)'0') + n);
}

return_type: char


decompiled_code:
ssize_t __fastcall PS_operadorWRT(unsigned int *a1, int a2, int a3)
{
char *v5; // rax
char *v7; // rax
int v8; // er13
char *v9; // rsi
int v10; // er14
char *v11; // r15
__int64 v12; // rax
__int64 v13; // r13
char *v14; // rax
const char *v15; // rbp
char v16; // al
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // rbp
__int64 v20; // [rsp-10h] [rbp-68h]
char *v21; // [rsp+8h] [rbp-50h]
char delim[2]; // [rsp+1Eh] [rbp-3Ah] BYREF

strcpy(delim, " ");
v5 = strtok(0LL, delim);
if ( !v5 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( *v5 != 70 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v5[1] != 68 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v5[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v7 = strtok(0LL, delim);
v8 = string_to_integer(v7);
v9 = strtok(0LL, delim);
if ( !v9 || strcmp(v9, "SIZE") )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v21 = strtok(0LL, delim);
v10 = string_to_integer(v21);
v11 = strtok(0LL, delim);
if ( v11 )
{
if ( v10 > 0 && v8 > 0 )
{
v12 = buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL);
v13 = v12;
if ( !v12 || *(_DWORD *)(v12 + 12) != a3 )
return responder_al_cliente(a2, "ERROR FD INCORRECTO\n");
v15 = (const char *)cola_cadena(v11);
if ( strlen(v15) != v10 )
return responder_al_cliente(a2, &unk_E76);
v16 = integer_to_char(*(_DWORD *)(v13 + 8));
enviarWR(*a1, 119LL, (unsigned int)v16, v17, v18, *(_QWORD *)v13, v15);
v19 = recibir(a1[1]);
responder_al_cliente(a2, &unk_DC8);
liberar_msj(v19);
return v20;
}
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
}
v14 = (char *)sacar_nueva_linea(v21);
if ( (unsigned int)string_to_integer(v14) || v8 <= 0 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( !buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL) )
return responder_al_cliente(a2, "ERROR FD INCORRECTO\n");
return responder_al_cliente(a2, &unk_DC8);
}

canonical_decompiled_code:
ssize_t __fastcall func9(unsigned int *a1, int a2, int a3)
{
char *v5; // rax
char *v7; // rax
int v8; // er13
char *v9; // rsi
int v10; // er14
char *v11; // r15
__int64 v12; // rax
__int64 v13; // r13
char *v14; // rax
const char *v15; // rbp
char v16; // al
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // rbp
__int64 v20; // [rsp-10h] [rbp-68h]
char *v21; // [rsp+8h] [rbp-50h]
char delim[2]; // [rsp+1Eh] [rbp-3Ah] BYREF

strcpy(delim, " ");
v5 = strtok(0LL, delim);
if ( !v5 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( *v5 != 70 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v5[1] != 68 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v5[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
v7 = strtok(0LL, delim);
v8 = func7(v7);
v9 = strtok(0LL, delim);
if ( !v9 || strcmp(v9, "SIZE") )
return func0(a2, "ERROR DE SINTAXIS\n");
v21 = strtok(0LL, delim);
v10 = func7(v21);
v11 = strtok(0LL, delim);
if ( v11 )
{
if ( v10 > 0 && v8 > 0 )
{
v12 = buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL);
v13 = v12;
if ( !v12 || *(_DWORD *)(v12 + 12) != a3 )
return func0(a2, "ERROR FD INCORRECTO\n");
v15 = (const char *)cola_cadena(v11);
if ( strlen(v15) != v10 )
return func0(a2, &unk_E76);
v16 = func8(*(_DWORD *)(v13 + 8));
enviarWR(*a1, 119LL, (unsigned int)v16, v17, v18, *(_QWORD *)v13, v15);
v19 = recibir(a1[1]);
func0(a2, &unk_DC8);
liberar_msj(v19);
return v20;
}
return func0(a2, "ERROR DE SINTAXIS\n");
}
v14 = (char *)sacar_nueva_linea(v21);
if ( (unsigned int)func7(v14) || v8 <= 0 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( !buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL) )
return func0(a2, "ERROR FD INCORRECTO\n");
return func0(a2, &unk_DC8);
}

original_code:
void PS_operadorWRT(DescriptorColas *cola, long conn_s, int worker)
{
  int i = 0, fd, size;
  char *token, *size_token;
  char delims[] = " ";
  DescriptorArchivo *archivo;
  Msj *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0)) {
    fd = string_to_integer(strtok(((void *)0), delims));
    if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "SIZE") == 0)) {
      size_token = strtok(((void *)0), delims);
      size = string_to_integer(size_token);
      if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (fd > 0) && (size > 0))
        i = 1;
      if((token == ((void *)0)) && (string_to_integer(sacar_nueva_linea(size_token)) == 0) && (fd > 0))
        i = 2;
    }
  }
  switch(i) {
    case 1:
      if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
      else {
        if(archivo->worker_a == worker) {
          token = cola_cadena(token);
          if(strlen(token) == size) {
            enviarWR(cola->worker,'w',integer_to_char(archivo->worker_c),'m',size,archivo->nombre,token);
            msj = recibir(cola->disp);
            responder_al_cliente(conn_s, "OK\n");
            liberar_msj(msj);
          }
          else {
            responder_al_cliente(conn_s, "ERROR TAMAÑO INCORRECTO\n");
          }
        }
        else {
          responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
        }
      }
      break;
    case 2:
      if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
      else {
        responder_al_cliente(conn_s, "OK\n");
      }
      break;
    case 0:
      responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
      break;
  }
}

canonical_original_code:
void PS_operadorWRT(struct colas *cola, long conn_s, int worker)
{
  int i = 0; int fd; int size;
  char *token; char *size_token;
  char delims[] = " ";
  struct des_ *archivo;
  struct msj_ *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0)) {
    fd = string_to_integer(strtok(((void *)0), delims));
    if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "SIZE") == 0)) {
      size_token = strtok(((void *)0), delims);
      size = string_to_integer(size_token);
      if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (fd > 0) && (size > 0))
        i = 1;
      if((token == ((void *)0)) && (string_to_integer(sacar_nueva_linea(size_token)) == 0) && (fd > 0))
        i = 2;
    }
  }
  switch(i) {
    case 1:
      if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
      else {
        if(archivo->worker_a == worker) {
          token = cola_cadena(token);
          if(strlen(token) == size) {
            enviarWR(cola->worker,'w',integer_to_char(archivo->worker_c),'m',size,archivo->nombre,token);
            msj = recibir(cola->disp);
            responder_al_cliente(conn_s, "OK\n");
            liberar_msj(msj);
          }
          else {
            responder_al_cliente(conn_s, "ERROR TAMAÑO INCORRECTO\n");
          }
        }
        else {
          responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
        }
      }
      break;
    case 2:
      if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
      else {
        responder_al_cliente(conn_s, "OK\n");
      }
      break;
    case 0:
      responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
      break;
  }
}

variable_types: fd int

variable_types: size int

variable_types: struct des_ { char *nombre; int worker_c; int worker_a; int fd; struct des_ *proximo; } *

variable_types: struct msj_ { char tipo; char contador; char dato; int otrodato; char *nombre; char *texto; } *


decompiled_code:
__int64 __fastcall PS_operadorREA(unsigned int *a1, int a2, int a3)
{
char *v5; // rax
char *v7; // rax
int v8; // er14
char *v9; // rsi
char *v10; // rax
char *v11; // rax
int v12; // er13
__int64 v13; // rax
char v14; // al
_QWORD *v15; // rdx
__int64 v16; // rcx
__int64 v17; // r8
__int64 v18; // rax
const char *v19; // rcx
__int64 v20; // rbp
char delim[2]; // [rsp+Eh] [rbp-22Ah] BYREF
char s[552]; // [rsp+10h] [rbp-228h] BYREF

strcpy(delim, " ");
v5 = strtok(0LL, delim);
if ( !v5 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( *v5 != 70 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v5[1] != 68 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v5[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v7 = strtok(0LL, delim);
v8 = string_to_integer(v7);
v9 = strtok(0LL, delim);
if ( !v9 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( strcmp(v9, "SIZE") )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v10 = strtok(0LL, delim);
v11 = (char *)sacar_nueva_linea(v10);
v12 = string_to_integer(v11);
if ( strtok(0LL, delim) || v8 <= 0 || v12 < 0 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v13 = buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL);
if ( !v13 || *(_DWORD *)(v13 + 12) != a3 )
return responder_al_cliente(a2, "ERROR FD INCORRECTO\n");
v14 = integer_to_char(*(_DWORD *)(v13 + 8));
enviarWR(*a1, 114LL, (unsigned int)v14, v16, v17, *v15, 0LL);
v18 = recibir(a1[1]);
v19 = *(const char **)(v18 + 8);
v20 = v18;
if ( v19 )
{
sprintf(s, "OK SIZE %d %s\n", *(unsigned int *)(v18 + 4), v19);
responder_al_cliente(a2, s);
}
else
{
responder_al_cliente(a2, "OK SIZE 0\n");
}
return liberar_msj(v20);
}

canonical_decompiled_code:
__int64 __fastcall func10(unsigned int *a1, int a2, int a3)
{
char *v5; // rax
char *v7; // rax
int v8; // er14
char *v9; // rsi
char *v10; // rax
char *v11; // rax
int v12; // er13
__int64 v13; // rax
char v14; // al
_QWORD *v15; // rdx
__int64 v16; // rcx
__int64 v17; // r8
__int64 v18; // rax
const char *v19; // rcx
__int64 v20; // rbp
char delim[2]; // [rsp+Eh] [rbp-22Ah] BYREF
char s[552]; // [rsp+10h] [rbp-228h] BYREF

strcpy(delim, " ");
v5 = strtok(0LL, delim);
if ( !v5 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( *v5 != 70 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v5[1] != 68 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v5[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
v7 = strtok(0LL, delim);
v8 = func7(v7);
v9 = strtok(0LL, delim);
if ( !v9 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( strcmp(v9, "SIZE") )
return func0(a2, "ERROR DE SINTAXIS\n");
v10 = strtok(0LL, delim);
v11 = (char *)sacar_nueva_linea(v10);
v12 = func7(v11);
if ( strtok(0LL, delim) || v8 <= 0 || v12 < 0 )
return func0(a2, "ERROR DE SINTAXIS\n");
v13 = buscar_descriptor(descriptores, 0LL, (unsigned int)v8, 1LL);
if ( !v13 || *(_DWORD *)(v13 + 12) != a3 )
return func0(a2, "ERROR FD INCORRECTO\n");
v14 = func8(*(_DWORD *)(v13 + 8));
enviarWR(*a1, 114LL, (unsigned int)v14, v16, v17, *v15, 0LL);
v18 = recibir(a1[1]);
v19 = *(const char **)(v18 + 8);
v20 = v18;
if ( v19 )
{
sprintf(s, "OK SIZE %d %s\n", *(unsigned int *)(v18 + 4), v19);
func0(a2, s);
}
else
{
func0(a2, "OK SIZE 0\n");
}
return liberar_msj(v20);
}

original_code:
void PS_operadorREA(DescriptorColas *cola, long conn_s, int worker)
{
  int i = 0, fd, size;
  char *token;
  char buffer[512], delims[] = " ";
  DescriptorArchivo *archivo;
  Msj *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0)) {
    fd = string_to_integer(strtok(((void *)0), delims));
    if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "SIZE") == 0)) {
      size = string_to_integer(sacar_nueva_linea(strtok(((void *)0), delims)));
      if(((strtok(((void *)0), delims)) == ((void *)0)) && (fd > 0) && (size >= 0))
        i = 1;
    }
  }
  if(i) {
    if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
    }
    else {
      if(archivo->worker_a == worker) {
        enviarWR(cola->worker,'r',integer_to_char(archivo->worker_c),'m', size, archivo->nombre, ((void *)0));
        msj = recibir(cola->disp);
        if(msj->nombre == ((void *)0)) {
          responder_al_cliente(conn_s, "OK SIZE 0\n");
        }
        else {
          sprintf(buffer,"OK SIZE %d %s\n",msj->otrodato, msj->nombre);
          responder_al_cliente(conn_s, buffer);
        }
        liberar_msj(msj);
      }
      else {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

canonical_original_code:
void PS_operadorREA(struct colas *cola, long conn_s, int worker)
{
  int i = 0; int fd; int size;
  char *token;
  char buffer[512]; char delims[] = " ";
  struct des_ *archivo;
  struct msj_ *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0)) {
    fd = string_to_integer(strtok(((void *)0), delims));
    if(((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "SIZE") == 0)) {
      size = string_to_integer(sacar_nueva_linea(strtok(((void *)0), delims)));
      if(((strtok(((void *)0), delims)) == ((void *)0)) && (fd > 0) && (size >= 0))
        i = 1;
    }
  }
  if(i) {
    if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
    }
    else {
      if(archivo->worker_a == worker) {
        enviarWR(cola->worker,'r',integer_to_char(archivo->worker_c),'m', size, archivo->nombre, ((void *)0));
        msj = recibir(cola->disp);
        if(msj->nombre == ((void *)0)) {
          responder_al_cliente(conn_s, "OK SIZE 0\n");
        }
        else {
          sprintf(buffer,"OK SIZE %d %s\n",msj->otrodato, msj->nombre);
          responder_al_cliente(conn_s, buffer);
        }
        liberar_msj(msj);
      }
      else {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

variable_types: i int

user_defined_types: struct des_ { char *nombre; int worker_c; int worker_a; int fd; struct des_ *proximo; }


decompiled_code:
__int64 __fastcall PS_operadorCLO(unsigned int *a1, int a2, int a3)
{
char *v4; // rax
char *v6; // rax
char *v7; // r13
char *v8; // rax
int v9; // eax
__int64 v10; // rax
_QWORD *v11; // r13
char v12; // al
__int64 v13; // rcx
__int64 v14; // rbp
char delim[2]; // [rsp+Eh] [rbp-2Ah] BYREF

strcpy(delim, " ");
v4 = strtok(0LL, delim);
if ( !v4 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( *v4 != 70 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v4[1] != 68 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( v4[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v6 = strtok(0LL, delim);
v7 = v6;
if ( !v6 || *v6 == 13 && v6[1] == 10 && !v6[2] )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v8 = (char *)sacar_nueva_linea(v7);
v9 = string_to_integer(v8);
if ( v9 <= 0 )
return responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
v10 = buscar_descriptor(descriptores, 0LL, (unsigned int)v9, 1LL);
v11 = (_QWORD *)v10;
if ( !v10 || *(_DWORD *)(v10 + 12) != a3 )
return responder_al_cliente(a2, "ERROR FD INCORRECTO\n");
v12 = integer_to_char(*(_DWORD *)(v10 + 8));
enviar(*a1, 115LL, (unsigned int)v12, v13, *v11);
v14 = recibir(a1[1]);
borrar_descriptor(descriptores, *v11);
responder_al_cliente(a2, &unk_DC8);
return liberar_msj(v14);
}

canonical_decompiled_code:
__int64 __fastcall func11(unsigned int *a1, int a2, int a3)
{
char *v4; // rax
char *v6; // rax
char *v7; // r13
char *v8; // rax
int v9; // eax
__int64 v10; // rax
_QWORD *v11; // r13
char v12; // al
__int64 v13; // rcx
__int64 v14; // rbp
char delim[2]; // [rsp+Eh] [rbp-2Ah] BYREF

strcpy(delim, " ");
v4 = strtok(0LL, delim);
if ( !v4 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( *v4 != 70 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v4[1] != 68 )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( v4[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
v6 = strtok(0LL, delim);
v7 = v6;
if ( !v6 || *v6 == 13 && v6[1] == 10 && !v6[2] )
return func0(a2, "ERROR DE SINTAXIS\n");
if ( strtok(0LL, delim) )
return func0(a2, "ERROR DE SINTAXIS\n");
v8 = (char *)sacar_nueva_linea(v7);
v9 = func7(v8);
if ( v9 <= 0 )
return func0(a2, "ERROR DE SINTAXIS\n");
v10 = buscar_descriptor(descriptores, 0LL, (unsigned int)v9, 1LL);
v11 = (_QWORD *)v10;
if ( !v10 || *(_DWORD *)(v10 + 12) != a3 )
return func0(a2, "ERROR FD INCORRECTO\n");
v12 = func8(*(_DWORD *)(v10 + 8));
enviar(*a1, 115LL, (unsigned int)v12, v13, *v11);
v14 = recibir(a1[1]);
borrar_descriptor(descriptores, *v11);
func0(a2, &unk_DC8);
return liberar_msj(v14);
}

original_code:
void PS_operadorCLO(DescriptorColas *cola, long conn_s, int worker)
{
  int i = 0, fd;
  char *token;
  char delims[] = " ";
  DescriptorArchivo *archivo;
  Msj *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0) &&
     ((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)) {
    if(((strtok(((void *)0), delims)) == ((void *)0)) && ((fd = string_to_integer(sacar_nueva_linea(token))) > 0))
      i = 1;
  }
  if(i) {
    if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
    }
    else {
      if(archivo->worker_a == worker) {
        enviar(cola->worker,'s',integer_to_char(archivo->worker_c),'m',archivo->nombre);
        msj = recibir(cola->disp);
        borrar_descriptor(descriptores, archivo->nombre);
        responder_al_cliente(conn_s, "OK\n");
        liberar_msj(msj);
      }
      else {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}

canonical_original_code:
void PS_operadorCLO(struct colas *cola, long conn_s, int worker)
{
  int i = 0; int fd;
  char *token;
  char delims[] = " ";
  struct des_ *archivo;
  struct msj_ *msj;
  if(((token = strtok(((void *)0), delims)) != ((void *)0) ) && (strcmp(token, "FD") == 0) &&
     ((token = strtok(((void *)0), delims)) != ((void *)0)) && (strcmp(token, "\r\n") != 0)) {
    if(((strtok(((void *)0), delims)) == ((void *)0)) && ((fd = string_to_integer(sacar_nueva_linea(token))) > 0))
      i = 1;
  }
  if(i) {
    if((archivo = buscar_descriptor(descriptores, ((void *)0), fd, 1)) == ((void *)0)) {
      responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
    }
    else {
      if(archivo->worker_a == worker) {
        enviar(cola->worker,'s',integer_to_char(archivo->worker_c),'m',archivo->nombre);
        msj = recibir(cola->disp);
        borrar_descriptor(descriptores, archivo->nombre);
        responder_al_cliente(conn_s, "OK\n");
        liberar_msj(msj);
      }
      else {
        responder_al_cliente(conn_s, "ERROR FD INCORRECTO\n");
      }
    }
  }
  else {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
}


decompiled_code:
int __fastcall PS_operadorBYE(unsigned int *a1, int a2, int a3)
{
_QWORD *v3; // rbx
char v5; // al
__int64 v6; // rcx
__int64 v7; // rax

v3 = (_QWORD *)*descriptores;
if ( *descriptores )
{
do
{
while ( *((_DWORD *)v3 + 3) != a3 )
{
v3 = (_QWORD *)v3[3];
if ( !v3 )
goto LABEL_6;
}
v5 = integer_to_char(*((_DWORD *)v3 + 2));
enviar(*a1, 115LL, (unsigned int)v5, v6, *v3);
v7 = recibir(a1[1]);
liberar_msj(v7);
v3 = (_QWORD *)borrar_descriptor(descriptores, *v3);
}
while ( v3 );
}
LABEL_6:
responder_al_cliente(a2, &unk_DC8);
return close(a2);
}

canonical_decompiled_code:
int __fastcall func12(unsigned int *a1, int a2, int a3)
{
_QWORD *v3; // rbx
char v5; // al
__int64 v6; // rcx
__int64 v7; // rax

v3 = (_QWORD *)*descriptores;
if ( *descriptores )
{
do
{
while ( *((_DWORD *)v3 + 3) != a3 )
{
v3 = (_QWORD *)v3[3];
if ( !v3 )
goto LABEL_6;
}
v5 = func8(*((_DWORD *)v3 + 2));
enviar(*a1, 115LL, (unsigned int)v5, v6, *v3);
v7 = recibir(a1[1]);
liberar_msj(v7);
v3 = (_QWORD *)borrar_descriptor(descriptores, *v3);
}
while ( v3 );
}
LABEL_6:
func0(a2, &unk_DC8);
return close(a2);
}

original_code:
void PS_operadorBYE(DescriptorColas *cola, long conn_s, int worker)
{
  DescriptorArchivo *archivo;
  Msj *msj;
  archivo = descriptores->inicio;
  while(archivo != ((void *)0)) {
    if(archivo->worker_a == worker) {
      enviar(cola->worker,'s',integer_to_char(archivo->worker_c),'m',archivo->nombre);
      msj = recibir(cola->disp);
      liberar_msj(msj);
      archivo = borrar_descriptor(descriptores, archivo->nombre);
      continue;
    }
    archivo = archivo->proximo;
  }
  responder_al_cliente(conn_s, "OK\n");
  close(conn_s);
}

canonical_original_code:
void PS_operadorBYE(struct colas *cola, long conn_s, int worker)
{
  struct des_ *archivo;
  struct msj_ *msj;
  archivo = descriptores->inicio;
  while(archivo != ((void *)0)) {
    if(archivo->worker_a == worker) {
      enviar(cola->worker,'s',integer_to_char(archivo->worker_c),'m',archivo->nombre);
      msj = recibir(cola->disp);
      liberar_msj(msj);
      archivo = borrar_descriptor(descriptores, archivo->nombre);
      continue;
    }
    archivo = archivo->proximo;
  }
  responder_al_cliente(conn_s, "OK\n");
  close(conn_s);
}


decompiled_code:
__int64 __fastcall evaluar_pedido(char *a1, int a2, unsigned int a3, unsigned int *a4)
{
__int64 v7; // rbx
const char *v8; // rsi
char *v9; // rbp
__int64 result; // rax
char delim[2]; // [rsp+1Eh] [rbp-3Ah] BYREF

v7 = 0LL;
strcpy(delim, " ");
v8 = "CON\r\n";
v9 = strtok(a1, delim);
while ( strcmp(v9, v8) )
{
if ( ++v7 == 9 )
{
responder_al_cliente(a2, "ERROR DE SINTAXIS\n");
return 0LL;
}
v8 = operaciones[v7];
}
switch ( (int)v7 )
{
case 1:
PS_operadorLSD(a4, a2);
result = 0LL;
break;
case 2:
PS_operadorDEL(a4, a2);
result = 0LL;
break;
case 3:
PS_operadorCRE(a4, a2);
result = 0LL;
break;
case 4:
PS_operadorOPN(a4, a2, a3);
result = 0LL;
break;
case 5:
PS_operadorWRT(a4, a2, a3);
result = 0LL;
break;
case 6:
PS_operadorREA(a4, a2, a3);
result = 0LL;
break;
case 7:
PS_operadorCLO(a4, a2, a3);
result = 0LL;
break;
case 8:
PS_operadorBYE(a4, a2, a3);
result = 1LL;
break;
default:
responder_al_cliente(a2, "ERROR YA ESTA CONECTADO\n");
result = 0LL;
break;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func13(char *a1, int a2, unsigned int a3, unsigned int *a4)
{
__int64 v7; // rbx
const char *v8; // rsi
char *v9; // rbp
__int64 result; // rax
char delim[2]; // [rsp+1Eh] [rbp-3Ah] BYREF

v7 = 0LL;
strcpy(delim, " ");
v8 = "CON\r\n";
v9 = strtok(a1, delim);
while ( strcmp(v9, v8) )
{
if ( ++v7 == 9 )
{
func0(a2, "ERROR DE SINTAXIS\n");
return 0LL;
}
v8 = operaciones[v7];
}
switch ( (int)v7 )
{
case 1:
func2(a4, a2);
result = 0LL;
break;
case 2:
func3(a4, a2);
result = 0LL;
break;
case 3:
func4(a4, a2);
result = 0LL;
break;
case 4:
func5(a4, a2, a3);
result = 0LL;
break;
case 5:
func9(a4, a2, a3);
result = 0LL;
break;
case 6:
func10(a4, a2, a3);
result = 0LL;
break;
case 7:
func11(a4, a2, a3);
result = 0LL;
break;
case 8:
func12(a4, a2, a3);
result = 1LL;
break;
default:
func0(a2, "ERROR YA ESTA CONECTADO\n");
result = 0LL;
break;
}
return result;
}

original_code:
int evaluar_pedido(char *pedido, long conn_s, int worker, DescriptorColas* cola)
{
  int i;
  char *token;
  char delims[] = " ";
  token = strtok(pedido, delims);
  for(i = 0; i <= 8; i++) {
    if (strcmp (token, operaciones[i]) == 0) {
      switch(i) {
        case 0:
          responder_al_cliente(conn_s, "ERROR YA ESTA CONECTADO\n");
          break;
        case 1:
          PS_operadorLSD(cola, conn_s);
          break;
        case 2:
          PS_operadorDEL(cola, conn_s);
          break;
        case 3:
          PS_operadorCRE(cola, conn_s);
          break;
        case 4:
          PS_operadorOPN(cola, conn_s, worker);
          break;
        case 5:
          PS_operadorWRT(cola, conn_s, worker);
          break;
        case 6:
          PS_operadorREA(cola, conn_s, worker);
          break;
        case 7:
          PS_operadorCLO(cola, conn_s, worker);
          break;
        case 8:
          PS_operadorBYE(cola, conn_s, worker);
          return 1;
          break;
      }
    i = 0;
    break;
    }
  }
  if(i > 0) {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
  return 0;
}

canonical_original_code:
int evaluar_pedido(char *pedido, long conn_s, int worker, struct colas *cola)
{
  int i;
  char *token;
  char delims[] = " ";
  token = strtok(pedido, delims);
  for(i = 0; i <= 8; i++) {
    if (strcmp (token, operaciones[i]) == 0) {
      switch(i) {
        case 0:
          responder_al_cliente(conn_s, "ERROR YA ESTA CONECTADO\n");
          break;
        case 1:
          PS_operadorLSD(cola, conn_s);
          break;
        case 2:
          PS_operadorDEL(cola, conn_s);
          break;
        case 3:
          PS_operadorCRE(cola, conn_s);
          break;
        case 4:
          PS_operadorOPN(cola, conn_s, worker);
          break;
        case 5:
          PS_operadorWRT(cola, conn_s, worker);
          break;
        case 6:
          PS_operadorREA(cola, conn_s, worker);
          break;
        case 7:
          PS_operadorCLO(cola, conn_s, worker);
          break;
        case 8:
          PS_operadorBYE(cola, conn_s, worker);
          return 1;
          break;
      }
    i = 0;
    break;
    }
  }
  if(i > 0) {
    responder_al_cliente(conn_s, "ERROR DE SINTAXIS\n");
  }
  return 0;
}

variable_types:
pedido
char *


decompiled_code:
__int64 __fastcall proceso_socket(__int64 *a1)
{
__int64 v1; // rbx
int v2; // er12
int v3; // eax
unsigned int v4; // ebp
int v5; // eax
unsigned int *v7; // r13
int v8; // eax
char s[7]; // [rsp+9h] [rbp-22Fh] BYREF
char buf[552]; // [rsp+10h] [rbp-228h] BYREF

v1 = *a1;
v2 = *a1;
do
{
v5 = read(v2, buf, 0x200uLL);
if ( v5 <= 0 )
{
close(v1);
goto LABEL_5;
}
buf[v5] = 0;
v3 = iniciar_conexion(buf, v1);
v4 = v3;
}
while ( v3 < 0 );
printf("-> Cliente con ID %d conectado\n", (unsigned int)v3);
v7 = (unsigned int *)nueva_cola_mensaje(v4, 100LL);
sprintf(s, "/cola%d", v4);
*v7 = abrir(s);
while ( 1 )
{
v8 = read(v2, buf, 0x200uLL);
if ( v8 <= 0 )
break;
buf[v8] = 0;
if ( (unsigned int)evaluar_pedido(buf, v1, v4, v7) )
goto LABEL_10;
}
PS_operadorBYE(v7, v1, v4);
LABEL_10:
close(v1);
pthread_mutex_lock(&m);
*(_BYTE *)(bitmap_worker + (int)v4) = 0;
pthread_mutex_unlock(&m);
borrar_cola_mensaje(v7, v4, 100LL);
printf("<- Cliente con ID %d desconectado\n", v4);
LABEL_5:
close(v1);
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func14(__int64 *a1)
{
__int64 v1; // rbx
int v2; // er12
int v3; // eax
unsigned int v4; // ebp
int v5; // eax
unsigned int *v7; // r13
int v8; // eax
char s[7]; // [rsp+9h] [rbp-22Fh] BYREF
char buf[552]; // [rsp+10h] [rbp-228h] BYREF

v1 = *a1;
v2 = *a1;
do
{
v5 = read(v2, buf, 0x200uLL);
if ( v5 <= 0 )
{
close(v1);
goto LABEL_5;
}
buf[v5] = 0;
v3 = func6(buf, v1);
v4 = v3;
}
while ( v3 < 0 );
printf("-> Cliente con ID %d conectado\n", (unsigned int)v3);
v7 = (unsigned int *)nueva_cola_mensaje(v4, 100LL);
sprintf(s, "/cola%d", v4);
*v7 = abrir(s);
while ( 1 )
{
v8 = read(v2, buf, 0x200uLL);
if ( v8 <= 0 )
break;
buf[v8] = 0;
if ( (unsigned int)func13(buf, v1, v4, v7) )
goto LABEL_10;
}
func12(v7, v1, v4);
LABEL_10:
close(v1);
pthread_mutex_lock(&m);
*(_BYTE *)(bitmap_worker + (int)v4) = 0;
pthread_mutex_unlock(&m);
borrar_cola_mensaje(v7, v4, 100LL);
printf("<- Cliente con ID %d desconectado\n", v4);
LABEL_5:
close(v1);
return 0LL;
}

original_code:
void *proceso_socket(void *arg)
{
  long conn_s = *(long *)arg;
  char pedido[512], cola_w[7];
  int res, worker;
  DescriptorColas *cola;
  while(1) {
    res=read(conn_s,pedido,512);
    if (res<=0) {
      close(conn_s);
      break;
    }
    pedido[res]='\0';
    if((worker = iniciar_conexion(pedido, conn_s)) >= 0) {
      printf("-> Cliente con ID %d conectado\n", worker);
      cola = nueva_cola_mensaje(worker, 'd');
      sprintf(cola_w, "/cola%d", worker);
      cola->worker = abrir(cola_w);
      while(1) {
        res=read(conn_s,pedido,512);
        if(res<=0) {
          PS_operadorBYE(cola, conn_s, worker);
          break;
        }
        pedido[res]='\0';
        if(evaluar_pedido(pedido, conn_s, worker, cola))
          break;
      }
      close(conn_s);
      pthread_mutex_lock(&m);
      bitmap_worker[worker] = 0;
      pthread_mutex_unlock(&m);
      borrar_cola_mensaje(cola, worker, 'd');
      printf("<- Cliente con ID %d desconectado\n",worker);
      break;
    }
  }
  close(conn_s);
  return ((void *)0);
}

canonical_original_code:
void *proceso_socket(void *arg)
{
  long conn_s = *(long *)arg;
  char pedido[512]; char cola_w[7];
  int res; int worker;
  struct colas *cola;
  while(1) {
    res=read(conn_s,pedido,512);
    if (res<=0) {
      close(conn_s);
      break;
    }
    pedido[res]='\0';
    if((worker = iniciar_conexion(pedido, conn_s)) >= 0) {
      printf("-> Cliente con ID %d conectado\n", worker);
      cola = nueva_cola_mensaje(worker, 'd');
      sprintf(cola_w, "/cola%d", worker);
      cola->worker = abrir(cola_w);
      while(1) {
        res=read(conn_s,pedido,512);
        if(res<=0) {
          PS_operadorBYE(cola, conn_s, worker);
          break;
        }
        pedido[res]='\0';
        if(evaluar_pedido(pedido, conn_s, worker, cola))
          break;
      }
      close(conn_s);
      pthread_mutex_lock(&m);
      bitmap_worker[worker] = 0;
      pthread_mutex_unlock(&m);
      borrar_cola_mensaje(cola, worker, 'd');
      printf("<- Cliente con ID %d desconectado\n",worker);
      break;
    }
  }
  close(conn_s);
  return ((void *)0);
}

variable_types:
arg
void *

variable_types:
pedido
char [512]

variable_types: res int

return_type: void *


nueva

decompiled_code:
__int64 __fastcall nueva(__int64 a1)
{
__int64 result; // rax
__int64 v2[9]; // [rsp+10h] [rbp-48h] BYREF

v2[1] = 5LL;
v2[2] = 24LL;
v2[0] = 0LL;
result = mq_open(a1, 66LL, 448LL, v2);
if ( (_DWORD)result == -1 )
{
perror("mq_open");
result = 0xFFFFFFFFLL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1)
{
__int64 result; // rax
__int64 v2[9]; // [rsp+10h] [rbp-48h] BYREF

v2[1] = 5LL;
v2[2] = 24LL;
v2[0] = 0LL;
result = mq_open(a1, 66LL, 448LL, v2);
if ( (_DWORD)result == -1 )
{
perror("mq_open");
result = 0xFFFFFFFFLL;
}
return result;
}

original_code:
mqd_t nueva(char *nombre)
{
  struct mq_attr atributos;
  mqd_t cola;
  atributos.mq_maxmsg = 5;
  atributos.mq_msgsize = sizeof(Msj);
  atributos.mq_flags = 0;
  if ((cola = mq_open(nombre, 0100 | 02, (0400|0200|0100), &atributos)) == (mqd_t)-1)
    perror ("mq_open");
  return cola;
}

canonical_original_code:
int nueva(char *nombre)
{
  struct mq_attr atributos;
  int cola;
  atributos.mq_maxmsg = 5;
  atributos.mq_msgsize = sizeof(Msj);
  atributos.mq_flags = 0;
  if ((cola = mq_open(nombre, 0100 | 02, (0400|0200|0100), &atributos)) == (mqd_t)-1)
    perror ("mq_open");
  return cola;
}

variable_types:
nombre
char *

variable_types: struct mq_attr { long mq_flags; long mq_maxmsg; long mq_msgsize; long mq_curmsgs; long __pad[4]; }

variable_types: cola int


abrir

decompiled_code:
__int64 __fastcall abrir(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 result; // rax

result = mq_open(a1, 2LL, a3, a4);
if ( (_DWORD)result == -1 )
{
perror("mq_open");
result = 0xFFFFFFFFLL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 result; // rax

result = mq_open(a1, 2LL, a3, a4);
if ( (_DWORD)result == -1 )
{
perror("mq_open");
result = 0xFFFFFFFFLL;
}
return result;
}

original_code:
mqd_t abrir(char *nombre)
{
  mqd_t cola;
  if ((cola = mq_open(nombre, 02)) == (mqd_t)-1)
    perror("mq_open");
  return cola;
}

canonical_original_code:
int abrir(char *nombre)
{
  int cola;
  if ((cola = mq_open(nombre, 02)) == (mqd_t)-1)
    perror("mq_open");
  return cola;
}


decompiled_code:
__int64 __fastcall enviar_msj(__int64 a1, __int64 a2)
{
if ( (unsigned int)mq_send(a1, a2, 24LL, 0LL) == -1 )
perror("mq_send");
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2)
{
if ( (unsigned int)mq_send(a1, a2, 24LL, 0LL) == -1 )
perror("mq_send");
return 0LL;
}

original_code:
int enviar_msj(mqd_t cola, char *mensaje)
{
  if(mq_send(cola, mensaje, sizeof(Msj), 0) == -1)
    perror("mq_send");
  return 0;
}

canonical_original_code:
int enviar_msj(int cola, char *mensaje)
{
  if(mq_send(cola, mensaje, sizeof(Msj), 0) == -1)
    perror("mq_send");
  return 0;
}

variable_types:
mensaje
char *


decompiled_code:
__int64 __fastcall recibir_msj(__int64 a1, __int64 a2)
{
if ( mq_receive(a1, a2, 24LL, 0LL) == -1 )
perror("mq_receive");
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func3(__int64 a1, __int64 a2)
{
if ( mq_receive(a1, a2, 24LL, 0LL) == -1 )
perror("mq_receive");
return 0LL;
}

original_code:
int recibir_msj(mqd_t cola, char *buf)
{
  if (mq_receive(cola, buf, sizeof(Msj), ((void *)0)) == -1)
    perror("mq_receive");
  return 0;
}

canonical_original_code:
int recibir_msj(int cola, char *buf)
{
  if (mq_receive(cola, buf, sizeof(Msj), ((void *)0)) == -1)
    perror("mq_receive");
  return 0;
}

variable_types:
buf
char *


cerrar

decompiled_code:
__int64 cerrar()
{
mq_close();
return 0LL;
}

canonical_decompiled_code:
__int64 func4()
{
mq_close();
return 0LL;
}

original_code:
int cerrar(mqd_t cola)
{
  mq_close(cola);
  return 0;
}

canonical_original_code:
int cerrar(int cola)
{
  mq_close(cola);
  return 0;
}


borrar

decompiled_code:
__int64 borrar()
{
mq_unlink();
return 0LL;
}

canonical_decompiled_code:
__int64 func5()
{
mq_unlink();
return 0LL;
}

original_code:
int borrar(char *nombre_cola)
{
  mq_unlink(nombre_cola);
  return 0;
}


atributos

decompiled_code:
__int64 __fastcall atributos(__int64 a1, __int64 a2)
{
const char *v2; // r9
__int64 result; // rax
_BYTE v4[8]; // [rsp+0h] [rbp-48h] BYREF
__int64 v5; // [rsp+8h] [rbp-40h]
__int64 v6; // [rsp+10h] [rbp-38h]
__int64 v7; // [rsp+18h] [rbp-30h]

if ( (int)mq_getattr(a1, v4) < 0 )
{
perror("mq_getattr");
result = 0LL;
}
else
{
v2 = "sin-bloqueo";
if ( (v4[1] & 8) == 0 )
v2 = "bloqueo";
printf(format, a2, v7, v5, v6, v2);
result = 0LL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1, __int64 a2)
{
const char *v2; // r9
__int64 result; // rax
_BYTE v4[8]; // [rsp+0h] [rbp-48h] BYREF
__int64 v5; // [rsp+8h] [rbp-40h]
__int64 v6; // [rsp+10h] [rbp-38h]
__int64 v7; // [rsp+18h] [rbp-30h]

if ( (int)mq_getattr(a1, v4) < 0 )
{
perror("mq_getattr");
result = 0LL;
}
else
{
v2 = "sin-bloqueo";
if ( (v4[1] & 8) == 0 )
v2 = "bloqueo";
printf(format, a2, v7, v5, v6, v2);
result = 0LL;
}
return result;
}

original_code:
int atributos(mqd_t cola, char *nombre)
{
  struct mq_attr mqa;
  if (mq_getattr(cola, &mqa) < 0)
    perror("mq_getattr");
  else {
    printf("MQD: %s tiene %ld msjs (max %ld, max tamaño %ld, modo %s)\n",
    nombre, mqa.mq_curmsgs, mqa.mq_maxmsg, mqa.mq_msgsize, (mqa.mq_flags & 04000) ? "sin-bloqueo" : "bloqueo");
  }
  return 0;
}

canonical_original_code:
int atributos(int cola, char *nombre)
{
  struct mq_attr mqa;
  if (mq_getattr(cola, &mqa) < 0)
    perror("mq_getattr");
  else {
    printf("MQD: %s tiene %ld msjs (max %ld, max tamaño %ld, modo %s)\n",
    nombre, mqa.mq_curmsgs, mqa.mq_maxmsg, mqa.mq_msgsize, (mqa.mq_flags & 04000) ? "sin-bloqueo" : "bloqueo");
  }
  return 0;
}

user_defined_types: struct mq_attr { long mq_flags; long mq_maxmsg; long mq_msgsize; long mq_curmsgs; long __pad[4]; }


decompiled_code:
__int64 __fastcall crear_cola(unsigned int a1)
{
char *v1; // rbp

v1 = (char *)malloc(7uLL);
if ( !v1 )
printf("Error al crear cola de mensajes");
sprintf(v1, "/cola%d", a1);
mq_unlink(v1);
return nueva((__int64)v1);
}

canonical_decompiled_code:
__int64 __fastcall func7(unsigned int a1)
{
char *v1; // rbp

v1 = (char *)malloc(7uLL);
if ( !v1 )
printf("Error al crear cola de mensajes");
sprintf(v1, "/cola%d", a1);
mq_unlink(v1);
return func0((__int64)v1);
}

original_code:
mqd_t crear_cola(int cola)
{
  mqd_t mqd;
  char *buff;
  if((buff = (char *) malloc(7*sizeof(char))) == ((void *)0))
     printf("Error al crear cola de mensajes");
  sprintf(buff, "/cola%d", cola);
  mq_unlink(buff);
  mqd = nueva(buff);
  return mqd;
}

canonical_original_code:
int crear_cola(int cola)
{
  int mqd;
  char *buff;
  if((buff = (char *) malloc(7*sizeof(char))) == ((void *)0))
     printf("Error al crear cola de mensajes");
  sprintf(buff, "/cola%d", cola);
  mq_unlink(buff);
  mqd = nueva(buff);
  return mqd;
}

variable_types: mqd int

variable_types:
buff
char *


enviar

decompiled_code:
__int64 __fastcall enviar(unsigned int a1, char a2, char a3, char a4, __int64 a5)
{
_BYTE *v9; // rsi

v9 = calloc(1uLL, 0x18uLL);
if ( !v9 )
{
puts("Error al enviar mensaje");
v9 = 0LL;
}
*v9 = a2;
v9[1] = a3;
v9[2] = a4;
*((_DWORD *)v9 + 1) = 48;
*((_QWORD *)v9 + 1) = a5;
*((_QWORD *)v9 + 2) = 0LL;
return enviar_msj(a1, (__int64)v9);
}

canonical_decompiled_code:
__int64 __fastcall func8(unsigned int a1, char a2, char a3, char a4, __int64 a5)
{
_BYTE *v9; // rsi

v9 = calloc(1uLL, 0x18uLL);
if ( !v9 )
{
puts("Error al enviar mensaje");
v9 = 0LL;
}
*v9 = a2;
v9[1] = a3;
v9[2] = a4;
*((_DWORD *)v9 + 1) = 48;
*((_QWORD *)v9 + 1) = a5;
*((_QWORD *)v9 + 2) = 0LL;
return func2(a1, (__int64)v9);
}

original_code:
void enviar(mqd_t mqd, char tipo, char contador, char dato, char *nombre)
{
  Msj *msj;
  if((msj = (Msj *) calloc(1, sizeof(Msj))) == ((void *)0))
    printf("Error al enviar mensaje\n");
  msj->tipo = tipo;
  msj->contador = contador;
  msj->dato = dato;
  msj->otrodato = '0';
  msj->nombre = nombre;
  msj->texto = ((void *)0);
  enviar_msj(mqd, (char *)msj);
}

canonical_original_code:
void enviar(int mqd, char tipo, char contador, char dato, char *nombre)
{
  struct msj_ *msj;
  if((msj = (struct msj_ *) calloc(1, sizeof(Msj))) == ((void *)0))
    printf("Error al enviar mensaje\n");
  msj->tipo = tipo;
  msj->contador = contador;
  msj->dato = dato;
  msj->otrodato = '0';
  msj->nombre = nombre;
  msj->texto = ((void *)0);
  enviar_msj(mqd, (char *)msj);
}

variable_types: tipo char

variable_types: contador char

variable_types: dato char


enviarWR

decompiled_code:
__int64 __fastcall enviarWR(unsigned int a1, char a2, char a3, char a4, int a5, __int64 a6, __int64 a7)
{
_BYTE *v11; // rax

v11 = calloc(1uLL, 0x18uLL);
*v11 = a2;
v11[1] = a3;
v11[2] = a4;
*((_DWORD *)v11 + 1) = a5;
*((_QWORD *)v11 + 1) = a6;
*((_QWORD *)v11 + 2) = a7;
return enviar_msj(a1, (__int64)v11);
}

original_code:
void enviarWR(mqd_t mqd, char tipo, char contador, char dato, int otrodato, char *nombre, char *texto)
{
  Msj *msj = (Msj *)calloc(1, sizeof(Msj));
  msj->tipo = tipo;
  msj->contador = contador;
  msj->dato = dato;
  msj->otrodato = otrodato;
  msj->nombre = nombre;
  msj->texto = texto;
  enviar_msj(mqd, (char *)msj);
}

canonical_original_code:
void enviarWR(int mqd, char tipo, char contador, char dato, int otrodato, char *nombre, char *texto)
{
  struct msj_ *msj = (Msj *)calloc(1, sizeof(Msj));
  msj->tipo = tipo;
  msj->contador = contador;
  msj->dato = dato;
  msj->otrodato = otrodato;
  msj->nombre = nombre;
  msj->texto = texto;
  enviar_msj(mqd, (char *)msj);
}

variable_types: otrodato int

variable_types:
texto
char *


original_code:
void reenvio_msj(mqd_t mqd, Msj *msj, char tipo)
{
  switch(tipo) {
    case 'w':
      enviarWR(mqd, 'w', msj->contador-1, msj->dato, msj->otrodato, msj->nombre, msj->texto);
      break;
    case 'r':
      enviarWR(mqd, 'r', msj->contador-1, msj->dato, msj->otrodato, msj->nombre, msj->texto);
      break;
    default:
      enviar(mqd,tipo,msj->contador-1,msj->dato,msj->nombre);
      break;
  }
}

canonical_original_code:
void reenvio_msj(int mqd, struct msj_ *msj, char tipo)
{
  switch(tipo) {
    case 'w':
      enviarWR(mqd, 'w', msj->contador-1, msj->dato, msj->otrodato, msj->nombre, msj->texto);
      break;
    case 'r':
      enviarWR(mqd, 'r', msj->contador-1, msj->dato, msj->otrodato, msj->nombre, msj->texto);
      break;
    default:
      enviar(mqd,tipo,msj->contador-1,msj->dato,msj->nombre);
      break;
  }
}

variable_types: struct msj_ { char tipo; char contador; char dato; int otrodato; char *nombre; char *texto; } *


recibir

decompiled_code:
void *__fastcall recibir(unsigned int a1)
{
void *v1; // r12

v1 = malloc(0x18uLL);
if ( !v1 )
puts("Error no es posible recibir un msj por el anillo");
recibir_msj(a1, (__int64)v1);
return v1;
}

canonical_decompiled_code:
void *__fastcall func11(unsigned int a1)
{
void *v1; // r12

v1 = malloc(0x18uLL);
if ( !v1 )
puts("Error no es posible recibir un msj por el anillo");
func3(a1, (__int64)v1);
return v1;
}

original_code:
Msj* recibir(mqd_t mqd)
{
  char *buff;
  if ((buff = (char *)malloc(sizeof(Msj))) == ((void *)0))
    printf("Error no es posible recibir un msj por el anillo\n");
  recibir_msj(mqd, buff);
  return (Msj *)buff;
}

canonical_original_code:
struct msj_ *recibir(int mqd)
{
  char *buff;
  if ((buff = (char *)malloc(sizeof(Msj))) == ((void *)0))
    printf("Error no es posible recibir un msj por el anillo\n");
  recibir_msj(mqd, buff);
  return (struct msj_ *)buff;
}

return_type: struct msj_ { char tipo; char contador; char dato; int otrodato; char *nombre; char *texto; } *


decompiled_code:
void __fastcall liberar_msj(void *ptr)
{
if ( ptr )
{
free(*((void **)ptr + 1));
free(*((void **)ptr + 2));
free(ptr);
}
}

canonical_decompiled_code:
void __fastcall func12(void *ptr)
{
if ( ptr )
{
free(*((void **)ptr + 1));
free(*((void **)ptr + 2));
free(ptr);
}
}

original_code:
void liberar_msj(Msj *msj)
{
  if(msj == ((void *)0))
    return;
  free(msj->nombre);
  free(msj->texto);
  free(msj);
  msj = ((void *)0);
}

canonical_original_code:
void liberar_msj(struct msj_ *msj)
{
  if(msj == ((void *)0))
    return;
  free(msj->nombre);
  free(msj->texto);
  free(msj);
  msj = ((void *)0);
}


decompiled_code:
int __fastcall imprimir_msj(char *a1)
{
const char *v2; // rdi
const char *v3; // rdi

printf("El tipo: %c\n", (unsigned int)*a1);
printf("El contador: %c\n", (unsigned int)a1[1]);
printf("El dato: %c\n", (unsigned int)a1[2]);
printf("El otrodato: %d\n", *((unsigned int *)a1 + 1));
v2 = (const char *)*((_QWORD *)a1 + 1);
if ( v2 )
{
puts(v2);
v3 = (const char *)*((_QWORD *)a1 + 2);
if ( v3 )
{
LABEL_3:
puts(v3);
return putchar(10);
}
}
else
{
puts("sin nombre");
v3 = (const char *)*((_QWORD *)a1 + 2);
if ( v3 )
goto LABEL_3;
}
puts("sin texto");
return putchar(10);
}

canonical_decompiled_code:
int __fastcall func13(char *a1)
{
const char *v2; // rdi
const char *v3; // rdi

printf("El tipo: %c\n", (unsigned int)*a1);
printf("El contador: %c\n", (unsigned int)a1[1]);
printf("El dato: %c\n", (unsigned int)a1[2]);
printf("El otrodato: %d\n", *((unsigned int *)a1 + 1));
v2 = (const char *)*((_QWORD *)a1 + 1);
if ( v2 )
{
puts(v2);
v3 = (const char *)*((_QWORD *)a1 + 2);
if ( v3 )
{
LABEL_3:
puts(v3);
return putchar(10);
}
}
else
{
puts("sin nombre");
v3 = (const char *)*((_QWORD *)a1 + 2);
if ( v3 )
goto LABEL_3;
}
puts("sin texto");
return putchar(10);
}

original_code:
void imprimir_msj(Msj *msj)
{
  printf("El tipo: %c\n",msj->tipo);
  printf("El contador: %c\n",msj->contador);
  printf("El dato: %c\n",msj->dato);
  printf("El otrodato: %d\n",msj->otrodato);
  if(msj->nombre == ((void *)0))
    printf("sin nombre\n");
  else
    printf("%s\n",msj->nombre);
  if(msj->texto == ((void *)0))
    printf("sin texto\n");
  else
    printf("%s\n",msj->texto);
  printf("\n");
}

canonical_original_code:
void imprimir_msj(struct msj_ *msj)
{
  printf("El tipo: %c\n",msj->tipo);
  printf("El contador: %c\n",msj->contador);
  printf("El dato: %c\n",msj->dato);
  printf("El otrodato: %d\n",msj->otrodato);
  if(msj->nombre == ((void *)0))
    printf("sin nombre\n");
  else
    printf("%s\n",msj->nombre);
  if(msj->texto == ((void *)0))
    printf("sin texto\n");
  else
    printf("%s\n",msj->texto);
  printf("\n");
}


decompiled_code:
void __fastcall borrar_cola_mensaje(void *ptr, unsigned int a2, char a3)
{
__int64 v3; // rdx
char s[31]; // [rsp+9h] [rbp-1Fh] BYREF

if ( a3 == 100 )
{
cerrar(*((unsigned int *)ptr + 1));
cerrar(*(unsigned int *)ptr);
v3 = (unsigned int)((int)(a2 + 5) % 10);
goto LABEL_4;
}
if ( a3 == 119 )
{
cerrar(*(unsigned int *)ptr);
cerrar(*((unsigned int *)ptr + 2));
v3 = a2;
LABEL_4:
sprintf(s, "/cola%d", v3);
borrar(s);
}
free(ptr);
}

canonical_decompiled_code:
void __fastcall func14(void *ptr, unsigned int a2, char a3)
{
__int64 v3; // rdx
char s[31]; // [rsp+9h] [rbp-1Fh] BYREF

if ( a3 == 100 )
{
func4(*((unsigned int *)ptr + 1));
func4(*(unsigned int *)ptr);
v3 = (unsigned int)((int)(a2 + 5) % 10);
goto LABEL_4;
}
if ( a3 == 119 )
{
func4(*(unsigned int *)ptr);
func4(*((unsigned int *)ptr + 2));
v3 = a2;
LABEL_4:
sprintf(s, "/cola%d", v3);
func5(s);
}
free(ptr);
}

original_code:
void borrar_cola_mensaje(DescriptorColas* cola, int worker, char tipo)
{
  char nombre[7];
  switch(tipo) {
    case 'w':
      cerrar(cola->worker);
      cerrar(cola->anillo);
      sprintf(nombre, "/cola%d", worker);
      borrar(nombre);
      break;
    case 'd':
      cerrar(cola->disp);
      cerrar(cola->worker);
      sprintf(nombre, "/cola%d", (worker+5)%(2*5));
      borrar(nombre);
      break;
  }
  free(cola);
}

canonical_original_code:
void borrar_cola_mensaje(struct colas *cola, int worker, char tipo)
{
  char nombre[7];
  switch(tipo) {
    case 'w':
      cerrar(cola->worker);
      cerrar(cola->anillo);
      sprintf(nombre, "/cola%d", worker);
      borrar(nombre);
      break;
    case 'd':
      cerrar(cola->disp);
      cerrar(cola->worker);
      sprintf(nombre, "/cola%d", (worker+5)%(2*5));
      borrar(nombre);
      break;
  }
  free(cola);
}

variable_types: struct colas { int worker; int disp; int anillo; } *

variable_types: worker int

variable_types:
nombre
char [7]


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

if ( a1 )
{
v1 = *a1;
if ( (_DWORD)v1 )
{
printf("Cola worker: %d\n", v1);
v2 = a1[2];
if ( !(_DWORD)v2 )
{
LABEL_4:
v3 = a1[1];
if ( !(_DWORD)v3 )
return putchar(10);
goto LABEL_6;
}
}
else
{
v2 = a1[2];
if ( !(_DWORD)v2 )
goto LABEL_4;
}
printf("Cola anillo: %d\n", v2);
v3 = a1[1];
if ( !(_DWORD)v3 )
return putchar(10);
LABEL_6:
printf("Cola dispatcher: %d\n", v3);
result = putchar(10);
}
return result;
}

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

if ( a1 )
{
v1 = *a1;
if ( (_DWORD)v1 )
{
printf("Cola worker: %d\n", v1);
v2 = a1[2];
if ( !(_DWORD)v2 )
{
LABEL_4:
v3 = a1[1];
if ( !(_DWORD)v3 )
return putchar(10);
goto LABEL_6;
}
}
else
{
v2 = a1[2];
if ( !(_DWORD)v2 )
goto LABEL_4;
}
printf("Cola anillo: %d\n", v2);
v3 = a1[1];
if ( !(_DWORD)v3 )
return putchar(10);
LABEL_6:
printf("Cola dispatcher: %d\n", v3);
result = putchar(10);
}
return result;
}

original_code:
void imprimir_cola(DescriptorColas* cola)
{
  if(cola != ((void *)0)) {
    if(cola->worker != 0)
      printf("Cola worker: %d\n",(int)cola->worker);
    if(cola->anillo != 0)
      printf("Cola anillo: %d\n",(int)cola->anillo);
    if(cola->disp != 0)
      printf("Cola dispatcher: %d\n",(int)cola->disp);
    printf("\n");
  }
}

canonical_original_code:
void imprimir_cola(struct colas *cola)
{
  if(cola != ((void *)0)) {
    if(cola->worker != 0)
      printf("Cola worker: %d\n",(int)cola->worker);
    if(cola->anillo != 0)
      printf("Cola anillo: %d\n",(int)cola->anillo);
    if(cola->disp != 0)
      printf("Cola dispatcher: %d\n",(int)cola->disp);
    printf("\n");
  }
}


repo: JohnAnthony/Structures

decompiled_code:
__int64 __fastcall dlist_get_head(__int64 a1)
{
return *(_QWORD *)a1;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1)
{
return *(_QWORD *)a1;
}

original_code:
struct dlist_elem* dlist_get_head( const struct dlist *dlist) {
    return dlist->head;
}

canonical_original_code:
struct dlist_elem *dlist_get_head(struct dlist *dlist) {
    return dlist->head;
}

variable_types: struct dlist { struct dlist_elem *head; } *

return_type: struct dlist_elem { struct dlist_elem *next; struct dlist_elem *prev; void *data; } *