decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int16 v3; // ax
__int16 v4; // ax
__int16 v5; // ax
__int16 v6; // ax
char v8[2]; // [rsp+6h] [rbp-12h] BYREF
void *v9; // [rsp+8h] [rbp-10h] BYREF

setbuf(stdout, 0LL);
printf("\x1B[H\x1B[J");
puts(" ========================================================================");
puts(" == 7300 SAMPLE : PCI-7300 Multiple Buffered DMA ==");
puts(" ========================================================================\n\n");
printf(
" The output data is a sine wave and store data to file '%s'. It will not stop until you press a key.\n"
"\n"
"Press any key to start the operation.\n",
file_name);
getch();
v3 = Register_Card(15LL, (unsigned __int16)card_number);
card = v3;
if ( v3 < 0 )
{
printf("Register_Card error=%d\n", (unsigned int)v3);
exit(1);
}
fp = fopen(file_name, "w+b");
if ( fp )
{
memset(&in_buf, 0, (size_t)&unk_30D40);
memset(&in_buf2, 0, (size_t)&unk_30D40);
v9 = &unk_186A0;
v4 = DI_7300B_Config((unsigned __int16)card, 16LL, 4LL, 0LL, 1LL, 0LL, 1LL, 1LL);
if ( v4 )
{
printf("DI_7300B_Config error=%d\n", (unsigned int)v4);
}
else
{
DI_EventCallBack((unsigned __int16)card, 1LL, 1LL, signal_handler);
DI_EventCallBack((unsigned __int16)card, 1LL, 0LL, signal_handler2);
v5 = DI_ContMultiBufferSetup((unsigned __int16)card, &in_buf, data_size, v8);
if ( v5 >= 0 )
{
v5 = DI_ContMultiBufferSetup((unsigned __int16)card, &in_buf2, data_size, v8);
if ( v5 >= 0 )
{
v6 = DI_ContMultiBufferStart((unsigned __int16)card, 0LL, 1.0);
if ( v6 >= 0 )
{
printf("\n\nPress any key to stop input operation.");
puts("\n\nData count : ");
getch();
if ( (unsigned __int16)DI_AsyncClear((unsigned __int16)card, &count) )
{
puts("D2K_AI_AsyncClear Failed !!!, Ready to system hang !!!");
getch();
}
DI_EventCallBack((unsigned __int16)card, 0LL, 1LL, 0LL);
DI_EventCallBack((unsigned __int16)card, 0LL, 0LL, 0LL);
Release_Card((unsigned __int16)card);
fclose(fp);
exit(1);
}
printf("DI_ContMultiBufferStart error=%d", (unsigned int)v6);
DO_AsyncClear((unsigned __int16)card, &v9);
Release_Card((unsigned __int16)card);
exit(1);
}
}
printf("DI_ContMultiBufferSetup Error=%d\n", (unsigned int)v5);
}
Release_Card((unsigned __int16)card);
exit(1);
}
return -10;
}

original_code:
int main(void)
{
    I16 err;
    U32 i;
    U16 BufferId;
    setbuf( stdout, ((void *)0) );
    printf("\033[H\033[J");
    printf(" ========================================================================\n");
    printf(" ==           7300 SAMPLE : PCI-7300 Multiple Buffered DMA             ==\n");
    printf(" ========================================================================\n\n\n");
    printf(" The output data is a sine wave and store data to file '%s'. It will not stop until you press a key.\n\nPress any key to start the operation.\n", file_name );
    getch();
    if ((card=Register_Card(15, card_number)) < 0) {
        printf("Register_Card error=%d\n", card);
        exit(1);
    }
    if( (fp = fopen( file_name, "w+b" ) ) == ((void *)0) )
        return -10;
    for (i=0; i<100000; i++) {
        in_buf[i] = (U16)(0);
        in_buf2[i] = (U16)(0);
    }
    err=DI_7300B_Config(card, 16, 4, 0, 1, 0, 1, 1);
    if (err !=0) {
        printf("DI_7300B_Config error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    DI_EventCallBack (card, 1, 1, signal_handler);
    DI_EventCallBack (card, 1, 0, signal_handler2);
    err = DI_ContMultiBufferSetup (card, in_buf, data_size, &BufferId);
    if (err < 0) {
        printf("DI_ContMultiBufferSetup Error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    err = DI_ContMultiBufferSetup (card, in_buf2, data_size, &BufferId);
    if (err < 0) {
        printf("DI_ContMultiBufferSetup Error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    err = DI_ContMultiBufferStart (card, 0, 1);
    if (err < 0) {
        printf("DI_ContMultiBufferStart error=%d", err);
        DO_AsyncClear(card, &i);
        Release_Card( card );
        exit(1);
    }
    printf("\n\nPress any key to stop input operation.");
    printf("\n\nData count : \n");
    getch();
    err = DI_AsyncClear(card, &count);
    if( err != 0 ){
        printf("D2K_AI_AsyncClear Failed !!!, Ready to system hang !!!\n" );
        getch();
    }
    DI_EventCallBack(card, 0, 1, ((void *)0));
    DI_EventCallBack(card, 0, 0, ((void *)0));
    Release_Card(card);
    fclose(fp);
    exit(1);
}

canonical_original_code:
int main()
{
    short err;
    unsigned long i;
    unsigned short BufferId;
    setbuf( stdout, ((void *)0) );
    printf("\033[H\033[J");
    printf(" ========================================================================\n");
    printf(" ==           7300 SAMPLE : PCI-7300 Multiple Buffered DMA             ==\n");
    printf(" ========================================================================\n\n\n");
    printf(" The output data is a sine wave and store data to file '%s'. It will not stop until you press a key.\n\nPress any key to start the operation.\n", file_name );
    getch();
    if ((card=Register_Card(15, card_number)) < 0) {
        printf("Register_Card error=%d\n", card);
        exit(1);
    }
    if( (fp = fopen( file_name, "w+b" ) ) == ((void *)0) )
        return -10;
    for (i=0; i<100000; i++) {
        in_buf[i] = (U16)(0);
        in_buf2[i] = (U16)(0);
    }
    err=DI_7300B_Config(card, 16, 4, 0, 1, 0, 1, 1);
    if (err !=0) {
        printf("DI_7300B_Config error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    DI_EventCallBack (card, 1, 1, signal_handler);
    DI_EventCallBack (card, 1, 0, signal_handler2);
    err = DI_ContMultiBufferSetup (card, in_buf, data_size, &BufferId);
    if (err < 0) {
        printf("DI_ContMultiBufferSetup Error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    err = DI_ContMultiBufferSetup (card, in_buf2, data_size, &BufferId);
    if (err < 0) {
        printf("DI_ContMultiBufferSetup Error=%d\n", err);
        Release_Card( card );
        exit(1);
    }
    err = DI_ContMultiBufferStart (card, 0, 1);
    if (err < 0) {
        printf("DI_ContMultiBufferStart error=%d", err);
        DO_AsyncClear(card, &i);
        Release_Card( card );
        exit(1);
    }
    printf("\n\nPress any key to stop input operation.");
    printf("\n\nData count : \n");
    getch();
    err = DI_AsyncClear(card, &count);
    if( err != 0 ){
        printf("D2K_AI_AsyncClear Failed !!!, Ready to system hang !!!\n" );
        getch();
    }
    DI_EventCallBack(card, 0, 1, ((void *)0));
    DI_EventCallBack(card, 0, 0, ((void *)0));
    Release_Card(card);
    fclose(fp);
    exit(1);
}

variable_types: err short

variable_types:
i
unsigned long

variable_types:
BufferId
unsigned short


lowerCase

decompiled_code:
char *__fastcall lowerCase(char *a1)
{
__int64 v1; // rbx
const __int32_t **v2; // rcx
char *v3; // rax

v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = _ctype_tolower_loc();
v3 = a1;
do
{
*v3++ = (*v2)[v1];
v1 = *v3;
}
while ( (_BYTE)v1 );
}
return a1;
}

canonical_decompiled_code:
char *__fastcall func0(char *a1)
{
__int64 v1; // rbx
const __int32_t **v2; // rcx
char *v3; // rax

v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = _ctype_tolower_loc();
v3 = a1;
do
{
*v3++ = (*v2)[v1];
v1 = *v3;
}
while ( (_BYTE)v1 );
}
return a1;
}

original_code:
char* lowerCase(char *palavra)
{
 int i;
 for (i = 0; palavra[i] != '\0'; i++)
  palavra[i] = tolower(palavra[i]);
 return palavra;
}

canonical_original_code:
char *lowerCase(char *palavra)
{
 int i;
 for (i = 0; palavra[i] != '\0'; i++)
  palavra[i] = tolower(palavra[i]);
 return palavra;
}

variable_types:
palavra
char *

variable_types: i int

return_type: char *


comparaString

decompiled_code:
int __fastcall comparaString(const char **a1, const char **a2)
{
const char *v2; // r15
size_t v3; // r13
void *v4; // rax
const char *v5; // r14
void *v6; // rbp
size_t v7; // rax
char *v8; // r12
char *v9; // r12
char *v10; // rax

v2 = *a1;
v3 = strlen(*a1) + 1;
v4 = malloc(8 * v3);
v5 = *a2;
v6 = v4;
v7 = strlen(*a2);
v8 = (char *)malloc(8 * v7 + 8);
memcpy(v6, v2, v3);
strcpy(v8, v5);
v9 = lowerCase(v8);
v10 = lowerCase((char *)v6);
return strcmp(v10, v9);
}

canonical_decompiled_code:
int __fastcall func1(const char **a1, const char **a2)
{
const char *v2; // r15
size_t v3; // r13
void *v4; // rax
const char *v5; // r14
void *v6; // rbp
size_t v7; // rax
char *v8; // r12
char *v9; // r12
char *v10; // rax

v2 = *a1;
v3 = strlen(*a1) + 1;
v4 = malloc(8 * v3);
v5 = *a2;
v6 = v4;
v7 = strlen(*a2);
v8 = (char *)malloc(8 * v7 + 8);
memcpy(v6, v2, v3);
strcpy(v8, v5);
v9 = func0(v8);
v10 = func0((char *)v6);
return strcmp(v10, v9);
}

original_code:
int comparaString(const void *stringA, const void *stringB)
{
 char *A = malloc((strlen(*(char**)stringA)+1) * sizeof(char*));
 char *B = malloc((strlen(*(char**)stringB)+1) * sizeof(char*));
 strcpy(A, *(char**)stringA);
 strcpy(B, *(char**)stringB);
 return strcmp(lowerCase(A), lowerCase(B));
}

canonical_original_code:
int comparaString(void *stringA, void *stringB)
{
 char *A = malloc((strlen(*(char**)stringA)+1) * sizeof(char*));
 char *B = malloc((strlen(*(char**)stringB)+1) * sizeof(char*));
 strcpy(A, *(char **)stringA);
 strcpy(B, *(char **)stringB);
 return strcmp(lowerCase(A), lowerCase(B));
}

variable_types:
stringA
void *

variable_types:
stringB
void *

variable_types:
A
char *

variable_types:
B
char *

return_type: int


hashOption

decompiled_code:
__int64 __fastcall hashOption(char *a1)
{
char v1; // al
char *v2; // rdi
unsigned int v3; // er8

v1 = *a1;
if ( !*a1 )
return 1LL;
v2 = a1 + 1;
v3 = 1;
do
{
switch ( v1 )
{
case '-':
v3 *= 2;
break;
case 'F':
v3 *= 13;
break;
case 'L':
v3 *= 29;
break;
case 'V':
v3 *= 11;
break;
case 'a':
v3 *= 5;
break;
case 'd':
v3 *= 19;
break;
case 'e':
v3 *= 3;
break;
case 'l':
v3 *= 23;
break;
case 's':
v3 *= 31;
break;
case 't':
v3 *= 17;
break;
case 'v':
v3 *= 7;
break;
default:
v3 = 0;
break;
}
v1 = *v2++;
}
while ( v1 );
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func2(char *a1)
{
char v1; // al
char *v2; // rdi
unsigned int v3; // er8

v1 = *a1;
if ( !*a1 )
return 1LL;
v2 = a1 + 1;
v3 = 1;
do
{
switch ( v1 )
{
case '-':
v3 *= 2;
break;
case 'F':
v3 *= 13;
break;
case 'L':
v3 *= 29;
break;
case 'V':
v3 *= 11;
break;
case 'a':
v3 *= 5;
break;
case 'd':
v3 *= 19;
break;
case 'e':
v3 *= 3;
break;
case 'l':
v3 *= 23;
break;
case 's':
v3 *= 31;
break;
case 't':
v3 *= 17;
break;
case 'v':
v3 *= 7;
break;
default:
v3 = 0;
break;
}
v1 = *v2++;
}
while ( v1 );
return v3;
}

original_code:
int hashOption(char *opcao)
{
 int i = 0, codigo = 1;
 char c = opcao[i];
 while (c != '\0')
 {
  switch(c)
  {
   case '-': codigo *= 2; break;
   case 'e': codigo *= 3; break;
   case 'a': codigo *= 5; break;
   case 'v': codigo *= 7; break;
   case 'V': codigo *= 11; break;
   case 'F': codigo *= 13; break;
   case 't': codigo *= 17; break;
   case 'd': codigo *= 19; break;
   case 'l': codigo *= 23; break;
   case 'L': codigo *= 29; break;
   case 's': codigo *= 31; break;
   default: codigo = 0; break;
  }
  c = opcao[++i];
 }
 return codigo;
}

canonical_original_code:
int hashOption(char *opcao)
{
 int i = 0; int codigo = 1;
 char c = opcao[i];
 while (c != '\0')
 {
  switch(c)
  {
   case '-': codigo *= 2; break;
   case 'e': codigo *= 3; break;
   case 'a': codigo *= 5; break;
   case 'v': codigo *= 7; break;
   case 'V': codigo *= 11; break;
   case 'F': codigo *= 13; break;
   case 't': codigo *= 17; break;
   case 'd': codigo *= 19; break;
   case 'l': codigo *= 23; break;
   case 'L': codigo *= 29; break;
   case 's': codigo *= 31; break;
   default: codigo = 0; break;
  }
  c = opcao[++i];
 }
 return codigo;
}

variable_types:
opcao
char *

variable_types: codigo int

variable_types: c char


hash

decompiled_code:
__int64 __fastcall hash(_BYTE *a1, int a2)
{
int v2; // ecx
unsigned int i; // edx
int v4; // eax

v2 = (char)*a1;
for ( i = 0; *a1; i = v4 % a2 )
{
++a1;
v4 = v2 + 127 * i;
v2 = (char)*a1;
}
return i;
}

canonical_decompiled_code:
__int64 __fastcall func3(_BYTE *a1, int a2)
{
int v2; // ecx
unsigned int i; // edx
int v4; // eax

v2 = (char)*a1;
for ( i = 0; *a1; i = v4 % a2 )
{
++a1;
v4 = v2 + 127 * i;
v2 = (char)*a1;
}
return i;
}

original_code:
int hash(char *palavra, int tableSize)
{
 int h = 0, a = 127;
 while (*palavra != '\0')
 {
  h = (a * h + *palavra)%tableSize;
  palavra++;
 }
 return h;
}

canonical_original_code:
int hash(char *palavra, int tableSize)
{
 int h = 0; int a = 127;
 while (*palavra != '\0')
 {
  h = (a * h + *palavra)%tableSize;
  palavra++;
 }
 return h;
}

variable_types: tableSize int

variable_types: h int

variable_types: a int


initSentence

decompiled_code:
void *__fastcall initSentence(int a1)
{
void *result; // rax

result = malloc(24LL * a1);
sentences = (__int64)result;
return result;
}

canonical_decompiled_code:
void *__fastcall func4(int a1)
{
void *result; // rax

result = malloc(24LL * a1);
sentences = (__int64)result;
return result;
}

original_code:
void initSentence(int slots)
{
 sentences = malloc(slots * sizeof(Sentenca));
}

variable_types: slots int

return_type: void


insertVal

original_code:
static Valor* insertVal(Valor *ini, Valor *novo)
{
 Valor *p;
 if (ini == ((void *)0))
  return ini = novo;
 p = ini->ant;
 p->prox = novo;
 ini->ant = novo;
 novo->prox = ini;
 novo->ant = p;
 return ini;
}

canonical_original_code:
static struct valor *insertVal(struct valor *ini, struct valor *novo)
{
 struct valor *p;
 if (ini == ((void *)0))
  return ini = novo;
 p = ini->ant;
 p->prox = novo;
 ini->ant = novo;
 novo->prox = ini;
 novo->ant = p;
 return ini;
}

variable_types:
ini
struct valor *

variable_types:
novo
struct valor *

variable_types: struct valor { char *palavra; char *lema; int sentenca; struct valor *ant; struct valor *prox; } *


original_code:
void ST_t2_insert(Valor *val)
{
 int i;
 Node *p;
 if (N > M-1)
  remapeiaTabela();
 i = hash(val->lema, M);
 p = t2enc_head[i];
 while (p != ((void *)0) && p->valor != ((void *)0))
 {
  if (strcmp(p->valor->lema, val->lema) == 0)
  {
   p->valor = insertVal(p->valor, val);
   break;
  }
  p = p->prox;
 }
 if (p == ((void *)0))
 {
  t2enc_head[i] = newNode(val, t2enc_head[i]);
  if (((*__ctype_b_loc ())[(int) ((val->lema[0]))] & (unsigned short int) _ISalpha))
   L++;
 }
 N++;
}

canonical_original_code:
void ST_t2_insert(struct valor *val)
{
 int i;
 struct node *p;
 if (N > M-1)
  remapeiaTabela();
 i = hash(val->lema, M);
 p = t2enc_head[i];
 while (p != ((void *)0) && p->valor != ((void *)0))
 {
  if (strcmp(p->valor->lema, val->lema) == 0)
  {
   p->valor = insertVal(p->valor, val);
   break;
  }
  p = p->prox;
 }
 if (p == ((void *)0))
 {
  t2enc_head[i] = newNode(val, t2enc_head[i]);
  if (((*__ctype_b_loc ())[(int) ((val->lema[0]))] & (unsigned short) _ISalpha))
   L++;
 }
 N++;
}

variable_types: struct node { struct valor { char *palavra; char *lema; int sentenca; struct valor *ant; struct valor *prox; } *valor; struct node *prox; } *

user_defined_types: struct node { struct valor *valor; struct node *prox; }


decompiled_code:
__int64 __fastcall ST_t2_search(const char *a1)
{
__int64 v2; // rax
__int64 v3; // rbx
int v4; // eax

v2 = ST_t1_search();
if ( v2 )
a1 = *(const char **)(v2 + 8);
v3 = t2enc_head;
v4 = hash(a1, (unsigned int)M);
return searchRec(*(_QWORD **)(v3 + 8LL * v4), a1);
}

canonical_decompiled_code:
__int64 __fastcall func5(const char *a1)
{
__int64 v2; // rax
__int64 v3; // rbx
int v4; // eax

v2 = ST_t1_search();
if ( v2 )
a1 = *(const char **)(v2 + 8);
v3 = t2enc_head;
v4 = hash(a1, (unsigned int)M);
return func1(*(_QWORD **)(v3 + 8LL * v4), a1);
}

original_code:
Valor* ST_t2_search(char *chave)
{
 Valor *temp = ST_t1_search(chave);
 if (temp != ((void *)0))
  return searchRec(t2enc_head[hash(temp->lema, M)], temp->lema);
 return searchRec(t2enc_head[hash(chave, M)], chave);
}

canonical_original_code:
struct valor *ST_t2_search(char *chave)
{
 struct valor *temp = ST_t1_search(chave);
 if (temp != ((void *)0))
  return searchRec(t2enc_head[hash(temp->lema, M)], temp->lema);
 return searchRec(t2enc_head[hash(chave, M)], chave);
}

variable_types:
chave
char *

return_type: struct valor { char *palavra; char *lema; int sentenca; struct valor *ant; struct valor *prox; } *


decompiled_code:
void *ST_t2_init()
{
void *result; // rax

N = 0;
M = 193;
result = malloc(0xC10uLL);
t2enc_head = (__int64)result;
return result;
}

canonical_decompiled_code:
void *func6()
{
void *result; // rax

N = 0;
M = 193;
result = malloc(0xC10uLL);
t2enc_head = (__int64)result;
return result;
}

original_code:
void ST_t2_init()
{
 N = 0;
 M = 193;
 t2enc_head = malloc(M * sizeof(Node));
}


decompiled_code:
void __fastcall ST_t2_list(int a1)
{
void *v1; // rbp
_QWORD **v2; // rax
__int64 v3; // rbx
__int64 v4; // r12
size_t v5; // rsi
__int64 v6; // rbx
const char *v7; // rdi
__int64 v8; // rbx
const char *v9; // r12
__int64 v10; // r13
int v11; // eax
__int64 v12; // rax

cnt = 0;
v1 = malloc(8LL * N);
if ( M <= 0 )
{
v5 = 0LL;
}
else
{
v2 = (_QWORD **)t2enc_head;
v3 = t2enc_head + 8;
v4 = t2enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v2 )
listRec(*v2, (__int64)v1);
v2 = (_QWORD **)v3;
if ( v3 == v4 )
break;
v3 += 8LL;
}
v5 = cnt;
}
qsort(v1, v5, 8uLL, (__compar_fn_t)&comparaString);
if ( a1 == 1 )
{
v8 = 0LL;
while ( cnt > (int)v8 )
{
printf("%s ", *((const char **)v1 + v8));
v9 = (const char *)*((_QWORD *)v1 + v8++);
v10 = t2enc_head;
v11 = hash(v9, (unsigned int)M);
v12 = searchRec(*(_QWORD **)(v10 + 8LL * v11), v9);
printValor(v12, 0LL, 3LL);
}
}
else if ( !a1 && cnt > 0 )
{
v6 = 0LL;
do
{
v7 = (const char *)*((_QWORD *)v1 + v6++);
puts(v7);
}
while ( cnt > (int)v6 );
}
putchar(10);
free(v1);
}

canonical_decompiled_code:
void __fastcall func7(int a1)
{
void *v1; // rbp
_QWORD **v2; // rax
__int64 v3; // rbx
__int64 v4; // r12
size_t v5; // rsi
__int64 v6; // rbx
const char *v7; // rdi
__int64 v8; // rbx
const char *v9; // r12
__int64 v10; // r13
int v11; // eax
__int64 v12; // rax

cnt = 0;
v1 = malloc(8LL * N);
if ( M <= 0 )
{
v5 = 0LL;
}
else
{
v2 = (_QWORD **)t2enc_head;
v3 = t2enc_head + 8;
v4 = t2enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v2 )
func2(*v2, (__int64)v1);
v2 = (_QWORD **)v3;
if ( v3 == v4 )
break;
v3 += 8LL;
}
v5 = cnt;
}
qsort(v1, v5, 8uLL, (__compar_fn_t)&comparaString);
if ( a1 == 1 )
{
v8 = 0LL;
while ( cnt > (int)v8 )
{
printf("%s ", *((const char **)v1 + v8));
v9 = (const char *)*((_QWORD *)v1 + v8++);
v10 = t2enc_head;
v11 = hash(v9, (unsigned int)M);
v12 = func1(*(_QWORD **)(v10 + 8LL * v11), v9);
printValor(v12, 0LL, 3LL);
}
}
else if ( !a1 && cnt > 0 )
{
v6 = 0LL;
do
{
v7 = (const char *)*((_QWORD *)v1 + v6++);
puts(v7);
}
while ( cnt > (int)v6 );
}
putchar(10);
free(v1);
}

original_code:
void ST_t2_list(int modo)
{
 char **tokens;
 int i;
 cnt = 0;
 tokens = malloc(N * sizeof(char*));
 for (i = 0; i < M; i++)
 {
  if(t2enc_head[i] != ((void *)0))
   listRec(t2enc_head[i], tokens);
 }
 qsort(tokens, cnt, sizeof(tokens[0]), comparaString);
 if (modo == 1)
 {
  for (i = 0; i < cnt; i++)
  {
   printf("%s ", tokens[i]);
   printValor(searchRec(t2enc_head[hash(tokens[i], M)], tokens[i]), ((void *)0), 3);
  }
 }
 else if (modo == 0)
 {
  for (i = 0; i < cnt; i++)
   printf("%s\n", tokens[i]);
 }
 printf("\n");
 free(tokens);
}

canonical_original_code:
void ST_t2_list(int modo)
{
 char **tokens;
 int i;
 cnt = 0;
 tokens = malloc(N * sizeof(char *));
 for (i = 0; i < M; i++)
 {
  if(t2enc_head[i] != ((void *)0))
   listRec(t2enc_head[i], tokens);
 }
 qsort(tokens, cnt, sizeof(tokens[0]), comparaString);
 if (modo == 1)
 {
  for (i = 0; i < cnt; i++)
  {
   printf("%s ", tokens[i]);
   printValor(searchRec(t2enc_head[hash(tokens[i], M)], tokens[i]), ((void *)0), 3);
  }
 }
 else if (modo == 0)
 {
  for (i = 0; i < cnt; i++)
   printf("%s\n", tokens[i]);
 }
 printf("\n");
 free(tokens);
}

variable_types: modo int

variable_types:
tokens
char **

variable_types: i int


decompiled_code:
__int64 ST_t2_count()
{
return (unsigned int)L;
}

canonical_decompiled_code:
__int64 func8()
{
return (unsigned int)L;
}

original_code:
int ST_t2_count()
{
 return L;
}

canonical_original_code:
int ST_t2_count()
{
 return L;
}


user_defined_types: struct valor { char *palavra; char *lema; int sentenca; struct valor *ant; struct valor *prox; }


decompiled_code:
const unsigned __int16 *__fastcall ST_t1_insert(const char **a1)
{
__int64 v1; // rsi
__int64 *v2; // r15
__int64 v3; // r14
const char *v4; // r12
__int64 v5; // rbx
const char **v6; // rbp
const unsigned __int16 *result; // rax
__int64 v8; // rax
__int64 *v9; // rax

v1 = (unsigned int)M;
if ( M <= N )
{
remapeiaTabela();
v1 = (unsigned int)M;
}
v2 = (__int64 *)(t1enc_head + 8LL * (int)hash(*a1, v1));
v3 = *v2;
if ( *v2 )
{
v4 = *a1;
v5 = *v2;
while ( 1 )
{
v6 = *(const char ***)v5;
if ( !*(_QWORD *)v5 )
break;
if ( !strcmp(*v6, v4) )
{
v8 = insertVal((__int64)v6, (__int64)a1);
v4 = *a1;
*(_QWORD *)v5 = v8;
break;
}
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
goto LABEL_12;
}
}
else
{
LABEL_12:
v9 = newNode((__int64)a1, v3);
v4 = *a1;
*v2 = (__int64)v9;
}
result = *_ctype_b_loc();
if ( (result[*v4] & 0x400) != 0 )
++P;
++N;
return result;
}

canonical_decompiled_code:
const unsigned __int16 *__fastcall func4(const char **a1)
{
__int64 v1; // rsi
__int64 *v2; // r15
__int64 v3; // r14
const char *v4; // r12
__int64 v5; // rbx
const char **v6; // rbp
const unsigned __int16 *result; // rax
__int64 v8; // rax
__int64 *v9; // rax

v1 = (unsigned int)M;
if ( M <= N )
{
func3();
v1 = (unsigned int)M;
}
v2 = (__int64 *)(t1enc_head + 8LL * (int)hash(*a1, v1));
v3 = *v2;
if ( *v2 )
{
v4 = *a1;
v5 = *v2;
while ( 1 )
{
v6 = *(const char ***)v5;
if ( !*(_QWORD *)v5 )
break;
if ( !strcmp(*v6, v4) )
{
v8 = func0((__int64)v6, (__int64)a1);
v4 = *a1;
*(_QWORD *)v5 = v8;
break;
}
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
goto LABEL_12;
}
}
else
{
LABEL_12:
v9 = newNode((__int64)a1, v3);
v4 = *a1;
*v2 = (__int64)v9;
}
result = *_ctype_b_loc();
if ( (result[*v4] & 0x400) != 0 )
++P;
++N;
return result;
}

original_code:
void ST_t1_insert(Valor *val)
{
 int i;
 Node *p;
 if (N > M-1)
  remapeiaTabela();
 i = hash(val->palavra, M);
 p = t1enc_head[i];
 while (p != ((void *)0) && p->valor != ((void *)0))
 {
  if (strcmp(p->valor->palavra, val->palavra) == 0)
  {
   p->valor = insertVal(p->valor, val);
   break;
  }
  p = p->prox;
 }
 if (p == ((void *)0))
  t1enc_head[i] = newNode(val, t1enc_head[i]);
 if (((*__ctype_b_loc ())[(int) ((val->palavra[0]))] & (unsigned short int) _ISalpha))
  P++;
 N++;
}

canonical_original_code:
void ST_t1_insert(struct valor *val)
{
 int i;
 struct node *p;
 if (N > M-1)
  remapeiaTabela();
 i = hash(val->palavra, M);
 p = t1enc_head[i];
 while (p != ((void *)0) && p->valor != ((void *)0))
 {
  if (strcmp(p->valor->palavra, val->palavra) == 0)
  {
   p->valor = insertVal(p->valor, val);
   break;
  }
  p = p->prox;
 }
 if (p == ((void *)0))
  t1enc_head[i] = newNode(val, t1enc_head[i]);
 if (((*__ctype_b_loc ())[(int) ((val->palavra[0]))] & (unsigned short) _ISalpha))
  P++;
 N++;
}


decompiled_code:
const char **__fastcall ST_t1_search(const char *a1)
{
__int64 v1; // rbx
int v2; // eax

v1 = t1enc_head;
v2 = hash(a1, (unsigned int)M);
return searchRec(*(_QWORD *)(v1 + 8LL * v2), a1);
}

canonical_decompiled_code:
const char **__fastcall func5(const char *a1)
{
__int64 v1; // rbx
int v2; // eax

v1 = t1enc_head;
v2 = hash(a1, (unsigned int)M);
return func1(*(_QWORD *)(v1 + 8LL * v2), a1);
}

original_code:
Valor* ST_t1_search(char *chave)
{
 return searchRec(t1enc_head[hash(chave, M)], chave);
}

canonical_original_code:
struct valor *ST_t1_search(char *chave)
{
 return searchRec(t1enc_head[hash(chave, M)], chave);
}


decompiled_code:
void *ST_t1_init()
{
void *result; // rax

N = 0;
M = 193;
result = malloc(0xC10uLL);
t1enc_head = (__int64)result;
return result;
}

canonical_decompiled_code:
void *func6()
{
void *result; // rax

N = 0;
M = 193;
result = malloc(0xC10uLL);
t1enc_head = (__int64)result;
return result;
}

original_code:
void ST_t1_init()
{
 N = 0;
 M = 193;
 t1enc_head = malloc(M * sizeof(Node));
}


decompiled_code:
void __fastcall ST_t1_list(int a1)
{
void *v1; // rbp
char ****v2; // rax
__int64 v3; // rbx
__int64 v4; // r12
size_t v5; // rsi
__int64 v6; // rbx
const char *v7; // rdi

cnt = 0;
v1 = malloc(8LL * N);
if ( M <= 0 )
{
v5 = 0LL;
}
else
{
v2 = (char ****)t1enc_head;
v3 = t1enc_head + 8;
v4 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v2 )
listRec(*v2, (__int64)v1, a1);
v2 = (char ****)v3;
if ( v3 == v4 )
break;
v3 += 8LL;
}
v5 = cnt;
}
v6 = 0LL;
qsort(v1, v5, 8uLL, (__compar_fn_t)&comparaString);
if ( cnt > 0 )
{
do
{
v7 = (const char *)*((_QWORD *)v1 + v6++);
puts(v7);
}
while ( cnt > (int)v6 );
}
putchar(10);
free(v1);
}

canonical_decompiled_code:
void __fastcall func7(int a1)
{
void *v1; // rbp
char ****v2; // rax
__int64 v3; // rbx
__int64 v4; // r12
size_t v5; // rsi
__int64 v6; // rbx
const char *v7; // rdi

cnt = 0;
v1 = malloc(8LL * N);
if ( M <= 0 )
{
v5 = 0LL;
}
else
{
v2 = (char ****)t1enc_head;
v3 = t1enc_head + 8;
v4 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v2 )
func2(*v2, (__int64)v1, a1);
v2 = (char ****)v3;
if ( v3 == v4 )
break;
v3 += 8LL;
}
v5 = cnt;
}
v6 = 0LL;
qsort(v1, v5, 8uLL, (__compar_fn_t)&comparaString);
if ( cnt > 0 )
{
do
{
v7 = (const char *)*((_QWORD *)v1 + v6++);
puts(v7);
}
while ( cnt > (int)v6 );
}
putchar(10);
free(v1);
}

original_code:
void ST_t1_list(int modo)
{
 char **tokens;
 int i;
 cnt = 0;
 tokens = malloc(N * sizeof(char*));
 for (i = 0; i < M; i++)
 {
  if(t1enc_head[i] != ((void *)0))
   listRec(t1enc_head[i], tokens, modo);
 }
 qsort(tokens, cnt, sizeof(tokens[0]), comparaString);
 for (i = 0; i < cnt; i++)
  printf("%s\n", tokens[i]);
 printf("\n");
 free(tokens);
}

canonical_original_code:
void ST_t1_list(int modo)
{
 char **tokens;
 int i;
 cnt = 0;
 tokens = malloc(N * sizeof(char *));
 for (i = 0; i < M; i++)
 {
  if(t1enc_head[i] != ((void *)0))
   listRec(t1enc_head[i], tokens, modo);
 }
 qsort(tokens, cnt, sizeof(tokens[0]), comparaString);
 for (i = 0; i < cnt; i++)
  printf("%s\n", tokens[i]);
 printf("\n");
 free(tokens);
}


decompiled_code:
__int64 __fastcall ST_t1_count(int a1)
{
unsigned int v1; // er12
void *v2; // rax
__int64 v3; // rbp
char ****v5; // rax
__int64 v6; // rbx
__int64 v7; // r12
char ****v9; // rax
__int64 v10; // rbx
__int64 v11; // r12

v1 = N;
v2 = malloc(8LL * N);
v3 = (__int64)v2;
if ( a1 == 2 )
{
cnt = 0;
if ( M <= 0 )
return 0LL;
v9 = (char ****)t1enc_head;
v10 = t1enc_head + 8;
v11 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v9 )
listRec(*v9, v3, 0);
v9 = (char ****)v10;
if ( v10 == v11 )
break;
v10 += 8LL;
}
return (unsigned int)cnt;
}
if ( a1 <= 2 )
{
if ( !a1 )
return v1;
if ( a1 == 1 )
return (unsigned int)P;
goto LABEL_16;
}
if ( a1 != 3 )
{
LABEL_16:
free(v2);
return 0LL;
}
cnt = 0;
if ( M > 0 )
{
v5 = (char ****)t1enc_head;
v6 = t1enc_head + 8;
v7 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v5 )
listRec(*v5, v3, 1);
v5 = (char ****)v6;
if ( v6 == v7 )
break;
v6 += 8LL;
}
return (unsigned int)cnt;
}
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func8(int a1)
{
unsigned int v1; // er12
void *v2; // rax
__int64 v3; // rbp
char ****v5; // rax
__int64 v6; // rbx
__int64 v7; // r12
char ****v9; // rax
__int64 v10; // rbx
__int64 v11; // r12

v1 = N;
v2 = malloc(8LL * N);
v3 = (__int64)v2;
if ( a1 == 2 )
{
cnt = 0;
if ( M <= 0 )
return 0LL;
v9 = (char ****)t1enc_head;
v10 = t1enc_head + 8;
v11 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v9 )
func2(*v9, v3, 0);
v9 = (char ****)v10;
if ( v10 == v11 )
break;
v10 += 8LL;
}
return (unsigned int)cnt;
}
if ( a1 <= 2 )
{
if ( !a1 )
return v1;
if ( a1 == 1 )
return (unsigned int)P;
goto LABEL_16;
}
if ( a1 != 3 )
{
LABEL_16:
free(v2);
return 0LL;
}
cnt = 0;
if ( M > 0 )
{
v5 = (char ****)t1enc_head;
v6 = t1enc_head + 8;
v7 = t1enc_head + 8 + 8LL * (unsigned int)(M - 1);
while ( 1 )
{
if ( *v5 )
func2(*v5, v3, 1);
v5 = (char ****)v6;
if ( v6 == v7 )
break;
v6 += 8LL;
}
return (unsigned int)cnt;
}
return 0LL;
}

original_code:
int ST_t1_count(int modo)
{
 int i;
 char **temp = malloc(N * sizeof(char*));
 switch(modo)
 {
  case 0:
   return N;
  case 1:
   return P;
  case 2:
   cnt = 0;
   for (i = 0; i < M; i++)
   {
    if (t1enc_head[i] != ((void *)0))
     listRec(t1enc_head[i], temp, 0);
   }
   return cnt;
  case 3:
   cnt = 0;
   for (i = 0; i < M; i++)
   {
    if (t1enc_head[i] != ((void *)0))
     listRec(t1enc_head[i], temp, 1);
   }
   return cnt;
  default:
   break;
 }
 free (temp);
 return 0;
}

variable_types:
temp
char **


main

canonical_name: main

repo: elreplicante/simple-file-system

decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
__int64 v4; // rsi
unsigned int v5; // eax
__int64 v6; // rax
void *v7; // rbp
__int64 v8; // rax
__int64 v9; // r12
const char *v10; // r13
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // eax
unsigned int v14; // eax
_DWORD v15[1738]; // [rsp+0h] [rbp-1B28h] BYREF

v15[1724] = 45;
if ( argc != 4 || strcmp(argv[1], "-mkfs") )
{
fwrite(&unk_A8, 1uLL, 0x6DuLL, stderr);
exit(-1);
}
v4 = (unsigned int)atoi(argv[2]);
v5 = myMkfs(v15, v4, argv[3]);
if ( v5 )
{
fprintf(stderr, format, v5);
exit(-1);
}
initNodosI(v15, v4, 0LL);
fwrite("Sistema de ficheros disponible\n", 1uLL, 0x1FuLL, stderr);
while ( 1 )
{
while ( 1 )
{
v6 = readline("% ");
v7 = (void *)v6;
if ( v6 )
break;
fwrite("Incapaz de leer un comando\n", 1uLL, 0x1BuLL, stderr);
}
v8 = parse(v6);
v9 = v8;
if ( v8 )
{
v10 = *(const char **)(v8 + 16);
if ( v10 )
{
if ( !memcmp(*(const void **)(v8 + 16), "import", 6uLL) )
{
if ( *(_DWORD *)(v8 + 104) == 3 )
{
v11 = myImport(*(_QWORD *)(v8 + 32), v15, *(_QWORD *)(v8 + 40));
if ( v11 )
fprintf(stderr, aIncapazDeImpor, *(_QWORD *)(v9 + 32), *(_QWORD *)(v9 + 40), v11);
}
else
{
fwrite("import nombreArchivoExterno nombreArchivoInterno\n", 1uLL, 0x31uLL, stderr);
}
}
else if ( !memcmp(v10, "export", 6uLL) )
{
if ( *(_DWORD *)(v8 + 104) == 3 )
{
v12 = myExport(v15, *(_QWORD *)(v8 + 32), *(_QWORD *)(v8 + 40));
if ( v12 )
fprintf(stderr, aIncapazDeExpor, *(_QWORD *)(v9 + 32), *(_QWORD *)(v9 + 40), v12);
}
else
{
fwrite("export nombreArchivoInterno nombreArchivoExterno \n", 1uLL, 0x32uLL, stderr);
}
}
else if ( !strncmp(v10, "rm", 2uLL) )
{
if ( *(_DWORD *)(v9 + 104) == 2 )
{
v13 = myRm(v15, *(_QWORD *)(v9 + 32));
if ( v13 )
fprintf(stderr, aIncapazDeBorra, *(_QWORD *)(v9 + 32), v13);
}
else
{
fwrite("rm nombreArchivo\n", 1uLL, 0x11uLL, stderr);
}
}
else if ( !strncmp(v10, "ls", 2uLL) )
{
myLs(v15);
}
else if ( !strncmp(v10, "quota", 5uLL) )
{
v14 = myQuota(v15);
fprintf(stderr, "Espacio libre: %d bytes, %d bloques\n", v14 << 12, v14);
}
else if ( !strncmp(v10, "exit", 4uLL) )
{
myExit(v15);
}
else
{
fprintf(stderr, "Comando desconocido: %s\n", v10);
fwrite("\tPrueba con: import, export, ls, rm, quota, exit\n", 1uLL, 0x31uLL, stderr);
}
}
free_info(v9);
}
free(v7);
}
}

original_code:
int main(int argc, char** argv) {
    MiSistemaDeFicheros miSistemaDeFicheros;
    miSistemaDeFicheros.numNodosLibres = ((4096/sizeof(EstructuraNodoI)) * 5);
    char* lineaComando;
    parseInfo* info;
    struct commandType* comando;
    int ret;
    if ((argc == 4) && (strcmp(argv[1],"-mkfs")==0)) {
     ret = myMkfs(&miSistemaDeFicheros, atoi(argv[2]), argv[3]);
        if (ret) {
            fprintf(stderr, "Incapaz de formatear, código de error: %d\n", ret);
            exit(-1);
        }
    } else {
        fprintf(stderr, "Error, debes introducir el tamaño del disco y su nombre: ./MiSistemaDeFicheros -mkfs tamDisco nombreArchivo\n");
        exit(-1);
    }
    initNodosI(&miSistemaDeFicheros);
    fprintf(stderr, "Sistema de ficheros disponible\n");
    while (1) {
        lineaComando = readline("% ");
        if (lineaComando == ((void *)0)) {
            fprintf(stderr, "Incapaz de leer un comando\n");
            continue;
        }
        info = parse(lineaComando);
        if (info == ((void *)0)) {
            free(lineaComando);
            continue;
        }
        comando = &info->CommArray[0];
        if ((comando == ((void *)0)) || (comando->command == ((void *)0))) {
            free_info(info);
            free(lineaComando);
            continue;
        }
        if (strncmp(comando->command, "import", strlen("import")) == 0) {
            if (comando->VarNum != 3) {
                fprintf(stderr, "import nombreArchivoExterno nombreArchivoInterno\n");
            } else {
             ret = myImport(comando->VarList[1], &miSistemaDeFicheros, comando->VarList[2]);
                if (ret) {
                    fprintf(stderr, "Incapaz de importar el fichero externo %s en nuestro sistema de ficheros como %s. código de error: %d\n", comando->VarList[1], comando->VarList[2], ret);
                }
            }
        } else if (strncmp(comando->command, "export", strlen("export")) == 0) {
            if (comando->VarNum != 3) {
                fprintf(stderr, "export nombreArchivoInterno nombreArchivoExterno \n");
            } else {
             ret = myExport(&miSistemaDeFicheros, comando->VarList[1], comando->VarList[2]);
                if (ret) {
                    fprintf(stderr, "Incapaz de exportar el archivo interno %s a el archivo externo %s, código de error: %d\n", comando->VarList[1], comando->VarList[2], ret);
                }
            }
        } else if (strncmp(comando->command, "rm", strlen("rm")) == 0) {
            if (comando->VarNum != 2) {
                fprintf(stderr, "rm nombreArchivo\n");
            } else {
             ret = myRm(&miSistemaDeFicheros, comando->VarList[1]);
                if (ret) {
                    fprintf(stderr, "Incapaz de borrar el archivo %s, código de error: %d\n", comando->VarList[1], ret);
                }
            }
        } else if (strncmp(comando->command, "ls", strlen("ls")) == 0) {
            myLs(&miSistemaDeFicheros);
        } else if (strncmp(comando->command, "quota", strlen("quota")) == 0) {
            int free_blocks = myQuota(&miSistemaDeFicheros);
            fprintf(stderr, "Espacio libre: %d bytes, %d bloques\n", free_blocks * 4096, free_blocks);
        } else if (strncmp(comando->command, "exit", strlen("exit")) == 0) {
         myExit(&miSistemaDeFicheros);
        } else {
            fprintf(stderr, "Comando desconocido: %s\n", comando->command);
            fprintf(stderr, "\tPrueba con: import, export, ls, rm, quota, exit\n");
        }
        free_info(info);
        free(lineaComando);
    }
}

canonical_original_code:
int main(int argc, char **argv) {
    struct MiSistemaDeFicheros miSistemaDeFicheros;
    miSistemaDeFicheros.numNodosLibres = ((4096/sizeof(EstructuraNodoI)) * 5);
    char *lineaComando;
    struct parseInfo *info;
    struct commandType *comando;
    int ret;
    if ((argc == 4) && (strcmp(argv[1],"-mkfs")==0)) {
     ret = myMkfs(&miSistemaDeFicheros, atoi(argv[2]), argv[3]);
        if (ret) {
            fprintf(stderr, "Incapaz de formatear, código de error: %d\n", ret);
            exit(-1);
        }
    } else {
        fprintf(stderr, "Error, debes introducir el tamaño del disco y su nombre: ./MiSistemaDeFicheros -mkfs tamDisco nombreArchivo\n");
        exit(-1);
    }
    initNodosI(&miSistemaDeFicheros);
    fprintf(stderr, "Sistema de ficheros disponible\n");
    while (1) {
        lineaComando = readline("% ");
        if (lineaComando == ((void *)0)) {
            fprintf(stderr, "Incapaz de leer un comando\n");
            continue;
        }
        info = parse(lineaComando);
        if (info == ((void *)0)) {
            free(lineaComando);
            continue;
        }
        comando = &info->CommArray[0];
        if ((comando == ((void *)0)) || (comando->command == ((void *)0))) {
            free_info(info);
            free(lineaComando);
            continue;
        }
        if (strncmp(comando->command, "import", strlen("import")) == 0) {
            if (comando->VarNum != 3) {
                fprintf(stderr, "import nombreArchivoExterno nombreArchivoInterno\n");
            } else {
             ret = myImport(comando->VarList[1], &miSistemaDeFicheros, comando->VarList[2]);
                if (ret) {
                    fprintf(stderr, "Incapaz de importar el fichero externo %s en nuestro sistema de ficheros como %s. código de error: %d\n", comando->VarList[1], comando->VarList[2], ret);
                }
            }
        } else if (strncmp(comando->command, "export", strlen("export")) == 0) {
            if (comando->VarNum != 3) {
                fprintf(stderr, "export nombreArchivoInterno nombreArchivoExterno \n");
            } else {
             ret = myExport(&miSistemaDeFicheros, comando->VarList[1], comando->VarList[2]);
                if (ret) {
                    fprintf(stderr, "Incapaz de exportar el archivo interno %s a el archivo externo %s, código de error: %d\n", comando->VarList[1], comando->VarList[2], ret);
                }
            }
        } else if (strncmp(comando->command, "rm", strlen("rm")) == 0) {
            if (comando->VarNum != 2) {
                fprintf(stderr, "rm nombreArchivo\n");
            } else {
             ret = myRm(&miSistemaDeFicheros, comando->VarList[1]);
                if (ret) {
                    fprintf(stderr, "Incapaz de borrar el archivo %s, código de error: %d\n", comando->VarList[1], ret);
                }
            }
        } else if (strncmp(comando->command, "ls", strlen("ls")) == 0) {
            myLs(&miSistemaDeFicheros);
        } else if (strncmp(comando->command, "quota", strlen("quota")) == 0) {
            int free_blocks = myQuota(&miSistemaDeFicheros);
            fprintf(stderr, "Espacio libre: %d bytes, %d bloques\n", free_blocks * 4096, free_blocks);
        } else if (strncmp(comando->command, "exit", strlen("exit")) == 0) {
         myExit(&miSistemaDeFicheros);
        } else {
            fprintf(stderr, "Comando desconocido: %s\n", comando->command);
            fprintf(stderr, "\tPrueba con: import, export, ls, rm, quota, exit\n");
        }
        free_info(info);
        free(lineaComando);
    }
}

variable_types: argc int

variable_types:
argv
char **

variable_types: struct MiSistemaDeFicheros { int discoVirtual; struct EstructuraSuperBloque { int tamSuperBloque; int tamDirectorio; int tamNodoI; int tamDiscoEnBloques; int numBloquesLibres; int tamBloque; int maxTamNombreArchivo; int maxBloquesPorArchivo; } superBloque; unsigned int mapaDeBits[-1]; struct EstructuraDirectorio { int numArchivos; struct EstructuraArchivo { int idxNodoI; char nombreArchivo[-1]; int libre; } archivos[100]; } directorio; struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *nodosI[-1]; int numNodosLibres; }

variable_types:
lineaComando
char *

variable_types: struct parseInfo { int boolInfile; int boolOutfile; int boolBackground; struct commandType { char *command; char *VarList[10]; int VarNum; } CommArray[10]; int pipeNum; char inFile[40]; char outFile[40]; } *

variable_types: struct commandType { char *command; char *VarList[10]; int VarNum; } *

variable_types: ret int

user_defined_types: struct MiSistemaDeFicheros { int discoVirtual; struct EstructuraSuperBloque superBloque; unsigned int mapaDeBits[-1]; struct EstructuraDirectorio directorio; struct EstructuraNodoI *nodosI[-1]; int numNodosLibres; }

user_defined_types: struct EstructuraDirectorio { int numArchivos; struct EstructuraArchivo archivos[100]; }

user_defined_types: struct parseInfo { int boolInfile; int boolOutfile; int boolBackground; struct commandType CommArray[10]; int pipeNum; char inFile[40]; char outFile[40]; }


escribeMapaDeBits

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

if ( lseek(*a1, 4096LL, 0) == -1 )
{
perror(s);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 9, 0x1000uLL) == -1 )
{
perror(aFall);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

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

if ( lseek(*a1, 4096LL, 0) == -1 )
{
perror(s);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 9, 0x1000uLL) == -1 )
{
perror(aFall);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

original_code:
int escribeMapaDeBits(MiSistemaDeFicheros* miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 1, 0) == (off_t) -1) {
  perror("Falló lseek en escribeMapaDeBits");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   miSistemaDeFicheros->mapaDeBits, sizeof(unsigned) * (4096/sizeof(unsigned))) == -1) {
  perror("Falló write en escribeMapaDeBits");
  return -1;
 }
 return 0;
}

canonical_original_code:
int escribeMapaDeBits(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 1, 0) == (off_t) -1) {
  perror("Falló lseek en escribeMapaDeBits");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   miSistemaDeFicheros->mapaDeBits, sizeof(unsigned int) * (4096/sizeof(unsigned int))) == -1) {
  perror("Falló write en escribeMapaDeBits");
  return -1;
 }
 return 0;
}

variable_types: struct MiSistemaDeFicheros { int discoVirtual; struct EstructuraSuperBloque { int tamSuperBloque; int tamDirectorio; int tamNodoI; int tamDiscoEnBloques; int numBloquesLibres; int tamBloque; int maxTamNombreArchivo; int maxBloquesPorArchivo; } superBloque; unsigned int mapaDeBits[-1]; struct EstructuraDirectorio { int numArchivos; struct EstructuraArchivo { int idxNodoI; char nombreArchivo[-1]; int libre; } archivos[100]; } directorio; struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *nodosI[-1]; int numNodosLibres; } *


escribeSuperBloque

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

if ( lseek(*a1, 0LL, 0) == -1 )
{
perror(aFall_0);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 1, 0x20uLL) == -1 )
{
perror(aFall_1);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

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

if ( lseek(*a1, 0LL, 0) == -1 )
{
perror(aFall_0);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 1, 0x20uLL) == -1 )
{
perror(aFall_1);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

original_code:
int escribeSuperBloque(MiSistemaDeFicheros* miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 0, 0) == (off_t) -1) {
  perror("Falló lseek en escribeSuperBloque");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   &(miSistemaDeFicheros->superBloque), sizeof(EstructuraSuperBloque))
   == -1) {
  perror("Falló write en escribeSuperBloque");
  return -1;
 }
 return 0;
}

canonical_original_code:
int escribeSuperBloque(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 0, 0) == (off_t) -1) {
  perror("Falló lseek en escribeSuperBloque");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   &(miSistemaDeFicheros->superBloque), sizeof(EstructuraSuperBloque))
   == -1) {
  perror("Falló write en escribeSuperBloque");
  return -1;
 }
 return 0;
}

user_defined_types: struct EstructuraSuperBloque { int tamSuperBloque; int tamDirectorio; int tamNodoI; int tamDiscoEnBloques; int numBloquesLibres; int tamBloque; int maxTamNombreArchivo; int maxBloquesPorArchivo; }

user_defined_types: struct EstructuraArchivo { int idxNodoI; char nombreArchivo[-1]; int libre; }

user_defined_types: struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; }


escribeDirectorio

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

if ( lseek(*a1, 0x2000LL, 0) == -1 )
{
perror(aFall_2);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 1033, 0x964uLL) == -1 )
{
perror(aFall_3);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

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

if ( lseek(*a1, 0x2000LL, 0) == -1 )
{
perror(aFall_2);
result = 0xFFFFFFFFLL;
}
else if ( write(*a1, a1 + 1033, 0x964uLL) == -1 )
{
perror(aFall_3);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
return result;
}

original_code:
int escribeDirectorio(MiSistemaDeFicheros* miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 2, 0) == (off_t) -1) {
  perror("Falló lseek en escribeDirectorio");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   &(miSistemaDeFicheros->directorio), sizeof(EstructuraDirectorio))
   == -1) {
  perror("Falló write en escribeDirectorio");
  return -1;
 }
 return 0;
}

canonical_original_code:
int escribeDirectorio(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 if (lseek(miSistemaDeFicheros->discoVirtual, 4096
   * 2, 0) == (off_t) -1) {
  perror("Falló lseek en escribeDirectorio");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual,
   &(miSistemaDeFicheros->directorio), sizeof(EstructuraDirectorio))
   == -1) {
  perror("Falló write en escribeDirectorio");
  return -1;
 }
 return 0;
}


escribeDatos

decompiled_code:
__int64 __fastcall escribeDatos(int *a1, int a2, int a3)
{
int *v3; // r12
int v4; // er15
__int64 v5; // rbx
int v6; // ecx
__int64 result; // rax
size_t v8; // r15
ssize_t v9; // r8
int v10; // [rsp+4h] [rbp-1044h]
int v11; // [rsp+8h] [rbp-1040h]
int v12; // [rsp+Ch] [rbp-103Ch]
char buf[4152]; // [rsp+10h] [rbp-1038h] BYREF

v3 = *(int **)&a1[2 * a3 + 1634];
v4 = *v3;
v10 = a1[6];
v11 = v3[1];
if ( *v3 <= 1 )
{
v6 = 0;
LABEL_10:
v12 = v6;
v8 = v10 - (v10 * v4 - v11);
if ( read(a2, buf, v8) == -1 )
{
perror(aFall_8);
result = 0xFFFFFFFFLL;
}
else if ( lseek(*a1, v3[v12 + 4] << 12, 0) == -1 )
{
perror(aFall_9);
result = 0xFFFFFFFFLL;
}
else
{
v9 = write(*a1, buf, v8);
result = 0LL;
if ( v9 == -1 )
{
perror(aFall_5);
result = 0LL;
}
}
}
else
{
v5 = 0LL;
while ( 1 )
{
if ( read(a2, buf, 0x1000uLL) == -1 )
{
perror(aFall_4);
return 0xFFFFFFFFLL;
}
if ( lseek(*a1, v3[v5 + 4] << 12, 0) == -1 )
{
perror(aFall_6);
return 0xFFFFFFFFLL;
}
if ( write(*a1, buf, 0x1000uLL) == -1 )
break;
v6 = ++v5;
if ( *v3 - 1 <= (int)v5 )
goto LABEL_10;
}
perror(aFall_7);
result = 0xFFFFFFFFLL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func3(int *a1, int a2, int a3)
{
int *v3; // r12
int v4; // er15
__int64 v5; // rbx
int v6; // ecx
__int64 result; // rax
size_t v8; // r15
ssize_t v9; // r8
int v10; // [rsp+4h] [rbp-1044h]
int v11; // [rsp+8h] [rbp-1040h]
int v12; // [rsp+Ch] [rbp-103Ch]
char buf[4152]; // [rsp+10h] [rbp-1038h] BYREF

v3 = *(int **)&a1[2 * a3 + 1634];
v4 = *v3;
v10 = a1[6];
v11 = v3[1];
if ( *v3 <= 1 )
{
v6 = 0;
LABEL_10:
v12 = v6;
v8 = v10 - (v10 * v4 - v11);
if ( read(a2, buf, v8) == -1 )
{
perror(aFall_8);
result = 0xFFFFFFFFLL;
}
else if ( lseek(*a1, v3[v12 + 4] << 12, 0) == -1 )
{
perror(aFall_9);
result = 0xFFFFFFFFLL;
}
else
{
v9 = write(*a1, buf, v8);
result = 0LL;
if ( v9 == -1 )
{
perror(aFall_5);
result = 0LL;
}
}
}
else
{
v5 = 0LL;
while ( 1 )
{
if ( read(a2, buf, 0x1000uLL) == -1 )
{
perror(aFall_4);
return 0xFFFFFFFFLL;
}
if ( lseek(*a1, v3[v5 + 4] << 12, 0) == -1 )
{
perror(aFall_6);
return 0xFFFFFFFFLL;
}
if ( write(*a1, buf, 0x1000uLL) == -1 )
break;
v6 = ++v5;
if ( *v3 - 1 <= (int)v5 )
goto LABEL_10;
}
perror(aFall_7);
result = 0xFFFFFFFFLL;
}
return result;
}

original_code:
int escribeDatos(MiSistemaDeFicheros* miSistemaDeFicheros, int archivoExterno,
  int numNodoI) {
 int i;
 char buffer[4096];
 EstructuraNodoI* temp = miSistemaDeFicheros->nodosI[numNodoI];
 int bytesRestantes = miSistemaDeFicheros->superBloque.tamBloque
   - (temp->numBloques * miSistemaDeFicheros->superBloque.tamBloque
     - temp->tamArchivo);
 for (i = 0; i < temp->numBloques - 1; i++) {
  if (read(archivoExterno, &buffer, 4096) == -1) {
   perror("Falló read en escribeDatos");
   return -1;
  }
  if (lseek(miSistemaDeFicheros->discoVirtual, temp->idxBloques[i]
    * 4096, 0) == (off_t) -1) {
   perror("Falló lseek en escribeDatos");
   return -1;
  }
  if (write(miSistemaDeFicheros->discoVirtual, &buffer, 4096)
    == -1) {
   perror("Falló write en escribeDatos");
   return -1;
  }
 }
 if (read(archivoExterno, &buffer, bytesRestantes) == -1) {
  perror("Falló read (2) en escribeDatos");
  return -1;
 }
 if (lseek(miSistemaDeFicheros->discoVirtual, temp->idxBloques[i]
   * 4096, 0) == (off_t) -1) {
  perror("Falló lseek (2) en escribeDatos");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual, &buffer, bytesRestantes) == -1) {
  perror("Falló write (2) en escribeDatos");
 }
 return 0;
}

canonical_original_code:
int escribeDatos(struct MiSistemaDeFicheros *miSistemaDeFicheros, int archivoExterno, int numNodoI) {
 int i;
 char buffer[4096];
 struct EstructuraNodoI *temp = miSistemaDeFicheros->nodosI[numNodoI];
 int bytesRestantes = miSistemaDeFicheros->superBloque.tamBloque
   - (temp->numBloques * miSistemaDeFicheros->superBloque.tamBloque
     - temp->tamArchivo);
 for (i = 0; i < temp->numBloques - 1; i++) {
  if (read(archivoExterno, &buffer, 4096) == -1) {
   perror("Falló read en escribeDatos");
   return -1;
  }
  if (lseek(miSistemaDeFicheros->discoVirtual, temp->idxBloques[i]
    * 4096, 0) == (off_t) -1) {
   perror("Falló lseek en escribeDatos");
   return -1;
  }
  if (write(miSistemaDeFicheros->discoVirtual, &buffer, 4096)
    == -1) {
   perror("Falló write en escribeDatos");
   return -1;
  }
 }
 if (read(archivoExterno, &buffer, bytesRestantes) == -1) {
  perror("Falló read (2) en escribeDatos");
  return -1;
 }
 if (lseek(miSistemaDeFicheros->discoVirtual, temp->idxBloques[i]
   * 4096, 0) == (off_t) -1) {
  perror("Falló lseek (2) en escribeDatos");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual, &buffer, bytesRestantes) == -1) {
  perror("Falló write (2) en escribeDatos");
 }
 return 0;
}

variable_types: archivoExterno int

variable_types: numNodoI int

variable_types:
buffer
char [4096]

variable_types: struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *

variable_types: bytesRestantes int


exportaDatos

decompiled_code:
__int64 __fastcall exportaDatos(__int64 a1, int a2, int a3)
{
__int64 v3; // r14
int *v4; // rax
int v5; // ebp
int v6; // ebx
__int64 result; // rax
int v8; // [rsp+8h] [rbp-1040h]
int v9; // [rsp+Ch] [rbp-103Ch]
char buf[4152]; // [rsp+10h] [rbp-1038h] BYREF

v3 = a3 + 816LL;
v4 = *(int **)(a1 + 8 * v3 + 8);
v5 = *v4;
v8 = *(_DWORD *)(a1 + 24);
v9 = v4[1];
if ( *v4 <= 1 )
{
LABEL_6:
if ( write(a2, buf, v8 - (v8 * v5 - v9)) == -1 )
{
perror(aFall_11);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
}
else
{
v6 = 0;
while ( write(a2, buf, 0x1000uLL) != -1 )
{
if ( **(_DWORD **)(a1 + 8 * v3 + 8) - 1 <= ++v6 )
goto LABEL_6;
}
perror(aFall_10);
result = 0xFFFFFFFFLL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1, int a2, int a3)
{
__int64 v3; // r14
int *v4; // rax
int v5; // ebp
int v6; // ebx
__int64 result; // rax
int v8; // [rsp+8h] [rbp-1040h]
int v9; // [rsp+Ch] [rbp-103Ch]
char buf[4152]; // [rsp+10h] [rbp-1038h] BYREF

v3 = a3 + 816LL;
v4 = *(int **)(a1 + 8 * v3 + 8);
v5 = *v4;
v8 = *(_DWORD *)(a1 + 24);
v9 = v4[1];
if ( *v4 <= 1 )
{
LABEL_6:
if ( write(a2, buf, v8 - (v8 * v5 - v9)) == -1 )
{
perror(aFall_11);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
}
}
else
{
v6 = 0;
while ( write(a2, buf, 0x1000uLL) != -1 )
{
if ( **(_DWORD **)(a1 + 8 * v3 + 8) - 1 <= ++v6 )
goto LABEL_6;
}
perror(aFall_10);
result = 0xFFFFFFFFLL;
}
return result;
}

original_code:
int exportaDatos(MiSistemaDeFicheros* miSistemaDeFicheros, int handle,
  int idxNodoI) {
 int i;
 char buffer[4096];
 EstructuraNodoI* temp = miSistemaDeFicheros->nodosI[idxNodoI];
 int bytesRestantes = miSistemaDeFicheros->superBloque.tamBloque
   - (temp->numBloques * miSistemaDeFicheros->superBloque.tamBloque
     - temp->tamArchivo);
 for (i = 0; i < miSistemaDeFicheros->nodosI[idxNodoI]->numBloques - 1; ++i) {
  if (write(handle, &buffer, 4096) == -1) {
   perror("Falló write en exportaDatos");
   return -1;
  }
 }
 if (write(handle, &buffer, bytesRestantes) == -1) {
  perror("Falló write (2) en exportaDatos");
  return -1;
 }
 return 0;
}

canonical_original_code:
int exportaDatos(struct MiSistemaDeFicheros *miSistemaDeFicheros, int handle, int idxNodoI) {
 int i;
 char buffer[4096];
 struct EstructuraNodoI *temp = miSistemaDeFicheros->nodosI[idxNodoI];
 int bytesRestantes = miSistemaDeFicheros->superBloque.tamBloque
   - (temp->numBloques * miSistemaDeFicheros->superBloque.tamBloque
     - temp->tamArchivo);
 for (i = 0; i < miSistemaDeFicheros->nodosI[idxNodoI]->numBloques - 1; ++i) {
  if (write(handle, &buffer, 4096) == -1) {
   perror("Falló write en exportaDatos");
   return -1;
  }
 }
 if (write(handle, &buffer, bytesRestantes) == -1) {
  perror("Falló write (2) en exportaDatos");
  return -1;
 }
 return 0;
}

variable_types: handle int

variable_types: idxNodoI int


calculaPosNodoI

decompiled_code:
unsigned __int64 __fastcall calculaPosNodoI(int a1)
{
return 424 * (a1 % 9uLL) + (((unsigned int)(a1 / 9uLL) + 3) << 12);
}

canonical_decompiled_code:
unsigned __int64 __fastcall func5(int a1)
{
return 424 * (a1 % 9uLL) + (((unsigned int)(a1 / 9uLL) + 3) << 12);
}

original_code:
int calculaPosNodoI(int numNodoI) {
 int whichInodeBlock;
 int whichInodeInBlock;
 int inodeLocation;
 whichInodeBlock = numNodoI / (4096/sizeof(EstructuraNodoI));
 whichInodeInBlock = numNodoI % (4096/sizeof(EstructuraNodoI));
 inodeLocation = (3 + whichInodeBlock) * 4096
   + whichInodeInBlock * sizeof(EstructuraNodoI);
 return inodeLocation;
}

variable_types: whichInodeBlock int

variable_types: whichInodeInBlock int

variable_types: inodeLocation int


escribeNodoI

decompiled_code:
__int64 __fastcall escribeNodoI(int *a1, unsigned int a2, const void *a3)
{
int v4; // eax
__int64 result; // rax

if ( a2 > 0x2C )
_assert_fail("numNodoI < MAX_NODOSI", "common.c", 0x16u, "escribeNodoI");
v4 = calculaPosNodoI(a2);
if ( lseek(*a1, v4, 0) == -1 )
{
perror(aFall_12);
result = 0xFFFFFFFFLL;
}
else
{
if ( write(*a1, a3, 0x1A8uLL) == -1 )
perror(aFall_13);
sync();
result = 1LL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func6(int *a1, unsigned int a2, const void *a3)
{
int v4; // eax
__int64 result; // rax

if ( a2 > 0x2C )
_assert_fail("numNodoI < MAX_NODOSI", "common.c", 0x16u, "escribeNodoI");
v4 = func5(a2);
if ( lseek(*a1, v4, 0) == -1 )
{
perror(aFall_12);
result = 0xFFFFFFFFLL;
}
else
{
if ( write(*a1, a3, 0x1A8uLL) == -1 )
perror(aFall_13);
sync();
result = 1LL;
}
return result;
}

original_code:
int escribeNodoI(MiSistemaDeFicheros* miSistemaDeFicheros, int numNodoI,
  EstructuraNodoI* nodoI) {
 int posNodoI;
 ((void) sizeof ((numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ? 1 : 0), __extension__ ({ if (numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ; else __assert_fail ("numNodoI < MAX_NODOSI", "common.c", 22, __extension__ __PRETTY_FUNCTION__); }));
 posNodoI = calculaPosNodoI(numNodoI);
 if (lseek(miSistemaDeFicheros->discoVirtual, posNodoI, 0)
   == (off_t) -1) {
  perror("Falló lseek en escribeNodoI");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual, nodoI, sizeof(EstructuraNodoI))
   == -1) {
  perror("Falló write en escribeNodoI");
 }
 sync();
 return 1;
}

canonical_original_code:
int escribeNodoI(struct MiSistemaDeFicheros *miSistemaDeFicheros, int numNodoI, struct EstructuraNodoI *nodoI) {
 int posNodoI;
 ((void) sizeof ((numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ? 1 : 0), __extension__ ({ if (numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ; else __assert_fail ("numNodoI < MAX_NODOSI", "common.c", 22, __extension__ __PRETTY_FUNCTION__); }));
 posNodoI = calculaPosNodoI(numNodoI);
 if (lseek(miSistemaDeFicheros->discoVirtual, posNodoI, 0)
   == (off_t) -1) {
  perror("Falló lseek en escribeNodoI");
  return -1;
 }
 if (write(miSistemaDeFicheros->discoVirtual, nodoI, sizeof(EstructuraNodoI))
   == -1) {
  perror("Falló write en escribeNodoI");
 }
 sync();
 return 1;
}

variable_types:
nodoI
struct EstructuraNodoI *

variable_types: posNodoI int


leeNodoI

decompiled_code:
__int64 __fastcall leeNodoI(int *a1, unsigned int a2, void *a3)
{
int v4; // eax

if ( a2 > 0x2C )
_assert_fail("numNodoI < MAX_NODOSI", "common.c", 0xB8u, "leeNodoI");
v4 = calculaPosNodoI(a2);
lseek(*a1, v4, 0);
read(*a1, a3, 0x1A8uLL);
return 1LL;
}

canonical_decompiled_code:
__int64 __fastcall func7(int *a1, unsigned int a2, void *a3)
{
int v4; // eax

if ( a2 > 0x2C )
_assert_fail("numNodoI < MAX_NODOSI", "common.c", 0xB8u, "leeNodoI");
v4 = func5(a2);
lseek(*a1, v4, 0);
read(*a1, a3, 0x1A8uLL);
return 1LL;
}

original_code:
int leeNodoI(MiSistemaDeFicheros* miSistemaDeFicheros, int numNodoI,
  EstructuraNodoI* nodoI) {
 int posNodoI;
 ((void) sizeof ((numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ? 1 : 0), __extension__ ({ if (numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ; else __assert_fail ("numNodoI < MAX_NODOSI", "common.c", 184, __extension__ __PRETTY_FUNCTION__); }));
 posNodoI = calculaPosNodoI(numNodoI);
 lseek(miSistemaDeFicheros->discoVirtual, posNodoI, 0);
 read(miSistemaDeFicheros->discoVirtual, nodoI, sizeof(EstructuraNodoI));
 return 1;
}

canonical_original_code:
int leeNodoI(struct MiSistemaDeFicheros *miSistemaDeFicheros, int numNodoI, struct EstructuraNodoI *nodoI) {
 int posNodoI;
 ((void) sizeof ((numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ? 1 : 0), __extension__ ({ if (numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5)) ; else __assert_fail ("numNodoI < MAX_NODOSI", "common.c", 184, __extension__ __PRETTY_FUNCTION__); }));
 posNodoI = calculaPosNodoI(numNodoI);
 lseek(miSistemaDeFicheros->discoVirtual, posNodoI, 0);
 read(miSistemaDeFicheros->discoVirtual, nodoI, sizeof(EstructuraNodoI));
 return 1;
}


copiaNodoI

original_code:
void copiaNodoI(EstructuraNodoI* dest, EstructuraNodoI* src) {
 int i;
 dest->numBloques = src->numBloques;
 dest->tamArchivo = src->tamArchivo;
 dest->tiempoModificado = src->tiempoModificado;
 dest->libre = src->libre;
 for (i = 0; i < 100; i++)
  dest->idxBloques[i] = src->idxBloques[i];
}

canonical_original_code:
void copiaNodoI(struct EstructuraNodoI *dest, struct EstructuraNodoI *src) {
 int i;
 dest->numBloques = src->numBloques;
 dest->tamArchivo = src->tamArchivo;
 dest->tiempoModificado = src->tiempoModificado;
 dest->libre = src->libre;
 for (i = 0; i < 100; i++)
  dest->idxBloques[i] = src->idxBloques[i];
}

variable_types:
src
struct EstructuraNodoI *

variable_types: i int


initNodosI

decompiled_code:
void *__fastcall initNodosI(int *a1)
{
__int64 v1; // rbx
unsigned int *v2; // r12
void *result; // rax
void *v4; // rax

v1 = 0LL;
v2 = (unsigned int *)malloc(0x1A8uLL);
do
{
while ( 1 )
{
leeNodoI(a1, v1, v2);
result = (void *)v2[104];
if ( !(_DWORD)result )
break;
*(_QWORD *)&a1[2 * v1++ + 1634] = 0LL;
if ( v1 == 45 )
return result;
}
--a1[1724];
v4 = malloc(0x1A8uLL);
*(_QWORD *)&a1[2 * v1++ + 1634] = v4;
result = copiaNodoI((__int64)v4, (int *)v2);
}
while ( v1 != 45 );
return result;
}

canonical_decompiled_code:
void *__fastcall func9(int *a1)
{
__int64 v1; // rbx
unsigned int *v2; // r12
void *result; // rax
void *v4; // rax

v1 = 0LL;
v2 = (unsigned int *)malloc(0x1A8uLL);
do
{
while ( 1 )
{
func7(a1, v1, v2);
result = (void *)v2[104];
if ( !(_DWORD)result )
break;
*(_QWORD *)&a1[2 * v1++ + 1634] = 0LL;
if ( v1 == 45 )
return result;
}
--a1[1724];
v4 = malloc(0x1A8uLL);
*(_QWORD *)&a1[2 * v1++ + 1634] = v4;
result = func8((__int64)v4, (int *)v2);
}
while ( v1 != 45 );
return result;
}

original_code:
void initNodosI(MiSistemaDeFicheros* miSistemaDeFicheros) {
 int numNodoI;
 EstructuraNodoI* temp = malloc(sizeof(EstructuraNodoI));
 for (numNodoI = 0; numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5); numNodoI++) {
  leeNodoI(miSistemaDeFicheros, numNodoI, temp);
  if (temp->libre) {
   miSistemaDeFicheros->nodosI[numNodoI] = ((void *)0);
  } else {
   miSistemaDeFicheros->numNodosLibres--;
   miSistemaDeFicheros->nodosI[numNodoI] = malloc(
     sizeof(EstructuraNodoI));
   copiaNodoI(miSistemaDeFicheros->nodosI[numNodoI], temp);
  }
 }
}

canonical_original_code:
void initNodosI(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 int numNodoI;
 struct EstructuraNodoI *temp = malloc(sizeof(EstructuraNodoI));
 for (numNodoI = 0; numNodoI < ((4096/sizeof(EstructuraNodoI)) * 5); numNodoI++) {
  leeNodoI(miSistemaDeFicheros, numNodoI, temp);
  if (temp->libre) {
   miSistemaDeFicheros->nodosI[numNodoI] = ((void *)0);
  } else {
   miSistemaDeFicheros->numNodosLibres--;
   miSistemaDeFicheros->nodosI[numNodoI] = malloc(
     sizeof(EstructuraNodoI));
   copiaNodoI(miSistemaDeFicheros->nodosI[numNodoI], temp);
  }
 }
}


buscaNodoLibre

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

for ( result = 0LL; result != 45; ++result )
{
if ( !*(_QWORD *)(a1 + 8 * result + 6536) )
return (unsigned int)result;
}
return 0xFFFFFFFFLL;
}

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

for ( result = 0LL; result != 45; ++result )
{
if ( !*(_QWORD *)(a1 + 8 * result + 6536) )
return (unsigned int)result;
}
return 0xFFFFFFFFLL;
}

original_code:
int buscaNodoLibre(MiSistemaDeFicheros* miSistemaDeFicheros) {
 int i;
 for (i = 0; i < ((4096/sizeof(EstructuraNodoI)) * 5); i++) {
  if (miSistemaDeFicheros->nodosI[i] == ((void *)0))
   return i;
 }
 return -1;
}

canonical_original_code:
int buscaNodoLibre(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 int i;
 for (i = 0; i < ((4096/sizeof(EstructuraNodoI)) * 5); i++) {
  if (miSistemaDeFicheros->nodosI[i] == ((void *)0))
   return i;
 }
 return -1;
}


reservaBloquesNodosI

original_code:
void reservaBloquesNodosI(MiSistemaDeFicheros* miSistemaDeFicheros,
  int idxBloques[], int numBloques) {
 int i = 0;
 int bloqueActual = 0;
 while ((bloqueActual < numBloques) && (i < (4096/sizeof(unsigned)))) {
  if (miSistemaDeFicheros->mapaDeBits[i] == 0) {
   miSistemaDeFicheros->mapaDeBits[i] = 1;
   idxBloques[bloqueActual] = i;
   bloqueActual++;
  }
  ++i;
 }
}

canonical_original_code:
void reservaBloquesNodosI(struct MiSistemaDeFicheros *miSistemaDeFicheros, int idxBloques[], int numBloques) {
 int i = 0;
 int bloqueActual = 0;
 while ((bloqueActual < numBloques) && (i < (4096/sizeof(unsigned int)))) {
  if (miSistemaDeFicheros->mapaDeBits[i] == 0) {
   miSistemaDeFicheros->mapaDeBits[i] = 1;
   idxBloques[bloqueActual] = i;
   bloqueActual++;
  }
  ++i;
 }
}

variable_types:
idxBloques
int []

variable_types: numBloques int

variable_types: bloqueActual int


buscaPosDirectorio

decompiled_code:
__int64 __fastcall buscaPosDirectorio(__int64 a1, const char *a2)
{
unsigned int v2; // er12
__int64 v3; // rbx

v2 = 0;
v3 = a1 + 4140;
do
{
if ( !*(_DWORD *)(v3 + 16) && !strcmp(a2, (const char *)v3) )
return v2;
++v2;
v3 += 24LL;
}
while ( v2 != 100 );
return 0xFFFFFFFFLL;
}

canonical_decompiled_code:
__int64 __fastcall func12(__int64 a1, const char *a2)
{
unsigned int v2; // er12
__int64 v3; // rbx

v2 = 0;
v3 = a1 + 4140;
do
{
if ( !*(_DWORD *)(v3 + 16) && !strcmp(a2, (const char *)v3) )
return v2;
++v2;
v3 += 24LL;
}
while ( v2 != 100 );
return 0xFFFFFFFFLL;
}

original_code:
int buscaPosDirectorio(MiSistemaDeFicheros* miSistemaDeFicheros, char* nombre) {
 int i;
 for (i = 0; i < 100; i++) {
  if (miSistemaDeFicheros->directorio.archivos[i].libre == 0) {
   if (strcmp(nombre,
     miSistemaDeFicheros->directorio.archivos[i].nombreArchivo)
     == 0)
    return i;
  }
 }
 return -1;
}

canonical_original_code:
int buscaPosDirectorio(struct MiSistemaDeFicheros *miSistemaDeFicheros, char *nombre) {
 int i;
 for (i = 0; i < 100; i++) {
  if (miSistemaDeFicheros->directorio.archivos[i].libre == 0) {
   if (strcmp(nombre,
     miSistemaDeFicheros->directorio.archivos[i].nombreArchivo)
     == 0)
    return i;
  }
 }
 return -1;
}

variable_types: struct MiSistemaDeFicheros { int discoVirtual; struct EstructuraSuperBloque { int tamSuperBloque; int tamDirectorio; int tamNodoI; int tamDiscoEnBloques; int numBloquesLibres; int tamBloque; int maxTamNombreArchivo; int maxBloquesPorArchivo; } superBloque; unsigned int mapaDeBits[-1]; struct EstructuraDirectorio { int numArchivos; struct EstructuraArchivo { int idxNodoI; char nombreArchivo[-1]; int libre; } archivos[100]; } directorio; struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *nodosI[-1]; int numNodosLibres; } *

variable_types:
nombre
char *


myQuota

decompiled_code:
__int64 __fastcall myQuota(__int64 a1)
{
int v1; // edx
_DWORD *v2; // rax
unsigned int v3; // er8
__int64 v4; // rdx

v1 = *(_DWORD *)(a1 + 16);
if ( v1 <= 0 )
return 0LL;
v2 = (_DWORD *)(a1 + 36);
v3 = 0;
v4 = a1 + 4LL * (unsigned int)(v1 - 1) + 40;
do
v3 += *v2++ == 0;
while ( v2 != (_DWORD *)v4 );
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func13(__int64 a1)
{
int v1; // edx
_DWORD *v2; // rax
unsigned int v3; // er8
__int64 v4; // rdx

v1 = *(_DWORD *)(a1 + 16);
if ( v1 <= 0 )
return 0LL;
v2 = (_DWORD *)(a1 + 36);
v3 = 0;
v4 = a1 + 4LL * (unsigned int)(v1 - 1) + 40;
do
v3 += *v2++ == 0;
while ( v2 != (_DWORD *)v4 );
return v3;
}

original_code:
int myQuota(MiSistemaDeFicheros* miSistemaDeFicheros) {
 int freeCount = 0;
 int i;
 for (i = 0; i < miSistemaDeFicheros->superBloque.tamDiscoEnBloques; i++) {
  if (miSistemaDeFicheros->mapaDeBits[i] == 0) {
   freeCount++;
  }
 }
 return freeCount;
}

canonical_original_code:
int myQuota(struct MiSistemaDeFicheros *miSistemaDeFicheros) {
 int freeCount = 0;
 int i;
 for (i = 0; i < miSistemaDeFicheros->superBloque.tamDiscoEnBloques; i++) {
  if (miSistemaDeFicheros->mapaDeBits[i] == 0) {
   freeCount++;
  }
 }
 return freeCount;
}

variable_types: freeCount int


original_code:
void parse_command(char * command, struct commandType *comm) {
    int i = 0;
    int pos = 0;
    char word[81];
    comm->VarNum = 0;
    comm->command = ((void *)0);
    comm->VarList[0] = ((void *)0);
    while (((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short int) _ISspace))
        i++;
    if (command[i] == '\0')
        return;
    while (command[i] != '\0') {
        while (command[i] != '\0' && !((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short int) _ISspace)) {
            word[pos++] = command[i++];
        }
        word[pos] = '\0';
        comm->VarList[comm->VarNum] = malloc((strlen(word) + 1) * sizeof (char));
        strcpy(comm->VarList[comm->VarNum], word);
        comm->VarNum++;
        word[0] = '\0';
        pos = 0;
        while (((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short int) _ISspace))
            i++;
    }
    comm->command = malloc((strlen(comm->VarList[0]) + 1) * sizeof (char));
    strcpy(comm->command, comm->VarList[0]);
    comm->VarList[comm->VarNum] = ((void *)0);
}

canonical_original_code:
void parse_command(char *command, struct commandType *comm) {
    int i = 0;
    int pos = 0;
    char word[81];
    comm->VarNum = 0;
    comm->command = ((void *)0);
    comm->VarList[0] = ((void *)0);
    while (((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short) _ISspace))
        i++;
    if (command[i] == '\0')
        return;
    while (command[i] != '\0') {
        while (command[i] != '\0' && !((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short) _ISspace)) {
            word[pos++] = command[i++];
        }
        word[pos] = '\0';
        comm->VarList[comm->VarNum] = malloc((strlen(word) + 1) * sizeof (char));
        strcpy(comm->VarList[comm->VarNum], word);
        comm->VarNum++;
        word[0] = '\0';
        pos = 0;
        while (((*__ctype_b_loc ())[(int) ((command[i]))] & (unsigned short) _ISspace))
            i++;
    }
    comm->command = malloc((strlen(comm->VarList[0]) + 1) * sizeof (char));
    strcpy(comm->command, comm->VarList[0]);
    comm->VarList[comm->VarNum] = ((void *)0);
}

variable_types:
command
char *

variable_types: struct commandType { char *command; char *VarList[10]; int VarNum; } *

variable_types: pos int

variable_types:
word
char [81]


decompiled_code:
int __fastcall print_info(__int64 a1)
{
__int64 v1; // r13
__int64 v2; // rbp
int v3; // er12
__int64 v4; // rbx
const char *v5; // rdx
__int64 v6; // rsi
const char *v7; // rdi

v1 = a1;
puts("Parse struct:\n");
printf("# of pipes:%d\n", *(unsigned int *)(a1 + 976));
if ( *(int *)(a1 + 976) >= 0 )
{
v2 = a1;
v3 = 0;
do
{
printf("Command %d is %s.\t", (unsigned int)++v3, *(const char **)(v2 + 16));
if ( *(int *)(v2 + 104) > 0 )
{
v4 = 0LL;
do
{
v5 = *(const char **)(v2 + 8 * v4 + 24);
v6 = (unsigned int)v4++;
printf("Arg %d: %s ", v6, v5);
}
while ( *(_DWORD *)(v2 + 104) > (int)v4 );
}
v2 += 96LL;
putchar(10);
}
while ( v3 <= *(_DWORD *)(a1 + 976) );
}
putchar(10);
if ( *(_DWORD *)a1 )
printf("infile: %s\n", (const char *)(a1 + 980));
else
puts("no input redirection.");
if ( *(_DWORD *)(a1 + 4) )
printf("outfile: %s\n", (const char *)(a1 + 1020));
else
puts("no output redirection.");
v7 = "Background process.";
if ( !*(_DWORD *)(v1 + 8) )
v7 = "Foreground process.";
return puts(v7);
}

canonical_decompiled_code:
int __fastcall func1(__int64 a1)
{
__int64 v1; // r13
__int64 v2; // rbp
int v3; // er12
__int64 v4; // rbx
const char *v5; // rdx
__int64 v6; // rsi
const char *v7; // rdi

v1 = a1;
puts("Parse struct:\n");
printf("# of pipes:%d\n", *(unsigned int *)(a1 + 976));
if ( *(int *)(a1 + 976) >= 0 )
{
v2 = a1;
v3 = 0;
do
{
printf("Command %d is %s.\t", (unsigned int)++v3, *(const char **)(v2 + 16));
if ( *(int *)(v2 + 104) > 0 )
{
v4 = 0LL;
do
{
v5 = *(const char **)(v2 + 8 * v4 + 24);
v6 = (unsigned int)v4++;
printf("Arg %d: %s ", v6, v5);
}
while ( *(_DWORD *)(v2 + 104) > (int)v4 );
}
v2 += 96LL;
putchar(10);
}
while ( v3 <= *(_DWORD *)(a1 + 976) );
}
putchar(10);
if ( *(_DWORD *)a1 )
printf("infile: %s\n", (const char *)(a1 + 980));
else
puts("no input redirection.");
if ( *(_DWORD *)(a1 + 4) )
printf("outfile: %s\n", (const char *)(a1 + 1020));
else
puts("no output redirection.");
v7 = "Background process.";
if ( !*(_DWORD *)(v1 + 8) )
v7 = "Foreground process.";
return puts(v7);
}

original_code:
void print_info(parseInfo *info) {
    int i, j;
    struct commandType *comm;
    printf("Parse struct:\n\n");
    printf("# of pipes:%d\n", info->pipeNum);
    for (i = 0; i <= info->pipeNum; i++) {
        comm = &(info->CommArray[i]);
        printf("Command %d is %s.\t", i + 1, comm->command);
        for (j = 0; j < comm->VarNum; j++)
            printf("Arg %d: %s ", j, comm->VarList[j]);
        printf("\n");
    }
    printf("\n");
    if (info->boolInfile)
        printf("infile: %s\n", info->inFile);
    else
        printf("no input redirection.\n");
    if (info->boolOutfile)
        printf("outfile: %s\n", info->outFile);
    else
        printf("no output redirection.\n");
    if (info->boolBackground)
        printf("Background process.\n");
    else
        printf("Foreground process.\n");
}

canonical_original_code:
void print_info(struct parseInfo *info) {
    int i; int j;
    struct commandType *comm;
    printf("Parse struct:\n\n");
    printf("# of pipes:%d\n", info->pipeNum);
    for (i = 0; i <= info->pipeNum; i++) {
        comm = &(info->CommArray[i]);
        printf("Command %d is %s.\t", i + 1, comm->command);
        for (j = 0; j < comm->VarNum; j++)
            printf("Arg %d: %s ", j, comm->VarList[j]);
        printf("\n");
    }
    printf("\n");
    if (info->boolInfile)
        printf("infile: %s\n", info->inFile);
    else
        printf("no input redirection.\n");
    if (info->boolOutfile)
        printf("outfile: %s\n", info->outFile);
    else
        printf("no output redirection.\n");
    if (info->boolBackground)
        printf("Background process.\n");
    else
        printf("Foreground process.\n");
}

variable_types: struct parseInfo { int boolInfile; int boolOutfile; int boolBackground; struct commandType { char *command; char *VarList[10]; int VarNum; } CommArray[10]; int pipeNum; char inFile[40]; char outFile[40]; } *

variable_types: j int


decompiled_code:
void __fastcall free_info(void *ptr)
{
void *v1; // r13
char *v2; // r12
char *v3; // rbp
__int64 i; // rbx
void *v5; // rdi
void *v6; // rdi

if ( ptr )
{
v1 = ptr;
v2 = (char *)ptr + 960;
v3 = (char *)ptr;
do
{
for ( i = 0LL; *((_DWORD *)v3 + 26) > (int)i; ++i )
{
v5 = *(void **)&v3[8 * i + 24];
free(v5);
}
v6 = (void *)*((_QWORD *)v3 + 2);
if ( v6 )
free(v6);
v3 += 96;
}
while ( v3 != v2 );
free(v1);
}
}

canonical_decompiled_code:
void __fastcall func2(void *ptr)
{
void *v1; // r13
char *v2; // r12
char *v3; // rbp
__int64 i; // rbx
void *v5; // rdi
void *v6; // rdi

if ( ptr )
{
v1 = ptr;
v2 = (char *)ptr + 960;
v3 = (char *)ptr;
do
{
for ( i = 0LL; *((_DWORD *)v3 + 26) > (int)i; ++i )
{
v5 = *(void **)&v3[8 * i + 24];
free(v5);
}
v6 = (void *)*((_QWORD *)v3 + 2);
if ( v6 )
free(v6);
v3 += 96;
}
while ( v3 != v2 );
free(v1);
}
}

original_code:
void free_info(parseInfo *info) {
    int i, j;
    struct commandType *comm;
    if (((void *)0) == info) return;
    for (i = 0; i < 10; i++) {
        comm = &(info->CommArray[i]);
        for (j = 0; j < comm->VarNum; j++)
            free(comm->VarList[j]);
        if (((void *)0) != comm->command) free(comm->command);
    }
    free(info);
}

canonical_original_code:
void free_info(struct parseInfo *info) {
    int i; int j;
    struct commandType *comm;
    if (((void *)0) == info) return;
    for (i = 0; i < 10; i++) {
        comm = &(info->CommArray[i]);
        for (j = 0; j < comm->VarNum; j++)
            free(comm->VarList[j]);
        if (((void *)0) != comm->command) free(comm->command);
    }
    free(info);
}

user_defined_types: struct commandType { char *command; char *VarList[10]; int VarNum; }


myMkfs

decompiled_code:
__int64 __fastcall myMkfs(__int64 a1, int a2, const char *a3)
{
_DWORD *v4; // rax
__int64 v5; // rbx
__int64 result; // rax
_DWORD v7[118]; // [rsp+0h] [rbp-1D8h] BYREF

*(_DWORD *)a1 = open(a3, 66, 384LL);
if ( a2 <= 36863 )
{
perror(aNumeroDeBloque_0);
result = 1LL;
}
else if ( a2 > 0x3FFFFF )
{
perror("Numero de bloques demasiado grande");
result = 2LL;
}
else
{
*(_QWORD *)(a1 + 4124) = 0LL;
memset(
(void *)((a1 + 44) & 0xFFFFFFFFFFFFFFF8LL),
0,
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 44) & 0xFFFFFFF8) + 4132) >> 3));
*(_QWORD *)(a1 + 36) = 0x100000001LL;
*(_QWORD *)(a1 + 44) = 0x100000001LL;
*(_QWORD *)(a1 + 52) = 0x100000001LL;
*(_QWORD *)(a1 + 60) = 0x100000001LL;
escribeMapaDeBits(a1);
v4 = (_DWORD *)(a1 + 4156);
*(_DWORD *)(a1 + 4132) = 0;
do
{
*v4 = 1;
v4 += 6;
}
while ( v4 != (_DWORD *)(a1 + 6556) );
v5 = 0LL;
escribeDirectorio(a1);
v7[104] = 1;
do
{
escribeNodoI(a1, (unsigned int)v5, v7);
*(_QWORD *)(a1 + 8 * v5++ + 6536) = 0LL;
}
while ( v5 != 45 );
initSuperBloque(a1, (unsigned int)a2);
escribeSuperBloque(a1);
sync();
if ( (int)myQuota(a1) <= 0 )
_assert_fail("myQuota(miSistemaDeFicheros) >= 1", "util.c", 0x4Du, "myMkfs");
printf("SF: %s, %d B (%d B/bloque), %d bloques\n", a3, (unsigned int)a2, 4096LL, (unsigned int)(a2 >> 12));
printf("1 bloque para SUPERBLOQUE (%lu B)\n", 32LL);
printf("1 bloque para MAPA DE BITS, que cubre %lu bloques, %lu B\n", 1024LL, 0x400000LL);
printf("1 bloque para DIRECTORIO (%lu B)\n", 2404LL);
printf("%d bloques para nodos-i (a %lu B/nodo-i, %lu nodos-i)\n", 5LL, 424LL, 45LL);
printf("%d bloques para datos (%d B)\n", *(unsigned int *)(a1 + 20), (unsigned int)(*(_DWORD *)(a1 + 20) << 12));
puts(&s);
result = 0LL;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, int a2, const char *a3)
{
_DWORD *v4; // rax
__int64 v5; // rbx
__int64 result; // rax
_DWORD v7[118]; // [rsp+0h] [rbp-1D8h] BYREF

*(_DWORD *)a1 = open(a3, 66, 384LL);
if ( a2 <= 36863 )
{
perror(aNumeroDeBloque_0);
result = 1LL;
}
else if ( a2 > 0x3FFFFF )
{
perror("Numero de bloques demasiado grande");
result = 2LL;
}
else
{
*(_QWORD *)(a1 + 4124) = 0LL;
memset(
(void *)((a1 + 44) & 0xFFFFFFFFFFFFFFF8LL),
0,
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 44) & 0xFFFFFFF8) + 4132) >> 3));
*(_QWORD *)(a1 + 36) = 0x100000001LL;
*(_QWORD *)(a1 + 44) = 0x100000001LL;
*(_QWORD *)(a1 + 52) = 0x100000001LL;
*(_QWORD *)(a1 + 60) = 0x100000001LL;
escribeMapaDeBits(a1);
v4 = (_DWORD *)(a1 + 4156);
*(_DWORD *)(a1 + 4132) = 0;
do
{
*v4 = 1;
v4 += 6;
}
while ( v4 != (_DWORD *)(a1 + 6556) );
v5 = 0LL;
escribeDirectorio(a1);
v7[104] = 1;
do
{
escribeNodoI(a1, (unsigned int)v5, v7);
*(_QWORD *)(a1 + 8 * v5++ + 6536) = 0LL;
}
while ( v5 != 45 );
initSuperBloque(a1, (unsigned int)a2);
escribeSuperBloque(a1);
sync();
if ( (int)myQuota(a1) <= 0 )
_assert_fail("myQuota(miSistemaDeFicheros) >= 1", "util.c", 0x4Du, "myMkfs");
printf("SF: %s, %d B (%d B/bloque), %d bloques\n", a3, (unsigned int)a2, 4096LL, (unsigned int)(a2 >> 12));
printf("1 bloque para SUPERBLOQUE (%lu B)\n", 32LL);
printf("1 bloque para MAPA DE BITS, que cubre %lu bloques, %lu B\n", 1024LL, 0x400000LL);
printf("1 bloque para DIRECTORIO (%lu B)\n", 2404LL);
printf("%d bloques para nodos-i (a %lu B/nodo-i, %lu nodos-i)\n", 5LL, 424LL, 45LL);
printf("%d bloques para datos (%d B)\n", *(unsigned int *)(a1 + 20), (unsigned int)(*(_DWORD *)(a1 + 20) << 12));
puts(&s);
result = 0LL;
}
return result;
}

original_code:
int myMkfs(MiSistemaDeFicheros* miSistemaDeFicheros, int tamDisco,
  char* nombreArchivo) {
 miSistemaDeFicheros->discoVirtual = open(nombreArchivo, 0100 | 02,
   0400 | 0200);
 int i;
 int numBloques = tamDisco / 4096;
 int minNumBloques = 3 + 5 + 1;
 int maxNumBloques = (4096/sizeof(unsigned));
 ((void) sizeof ((sizeof (EstructuraSuperBloque) <= 4096) ? 1 : 0), __extension__ ({ if (sizeof (EstructuraSuperBloque) <= 4096) ; else __assert_fail ("sizeof (EstructuraSuperBloque) <= TAM_BLOQUE_BYTES", "util.c", 22, __extension__ __PRETTY_FUNCTION__); }));
 ((void) sizeof ((sizeof (EstructuraDirectorio) <= 4096) ? 1 : 0), __extension__ ({ if (sizeof (EstructuraDirectorio) <= 4096) ; else __assert_fail ("sizeof (EstructuraDirectorio) <= TAM_BLOQUE_BYTES", "util.c", 23, __extension__ __PRETTY_FUNCTION__); }));
 if (numBloques < minNumBloques) {
  perror("Numero de bloques demasiado pequeño");
  return 1;
 }
 if (numBloques >= maxNumBloques) {
  perror("Numero de bloques demasiado grande");
  return 2;
 }
 for (i = 0; i < (4096/sizeof(unsigned)); i++) {
  miSistemaDeFicheros->mapaDeBits[i] = 0;
 }
 miSistemaDeFicheros->mapaDeBits[0] = 1;
 miSistemaDeFicheros->mapaDeBits[1] = 1;
 miSistemaDeFicheros->mapaDeBits[2] = 1;
 for (i = 3; i < 3 + 5; i++) {
  miSistemaDeFicheros->mapaDeBits[i] = 1;
 }
 escribeMapaDeBits(miSistemaDeFicheros);
 miSistemaDeFicheros->directorio.numArchivos = 0;
 int j;
 for (j = 0; j < 100; j++) {
  miSistemaDeFicheros->directorio.archivos[j].libre = 1;
 }
 escribeDirectorio(miSistemaDeFicheros);
 EstructuraNodoI nodoActual;
 nodoActual.libre = 1;
 for (i = 0; i < ((4096/sizeof(EstructuraNodoI)) * 5); i++) {
  escribeNodoI(miSistemaDeFicheros, i, &nodoActual);
  miSistemaDeFicheros->nodosI[i] = ((void *)0);
 }
 initSuperBloque(miSistemaDeFicheros, tamDisco);
 escribeSuperBloque(miSistemaDeFicheros);
 sync();
 ((void) sizeof ((myQuota(miSistemaDeFicheros) >= 1) ? 1 : 0), __extension__ ({ if (myQuota(miSistemaDeFicheros) >= 1) ; else __assert_fail ("myQuota(miSistemaDeFicheros) >= 1", "util.c", 77, __extension__ __PRETTY_FUNCTION__); }));
 printf("SF: %s, %d B (%d B/bloque), %d bloques\n", nombreArchivo, tamDisco,
   4096, numBloques);
 printf("1 bloque para SUPERBLOQUE (%lu B)\n", sizeof(EstructuraSuperBloque));
 printf("1 bloque para MAPA DE BITS, que cubre %lu bloques, %lu B\n",
   (4096/sizeof(unsigned)), (4096/sizeof(unsigned)) * 4096);
 printf("1 bloque para DIRECTORIO (%lu B)\n", sizeof(EstructuraDirectorio));
 printf("%d bloques para nodos-i (a %lu B/nodo-i, %lu nodos-i)\n",
   5, sizeof(EstructuraNodoI), ((4096/sizeof(EstructuraNodoI)) * 5));
 printf("%d bloques para datos (%d B)\n",
   miSistemaDeFicheros->superBloque.numBloquesLibres, 4096
     * miSistemaDeFicheros->superBloque.numBloquesLibres);
 printf("¡Formato completado!\n");
 return 0;
}

canonical_original_code:
int myMkfs(struct MiSistemaDeFicheros *miSistemaDeFicheros, int tamDisco, char *nombreArchivo) {
 miSistemaDeFicheros->discoVirtual = open(nombreArchivo, 0100 | 02,
   0400 | 0200);
 int i;
 int numBloques = tamDisco / 4096;
 int minNumBloques = 3 + 5 + 1;
 int maxNumBloques = (4096/sizeof(unsigned));
 ((void) sizeof ((sizeof (EstructuraSuperBloque) <= 4096) ? 1 : 0), __extension__ ({ if (sizeof (EstructuraSuperBloque) <= 4096) ; else __assert_fail ("sizeof (EstructuraSuperBloque) <= TAM_BLOQUE_BYTES", "util.c", 22, __extension__ __PRETTY_FUNCTION__); }));
 ((void) sizeof ((sizeof (EstructuraDirectorio) <= 4096) ? 1 : 0), __extension__ ({ if (sizeof (EstructuraDirectorio) <= 4096) ; else __assert_fail ("sizeof (EstructuraDirectorio) <= TAM_BLOQUE_BYTES", "util.c", 23, __extension__ __PRETTY_FUNCTION__); }));
 if (numBloques < minNumBloques) {
  perror("Numero de bloques demasiado pequeño");
  return 1;
 }
 if (numBloques >= maxNumBloques) {
  perror("Numero de bloques demasiado grande");
  return 2;
 }
 for (i = 0; i < (4096/sizeof(unsigned int)); i++) {
  miSistemaDeFicheros->mapaDeBits[i] = 0;
 }
 miSistemaDeFicheros->mapaDeBits[0] = 1;
 miSistemaDeFicheros->mapaDeBits[1] = 1;
 miSistemaDeFicheros->mapaDeBits[2] = 1;
 for (i = 3; i < 3 + 5; i++) {
  miSistemaDeFicheros->mapaDeBits[i] = 1;
 }
 escribeMapaDeBits(miSistemaDeFicheros);
 miSistemaDeFicheros->directorio.numArchivos = 0;
 int j;
 for (j = 0; j < 100; j++) {
  miSistemaDeFicheros->directorio.archivos[j].libre = 1;
 }
 escribeDirectorio(miSistemaDeFicheros);
 struct EstructuraNodoI nodoActual;
 nodoActual.libre = 1;
 for (i = 0; i < ((4096/sizeof(EstructuraNodoI)) * 5); i++) {
  escribeNodoI(miSistemaDeFicheros, i, &nodoActual);
  miSistemaDeFicheros->nodosI[i] = ((void *)0);
 }
 initSuperBloque(miSistemaDeFicheros, tamDisco);
 escribeSuperBloque(miSistemaDeFicheros);
 sync();
 ((void) sizeof ((myQuota(miSistemaDeFicheros) >= 1) ? 1 : 0), __extension__ ({ if (myQuota(miSistemaDeFicheros) >= 1) ; else __assert_fail ("myQuota(miSistemaDeFicheros) >= 1", "util.c", 77, __extension__ __PRETTY_FUNCTION__); }));
 printf("SF: %s, %d B (%d B/bloque), %d bloques\n", nombreArchivo, tamDisco,
   4096, numBloques);
 printf("1 bloque para SUPERBLOQUE (%lu B)\n", sizeof(EstructuraSuperBloque));
 printf("1 bloque para MAPA DE BITS, que cubre %lu bloques, %lu B\n",
   (4096/sizeof(unsigned int)), (4096/sizeof(unsigned int)) * 4096);
 printf("1 bloque para DIRECTORIO (%lu B)\n", sizeof(EstructuraDirectorio));
 printf("%d bloques para nodos-i (a %lu B/nodo-i, %lu nodos-i)\n",
   5, sizeof(EstructuraNodoI), ((4096/sizeof(EstructuraNodoI)) * 5));
 printf("%d bloques para datos (%d B)\n",
   miSistemaDeFicheros->superBloque.numBloquesLibres, 4096
     * miSistemaDeFicheros->superBloque.numBloquesLibres);
 printf("¡Formato completado!\n");
 return 0;
}

variable_types: tamDisco int

variable_types:
nombreArchivo
char *

variable_types: minNumBloques int

variable_types: maxNumBloques int

variable_types: struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; }


myImport

decompiled_code:
__int64 __fastcall myImport(char *file, _DWORD *a2, const char *a3)
{
int v4; // eax
unsigned int v5; // er14
unsigned int v6; // ebx
unsigned int v7; // er13
unsigned int *v8; // r12
__off_t v9; // rax
__int64 v10; // rdx
__int64 v11; // rax
time_t v12; // rax
__int64 v13; // rdx
struct stat v15; // [rsp+10h] [rbp-C8h] BYREF

v4 = open(file, 0);
if ( v4 == -1 )
{
v7 = 1;
printf("Error, leyendo archivo %s\n", file);
}
else
{
v5 = v4;
v6 = buscaNodoLibre(a2);
v7 = stat(file, &v15);
if ( v7 )
{
v7 = 2;
perror("stat");
fprintf(stderr, "Error, ejecutando stat en archivo %s\n", file);
}
else if ( v15.st_size > (int)(a2[5] << 12) )
{
v7 = 3;
fwrite("No hay suficiente espacio en disco\n", 1uLL, 0x23uLL, stderr);
}
else if ( v15.st_size > 409600 )
{
v7 = 4;
fwrite("El archivo a copiar es demasido grande\n", 1uLL, 0x27uLL, stderr);
}
else if ( strlen(a3) > 0xF )
{
v7 = 5;
fwrite("Nombre de archivo demasiado grande\n", 1uLL, 0x23uLL, stderr);
}
else if ( (unsigned int)buscaPosDirectorio(a2, a3) == -1 )
{
if ( v6 == -1 )
{
v7 = 7;
fwrite("No existen nodos-i libres\n", 1uLL, 0x1AuLL, stderr);
}
else if ( a2[1033] == 100 )
{
v7 = 8;
fwrite("No caben mas archivos en el directorio\n", 1uLL, 0x27uLL, stderr);
}
else
{
v8 = (unsigned int *)malloc(0x1A8uLL);
v9 = v15.st_size;
v8[104] = 0;
v10 = v9 + 8190;
v8[1] = v9;
v11 = v9 + 4095;
if ( v11 < 0 )
v11 = v10;
*v8 = v11 >> 12;
v12 = time(0LL);
v13 = *v8;
*(_QWORD *)&a2[2 * v6 + 1634] = v8;
--a2[1724];
*((_QWORD *)v8 + 1) = v12;
reservaBloquesNodosI(a2, v8 + 4, v13);
escribeNodoI(a2, v6, v8);
escribeDatos(a2, v5, v6);
escribeMapaDeBits(a2);
++a2[1033];
a2[6 * v6 + 1039] = 0;
strcpy((char *)&a2[6 * v6 + 1035], a3);
escribeDirectorio(a2);
a2[5] -= *v8;
escribeSuperBloque(a2);
sync();
close(v5);
}
}
else
{
v7 = 6;
fwrite("El archivo a copiar ya existe\n", 1uLL, 0x1EuLL, stderr);
}
}
return v7;
}

canonical_decompiled_code:
__int64 __fastcall func1(char *file, _DWORD *a2, const char *a3)
{
int v4; // eax
unsigned int v5; // er14
unsigned int v6; // ebx
unsigned int v7; // er13
unsigned int *v8; // r12
__off_t v9; // rax
__int64 v10; // rdx
__int64 v11; // rax
time_t v12; // rax
__int64 v13; // rdx
struct stat v15; // [rsp+10h] [rbp-C8h] BYREF

v4 = open(file, 0);
if ( v4 == -1 )
{
v7 = 1;
printf("Error, leyendo archivo %s\n", file);
}
else
{
v5 = v4;
v6 = buscaNodoLibre(a2);
v7 = stat(file, &v15);
if ( v7 )
{
v7 = 2;
perror("stat");
fprintf(stderr, "Error, ejecutando stat en archivo %s\n", file);
}
else if ( v15.st_size > (int)(a2[5] << 12) )
{
v7 = 3;
fwrite("No hay suficiente espacio en disco\n", 1uLL, 0x23uLL, stderr);
}
else if ( v15.st_size > 409600 )
{
v7 = 4;
fwrite("El archivo a copiar es demasido grande\n", 1uLL, 0x27uLL, stderr);
}
else if ( strlen(a3) > 0xF )
{
v7 = 5;
fwrite("Nombre de archivo demasiado grande\n", 1uLL, 0x23uLL, stderr);
}
else if ( (unsigned int)buscaPosDirectorio(a2, a3) == -1 )
{
if ( v6 == -1 )
{
v7 = 7;
fwrite("No existen nodos-i libres\n", 1uLL, 0x1AuLL, stderr);
}
else if ( a2[1033] == 100 )
{
v7 = 8;
fwrite("No caben mas archivos en el directorio\n", 1uLL, 0x27uLL, stderr);
}
else
{
v8 = (unsigned int *)malloc(0x1A8uLL);
v9 = v15.st_size;
v8[104] = 0;
v10 = v9 + 8190;
v8[1] = v9;
v11 = v9 + 4095;
if ( v11 < 0 )
v11 = v10;
*v8 = v11 >> 12;
v12 = time(0LL);
v13 = *v8;
*(_QWORD *)&a2[2 * v6 + 1634] = v8;
--a2[1724];
*((_QWORD *)v8 + 1) = v12;
reservaBloquesNodosI(a2, v8 + 4, v13);
escribeNodoI(a2, v6, v8);
escribeDatos(a2, v5, v6);
escribeMapaDeBits(a2);
++a2[1033];
a2[6 * v6 + 1039] = 0;
strcpy((char *)&a2[6 * v6 + 1035], a3);
escribeDirectorio(a2);
a2[5] -= *v8;
escribeSuperBloque(a2);
sync();
close(v5);
}
}
else
{
v7 = 6;
fwrite("El archivo a copiar ya existe\n", 1uLL, 0x1EuLL, stderr);
}
}
return v7;
}

original_code:
int myImport(char* nombreArchivoExterno,
  MiSistemaDeFicheros* miSistemaDeFicheros, char* nombreArchivoInterno) {
 struct stat stStat;
 int handle = open(nombreArchivoExterno, 00);
 if (handle == -1) {
  printf("Error, leyendo archivo %s\n", nombreArchivoExterno);
  return 1;
 }
 int nodoLibre = buscaNodoLibre(miSistemaDeFicheros);
 if (stat(nombreArchivoExterno, &stStat) != 0) {
  perror("stat");
  fprintf(stderr, "Error, ejecutando stat en archivo %s\n",
    nombreArchivoExterno);
  return 2;
 }
 if (stStat.st_size > miSistemaDeFicheros->superBloque.numBloquesLibres
   * 4096) {
  fprintf(stderr, "No hay suficiente espacio en disco\n");
  return 3;
 }
 if (stStat.st_size > (4096 * 100)) {
  fprintf(stderr, "El archivo a copiar es demasido grande\n");
  return 4;
 }
 if (strlen(nombreArchivoInterno) > 15) {
  fprintf(stderr, "Nombre de archivo demasiado grande\n");
  return 5;
 }
 if (buscaPosDirectorio(miSistemaDeFicheros, nombreArchivoInterno) != -1) {
  fprintf(stderr, "El archivo a copiar ya existe\n");
  return 6;
 }
 if (nodoLibre == -1) {
  fprintf(stderr, "No existen nodos-i libres\n");
  return 7;
 }
 if (miSistemaDeFicheros->directorio.numArchivos
   == 100) {
  fprintf(stderr, "No caben mas archivos en el directorio\n");
  return 8;
 }
 EstructuraNodoI *nodo = malloc(sizeof(EstructuraNodoI));
 nodo->tamArchivo = stStat.st_size;
 nodo->numBloques = ((stStat.st_size + (4096 - 1))
   / 4096);
 nodo->libre = 0;
 nodo->tiempoModificado = time(0);
 miSistemaDeFicheros->nodosI[nodoLibre] = nodo;
 miSistemaDeFicheros->numNodosLibres--;
 reservaBloquesNodosI(miSistemaDeFicheros, nodo->idxBloques,
   nodo->numBloques);
 escribeNodoI(miSistemaDeFicheros, nodoLibre, nodo);
 escribeDatos(miSistemaDeFicheros, handle, nodoLibre);
 escribeMapaDeBits(miSistemaDeFicheros);
 miSistemaDeFicheros->directorio.numArchivos++;
 miSistemaDeFicheros->directorio.archivos[nodoLibre].libre = 0;
 strcpy(miSistemaDeFicheros->directorio.archivos[nodoLibre].nombreArchivo,
   nombreArchivoInterno);
 escribeDirectorio(miSistemaDeFicheros);
 miSistemaDeFicheros->superBloque.numBloquesLibres -= nodo->numBloques;
 escribeSuperBloque(miSistemaDeFicheros);
 sync();
 close(handle);
 return 0;
}

canonical_original_code:
int myImport(char *nombreArchivoExterno, struct MiSistemaDeFicheros *miSistemaDeFicheros, char *nombreArchivoInterno) {
 struct stat stStat;
 int handle = open(nombreArchivoExterno, 00);
 if (handle == -1) {
  printf("Error, leyendo archivo %s\n", nombreArchivoExterno);
  return 1;
 }
 int nodoLibre = buscaNodoLibre(miSistemaDeFicheros);
 if (stat(nombreArchivoExterno, &stStat) != 0) {
  perror("stat");
  fprintf(stderr, "Error, ejecutando stat en archivo %s\n",
    nombreArchivoExterno);
  return 2;
 }
 if (stStat.st_size > miSistemaDeFicheros->superBloque.numBloquesLibres
   * 4096) {
  fprintf(stderr, "No hay suficiente espacio en disco\n");
  return 3;
 }
 if (stStat.st_size > (4096 * 100)) {
  fprintf(stderr, "El archivo a copiar es demasido grande\n");
  return 4;
 }
 if (strlen(nombreArchivoInterno) > 15) {
  fprintf(stderr, "Nombre de archivo demasiado grande\n");
  return 5;
 }
 if (buscaPosDirectorio(miSistemaDeFicheros, nombreArchivoInterno) != -1) {
  fprintf(stderr, "El archivo a copiar ya existe\n");
  return 6;
 }
 if (nodoLibre == -1) {
  fprintf(stderr, "No existen nodos-i libres\n");
  return 7;
 }
 if (miSistemaDeFicheros->directorio.numArchivos
   == 100) {
  fprintf(stderr, "No caben mas archivos en el directorio\n");
  return 8;
 }
 struct EstructuraNodoI *nodo = malloc(sizeof(EstructuraNodoI));
 nodo->tamArchivo = stStat.st_size;
 nodo->numBloques = ((stStat.st_size + (4096 - 1))
   / 4096);
 nodo->libre = 0;
 nodo->tiempoModificado = time(0);
 miSistemaDeFicheros->nodosI[nodoLibre] = nodo;
 miSistemaDeFicheros->numNodosLibres--;
 reservaBloquesNodosI(miSistemaDeFicheros, nodo->idxBloques,
   nodo->numBloques);
 escribeNodoI(miSistemaDeFicheros, nodoLibre, nodo);
 escribeDatos(miSistemaDeFicheros, handle, nodoLibre);
 escribeMapaDeBits(miSistemaDeFicheros);
 miSistemaDeFicheros->directorio.numArchivos++;
 miSistemaDeFicheros->directorio.archivos[nodoLibre].libre = 0;
 strcpy(miSistemaDeFicheros->directorio.archivos[nodoLibre].nombreArchivo,
   nombreArchivoInterno);
 escribeDirectorio(miSistemaDeFicheros);
 miSistemaDeFicheros->superBloque.numBloquesLibres -= nodo->numBloques;
 escribeSuperBloque(miSistemaDeFicheros);
 sync();
 close(handle);
 return 0;
}

variable_types:
nombreArchivoExterno
char *

variable_types:
nombreArchivoInterno
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]; }

variable_types: handle int

variable_types: nodoLibre int

variable_types: struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *

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]; }


myExport

decompiled_code:
__int64 __fastcall myExport(__int64 a1, __int64 a2, const char *a3)
{
int v4; // eax
__int64 v5; // rbx
unsigned int v6; // ebp
int v7; // er8
__int64 result; // rax
char v9[41]; // [rsp+Fh] [rbp-29h] BYREF

v4 = buscaPosDirectorio(a1, a2);
v5 = v4;
if ( v4 == -1 )
{
perror(" El archivo a exportar no existe");
result = 1LL;
}
else
{
v6 = open(a3, 1, 436LL);
if ( v6 == -1 )
{
v6 = creat(a3, 0x1A4u);
}
else
{
puts("El archivo ya existe,desea sobreescribir?(y/N):");
_isoc99_scanf("%c", v9);
if ( (v9[0] & 0xDF) == 78 )
{
puts("Escribe otro nombre de archivo:");
_isoc99_scanf("%s", a3);
v6 = creat(a3, 0x1A4u);
}
else if ( (v9[0] & 0xDF) == 89 )
{
v6 = open(a3, 513, 436LL);
}
}
exportaDatos(a1, v6, *(unsigned int *)(a1 + 24 * v5 + 4136));
v7 = close(v6);
result = 0LL;
if ( v7 == -1 )
{
perror("myExport close");
puts("Error, myExport close.");
result = 1LL;
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2, const char *a3)
{
int v4; // eax
__int64 v5; // rbx
unsigned int v6; // ebp
int v7; // er8
__int64 result; // rax
char v9[41]; // [rsp+Fh] [rbp-29h] BYREF

v4 = buscaPosDirectorio(a1, a2);
v5 = v4;
if ( v4 == -1 )
{
perror(" El archivo a exportar no existe");
result = 1LL;
}
else
{
v6 = open(a3, 1, 436LL);
if ( v6 == -1 )
{
v6 = creat(a3, 0x1A4u);
}
else
{
puts("El archivo ya existe,desea sobreescribir?(y/N):");
_isoc99_scanf("%c", v9);
if ( (v9[0] & 0xDF) == 78 )
{
puts("Escribe otro nombre de archivo:");
_isoc99_scanf("%s", a3);
v6 = creat(a3, 0x1A4u);
}
else if ( (v9[0] & 0xDF) == 89 )
{
v6 = open(a3, 513, 436LL);
}
}
exportaDatos(a1, v6, *(unsigned int *)(a1 + 24 * v5 + 4136));
v7 = close(v6);
result = 0LL;
if ( v7 == -1 )
{
perror("myExport close");
puts("Error, myExport close.");
result = 1LL;
}
}
return result;
}

original_code:
int myExport(MiSistemaDeFicheros* miSistemaDeFicheros,
  char* nombreArchivoInterno, char* nombreArchivoExterno) {
 int handle;
 int posDirectorio = buscaPosDirectorio(miSistemaDeFicheros,
   nombreArchivoInterno);
 if (posDirectorio == -1) {
  perror(" El archivo a exportar no existe");
  return 1;
 }
 handle = open(nombreArchivoExterno, 01, 0664);
 if (handle != -1) {
  printf("El archivo ya existe,desea sobreescribir?(y/N):\n");
  char option;
  scanf("%c", &option);
  if (option == 'n' || option == 'N') {
   printf("%s", "Escribe otro nombre de archivo:\n");
   scanf("%s", nombreArchivoExterno);
   handle = creat(nombreArchivoExterno, 0644);
  } else if (option == 'y' || option == 'Y') {
   handle = open(nombreArchivoExterno, 01|01000, 0664);
  }
 } else {
  handle = creat(nombreArchivoExterno, 0644);
 }
 int idxNodoI =
   miSistemaDeFicheros->directorio.archivos[posDirectorio].idxNodoI;
 exportaDatos(miSistemaDeFicheros, handle, idxNodoI);
 if (close(handle) == -1) {
  perror("myExport close");
  printf("Error, myExport close.\n");
  return 1;
 }
 return 0;
}

canonical_original_code:
int myExport(struct MiSistemaDeFicheros *miSistemaDeFicheros, char *nombreArchivoInterno, char *nombreArchivoExterno) {
 int handle;
 int posDirectorio = buscaPosDirectorio(miSistemaDeFicheros,
   nombreArchivoInterno);
 if (posDirectorio == -1) {
  perror(" El archivo a exportar no existe");
  return 1;
 }
 handle = open(nombreArchivoExterno, 01, 0664);
 if (handle != -1) {
  printf("El archivo ya existe,desea sobreescribir?(y/N):\n");
  char option;
  scanf("%c", &option);
  if (option == 'n' || option == 'N') {
   printf("%s", "Escribe otro nombre de archivo:\n");
   scanf("%s", nombreArchivoExterno);
   handle = creat(nombreArchivoExterno, 0644);
  } else if (option == 'y' || option == 'Y') {
   handle = open(nombreArchivoExterno, 01|01000, 0664);
  }
 } else {
  handle = creat(nombreArchivoExterno, 0644);
 }
 int idxNodoI = miSistemaDeFicheros->directorio.archivos[posDirectorio].idxNodoI;
 exportaDatos(miSistemaDeFicheros, handle, idxNodoI);
 if (close(handle) == -1) {
  perror("myExport close");
  printf("Error, myExport close.\n");
  return 1;
 }
 return 0;
}

variable_types: struct MiSistemaDeFicheros { int discoVirtual; struct EstructuraSuperBloque { int tamSuperBloque; int tamDirectorio; int tamNodoI; int tamDiscoEnBloques; int numBloquesLibres; int tamBloque; int maxTamNombreArchivo; int maxBloquesPorArchivo; } superBloque; unsigned int mapaDeBits[-1]; struct EstructuraDirectorio { int numArchivos; struct EstructuraArchivo { int idxNodoI; char nombreArchivo[-1]; int libre; } archivos[100]; } directorio; struct EstructuraNodoI { int numBloques; int tamArchivo; long tiempoModificado; int idxBloques[100]; int libre; } *nodosI[-1]; int numNodosLibres; } *

variable_types: posDirectorio int

variable_types: option char

variable_types: idxNodoI int