AtendeOficiais

decompiled_code:
void __noreturn AtendeOficiais()
{
void *v0; // rbx
__int64 v1; // rbp
unsigned int v2; // eax
pthread_t newthread; // [rsp+8h] [rbp-70h] BYREF
__int64 v4; // [rsp+10h] [rbp-68h] BYREF
char v5; // [rsp+18h] [rbp-60h]

v0 = (void *)CriarSd("/tmp/sdserv");
v1 = CriaSdAuxiliar();
while ( 1 )
{
RecebMsgSock(v1, v0, &v4);
if ( v4 == 0x746E657365727041LL && v5 == 97 )
{
v2 = IdentificaOficial(&v4);
RegistaEntrada(v2, 2LL);
}
else if ( (_DWORD)v4 != 1684627795 || BYTE4(v4) != 97 )
{
pthread_create(&newthread, 0LL, ThreadOficiais, v0);
EnviaMsgSock(v1, "Refeitorio responde!!!", v0);
}
}
}

canonical_decompiled_code:
void __noreturn func2()
{
void *v0; // rbx
__int64 v1; // rbp
unsigned int v2; // eax
pthread_t newthread; // [rsp+8h] [rbp-70h] BYREF
__int64 v4; // [rsp+10h] [rbp-68h] BYREF
char v5; // [rsp+18h] [rbp-60h]

v0 = (void *)CriarSd("/tmp/sdserv");
v1 = CriaSdAuxiliar();
while ( 1 )
{
RecebMsgSock(v1, v0, &v4);
if ( v4 == 0x746E657365727041LL && v5 == 97 )
{
v2 = IdentificaOficial(&v4);
RegistaEntrada(v2, 2LL);
}
else if ( (_DWORD)v4 != 1684627795 || BYTE4(v4) != 97 )
{
pthread_create(&newthread, 0LL, ThreadOficiais, v0);
EnviaMsgSock(v1, "Refeitorio responde!!!", v0);
}
}
}

original_code:
void *AtendeOficiais(void* argumento)
{
  pthread_t TidOficiais;
  sock_dgram *socketDgramOfic;
  sock_dgram *socketDgramRef;
  char msg[80];
  socketDgramRef= CriarSd( "/tmp/sdserv" );
  socketDgramOfic= CriaSdAuxiliar();
  while(1)
    {
      RecebMsgSock(socketDgramOfic,socketDgramRef, msg);
      if(strncmp( msg,"Apresenta", strlen("Apresenta") )== 0)
 {
   RegistaEntrada( IdentificaOficial(msg), 2);
 }
      else if (strncmp( msg, "Saida", strlen("Saida") )== 0)
 {
   CancelaThreadOfic();
 }
      else{
 pthread_create(&TidOficiais, ((void *)0),
         ThreadOficiais, (void*) socketDgramRef);
 EnviaMsgSock(socketDgramOfic, "Refeitorio responde!!!\0", socketDgramRef);
  CancelaThreadOfic();
      }
    }
  return 0;
}

canonical_original_code:
void *AtendeOficiais(void *argumento)
{
  unsigned long TidOficiais;
  struct sock_dgram_str *socketDgramOfic;
  struct sock_dgram_str *socketDgramRef;
  char msg[80];
  socketDgramRef= CriarSd( "/tmp/sdserv" );
  socketDgramOfic= CriaSdAuxiliar();
  while(1)
    {
      RecebMsgSock(socketDgramOfic,socketDgramRef, msg);
      if(strncmp( msg,"Apresenta", strlen("Apresenta") )== 0)
 {
   RegistaEntrada( IdentificaOficial(msg), 2);
 }
      else if (strncmp( msg, "Saida", strlen("Saida") )== 0)
 {
   CancelaThreadOfic();
 }
      else{
 pthread_create(&TidOficiais, ((void *)0),
         ThreadOficiais, (void *) socketDgramRef);
 EnviaMsgSock(socketDgramOfic, "Refeitorio responde!!!\0", socketDgramRef);
  CancelaThreadOfic();
      }
    }
  return 0;
}

variable_types:
TidOficiais
unsigned long

variable_types: struct sock_dgram_str { int sd; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } addr; unsigned int addrlen; } *

variable_types:
msg
char [80]

user_defined_types: struct sock_dgram_str { int sd; struct sockaddr_un addr; unsigned int addrlen; }


CriaSocketStreamEscuta

repo: TiagoTT/academic

decompiled_code:
char *__fastcall CriaSocketStreamEscuta(char *name)
{
char *v1; // r12
size_t v2; // r13
void *v3; // rax
int v4; // eax

v1 = (char *)malloc(0x88uLL);
v2 = strlen(name) + 1;
v3 = malloc(v2);
*((_QWORD *)v1 + 1) = v3;
memcpy(v3, name, v2);
v4 = socket(1, 1, 0);
*(_DWORD *)v1 = v4;
if ( v4 < 0 )
{
perror("Erro a criar socket");
exit(-1);
}
*((_WORD *)v1 + 8) = 1;
*(_QWORD *)(v1 + 18) = 0LL;
*(_QWORD *)(v1 + 118) = 0LL;
memset(
(void *)((unsigned __int64)(v1 + 26) & 0xFFFFFFFFFFFFFFF8LL),
0,
8LL * (((_DWORD)v1 + 18 - (((_DWORD)v1 + 26) & 0xFFFFFFF8) + 108) >> 3));
*((_DWORD *)v1 + 32) = (unsigned int)stpcpy(v1 + 18, name) - ((_DWORD)v1 + 18) + 2;
unlink(name);
if ( bind(*(_DWORD *)v1, (const struct sockaddr *)v1 + 1, *((_DWORD *)v1 + 32)) < 0 )
{
perror("Erro no bind");
exit(-1);
}
if ( listen(*(_DWORD *)v1, 10) < 0 )
{
perror("Erro no listen");
exit(-1);
}
return v1;
}

canonical_decompiled_code:
char *__fastcall func0(char *name)
{
char *v1; // r12
size_t v2; // r13
void *v3; // rax
int v4; // eax

v1 = (char *)malloc(0x88uLL);
v2 = strlen(name) + 1;
v3 = malloc(v2);
*((_QWORD *)v1 + 1) = v3;
memcpy(v3, name, v2);
v4 = socket(1, 1, 0);
*(_DWORD *)v1 = v4;
if ( v4 < 0 )
{
perror("Erro a criar socket");
exit(-1);
}
*((_WORD *)v1 + 8) = 1;
*(_QWORD *)(v1 + 18) = 0LL;
*(_QWORD *)(v1 + 118) = 0LL;
memset(
(void *)((unsigned __int64)(v1 + 26) & 0xFFFFFFFFFFFFFFF8LL),
0,
8LL * (((_DWORD)v1 + 18 - (((_DWORD)v1 + 26) & 0xFFFFFFF8) + 108) >> 3));
*((_DWORD *)v1 + 32) = (unsigned int)stpcpy(v1 + 18, name) - ((_DWORD)v1 + 18) + 2;
unlink(name);
if ( bind(*(_DWORD *)v1, (const struct sockaddr *)v1 + 1, *((_DWORD *)v1 + 32)) < 0 )
{
perror("Erro no bind");
exit(-1);
}
if ( listen(*(_DWORD *)v1, 10) < 0 )
{
perror("Erro no listen");
exit(-1);
}
return v1;
}

original_code:
SocketStream* CriaSocketStreamEscuta(char* nome)
{
 SocketStream* novo;
 novo = (SocketStream*)malloc( sizeof(SocketStream) );
 novo->nome = (char*)malloc( sizeof(char)*(strlen(nome) + 1) );
 strcpy(novo->nome, nome);
 if ((novo->fd = socket(1, SOCK_STREAM, 0)) < 0 ) {
  perror("Erro a criar socket");
  exit(-1);
 }
 novo->my_addr.sun_family = 1;
 memset(novo->my_addr.sun_path, 0, sizeof(novo->my_addr.sun_path));
 strcpy(novo->my_addr.sun_path, nome);
 novo->addrlen = sizeof(novo->my_addr.sun_family)
   + strlen(novo->my_addr.sun_path);
 unlink(nome);
 if (bind(novo->fd, (struct sockaddr *)&(novo->my_addr), novo->addrlen) < 0 ) {
  perror("Erro no bind");
  exit(-1);
 }
 if (listen(novo->fd, 10) < 0 ) {
  perror("Erro no listen");
  exit(-1);
 }
 return novo;
}

canonical_original_code:
struct SocketStreamStr *CriaSocketStreamEscuta(char *nome)
{
 struct SocketStreamStr *novo;
 novo = (struct SocketStreamStr *)malloc( sizeof(SocketStream) );
 novo->nome = (char *)malloc( sizeof(char)*(strlen(nome) + 1) );
 strcpy(novo->nome, nome);
 if ((novo->fd = socket(1, SOCK_STREAM, 0)) < 0 ) {
  perror("Erro a criar socket");
  exit(-1);
 }
 novo->my_addr.sun_family = 1;
 memset(novo->my_addr.sun_path, 0, sizeof(novo->my_addr.sun_path));
 strcpy(novo->my_addr.sun_path, nome);
 novo->addrlen = sizeof(novo->my_addr.sun_family)
   + strlen(novo->my_addr.sun_path);
 unlink(nome);
 if (bind(novo->fd, (struct sockaddr *)&(novo->my_addr), novo->addrlen) < 0 ) {
  perror("Erro no bind");
  exit(-1);
 }
 if (listen(novo->fd, 10) < 0 ) {
  perror("Erro no listen");
  exit(-1);
 }
 return novo;
}

variable_types:
nome
char *

variable_types: struct SocketStreamStr { int fd; char *nome; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } my_addr; unsigned int addrlen; } *

user_defined_types: struct SocketStreamStr { int fd; char *nome; struct sockaddr_un my_addr; unsigned int addrlen; }

user_defined_types: struct sockaddr { unsigned short sa_family; char sa_data[14]; }


AceitaLigacaoSocketStream

decompiled_code:
void *__fastcall AceitaLigacaoSocketStream(int *a1)
{
void *v2; // r12
int v3; // edi
int v4; // eax

v2 = malloc(0x88uLL);
while ( 1 )
{
v3 = *a1;
*((_DWORD *)v2 + 32) = 110;
v4 = accept(v3, (struct sockaddr *)v2 + 1, (socklen_t *)v2 + 32);
*(_DWORD *)v2 = v4;
if ( v4 != -1 )
break;
if ( *_errno_location() != 4 )
{
perror("Erro da funcao accept");
exit(-1);
}
}
return v2;
}

canonical_decompiled_code:
void *__fastcall func1(int *a1)
{
void *v2; // r12
int v3; // edi
int v4; // eax

v2 = malloc(0x88uLL);
while ( 1 )
{
v3 = *a1;
*((_DWORD *)v2 + 32) = 110;
v4 = accept(v3, (struct sockaddr *)v2 + 1, (socklen_t *)v2 + 32);
*(_DWORD *)v2 = v4;
if ( v4 != -1 )
break;
if ( *_errno_location() != 4 )
{
perror("Erro da funcao accept");
exit(-1);
}
}
return v2;
}

original_code:
SocketStream* AceitaLigacaoSocketStream(SocketStream* aberto)
{
 SocketStream* novo;
 novo = (SocketStream*)malloc( sizeof(SocketStream) );
 while(1) {
  novo->addrlen = sizeof(novo->my_addr);
  if(-1==( novo->fd = accept(aberto->fd,
     (struct sockaddr*)&(novo->my_addr),
     (socklen_t*)&(novo->addrlen)) ))
  {
   if( 4 == (*__errno_location ()) )
    continue;
   else{
    perror("Erro da funcao accept");
    exit( -1 );
   }
  }else
   break;
 }
 return novo;
}

canonical_original_code:
struct SocketStreamStr *AceitaLigacaoSocketStream(struct SocketStreamStr *aberto)
{
 struct SocketStreamStr *novo;
 novo = (struct SocketStreamStr *)malloc( sizeof(SocketStream) );
 while(1) {
  novo->addrlen = sizeof(novo->my_addr);
  if(-1==( novo->fd = accept(aberto->fd,
     (struct sockaddr *)&(novo->my_addr),
     (unsigned int *)&(novo->addrlen)) ))
  {
   if( 4 == (*__errno_location ()) )
    continue;
   else{
    perror("Erro da funcao accept");
    exit( -1 );
   }
  }else
   break;
 }
 return novo;
}

variable_types:
aberto
struct SocketStreamStr *

return_type: struct SocketStreamStr { int fd; char *nome; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } my_addr; unsigned int addrlen; } *


EnviaSocketStream

decompiled_code:
__int64 __fastcall EnviaSocketStream(int *a1, const char *a2)
{
int v2; // er13
int v3; // eax
int v4; // eax

if ( !a2 )
return 0LL;
v2 = strlen(a2) + 1;
if ( v2 <= 0 )
return 0LL;
while ( 1 )
{
while ( 1 )
{
v4 = write(*a1, a2, v2);
if ( v4 < 0 )
break;
v2 -= v4;
if ( v2 <= 0 )
return 0LL;
}
v3 = *_errno_location();
if ( v3 == 32 )
break;
if ( v3 != 4 )
{
perror("Erro no write");
exit(-1);
}
}
perror("write() falhou: O socket foi fechado !?");
return 0xFFFFFFFFLL;
}

canonical_decompiled_code:
__int64 __fastcall func2(int *a1, const char *a2)
{
int v2; // er13
int v3; // eax
int v4; // eax

if ( !a2 )
return 0LL;
v2 = strlen(a2) + 1;
if ( v2 <= 0 )
return 0LL;
while ( 1 )
{
while ( 1 )
{
v4 = write(*a1, a2, v2);
if ( v4 < 0 )
break;
v2 -= v4;
if ( v2 <= 0 )
return 0LL;
}
v3 = *_errno_location();
if ( v3 == 32 )
break;
if ( v3 != 4 )
{
perror("Erro no write");
exit(-1);
}
}
perror("write() falhou: O socket foi fechado !?");
return 0xFFFFFFFFLL;
}

original_code:
int EnviaSocketStream(SocketStream* destino, char* msg)
{
 int size, writen;
 if(((void *)0) == msg){
  return 0;
 }
 size = strlen(msg) + 1 ;
 while(size > 0){
  while(1){
   if ( (writen=write(destino->fd, msg, size)) < 0){
    if(32 == (*__errno_location ())){
     perror("write() falhou: O socket foi fechado !?");
     return -1;
    }else if(4 == (*__errno_location ())){
     continue;
    }else{
     perror("Erro no write");
     exit(-1);
    }
   }else{
    break;
   }
  }
  size -= writen;
 }
 return 0;
}

canonical_original_code:
int EnviaSocketStream(struct SocketStreamStr *destino, char *msg)
{
 int size; int writen;
 if(((void *)0) == msg){
  return 0;
 }
 size = strlen(msg) + 1 ;
 while(size > 0){
  while(1){
   if ( (writen=write(destino->fd, msg, size)) < 0){
    if(32 == (*__errno_location ())){
     perror("write() falhou: O socket foi fechado !?");
     return -1;
    }else if(4 == (*__errno_location ())){
     continue;
    }else{
     perror("Erro no write");
     exit(-1);
    }
   }else{
    break;
   }
  }
  size -= writen;
 }
 return 0;
}

variable_types:
msg
char *

variable_types: size int

variable_types: writen int

return_type: int

user_defined_types: struct sockaddr_un { unsigned short sun_family; char sun_path[108]; }


RecebeSocketStream

decompiled_code:
char *__fastcall RecebeSocketStream(int *a1)
{
char *v1; // rax
char *v2; // rbp
int v3; // eax
__int64 v4; // rbx
__int64 v5; // r12
size_t v6; // rax
char v8[72]; // [rsp+0h] [rbp-48h] BYREF

v1 = (char *)malloc(1uLL);
v8[0] = 0;
*v1 = 0;
v2 = v1;
do
{
while ( 1 )
{
v3 = read(*a1, v8, 0x13uLL);
if ( v3 >= 0 )
break;
if ( *_errno_location() != 4 )
{
perror("Erro no read");
exit(-1);
}
}
if ( !v3 )
break;
v4 = v3;
v5 = v3 - 1;
if ( v8[v5] )
v8[v3] = 0;
v6 = strlen(v2);
v2 = (char *)realloc(v2, v4 + v6 + 1);
strcat(v2, v8);
}
while ( v8[v5] );
return v2;
}

canonical_decompiled_code:
char *__fastcall func3(int *a1)
{
char *v1; // rax
char *v2; // rbp
int v3; // eax
__int64 v4; // rbx
__int64 v5; // r12
size_t v6; // rax
char v8[72]; // [rsp+0h] [rbp-48h] BYREF

v1 = (char *)malloc(1uLL);
v8[0] = 0;
*v1 = 0;
v2 = v1;
do
{
while ( 1 )
{
v3 = read(*a1, v8, 0x13uLL);
if ( v3 >= 0 )
break;
if ( *_errno_location() != 4 )
{
perror("Erro no read");
exit(-1);
}
}
if ( !v3 )
break;
v4 = v3;
v5 = v3 - 1;
if ( v8[v5] )
v8[v3] = 0;
v6 = strlen(v2);
v2 = (char *)realloc(v2, v4 + v6 + 1);
strcat(v2, v8);
}
while ( v8[v5] );
return v2;
}

original_code:
char* RecebeSocketStream(SocketStream* destino)
{
 char buf[20];
 char* msg;
 int size;
 size = 0;
 msg = (char*)malloc(sizeof(char));
 msg[0]='\0';
 buf[0]='\0';
 do{
  while( (size = read(destino->fd, buf, 20 -1)) < 0 ){
   if(4 == (*__errno_location ())){
    continue;
   }else{
    perror("Erro no read");
    exit(-1);
   }
  }
  if(size > 0){
   if(buf[size-1] != '\0')
    buf[size]='\0';
  }else{
   break;
  }
  msg = (char*)realloc( msg, sizeof(char)*( strlen(msg) + size + 1) );
  strcat(msg, buf);
 }while(buf[size-1] != '\0');
 return msg;
}

canonical_original_code:
char *RecebeSocketStream(struct SocketStreamStr *destino)
{
 char buf[20];
 char *msg;
 int size;
 size = 0;
 msg = (char *)malloc(sizeof(char));
 msg[0]='\0';
 buf[0]='\0';
 do{
  while( (size = read(destino->fd, buf, 20 -1)) < 0 ){
   if(4 == (*__errno_location ())){
    continue;
   }else{
    perror("Erro no read");
    exit(-1);
   }
  }
  if(size > 0){
   if(buf[size-1] != '\0')
    buf[size]='\0';
  }else{
   break;
  }
  msg = (char *)realloc( msg, sizeof(char)*( strlen(msg) + size + 1) );
  strcat(msg, buf);
 }while(buf[size-1] != '\0');
 return msg;
}

variable_types:
buf
char [20]

return_type: char *


FechaSocketStream

decompiled_code:
void __fastcall FechaSocketStream(void *ptr)
{
const char *v2; // rdi

if ( close(*(_DWORD *)ptr) < 0 )
perror("Erro no close");
v2 = (const char *)*((_QWORD *)ptr + 1);
if ( v2 )
{
unlink(v2);
free(*((void **)ptr + 1));
}
free(ptr);
}

canonical_decompiled_code:
void __fastcall func4(void *ptr)
{
const char *v2; // rdi

if ( close(*(_DWORD *)ptr) < 0 )
perror("Erro no close");
v2 = (const char *)*((_QWORD *)ptr + 1);
if ( v2 )
{
unlink(v2);
free(*((void **)ptr + 1));
}
free(ptr);
}

original_code:
void FechaSocketStream(SocketStream* sock){
 if(close(sock->fd) < 0){
  perror("Erro no close");
 }
 if(((void *)0) != sock->nome){
  unlink(sock->nome);
  free(sock->nome);
 }
 free(sock);
 return;
}

canonical_original_code:
void FechaSocketStream(struct SocketStreamStr *sock){
 if(close(sock->fd) < 0){
  perror("Erro no close");
 }
 if(((void *)0) != sock->nome){
  unlink(sock->nome);
  free(sock->nome);
 }
 free(sock);
 return;
}

return_type: void


CriaStock

decompiled_code:
__int64 CriaStock()
{
int v0; // eax
int v1; // ebp
__int64 result; // rax
__int64 i; // rbx
unsigned int v4; // eax

v0 = semget(123, *(&stock + 8), 950);
if ( v0 < 0 )
{
fwrite("Erro em CriaStock: semget().\n", 1uLL, 0x1DuLL, stderr);
perror("Erro em CriaStock: semget().");
exit(-1);
}
v1 = v0;
result = (unsigned int)*(&stock + 8);
for ( i = 0LL; (int)result > (int)i; ++i )
{
v4 = atoi((const char *)(*((_QWORD *)&stock + 1) + 25 * i + 20));
if ( semctl(v1, i, 16, v4) < 0 )
{
fwrite("Erro em CriaStock: semctl().\n", 1uLL, 0x1DuLL, stderr);
perror("Erro em CriaStock: semctl().");
exit(-1);
}
result = (unsigned int)*(&stock + 8);
}
*(&stock + 9) = result;
return result;
}

canonical_decompiled_code:
__int64 func0()
{
int v0; // eax
int v1; // ebp
__int64 result; // rax
__int64 i; // rbx
unsigned int v4; // eax

v0 = semget(123, *(&stock + 8), 950);
if ( v0 < 0 )
{
fwrite("Erro em CriaStock: semget().\n", 1uLL, 0x1DuLL, stderr);
perror("Erro em CriaStock: semget().");
exit(-1);
}
v1 = v0;
result = (unsigned int)*(&stock + 8);
for ( i = 0LL; (int)result > (int)i; ++i )
{
v4 = atoi((const char *)(*((_QWORD *)&stock + 1) + 25 * i + 20));
if ( semctl(v1, i, 16, v4) < 0 )
{
fwrite("Erro em CriaStock: semctl().\n", 1uLL, 0x1DuLL, stderr);
perror("Erro em CriaStock: semctl().");
exit(-1);
}
result = (unsigned int)*(&stock + 8);
}
*(&stock + 9) = result;
return result;
}

original_code:
void CriaStock()
{
 int id;
 int i;
 struct{
  int val;
 }arg;
 if( ( id = semget( 123, stock.n_prod, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em CriaStock: semget().\n" );
  perror("Erro em CriaStock: semget().");
  exit( -1 );
 }
 for( i = 0 ; i < stock.n_prod ; i++ )
 {
  arg.val = atoi( stock.inicio[i].quantidade );
  if( semctl( id, i, 16,arg ) < 0 ) {
   fprintf( stderr, "Erro em CriaStock: semctl().\n" );
   perror("Erro em CriaStock: semctl().");
   exit( -1 );
  }
 }
 stock.n_sem = stock.n_prod;
 return;
}

canonical_original_code:
void CriaStock()
{
 int id;
 int i;
 struct { int val; } arg;
 if( ( id = semget( 123, stock.n_prod, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em CriaStock: semget().\n" );
  perror("Erro em CriaStock: semget().");
  exit( -1 );
 }
 for( i = 0 ; i < stock.n_prod ; i++ )
 {
  arg.val = atoi( stock.inicio[i].quantidade );
  if( semctl( id, i, 16,arg ) < 0 ) {
   fprintf( stderr, "Erro em CriaStock: semctl().\n" );
   perror("Erro em CriaStock: semctl().");
   exit( -1 );
  }
 }
 stock.n_sem = stock.n_prod;
 return;
}

variable_types: id int

variable_types: i int

variable_types:
arg
struct { int val; }


DestroiStock

decompiled_code:
int DestroiStock()
{
int v0; // eax
int v1; // ebp
__int64 i; // rbx
__int64 v3; // rdx
__int64 v4; // rax
int result; // eax

v0 = semget(123, 0, 0);
if ( v0 < 0 )
{
fwrite("Erro em DestroiSemaforo: semget().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
v1 = v0;
for ( i = 0LL; *(&stock + 9) > (int)i; ++i )
{
v3 = (unsigned int)semctl(v1, i, 12);
v4 = 5 * i;
sprintf((char *)(*((_QWORD *)&stock + 1) + 5 * v4 + 20), "%4d", v3);
}
result = semctl(v1, 0, 0);
if ( result < 0 )
{
fwrite("Erro em DestroiSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int func1()
{
int v0; // eax
int v1; // ebp
__int64 i; // rbx
__int64 v3; // rdx
__int64 v4; // rax
int result; // eax

v0 = semget(123, 0, 0);
if ( v0 < 0 )
{
fwrite("Erro em DestroiSemaforo: semget().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
v1 = v0;
for ( i = 0LL; *(&stock + 9) > (int)i; ++i )
{
v3 = (unsigned int)semctl(v1, i, 12);
v4 = 5 * i;
sprintf((char *)(*((_QWORD *)&stock + 1) + 5 * v4 + 20), "%4d", v3);
}
result = semctl(v1, 0, 0);
if ( result < 0 )
{
fwrite("Erro em DestroiSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void DestroiStock()
{
 int id, i;
 if( ( id = semget( 123, 0, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semget().\n" );
  exit( -1 );
 }
 for( i = 0 ; i < stock.n_sem ; i++ )
 {
  sprintf( stock.inicio[i].quantidade, "%4d", semctl(id, i, 12) );
 }
 if( semctl( id, 0, 0) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semctl().\n" );
  exit( -1 );
 }
 return;
}

canonical_original_code:
void DestroiStock()
{
 int id; int i;
 if( ( id = semget( 123, 0, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semget().\n" );
  exit( -1 );
 }
 for( i = 0 ; i < stock.n_sem ; i++ )
 {
  sprintf( stock.inicio[i].quantidade, "%4d", semctl(id, i, 12) );
 }
 if( semctl( id, 0, 0) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semctl().\n" );
  exit( -1 );
 }
 return;
}


DevolveValorStock

decompiled_code:
int __fastcall DevolveValorStock(int semnum)
{
int v1; // eax
int result; // eax

v1 = semget(123, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em DevolveValorStock: semget().\n", 1uLL, 0x25uLL, stderr);
exit(-1);
}
result = semctl(v1, semnum, 12);
if ( result < 0 )
{
fwrite("Erro em DevolveValorStock: semctl().\n", 1uLL, 0x25uLL, stderr);
perror("Erro em DevolveValorStock: semctl().");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func2(int semnum)
{
int v1; // eax
int result; // eax

v1 = semget(123, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em DevolveValorStock: semget().\n", 1uLL, 0x25uLL, stderr);
exit(-1);
}
result = semctl(v1, semnum, 12);
if ( result < 0 )
{
fwrite("Erro em DevolveValorStock: semctl().\n", 1uLL, 0x25uLL, stderr);
perror("Erro em DevolveValorStock: semctl().");
exit(-1);
}
return result;
}

original_code:
int DevolveValorStock(int indice)
{
 int id;
        int val;
 if( ( id = semget( 123, 1, 0) ) < 0 ) {
  fprintf( stderr, "Erro em DevolveValorStock: semget().\n" );
  exit( -1 );
 }
 if( ( val = semctl( id, indice, 12 ) ) < 0 ) {
  fprintf( stderr, "Erro em DevolveValorStock: semctl().\n" );
  perror("Erro em DevolveValorStock: semctl().");
  exit( -1 );
 }
 return val;
}

variable_types: indice int

variable_types: val int


AdicionaProdMemMap

decompiled_code:
char *__fastcall AdicionaProdMemMap(char *src, char *a2)
{
__int64 v2; // r14
char *v4; // rdi
char *v5; // rax
__int64 v6; // rbx
unsigned __int64 v7; // r15
__int64 v8; // rax
void *v9; // rdi
unsigned __int64 v10; // rtt
__int64 v11; // rbx
__off_t v12; // r14
char *v13; // rax
char *result; // rax

v2 = *((_QWORD *)&stock + 3);
v4 = (char *)*((_QWORD *)&stock + 2);
v5 = &v4[-*((_QWORD *)&stock + 1)];
if ( (unsigned __int64)(v2 - (_QWORD)v5) <= 0x18 )
{
v6 = (__int64)&v5[-v2 + 25];
v7 = sysconf(30);
v8 = sysconf(30);
v9 = (void *)*((_QWORD *)&stock + 1);
v10 = v6;
v11 = *((_QWORD *)&stock + 2) - (_QWORD)v9;
v12 = v8 * (v10 / v7 + 1) + v2;
munmap(v9, *((_QWORD *)&stock + 3));
LODWORD(v9) = stock;
*((_QWORD *)&stock + 3) = v12;
if ( ftruncate((int)v9, v12) < 0 )
_assert_fail("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 0xA9u, "AdicionaProdMemMap");
v13 = (char *)mmap(0LL, *((_QWORD *)&stock + 3), 3, 1, stock, 0LL);
*((_QWORD *)&stock + 1) = v13;
if ( v13 == (char *)-1LL )
_assert_fail(
"( stock.inicio= mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED",
"stock.c",
0xABu,
"AdicionaProdMemMap");
v4 = &v13[v11];
*((_QWORD *)&stock + 2) = &v13[v11];
}
strncpy(v4, src, 0x14uLL);
result = strncpy((char *)(*((_QWORD *)&stock + 2) + 20LL), a2, 5uLL);
*((_QWORD *)&stock + 2) += 25LL;
++*(&stock + 8);
return result;
}

canonical_decompiled_code:
char *__fastcall func3(char *src, char *a2)
{
__int64 v2; // r14
char *v4; // rdi
char *v5; // rax
__int64 v6; // rbx
unsigned __int64 v7; // r15
__int64 v8; // rax
void *v9; // rdi
unsigned __int64 v10; // rtt
__int64 v11; // rbx
__off_t v12; // r14
char *v13; // rax
char *result; // rax

v2 = *((_QWORD *)&stock + 3);
v4 = (char *)*((_QWORD *)&stock + 2);
v5 = &v4[-*((_QWORD *)&stock + 1)];
if ( (unsigned __int64)(v2 - (_QWORD)v5) <= 0x18 )
{
v6 = (__int64)&v5[-v2 + 25];
v7 = sysconf(30);
v8 = sysconf(30);
v9 = (void *)*((_QWORD *)&stock + 1);
v10 = v6;
v11 = *((_QWORD *)&stock + 2) - (_QWORD)v9;
v12 = v8 * (v10 / v7 + 1) + v2;
munmap(v9, *((_QWORD *)&stock + 3));
LODWORD(v9) = stock;
*((_QWORD *)&stock + 3) = v12;
if ( ftruncate((int)v9, v12) < 0 )
_assert_fail("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 0xA9u, "AdicionaProdMemMap");
v13 = (char *)mmap(0LL, *((_QWORD *)&stock + 3), 3, 1, stock, 0LL);
*((_QWORD *)&stock + 1) = v13;
if ( v13 == (char *)-1LL )
_assert_fail(
"( stock.inicio= mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED",
"stock.c",
0xABu,
"AdicionaProdMemMap");
v4 = &v13[v11];
*((_QWORD *)&stock + 2) = &v13[v11];
}
strncpy(v4, src, 0x14uLL);
result = strncpy((char *)(*((_QWORD *)&stock + 2) + 20LL), a2, 5uLL);
*((_QWORD *)&stock + 2) += 25LL;
++*(&stock + 8);
return result;
}

original_code:
void AdicionaProdMemMap(char* nome, char* quantidade)
{
 size_t novadim;
 size_t fim;
 int nbytes;
 size_t nleft;
 nleft = stock.dim - (stock.fim-stock.inicio)*sizeof(Produto);
 nbytes= sizeof(Produto);
 if(nleft < nbytes)
 {
  novadim = stock.dim + (1 + (nbytes-nleft)/sysconf(_SC_PAGESIZE))*sysconf(_SC_PAGESIZE);
  fim = (stock.fim)-(stock.inicio);
  munmap(stock.inicio, stock.dim);
  stock.dim = novadim;
  ((void) sizeof ((ftruncate( stock.fd, stock.dim ) >= 0) ? 1 : 0), __extension__ ({ if (ftruncate( stock.fd, stock.dim ) >= 0) ; else __assert_fail ("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 169, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((( stock.inicio= mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ? 1 : 0), __extension__ ({ if (( stock.inicio= mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ; else __assert_fail ("( stock.inicio= mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED", "stock.c", 171, __extension__ __PRETTY_FUNCTION__); }));
  stock.fim= &( stock.inicio[fim] );
 }
 strncpy( stock.fim->nome, nome, 20 );
 strncpy( stock.fim->quantidade, quantidade, 5 );
 stock.fim = &( stock.fim[1] );
 stock.n_prod++;
 return;
}

canonical_original_code:
void AdicionaProdMemMap(char *nome, char *quantidade)
{
 unsigned long novadim;
 unsigned long fim;
 int nbytes;
 unsigned long nleft;
 nleft = stock.dim - (stock.fim-stock.inicio)*sizeof(Produto);
 nbytes= sizeof(Produto);
 if(nleft < nbytes)
 {
  novadim = stock.dim + (1 + (nbytes-nleft)/sysconf(_SC_PAGESIZE))*sysconf(_SC_PAGESIZE);
  fim = (stock.fim)-(stock.inicio);
  munmap(stock.inicio, stock.dim);
  stock.dim = novadim;
  ((void) sizeof ((ftruncate( stock.fd, stock.dim ) >= 0) ? 1 : 0), __extension__ ({ if (ftruncate( stock.fd, stock.dim ) >= 0) ; else __assert_fail ("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 169, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((( stock.inicio= mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ? 1 : 0), __extension__ ({ if (( stock.inicio= mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ; else __assert_fail ("( stock.inicio= mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED", "stock.c", 171, __extension__ __PRETTY_FUNCTION__); }));
  stock.fim= &( stock.inicio[fim] );
 }
 strncpy( stock.fim->nome, nome, 20 );
 strncpy( stock.fim->quantidade, quantidade, 5 );
 stock.fim = &( stock.fim[1] );
 stock.n_prod++;
 return;
}

variable_types:
quantidade
char *

variable_types:
novadim
unsigned long

variable_types:
fim
unsigned long

variable_types: nbytes int

variable_types:
nleft
unsigned long


GetIndiceStock

decompiled_code:
__int64 __fastcall GetIndiceStock(char *s2)
{
int v1; // ebp
__int64 v2; // r13
unsigned int v3; // er12

v1 = *(&stock + 8);
if ( v1 <= 0 )
return 0xFFFFFFFFLL;
v2 = *((_QWORD *)&stock + 1);
v3 = 0;
while ( strncmp((const char *)(v2 + 25LL * (__int16)v3), s2, 0x14uLL) )
{
if ( (__int16)++v3 >= v1 )
return 0xFFFFFFFFLL;
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func4(char *s2)
{
int v1; // ebp
__int64 v2; // r13
unsigned int v3; // er12

v1 = *(&stock + 8);
if ( v1 <= 0 )
return 0xFFFFFFFFLL;
v2 = *((_QWORD *)&stock + 1);
v3 = 0;
while ( strncmp((const char *)(v2 + 25LL * (__int16)v3), s2, 0x14uLL) )
{
if ( (__int16)++v3 >= v1 )
return 0xFFFFFFFFLL;
}
return v3;
}

original_code:
short GetIndiceStock(char* nome)
{
 short i;
 for(i=0 ; i < stock.n_prod ; i++)
 {
  if( strncmp( stock.inicio[i].nome, nome, 20 ) == 0)
  {
    return i;
  }
 }
 return -1;
}

canonical_original_code:
short GetIndiceStock(char *nome)
{
 short i;
 for(i=0 ; i < stock.n_prod ; i++)
 {
  if( strncmp( stock.inicio[i].nome, nome, 20 ) == 0)
  {
    return i;
  }
 }
 return -1;
}

variable_types:
nome
char *

variable_types: i short

return_type: short


AssinalaStock

decompiled_code:
void __fastcall AssinalaStock(char *s2, int a2)
{
int v3; // eax
int v4; // er14
struct sembuf *v5; // rax
struct sembuf *v6; // r13
struct sembuf *v7; // rbx
struct sembuf *v8; // r12
unsigned __int16 v9; // ax
const char *v10; // rdi

v3 = semget(123, 0, 0);
if ( v3 < 0 )
{
fwrite("Erro em AssinalaStock: semget().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
v4 = v3;
v5 = (struct sembuf *)malloc(6LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = &v5[a2];
do
{
++v7;
v9 = GetIndiceStock(s2);
v10 = s2 + 20;
s2 += 25;
v7[-1].sem_num = v9;
v7[-1].sem_op = atoi(v10);
v7[-1].sem_flg = 0;
}
while ( v7 != v8 );
}
if ( semop(v4, v6, a2) < 0 )
{
fwrite("Erro em AssinalaStock: semop().\n", 1uLL, 0x20uLL, stderr);
exit(-1);
}
free(v6);
}

canonical_decompiled_code:
void __fastcall func5(char *s2, int a2)
{
int v3; // eax
int v4; // er14
struct sembuf *v5; // rax
struct sembuf *v6; // r13
struct sembuf *v7; // rbx
struct sembuf *v8; // r12
unsigned __int16 v9; // ax
const char *v10; // rdi

v3 = semget(123, 0, 0);
if ( v3 < 0 )
{
fwrite("Erro em AssinalaStock: semget().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
v4 = v3;
v5 = (struct sembuf *)malloc(6LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = &v5[a2];
do
{
++v7;
v9 = func4(s2);
v10 = s2 + 20;
s2 += 25;
v7[-1].sem_num = v9;
v7[-1].sem_op = atoi(v10);
v7[-1].sem_flg = 0;
}
while ( v7 != v8 );
}
if ( semop(v4, v6, a2) < 0 )
{
fwrite("Erro em AssinalaStock: semop().\n", 1uLL, 0x20uLL, stderr);
exit(-1);
}
free(v6);
}

original_code:
void AssinalaStock(Produto* produtos, int n_prod)
{
 struct sembuf* op;
 int id, i;
 if( ( id = semget( 123, 0, 0) ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaStock: semget().\n" );
  exit( -1 );
 }
 op = (struct sembuf*)malloc(sizeof(struct sembuf)*n_prod);
 for( i = 0 ; i < n_prod ; i++ ) {
  op[i].sem_num = GetIndiceStock( produtos[i].nome );
  op[i].sem_op = atoi( produtos[i].quantidade );
  op[i].sem_flg = 0;
 }
 if( semop( id, op, n_prod ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaStock: semop().\n" );
  exit( -1 );
 }
 free(op);
 return;
}

canonical_original_code:
void AssinalaStock(struct ProdutoStr *produtos, int n_prod)
{
 struct sembuf *op;
 int id; int i;
 if( ( id = semget( 123, 0, 0) ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaStock: semget().\n" );
  exit( -1 );
 }
 op = (struct sembuf *)malloc(sizeof(struct sembuf)*n_prod);
 for( i = 0 ; i < n_prod ; i++ ) {
  op[i].sem_num = GetIndiceStock( produtos[i].nome );
  op[i].sem_op = atoi( produtos[i].quantidade );
  op[i].sem_flg = 0;
 }
 if( semop( id, op, n_prod ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaStock: semop().\n" );
  exit( -1 );
 }
 free(op);
 return;
}

variable_types: struct ProdutoStr { char nome[20]; char quantidade[5]; } *

variable_types: struct sembuf { unsigned short sem_num; short sem_op; short sem_flg; } *


EsperaStock

decompiled_code:
int __fastcall EsperaStock(char *s2, int a2)
{
int v3; // eax
int v4; // er14
struct sembuf *v5; // rax
struct sembuf *v6; // r13
struct sembuf *v7; // rbx
struct sembuf *v8; // r12
unsigned __int16 v9; // ax
const char *v10; // rdi
int result; // eax

v3 = semget(123, 0, 0);
if ( v3 < 0 )
{
fwrite("Erro em EsperaSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
v4 = v3;
v5 = (struct sembuf *)malloc(6LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = &v5[a2];
do
{
++v7;
v9 = GetIndiceStock(s2);
v10 = s2 + 20;
s2 += 25;
v7[-1].sem_num = v9;
v7[-1].sem_op = -(__int16)atoi(v10);
v7[-1].sem_flg = 0;
}
while ( v7 != v8 );
}
result = semop(v4, v6, a2);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforo: semop().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func6(char *s2, int a2)
{
int v3; // eax
int v4; // er14
struct sembuf *v5; // rax
struct sembuf *v6; // r13
struct sembuf *v7; // rbx
struct sembuf *v8; // r12
unsigned __int16 v9; // ax
const char *v10; // rdi
int result; // eax

v3 = semget(123, 0, 0);
if ( v3 < 0 )
{
fwrite("Erro em EsperaSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
v4 = v3;
v5 = (struct sembuf *)malloc(6LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = &v5[a2];
do
{
++v7;
v9 = func4(s2);
v10 = s2 + 20;
s2 += 25;
v7[-1].sem_num = v9;
v7[-1].sem_op = -(__int16)atoi(v10);
v7[-1].sem_flg = 0;
}
while ( v7 != v8 );
}
result = semop(v4, v6, a2);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforo: semop().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void EsperaStock(Produto* produtos, int n_prod)
{
 struct sembuf* op;
 int id, i;
 if( ( id = semget( 123, 0, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semget().\n" );
  exit( -1 );
 }
 op = (struct sembuf*)malloc(sizeof(struct sembuf)*n_prod);
 for( i = 0 ; i < n_prod ; i++ ) {
  op[i].sem_num = GetIndiceStock( produtos[i].nome );
  op[i].sem_op = - atoi( produtos[i].quantidade );
  op[i].sem_flg = 0;
 }
 if( semop( id, op, n_prod ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semop().\n" );
  exit( -1 );
 }
 return;
}

canonical_original_code:
void EsperaStock(struct ProdutoStr *produtos, int n_prod)
{
 struct sembuf *op;
 int id; int i;
 if( ( id = semget( 123, 0, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semget().\n" );
  exit( -1 );
 }
 op = (struct sembuf *)malloc(sizeof(struct sembuf)*n_prod);
 for( i = 0 ; i < n_prod ; i++ ) {
  op[i].sem_num = GetIndiceStock( produtos[i].nome );
  op[i].sem_op = - atoi( produtos[i].quantidade );
  op[i].sem_flg = 0;
 }
 if( semop( id, op, n_prod ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semop().\n" );
  exit( -1 );
 }
 return;
}

user_defined_types: struct sembuf { unsigned short sem_num; short sem_op; short sem_flg; }

user_defined_types: struct ProdutoStr { char nome[20]; char quantidade[5]; }


MapeiaFicheiroStock

decompiled_code:
unsigned __int64 __fastcall MapeiaFicheiroStock(const char *a1)
{
int v1; // eax
__off_t v2; // rbx
__int64 v3; // rbp
__int64 v4; // rax
int v5; // edi
__off_t v6; // rsi
char *v7; // rax
char *v8; // rcx
unsigned __int64 result; // rax
struct stat v10; // [rsp+0h] [rbp-A8h] BYREF

v1 = open(a1, 66, 438LL);
stock = v1;
if ( v1 < 0 )
_assert_fail("( stock.fd = open(nomefiche, O_RDWR | O_CREAT, 0666)) >=0", "stock.c", 0xD2u, "MapeiaFicheiroStock");
fstat(v1, &v10);
v2 = v10.st_size;
v3 = sysconf(30);
v4 = sysconf(30);
v5 = stock;
v6 = v4 * (v2 / v3 + 1);
*((_QWORD *)&stock + 3) = v6;
if ( ftruncate(v5, v6) < 0 )
_assert_fail("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 0xE6u, "MapeiaFicheiroStock");
v7 = (char *)mmap(0LL, *((_QWORD *)&stock + 3), 3, 1, stock, 0LL);
*((_QWORD *)&stock + 1) = v7;
v8 = v7;
if ( v7 == (char *)-1LL )
_assert_fail(
"( stock.inicio = mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED",
"stock.c",
0xE9u,
"MapeiaFicheiroStock");
result = 25 * (v10.st_size / 0x19uLL);
*((_QWORD *)&stock + 2) = &v8[result];
return result;
}

canonical_decompiled_code:
unsigned __int64 __fastcall func7(const char *a1)
{
int v1; // eax
__off_t v2; // rbx
__int64 v3; // rbp
__int64 v4; // rax
int v5; // edi
__off_t v6; // rsi
char *v7; // rax
char *v8; // rcx
unsigned __int64 result; // rax
struct stat v10; // [rsp+0h] [rbp-A8h] BYREF

v1 = open(a1, 66, 438LL);
stock = v1;
if ( v1 < 0 )
_assert_fail("( stock.fd = open(nomefiche, O_RDWR | O_CREAT, 0666)) >=0", "stock.c", 0xD2u, "MapeiaFicheiroStock");
fstat(v1, &v10);
v2 = v10.st_size;
v3 = sysconf(30);
v4 = sysconf(30);
v5 = stock;
v6 = v4 * (v2 / v3 + 1);
*((_QWORD *)&stock + 3) = v6;
if ( ftruncate(v5, v6) < 0 )
_assert_fail("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 0xE6u, "MapeiaFicheiroStock");
v7 = (char *)mmap(0LL, *((_QWORD *)&stock + 3), 3, 1, stock, 0LL);
*((_QWORD *)&stock + 1) = v7;
v8 = v7;
if ( v7 == (char *)-1LL )
_assert_fail(
"( stock.inicio = mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED",
"stock.c",
0xE9u,
"MapeiaFicheiroStock");
result = 25 * (v10.st_size / 0x19uLL);
*((_QWORD *)&stock + 2) = &v8[result];
return result;
}

original_code:
void MapeiaFicheiroStock(char* nomefiche)
{
 struct stat infofich;
 ((void) sizeof ((( stock.fd = open(nomefiche, 02 | 0100, 0666)) >=0) ? 1 : 0), __extension__ ({ if (( stock.fd = open(nomefiche, 02 | 0100, 0666)) >=0) ; else __assert_fail ("( stock.fd = open(nomefiche, O_RDWR | O_CREAT, 0666)) >=0", "stock.c", 210, __extension__ __PRETTY_FUNCTION__); }));
 fstat( stock.fd, &infofich);
 stock.dim = (size_t)(1+infofich.st_size/sysconf(_SC_PAGESIZE))*sysconf(_SC_PAGESIZE);
 ((void) sizeof ((ftruncate( stock.fd, stock.dim ) >= 0) ? 1 : 0), __extension__ ({ if (ftruncate( stock.fd, stock.dim ) >= 0) ; else __assert_fail ("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 230, __extension__ __PRETTY_FUNCTION__); }));
 ((void) sizeof ((( stock.inicio = mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ? 1 : 0), __extension__ ({ if (( stock.inicio = mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ; else __assert_fail ("( stock.inicio = mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED", "stock.c", 233, __extension__ __PRETTY_FUNCTION__); }));
 stock.fim = &( stock.inicio[ infofich.st_size/sizeof(Produto) ] );
 return;
}

canonical_original_code:
void MapeiaFicheiroStock(char *nomefiche)
{
 struct stat infofich;
 ((void) sizeof ((( stock.fd = open(nomefiche, 02 | 0100, 0666)) >=0) ? 1 : 0), __extension__ ({ if (( stock.fd = open(nomefiche, 02 | 0100, 0666)) >=0) ; else __assert_fail ("( stock.fd = open(nomefiche, O_RDWR | O_CREAT, 0666)) >=0", "stock.c", 210, __extension__ __PRETTY_FUNCTION__); }));
 fstat( stock.fd, &infofich);
 stock.dim = (unsigned long)(1+infofich.st_size/sysconf(_SC_PAGESIZE))*sysconf(_SC_PAGESIZE);
 ((void) sizeof ((ftruncate( stock.fd, stock.dim ) >= 0) ? 1 : 0), __extension__ ({ if (ftruncate( stock.fd, stock.dim ) >= 0) ; else __assert_fail ("ftruncate( stock.fd, stock.dim ) >= 0", "stock.c", 230, __extension__ __PRETTY_FUNCTION__); }));
 ((void) sizeof ((( stock.inicio = mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ? 1 : 0), __extension__ ({ if (( stock.inicio = mmap( ((void *)0), stock.dim, 0x1 | 0x2, 0x01, stock.fd, 0 ) ) != ((void *) -1)) ; else __assert_fail ("( stock.inicio = mmap( NULL, stock.dim, PROT_READ | PROT_WRITE, MAP_SHARED, stock.fd, 0 ) ) != MAP_FAILED", "stock.c", 233, __extension__ __PRETTY_FUNCTION__); }));
 stock.fim = &( stock.inicio[ infofich.st_size/sizeof(Produto) ] );
 return;
}

variable_types:
nomefiche
char *

variable_types: struct stat { unsigned long st_dev; unsigned long st_ino; unsigned long st_nlink; unsigned int st_mode; unsigned int st_uid; unsigned int st_gid; int __pad0; unsigned long st_rdev; long st_size; long st_blksize; long st_blocks; struct timespec { long tv_sec; long tv_nsec; } st_atim; struct timespec st_mtim; struct timespec st_ctim; long __glibc_reserved[3]; }

user_defined_types: struct stat { unsigned long st_dev; unsigned long st_ino; unsigned long st_nlink; unsigned int st_mode; unsigned int st_uid; unsigned int st_gid; int __pad0; unsigned long st_rdev; long st_size; long st_blksize; long st_blocks; struct timespec st_atim; struct timespec st_mtim; struct timespec st_ctim; long __glibc_reserved[3]; }


DesMapeiaFicheiroStock

decompiled_code:
int DesMapeiaFicheiroStock()
{
munmap(*((void **)&stock + 1), *((_QWORD *)&stock + 3));
ftruncate(stock, *((_QWORD *)&stock + 2) - *((_QWORD *)&stock + 1));
return close(stock);
}

canonical_decompiled_code:
int func8()
{
munmap(*((void **)&stock + 1), *((_QWORD *)&stock + 3));
ftruncate(stock, *((_QWORD *)&stock + 2) - *((_QWORD *)&stock + 1));
return close(stock);
}

original_code:
void DesMapeiaFicheiroStock()
{
 munmap( stock.inicio, stock.dim);
 ftruncate( stock.fd, (stock.fim-stock.inicio)*sizeof(Produto));
 close( stock.fd );
 return;
}


CriaSemaforo

decompiled_code:
int __fastcall CriaSemaforo(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 950);
if ( v1 < 0 )
{
fwrite("Erro em CriaSemaforo: semget().\n", 1uLL, 0x20uLL, stderr);
perror("Erro em CriaSemaforo: semget().");
exit(-1);
}
result = semctl(v1, 0, 16, 0LL);
if ( result < 0 )
{
fwrite("Erro em CriaSemaforo: semctl().\n", 1uLL, 0x20uLL, stderr);
perror("Erro em CriaSemaforo: semctl().");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func0(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 950);
if ( v1 < 0 )
{
fwrite("Erro em CriaSemaforo: semget().\n", 1uLL, 0x20uLL, stderr);
perror("Erro em CriaSemaforo: semget().");
exit(-1);
}
result = semctl(v1, 0, 16, 0LL);
if ( result < 0 )
{
fwrite("Erro em CriaSemaforo: semctl().\n", 1uLL, 0x20uLL, stderr);
perror("Erro em CriaSemaforo: semctl().");
exit(-1);
}
return result;
}

original_code:
void CriaSemaforo(int key)
{
 int id;
 struct{
  int val;
 }arg;
 if( ( id = semget( key, 1, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em CriaSemaforo: semget().\n" );
  perror("Erro em CriaSemaforo: semget().");
  exit( -1 );
 }
 arg.val = 0;
 if( semctl( id, 0, 16,arg ) < 0 ) {
  fprintf( stderr, "Erro em CriaSemaforo: semctl().\n" );
  perror("Erro em CriaSemaforo: semctl().");
  exit( -1 );
 }
 return;
}

canonical_original_code:
void CriaSemaforo(int key)
{
 int id;
 struct { int val; } arg;
 if( ( id = semget( key, 1, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em CriaSemaforo: semget().\n" );
  perror("Erro em CriaSemaforo: semget().");
  exit( -1 );
 }
 arg.val = 0;
 if( semctl( id, 0, 16,arg ) < 0 ) {
  fprintf( stderr, "Erro em CriaSemaforo: semctl().\n" );
  perror("Erro em CriaSemaforo: semctl().");
  exit( -1 );
 }
 return;
}

variable_types: key int


DefineSemaforo

decompiled_code:
int __fastcall DefineSemaforo(key_t a1, unsigned int a2)
{
int v2; // eax
int result; // eax

v2 = semget(a1, 1, 950);
if ( v2 < 0 )
{
fwrite("Erro em DefineSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
perror("Erro em DefineSemaforo: semget().");
exit(-1);
}
result = semctl(v2, 0, 16, a2);
if ( result < 0 )
{
fwrite("Erro em DefineSemaforo: semctl().\n", 1uLL, 0x22uLL, stderr);
perror("Erro em DefineSemaforo: semctl().");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func1(key_t a1, unsigned int a2)
{
int v2; // eax
int result; // eax

v2 = semget(a1, 1, 950);
if ( v2 < 0 )
{
fwrite("Erro em DefineSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
perror("Erro em DefineSemaforo: semget().");
exit(-1);
}
result = semctl(v2, 0, 16, a2);
if ( result < 0 )
{
fwrite("Erro em DefineSemaforo: semctl().\n", 1uLL, 0x22uLL, stderr);
perror("Erro em DefineSemaforo: semctl().");
exit(-1);
}
return result;
}

original_code:
void DefineSemaforo(int key, int valor)
{
 int id;
 struct{
  int val;
 }arg;
 if( ( id = semget( key, 1, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em DefineSemaforo: semget().\n" );
  perror("Erro em DefineSemaforo: semget().");
  exit( -1 );
 }
 arg.val = valor;
 if( semctl( id, 0, 16,arg ) < 0 ) {
  fprintf( stderr, "Erro em DefineSemaforo: semctl().\n" );
  perror("Erro em DefineSemaforo: semctl().");
  exit( -1 );
 }
 return;
}

canonical_original_code:
void DefineSemaforo(int key, int valor)
{
 int id;
 struct { int val; } arg;
 if( ( id = semget( key, 1, 0666|01000 ) ) < 0 ) {
  fprintf( stderr, "Erro em DefineSemaforo: semget().\n" );
  perror("Erro em DefineSemaforo: semget().");
  exit( -1 );
 }
 arg.val = valor;
 if( semctl( id, 0, 16,arg ) < 0 ) {
  fprintf( stderr, "Erro em DefineSemaforo: semctl().\n" );
  perror("Erro em DefineSemaforo: semctl().");
  exit( -1 );
 }
 return;
}

variable_types: valor int

variable_types: id int


DevolveSemaforo

decompiled_code:
int __fastcall DevolveSemaforo(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em Devolve Semaforo: semget().\n", 1uLL, 0x24uLL, stderr);
exit(-1);
}
result = semctl(v1, 0, 12);
if ( result < 0 )
{
fwrite("Erro em DevolveSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
perror("Erro em DevolveSemaforo: semctl().");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func2(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em Devolve Semaforo: semget().\n", 1uLL, 0x24uLL, stderr);
exit(-1);
}
result = semctl(v1, 0, 12);
if ( result < 0 )
{
fwrite("Erro em DevolveSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
perror("Erro em DevolveSemaforo: semctl().");
exit(-1);
}
return result;
}

original_code:
int DevolveSemaforo(int key)
{
 int id;
 int val;
 if( ( id = semget( key, 1, 0) ) < 0 ) {
  fprintf( stderr, "Erro em Devolve Semaforo: semget().\n" );
  exit( -1 );
 }
 if( ( val = semctl( id, 0, 12 ) ) < 0 ) {
  fprintf( stderr, "Erro em DevolveSemaforo: semctl().\n" );
  perror("Erro em DevolveSemaforo: semctl().");
  exit( -1 );
 }
 return val;
}


AssinalaSemaforo

decompiled_code:
int __fastcall AssinalaSemaforo(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em AssinalaSemaforo: semget().\n", 1uLL, 0x24uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = 0x10000;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em AssinalaSemaforo: semop().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func3(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em AssinalaSemaforo: semget().\n", 1uLL, 0x24uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = 0x10000;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em AssinalaSemaforo: semop().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void AssinalaSemaforo(int key)
{
 struct sembuf op;
 int id;
 if( ( id = semget( key, 1, 0) ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaSemaforo: semget().\n" );
  exit( -1 );
 }
 op.sem_num = 0;
 op.sem_op = +1;
 op.sem_flg = 0;
 if( semop( id, &op, 1 ) < 0 ) {
  fprintf( stderr, "Erro em AssinalaSemaforo: semop().\n" );
  exit( -1 );
 }
 return;
}

variable_types: struct sembuf { unsigned short sem_num; short sem_op; short sem_flg; }


EsperaSemaforo

decompiled_code:
int __fastcall EsperaSemaforo(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em EsperaSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = -65536;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforo: semop().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func4(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em EsperaSemaforo: semget().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = -65536;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforo: semop().\n", 1uLL, 0x21uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void EsperaSemaforo(int key)
{
 struct sembuf op;
 int id;
 if( ( id = semget( key, 1, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semget().\n" );
  exit( -1 );
 }
 op.sem_num = 0;
 op.sem_op = -1;
 op.sem_flg = 0;
 if( semop( id, &op, 1 ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforo: semop().\n" );
  exit( -1 );
 }
 return;
}


EsperaSemaforoZero

decompiled_code:
int __fastcall EsperaSemaforoZero(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em EsperaSemaforoZero: semget().\n", 1uLL, 0x26uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = 0;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforoZero: semop().\n", 1uLL, 0x25uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func5(key_t a1)
{
int v1; // eax
int result; // eax
struct sembuf sops; // [rsp+Ah] [rbp-Eh] BYREF

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em EsperaSemaforoZero: semget().\n", 1uLL, 0x26uLL, stderr);
exit(-1);
}
*(_DWORD *)&sops.sem_num = 0;
sops.sem_flg = 0;
result = semop(v1, &sops, 1uLL);
if ( result < 0 )
{
fwrite("Erro em EsperaSemaforoZero: semop().\n", 1uLL, 0x25uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void EsperaSemaforoZero(int key)
{
 struct sembuf op;
 int id;
 if( ( id = semget( key, 1, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforoZero: semget().\n" );
  exit( -1 );
 }
 op.sem_num = 0;
 op.sem_op = 0;
 op.sem_flg = 0;
 if( semop( id, &op, 1 ) < 0 ) {
  fprintf( stderr, "Erro em EsperaSemaforoZero: semop().\n" );
  exit( -1 );
 }
 return;
}


DestroiSemaforo

decompiled_code:
int __fastcall DestroiSemaforo(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em DestroiSemaforo: semget().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
result = semctl(v1, 0, 0);
if ( result < 0 )
{
fwrite("Erro em DestroiSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func6(key_t a1)
{
int v1; // eax
int result; // eax

v1 = semget(a1, 1, 0);
if ( v1 < 0 )
{
fwrite("Erro em DestroiSemaforo: semget().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
result = semctl(v1, 0, 0);
if ( result < 0 )
{
fwrite("Erro em DestroiSemaforo: semctl().\n", 1uLL, 0x23uLL, stderr);
exit(-1);
}
return result;
}

original_code:
void DestroiSemaforo(int key)
{
 int id;
 if( ( id = semget( key, 1, 0 ) ) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semget().\n" );
  exit( -1 );
 }
 if( semctl( id, 0, 0) < 0 ) {
  fprintf( stderr, "Erro em DestroiSemaforo: semctl().\n" );
  exit( -1 );
 }
 return;
}


traduzTipo

decompiled_code:
__int64 __fastcall traduzTipo(const char *a1)
{
unsigned int v1; // er8
bool v2; // zf
int v3; // eax

v1 = 2;
if ( !strcmp(a1, "from") )
return v1;
if ( !strcmp(a1, "FROM") )
return v1;
if ( !strcmp(a1, "inpt") )
return v1;
if ( !strcmp(a1, "INPT") )
return v1;
if ( !strcmp(a1, "buff") )
return v1;
if ( !strcmp(a1, "BUFF") )
return v1;
v1 = 3;
if ( !strcmp(a1, "not") )
return v1;
if ( !strcmp(a1, "NOT") )
return v1;
v2 = strcmp(a1, "and") == 0;
v1 = !v2;
if ( v2 )
return v1;
v2 = strcmp(a1, "AND") == 0;
v1 = !v2;
if ( v2 )
return v1;
v3 = *(unsigned __int8 *)a1;
if ( v3 == 111 && a1[1] == 114 )
{
v1 = 2;
if ( !a1[2] )
return v1;
}
if ( v3 == 79 && a1[1] == 82 )
{
v1 = 2;
if ( !a1[2] )
return v1;
}
v1 = 4;
if ( !strcmp(a1, "xor") )
return v1;
if ( !strcmp(a1, "XOR") )
return v1;
v1 = 1;
if ( !strcmp(a1, "nand") )
return v1;
if ( !strcmp(a1, "NAND") )
return v1;
v1 = 3;
if ( !strcmp(a1, "nor") )
return v1;
if ( !strcmp(a1, "NOR") )
return v1;
v1 = 5;
if ( !strcmp(a1, "xnor") || !strcmp(a1, "XNOR") )
return v1;
fprintf(stderr, "Tipo desconhecido: %s -> ficheiro.cir invalido.\n", a1);
return 0xFFFFFFFFLL;
}

canonical_decompiled_code:
__int64 __fastcall func3(const char *a1)
{
unsigned int v1; // er8
bool v2; // zf
int v3; // eax

v1 = 2;
if ( !strcmp(a1, "from") )
return v1;
if ( !strcmp(a1, "FROM") )
return v1;
if ( !strcmp(a1, "inpt") )
return v1;
if ( !strcmp(a1, "INPT") )
return v1;
if ( !strcmp(a1, "buff") )
return v1;
if ( !strcmp(a1, "BUFF") )
return v1;
v1 = 3;
if ( !strcmp(a1, "not") )
return v1;
if ( !strcmp(a1, "NOT") )
return v1;
v2 = strcmp(a1, "and") == 0;
v1 = !v2;
if ( v2 )
return v1;
v2 = strcmp(a1, "AND") == 0;
v1 = !v2;
if ( v2 )
return v1;
v3 = *(unsigned __int8 *)a1;
if ( v3 == 111 && a1[1] == 114 )
{
v1 = 2;
if ( !a1[2] )
return v1;
}
if ( v3 == 79 && a1[1] == 82 )
{
v1 = 2;
if ( !a1[2] )
return v1;
}
v1 = 4;
if ( !strcmp(a1, "xor") )
return v1;
if ( !strcmp(a1, "XOR") )
return v1;
v1 = 1;
if ( !strcmp(a1, "nand") )
return v1;
if ( !strcmp(a1, "NAND") )
return v1;
v1 = 3;
if ( !strcmp(a1, "nor") )
return v1;
if ( !strcmp(a1, "NOR") )
return v1;
v1 = 5;
if ( !strcmp(a1, "xnor") || !strcmp(a1, "XNOR") )
return v1;
fprintf(stderr, "Tipo desconhecido: %s -> ficheiro.cir invalido.\n", a1);
return 0xFFFFFFFFLL;
}

original_code:
int traduzTipo(char* tipo)
{
  if ( ( strcmp( tipo, "from") == 0 ) || ( strcmp( tipo, "FROM") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "inpt") == 0 ) || ( strcmp( tipo, "INPT") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "buff") == 0 ) || ( strcmp( tipo, "BUFF") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "not") == 0 ) || ( strcmp( tipo, "NOT") == 0 ) )
    return 3;
  else if ( ( strcmp( tipo, "and") == 0 ) || ( strcmp( tipo, "AND") == 0 ) )
    return 0;
  else if ( ( strcmp( tipo, "or") == 0 ) || ( strcmp( tipo, "OR") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "xor") == 0 ) || ( strcmp( tipo, "XOR") == 0) )
    return 4;
  else if ( ( strcmp( tipo, "nand") == 0 ) || ( strcmp( tipo, "NAND") == 0 ) )
    return 1;
  else if ( ( strcmp( tipo, "nor") == 0 ) || ( strcmp( tipo, "NOR") == 0 ) )
    return 3;
  else if ( ( strcmp( tipo, "xnor") == 0 ) || ( strcmp( tipo, "XNOR") == 0 ) )
    return 5;
  else
    {
      fprintf(stderr,"Tipo desconhecido: %s -> ficheiro.cir invalido.\n", tipo );
      return -1;
    }
}

canonical_original_code:
int traduzTipo(char *tipo)
{
  if ( ( strcmp( tipo, "from") == 0 ) || ( strcmp( tipo, "FROM") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "inpt") == 0 ) || ( strcmp( tipo, "INPT") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "buff") == 0 ) || ( strcmp( tipo, "BUFF") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "not") == 0 ) || ( strcmp( tipo, "NOT") == 0 ) )
    return 3;
  else if ( ( strcmp( tipo, "and") == 0 ) || ( strcmp( tipo, "AND") == 0 ) )
    return 0;
  else if ( ( strcmp( tipo, "or") == 0 ) || ( strcmp( tipo, "OR") == 0 ) )
    return 2;
  else if ( ( strcmp( tipo, "xor") == 0 ) || ( strcmp( tipo, "XOR") == 0) )
    return 4;
  else if ( ( strcmp( tipo, "nand") == 0 ) || ( strcmp( tipo, "NAND") == 0 ) )
    return 1;
  else if ( ( strcmp( tipo, "nor") == 0 ) || ( strcmp( tipo, "NOR") == 0 ) )
    return 3;
  else if ( ( strcmp( tipo, "xnor") == 0 ) || ( strcmp( tipo, "XNOR") == 0 ) )
    return 5;
  else
    {
      fprintf(stderr,"Tipo desconhecido: %s -> ficheiro.cir invalido.\n", tipo );
      return -1;
    }
}

variable_types:
tipo
char *


indiceDoNome

decompiled_code:
__int64 __fastcall indiceDoNome(__int64 a1, const char *a2)
{
int v2; // er12
const char *i; // rbx

v2 = *(_DWORD *)a1;
if ( *(int *)a1 < 0 )
return 0LL;
for ( i = (const char *)(*(_QWORD *)(a1 + 8) + 72LL * v2); strcmp(i, a2); i -= 72 )
{
if ( --v2 == -1 )
return 0LL;
}
return (unsigned int)v2;
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1, const char *a2)
{
int v2; // er12
const char *i; // rbx

v2 = *(_DWORD *)a1;
if ( *(int *)a1 < 0 )
return 0LL;
for ( i = (const char *)(*(_QWORD *)(a1 + 8) + 72LL * v2); strcmp(i, a2); i -= 72 )
{
if ( --v2 == -1 )
return 0LL;
}
return (unsigned int)v2;
}

original_code:
int indiceDoNome(Circuito* circuito, char* nome)
{
  int i;
  for( i = circuito->nNodes; i >= 0 ; i-- )
    if( 0 == strcmp( circuito->vectorNodes[ i ].nome, nome ) )
      return i;
  return 0;
}

canonical_original_code:
int indiceDoNome(struct CircuitoStr *circuito, char *nome)
{
  int i;
  for( i = circuito->nNodes; i >= 0 ; i-- )
    if( 0 == strcmp( circuito->vectorNodes[ i ].nome, nome ) )
      return i;
  return 0;
}

variable_types: struct CircuitoStr { int nNodes; struct NodeStr { char nome[16]; int tipo; int fanin; int *inputs; int valor; char flag; int fanout; char *sa0; char *sa1; int leituras; } *vectorNodes; int nMax; int nInputs; int realNodes; } *

variable_types: i int

user_defined_types: struct CircuitoStr { int nNodes; struct NodeStr *vectorNodes; int nMax; int nInputs; int realNodes; }


Abastece

decompiled_code:
__int64 __fastcall Abastece(char *src, char *a2)
{
char v3[20]; // [rsp+0h] [rbp-38h] BYREF
char dest[36]; // [rsp+14h] [rbp-24h] BYREF

GetIndiceStock();
strcpy(v3, src);
strcpy(dest, a2);
return AssinalaStock(v3, 1LL);
}

canonical_decompiled_code:
__int64 __fastcall func0(char *src, char *a2)
{
char v3[20]; // [rsp+0h] [rbp-38h] BYREF
char dest[36]; // [rsp+14h] [rbp-24h] BYREF

GetIndiceStock();
strcpy(v3, src);
strcpy(dest, a2);
return AssinalaStock(v3, 1LL);
}

original_code:
void Abastece(char* produto, char* quantidade)
{
 int indice;
 int n_prod_antes;
 Produto prod;
 n_prod_antes = stock.n_prod;
 indice = GetIndiceStock( produto );
 strcpy( prod.nome , produto );
 strcpy( prod.quantidade , quantidade );
 if( stock.n_prod == stock.n_prod ){
   AssinalaStock( &prod, 1 );
 }else{
   AdicionaProdMemMap( produto, quantidade);
 }
 return;
}

canonical_original_code:
void Abastece(char *produto, char *quantidade)
{
 int indice;
 int n_prod_antes;
 struct ProdutoStr prod;
 n_prod_antes = stock.n_prod;
 indice = GetIndiceStock( produto );
 strcpy( prod.nome , produto );
 strcpy( prod.quantidade , quantidade );
 if( stock.n_prod == stock.n_prod ){
   AssinalaStock( &prod, 1 );
 }else{
   AdicionaProdMemMap( produto, quantidade);
 }
 return;
}

variable_types:
produto
char *

variable_types:
quantidade
char *

variable_types: indice int

variable_types: struct ProdutoStr { char nome[20]; char quantidade[5]; }


ListaPedidosPendentes

decompiled_code:
void ListaPedidosPendentes()
{
;
}

canonical_decompiled_code:
void func1()
{
;
}

original_code:
void ListaPedidosPendentes(int verb)
{
 return;
}

variable_types: verb int


ListaStock

decompiled_code:
int ListaStock()
{
int result; // eax
__int64 v1; // rbp
int v2; // ebx
const char *v3; // rsi

result = *((_DWORD *)&stock + 8);
if ( result > 0 )
{
v1 = 0LL;
v2 = 0;
do
{
++v2;
v3 = (const char *)(v1 + *((_QWORD *)&stock + 1));
v1 += 25LL;
result = printf("Produto: %s - %s unidades\n", v3, v3 + 20);
}
while ( *((_DWORD *)&stock + 8) > v2 );
}
return result;
}

canonical_decompiled_code:
int func2()
{
int result; // eax
__int64 v1; // rbp
int v2; // ebx
const char *v3; // rsi

result = *((_DWORD *)&stock + 8);
if ( result > 0 )
{
v1 = 0LL;
v2 = 0;
do
{
++v2;
v3 = (const char *)(v1 + *((_QWORD *)&stock + 1));
v1 += 25LL;
result = printf("Produto: %s - %s unidades\n", v3, v3 + 20);
}
while ( *((_DWORD *)&stock + 8) > v2 );
}
return result;
}

original_code:
void ListaStock(int verb)
{
  int i;
  for( i = 0 ; i < stock.n_prod ; i++ )
    {
      printf("Produto: %s - %s unidades\n",
      stock.inicio[i].nome,
      stock.inicio[i].quantidade );
    }
  return;
}


TerminaRefeitorio

decompiled_code:
void __noreturn TerminaRefeitorio()
{
__int64 v0; // rbx
int v1; // ebp
void *v2; // rdi
int stat_loc[7]; // [rsp+Ch] [rbp-1Ch] BYREF

if ( *((int *)&clientes + 2) > 0 )
{
v0 = 0LL;
v1 = 0;
do
{
++v1;
kill(*(_DWORD *)(clientes + v0), 2);
waitpid(*(_DWORD *)(clientes + v0), stat_loc, 0);
pthread_cancel(*(_QWORD *)(clientes + v0 + 16));
pthread_join(*(_QWORD *)(clientes + v0 + 16), 0LL);
v2 = *(void **)(clientes + v0 + 8);
v0 += 24LL;
free(v2);
}
while ( *((_DWORD *)&clientes + 2) > v1 );
}
pthread_cancel(ThreadAtendeSoldados);
pthread_cancel(ThreadAtendeOficiais);
pthread_cancel(ThreadAtendeGenerais);
pthread_join(ThreadAtendeSoldados, 0LL);
pthread_join(ThreadAtendeOficiais, 0LL);
pthread_join(ThreadAtendeGenerais, 0LL);
DesMapeiaFicheiroStock();
DestroiSemaforo(1LL);
DestroiSemaforo(2LL);
DestroiSemaforo(3LL);
DestroiSemaforo(4LL);
DestroiSemaforo(5LL);
DestroiSemaforo(6LL);
DestroiSemaforo(7LL);
DestroiSemaforo(8LL);
DestroiSemaforo(9LL);
DestroiSemaforo(10LL);
DestroiSemaforo(11LL);
DestroiSemaforo(12LL);
DestroiSemaforo(13LL);
DestroiSemaforo(14LL);
DestroiSemaforo(15LL);
DestroiSemaforo(5LL);
DestroiMailbox(1LL);
exit(0);
}

canonical_decompiled_code:
void __noreturn func3()
{
__int64 v0; // rbx
int v1; // ebp
void *v2; // rdi
int stat_loc[7]; // [rsp+Ch] [rbp-1Ch] BYREF

if ( *((int *)&clientes + 2) > 0 )
{
v0 = 0LL;
v1 = 0;
do
{
++v1;
kill(*(_DWORD *)(clientes + v0), 2);
waitpid(*(_DWORD *)(clientes + v0), stat_loc, 0);
pthread_cancel(*(_QWORD *)(clientes + v0 + 16));
pthread_join(*(_QWORD *)(clientes + v0 + 16), 0LL);
v2 = *(void **)(clientes + v0 + 8);
v0 += 24LL;
free(v2);
}
while ( *((_DWORD *)&clientes + 2) > v1 );
}
pthread_cancel(ThreadAtendeSoldados);
pthread_cancel(ThreadAtendeOficiais);
pthread_cancel(ThreadAtendeGenerais);
pthread_join(ThreadAtendeSoldados, 0LL);
pthread_join(ThreadAtendeOficiais, 0LL);
pthread_join(ThreadAtendeGenerais, 0LL);
DesMapeiaFicheiroStock();
DestroiSemaforo(1LL);
DestroiSemaforo(2LL);
DestroiSemaforo(3LL);
DestroiSemaforo(4LL);
DestroiSemaforo(5LL);
DestroiSemaforo(6LL);
DestroiSemaforo(7LL);
DestroiSemaforo(8LL);
DestroiSemaforo(9LL);
DestroiSemaforo(10LL);
DestroiSemaforo(11LL);
DestroiSemaforo(12LL);
DestroiSemaforo(13LL);
DestroiSemaforo(14LL);
DestroiSemaforo(15LL);
DestroiSemaforo(5LL);
DestroiMailbox(1LL);
exit(0);
}

original_code:
void TerminaRefeitorio(int arg)
{
  int i, estado;
  for( i = 0 ; i < clientes.n_cli ; i++ )
    {
      kill( clientes.vector[i].id, 2 );
      waitpid( clientes.vector[i].id, &estado,0 );
      pthread_cancel( clientes.vector[i].tid );
      pthread_join( clientes.vector[i].tid, ((void *)0) );
      free( clientes.vector[i].pedido );
    }
  pthread_cancel( ThreadAtendeSoldados );
  pthread_cancel( ThreadAtendeOficiais );
  pthread_cancel( ThreadAtendeGenerais );
  pthread_join( ThreadAtendeSoldados, ((void *)0) );
  pthread_join( ThreadAtendeOficiais, ((void *)0) );
  pthread_join( ThreadAtendeGenerais, ((void *)0) );
  DesMapeiaFicheiroStock();
  DestroiSemaforo( 1 );
  DestroiSemaforo( 2 );
  DestroiSemaforo( 3 );
  DestroiSemaforo( 4 );
  DestroiSemaforo( 5 );
  DestroiSemaforo( 6 );
  DestroiSemaforo( 7 );
  DestroiSemaforo( 8 );
  DestroiSemaforo( 9 );
  DestroiSemaforo( 10 );
  DestroiSemaforo( 11 );
  DestroiSemaforo( 12 );
  DestroiSemaforo( 13 );
  DestroiSemaforo( 14 );
  DestroiSemaforo( 15 );
  DestroiSemaforo( 5 );
  DestroiMailbox( 1 );
  exit( 0 );
}

canonical_original_code:
void TerminaRefeitorio(int arg)
{
  int i; int estado;
  for( i = 0 ; i < clientes.n_cli ; i++ )
    {
      kill( clientes.vector[i].id, 2 );
      waitpid( clientes.vector[i].id, &estado,0 );
      pthread_cancel( clientes.vector[i].tid );
      pthread_join( clientes.vector[i].tid, ((void *)0) );
      free( clientes.vector[i].pedido );
    }
  pthread_cancel( ThreadAtendeSoldados );
  pthread_cancel( ThreadAtendeOficiais );
  pthread_cancel( ThreadAtendeGenerais );
  pthread_join( ThreadAtendeSoldados, ((void *)0) );
  pthread_join( ThreadAtendeOficiais, ((void *)0) );
  pthread_join( ThreadAtendeGenerais, ((void *)0) );
  DesMapeiaFicheiroStock();
  DestroiSemaforo( 1 );
  DestroiSemaforo( 2 );
  DestroiSemaforo( 3 );
  DestroiSemaforo( 4 );
  DestroiSemaforo( 5 );
  DestroiSemaforo( 6 );
  DestroiSemaforo( 7 );
  DestroiSemaforo( 8 );
  DestroiSemaforo( 9 );
  DestroiSemaforo( 10 );
  DestroiSemaforo( 11 );
  DestroiSemaforo( 12 );
  DestroiSemaforo( 13 );
  DestroiSemaforo( 14 );
  DestroiSemaforo( 15 );
  DestroiSemaforo( 5 );
  DestroiMailbox( 1 );
  exit( 0 );
}

variable_types: arg int

variable_types: estado int


decompiled_code:
void __noreturn Menu_Ref()
{
char v0; // al
char v1[5]; // [rsp+Bh] [rbp-2Dh] BYREF
char src[40]; // [rsp+10h] [rbp-28h] BYREF

while ( 1 )
{
while ( 1 )
{
Escreve_Menu_Ref();
v0 = getchar();
if ( v0 == 113 )
{
puts("TerminaRefeitorio();");
TerminaRefeitorio(0LL);
}
if ( v0 <= 113 )
break;
if ( v0 == 115 )
{
if ( (unsigned __int8)getchar() == 118 )
puts("ListaStock(1);");
else
puts("ListaStock(0);");
ListaStock();
}
else
{
LABEL_12:
puts("opcao invalida");
}
}
if ( v0 == 97 )
{
_isoc99_scanf("%s %s", src, v1);
printf("Abastece(%s,%s);\n", src, v1);
Abastece(src, v1);
}
else
{
if ( v0 != 112 )
goto LABEL_12;
if ( (unsigned __int8)getchar() == 118 )
puts("ListaPedidosPendentesVerboso();");
else
puts("ListaPedidosPendentes();");
}
}
}

canonical_decompiled_code:
void __noreturn func5()
{
char v0; // al
char v1[5]; // [rsp+Bh] [rbp-2Dh] BYREF
char src[40]; // [rsp+10h] [rbp-28h] BYREF

while ( 1 )
{
while ( 1 )
{
func4();
v0 = getchar();
if ( v0 == 113 )
{
puts("TerminaRefeitorio();");
func3(0LL);
}
if ( v0 <= 113 )
break;
if ( v0 == 115 )
{
if ( (unsigned __int8)getchar() == 118 )
puts("ListaStock(1);");
else
puts("ListaStock(0);");
func2();
}
else
{
LABEL_12:
puts("opcao invalida");
}
}
if ( v0 == 97 )
{
_isoc99_scanf("%s %s", src, v1);
printf("Abastece(%s,%s);\n", src, v1);
func0(src, v1);
}
else
{
if ( v0 != 112 )
goto LABEL_12;
if ( (unsigned __int8)getchar() == 118 )
puts("ListaPedidosPendentesVerboso();");
else
puts("ListaPedidosPendentes();");
}
}
}

original_code:
void *Menu_Ref(void *argumento)
{
  char opcao;
  char quantidade[5];
  char produto[20];
  while(1)
    {
      Escreve_Menu_Ref();
      opcao = getchar();
      switch( opcao )
 {
 case 'a':
   scanf("%s %s", produto, quantidade);
   printf("Abastece(%s,%s);\n", produto, quantidade);
   Abastece(produto, quantidade);
   break;
 case 'p':
   opcao = getchar();
   if('v' == opcao){
     puts("ListaPedidosPendentesVerboso();");
     ListaPedidosPendentes( 1 );
   }
   else
     {
       puts("ListaPedidosPendentes();");
       ListaPedidosPendentes( 0 );
     }
   break;
 case 's':
   opcao = getchar();
   if('v' == opcao){
     puts("ListaStock(1);");
     ListaStock(1);
   }
   else
     {
       puts("ListaStock(0);");
       ListaStock(0);
     }
   break;
 case 'q':
   puts("TerminaRefeitorio();");
   TerminaRefeitorio(0);
   return 0;
   break;
 default:
   puts("opcao invalida");
   break;
 }
    }
  return 0;
}

variable_types:
argumento
void *

variable_types: opcao char

variable_types:
quantidade
char [5]

variable_types:
produto
char [20]

return_type: void *


AtendeSoldados

decompiled_code:
void __noreturn AtendeSoldados()
{
__int64 v0; // rbx
void *v1; // rax
pthread_t newthread[2]; // [rsp+8h] [rbp-10h] BYREF

MenusFicheiroParaMemoriaPartilhada("menus.txt");
DefineSemaforo(9LL, 0LL);
DefineSemaforo(8LL, 1LL);
v0 = CriaSocketStreamEscuta("/tmp/ssserv");
while ( 1 )
{
v1 = (void *)AceitaLigacaoSocketStream(v0);
pthread_create(newthread, 0LL, ThreadSoldado, v1);
}
}

canonical_decompiled_code:
void __noreturn func1()
{
__int64 v0; // rbx
void *v1; // rax
pthread_t newthread[2]; // [rsp+8h] [rbp-10h] BYREF

func0("menus.txt");
DefineSemaforo(9LL, 0LL);
DefineSemaforo(8LL, 1LL);
v0 = CriaSocketStreamEscuta("/tmp/ssserv");
while ( 1 )
{
v1 = (void *)AceitaLigacaoSocketStream(v0);
pthread_create(newthread, 0LL, ThreadSoldado, v1);
}
}

original_code:
void *AtendeSoldados(void * parametros)
{
 pthread_t TidSoldados;
 SocketStream* SocketStreamRef;
 SocketStream* SocketStreamSol;
 MenusFicheiroParaMemoriaPartilhada( "menus.txt", 321 );
 DefineSemaforo( 9, 0 );
 DefineSemaforo( 8, 1 );
 SocketStreamRef = CriaSocketStreamEscuta( "/tmp/ssserv" );
 while(1){
  SocketStreamSol = AceitaLigacaoSocketStream( SocketStreamRef );
  pthread_create(&TidSoldados ,((void *)0), ThreadSoldado, (void*)SocketStreamSol );
 }
 return 0;
}

canonical_original_code:
void *AtendeSoldados(void *parametros)
{
 unsigned long TidSoldados;
 struct SocketStreamStr *SocketStreamRef;
 struct SocketStreamStr *SocketStreamSol;
 MenusFicheiroParaMemoriaPartilhada( "menus.txt", 321 );
 DefineSemaforo( 9, 0 );
 DefineSemaforo( 8, 1 );
 SocketStreamRef = CriaSocketStreamEscuta( "/tmp/ssserv" );
 while(1){
  SocketStreamSol = AceitaLigacaoSocketStream( SocketStreamRef );
  pthread_create(&TidSoldados ,((void *)0), ThreadSoldado, (void *)SocketStreamSol );
 }
 return 0;
}

variable_types:
parametros
void *

variable_types:
TidSoldados
unsigned long

variable_types: struct SocketStreamStr { int fd; char *nome; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } my_addr; unsigned int addrlen; } *


RetiraPedido

decompiled_code:
__int64 __fastcall RetiraPedido(int a1)
{
__int64 v1; // rbx
int v2; // eax
int v3; // edx
_DWORD *v4; // rax
__int64 v5; // rdx

v1 = AcedeMemoriaPedidos();
v2 = DevolveSemaforo(3LL);
if ( v2 <= 0 )
return 0xFFFFFFFFLL;
v3 = v2;
v4 = (_DWORD *)v1;
v5 = v1 + 8LL * (unsigned int)(v3 - 1) + 8;
while ( *v4 != a1 )
{
v4 += 2;
if ( v4 == (_DWORD *)v5 )
return 0xFFFFFFFFLL;
}
return (unsigned int)v4[1];
}

canonical_decompiled_code:
__int64 __fastcall func2(int a1)
{
__int64 v1; // rbx
int v2; // eax
int v3; // edx
_DWORD *v4; // rax
__int64 v5; // rdx

v1 = AcedeMemoriaPedidos();
v2 = DevolveSemaforo(3LL);
if ( v2 <= 0 )
return 0xFFFFFFFFLL;
v3 = v2;
v4 = (_DWORD *)v1;
v5 = v1 + 8LL * (unsigned int)(v3 - 1) + 8;
while ( *v4 != a1 )
{
v4 += 2;
if ( v4 == (_DWORD *)v5 )
return 0xFFFFFFFFLL;
}
return (unsigned int)v4[1];
}

original_code:
int RetiraPedido(int pid)
{
  int i;
  Escolha* pedidos;
  int n_ped;
  pedidos = AcedeMemoriaPedidos();
  n_ped = DevolveSemaforo( 3 );
  for( i = 0 ; i < n_ped ; i++ )
    {
      if( pid == pedidos[i].pid )
 {
   return pedidos[i].menu;
 }
    }
  return -1;
}

canonical_original_code:
int RetiraPedido(int pid)
{
  int i;
  struct EscolhaStr *pedidos;
  int n_ped;
  pedidos = AcedeMemoriaPedidos();
  n_ped = DevolveSemaforo( 3 );
  for( i = 0 ; i < n_ped ; i++ )
    {
      if( pid == pedidos[i].pid )
 {
   return pedidos[i].menu;
 }
    }
  return -1;
}

variable_types: pid int

variable_types: struct EscolhaStr { int pid; int menu; } *


CriaResposta

decompiled_code:
char *__fastcall CriaResposta(int a1)
{
__int64 v1; // rbx
char *v2; // rax

v1 = AcedeMemoriaMenus();
v2 = (char *)malloc(0x28uLL);
return strncpy(v2, (const char *)(v1 + 40 * a1), 0x28uLL);
}

canonical_decompiled_code:
char *__fastcall func3(int a1)
{
__int64 v1; // rbx
char *v2; // rax

v1 = AcedeMemoriaMenus();
v2 = (char *)malloc(0x28uLL);
return strncpy(v2, (const char *)(v1 + 40 * a1), 0x28uLL);
}

original_code:
char* CriaResposta(int menu)
{
  char *comida;
  Menus menus;
  menus = AcedeMemoriaMenus();
  comida = (char*) malloc ( sizeof(char)*40 );
  strncpy( comida, &menus.texto[ menu*40 ],40 );
  return comida;
}

canonical_original_code:
char *CriaResposta(int menu)
{
  char *comida;
  struct MenusStr menus;
  menus = AcedeMemoriaMenus();
  comida = (char *) malloc ( sizeof(char)*40 );
  strncpy( comida, &menus.texto[ menu*40 ],40 );
  return comida;
}

variable_types: menu int

variable_types:
comida
char *

variable_types: struct MenusStr { char *texto; int linhas; int colunas; }


ThreadSoldado

decompiled_code:
void *__fastcall ThreadSoldado(void *a1)
{
char *v1; // r12
unsigned int v2; // er13
int v3; // er14
_DWORD *v4; // r12
char *v5; // r14
char *v6; // r14

v1 = (char *)((__int64 (*)(void))RecebeSocketStream)();
v2 = IdentificaSoldado(v1);
puts(v1);
free(v1);
RegistaEntrada(v2, 1LL);
EsperaSemaforoZero(12LL);
v3 = RetiraPedido(v2);
v4 = ProcessaMenuSoldado(v3);
EsperaSemaforo(15LL);
v5 = CriaResposta(v3);
EsperaSemaforoZero(13LL);
EsperaStock(*(_QWORD *)v4, (unsigned int)v4[2]);
if ( (int)EnviaSocketStream(a1, v5) < 0 )
fwrite("Erro em EnviaSocketStream.\n", 1uLL, 0x1BuLL, stderr);
free(v5);
v6 = (char *)RecebeSocketStream(a1);
RegistaSaida(v2);
puts(v6);
free(v6);
free(v4);
FechaSocketStream(a1);
return 0LL;
}

canonical_decompiled_code:
void *__fastcall func4(void *a1)
{
char *v1; // r12
unsigned int v2; // er13
int v3; // er14
_DWORD *v4; // r12
char *v5; // r14
char *v6; // r14

v1 = (char *)((__int64 (*)(void))RecebeSocketStream)();
v2 = IdentificaSoldado(v1);
puts(v1);
free(v1);
RegistaEntrada(v2, 1LL);
EsperaSemaforoZero(12LL);
v3 = func2(v2);
v4 = ProcessaMenuSoldado(v3);
EsperaSemaforo(15LL);
v5 = func3(v3);
EsperaSemaforoZero(13LL);
EsperaStock(*(_QWORD *)v4, (unsigned int)v4[2]);
if ( (int)EnviaSocketStream(a1, v5) < 0 )
fwrite("Erro em EnviaSocketStream.\n", 1uLL, 0x1BuLL, stderr);
free(v5);
v6 = (char *)RecebeSocketStream(a1);
RegistaSaida(v2);
puts(v6);
free(v6);
free(v4);
FechaSocketStream(a1);
return 0LL;
}

original_code:
void *ThreadSoldado(void * argumento)
{
 SocketStream* SocketStreamSol;
 char* msg;
 int pid;
 int menu;
        Pedido* pedido;
 SocketStreamSol = (SocketStream*)argumento;
 msg = RecebeSocketStream( SocketStreamSol );
 pid = IdentificaSoldado( msg );
 puts( msg );
 free( msg );
 RegistaEntrada( pid, 1 );
 EsperaSemaforoZero( 12 );
 menu = RetiraPedido( pid );
        pedido = ProcessaMenuSoldado( menu );
 EsperaSemaforo( 15 );
 msg = CriaResposta( menu );
 EsperaSemaforoZero( 13 );
 EsperaStock( pedido->prod, pedido->n_prod );
 if( EnviaSocketStream( SocketStreamSol, msg ) < 0)
 {
  fprintf( stderr, "Erro em EnviaSocketStream.\n" );
 }
        free( msg );
 msg = RecebeSocketStream( SocketStreamSol );
 RegistaSaida( pid );
 puts( msg );
 free( msg );
 free( pedido );
 FechaSocketStream( SocketStreamSol );
 return 0;
}

canonical_original_code:
void *ThreadSoldado(void *argumento)
{
 struct SocketStreamStr *SocketStreamSol;
 char *msg;
 int pid;
 int menu;
        struct PedidoStr *pedido;
 SocketStreamSol = (struct SocketStreamStr *)argumento;
 msg = RecebeSocketStream( SocketStreamSol );
 pid = IdentificaSoldado( msg );
 puts( msg );
 free( msg );
 RegistaEntrada( pid, 1 );
 EsperaSemaforoZero( 12 );
 menu = RetiraPedido( pid );
        pedido = ProcessaMenuSoldado( menu );
 EsperaSemaforo( 15 );
 msg = CriaResposta( menu );
 EsperaSemaforoZero( 13 );
 EsperaStock( pedido->prod, pedido->n_prod );
 if( EnviaSocketStream( SocketStreamSol, msg ) < 0)
 {
  fprintf( stderr, "Erro em EnviaSocketStream.\n" );
 }
        free( msg );
 msg = RecebeSocketStream( SocketStreamSol );
 RegistaSaida( pid );
 puts( msg );
 free( msg );
 free( pedido );
 FechaSocketStream( SocketStreamSol );
 return 0;
}

variable_types:
msg
char *

variable_types: struct PedidoStr { struct ProdutoStr { char nome[20]; char quantidade[5]; } *prod; int n_prod; } *

user_defined_types: struct PedidoStr { struct ProdutoStr *prod; int n_prod; }


ApagaIdentificador

decompiled_code:
void __fastcall ApagaIdentificador(void *ptr)
{
free(*(void **)ptr);
free(ptr);
}

canonical_decompiled_code:
void __fastcall func0(void *ptr)
{
free(*(void **)ptr);
free(ptr);
}

original_code:
void ApagaIdentificador( void* dados ) {
 free( ((identificador*)dados) -> nome );
 free( ((identificador*)dados) );
}

canonical_original_code:
void ApagaIdentificador(void *dados) {
 free( ((struct identificador_str *)dados) -> nome );
 free( ((struct identificador_str *)dados) );
}

variable_types:
dados
void *

user_defined_types: struct identificador_str { char *nome; enum tipo t; enum boolean init; enum boolean use; }

user_defined_types: enum tipo { inteiro=0, semaforo=1, canal_limitado=2, canal_ilimitado=3, lista=4, constante=5 }


decompiled_code:
int __fastcall id_match(const char **a1, const char **a2)
{
return strcmp(*a1, *a2);
}

canonical_decompiled_code:
int __fastcall func1(const char **a1, const char **a2)
{
return strcmp(*a1, *a2);
}

original_code:
int id_match( void* ref, void* dados ) {
 return strcmp( ((identificador*)ref)->nome,
   ((identificador*)dados)->nome );
}

canonical_original_code:
int id_match(void *ref, void *dados) {
 return strcmp( ((struct identificador_str *)ref)->nome,
   ((struct identificador_str *)dados)->nome );
}

variable_types:
ref
void *


decompiled_code:
__int64 __fastcall table_push(__int64 a1)
{
__int64 v1; // rax

v1 = hash_init();
return stack_push(a1, v1);
}

canonical_decompiled_code:
__int64 __fastcall func3(__int64 a1)
{
__int64 v1; // rax

v1 = hash_init();
return stack_push(a1, v1);
}

original_code:
void table_push( Item** p ) {
 stack_push( p, (void*)hash_init() );
}

canonical_original_code:
void table_push(struct ItemStr **p) {
 stack_push( p, (void *)hash_init() );
}

variable_types: struct ItemStr { void *dados; struct ItemStr *next; } **


decompiled_code:
__int64 table_pop()
{
__int64 v0; // rax

v0 = stack_pop();
return hash_kill(v0, ApagaIdentificador);
}

canonical_decompiled_code:
__int64 func4()
{
__int64 v0; // rax

v0 = stack_pop();
return hash_kill(v0, ApagaIdentificador);
}

original_code:
void table_pop( Item** p ) {
 Item** table;
 table = (Item**)stack_pop( p );
 hash_kill( table, ApagaIdentificador );
}

canonical_original_code:
void table_pop(struct ItemStr **p) {
 struct ItemStr **table;
 table = (struct ItemStr **)stack_pop( p );
 hash_kill( table, ApagaIdentificador );
}

user_defined_types: struct ItemStr { void *dados; struct ItemStr *next; }


decompiled_code:
__int64 __fastcall table_insert(_QWORD *a1)
{
if ( !a1 )
{
fwrite("Erro: Tentativa de insercao de um identificador numa pilha de tabelas vazia.\n", 1uLL, 0x4DuLL, stderr);
exit(-1);
}
return hash_insert(*a1);
}

canonical_decompiled_code:
__int64 __fastcall func5(_QWORD *a1)
{
if ( !a1 )
{
fwrite("Erro: Tentativa de insercao de um identificador numa pilha de tabelas vazia.\n", 1uLL, 0x4DuLL, stderr);
exit(-1);
}
return hash_insert(*a1);
}

original_code:
void table_insert( Item* p, identificador* id ) {
 Item** table;
 if( ((void *)0) == p ) {
  fprintf(stderr,"Erro: Tentativa de insercao de um identificador numa pilha de tabelas vazia.\n");
  exit(-1);
 }
 table = (Item**)(p -> dados);
 hash_insert( table, (void*)id );
}

canonical_original_code:
void table_insert(struct ItemStr *p, struct identificador_str *id) {
 struct ItemStr **table;
 if( ((void *)0) == p ) {
  fprintf(stderr,"Erro: Tentativa de insercao de um identificador numa pilha de tabelas vazia.\n");
  exit(-1);
 }
 table = (struct ItemStr **)(p -> dados);
 hash_insert( table, (void *)id );
}

variable_types: struct ItemStr { void *dados; struct ItemStr *next; } *

variable_types: struct identificador_str { char *nome; enum tipo { inteiro=0, semaforo=1, canal_limitado=2, canal_ilimitado=3, lista=4, constante=5 } t; enum boolean { true=0, false=1 } init; enum boolean { true=0, false=1 } use; } *


decompiled_code:
__int64 __fastcall table_find(_QWORD *a1, __int64 a2)
{
_QWORD *v2; // rbx
char *v3; // rbp
__int64 v4; // rax
__int64 result; // rax
__int64 v6; // [rsp+8h] [rbp-20h]

v2 = a1;
v3 = NovoIdentificador(a2, 0);
if ( a1 )
{
while ( 1 )
{
v4 = hash_find(*v2, id_match, v3);
if ( v4 )
break;
v2 = (_QWORD *)v2[1];
if ( !v2 )
goto LABEL_6;
}
v6 = v4;
free(v3);
result = v6;
}
else
{
LABEL_6:
free(v3);
result = 0LL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func6(_QWORD *a1, __int64 a2)
{
_QWORD *v2; // rbx
char *v3; // rbp
__int64 v4; // rax
__int64 result; // rax
__int64 v6; // [rsp+8h] [rbp-20h]

v2 = a1;
v3 = func2(a2, 0);
if ( a1 )
{
while ( 1 )
{
v4 = hash_find(*v2, id_match, v3);
if ( v4 )
break;
v2 = (_QWORD *)v2[1];
if ( !v2 )
goto LABEL_6;
}
v6 = v4;
free(v3);
result = v6;
}
else
{
LABEL_6:
free(v3);
result = 0LL;
}
return result;
}

original_code:
identificador* table_find( Item* p, char* nome ) {
 Item* it;
 identificador* id;
 identificador* ref;
 ref = NovoIdentificador( nome, inteiro );
 for( it = p ; ((void *)0) != it ; it = it -> next ) {
  if( ((void *)0) != ( id = hash_find(
     (Item**)(it -> dados),
     id_match,
     (void*)ref ) ) ) {
   free( ref );
   return id;
  }
 }
 free( ref );
 return ((void *)0);
}

canonical_original_code:
struct identificador_str *table_find(struct ItemStr *p, char *nome) {
 struct ItemStr *it;
 struct identificador_str *id;
 struct identificador_str *ref;
 ref = NovoIdentificador( nome, inteiro );
 for( it = p ; ((void *)0) != it ; it = it -> next ) {
  if( ((void *)0) != ( id = hash_find(
     (struct ItemStr **)(it -> dados),
     id_match,
     (void *)ref ) ) ) {
   free( ref );
   return id;
  }
 }
 free( ref );
 return ((void *)0);
}

variable_types:
nome
char *

return_type: struct identificador_str { char *nome; enum tipo { inteiro=0, semaforo=1, canal_limitado=2, canal_ilimitado=3, lista=4, constante=5 } t; enum boolean { true=0, false=1 } init; enum boolean { true=0, false=1 } use; } *


decompiled_code:
__int64 __fastcall father_fill(__int64 a1, const char *a2)
{
char *v2; // rbp
__int64 v4; // rdi
__int64 result; // rax

v2 = (char *)(a1 + 6);
v4 = a1 + 14;
*(_WORD *)(v4 - 10) = 1;
*(_QWORD *)(v4 - 8) = 0LL;
*(_QWORD *)(v4 + 92) = 0LL;
memset(
(void *)(v4 & 0xFFFFFFFFFFFFFFF8LL),
0,
8 * ((unsigned __int64)((unsigned int)v2 - (v4 & 0xFFFFFFF8) + 108) >> 3));
result = (unsigned int)stpcpy(v2, a2) - (unsigned int)v2 + 2;
*(_DWORD *)(a1 + 116) = result;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, const char *a2)
{
char *v2; // rbp
__int64 v4; // rdi
__int64 result; // rax

v2 = (char *)(a1 + 6);
v4 = a1 + 14;
*(_WORD *)(v4 - 10) = 1;
*(_QWORD *)(v4 - 8) = 0LL;
*(_QWORD *)(v4 + 92) = 0LL;
memset(
(void *)(v4 & 0xFFFFFFFFFFFFFFF8LL),
0,
8 * ((unsigned __int64)((unsigned int)v2 - (v4 & 0xFFFFFFF8) + 108) >> 3));
result = (unsigned int)stpcpy(v2, a2) - (unsigned int)v2 + 2;
*(_DWORD *)(a1 + 116) = result;
return result;
}

original_code:
void father_fill (sock_dgram *soketDgramRef, char *name)
{
  soketDgramRef->addr.sun_family = 1;
  memset(soketDgramRef->addr.sun_path, 0, sizeof(soketDgramRef->addr.sun_path));
  strcpy(soketDgramRef->addr.sun_path,name);
  soketDgramRef->addrlen = sizeof(soketDgramRef->addr.sun_family) + strlen(soketDgramRef->addr.sun_path);
  return;
}

canonical_original_code:
void father_fill(struct sock_dgram_str *soketDgramRef, char *name)
{
  soketDgramRef->addr.sun_family = 1;
  memset(soketDgramRef->addr.sun_path, 0, sizeof(soketDgramRef->addr.sun_path));
  strcpy(soketDgramRef->addr.sun_path,name);
  soketDgramRef->addrlen = sizeof(soketDgramRef->addr.sun_family) + strlen(soketDgramRef->addr.sun_path);
  return;
}

variable_types: struct sock_dgram_str { int sd; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } addr; unsigned int addrlen; } *

variable_types:
name
char *


CriarSd

decompiled_code:
char *__fastcall CriarSd(char *src)
{
char *v1; // r12
int v2; // eax

v1 = (char *)malloc(0x78uLL);
v2 = socket(1, 2, 0);
*(_DWORD *)v1 = v2;
if ( v2 < 0 )
_assert_fail("(novo->sd = socket(PF_UNIX, SOCK_DGRAM, 0)) >= 0", "sock_dgram.c", 0x37u, "CriarSd");
unlink(src);
sun_fill(src, (__int64)(v1 + 4), (_DWORD *)v1 + 29);
if ( bind(*(_DWORD *)v1, (const struct sockaddr *)(v1 + 4), *((_DWORD *)v1 + 29)) < 0 )
_assert_fail(
"bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0",
"sock_dgram.c",
0x40u,
"CriarSd");
return v1;
}

canonical_decompiled_code:
char *__fastcall func2(char *src)
{
char *v1; // r12
int v2; // eax

v1 = (char *)malloc(0x78uLL);
v2 = socket(1, 2, 0);
*(_DWORD *)v1 = v2;
if ( v2 < 0 )
_assert_fail("(novo->sd = socket(PF_UNIX, SOCK_DGRAM, 0)) >= 0", "sock_dgram.c", 0x37u, "CriarSd");
unlink(src);
func0(src, (__int64)(v1 + 4), (_DWORD *)v1 + 29);
if ( bind(*(_DWORD *)v1, (const struct sockaddr *)(v1 + 4), *((_DWORD *)v1 + 29)) < 0 )
_assert_fail(
"bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0",
"sock_dgram.c",
0x40u,
"CriarSd");
return v1;
}

original_code:
sock_dgram *CriarSd(char *name)
{
  sock_dgram *novo;
  novo= (sock_dgram*) malloc(sizeof(sock_dgram));
  ((void) sizeof (((novo->sd = socket(1, SOCK_DGRAM, 0)) >= 0) ? 1 : 0), __extension__ ({ if ((novo->sd = socket(1, SOCK_DGRAM, 0)) >= 0) ; else __assert_fail ("(novo->sd = socket(PF_UNIX, SOCK_DGRAM, 0)) >= 0", "sock_dgram.c", 55, __extension__ __PRETTY_FUNCTION__); }));
  unlink(name);
  sun_fill(name, &(novo->addr), &(novo->addrlen));
  ((void) sizeof ((bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0) ? 1 : 0), __extension__ ({ if (bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0) ; else __assert_fail ("bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0", "sock_dgram.c", 64, __extension__ __PRETTY_FUNCTION__); }));
  return(novo);
}

canonical_original_code:
struct sock_dgram_str *CriarSd(char *name)
{
  struct sock_dgram_str *novo;
  novo= (struct sock_dgram_str *) malloc(sizeof(sock_dgram));
  ((void) sizeof (((novo->sd = socket(1, SOCK_DGRAM, 0)) >= 0) ? 1 : 0), __extension__ ({ if ((novo->sd = socket(1, SOCK_DGRAM, 0)) >= 0) ; else __assert_fail ("(novo->sd = socket(PF_UNIX, SOCK_DGRAM, 0)) >= 0", "sock_dgram.c", 55, __extension__ __PRETTY_FUNCTION__); }));
  unlink(name);
  sun_fill(name, &(novo->addr), &(novo->addrlen));
  ((void) sizeof ((bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0) ? 1 : 0), __extension__ ({ if (bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0) ; else __assert_fail ("bind(novo->sd, (struct sockaddr *)&(novo->addr),novo->addrlen) >= 0", "sock_dgram.c", 64, __extension__ __PRETTY_FUNCTION__); }));
  return(novo);
}

return_type: struct sock_dgram_str { int sd; struct sockaddr_un { unsigned short sun_family; char sun_path[108]; } addr; unsigned int addrlen; } *


CriaSdAuxiliar

decompiled_code:
void *CriaSdAuxiliar()
{
return malloc(0x78uLL);
}

canonical_decompiled_code:
void *func3()
{
return malloc(0x78uLL);
}

original_code:
sock_dgram *CriaSdAuxiliar()
{
  sock_dgram *socketDgramaux;
  socketDgramaux= (sock_dgram*) malloc(sizeof (sock_dgram));
  return (socketDgramaux);
}

canonical_original_code:
struct sock_dgram_str *CriaSdAuxiliar()
{
  struct sock_dgram_str *socketDgramaux;
  socketDgramaux= (struct sock_dgram_str *) malloc(sizeof (sock_dgram));
  return (socketDgramaux);
}


RecebMsgSock

decompiled_code:
__int64 __fastcall RecebMsgSock(__int64 a1, int *a2, char *a3)
{
struct sockaddr *v4; // r8
int v6; // edi
socklen_t addr_len; // [rsp+Ch] [rbp-6Ch] BYREF
char buf[104]; // [rsp+10h] [rbp-68h] BYREF

v4 = (struct sockaddr *)(a1 + 4);
v6 = *a2;
addr_len = 110;
if ( recvfrom(v6, buf, 0x50uLL, 0, v4, &addr_len) < 0 )
{
perror(" Erro no recvfrom");
}
else
{
strncpy(a3, buf, 0x50uLL);
printf(" Recebi: %s\n", buf);
}
return a1;
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1, int *a2, char *a3)
{
struct sockaddr *v4; // r8
int v6; // edi
socklen_t addr_len; // [rsp+Ch] [rbp-6Ch] BYREF
char buf[104]; // [rsp+10h] [rbp-68h] BYREF

v4 = (struct sockaddr *)(a1 + 4);
v6 = *a2;
addr_len = 110;
if ( recvfrom(v6, buf, 0x50uLL, 0, v4, &addr_len) < 0 )
{
perror(" Erro no recvfrom");
}
else
{
strncpy(a3, buf, 0x50uLL);
printf(" Recebi: %s\n", buf);
}
return a1;
}

original_code:
sock_dgram *RecebMsgSock(sock_dgram *sender, sock_dgram *receiver, char msg[80])
{
  socklen_t fromlen;
  char buf[ 80 ];
  fromlen= sizeof(sender->addr);
  if (recvfrom(receiver->sd, buf, sizeof(buf), 0, (struct sockaddr *)&(sender->addr), &fromlen) < 0) {
    perror(" Erro no recvfrom");
  }
  else {
    strncpy(msg, buf,sizeof(buf) );
    printf(" Recebi: %s\n", buf);
  }
  return (sender);
}

canonical_original_code:
struct sock_dgram_str *RecebMsgSock(struct sock_dgram_str *sender, struct sock_dgram_str *receiver, char msg[80])
{
  unsigned int fromlen;
  char buf[80];
  fromlen= sizeof(sender->addr);
  if (recvfrom(receiver->sd, buf, sizeof(buf), 0, (struct sockaddr *)&(sender->addr), &fromlen) < 0) {
    perror(" Erro no recvfrom");
  }
  else {
    strncpy(msg, buf,sizeof(buf) );
    printf(" Recebi: %s\n", buf);
  }
  return (sender);
}

variable_types:
sender
struct sock_dgram_str *

variable_types:
receiver
struct sock_dgram_str *

variable_types:
msg
char [80]

variable_types:
fromlen
unsigned int

variable_types:
buf
char [80]


EnviaMsgSock

decompiled_code:
void __fastcall EnviaMsgSock(__int64 a1, const char *a2, int *a3)
{
size_t v4; // rax

v4 = strlen(a2);
if ( sendto(*a3, a2, v4 + 1, 0, (const struct sockaddr *)(a1 + 4), 0x6Eu) < 0 )
perror(" Erro no sendto");
}

canonical_decompiled_code:
void __fastcall func5(__int64 a1, const char *a2, int *a3)
{
size_t v4; // rax

v4 = strlen(a2);
if ( sendto(*a3, a2, v4 + 1, 0, (const struct sockaddr *)(a1 + 4), 0x6Eu) < 0 )
perror(" Erro no sendto");
}

original_code:
void EnviaMsgSock( sock_dgram *receiver, char *msg, sock_dgram *sender )
{
  socklen_t tolen;
  tolen= sizeof(receiver->addr);
  if (sendto(sender->sd, msg, strlen(msg)+1, 0, (struct sockaddr *)&(receiver->addr),
      tolen) < 0) {
    perror(" Erro no sendto");
  }
}

canonical_original_code:
void EnviaMsgSock(struct sock_dgram_str *receiver, char *msg, struct sock_dgram_str *sender)
{
  unsigned int tolen;
  tolen= sizeof(receiver->addr);
  if (sendto(sender->sd, msg, strlen(msg)+1, 0, (struct sockaddr *)&(receiver->addr),
      tolen) < 0) {
    perror(" Erro no sendto");
  }
}

variable_types:
tolen
unsigned int


TerminaSock

original_code:
void TerminaSock(sock_dgram *socketDgram)
{
  struct sockaddr_un my_addr;
 my_addr= socketDgram->addr;
 close(socketDgram->sd);
  unlink(my_addr.sun_path);
}

canonical_original_code:
void TerminaSock(struct sock_dgram_str *socketDgram)
{
  struct sockaddr_un my_addr;
 my_addr= socketDgram->addr;
 close(socketDgram->sd);
  unlink(my_addr.sun_path);
}

variable_types: struct sockaddr_un { unsigned short sun_family; char sun_path[108]; }


cola

decompiled_code:
char *__fastcall cola(void *src, void *a2)
{
size_t v2; // rbx
size_t v3; // rbp
char *v4; // rax
char *v5; // r12

v2 = strlen((const char *)src);
v3 = strlen((const char *)a2);
v4 = (char *)malloc(v2 + v3 + 1);
if ( !v4 )
{
fwrite("Erro ao alocar memoria em cola().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
v5 = v4;
memcpy(v4, src, v2);
memcpy(&v5[v2], a2, v3 + 1);
return v5;
}

canonical_decompiled_code:
char *__fastcall func0(void *src, void *a2)
{
size_t v2; // rbx
size_t v3; // rbp
char *v4; // rax
char *v5; // r12

v2 = strlen((const char *)src);
v3 = strlen((const char *)a2);
v4 = (char *)malloc(v2 + v3 + 1);
if ( !v4 )
{
fwrite("Erro ao alocar memoria em cola().\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
v5 = v4;
memcpy(v4, src, v2);
memcpy(&v5[v2], a2, v3 + 1);
return v5;
}

original_code:
char* cola( char* s1, char* s2 ) {
 char* res;
 res = (char*)malloc( sizeof(char)*( strlen(s1)+strlen(s2)+1 ) );
 if( ((void *)0) == res ) {
  fprintf(stderr,"Erro ao alocar memoria em cola().\n");
  exit(-1);
 }
 strcpy( res, s1 );
 strcat( res, s2 );
 return res;
}

canonical_original_code:
char *cola(char *s1, char *s2) {
 char *res;
 res = (char *)malloc( sizeof(char)*( strlen(s1)+strlen(s2)+1 ) );
 if( ((void *)0) == res ) {
  fprintf(stderr,"Erro ao alocar memoria em cola().\n");
  exit(-1);
 }
 strcpy( res, s1 );
 strcat( res, s2 );
 return res;
}

variable_types:
res
char *


CriaMailbox

decompiled_code:
int __fastcall CriaMailbox(key_t a1)
{
int result; // eax

result = msgget(a1, 950);
if ( result < 0 )
{
perror("Erro a criar queue mailbox.");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func0(key_t a1)
{
int result; // eax

result = msgget(a1, 950);
if ( result < 0 )
{
perror("Erro a criar queue mailbox.");
exit(-1);
}
return result;
}

original_code:
void CriaMailbox(unsigned key)
{
 if (msgget( key, 0666|01000) < 0) {
  perror("Erro a criar queue mailbox.");
  exit(-1);
 }
 return;
}

canonical_original_code:
void CriaMailbox(unsigned int key)
{
 if (msgget( key, 0666|01000) < 0) {
  perror("Erro a criar queue mailbox.");
  exit(-1);
 }
 return;
}

variable_types:
key
unsigned int


EnviaMailMessage

decompiled_code:
int __fastcall EnviaMailMessage(int a1, key_t a2, unsigned int a3, const char *a4)
{
int v6; // eax
int v7; // ebp
int result; // eax
__int64 v9; // [rsp+0h] [rbp-88h] BYREF
int v10; // [rsp+8h] [rbp-80h]
char dest[124]; // [rsp+Ch] [rbp-7Ch] BYREF

v6 = msgget(a2, 0);
if ( v6 < 0 )
{
perror("Erro a associar a queue to.");
exit(-1);
}
v7 = v6;
v9 = a3;
v10 = a1;
strncpy(dest, a4, 0x50uLL);
result = msgsnd(v7, &v9, 0x54uLL, 0);
if ( result < 0 )
{
perror("Erro a enviar mensagem.");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func1(int a1, key_t a2, unsigned int a3, const char *a4)
{
int v6; // eax
int v7; // ebp
int result; // eax
__int64 v9; // [rsp+0h] [rbp-88h] BYREF
int v10; // [rsp+8h] [rbp-80h]
char dest[124]; // [rsp+Ch] [rbp-7Ch] BYREF

v6 = msgget(a2, 0);
if ( v6 < 0 )
{
perror("Erro a associar a queue to.");
exit(-1);
}
v7 = v6;
v9 = a3;
v10 = a1;
strncpy(dest, a4, 0x50uLL);
result = msgsnd(v7, &v9, 0x54uLL, 0);
if ( result < 0 )
{
perror("Erro a enviar mensagem.");
exit(-1);
}
return result;
}

original_code:
void EnviaMailMessage(unsigned fromKey, unsigned toKey, unsigned tipo, char* msgBody)
{
 int toId;
 MailMesage msg;
 if ((toId=msgget(toKey, 0)) < 0) {
  perror("Erro a associar a queue to.");
  exit(-1);
 }
 msg.mtype = tipo;
 msg.senderId = fromKey;
 strncpy( msg.msgBody, msgBody, 80);
 if (msgsnd(toId, &msg, sizeof(msg.msgBody)+sizeof(msg.senderId), 0) < 0)
 {
  perror("Erro a enviar mensagem.");
  exit(-1);
 }
 return;
}

canonical_original_code:
void EnviaMailMessage(unsigned int fromKey, unsigned int toKey, unsigned int tipo, char *msgBody)
{
 int toId;
 struct MailMesageStr msg;
 if ((toId=msgget(toKey, 0)) < 0) {
  perror("Erro a associar a queue to.");
  exit(-1);
 }
 msg.mtype = tipo;
 msg.senderId = fromKey;
 strncpy( msg.msgBody, msgBody, 80);
 if (msgsnd(toId, &msg, sizeof(msg.msgBody)+sizeof(msg.senderId), 0) < 0)
 {
  perror("Erro a enviar mensagem.");
  exit(-1);
 }
 return;
}

variable_types:
fromKey
unsigned int

variable_types:
toKey
unsigned int

variable_types:
tipo
unsigned int

variable_types:
msgBody
char *

variable_types: toId int

variable_types: struct MailMesageStr { long mtype; unsigned int senderId; char msgBody[80]; }


RecebeMailMessage

decompiled_code:
void *__fastcall RecebeMailMessage(_DWORD *a1, key_t a2, unsigned int a3)
{
int v4; // eax
size_t v5; // r12
void *v6; // rax
void *result; // rax
_DWORD v8[3]; // [rsp+0h] [rbp-78h] BYREF
char s[108]; // [rsp+Ch] [rbp-6Ch] BYREF

v4 = msgget(a2, 0);
if ( v4 < 0 )
{
perror("Erro a associar a queue to.");
exit(-1);
}
if ( msgrcv(v4, v8, 0x54uLL, a3, 0) < 0 )
{
perror("Erro a receber mensagem.");
exit(-1);
}
v5 = strlen(s) + 1;
v6 = malloc(v5);
result = memcpy(v6, s, v5);
*a1 = v8[2];
return result;
}

canonical_decompiled_code:
void *__fastcall func2(_DWORD *a1, key_t a2, unsigned int a3)
{
int v4; // eax
size_t v5; // r12
void *v6; // rax
void *result; // rax
_DWORD v8[3]; // [rsp+0h] [rbp-78h] BYREF
char s[108]; // [rsp+Ch] [rbp-6Ch] BYREF

v4 = msgget(a2, 0);
if ( v4 < 0 )
{
perror("Erro a associar a queue to.");
exit(-1);
}
if ( msgrcv(v4, v8, 0x54uLL, a3, 0) < 0 )
{
perror("Erro a receber mensagem.");
exit(-1);
}
v5 = strlen(s) + 1;
v6 = malloc(v5);
result = memcpy(v6, s, v5);
*a1 = v8[2];
return result;
}

original_code:
char* RecebeMailMessage(unsigned* fromKey, unsigned toKey, unsigned tipo)
{
 int toId;
 char* body;
 MailMesage msg;
 if ((toId=msgget(toKey, 0)) < 0) {
  perror("Erro a associar a queue to.");
  exit(-1);
 }
 if (msgrcv(toId, &msg, sizeof(msg.msgBody)+sizeof(msg.senderId), tipo, 0) < 0)
 {
  perror("Erro a receber mensagem.");
  exit(-1);
 }
 body = (char*)malloc( (strlen(msg.msgBody)+1)*sizeof(char) );
 strcpy(body, msg.msgBody);
 *fromKey = msg.senderId;
 return body;
}

canonical_original_code:
char *RecebeMailMessage(unsigned int *fromKey, unsigned int toKey, unsigned int tipo)
{
 int toId;
 char *body;
 struct MailMesageStr msg;
 if ((toId=msgget(toKey, 0)) < 0) {
  perror("Erro a associar a queue to.");
  exit(-1);
 }
 if (msgrcv(toId, &msg, sizeof(msg.msgBody)+sizeof(msg.senderId), tipo, 0) < 0)
 {
  perror("Erro a receber mensagem.");
  exit(-1);
 }
 body = (char *)malloc( (strlen(msg.msgBody)+1)*sizeof(char) );
 strcpy(body, msg.msgBody);
 *fromKey = msg.senderId;
 return body;
}

variable_types:
fromKey
unsigned int *

variable_types:
body
char *

user_defined_types: struct MailMesageStr { long mtype; unsigned int senderId; char msgBody[80]; }


DestroiMailbox

decompiled_code:
int __fastcall DestroiMailbox(key_t a1)
{
int v1; // eax
int result; // eax

v1 = msgget(a1, 0);
if ( v1 < 0 )
{
perror("Erro a associar a queue.");
exit(-1);
}
result = msgctl(v1, 0, 0LL);
if ( result < 0 )
{
perror("Erro a eliminar queue.");
exit(-1);
}
return result;
}

canonical_decompiled_code:
int __fastcall func3(key_t a1)
{
int v1; // eax
int result; // eax

v1 = msgget(a1, 0);
if ( v1 < 0 )
{
perror("Erro a associar a queue.");
exit(-1);
}
result = msgctl(v1, 0, 0LL);
if ( result < 0 )
{
perror("Erro a eliminar queue.");
exit(-1);
}
return result;
}

original_code:
void DestroiMailbox(unsigned key)
{
 int id;
 if ((id=msgget(key, 0)) < 0) {
  perror("Erro a associar a queue.");
  exit(-1);
 }
 if (msgctl(id, 0, 0) < 0) {
  perror("Erro a eliminar queue.");
  exit(-1);
 }
 return;
}

canonical_original_code:
void DestroiMailbox(unsigned int key)
{
 int id;
 if ((id=msgget(key, 0)) < 0) {
  perror("Erro a associar a queue.");
  exit(-1);
 }
 if (msgctl(id, 0, 0) < 0) {
  perror("Erro a eliminar queue.");
  exit(-1);
 }
 return;
}

variable_types: id int


CriaMemoriaPartilhada

decompiled_code:
void *__fastcall CriaMemoriaPartilhada(key_t a1, int a2)
{
int v2; // eax

v2 = shmget(a1, a2, 950);
if ( v2 < 0 )
_assert_fail("( id = shmget( key, n_bytes, 0666 | IPC_CREAT ) ) >= 0", "memoria.c", 0xEu, "CriaMemoriaPartilhada");
return shmat(v2, 0LL, 0);
}

canonical_decompiled_code:
void *__fastcall func0(key_t a1, int a2)
{
int v2; // eax

v2 = shmget(a1, a2, 950);
if ( v2 < 0 )
_assert_fail("( id = shmget( key, n_bytes, 0666 | IPC_CREAT ) ) >= 0", "memoria.c", 0xEu, "CriaMemoriaPartilhada");
return shmat(v2, 0LL, 0);
}

original_code:
void* CriaMemoriaPartilhada(int key, int n_bytes)
{
  void* ptr;
  int id;
  ((void) sizeof ((( id = shmget( key, n_bytes, 0666 | 01000 ) ) >= 0) ? 1 : 0), __extension__ ({ if (( id = shmget( key, n_bytes, 0666 | 01000 ) ) >= 0) ; else __assert_fail ("( id = shmget( key, n_bytes, 0666 | IPC_CREAT ) ) >= 0", "memoria.c", 14, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((( ptr = shmat( id, 0, 0) ) >= (void*)0) ? 1 : 0), __extension__ ({ if (( ptr = shmat( id, 0, 0) ) >= (void*)0) ; else __assert_fail ("( ptr = shmat( id, 0, 0) ) >= (void*)0", "memoria.c", 16, __extension__ __PRETTY_FUNCTION__); }));
  return ptr;
}

canonical_original_code:
void *CriaMemoriaPartilhada(int key, int n_bytes)
{
  void *ptr;
  int id;
  ((void) sizeof ((( id = shmget( key, n_bytes, 0666 | 01000 ) ) >= 0) ? 1 : 0), __extension__ ({ if (( id = shmget( key, n_bytes, 0666 | 01000 ) ) >= 0) ; else __assert_fail ("( id = shmget( key, n_bytes, 0666 | IPC_CREAT ) ) >= 0", "memoria.c", 14, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((( ptr = shmat( id, 0, 0) ) >= (void *)0) ? 1 : 0), __extension__ ({ if (( ptr = shmat( id, 0, 0) ) >= (void *)0) ; else __assert_fail ("( ptr = shmat( id, 0, 0) ) >= (void*)0", "memoria.c", 16, __extension__ __PRETTY_FUNCTION__); }));
  return ptr;
}

variable_types: key int

variable_types:
ptr
void *