decompiled_code:
ssize_t __fastcall get_data(void *buf, size_t nbytes)
{
ssize_t result; // rax

result = read(fd_s, buf, (unsigned int)nbytes);
if ( (int)result < 0 )
{
perror("get_data: read");
exit(1);
}
if ( !(_DWORD)result )
result = 0xFFFFFFFFLL;
return result;
}

canonical_decompiled_code:
ssize_t __fastcall func5(void *buf, size_t nbytes)
{
ssize_t result; // rax

result = read(fd_s, buf, (unsigned int)nbytes);
if ( (int)result < 0 )
{
perror("get_data: read");
exit(1);
}
if ( !(_DWORD)result )
result = 0xFFFFFFFFLL;
return result;
}

original_code:
int
get_data(void *buf, int size)
{
 int cnt;
 if ((cnt = read(fd_s, buf, size)) < 0) {
  perror("get_data: read");
  exit(1);
 }
 if (cnt == 0)
  return -1;
 else
  return cnt;
}


repo: dmorneau/TCP-Simulation

decompiled_code:
ssize_t __fastcall deliver_data(void *buf, size_t n)
{
ssize_t result; // rax

result = write(fd_r, buf, (unsigned int)n);
if ( (int)result < 0 )
{
perror("deliver_data: write");
exit(1);
}
return result;
}

canonical_decompiled_code:
ssize_t __fastcall func6(void *buf, size_t n)
{
ssize_t result; // rax

result = write(fd_r, buf, (unsigned int)n);
if ( (int)result < 0 )
{
perror("deliver_data: write");
exit(1);
}
return result;
}

original_code:
int
deliver_data(void *buf, int size)
{
 int cnt;
 if ((cnt = write(fd_r, buf, size)) < 0) {
  perror("deliver_data: write");
  exit(1);
 }
 return cnt;
}

variable_types:
buf
void *

variable_types: size int

variable_types: cnt int

return_type: int


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

if ( *(_DWORD *)(a1 + 4) >= 0xFFFFFFF8 || *(_DWORD *)(a1 + 4) == 0 )
_assert_fail("packet_size > HEADERSIZE", "gbn.c", 0x86u, "send_packet");
result = udt_send();
if ( (_DWORD)result )
{
if ( (_DWORD)result != -3 )
{
if ( (_DWORD)result == -2 )
{
fwrite("sender: NET_TOOBIG\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
fwrite("sender: unknown\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
fwrite("sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
return result;
}

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

if ( *(_DWORD *)(a1 + 4) >= 0xFFFFFFF8 || *(_DWORD *)(a1 + 4) == 0 )
_assert_fail("packet_size > HEADERSIZE", "gbn.c", 0x86u, "send_packet");
result = udt_send();
if ( (_DWORD)result )
{
if ( (_DWORD)result != -3 )
{
if ( (_DWORD)result == -2 )
{
fwrite("sender: NET_TOOBIG\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
fwrite("sender: unknown\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
fwrite("sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
return result;
}

original_code:
void send_packet(Packet* packet) {
  int ret;
  int packet_size = (sizeof(Packet) - 1024) + packet->nbuffer;
  ((void) sizeof ((packet_size > (sizeof(Packet) - 1024)) ? 1 : 0), __extension__ ({ if (packet_size > (sizeof(Packet) - 1024)) ; else __assert_fail ("packet_size > HEADERSIZE", "gbn.c", 134, __extension__ __PRETTY_FUNCTION__); }));
  if ((ret = udt_send(packet, packet_size)) != 0) {
    switch (ret) {
    case -2:
      fprintf(stderr, "sender: NET_TOOBIG\n");
      exit(1);
    case -3:
      fprintf(stderr, "sender: NET_SYSERR\n");
      exit(1);
    default:
      fprintf(stderr, "sender: unknown\n");
      exit(1);
    }
  }
}

canonical_original_code:
void send_packet(struct Packet *packet) {
  int ret;
  int packet_size = (sizeof(Packet) - 1024) + packet->nbuffer;
  ((void) sizeof ((packet_size > (sizeof(Packet) - 1024)) ? 1 : 0), __extension__ ({ if (packet_size > (sizeof(Packet) - 1024)) ; else __assert_fail ("packet_size > HEADERSIZE", "gbn.c", 134, __extension__ __PRETTY_FUNCTION__); }));
  if ((ret = udt_send(packet, packet_size)) != 0) {
    switch (ret) {
    case -2:
      fprintf(stderr, "sender: NET_TOOBIG\n");
      exit(1);
    case -3:
      fprintf(stderr, "sender: NET_SYSERR\n");
      exit(1);
    default:
      fprintf(stderr, "sender: unknown\n");
      exit(1);
    }
  }
}

variable_types: struct Packet { int seqn; int nbuffer; char buffer[1024]; } *

variable_types: ret int

return_type: void


PMOD

decompiled_code:
__int64 __fastcall PMOD(int a1, int a2)
{
int v2; // edx
unsigned int v3; // esi
__int64 result; // rax

v2 = a1 % a2;
v3 = a1 % a2 + a2;
result = (unsigned int)v2;
if ( v2 < 0 )
result = v3;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(int a1, int a2)
{
int v2; // edx
unsigned int v3; // esi
__int64 result; // rax

v2 = a1 % a2;
v3 = a1 % a2 + a2;
result = (unsigned int)v2;
if ( v2 < 0 )
result = v3;
return result;
}

original_code:
int PMOD(int n, int b) {
  int mod = n % b;
  return mod >= 0 ? mod : mod + b;
}

variable_types: n int

variable_types: b int

variable_types: mod int


decompiled_code:
void *__fastcall pqueue_init(__int64 a1, int a2)
{
void *result; // rax

*(_DWORD *)(a1 + 8) = a2;
*(_QWORD *)a1 = 0LL;
result = malloc(1032LL * a2);
*(_QWORD *)(a1 + 16) = result;
return result;
}

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

*(_DWORD *)(a1 + 8) = a2;
*(_QWORD *)a1 = 0LL;
result = malloc(1032LL * a2);
*(_QWORD *)(a1 + 16) = result;
return result;
}

original_code:
void pqueue_init(PQueue* queue, int windowsize) {
  queue->head = 0;
  queue->length = 0;
  queue->maxsize = windowsize;
  queue->packets = malloc(sizeof(Packet) * queue->maxsize);
}

canonical_original_code:
void pqueue_init(struct PQueue *queue, int windowsize) {
  queue->head = 0;
  queue->length = 0;
  queue->maxsize = windowsize;
  queue->packets = malloc(sizeof(Packet) * queue->maxsize);
}

variable_types: struct PQueue { int head; int length; int maxsize; struct Packet { int seqn; int nbuffer; char buffer[1024]; } *packets; } *

variable_types: windowsize int

user_defined_types: struct PQueue { int head; int length; int maxsize; struct Packet *packets; }


decompiled_code:
void __fastcall pqueue_destroy(__int64 a1)
{
free(*(void **)(a1 + 16));
}

canonical_decompiled_code:
void __fastcall func3(__int64 a1)
{
free(*(void **)(a1 + 16));
}

original_code:
void pqueue_destroy(PQueue* queue) {
  free(queue->packets);
}

canonical_original_code:
void pqueue_destroy(struct PQueue *queue) {
  free(queue->packets);
}

user_defined_types: struct Packet { int seqn; int nbuffer; char buffer[1024]; }


decompiled_code:
__int64 __fastcall pqueue_length(__int64 a1)
{
return *(unsigned int *)(a1 + 4);
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1)
{
return *(unsigned int *)(a1 + 4);
}

original_code:
int pqueue_length(PQueue* queue) {
  return queue->length;
}

canonical_original_code:
int pqueue_length(struct PQueue *queue) {
  return queue->length;
}


decompiled_code:
__int64 __fastcall pqueue_tail(__int64 a1)
{
int v1; // er8
int v2; // ecx

v1 = *(_DWORD *)(a1 + 4);
v2 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)a1 > v2 || *(int *)a1 < 0 )
_assert_fail("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 0x4Cu, "pqueue_tail");
if ( v1 > v2 )
_assert_fail("queue->length <= queue->maxsize", "gbn.c", 0x4Du, "pqueue_tail");
return *(_QWORD *)(a1 + 16) + 1032LL * ((*(_DWORD *)a1 + v1 - 1) % v2);
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 a1)
{
int v1; // er8
int v2; // ecx

v1 = *(_DWORD *)(a1 + 4);
v2 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)a1 > v2 || *(int *)a1 < 0 )
_assert_fail("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 0x4Cu, "pqueue_tail");
if ( v1 > v2 )
_assert_fail("queue->length <= queue->maxsize", "gbn.c", 0x4Du, "pqueue_tail");
return *(_QWORD *)(a1 + 16) + 1032LL * ((*(_DWORD *)a1 + v1 - 1) % v2);
}

original_code:
Packet* pqueue_tail(PQueue* queue) {
  int i = (queue->head + queue->length - 1) % queue->maxsize;
  ((void) sizeof ((queue->head <= queue->maxsize && queue->head >= 0) ? 1 : 0), __extension__ ({ if (queue->head <= queue->maxsize && queue->head >= 0) ; else __assert_fail ("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 76, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((queue->length <= queue->maxsize) ? 1 : 0), __extension__ ({ if (queue->length <= queue->maxsize) ; else __assert_fail ("queue->length <= queue->maxsize", "gbn.c", 77, __extension__ __PRETTY_FUNCTION__); }));
  return &queue->packets[i];
}

canonical_original_code:
struct Packet *pqueue_tail(struct PQueue *queue) {
  int i = (queue->head + queue->length - 1) % queue->maxsize;
  ((void) sizeof ((queue->head <= queue->maxsize && queue->head >= 0) ? 1 : 0), __extension__ ({ if (queue->head <= queue->maxsize && queue->head >= 0) ; else __assert_fail ("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 76, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((queue->length <= queue->maxsize) ? 1 : 0), __extension__ ({ if (queue->length <= queue->maxsize) ; else __assert_fail ("queue->length <= queue->maxsize", "gbn.c", 77, __extension__ __PRETTY_FUNCTION__); }));
  return &queue->packets[i];
}

variable_types: struct PQueue { int head; int length; int maxsize; struct Packet *packets; } *

variable_types: i int

return_type: struct Packet { int seqn; int nbuffer; char buffer[1024]; } *


decompiled_code:
__int64 __fastcall pqueue_head(int *a1)
{
__int64 v1; // rax
int v2; // edx

v1 = *a1;
v2 = a1[2];
if ( (int)v1 < 0 || (int)v1 > v2 )
_assert_fail("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 0x51u, "pqueue_head");
if ( v2 < a1[1] )
_assert_fail("queue->length <= queue->maxsize", "gbn.c", 0x52u, "pqueue_head");
return *((_QWORD *)a1 + 2) + 1032 * v1;
}

canonical_decompiled_code:
__int64 __fastcall func6(int *a1)
{
__int64 v1; // rax
int v2; // edx

v1 = *a1;
v2 = a1[2];
if ( (int)v1 < 0 || (int)v1 > v2 )
_assert_fail("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 0x51u, "pqueue_head");
if ( v2 < a1[1] )
_assert_fail("queue->length <= queue->maxsize", "gbn.c", 0x52u, "pqueue_head");
return *((_QWORD *)a1 + 2) + 1032 * v1;
}

original_code:
Packet* pqueue_head(PQueue* queue) {
  ((void) sizeof ((queue->head <= queue->maxsize && queue->head >= 0) ? 1 : 0), __extension__ ({ if (queue->head <= queue->maxsize && queue->head >= 0) ; else __assert_fail ("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 81, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((queue->length <= queue->maxsize) ? 1 : 0), __extension__ ({ if (queue->length <= queue->maxsize) ; else __assert_fail ("queue->length <= queue->maxsize", "gbn.c", 82, __extension__ __PRETTY_FUNCTION__); }));
  return &queue->packets[queue->head];
}

canonical_original_code:
struct Packet *pqueue_head(struct PQueue *queue) {
  ((void) sizeof ((queue->head <= queue->maxsize && queue->head >= 0) ? 1 : 0), __extension__ ({ if (queue->head <= queue->maxsize && queue->head >= 0) ; else __assert_fail ("queue->head <= queue->maxsize && queue->head >= 0", "gbn.c", 81, __extension__ __PRETTY_FUNCTION__); }));
  ((void) sizeof ((queue->length <= queue->maxsize) ? 1 : 0), __extension__ ({ if (queue->length <= queue->maxsize) ; else __assert_fail ("queue->length <= queue->maxsize", "gbn.c", 82, __extension__ __PRETTY_FUNCTION__); }));
  return &queue->packets[queue->head];
}


decompiled_code:
__int64 __fastcall pqueue_push(__int64 a1)
{
if ( (int)pqueue_length(a1) >= *(_DWORD *)(a1 + 8) )
_assert_fail("pqueue_length(queue) < queue->maxsize", "gbn.c", 0x56u, "pqueue_push");
++*(_DWORD *)(a1 + 4);
return pqueue_tail(a1);
}

canonical_decompiled_code:
__int64 __fastcall func7(__int64 a1)
{
if ( (int)func4(a1) >= *(_DWORD *)(a1 + 8) )
_assert_fail("pqueue_length(queue) < queue->maxsize", "gbn.c", 0x56u, "pqueue_push");
++*(_DWORD *)(a1 + 4);
return func5(a1);
}

original_code:
Packet* pqueue_push(PQueue* queue) {
  ((void) sizeof ((pqueue_length(queue) < queue->maxsize) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) < queue->maxsize) ; else __assert_fail ("pqueue_length(queue) < queue->maxsize", "gbn.c", 86, __extension__ __PRETTY_FUNCTION__); }));
  queue->length += 1;
  return pqueue_tail(queue);
}

canonical_original_code:
struct Packet *pqueue_push(struct PQueue *queue) {
  ((void) sizeof ((pqueue_length(queue) < queue->maxsize) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) < queue->maxsize) ; else __assert_fail ("pqueue_length(queue) < queue->maxsize", "gbn.c", 86, __extension__ __PRETTY_FUNCTION__); }));
  queue->length += 1;
  return pqueue_tail(queue);
}


decompiled_code:
__int64 __fastcall pqueue_pop(int *a1)
{
__int64 v1; // r8

pqueue_head(a1);
if ( (int)pqueue_length((__int64)a1) <= 0 )
_assert_fail("pqueue_length(queue) > 0", "gbn.c", 0x5Cu, "pqueue_pop");
--a1[1];
*a1 = PMOD(*a1 + 1, a1[2]);
return v1;
}

canonical_decompiled_code:
__int64 __fastcall func8(int *a1)
{
__int64 v1; // r8

func6(a1);
if ( (int)func4((__int64)a1) <= 0 )
_assert_fail("pqueue_length(queue) > 0", "gbn.c", 0x5Cu, "pqueue_pop");
--a1[1];
*a1 = func1(*a1 + 1, a1[2]);
return v1;
}

original_code:
Packet* pqueue_pop(PQueue* queue) {
  Packet* tmp = pqueue_head(queue);
  ((void) sizeof ((pqueue_length(queue) > 0) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) > 0) ; else __assert_fail ("pqueue_length(queue) > 0", "gbn.c", 92, __extension__ __PRETTY_FUNCTION__); }));
  queue->head++;
  queue->length--;
  queue->head = PMOD(queue->head, queue->maxsize);
  return tmp;
}

canonical_original_code:
struct Packet *pqueue_pop(struct PQueue *queue) {
  struct Packet *tmp = pqueue_head(queue);
  ((void) sizeof ((pqueue_length(queue) > 0) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) > 0) ; else __assert_fail ("pqueue_length(queue) > 0", "gbn.c", 92, __extension__ __PRETTY_FUNCTION__); }));
  queue->head++;
  queue->length--;
  queue->head = PMOD(queue->head, queue->maxsize);
  return tmp;
}


decompiled_code:
__int64 __fastcall pqueue_poptail(__int64 a1)
{
__int64 v1; // r8

pqueue_tail(a1);
if ( (int)pqueue_length(a1) <= 0 )
_assert_fail("pqueue_length(queue) > 0", "gbn.c", 0x64u, "pqueue_poptail");
--*(_DWORD *)(a1 + 4);
return v1;
}

canonical_decompiled_code:
__int64 __fastcall func9(__int64 a1)
{
__int64 v1; // r8

func5(a1);
if ( (int)func4(a1) <= 0 )
_assert_fail("pqueue_length(queue) > 0", "gbn.c", 0x64u, "pqueue_poptail");
--*(_DWORD *)(a1 + 4);
return v1;
}

original_code:
Packet* pqueue_poptail(PQueue* queue) {
  Packet* tmp = pqueue_tail(queue);
  ((void) sizeof ((pqueue_length(queue) > 0) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) > 0) ; else __assert_fail ("pqueue_length(queue) > 0", "gbn.c", 100, __extension__ __PRETTY_FUNCTION__); }));
  queue->length -= 1;
  return tmp;
}

canonical_original_code:
struct Packet *pqueue_poptail(struct PQueue *queue) {
  struct Packet *tmp = pqueue_tail(queue);
  ((void) sizeof ((pqueue_length(queue) > 0) ? 1 : 0), __extension__ ({ if (pqueue_length(queue) > 0) ; else __assert_fail ("pqueue_length(queue) > 0", "gbn.c", 100, __extension__ __PRETTY_FUNCTION__); }));
  queue->length -= 1;
  return tmp;
}


decompiled_code:
bool __fastcall pqueue_empty(__int64 a1)
{
return *(_DWORD *)(a1 + 4) == 0;
}

canonical_decompiled_code:
bool __fastcall func10(__int64 a1)
{
return *(_DWORD *)(a1 + 4) == 0;
}

original_code:
_Bool pqueue_empty(PQueue* queue) {
  return queue->length == 0;
}

canonical_original_code:
_Bool pqueue_empty(struct PQueue *queue) {
  return queue->length == 0;
}


original_code:
void pqueue_map(PQueue* queue, void (*fn)(Packet*) ) {
  int i = queue->head;
  int last = (queue->head + queue->length - 1) % queue->maxsize;
  if (pqueue_empty(queue))
    return;
  while( i != last ) {
    fn(&queue->packets[i]);
    i = PMOD(i+1, queue->maxsize);
  }
  if (pqueue_length(queue) > 1)
    fn(&queue->packets[last]);
}

canonical_original_code:
void pqueue_map(struct PQueue *queue, void (*fn)(struct Packet *)) {
  int i = queue->head;
  int last = (queue->head + queue->length - 1) % queue->maxsize;
  if (pqueue_empty(queue))
    return;
  while( i != last ) {
    fn(&queue->packets[i]);
    i = PMOD(i+1, queue->maxsize);
  }
  if (pqueue_length(queue) > 1)
    fn(&queue->packets[last]);
}

variable_types:
fn
void (*)(struct Packet *)

variable_types: last int


decompiled_code:
int __fastcall pqueue_debug_print(int *a1)
{
int v1; // eax
unsigned int v2; // er13
unsigned int v3; // er12
unsigned int *v4; // rbx
unsigned int *v5; // rax

v1 = pqueue_length((__int64)a1);
v2 = a1[2];
if ( v1 <= 0 )
return printf("Empty queue, window size %d\n", v2);
v3 = v1;
v4 = (unsigned int *)pqueue_tail((__int64)a1);
v5 = (unsigned int *)pqueue_head(a1);
return printf("Queue head seq#%d, tail seq#%d, size %d, window size %d\n", *v5, *v4, v3, v2);
}

canonical_decompiled_code:
int __fastcall func12(int *a1)
{
int v1; // eax
unsigned int v2; // er13
unsigned int v3; // er12
unsigned int *v4; // rbx
unsigned int *v5; // rax

v1 = func4((__int64)a1);
v2 = a1[2];
if ( v1 <= 0 )
return printf("Empty queue, window size %d\n", v2);
v3 = v1;
v4 = (unsigned int *)func5((__int64)a1);
v5 = (unsigned int *)func6(a1);
return printf("Queue head seq#%d, tail seq#%d, size %d, window size %d\n", *v5, *v4, v3, v2);
}

original_code:
void pqueue_debug_print(PQueue* queue) {
  if (pqueue_length(queue) > 0) {
    printf("Queue head seq#%d, tail seq#%d, size %d, window size %d\n",
     pqueue_head(queue)->seqn, pqueue_tail(queue)->seqn,
     pqueue_length(queue), queue->maxsize);
  } else {
    printf("Empty queue, window size %d\n", queue->maxsize);
  }
}

canonical_original_code:
void pqueue_debug_print(struct PQueue *queue) {
  if (pqueue_length(queue) > 0) {
    printf("Queue head seq#%d, tail seq#%d, size %d, window size %d\n",
     pqueue_head(queue)->seqn, pqueue_tail(queue)->seqn,
     pqueue_length(queue), queue->maxsize);
  } else {
    printf("Empty queue, window size %d\n", queue->maxsize);
  }
}


decompiled_code:
__int64 __fastcall get_ack(unsigned int a1)
{
int v1; // eax
__int64 result; // rax
char v3[4]; // [rsp+8h] [rbp-10h] BYREF
unsigned int v4; // [rsp+Ch] [rbp-Ch]

v1 = udt_recv(v3, 8LL, a1);
if ( v1 == -1 )
{
fwrite("Sender: NET_EOF\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
if ( v1 == -3 )
{
fwrite("Sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
if ( v1 )
result = v4;
else
result = 0xFFFFFFFFLL;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func13(unsigned int a1)
{
int v1; // eax
__int64 result; // rax
char v3[4]; // [rsp+8h] [rbp-10h] BYREF
unsigned int v4; // [rsp+Ch] [rbp-Ch]

v1 = udt_recv(v3, 8LL, a1);
if ( v1 == -1 )
{
fwrite("Sender: NET_EOF\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
if ( v1 == -3 )
{
fwrite("Sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
if ( v1 )
result = v4;
else
result = 0xFFFFFFFFLL;
return result;
}

original_code:
int get_ack(int timeout) {
  ACKPacket ack;
  int ret = udt_recv(&ack, sizeof(ACKPacket), timeout);
  if (ret == -1) {
    fprintf(stderr, "Sender: NET_EOF\n");
    exit(1);
  } else if (ret == -3) {
    fprintf(stderr, "Sender: NET_SYSERR\n");
    exit(1);
  }
  return ret == 0 ? -1 : ack.seqn;
}

canonical_original_code:
int get_ack(int timeout) {
  struct ACKPacket ack;
  int ret = udt_recv(&ack, sizeof(ACKPacket), timeout);
  if (ret == -1) {
    fprintf(stderr, "Sender: NET_EOF\n");
    exit(1);
  } else if (ret == -3) {
    fprintf(stderr, "Sender: NET_SYSERR\n");
    exit(1);
  }
  return ret == 0 ? -1 : ack.seqn;
}

variable_types: timeout int

variable_types: struct ACKPacket { char code[-1]; int seqn; }


decompiled_code:
void __fastcall start_timer(int a1)
{
cnt_timeout = a1;
cnt_time = 0;
cnt_active = 1;
}

canonical_decompiled_code:
void __fastcall func14(int a1)
{
cnt_timeout = a1;
cnt_time = 0;
cnt_active = 1;
}

original_code:
void start_timer(int timeout) {
  cnt_timeout = timeout;
  cnt_time = 0;
  cnt_active = 1;
}


decompiled_code:
void stop_timer()
{
cnt_active = 0;
}

canonical_decompiled_code:
void func15()
{
cnt_active = 0;
}

original_code:
void stop_timer() {
  cnt_active = 0;
}

canonical_original_code:
void stop_timer() {
  cnt_active = 0;
}


decompiled_code:
__int64 __fastcall receiver_acknowledge(int a1)
{
__int64 result; // rax
int v2[4]; // [rsp+8h] [rbp-10h] BYREF

v2[1] = a1;
v2[0] = 4932417;
result = udt_send(v2, 8LL);
if ( (_DWORD)result )
{
if ( (_DWORD)result != -3 )
{
if ( (_DWORD)result == -2 )
{
fwrite("sender: NET_TOOBIG\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
fwrite("sender: unknown\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
fwrite("sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func17(int a1)
{
__int64 result; // rax
int v2[4]; // [rsp+8h] [rbp-10h] BYREF

v2[1] = a1;
v2[0] = 4932417;
result = udt_send(v2, 8LL);
if ( (_DWORD)result )
{
if ( (_DWORD)result != -3 )
{
if ( (_DWORD)result == -2 )
{
fwrite("sender: NET_TOOBIG\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
fwrite("sender: unknown\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
fwrite("sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
return result;
}

original_code:
void receiver_acknowledge(int seqn) {
  int ret;
  ACKPacket ack = {"ACK", 0};
  ack.seqn = seqn;
  ret = udt_send(&ack, sizeof(ACKPacket));
  if (ret != 0) {
    switch (ret) {
    case -2:
      fprintf(stderr, "sender: NET_TOOBIG\n");
      exit(1);
    case -3:
      fprintf(stderr, "sender: NET_SYSERR\n");
      exit(1);
    default:
      fprintf(stderr, "sender: unknown\n");
      exit(1);
    }
  }
}

canonical_original_code:
void receiver_acknowledge(int seqn) {
  int ret;
  struct ACKPacket ack = {"ACK", 0};
  ack.seqn = seqn;
  ret = udt_send(&ack, sizeof(ACKPacket));
  if (ret != 0) {
    switch (ret) {
    case -2:
      fprintf(stderr, "sender: NET_TOOBIG\n");
      exit(1);
    case -3:
      fprintf(stderr, "sender: NET_SYSERR\n");
      exit(1);
    default:
      fprintf(stderr, "sender: unknown\n");
      exit(1);
    }
  }
}

variable_types: seqn int

user_defined_types: struct ACKPacket { char code[-1]; int seqn; }


canonical_decompiled_code:
__int64 __fastcall func4(int a1)
{
__int64 result; // rax
int v2[4]; // [rsp+8h] [rbp-10h] BYREF

v2[1] = a1;
v2[0] = 4932417;
result = udt_send(v2, 8LL);
if ( (_DWORD)result )
{
if ( (_DWORD)result != -3 )
{
if ( (_DWORD)result == -2 )
{
fwrite("sender: NET_TOOBIG\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
fwrite("sender: unknown\n", 1uLL, 0x10uLL, stderr);
exit(1);
}
fwrite("sender: NET_SYSERR\n", 1uLL, 0x13uLL, stderr);
exit(1);
}
return result;
}


decompiled_code:
__int64 __fastcall vazia_fig1(__int64 a1, unsigned int a2)
{
unsigned int v2; // er12
unsigned int v3; // ebx

v2 = 1;
v3 = a2;
do
{
if ( (unsigned __int8)le_da_coluna(a1, v3) != 32 )
v2 = 0;
++v3;
}
while ( v3 != a2 + 4 );
return v2;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, unsigned int a2)
{
unsigned int v2; // er12
unsigned int v3; // ebx

v2 = 1;
v3 = a2;
do
{
if ( (unsigned __int8)le_da_coluna(a1, v3) != 32 )
v2 = 0;
++v3;
}
while ( v3 != a2 + 4 );
return v2;
}

original_code:
int vazia_fig1(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 for(i = 0; i < 4; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig1(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 for(i = 0; i < 4; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

variable_types: struct no_linha { struct no_linha *acima; char *conteudo; struct l_pecas { char cor; int formato; struct l_pecas *next; } *lista_pecas; struct no_linha *abaixo; } *

variable_types: coluna int

variable_types: vazia int

user_defined_types: struct no_linha { struct no_linha *acima; char *conteudo; struct l_pecas *lista_pecas; struct no_linha *abaixo; }


decompiled_code:
__int64 __fastcall coloca_fig1(char a1, unsigned int a2)
{
unsigned int v2; // ebx
__int64 v3; // rbp
unsigned int v4; // er13
__int64 v5; // rsi
__int64 v7; // rax

v2 = a2;
v3 = top;
if ( top && (unsigned int)vazia_fig1(top, a2) )
{
while ( linha_baixo(v3) )
{
v7 = linha_baixo(v3);
if ( !(unsigned int)vazia_fig1(v7, a2) )
break;
v3 = linha_baixo(v3);
}
}
else
{
inserir_linha();
v3 = top;
}
v4 = a2 + 4;
insere_peca_lista(v3, (unsigned int)a1, 1LL);
do
{
v5 = v2++;
escreve_na_coluna(v3, v5, (unsigned int)a1);
}
while ( v2 != v4 );
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func1(char a1, unsigned int a2)
{
unsigned int v2; // ebx
__int64 v3; // rbp
unsigned int v4; // er13
__int64 v5; // rsi
__int64 v7; // rax

v2 = a2;
v3 = top;
if ( top && (unsigned int)func0(top, a2) )
{
while ( linha_baixo(v3) )
{
v7 = linha_baixo(v3);
if ( !(unsigned int)func0(v7, a2) )
break;
v3 = linha_baixo(v3);
}
}
else
{
inserir_linha();
v3 = top;
}
v4 = a2 + 4;
insere_peca_lista(v3, (unsigned int)a1, 1LL);
do
{
v5 = v2++;
escreve_na_coluna(v3, v5, (unsigned int)a1);
}
while ( v2 != v4 );
return v3;
}

original_code:
ptr_no coloca_fig1(char cor, int coluna)
{
 int i;
 ptr_no ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig1(ponteiro,coluna) == 0)
 {
  inserir_linha();
  ponteiro = top;
 }
 else
  while(linha_baixo(ponteiro) != ((void *)0) && vazia_fig1(linha_baixo(ponteiro),coluna))
   ponteiro = linha_baixo(ponteiro);
 insere_peca_lista(ponteiro,cor,1);
 for(i = 0;i < 4; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 return ponteiro;
}

canonical_original_code:
struct no_linha *coloca_fig1(char cor, int coluna)
{
 int i;
 struct no_linha *ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig1(ponteiro,coluna) == 0)
 {
  inserir_linha();
  ponteiro = top;
 }
 else
  while(linha_baixo(ponteiro) != ((void *)0) && vazia_fig1(linha_baixo(ponteiro),coluna))
   ponteiro = linha_baixo(ponteiro);
 insere_peca_lista(ponteiro,cor,1);
 for(i = 0;i < 4; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 return ponteiro;
}

variable_types: cor char

return_type: struct no_linha { struct no_linha *acima; char *conteudo; struct l_pecas { char cor; int formato; struct l_pecas *next; } *lista_pecas; struct no_linha *abaixo; } *


decompiled_code:
_BOOL8 __fastcall vazia_fig2(__int64 a1, __int64 a2)
{
char v2; // r12
char v3; // r8
_BOOL8 result; // rax

v2 = le_da_coluna(a1, a2);
v3 = le_da_coluna(a1, (unsigned int)(a2 + 1));
result = 0LL;
if ( v3 == 32 )
result = v2 == 32;
return result;
}

canonical_decompiled_code:
_BOOL8 __fastcall func2(__int64 a1, __int64 a2)
{
char v2; // r12
char v3; // r8
_BOOL8 result; // rax

v2 = le_da_coluna(a1, a2);
v3 = le_da_coluna(a1, (unsigned int)(a2 + 1));
result = 0LL;
if ( v3 == 32 )
result = v2 == 32;
return result;
}

original_code:
int vazia_fig2(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 for(i = 0; i < 2; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig2(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 for(i = 0; i < 2; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

user_defined_types: struct l_pecas { char cor; int formato; struct l_pecas *next; }


decompiled_code:
__int64 __fastcall coloca_fig2(char a1, __int64 a2)
{
__int64 v2; // r13
__int64 v4; // r13
__int64 v5; // r14
__int64 v7; // rdi
__int64 v8; // rax

v2 = top;
if ( top && vazia_fig2(top, a2) )
{
if ( linha_baixo(v2) && (v7 = linha_baixo(v2), vazia_fig2(v7, (unsigned int)a2)) )
{
while ( linha_baixo(v2) )
{
v8 = linha_baixo(v2);
if ( !vazia_fig2(v8, (unsigned int)a2) )
break;
v2 = linha_baixo(v2);
}
v4 = linha_cima(v2);
}
else
{
inserir_linha();
v4 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v4 = top;
}
escreve_na_coluna(v4, (unsigned int)a2, (unsigned int)a1);
escreve_na_coluna(v4, (unsigned int)(a2 + 1), (unsigned int)a1);
v5 = linha_baixo(v4);
escreve_na_coluna(v5, (unsigned int)a2, (unsigned int)a1);
escreve_na_coluna(v5, (unsigned int)(a2 + 1), (unsigned int)a1);
insere_peca_lista(v4, (unsigned int)a1, 2LL);
return v4;
}

canonical_decompiled_code:
__int64 __fastcall func3(char a1, __int64 a2)
{
__int64 v2; // r13
__int64 v4; // r13
__int64 v5; // r14
__int64 v7; // rdi
__int64 v8; // rax

v2 = top;
if ( top && func2(top, a2) )
{
if ( linha_baixo(v2) && (v7 = linha_baixo(v2), func2(v7, (unsigned int)a2)) )
{
while ( linha_baixo(v2) )
{
v8 = linha_baixo(v2);
if ( !func2(v8, (unsigned int)a2) )
break;
v2 = linha_baixo(v2);
}
v4 = linha_cima(v2);
}
else
{
inserir_linha();
v4 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v4 = top;
}
escreve_na_coluna(v4, (unsigned int)a2, (unsigned int)a1);
escreve_na_coluna(v4, (unsigned int)(a2 + 1), (unsigned int)a1);
v5 = linha_baixo(v4);
escreve_na_coluna(v5, (unsigned int)a2, (unsigned int)a1);
escreve_na_coluna(v5, (unsigned int)(a2 + 1), (unsigned int)a1);
insere_peca_lista(v4, (unsigned int)a1, 2LL);
return v4;
}

original_code:
ptr_no coloca_fig2(char cor, int coluna)
{
 int i,coluna_l2;
 ptr_no final, ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig2(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig2(linha_baixo(ponteiro),coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   {
    while(linha_baixo(ponteiro) != ((void *)0) && vazia_fig2(linha_baixo(ponteiro),coluna))
     ponteiro = linha_baixo(ponteiro);
    ponteiro = linha_cima(ponteiro);
   }
 final = ponteiro;
 coluna_l2 = coluna;
 for(i = 0;i < 2; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 for(i = 0;i < 2; i++,coluna_l2++)
  escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,2);
 return final;
}

canonical_original_code:
struct no_linha *coloca_fig2(char cor, int coluna)
{
 int i; int coluna_l2;
 struct no_linha *final; struct no_linha *ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig2(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig2(linha_baixo(ponteiro),coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   {
    while(linha_baixo(ponteiro) != ((void *)0) && vazia_fig2(linha_baixo(ponteiro),coluna))
     ponteiro = linha_baixo(ponteiro);
    ponteiro = linha_cima(ponteiro);
   }
 final = ponteiro;
 coluna_l2 = coluna;
 for(i = 0;i < 2; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 for(i = 0;i < 2; i++,coluna_l2++)
  escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,2);
 return final;
}


decompiled_code:
// attributes: thunk
_BOOL8 __fastcall vazia_fig3_superior(__int64 a1, __int64 a2)
{
return vazia_fig2(a1, a2);
}

canonical_decompiled_code:
_BOOL8 __fastcall func4(__int64 a1, __int64 a2)
{
return func2(a1, a2);
}

original_code:
int vazia_fig3_superior(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 for(i = 0; i < 2; i++,coluna++)
   if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig3_superior(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 for(i = 0; i < 2; i++,coluna++)
   if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}


decompiled_code:
_BOOL8 __fastcall vazia_fig3_base(__int64 a1, int a2)
{
char v2; // r12
char v3; // r8
_BOOL8 result; // rax

v2 = le_da_coluna(a1, (unsigned int)(a2 + 1));
v3 = le_da_coluna(a1, (unsigned int)(a2 + 2));
result = 0LL;
if ( v3 == 32 )
result = v2 == 32;
return result;
}

canonical_decompiled_code:
_BOOL8 __fastcall func5(__int64 a1, int a2)
{
char v2; // r12
char v3; // r8
_BOOL8 result; // rax

v2 = le_da_coluna(a1, (unsigned int)(a2 + 1));
v3 = le_da_coluna(a1, (unsigned int)(a2 + 2));
result = 0LL;
if ( v3 == 32 )
result = v2 == 32;
return result;
}

original_code:
int vazia_fig3_base(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 coluna++;
 for(i = 0; i < 2; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig3_base(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 coluna++;
 for(i = 0; i < 2; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}


decompiled_code:
__int64 __fastcall coloca_fig3(char a1, unsigned int a2)
{
__int64 v2; // r12
__int64 v4; // r13
__int64 v6; // rdi
__int64 v7; // rax
__int64 v8; // rax
__int64 v9; // rax
__int64 v10; // rax

v2 = top;
if ( top && vazia_fig3_base(top, a2) )
{
if ( linha_baixo(v2) && (v6 = linha_baixo(v2), vazia_fig3_base(v6, a2)) && vazia_fig2(v2, a2) )
{
while ( linha_baixo(v2) )
{
v7 = linha_baixo(v2);
if ( !linha_baixo(v7) )
break;
v8 = linha_baixo(v2);
v9 = linha_baixo(v8);
if ( !vazia_fig3_base(v9, a2) )
break;
v10 = linha_baixo(v2);
if ( !vazia_fig2(v10, a2) )
break;
v2 = linha_baixo(v2);
}
}
else
{
inserir_linha();
v2 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v2 = top;
}
escreve_na_coluna(v2, a2, (unsigned int)a1);
escreve_na_coluna(v2, a2 + 1, (unsigned int)a1);
v4 = linha_baixo(v2);
escreve_na_coluna(v4, a2 + 1, (unsigned int)a1);
escreve_na_coluna(v4, a2 + 2, (unsigned int)a1);
insere_peca_lista(v2, (unsigned int)a1, 3LL);
return v2;
}

canonical_decompiled_code:
__int64 __fastcall func6(char a1, unsigned int a2)
{
__int64 v2; // r12
__int64 v4; // r13
__int64 v6; // rdi
__int64 v7; // rax
__int64 v8; // rax
__int64 v9; // rax
__int64 v10; // rax

v2 = top;
if ( top && func5(top, a2) )
{
if ( linha_baixo(v2) && (v6 = linha_baixo(v2), func5(v6, a2)) && func2(v2, a2) )
{
while ( linha_baixo(v2) )
{
v7 = linha_baixo(v2);
if ( !linha_baixo(v7) )
break;
v8 = linha_baixo(v2);
v9 = linha_baixo(v8);
if ( !func5(v9, a2) )
break;
v10 = linha_baixo(v2);
if ( !func2(v10, a2) )
break;
v2 = linha_baixo(v2);
}
}
else
{
inserir_linha();
v2 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v2 = top;
}
escreve_na_coluna(v2, a2, (unsigned int)a1);
escreve_na_coluna(v2, a2 + 1, (unsigned int)a1);
v4 = linha_baixo(v2);
escreve_na_coluna(v4, a2 + 1, (unsigned int)a1);
escreve_na_coluna(v4, a2 + 2, (unsigned int)a1);
insere_peca_lista(v2, (unsigned int)a1, 3LL);
return v2;
}

original_code:
ptr_no coloca_fig3(char cor, int coluna)
{
 int i,coluna_l2;
 ptr_no final,ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig3_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig3_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig3_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig3_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig3_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna+1;
 for(i = 0;i < 2; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 for(i = 0;i < 2; i++,coluna_l2++)
  escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,3);
 return final;
}

canonical_original_code:
struct no_linha *coloca_fig3(char cor, int coluna)
{
 int i; int coluna_l2;
 struct no_linha *final; struct no_linha *ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig3_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig3_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig3_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig3_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig3_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna+1;
 for(i = 0;i < 2; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 for(i = 0;i < 2; i++,coluna_l2++)
  escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,3);
 return final;
}


decompiled_code:
__int64 __fastcall vazia_fig4_superior(__int64 a1, unsigned int a2)
{
unsigned int v2; // er12
unsigned int v3; // ebx

v2 = 1;
v3 = a2;
do
{
if ( (unsigned __int8)le_da_coluna(a1, v3) != 32 )
v2 = 0;
++v3;
}
while ( v3 != a2 + 3 );
return v2;
}

canonical_decompiled_code:
__int64 __fastcall func7(__int64 a1, unsigned int a2)
{
unsigned int v2; // er12
unsigned int v3; // ebx

v2 = 1;
v3 = a2;
do
{
if ( (unsigned __int8)le_da_coluna(a1, v3) != 32 )
v2 = 0;
++v3;
}
while ( v3 != a2 + 3 );
return v2;
}

original_code:
int vazia_fig4_superior(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 for(i = 0; i < 3; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig4_superior(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 for(i = 0; i < 3; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}


decompiled_code:
_BOOL8 __fastcall vazia_fig4_base(__int64 a1, int a2)
{
return (unsigned __int8)le_da_coluna(a1, (unsigned int)(a2 + 1)) == 32;
}

canonical_decompiled_code:
_BOOL8 __fastcall func8(__int64 a1, int a2)
{
return (unsigned __int8)le_da_coluna(a1, (unsigned int)(a2 + 1)) == 32;
}

original_code:
int vazia_fig4_base(ptr_no linha,int coluna)
{
 int vazia = 1;
 if(le_da_coluna(linha,++coluna) != ' ')
   vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig4_base(struct no_linha *linha, int coluna)
{
 int vazia = 1;
 if(le_da_coluna(linha,++coluna) != ' ')
   vazia = 0;
 return vazia;
}


decompiled_code:
__int64 __fastcall coloca_fig4(char a1, unsigned int a2)
{
unsigned int v3; // ebp
__int64 v4; // r15
unsigned int v5; // ebx
unsigned int v6; // er14
unsigned int v7; // er13
__int64 v8; // rsi
__int64 v9; // rax
__int64 v11; // rdi
__int64 v12; // rax
__int64 v13; // rax
__int64 v14; // rax
__int64 v15; // rax

v3 = a2;
v4 = top;
if ( top && vazia_fig4_base(top, a2) )
{
if ( linha_baixo(v4)
&& (v11 = linha_baixo(v4), vazia_fig4_base(v11, a2))
&& (unsigned int)vazia_fig4_superior(v4, a2) )
{
while ( linha_baixo(v4) )
{
v12 = linha_baixo(v4);
if ( !linha_baixo(v12) )
break;
v13 = linha_baixo(v4);
v14 = linha_baixo(v13);
if ( !vazia_fig4_base(v14, a2) )
break;
v15 = linha_baixo(v4);
if ( !(unsigned int)vazia_fig4_superior(v15, a2) )
break;
v4 = linha_baixo(v4);
}
}
else
{
inserir_linha();
v4 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v4 = top;
}
v5 = a2 + 1;
v6 = a2 + 3;
v7 = a2 + 1;
while ( 1 )
{
v8 = v3;
v3 = v5;
escreve_na_coluna(v4, v8, (unsigned int)a1);
if ( v5 == v6 )
break;
++v5;
}
v9 = linha_baixo(v4);
escreve_na_coluna(v9, v7, (unsigned int)a1);
insere_peca_lista(v4, (unsigned int)a1, 4LL);
return v4;
}

canonical_decompiled_code:
__int64 __fastcall func9(char a1, unsigned int a2)
{
unsigned int v3; // ebp
__int64 v4; // r15
unsigned int v5; // ebx
unsigned int v6; // er14
unsigned int v7; // er13
__int64 v8; // rsi
__int64 v9; // rax
__int64 v11; // rdi
__int64 v12; // rax
__int64 v13; // rax
__int64 v14; // rax
__int64 v15; // rax

v3 = a2;
v4 = top;
if ( top && func8(top, a2) )
{
if ( linha_baixo(v4)
&& (v11 = linha_baixo(v4), func8(v11, a2))
&& (unsigned int)func7(v4, a2) )
{
while ( linha_baixo(v4) )
{
v12 = linha_baixo(v4);
if ( !linha_baixo(v12) )
break;
v13 = linha_baixo(v4);
v14 = linha_baixo(v13);
if ( !func8(v14, a2) )
break;
v15 = linha_baixo(v4);
if ( !(unsigned int)func7(v15, a2) )
break;
v4 = linha_baixo(v4);
}
}
else
{
inserir_linha();
v4 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v4 = top;
}
v5 = a2 + 1;
v6 = a2 + 3;
v7 = a2 + 1;
while ( 1 )
{
v8 = v3;
v3 = v5;
escreve_na_coluna(v4, v8, (unsigned int)a1);
if ( v5 == v6 )
break;
++v5;
}
v9 = linha_baixo(v4);
escreve_na_coluna(v9, v7, (unsigned int)a1);
insere_peca_lista(v4, (unsigned int)a1, 4LL);
return v4;
}

original_code:
ptr_no coloca_fig4(char cor, int coluna)
{
 int i,coluna_l2;
 ptr_no final, ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig4_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig4_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig4_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig4_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig4_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna+1;
 for(i = 0;i < 3; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,4);
 return final;
}

canonical_original_code:
struct no_linha *coloca_fig4(char cor, int coluna)
{
 int i; int coluna_l2;
 struct no_linha *final; struct no_linha *ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig4_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig4_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig4_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig4_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig4_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna+1;
 for(i = 0;i < 3; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,4);
 return final;
}


decompiled_code:
// attributes: thunk
__int64 __fastcall vazia_fig5_superior(__int64 a1, unsigned int a2)
{
return vazia_fig4_superior(a1, a2);
}

canonical_decompiled_code:
__int64 __fastcall func10(__int64 a1, unsigned int a2)
{
return func7(a1, a2);
}

original_code:
int vazia_fig5_superior(ptr_no linha,int coluna)
{
 int i, vazia = 1;
 for(i = 0; i < 3; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig5_superior(struct no_linha *linha, int coluna)
{
 int i; int vazia = 1;
 for(i = 0; i < 3; i++,coluna++)
  if(le_da_coluna(linha,coluna) != ' ')
    vazia = 0;
 return vazia;
}


decompiled_code:
_BOOL8 __fastcall vazia_fig5_base(__int64 a1, __int64 a2)
{
return (unsigned __int8)le_da_coluna(a1, a2) == 32;
}

canonical_decompiled_code:
_BOOL8 __fastcall func11(__int64 a1, __int64 a2)
{
return (unsigned __int8)le_da_coluna(a1, a2) == 32;
}

original_code:
int vazia_fig5_base(ptr_no linha,int coluna)
{
 int vazia = 1;
 if(le_da_coluna(linha,coluna) != ' ')
   vazia = 0;
 return vazia;
}

canonical_original_code:
int vazia_fig5_base(struct no_linha *linha, int coluna)
{
 int vazia = 1;
 if(le_da_coluna(linha,coluna) != ' ')
   vazia = 0;
 return vazia;
}


decompiled_code:
__int64 __fastcall coloca_fig5(char a1, __int64 a2)
{
unsigned int v2; // er13
__int64 v3; // r12
unsigned int v5; // ebx
__int64 v6; // rsi
__int64 v7; // rax
__int64 v9; // rdi
__int64 v10; // rax
__int64 v11; // rax
__int64 v12; // rax
__int64 v13; // rax

v2 = a2;
v3 = top;
if ( top && vazia_fig5_base(top, a2) )
{
if ( linha_baixo(v3)
&& (v9 = linha_baixo(v3), vazia_fig5_base(v9, (unsigned int)a2))
&& (unsigned int)vazia_fig4_superior(v3, a2) )
{
while ( linha_baixo(v3) )
{
v10 = linha_baixo(v3);
if ( !linha_baixo(v10) )
break;
v11 = linha_baixo(v3);
v12 = linha_baixo(v11);
if ( !vazia_fig5_base(v12, (unsigned int)a2) )
break;
v13 = linha_baixo(v3);
if ( !(unsigned int)vazia_fig4_superior(v13, a2) )
break;
v3 = linha_baixo(v3);
}
}
else
{
inserir_linha();
v3 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v3 = top;
}
v5 = a2;
do
{
v6 = v5++;
escreve_na_coluna(v3, v6, (unsigned int)a1);
}
while ( v5 != v2 + 3 );
v7 = linha_baixo(v3);
escreve_na_coluna(v7, v2, (unsigned int)a1);
insere_peca_lista(v3, (unsigned int)a1, 5LL);
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func12(char a1, __int64 a2)
{
unsigned int v2; // er13
__int64 v3; // r12
unsigned int v5; // ebx
__int64 v6; // rsi
__int64 v7; // rax
__int64 v9; // rdi
__int64 v10; // rax
__int64 v11; // rax
__int64 v12; // rax
__int64 v13; // rax

v2 = a2;
v3 = top;
if ( top && func11(top, a2) )
{
if ( linha_baixo(v3)
&& (v9 = linha_baixo(v3), func11(v9, (unsigned int)a2))
&& (unsigned int)func7(v3, a2) )
{
while ( linha_baixo(v3) )
{
v10 = linha_baixo(v3);
if ( !linha_baixo(v10) )
break;
v11 = linha_baixo(v3);
v12 = linha_baixo(v11);
if ( !func11(v12, (unsigned int)a2) )
break;
v13 = linha_baixo(v3);
if ( !(unsigned int)func7(v13, a2) )
break;
v3 = linha_baixo(v3);
}
}
else
{
inserir_linha();
v3 = top;
}
}
else
{
inserir_linha();
inserir_linha();
v3 = top;
}
v5 = a2;
do
{
v6 = v5++;
escreve_na_coluna(v3, v6, (unsigned int)a1);
}
while ( v5 != v2 + 3 );
v7 = linha_baixo(v3);
escreve_na_coluna(v7, v2, (unsigned int)a1);
insere_peca_lista(v3, (unsigned int)a1, 5LL);
return v3;
}

original_code:
ptr_no coloca_fig5(char cor, int coluna)
{
 int i,coluna_l2;
 ptr_no final,ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig5_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig5_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig5_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig5_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig5_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna;
 for(i = 0;i < 3; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,5);
 return final;
}

canonical_original_code:
struct no_linha *coloca_fig5(char cor, int coluna)
{
 int i; int coluna_l2;
 struct no_linha *final; struct no_linha *ponteiro = top;
 if(ponteiro == ((void *)0) || vazia_fig5_base(ponteiro,coluna) == 0)
  {
   inserir_linha();
   inserir_linha();
   ponteiro = top;
  }
 else if(linha_baixo(ponteiro) == ((void *)0) || vazia_fig5_base(linha_baixo(ponteiro),coluna) == 0 || vazia_fig5_superior(ponteiro,coluna) == 0)
  {
   inserir_linha();
   ponteiro = top;
  }
  else
   while(linha_baixo(ponteiro) != ((void *)0) && linha_baixo(linha_baixo(ponteiro)) != ((void *)0) && vazia_fig5_base(linha_baixo(linha_baixo(ponteiro)),coluna) && vazia_fig5_superior(linha_baixo(ponteiro),coluna))
    ponteiro = linha_baixo(ponteiro);
 final = ponteiro;
 coluna_l2 = coluna;
 for(i = 0;i < 3; i++,coluna++)
  escreve_na_coluna(ponteiro,coluna,cor);
 ponteiro = linha_baixo(ponteiro);
 escreve_na_coluna(ponteiro,coluna_l2,cor);
 insere_peca_lista(final,cor,5);
 return final;
}


lmax

decompiled_code:
__int64 __fastcall lmax(__int64 a1)
{
unsigned int v1; // er12

v1 = 0;
if ( a1 )
{
do
++v1;
while ( linha_baixo() );
}
return v1;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1)
{
unsigned int v1; // er12

v1 = 0;
if ( a1 )
{
do
++v1;
while ( linha_baixo() );
}
return v1;
}

original_code:
int lmax(ptr_no topo)
{
 int i;
 for(i = 0; topo != ((void *)0); topo = linha_baixo(topo))
  i++;
 return i;
}

canonical_original_code:
int lmax(struct no_linha *topo)
{
 int i;
 for(i = 0; topo != ((void *)0); topo = linha_baixo(topo))
  i++;
 return i;
}


decompiled_code:
__int64 inserir_linha()
{
__int64 result; // rax

result = inserir_no(top);
top = result;
return result;
}

canonical_decompiled_code:
__int64 func1()
{
__int64 result; // rax

result = inserir_no(top);
top = result;
return result;
}

original_code:
void inserir_linha()
{
 top = inserir_no(top);
}


decompiled_code:
__int64 __fastcall apagar_linha(_QWORD *a1)
{
__int64 result; // rax

remove_grandes(*a1);
apaga_lista(a1[2]);
result = apagar_no(a1, top);
top = result;
return result;
}

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

remove_grandes(*a1);
apaga_lista(a1[2]);
result = apagar_no(a1, top);
top = result;
return result;
}

original_code:
void apagar_linha(ptr_no linha)
{
 remove_grandes(linha->acima);
 apaga_lista(linha->lista_pecas);
 top = apagar_no(linha,top);
}

canonical_original_code:
void apagar_linha(struct no_linha *linha)
{
 remove_grandes(linha->acima);
 apaga_lista(linha->lista_pecas);
 top = apagar_no(linha,top);
}


decompiled_code:
int __fastcall imprimir_tabuleiro(__int64 a1, __int64 a2, unsigned int a3)
{
__int64 v4; // rbp
unsigned int v5; // ebx
__int64 v6; // rax

v4 = a1;
v5 = a2;
printf("%d\n", a2);
printf("%d\n\n", a3);
if ( a1 )
{
do
{
putchar(124);
v6 = le_linha(v4);
imprimir(v6);
printf("| %d\n", v5--);
v4 = linha_baixo(v4);
}
while ( v4 );
}
return puts(" ----------");
}

canonical_decompiled_code:
int __fastcall func3(__int64 a1, __int64 a2, unsigned int a3)
{
__int64 v4; // rbp
unsigned int v5; // ebx
__int64 v6; // rax

v4 = a1;
v5 = a2;
printf("%d\n", a2);
printf("%d\n\n", a3);
if ( a1 )
{
do
{
putchar(124);
v6 = le_linha(v4);
imprimir(v6);
printf("| %d\n", v5--);
v4 = linha_baixo(v4);
}
while ( v4 );
}
return puts(" ----------");
}

original_code:
void imprimir_tabuleiro(ptr_no topo,int Lmax,int pontuacao)
{
 printf("%d\n",Lmax);
 printf("%d\n\n",pontuacao);
 while(topo != ((void *)0))
  {
   printf("|");
   imprimir(le_linha(topo));
   printf("| %d\n",Lmax--);
   topo = linha_baixo(topo);
  }
 printf(" ----------\n");
}

canonical_original_code:
void imprimir_tabuleiro(struct no_linha *topo, int Lmax, int pontuacao)
{
 printf("%d\n",Lmax);
 printf("%d\n\n",pontuacao);
 while(topo != ((void *)0))
  {
   printf("|");
   imprimir(le_linha(topo));
   printf("| %d\n",Lmax--);
   topo = linha_baixo(topo);
  }
 printf(" ----------\n");
}

variable_types: Lmax int

variable_types: pontuacao int


ler

decompiled_code:
__int64 ler()
{
__int64 result; // rax
char v1; // [rsp+7h] [rbp-11h] BYREF
int v2; // [rsp+8h] [rbp-10h] BYREF
unsigned int v3; // [rsp+Ch] [rbp-Ch] BYREF

fscanf(stdin, "%d %d %c \n", &v2, &v3, &v1);
switch ( v2 )
{
case 1:
result = coloca_fig1((unsigned int)v1, v3);
break;
case 2:
result = coloca_fig2((unsigned int)v1, v3);
break;
case 3:
result = coloca_fig3((unsigned int)v1, v3);
break;
case 4:
result = coloca_fig4((unsigned int)v1, v3);
break;
case 5:
result = coloca_fig5((unsigned int)v1, v3);
break;
default:
printf("ERRO INTERNO,switch leitura");
exit(0);
}
return result;
}

canonical_decompiled_code:
__int64 func4()
{
__int64 result; // rax
char v1; // [rsp+7h] [rbp-11h] BYREF
int v2; // [rsp+8h] [rbp-10h] BYREF
unsigned int v3; // [rsp+Ch] [rbp-Ch] BYREF

fscanf(stdin, "%d %d %c \n", &v2, &v3, &v1);
switch ( v2 )
{
case 1:
result = coloca_fig1((unsigned int)v1, v3);
break;
case 2:
result = coloca_fig2((unsigned int)v1, v3);
break;
case 3:
result = coloca_fig3((unsigned int)v1, v3);
break;
case 4:
result = coloca_fig4((unsigned int)v1, v3);
break;
case 5:
result = coloca_fig5((unsigned int)v1, v3);
break;
default:
printf("ERRO INTERNO,switch leitura");
exit(0);
}
return result;
}

original_code:
ptr_no ler()
{
 int tipo,coordenada;
 char cor;
 ptr_no final;
  fscanf(stdin,"%d %d %c \n",&tipo, &coordenada, &cor);
  switch(tipo)
  {
   case 1: final = coloca_fig1(cor, coordenada);break;
   case 2: final = coloca_fig2(cor, coordenada);break;
   case 3: final = coloca_fig3(cor, coordenada);break;
   case 4: final = coloca_fig4(cor, coordenada);break;
   case 5: final = coloca_fig5(cor, coordenada);break;
   default :printf("ERRO INTERNO,switch leitura");exit(0);
  }
 return final;
}

canonical_original_code:
struct no_linha *ler()
{
 int tipo; int coordenada;
 char cor;
 struct no_linha *final;
  fscanf(stdin,"%d %d %c \n",&tipo, &coordenada, &cor);
  switch(tipo)
  {
   case 1: final = coloca_fig1(cor, coordenada);break;
   case 2: final = coloca_fig2(cor, coordenada);break;
   case 3: final = coloca_fig3(cor, coordenada);break;
   case 4: final = coloca_fig4(cor, coordenada);break;
   case 5: final = coloca_fig5(cor, coordenada);break;
   default :printf("ERRO INTERNO,switch leitura");exit(0);
  }
 return final;
}

variable_types: tipo int

variable_types: coordenada int


main

canonical_name: main

decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // ebx
__int64 v4; // rax
__int64 v5; // rsi
int v7[3]; // [rsp+Ch] [rbp-Ch] BYREF

inicia_pecas_inteiras(argc, argv, envp);
scanf("%d\n", v7);
if ( v7[0] > 0 )
{
v3 = 0;
do
{
++v3;
v4 = ler();
pontuacao += pontua(v4);
}
while ( v7[0] > v3 );
}
v5 = (unsigned int)lmax(top);
imprimir_tabuleiro(top, v5, pontuacao);
putchar(10);
conta_pecas(top);
printf("%d\n", (unsigned int)numero_pecas_inteiras);
imprimir_contagem();
putchar(10);
imprElim();
return 0;
}

canonical_decompiled_code:
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // ebx
__int64 v4; // rax
__int64 v5; // rsi
int v7[3]; // [rsp+Ch] [rbp-Ch] BYREF

inicia_pecas_inteiras(argc, argv, envp);
scanf("%d\n", v7);
if ( v7[0] > 0 )
{
v3 = 0;
do
{
++v3;
v4 = func4();
pontuacao += pontua(v4);
}
while ( v7[0] > v3 );
}
v5 = (unsigned int)func0(top);
func3(top, v5, pontuacao);
putchar(10);
conta_pecas(top);
printf("%d\n", (unsigned int)numero_pecas_inteiras);
imprimir_contagem();
putchar(10);
imprElim();
return 0;
}

original_code:
int main()
{
 int i, Lmax,total_pecas;
 ptr_no ultima_linha;
 inicia_pecas_inteiras();
 scanf("%d\n",&total_pecas);
 for(i = 0; i < total_pecas; i++)
 {
  ultima_linha = ler();
  pontuacao += pontua(ultima_linha);
 }
 Lmax = lmax(top);
 imprimir_tabuleiro(top,Lmax,pontuacao);
 printf("\n");
 conta_pecas(top);
 printf("%d\n",numero_pecas_inteiras);
 imprimir_contagem();
 printf("\n");
 imprElim();
 return 0;
}

canonical_original_code:
int main()
{
 int i; int Lmax; int total_pecas;
 struct no_linha *ultima_linha;
 inicia_pecas_inteiras();
 scanf("%d\n",&total_pecas);
 for(i = 0; i < total_pecas; i++)
 {
  ultima_linha = ler();
  pontuacao += pontua(ultima_linha);
 }
 Lmax = lmax(top);
 imprimir_tabuleiro(top,Lmax,pontuacao);
 printf("\n");
 conta_pecas(top);
 printf("%d\n",numero_pecas_inteiras);
 imprimir_contagem();
 printf("\n");
 imprElim();
 return 0;
}


insereElim

decompiled_code:
int __fastcall insereElim(void *src)
{
__int64 v1; // rbx
_QWORD *v2; // r12
size_t v3; // r14
char *v4; // rax
const char *v5; // rbp
int result; // eax
__int64 v7; // r13

v1 = head;
v2 = malloc(0x10uLL);
v3 = strlen((const char *)src) + 1;
v4 = (char *)malloc(v3);
*v2 = v4;
v5 = v4;
result = (unsigned int)memcpy(v4, src, v3);
if ( v1 && (result = strcmp(*(const char **)v1, v5), result <= 0) )
{
do
{
v7 = v1;
v1 = *(_QWORD *)(v1 + 8);
if ( !v1 )
{
v2[1] = 0LL;
*(_QWORD *)(v7 + 8) = v2;
return result;
}
result = strcmp(*(const char **)v1, v5);
}
while ( result <= 0 );
v2[1] = v1;
*(_QWORD *)(v7 + 8) = v2;
}
else
{
v2[1] = v1;
head = (__int64)v2;
}
return result;
}

canonical_decompiled_code:
int __fastcall func0(void *src)
{
__int64 v1; // rbx
_QWORD *v2; // r12
size_t v3; // r14
char *v4; // rax
const char *v5; // rbp
int result; // eax
__int64 v7; // r13

v1 = head;
v2 = malloc(0x10uLL);
v3 = strlen((const char *)src) + 1;
v4 = (char *)malloc(v3);
*v2 = v4;
v5 = v4;
result = (unsigned int)memcpy(v4, src, v3);
if ( v1 && (result = strcmp(*(const char **)v1, v5), result <= 0) )
{
do
{
v7 = v1;
v1 = *(_QWORD *)(v1 + 8);
if ( !v1 )
{
v2[1] = 0LL;
*(_QWORD *)(v7 + 8) = v2;
return result;
}
result = strcmp(*(const char **)v1, v5);
}
while ( result <= 0 );
v2[1] = v1;
*(_QWORD *)(v7 + 8) = v2;
}
else
{
v2[1] = v1;
head = (__int64)v2;
}
return result;
}

original_code:
void insereElim(char* lin){
 list aux=head;
 list lt = (list)malloc(sizeof(struct elim));
 lt->linha=(char*)malloc(sizeof(char)*(strlen(lin)+1));
 strcpy(lt->linha, lin);
 if(aux==((void *)0) || (strcmp(aux->linha,lt->linha))>0){
  lt->next=head;
  head=lt;
  return;
 }
 while(aux->next!=((void *)0)){
  if((strcmp(aux->next->linha,lt->linha)>0)){
   lt->next=aux->next;
   aux->next=lt;
   return;
  }
  aux=aux->next;
 }
 lt->next=aux->next;
 aux->next=lt;
}

canonical_original_code:
void insereElim(char *lin){
 struct elim *aux = head;
 struct elim *lt = (list)malloc(sizeof(struct elim));
 lt->linha=(char *)malloc(sizeof(char)*(strlen(lin)+1));
 strcpy(lt->linha, lin);
 if(aux==((void *)0) || (strcmp(aux->linha,lt->linha))>0){
  lt->next=head;
  head=lt;
  return;
 }
 while(aux->next!=((void *)0)){
  if((strcmp(aux->next->linha,lt->linha)>0)){
   lt->next=aux->next;
   aux->next=lt;
   return;
  }
  aux=aux->next;
 }
 lt->next=aux->next;
 aux->next=lt;
}

variable_types:
lin
char *

variable_types: struct elim { char *linha; struct elim *next; } *


trataLinhas

decompiled_code:
int __fastcall trataLinhas(__int64 a1)
{
char v1; // al
char *v2; // rdx
int v3; // ecx
__int64 v4; // rsi
char v6; // [rsp+0h] [rbp-28h] BYREF
char v7; // [rsp+1h] [rbp-27h] BYREF

strcpy(&v6, *(const char **)(a1 + 8));
v1 = v6;
if ( v6 )
{
v2 = &v7;
v3 = 0;
do
{
if ( v1 != 32 )
{
v4 = v3++;
*(&v6 + v4) = v1;
}
v1 = *v2++;
}
while ( v1 );
}
else
{
v3 = 0;
}
*(&v6 + v3) = 0;
return insereElim(&v6);
}

original_code:
void trataLinhas(ptr_no lin){
 int i,j;
 char ln[20];
 strcpy(ln, lin->conteudo);
 for(i=j=0; ln[i]!='\0';i++)
  if(ln[i]!= ' ')
   ln[j++]=ln[i];
 ln[j]='\0';
 insereElim(ln);
}

canonical_original_code:
void trataLinhas(struct no_linha *lin){
 int i; int j;
 char ln[20];
 strcpy(ln, lin->conteudo);
 for(i=j=0; ln[i]!='\0';i++)
  if(ln[i]!= ' ')
   ln[j++]=ln[i];
 ln[j]='\0';
 insereElim(ln);
}

variable_types: j int

variable_types:
ln
char [20]


listLength

decompiled_code:
__int64 listLength()
{
__int64 v0; // rax
unsigned int i; // er8

v0 = head;
for ( i = 0; v0; ++i )
v0 = *(_QWORD *)(v0 + 8);
return i;
}

canonical_decompiled_code:
__int64 func2()
{
__int64 v0; // rax
unsigned int i; // er8

v0 = head;
for ( i = 0; v0; ++i )
v0 = *(_QWORD *)(v0 + 8);
return i;
}

original_code:
int listLength(){
 list aux=head;
 int length=0;
 while(aux!=((void *)0)){
  length++;
  aux=aux->next;
 }
 return length;
}

canonical_original_code:
int listLength(){
 struct elim *aux = head;
 int length = 0;
 while(aux!=((void *)0)){
  length++;
  aux=aux->next;
 }
 return length;
}

variable_types: length int

user_defined_types: struct elim { char *linha; struct elim *next; }


imprElim

decompiled_code:
int imprElim()
{
int v0; // eax
__int64 v1; // rdx
int v2; // ecx
int i; // eax

v0 = listLength();
if ( !v0 )
return puts("No eliminations");
v1 = head;
v2 = (v0 % 2 == 1) + v0 / 2;
for ( i = 1; i != v2; v1 = *(_QWORD *)(v1 + 8) )
++i;
return puts(*(const char **)v1);
}

canonical_decompiled_code:
int func3()
{
int v0; // eax
__int64 v1; // rdx
int v2; // ecx
int i; // eax

v0 = func2();
if ( !v0 )
return puts("No eliminations");
v1 = head;
v2 = (v0 % 2 == 1) + v0 / 2;
for ( i = 1; i != v2; v1 = *(_QWORD *)(v1 + 8) )
++i;
return puts(*(const char **)v1);
}

original_code:
void imprElim(){
 int x=1;
 list aux=head;
 int mediana=listLength();
 if(mediana==0){
  printf("No eliminations\n");
  return;
 }
 if((mediana%2)==1)
  mediana=(mediana/2)+1;
 else
  mediana=mediana/2;
 while(x!=mediana){
  aux=aux->next;
  x++;
 }
 printf("%s\n",aux->linha);
}

canonical_original_code:
void imprElim(){
 int x = 1;
 struct elim *aux = head;
 int mediana = listLength();
 if(mediana==0){
  printf("No eliminations\n");
  return;
 }
 if((mediana%2)==1)
  mediana=(mediana/2)+1;
 else
  mediana=mediana/2;
 while(x!=mediana){
  aux=aux->next;
  x++;
 }
 printf("%s\n",aux->linha);
}

variable_types: x int

variable_types: mediana int


NOVO

decompiled_code:
char *NOVO()
{
char *result; // rax

result = (char *)malloc(0xBuLL);
if ( !result )
{
printf("ERRO INTERNO: Alocacao memoria string");
exit(0);
}
strcpy(result, " ");
return result;
}

canonical_decompiled_code:
char *func0()
{
char *result; // rax

result = (char *)malloc(0xBuLL);
if ( !result )
{
printf("ERRO INTERNO: Alocacao memoria string");
exit(0);
}
strcpy(result, " ");
return result;
}

original_code:
Item NOVO()
{
 int i;
 Item nova = (Item) (malloc((sizeof(char)*(10 +1))));
 if (nova == ((void *)0))
  {
   printf("ERRO INTERNO: Alocacao memoria string");
   exit(0);
  }
 for(i = 0; i < 10; i++)
  nova[i] = ' ';
 nova[i] = '\0';
 return nova;
}

canonical_original_code:
char *NOVO()
{
 int i;
 char *nova = (Item) (malloc((sizeof(char)*(10 +1))));
 if (nova == ((void *)0))
  {
   printf("ERRO INTERNO: Alocacao memoria string");
   exit(0);
  }
 for(i = 0; i < 10; i++)
  nova[i] = ' ';
 nova[i] = '\0';
 return nova;
}

variable_types: i int

variable_types:
nova
char *

return_type: char *


imprimir

decompiled_code:
int __fastcall imprimir(const char *a1)
{
return printf("%s", a1);
}

canonical_decompiled_code:
int __fastcall func1(const char *a1)
{
return printf("%s", a1);
}

original_code:
void imprimir(char *string)
{
 printf("%s",string);
}

variable_types:
string
char *


original_code:
void remove_grandes(ptr_no linha)
{
 ptr_pecas aux,peca;
 if(linha == ((void *)0))
  return;
 peca = linha->lista_pecas;
 if(peca == ((void *)0))
  return;
 while(peca != ((void *)0) && peca->formato != 1)
  {
   aux = peca;
   peca = peca->next;
   free(aux);
  }
 linha->lista_pecas = peca;
 while(peca != ((void *)0))
  {
   aux = peca->next;
   if(aux != ((void *)0) && aux->formato != 1)
    {
     peca->next = aux->next;
     free(aux);
    }
   peca = peca->next;
  }
}

canonical_original_code:
void remove_grandes(struct no_linha *linha)
{
 struct l_pecas *aux; struct l_pecas *peca;
 if(linha == ((void *)0))
  return;
 peca = linha->lista_pecas;
 if(peca == ((void *)0))
  return;
 while(peca != ((void *)0) && peca->formato != 1)
  {
   aux = peca;
   peca = peca->next;
   free(aux);
  }
 linha->lista_pecas = peca;
 while(peca != ((void *)0))
  {
   aux = peca->next;
   if(aux != ((void *)0) && aux->formato != 1)
    {
     peca->next = aux->next;
     free(aux);
    }
   peca = peca->next;
  }
}

variable_types: struct no_linha { struct no_linha *acima; char *conteudo; struct l_pecas { char cor; int formato; struct l_pecas *next; } *lista_pecas; struct no_linha *abaixo; } *


decompiled_code:
void inicia_pecas_inteiras()
{
*((_QWORD *)&pecas_inteiras + 2) = 0LL;
pecas_inteiras = 0LL;
}

canonical_decompiled_code:
void func2()
{
*((_QWORD *)&pecas_inteiras + 2) = 0LL;
pecas_inteiras = 0LL;
}

original_code:
void inicia_pecas_inteiras()
{
 int i,j;
 for(i = 0, j = 0; i < 5; i++)
  while(j < 6)
   {
    pecas_inteiras[i][j] = 0;
    j++;
   }
}

canonical_original_code:
void inicia_pecas_inteiras()
{
 int i; int j;
 for(i = 0, j = 0; i < 5; i++)
  while(j < 6)
   {
    pecas_inteiras[i][j] = 0;
    j++;
   }
}


decompiled_code:
void __fastcall conta_pecas(__int64 a1)
{
__int64 v1; // r8
__int64 v2; // rcx
int v3; // esi
char v4; // di
int v5; // eax
__int64 v6; // rdx

if ( a1 )
{
v1 = a1;
do
{
v2 = *(_QWORD *)(v1 + 16);
if ( v2 )
{
v3 = numero_pecas_inteiras;
v4 = 0;
do
{
v5 = *(_DWORD *)(v2 + 4) - 1;
switch ( *(_BYTE *)v2 )
{
case 'B':
v6 = 0LL;
break;
case 'G':
v6 = 1LL;
break;
case 'O':
v6 = 2LL;
break;
case 'R':
v6 = 3LL;
break;
case 'V':
v6 = 4LL;
break;
case 'Y':
v6 = 5LL;
break;
default:
if ( v4 )
numero_pecas_inteiras = v3;
printf("Erro conta_pecas: cor invalida");
exit(0);
}
v2 = *(_QWORD *)(v2 + 8);
++v3;
v4 = 1;
++pecas_inteiras[6 * v5 + v6];
}
while ( v2 );
numero_pecas_inteiras = v3;
}
v1 = linha_baixo(v1);
}
while ( v1 );
}
}

canonical_decompiled_code:
void __fastcall func3(__int64 a1)
{
__int64 v1; // r8
__int64 v2; // rcx
int v3; // esi
char v4; // di
int v5; // eax
__int64 v6; // rdx

if ( a1 )
{
v1 = a1;
do
{
v2 = *(_QWORD *)(v1 + 16);
if ( v2 )
{
v3 = numero_pecas_inteiras;
v4 = 0;
do
{
v5 = *(_DWORD *)(v2 + 4) - 1;
switch ( *(_BYTE *)v2 )
{
case 'B':
v6 = 0LL;
break;
case 'G':
v6 = 1LL;
break;
case 'O':
v6 = 2LL;
break;
case 'R':
v6 = 3LL;
break;
case 'V':
v6 = 4LL;
break;
case 'Y':
v6 = 5LL;
break;
default:
if ( v4 )
numero_pecas_inteiras = v3;
printf("Erro conta_pecas: cor invalida");
exit(0);
}
v2 = *(_QWORD *)(v2 + 8);
++v3;
v4 = 1;
++pecas_inteiras[6 * v5 + v6];
}
while ( v2 );
numero_pecas_inteiras = v3;
}
v1 = linha_baixo(v1);
}
while ( v1 );
}
}

original_code:
void conta_pecas(ptr_no topo)
{
 ptr_pecas lista;
 int formato,cor_num;
 char cor;
 while(topo != ((void *)0))
 {
  lista = topo->lista_pecas;
  while(lista != ((void *)0))
  {
   formato = lista->formato -1 ;
   cor = lista->cor;
   switch(cor){
    case 'B': cor_num = 0;break;
    case 'G': cor_num = 1;break;
    case 'O': cor_num = 2;break;
    case 'R': cor_num = 3;break;
    case 'V': cor_num = 4;break;
    case 'Y': cor_num = 5;break;
    default : printf("Erro conta_pecas: cor invalida");exit(0);
    }
   pecas_inteiras[formato][cor_num] += 1;
   numero_pecas_inteiras++;
   lista = lista->next;
  }
 topo = linha_baixo(topo);
 }
}

canonical_original_code:
void conta_pecas(struct no_linha *topo)
{
 struct l_pecas *lista;
 int formato; int cor_num;
 char cor;
 while(topo != ((void *)0))
 {
  lista = topo->lista_pecas;
  while(lista != ((void *)0))
  {
   formato = lista->formato -1 ;
   cor = lista->cor;
   switch(cor){
    case 'B': cor_num = 0;break;
    case 'G': cor_num = 1;break;
    case 'O': cor_num = 2;break;
    case 'R': cor_num = 3;break;
    case 'V': cor_num = 4;break;
    case 'Y': cor_num = 5;break;
    default : printf("Erro conta_pecas: cor invalida");exit(0);
    }
   pecas_inteiras[formato][cor_num] += 1;
   numero_pecas_inteiras++;
   lista = lista->next;
  }
 topo = linha_baixo(topo);
 }
}

variable_types: struct l_pecas { char cor; int formato; struct l_pecas *next; } *

variable_types: formato int


decompiled_code:
int imprimir_contagem()
{
int *v0; // r15
unsigned int v1; // ebp
int *v2; // r14
unsigned int i; // er13
int v4; // ebx
unsigned int v5; // er12
int result; // eax

v0 = pecas_inteiras;
v1 = 0;
do
{
++v1;
v2 = v0;
for ( i = -1; i != 5; ++i )
{
while ( 1 )
{
v4 = *v2;
if ( *v2 )
break;
++i;
++v2;
if ( i == 5 )
goto LABEL_9;
}
if ( i <= 4 )
v5 = CSWTCH_8[i];
else
v5 = 66;
do
{
result = printf("%d %c\n", v1, v5);
--v4;
}
while ( v4 );
++v2;
}
LABEL_9:
v0 += 6;
}
while ( v1 != 6 );
return result;
}

canonical_decompiled_code:
int func4()
{
int *v0; // r15
unsigned int v1; // ebp
int *v2; // r14
unsigned int i; // er13
int v4; // ebx
unsigned int v5; // er12
int result; // eax

v0 = pecas_inteiras;
v1 = 0;
do
{
++v1;
v2 = v0;
for ( i = -1; i != 5; ++i )
{
while ( 1 )
{
v4 = *v2;
if ( *v2 )
break;
++i;
++v2;
if ( i == 5 )
goto LABEL_9;
}
if ( i <= 4 )
v5 = CSWTCH_8[i];
else
v5 = 66;
do
{
result = printf("%d %c\n", v1, v5);
--v4;
}
while ( v4 );
++v2;
}
LABEL_9:
v0 += 6;
}
while ( v1 != 6 );
return result;
}

original_code:
void imprimir_contagem()
{
 int formato,cor_num,contadas;
 char cor;
 for(formato = cor_num = 0; formato< 6; formato++)
 {
  for(cor_num = 0; cor_num < 6; cor_num++)
  {
   contadas = pecas_inteiras[formato][cor_num];
   if(contadas == 0)
    continue;
   switch(cor_num){
    case 0: cor = 'B';break;
    case 1: cor = 'G';break;
    case 2: cor = 'O';break;
    case 3: cor = 'R';break;
    case 4: cor = 'V';break;
    case 5: cor = 'Y';break;
    default : printf("Erro imprimir_contagem: erro interno");exit(0);
    }
   while(contadas-- != 0)
    printf("%d %c\n",formato+1,cor);
   }
 }
}

canonical_original_code:
void imprimir_contagem()
{
 int formato; int cor_num; int contadas;
 char cor;
 for(formato = cor_num = 0; formato< 6; formato++)
 {
  for(cor_num = 0; cor_num < 6; cor_num++)
  {
   contadas = pecas_inteiras[formato][cor_num];
   if(contadas == 0)
    continue;
   switch(cor_num){
    case 0: cor = 'B';break;
    case 1: cor = 'G';break;
    case 2: cor = 'O';break;
    case 3: cor = 'R';break;
    case 4: cor = 'V';break;
    case 5: cor = 'Y';break;
    default : printf("Erro imprimir_contagem: erro interno");exit(0);
    }
   while(contadas-- != 0)
    printf("%d %c\n",formato+1,cor);
   }
 }
}

variable_types: contadas int

variable_types: cor char


decompiled_code:
_QWORD *criar_no()
{
_QWORD *v0; // r12
__int64 v1; // rax
_QWORD *result; // rax

v0 = malloc(0x20uLL);
v1 = NOVO();
*v0 = 0LL;
v0[1] = v1;
result = v0;
v0[2] = 0LL;
v0[3] = 0LL;
return result;
}

canonical_decompiled_code:
_QWORD *func0()
{
_QWORD *v0; // r12
__int64 v1; // rax
_QWORD *result; // rax

v0 = malloc(0x20uLL);
v1 = NOVO();
*v0 = 0LL;
v0[1] = v1;
result = v0;
v0[2] = 0LL;
v0[3] = 0LL;
return result;
}

original_code:
ptr_no criar_no()
{
 ptr_no novo;
 novo = (ptr_no) malloc (sizeof(struct no_linha));
 novo->conteudo = NOVO();
 novo->lista_pecas = ((void *)0);
 novo->abaixo = ((void *)0);
 novo->acima = ((void *)0);
 return novo;
}

canonical_original_code:
struct no_linha *criar_no()
{
 struct no_linha *novo;
 novo = (struct no_linha *) malloc (sizeof(struct no_linha));
 novo->conteudo = NOVO();
 novo->lista_pecas = ((void *)0);
 novo->abaixo = ((void *)0);
 novo->acima = ((void *)0);
 return novo;
}


decompiled_code:
__int64 __fastcall linha_baixo(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Linha_baixo de um NULL");
exit(0);
}
return *(_QWORD *)(a1 + 24);
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Linha_baixo de um NULL");
exit(0);
}
return *(_QWORD *)(a1 + 24);
}

original_code:
ptr_no linha_baixo(ptr_no linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Linha_baixo de um NULL");
  exit(0);
 }
 return linha->abaixo;
}

canonical_original_code:
struct no_linha *linha_baixo(struct no_linha *linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Linha_baixo de um NULL");
  exit(0);
 }
 return linha->abaixo;
}

variable_types:
linha
struct no_linha *


decompiled_code:
__int64 __fastcall linha_cima(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Linha_cima de um NULL");
exit(0);
}
return *(_QWORD *)a1;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Linha_cima de um NULL");
exit(0);
}
return *(_QWORD *)a1;
}

original_code:
ptr_no linha_cima(ptr_no linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Linha_cima de um NULL");
  exit(0);
 }
 return linha->acima;
}

canonical_original_code:
struct no_linha *linha_cima(struct no_linha *linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Linha_cima de um NULL");
  exit(0);
 }
 return linha->acima;
}


decompiled_code:
void __fastcall escreve_linha(__int64 a1, __int64 a2)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: escrever linha num NULL");
exit(0);
}
*(_QWORD *)(a1 + 8) = a2;
}

canonical_decompiled_code:
void __fastcall func3(__int64 a1, __int64 a2)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: escrever linha num NULL");
exit(0);
}
*(_QWORD *)(a1 + 8) = a2;
}

original_code:
void escreve_linha(ptr_no linha,Item item)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: escrever linha num NULL");
  exit(0);
 }
 linha->conteudo = item;
}

canonical_original_code:
void escreve_linha(struct no_linha *linha, char *item)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: escrever linha num NULL");
  exit(0);
 }
 linha->conteudo = item;
}

variable_types:
item
char *


decompiled_code:
__int64 __fastcall le_linha(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Ler linha de um NULL");
exit(0);
}
return *(_QWORD *)(a1 + 8);
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Ler linha de um NULL");
exit(0);
}
return *(_QWORD *)(a1 + 8);
}

original_code:
Item le_linha(ptr_no linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Ler linha de um NULL");
  exit(0);
 }
 return linha->conteudo;
}

canonical_original_code:
char *le_linha(struct no_linha *linha)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Ler linha de um NULL");
  exit(0);
 }
 return linha->conteudo;
}


decompiled_code:
__int64 __fastcall escreve_na_coluna(__int64 a1, int a2, char a3)
{
__int64 result; // rax

if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: escrever na coluna de um NULL");
exit(0);
}
result = *(_QWORD *)(a1 + 8);
*(_BYTE *)(result + a2 - 1) = a3;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 a1, int a2, char a3)
{
__int64 result; // rax

if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: escrever na coluna de um NULL");
exit(0);
}
result = *(_QWORD *)(a1 + 8);
*(_BYTE *)(result + a2 - 1) = a3;
return result;
}

original_code:
void escreve_na_coluna(ptr_no linha,int coluna,char letra)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: escrever na coluna de um NULL");
  exit(0);
 }
 linha->conteudo[coluna-1] = letra;
}

canonical_original_code:
void escreve_na_coluna(struct no_linha *linha, int coluna, char letra)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: escrever na coluna de um NULL");
  exit(0);
 }
 linha->conteudo[coluna-1] = letra;
}

variable_types: coluna int

variable_types: letra char


decompiled_code:
__int64 __fastcall le_da_coluna(__int64 a1, int a2)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Ler da coluna de um NULL");
exit(0);
}
return *(unsigned __int8 *)(*(_QWORD *)(a1 + 8) + a2 - 1LL);
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1, int a2)
{
if ( !a1 )
{
printf("ERRO INTERNO_tabuleiro: Ler da coluna de um NULL");
exit(0);
}
return *(unsigned __int8 *)(*(_QWORD *)(a1 + 8) + a2 - 1LL);
}

original_code:
char le_da_coluna(ptr_no linha,int coluna)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Ler da coluna de um NULL");
  exit(0);
 }
 return linha->conteudo[coluna-1];
}

canonical_original_code:
char le_da_coluna(struct no_linha *linha, int coluna)
{
 if(linha == ((void *)0))
 {
  printf("ERRO INTERNO_tabuleiro: Ler da coluna de um NULL");
  exit(0);
 }
 return linha->conteudo[coluna-1];
}

return_type: char


decompiled_code:
__int64 __fastcall conta_cores(__int64 a1)
{
unsigned int v1; // ebx
unsigned int v2; // er14
char v3; // r12
char v4; // al

if ( (unsigned __int8)le_da_coluna(a1, 1LL) != 32 )
{
v1 = 2;
v2 = 1;
v3 = le_da_coluna(a1, 1LL);
while ( 1 )
{
v4 = le_da_coluna(a1, v1);
if ( v4 == 32 )
break;
if ( v3 != v4 )
v2 = 2;
if ( ++v1 == 11 )
return v2;
}
}
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1)
{
unsigned int v1; // ebx
unsigned int v2; // er14
char v3; // r12
char v4; // al

if ( (unsigned __int8)le_da_coluna(a1, 1LL) != 32 )
{
v1 = 2;
v2 = 1;
v3 = le_da_coluna(a1, 1LL);
while ( 1 )
{
v4 = le_da_coluna(a1, v1);
if ( v4 == 32 )
break;
if ( v3 != v4 )
v2 = 2;
if ( ++v1 == 11 )
return v2;
}
}
return 0LL;
}

original_code:
int conta_cores(ptr_no linha)
{
 int posicao,duas_cores = 1;
 char pri_cor,cor_lida;
 posicao = 1;
 if(le_da_coluna(linha,posicao) == ' ')
  return 0;
 else
  pri_cor = le_da_coluna(linha,posicao);
  for(posicao = 2; posicao <= 10; posicao++)
  {
   cor_lida = le_da_coluna(linha,posicao);
   if(cor_lida == ' ')
    return 0;
   else if(cor_lida != pri_cor)
    duas_cores = 2;
  }
 return duas_cores;
}

canonical_original_code:
int conta_cores(struct no_linha *linha)
{
 int posicao; int duas_cores = 1;
 char pri_cor; char cor_lida;
 posicao = 1;
 if(le_da_coluna(linha,posicao) == ' ')
  return 0;
 else
  pri_cor = le_da_coluna(linha,posicao);
  for(posicao = 2; posicao <= 10; posicao++)
  {
   cor_lida = le_da_coluna(linha,posicao);
   if(cor_lida == ' ')
    return 0;
   else if(cor_lida != pri_cor)
    duas_cores = 2;
  }
 return duas_cores;
}

variable_types: posicao int


pontua

decompiled_code:
__int64 __fastcall pontua(__int64 a1)
{
__int64 v1; // rbx
int v2; // er14
unsigned int v3; // er12
__int64 v4; // r13
int i; // er15
__int64 v6; // rax
__int64 v8; // rax
__int64 v9; // rax
__int64 v10; // rax
__int64 v11; // rbp
__int64 v12; // rax
__int64 v13; // rax
__int64 v14; // rax

v3 = 0;
if ( a1 )
{
v4 = a1;
for ( i = 0; ; ++i )
{
LODWORD(v6) = conta_cores(v4);
LOBYTE(v2) = i <= 0;
if ( (_DWORD)v6 == 1 )
{
v3 += 3;
if ( linha_cima(v4) )
{
v9 = linha_cima(v4);
trataLinhas(v9);
v10 = linha_cima(v4);
apagar_linha(v10);
}
v11 = linha_baixo(v4);
if ( v11 )
{
while ( 1 )
{
if ( (unsigned int)conta_cores(v11) != 1 )
{
v3 += conta_cores(v11) == 2;
v1 = linha_baixo(v11);
v12 = linha_baixo(v4);
trataLinhas(v12);
v13 = linha_baixo(v4);
v14 = apagar_linha(v13);
LOBYTE(v14) = v1 != 0;
v2 &= v14;
goto LABEL_20;
}
v3 += 3;
v1 = linha_baixo(v11);
trataLinhas(v11);
apagar_linha(v11);
if ( !v1 )
break;
v11 = v1;
}
v2 = 0;
}
else
{
v1 = 0LL;
v2 = 0;
}
LABEL_20:
trataLinhas(v4);
apagar_linha(v4);
}
else
{
if ( (_DWORD)v6 == 2 )
{
++v3;
v1 = linha_baixo(v4);
trataLinhas(v4);
v6 = apagar_linha(v4);
LABEL_6:
LOBYTE(v6) = v1 != 0;
v2 &= v6;
goto LABEL_7;
}
if ( (_DWORD)v6 )
goto LABEL_6;
v8 = linha_baixo(v4);
v1 = v8;
LOBYTE(v8) = v8 != 0;
v2 &= v8;
}
LABEL_7:
if ( !(_BYTE)v2 )
return v3;
v4 = v1;
}
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1)
{
__int64 v1; // rbx
int v2; // er14
unsigned int v3; // er12
__int64 v4; // r13
int i; // er15
__int64 v6; // rax
__int64 v8; // rax
__int64 v9; // rax
__int64 v10; // rax
__int64 v11; // rbp
__int64 v12; // rax
__int64 v13; // rax
__int64 v14; // rax

v3 = 0;
if ( a1 )
{
v4 = a1;
for ( i = 0; ; ++i )
{
LODWORD(v6) = func0(v4);
LOBYTE(v2) = i <= 0;
if ( (_DWORD)v6 == 1 )
{
v3 += 3;
if ( linha_cima(v4) )
{
v9 = linha_cima(v4);
trataLinhas(v9);
v10 = linha_cima(v4);
apagar_linha(v10);
}
v11 = linha_baixo(v4);
if ( v11 )
{
while ( 1 )
{
if ( (unsigned int)func0(v11) != 1 )
{
v3 += func0(v11) == 2;
v1 = linha_baixo(v11);
v12 = linha_baixo(v4);
trataLinhas(v12);
v13 = linha_baixo(v4);
v14 = apagar_linha(v13);
LOBYTE(v14) = v1 != 0;
v2 &= v14;
goto LABEL_20;
}
v3 += 3;
v1 = linha_baixo(v11);
trataLinhas(v11);
apagar_linha(v11);
if ( !v1 )
break;
v11 = v1;
}
v2 = 0;
}
else
{
v1 = 0LL;
v2 = 0;
}
LABEL_20:
trataLinhas(v4);
apagar_linha(v4);
}
else
{
if ( (_DWORD)v6 == 2 )
{
++v3;
v1 = linha_baixo(v4);
trataLinhas(v4);
v6 = apagar_linha(v4);
LABEL_6:
LOBYTE(v6) = v1 != 0;
v2 &= v6;
goto LABEL_7;
}
if ( (_DWORD)v6 )
goto LABEL_6;
v8 = linha_baixo(v4);
v1 = v8;
LOBYTE(v8) = v8 != 0;
v2 &= v8;
}
LABEL_7:
if ( !(_BYTE)v2 )
return v3;
v4 = v1;
}
}
return v3;
}

original_code:
int pontua(ptr_no ponteiro)
{
 int cores, i, pontos = 0;
 ptr_no baixo,aux;
 i = 0;
 while(ponteiro != ((void *)0) && i < 2)
 {
  cores = conta_cores(ponteiro);
  switch(cores)
  {
   case 0: baixo = linha_baixo(ponteiro); break;
   case 1 :
    pontos += 3;
    if(linha_cima(ponteiro) != ((void *)0)){
     trataLinhas(linha_cima(ponteiro));
     apagar_linha(linha_cima(ponteiro));
    }
    baixo = linha_baixo(ponteiro);
    while(baixo != ((void *)0) && conta_cores(baixo) == 1)
    {
     pontos += 3;
     aux = baixo;
     baixo = linha_baixo(baixo);
     trataLinhas(aux);
     apagar_linha(aux);
    }
    if(baixo != ((void *)0))
     {
      if(conta_cores(baixo) == 2)
       pontos++;
      baixo = linha_baixo(baixo);
      trataLinhas(linha_baixo(ponteiro));
      apagar_linha(linha_baixo(ponteiro));
     }
    trataLinhas(ponteiro);
    apagar_linha(ponteiro);
    break;
   case 2 :
    pontos++;
    baixo = linha_baixo(ponteiro);
    trataLinhas(ponteiro);
    apagar_linha(ponteiro);
    break;
   }
  ponteiro = baixo;
  i++;
 }
 return pontos;
}

canonical_original_code:
int pontua(struct no_linha *ponteiro)
{
 int cores; int i; int pontos = 0;
 struct no_linha *baixo; struct no_linha *aux;
 i = 0;
 while(ponteiro != ((void *)0) && i < 2)
 {
  cores = conta_cores(ponteiro);
  switch(cores)
  {
   case 0: baixo = linha_baixo(ponteiro); break;
   case 1 :
    pontos += 3;
    if(linha_cima(ponteiro) != ((void *)0)){
     trataLinhas(linha_cima(ponteiro));
     apagar_linha(linha_cima(ponteiro));
    }
    baixo = linha_baixo(ponteiro);
    while(baixo != ((void *)0) && conta_cores(baixo) == 1)
    {
     pontos += 3;
     aux = baixo;
     baixo = linha_baixo(baixo);
     trataLinhas(aux);
     apagar_linha(aux);
    }
    if(baixo != ((void *)0))
     {
      if(conta_cores(baixo) == 2)
       pontos++;
      baixo = linha_baixo(baixo);
      trataLinhas(linha_baixo(ponteiro));
      apagar_linha(linha_baixo(ponteiro));
     }
    trataLinhas(ponteiro);
    apagar_linha(ponteiro);
    break;
   case 2 :
    pontos++;
    baixo = linha_baixo(ponteiro);
    trataLinhas(ponteiro);
    apagar_linha(ponteiro);
    break;
   }
  ponteiro = baixo;
  i++;
 }
 return pontos;
}

variable_types: cores int

variable_types: pontos int


repo: dnet/unixsstv

decompiled_code:
__int64 __fastcall gen_samples(int a1)
{
double v1; // xmm1_8
char *v2; // r13
double v3; // xmm4_8
double v4; // xmm1_8
int v5; // ebx
int v6; // eax
double v7; // xmm0_8
double v8; // xmm0_8
double v10; // [rsp+0h] [rbp-2050h]
float ptr; // [rsp+20h] [rbp-2030h] BYREF
int v12; // [rsp+24h] [rbp-202Ch] BYREF
double v13[1024]; // [rsp+28h] [rbp-2028h] BYREF
char v14; // [rsp+2028h] [rbp-28h] BYREF

v1 = (double)(1 << a1);
v2 = (char *)v13;
v3 = 1.0 / v1;
v4 = v1 * 0.5;
v10 = v3;
do
{
v2 += 8;
*((double *)v2 - 1) = ((double)(int)random() / 2147483647.0 - 0.5) * v10;
}
while ( &v14 != v2 );
v5 = 0;
while ( !feof(stdin) )
{
while ( 1 )
{
v6 = v5 + 1;
if ( (_WORD)v5 == 1024 )
v6 = 0;
v5 = v6;
if ( fread(&ptr, 4uLL, 1uLL, stdin) != 1 )
break;
v7 = ptr * v4 + v13[(unsigned __int16)v5];
if ( v7 > v4 - 1.0 )
v8 = v4 - 1.0;
else
v8 = fmax(-v4, v7);
v12 = (int)v8 >> (32 - a1);
fwrite(&v12, (unsigned __int8)(a1 / 8), 1uLL, _bss_start);
if ( feof(stdin) )
return 0LL;
}
}
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func7(int a1)
{
double v1; // xmm1_8
char *v2; // r13
double v3; // xmm4_8
double v4; // xmm1_8
int v5; // ebx
int v6; // eax
double v7; // xmm0_8
double v8; // xmm0_8
double v10; // [rsp+0h] [rbp-2050h]
float ptr; // [rsp+20h] [rbp-2030h] BYREF
int v12; // [rsp+24h] [rbp-202Ch] BYREF
double v13[1024]; // [rsp+28h] [rbp-2028h] BYREF
char v14; // [rsp+2028h] [rbp-28h] BYREF

v1 = (double)(1 << a1);
v2 = (char *)v13;
v3 = 1.0 / v1;
v4 = v1 * 0.5;
v10 = v3;
do
{
v2 += 8;
*((double *)v2 - 1) = ((double)(int)random() / 2147483647.0 - 0.5) * v10;
}
while ( &v14 != v2 );
v5 = 0;
while ( !feof(stdin) )
{
while ( 1 )
{
v6 = v5 + 1;
if ( (_WORD)v5 == 1024 )
v6 = 0;
v5 = v6;
if ( fread(&ptr, 4uLL, 1uLL, stdin) != 1 )
break;
v7 = ptr * v4 + v13[(unsigned __int16)v5];
if ( v7 > v4 - 1.0 )
v8 = v4 - 1.0;
else
v8 = fmax(-v4, v7);
v12 = (int)v8 >> (32 - a1);
fwrite(&v12, (unsigned __int8)(a1 / 8), 1uLL, _bss_start);
if ( feof(stdin) )
return 0LL;
}
}
return 0LL;
}

original_code:
int gen_samples(const int bits_per_sample) {
 const double max_value = 1 << bits_per_sample;
 const double alias = 1.0 / max_value;
 const double amp = max_value / 2.0;
 double lowest = -amp;
 double highest = amp - 1.0;
 double alias_cache[1024];
 float input;
 double calc;
 int32_t output;
 uint16_t alias_index;
 uint8_t outbytes, outshift;
 outshift = 32 - bits_per_sample;
 outbytes = bits_per_sample / 8;
 for (alias_index = 0; alias_index < 1024; alias_index++) {
  double rnd = ((double)random()) / (double)2147483647;
  alias_cache[alias_index] = alias * (rnd - 0.5);
 }
 alias_index = 0;
 while (!feof(stdin)) {
  if (alias_index++ == 1024) alias_index = 0;
  if (fread(&input, sizeof(input), 1, stdin) == 1) {
   calc = input * amp + alias_cache[alias_index];
   if (calc > highest) calc = highest;
   else if (calc < lowest) calc = lowest;
   output = calc;
   output >>= outshift;
   fwrite(&output, outbytes, 1, stdout);
  }
 }
 return 0;
}

canonical_original_code:
int gen_samples(int bits_per_sample) {
 double max_value = 1 << bits_per_sample;
 double alias = 1.0 / max_value;
 double amp = max_value / 2.0;
 double lowest = -amp;
 double highest = amp - 1.0;
 double alias_cache[1024];
 float input;
 double calc;
 int output;
 unsigned short alias_index;
 unsigned char outbytes; unsigned char outshift;
 outshift = 32 - bits_per_sample;
 outbytes = bits_per_sample / 8;
 for (alias_index = 0; alias_index < 1024; alias_index++) {
  double rnd = ((double)random()) / (double)2147483647;
  alias_cache[alias_index] = alias * (rnd - 0.5);
 }
 alias_index = 0;
 while (!feof(stdin)) {
  if (alias_index++ == 1024) alias_index = 0;
  if (fread(&input, sizeof(input), 1, stdin) == 1) {
   calc = input * amp + alias_cache[alias_index];
   if (calc > highest) calc = highest;
   else if (calc < lowest) calc = lowest;
   output = calc;
   output >>= outshift;
   fwrite(&output, outbytes, 1, stdout);
  }
 }
 return 0;
}

variable_types: alias double

variable_types: amp double

variable_types: lowest double

variable_types: highest double

variable_types: input float

variable_types: calc double

variable_types: output int

variable_types:
outbytes
unsigned char

variable_types:
outshift
unsigned char

variable_types: rnd double


main

decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
int v4; // eax

if ( argc > 1 )
{
v3 = atoi(argv[1]);
v4 = gen_samples(v3);
exit(v4);
}
fprintf(stderr, "Usage: %s <bits per sample>\n", *argv);
exit(1);
}

canonical_decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
int v4; // eax

if ( argc > 1 )
{
v3 = atoi(argv[1]);
v4 = func7(v3);
exit(v4);
}
fprintf(stderr, "Usage: %s <bits per sample>\n", *argv);
exit(1);
}

original_code:
int main(int argc, char **argv) {
 if (argc < 2) {
  fprintf(stderr, "Usage: %s <bits per sample>\n", argv[0]);
  exit(1);
 }
 int bits_per_sample = atoi(argv[1]);
 exit(gen_samples(bits_per_sample));
}

variable_types: argc int

variable_types:
argv
char **


decompiled_code:
__int64 __fastcall gen_values(int a1)
{
int v1; // ebx
int v3; // ebp
double v4; // r14
double v5; // xmm0_8
double v6; // [rsp+0h] [rbp-48h]
double v7; // [rsp+0h] [rbp-48h]
double v8; // [rsp+8h] [rbp-40h]
double v9; // [rsp+10h] [rbp-38h]
float v10; // [rsp+24h] [rbp-24h] BYREF
float ptr; // [rsp+28h] [rbp-20h] BYREF
float v12; // [rsp+2Ch] [rbp-1Ch]

v6 = 0.0;
v9 = (double)a1 / 1000.0;
v8 = 0.0;
while ( 1 )
{
v1 = feof(stdin);
if ( v1 )
break;
if ( fread(&ptr, 8uLL, 1uLL, stdin) == 1 )
{
v3 = (int)(v12 * v9 + v6);
v4 = v12 * v9 + v6;
v7 = ptr * (6.283185307179586 / (double)a1);
if ( v3 > 0 )
{
do
{
v5 = (double)v1++ * v7;
*(float *)&v5 = v5 + v8;
v10 = sinf(*(float *)&v5);
fwrite(&v10, 4uLL, 1uLL, _bss_start);
}
while ( v3 != v1 );
v7 = (double)(v3 + 1) * v7;
}
v8 = v8 + v7;
v6 = v4 - (double)v3;
}
}
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func7(int a1)
{
int v1; // ebx
int v3; // ebp
double v4; // r14
double v5; // xmm0_8
double v6; // [rsp+0h] [rbp-48h]
double v7; // [rsp+0h] [rbp-48h]
double v8; // [rsp+8h] [rbp-40h]
double v9; // [rsp+10h] [rbp-38h]
float v10; // [rsp+24h] [rbp-24h] BYREF
float ptr; // [rsp+28h] [rbp-20h] BYREF
float v12; // [rsp+2Ch] [rbp-1Ch]

v6 = 0.0;
v9 = (double)a1 / 1000.0;
v8 = 0.0;
while ( 1 )
{
v1 = feof(stdin);
if ( v1 )
break;
if ( fread(&ptr, 8uLL, 1uLL, stdin) == 1 )
{
v3 = (int)(v12 * v9 + v6);
v4 = v12 * v9 + v6;
v7 = ptr * (6.283185307179586 / (double)a1);
if ( v3 > 0 )
{
do
{
v5 = (double)v1++ * v7;
*(float *)&v5 = v5 + v8;
v10 = sinf(*(float *)&v5);
fwrite(&v10, 4uLL, 1uLL, _bss_start);
}
while ( v3 != v1 );
v7 = (double)(v3 + 1) * v7;
}
v8 = v8 + v7;
v6 = v4 - (double)v3;
}
}
return 0LL;
}

original_code:
int gen_values(const int samples_per_second) {
 const double spms = ((double)samples_per_second) / 1000.0;
 double offset = 0.0;
 const double factor = 2.0 * 3.14159265358979323846 / ((double)samples_per_second);
 double freq_factor;
 double samples = 0.0;
 freq_tuple_t input;
 float output;
 int sample, tx;
 while (!feof(stdin)) {
  if (fread(&input, sizeof(freq_tuple_t), 1, stdin) == 1) {
   samples += spms * input.msec;
   tx = (int)samples;
   freq_factor = input.freq * factor;
   for (sample = 0; sample < tx; sample++) {
    output = sinf(sample * freq_factor + offset);
    fwrite(&output, sizeof(output), 1, stdout);
   }
   offset += (sample + 1) * freq_factor;
   samples -= tx;
  }
 }
 return 0;
}

canonical_original_code:
int gen_values(int samples_per_second) {
 double spms = ((double)samples_per_second) / 1000.0;
 double offset = 0.0;
 double factor = 2.0 * 3.14159265358979323846 / ((double)samples_per_second);
 double freq_factor;
 double samples = 0.0;
 struct freq_tuple input;
 float output;
 int sample; int tx;
 while (!feof(stdin)) {
  if (fread(&input, sizeof(freq_tuple_t), 1, stdin) == 1) {
   samples += spms * input.msec;
   tx = (int)samples;
   freq_factor = input.freq * factor;
   for (sample = 0; sample < tx; sample++) {
    output = sinf(sample * freq_factor + offset);
    fwrite(&output, sizeof(output), 1, stdout);
   }
   offset += (sample + 1) * freq_factor;
   samples -= tx;
  }
 }
 return 0;
}

variable_types: spms double

variable_types: offset double

variable_types: factor double

variable_types: samples double

variable_types: struct freq_tuple { float freq; float msec; }

variable_types: output float

variable_types: sample int

variable_types: tx int


decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
int v4; // eax

if ( argc > 1 )
{
v3 = atoi(argv[1]);
v4 = gen_values(v3);
exit(v4);
}
fprintf(stderr, "Usage: %s <samples per second>\n", *argv);
exit(1);
}

canonical_decompiled_code:
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
int v4; // eax

if ( argc > 1 )
{
v3 = atoi(argv[1]);
v4 = func7(v3);
exit(v4);
}
fprintf(stderr, "Usage: %s <samples per second>\n", *argv);
exit(1);
}

original_code:
int main(int argc, char **argv) {
 if (argc < 2) {
  fprintf(stderr, "Usage: %s <samples per second>\n", argv[0]);
  exit(1);
 }
 int samples_per_second = atoi(argv[1]);
 exit(gen_values(samples_per_second));
}


push

original_code:
void push(CommandList * cmdList, Command * cmd) {
 if (cmdList->size == 0) {
  cmdList->head = cmd;
  cmdList->foot = cmdList->head;
 } else {
  cmd->prev = cmdList->foot;
  cmd->prev->next = cmd;
  cmdList->foot = cmd;
 }
 cmdList->size++;
 cmd->next = ((void *)0);
}

canonical_original_code:
void push(struct CommandList *cmdList, struct Command *cmd) {
 if (cmdList->size == 0) {
  cmdList->head = cmd;
  cmdList->foot = cmdList->head;
 } else {
  cmd->prev = cmdList->foot;
  cmd->prev->next = cmd;
  cmdList->foot = cmd;
 }
 cmdList->size++;
 cmd->next = ((void *)0);
}

variable_types: struct CommandList { union pthread_mutex_t { struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; short __spins; short __elision; struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __list; } __data; char __size[40]; long __align; } lock; int size; struct Command { int id; int numArgs; struct timeval { long tv_sec; long tv_usec; } time; struct Command *next; struct Command *prev; int *args; } *head; struct Command *foot; } *

variable_types:
cmd
struct Command *

user_defined_types: struct CommandList { union pthread_mutex_t lock; int size; struct Command *head; struct Command *foot; }

user_defined_types: union pthread_mutex_t { struct __pthread_mutex_s __data; char __size[40]; long __align; }

user_defined_types: struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; short __spins; short __elision; struct __pthread_internal_list __list; }

user_defined_types: struct Command { int id; int numArgs; struct timeval time; struct Command *next; struct Command *prev; int *args; }


pop

original_code:
Command * pop(CommandList * cmdList) {
 if (cmdList->size == 0) {
  return ((void *)0);
 }
 Command * cmd = cmdList->head;
 cmdList->size--;
 if (cmdList->size == 0) {
  cmdList->head = ((void *)0);
  cmdList->foot = ((void *)0);
 } else {
  cmdList->head = cmdList->head->next;
  cmdList->head->prev = ((void *)0);
 }
 return cmd;
}

canonical_original_code:
struct Command *pop(struct CommandList *cmdList) {
 if (cmdList->size == 0) {
  return ((void *)0);
 }
 struct Command *cmd = cmdList->head;
 cmdList->size--;
 if (cmdList->size == 0) {
  cmdList->head = ((void *)0);
  cmdList->foot = ((void *)0);
 } else {
  cmdList->head = cmdList->head->next;
  cmdList->head->prev = ((void *)0);
 }
 return cmd;
}

variable_types: struct CommandList { union pthread_mutex_t { struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; short __spins; short __elision; struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __list; } __data; char __size[40]; long __align; } lock; int size; struct Command *head; struct Command *foot; } *

variable_types: struct Command { int id; int numArgs; struct timeval { long tv_sec; long tv_usec; } time; struct Command *next; struct Command *prev; int *args; } *


listInit

decompiled_code:
pthread_mutex_t *listInit()
{
pthread_mutex_t *v0; // rax
pthread_mutex_t *v1; // r12

v0 = (pthread_mutex_t *)malloc(0x40uLL);
v0[1].__lock = 0;
v1 = v0;
*(&v0[1].__align + 2) = 0LL;
*(&v0[1].__align + 1) = 0LL;
pthread_mutex_init(v0, 0LL);
return v1;
}

canonical_decompiled_code:
pthread_mutex_t *func2()
{
pthread_mutex_t *v0; // rax
pthread_mutex_t *v1; // r12

v0 = (pthread_mutex_t *)malloc(0x40uLL);
v0[1].__lock = 0;
v1 = v0;
*(&v0[1].__align + 2) = 0LL;
*(&v0[1].__align + 1) = 0LL;
pthread_mutex_init(v0, 0LL);
return v1;
}

original_code:
CommandList * listInit() {
 CommandList * cmdList = (CommandList*) malloc(sizeof(CommandList));
 cmdList->size = 0;
 cmdList->head = cmdList->foot = ((void *)0);
 pthread_mutex_init(&(cmdList->lock), ((void *)0));
 return cmdList;
}

canonical_original_code:
struct CommandList *listInit() {
 struct CommandList *cmdList = (CommandList*) malloc(sizeof(CommandList));
 cmdList->size = 0;
 cmdList->head = cmdList->foot = ((void *)0);
 pthread_mutex_init(&(cmdList->lock), ((void *)0));
 return cmdList;
}

return_type: struct CommandList { union pthread_mutex_t { struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; short __spins; short __elision; struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __list; } __data; char __size[40]; long __align; } lock; int size; struct Command { int id; int numArgs; struct timeval { long tv_sec; long tv_usec; } time; struct Command *next; struct Command *prev; int *args; } *head; struct Command *foot; } *


commandInit

decompiled_code:
char *__fastcall commandInit(int a1, int a2, __int64 a3)
{
char *v4; // rax
char *v5; // r14
_DWORD *v6; // rax
_DWORD *v7; // rbp
__int64 i; // rbx

v4 = (char *)malloc(0x30uLL);
*((_QWORD *)v4 + 3) = 0LL;
v5 = v4;
*((_QWORD *)v4 + 4) = 0LL;
*(_DWORD *)v4 = a1;
gettimeofday((struct timeval *)(v4 + 8), 0LL);
*((_DWORD *)v5 + 1) = a2;
v6 = malloc(4LL * a2);
*((_QWORD *)v5 + 5) = v6;
if ( a2 > 1 )
{
v7 = v6;
for ( i = 1LL; i != a2; ++i )
v7[i] = atoi(*(const char **)(a3 + 8 * i));
}
return v5;
}

canonical_decompiled_code:
char *__fastcall func3(int a1, int a2, __int64 a3)
{
char *v4; // rax
char *v5; // r14
_DWORD *v6; // rax
_DWORD *v7; // rbp
__int64 i; // rbx

v4 = (char *)malloc(0x30uLL);
*((_QWORD *)v4 + 3) = 0LL;
v5 = v4;
*((_QWORD *)v4 + 4) = 0LL;
*(_DWORD *)v4 = a1;
gettimeofday((struct timeval *)(v4 + 8), 0LL);
*((_DWORD *)v5 + 1) = a2;
v6 = malloc(4LL * a2);
*((_QWORD *)v5 + 5) = v6;
if ( a2 > 1 )
{
v7 = v6;
for ( i = 1LL; i != a2; ++i )
v7[i] = atoi(*(const char **)(a3 + 8 * i));
}
return v5;
}

original_code:
Command * commandInit(int id, int numArgs, char ** inputArgs) {
 Command * cmd = (Command*) malloc(sizeof(Command));
 cmd->next = ((void *)0);
 cmd->prev = ((void *)0);
 cmd->id = id;
 gettimeofday(&(cmd->time), ((void *)0));
 cmd->numArgs = numArgs;
 cmd->args = (int *) malloc(sizeof(int) * numArgs);
 int j;
 for (j = 1; j < numArgs; j++) {
  cmd->args[j] = atoi(inputArgs[j]);
 }
 return cmd;
}

canonical_original_code:
struct Command *commandInit(int id, int numArgs, char **inputArgs) {
 struct Command *cmd = (Command*) malloc(sizeof(Command));
 cmd->next = ((void *)0);
 cmd->prev = ((void *)0);
 cmd->id = id;
 gettimeofday(&(cmd->time), ((void *)0));
 cmd->numArgs = numArgs;
 cmd->args = (int *) malloc(sizeof(int) * numArgs);
 int j;
 for (j = 1; j < numArgs; j++) {
  cmd->args[j] = atoi(inputArgs[j]);
 }
 return cmd;
}

variable_types: id int

variable_types: numArgs int

variable_types:
inputArgs
char **

variable_types: j int

return_type: struct Command { int id; int numArgs; struct timeval { long tv_sec; long tv_usec; } time; struct Command *next; struct Command *prev; int *args; } *


sortProcessesByArrivalTime

original_code:
void sortProcessesByArrivalTime(struct process *proc) {
 int c, d;
 struct process * swap = malloc(sizeof(struct process));
 for (c = 0; c < (20 - 1); c++) {
  for (d = 0; d < 20 - c - 1; d++) {
   if (proc[d].arrivaltime > proc[d + 1].arrivaltime) {
    memcpy(swap, &(proc[d]), sizeof(struct process));
    memcpy(&(proc[d]), &(proc[d + 1]), sizeof(struct process));
    memcpy(&(proc[d + 1]), swap, sizeof(struct process));
   }
  }
 }
 free(swap);
}

canonical_original_code:
void sortProcessesByArrivalTime(struct process *proc) {
 int c; int d;
 struct process *swap = malloc(sizeof(struct process));
 for (c = 0; c < (20 - 1); c++) {
  for (d = 0; d < 20 - c - 1; d++) {
   if (proc[d].arrivaltime > proc[d + 1].arrivaltime) {
    memcpy(swap, &(proc[d]), sizeof(struct process));
    memcpy(&(proc[d]), &(proc[d + 1]), sizeof(struct process));
    memcpy(&(proc[d + 1]), swap, sizeof(struct process));
   }
  }
 }
 free(swap);
}

variable_types: struct process { int arrivaltime; int runtime; int priority; int starttime; int endtime; int flag; int remainingtime; int number; } *

variable_types: c int

variable_types: d int