LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch6/limit_memory.c
// Function: main
int main() {
  lua_State *L = lua_newstate(alloc, NULL);
  luaL_openlibs(L);

  print_status();
  while (accept_and_run_a_line(L)) print_status();

  lua_close(L);
  print_status();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x76(%rip), %rdi       # 0x460c
xorl %esi, %esi
callq 0x49a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x8860
callq 0x465b
movq %rbx, %rdi
callq 0x1d600
testl %eax, %eax
jne 0x4694
movq %rbx, %rdi
callq 0x4c46
callq 0x465b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch6/interpreter.c
// Function: accept_and_run_a_line
int accept_and_run_a_line(lua_State *L) {

  char buff[2048];

  // Read input and exit early if there is an end of stream.
  printf("> ");
  if (!fgets(buff, sizeof(buff), stdin)) {
    printf("\n");
    return 0;
  }

  // Try to run the line, printing errors if there are any.
  int error = luaL_loadstring(L, buff);
  if (!error) error = lua_pcall(L, 0, 0, 0);
  if (error) {
    fprintf(stderr, "%s\n", lua_tostring(L, -1));
    lua_pop(L, 1);
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %r14
leaq 0x24b0(%rip), %rdi      # 0x1faca
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4170
movq 0x109a6(%rip), %rax     # 0x2dfd0
movq (%rax), %rdx
leaq -0x820(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x4230
testq %rax, %rax
je 0x1d6a9
leaq -0x820(%rbp), %rsi
movq %r14, %rdi
callq 0x137de
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0x1d671
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9ac0
testl %eax, %eax
je 0x1d6b1
movq 0x10978(%rip), %rax     # 0x2dff0
movq (%rax), %r15
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x8e72
leaq 0x1e39(%rip), %rsi      # 0x1f4c8
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4280
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x89d9
jmp 0x1d6b1
pushq $0xa
popq %rdi
callq 0x4070
movl %ebx, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/amanelis[P]uici/client.c
// Function: main
int main(int argc, char *argv[]) {
   int bytescopied;
   int communfd;
   u_port_t portnumber;
 
   if (argc != 3) {
      fprintf(stderr, "Usage: %s host port\n", argv[0]);
      return 1;
   }
   portnumber = (u_port_t)atoi(argv[2]);

   if ((communfd = u_connect(portnumber, argv[1])) == -1) {
      perror("Failed to make connection");
      return 1;
   }
   fprintf(stderr, "[%ld]:connected %s\n", (long)getpid(), argv[1]);
   bytescopied = copyfile(STDIN_FILENO, communfd);
   fprintf(stderr, "[%ld]:sent %d bytes\n", (long)getpid(), bytescopied);
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x1347
movq 0x10(%rbx), %rdi
callq 0x11a0
movq 0x8(%rbx), %rsi
movzwl %ax, %edi
callq 0x1c9e
cmpl $-0x1, %eax
jne 0x1367
leaq 0xcd9(%rip), %rdi       # 0x2019
callq 0x1180
jmp 0x1362
movq 0x2caa(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xca9(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rbx
jmp 0x13c1
movl %eax, %r14d
movq 0x2c87(%rip), %r12      # 0x3ff8
movq (%r12), %r15
callq 0x1080
movslq %eax, %rdx
movq 0x8(%rbx), %rcx
leaq 0xcab(%rip), %rsi       # 0x2033
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1100
xorl %edi, %edi
movl %r14d, %esi
callq 0x162e
movl %eax, %r14d
movq (%r12), %r15
callq 0x1080
movslq %eax, %rdx
leaq 0xc93(%rip), %rsi       # 0x2047
movq %r15, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1100
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/amanelis[P]uici/uiciname.c
// Function: addr2name
void addr2name(struct in_addr addr, char *name, int namelen) {
   struct hostent *hostptr;

   if (pthread_mutex_lock(&mutex) == -1) {
      strncpy(name, inet_ntoa(addr), namelen-1); 
      name[namelen-1] = 0;
      return;
   }
   hostptr = gethostbyaddr((char *)&addr, 4, AF_INET);
   if (hostptr == NULL)
      strncpy(name, inet_ntoa(addr), namelen-1); 
   else  
      strncpy(name, hostptr->h_name, namelen-1);
   pthread_mutex_unlock(&mutex);
   name[namelen-1] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %r15d
movl %edi, -0x1c(%rbp)
leaq 0x2703(%rip), %rdi      # 0x4120
callq 0x11e0
cmpl $-0x1, %eax
je 0x1a40
leaq -0x1c(%rbp), %rdi
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
callq 0x11b0
testq %rax, %rax
je 0x1a63
movq (%rax), %rsi
jmp 0x1a6e
movl %r15d, %edi
callq 0x1090
movslq %r14d, %r14
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1040
leaq (%rbx,%r14), %rax
decq %rax
jmp 0x1a92
movl -0x1c(%rbp), %edi
callq 0x1090
movq %rax, %rsi
leal -0x1(%r14), %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x1040
leaq 0x269c(%rip), %rdi      # 0x4120
callq 0x1130
movslq %r14d, %rax
addq %rbx, %rax
decq %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/amanelis[P]uici/uiciname.c
// Function: name2addr
int name2addr(char *name, in_addr_t *addrp) {
   struct hostent *hp;
 
   if (isdigit((int)(*name)))
      *addrp = inet_addr(name);
   else {
      if (pthread_mutex_lock(&mutex) == -1)
         return -1;
      hp = gethostbyname(name);
      if (hp == NULL) {
         pthread_mutex_unlock(&mutex);
         return -1;
      }
      memcpy((char *)addrp, hp->h_addr_list[0], hp->h_length);
      pthread_mutex_unlock(&mutex);
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x11f0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x1b06
leaq 0x2656(%rip), %rdi      # 0x4120
callq 0x11e0
pushq $-0x1
popq %r14
cmpl $-0x1, %eax
je 0x1b13
movq %r15, %rdi
callq 0x10f0
testq %rax, %rax
je 0x1b21
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movslq 0x14(%rax), %rdx
movq %rbx, %rdi
callq 0x1110
leaq 0x2621(%rip), %rdi      # 0x4120
callq 0x1130
jmp 0x1b10
movq %r15, %rdi
callq 0x10e0
movl %eax, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25f8(%rip), %rdi      # 0x4120
callq 0x1130
jmp 0x1b13
nop
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.3/thread-create3.c
// Function: char_print
void* char_print (void* parameters)
{
/* Cast the cookie pointer to the right type. */
	struct char_print_parms* p = (struct char_print_parms*) parameters;
	int i;
	for (i = 0; i < p->count; ++i)
	fputc (p->character, stderr);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2e85(%rip), %r15      # 0x3ff8
cmpl 0x4(%rbx), %r14d
jge 0x1189
movsbl (%rbx), %edi
movq (%r15), %rsi
callq 0x1030
incl %r14d
jmp 0x1173
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/fq2b.c
// Function: packInit
void packInit (void)
{
  if (isPackInitialised) return ;
  int i ;
  static int sIndex[] = {'a','c','g','t','A','C','G','T'} ;
  for (i = 0 ; i < 8 ; ++i) sPack[sIndex[i]] = i%4 ;
  for (i = '$' + 20 ; i < 256 ; ++i) qPack[i] = 1 ;
  isPackInitialised = TRUE ;
}

// Assembly:
cmpb $0x0, 0x5e1d(%rip)      # 0x7130
jne 0x1364
leaq 0x2cf4(%rip), %rax      # 0x4010
xorl %ecx, %ecx
leaq 0x5e1b(%rip), %rdx      # 0x7140
cmpq $0x8, %rcx
je 0x133f
movl %ecx, %esi
andl $0x3, %esi
movslq (%rax), %rdi
movl %esi, (%rdx,%rdi,4)
incq %rcx
addq $0x4, %rax
jmp 0x1325
pushq $0x38
popq %rax
leaq 0x61f7(%rip), %rcx      # 0x7540
cmpq $0x100, %rax            # imm = 0x100
je 0x135d
movl $0x1, (%rcx,%rax,4)
incq %rax
jmp 0x1349
movb $0x1, 0x5dcc(%rip)      # 0x7130
retq
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/fq2b.c
// Function: seqPack
void seqPack (char *s, U32 *u, int len) /* compress s into (len+)/4 U32  */
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 16)
    { *u = 0 ; for (i = 0 ; i < 16 ; ++i) *u = (*u << 2) | sPack[*s++] ;
      len -= 16 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 2) | sPack[*s++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x5dc3(%rip)      # 0x7130
jne 0x13c2
leaq 0x5dca(%rip), %rax      # 0x7140
andl $0x0, (%rsi)
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpl $0x11, %edx
jl 0x13bc
cmpl $0x10, %ecx
je 0x139d
shll $0x2, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rax,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
jmp 0x1383
addl $-0x10, %edx
addq $0x4, %rsi
addq %rcx, %rdi
jmp 0x1376
shll $0x2, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rax,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
cmpl %edx, %ecx
jl 0x13a9
popq %rax
retq
leaq 0x2c67(%rip), %rdi      # 0x4030
leaq 0x2c72(%rip), %rsi      # 0x4042
leaq 0x2c72(%rip), %rcx      # 0x4049
pushq $0x23
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/fq2b.c
// Function: qualPack
void qualPack (char *q, U32 *u, int len)
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 32)
    { *u = 0 ; for (i = 0 ; i < 32 ; ++i) *u = (*u << 1) | qPack[*q++] ;
      len -= 32 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 1) | qPack[*q++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x5d01(%rip)      # 0x7130
jne 0x1482
leaq 0x6108(%rip), %rax      # 0x7540
andl $0x0, (%rsi)
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpl $0x21, %edx
jl 0x147c
cmpl $0x20, %ecx
je 0x145e
addl %r8d, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rax,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
jmp 0x1445
addl $-0x20, %edx
addq $0x4, %rsi
addq %rcx, %rdi
jmp 0x1438
addl %r8d, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rax,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
cmpl %edx, %ecx
jl 0x146a
popq %rax
retq
leaq 0x2ba7(%rip), %rdi      # 0x4030
leaq 0x2bb2(%rip), %rsi      # 0x4042
leaq 0x2bd3(%rip), %rcx      # 0x406a
pushq $0x36
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/fq2b.c
// Function: read10xWhitelist
void read10xWhitelist (char *fileName)
{ FILE *f = fopen (fileName, "r") ;
  if (!f) die ("failed to open 10x whitelist file %s\n", fileName) ;
  char s[32] ;
  U32 u ; 
  int i,j,n = 0 ;

  if (!(table = calloc ((size_t)1<<32, 1))) die ("can't allocate barcode table") ;
  for (i = 0 ; i < 16 ; ++i)
    for (j = 0 ; j < 4 ; ++j)
      { mask[i*4 + j] = ~(3 << (2*i)) ; bits[i*4 + j] = j << (2*i) ; }
  
  while (!feof (f) && fscanf (f, "%s\n", s))
    { ++n ;
      if (strlen(s) != 16) die ("bad barcode line % in %s: %s", n, fileName, s) ;
      seqPack (s, &u, 16) ;
      for (i = 0 ; i < 16 ; ++i)
	{ U8 ui = 1 + i*4 + ((u >> (2*i)) & 0x3) ; /* code to reset i'th base to u[i] */
	  for (j = 0 ; j < 4 ; ++j) table[switchBase(u,1+i*4+j)] = ui ;
	}
    }
  fclose (f) ;
  fprintf (stderr, "read %d barcodes from file %s\n", n, fileName) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x2bd8(%rip), %rsi      # 0x408c
movq %rdi, (%rsp)
callq 0x1190
movq %rax, %r14
testq %rax, %rax
jne 0x14d7
leaq 0x2bc2(%rip), %rdi      # 0x408e
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x3060
movabsq $0x100000000, %rdi      # imm = 0x100000000
pushq $0x1
popq %rsi
callq 0x10f0
movq %rax, 0x6468(%rip)      # 0x7958
testq %rax, %rax
jne 0x1503
leaq 0x2bb8(%rip), %rdi      # 0x40b4
xorl %eax, %eax
callq 0x3060
leaq 0x6556(%rip), %rax      # 0x7a60
leaq 0x644f(%rip), %rdx      # 0x7960
xorl %esi, %esi
pushq $0x3
popq %rdi
cmpq $0x10, %rsi
je 0x1551
leal (%rsi,%rsi), %ecx
movl %edi, %r8d
shll %cl, %r8d
notl %r8d
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x1544
movl %r9d, %r10d
shll %cl, %r10d
movl %r8d, (%rdx,%r9,4)
movl %r10d, (%rax,%r9,4)
incq %r9
jmp 0x152b
incq %rsi
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x1516
leaq 0x10(%rsp), %r12
pushq $0x10
popq %rbx
leaq 0x6400(%rip), %r15      # 0x7960
leaq 0x64f9(%rip), %r13      # 0x7a60
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
jne 0x161a
movq %r14, %rdi
leaq 0x2b86(%rip), %rsi      # 0x4109
movq %r12, %rdx
xorl %eax, %eax
callq 0x1050
testl %eax, %eax
je 0x161a
incl %ebp
movq %r12, %rdi
callq 0x1090
cmpq $0x10, %rax
je 0x15bc
leaq 0x2b25(%rip), %rdi      # 0x40d1
movl %ebp, %esi
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3060
movq %r12, %rdi
leaq 0xc(%rsp), %rsi
movl %ebx, %edx
callq 0x1365
movl 0xc(%rsp), %eax
xorl %edx, %edx
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x1569
leal (%rsi,%rsi), %ecx
movl %eax, %edi
shrl %cl, %edi
andl $0x3, %edi
leal (%rdi,%rsi,4), %ecx
incb %cl
xorl %edi, %edi
cmpq $0x10, %rdi
je 0x1611
movq 0x6361(%rip), %r8       # 0x7958
leaq (%rdx,%rdi), %r9
movl (%r15,%r9), %r10d
andl %eax, %r10d
orl (%r13,%r9), %r10d
movb %cl, (%r8,%r10)
addq $0x4, %rdi
jmp 0x15ea
incq %rsi
addq $0x10, %rdx
jmp 0x15d3
movq %r14, %rdi
callq 0x1080
movq 0x59cf(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2abb(%rip), %rsi      # 0x40ee
movl %ebp, %edx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x1120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/fq2b.c
// Function: find10xBarcode
BOOL find10xBarcode (U32* u)
{
  if (!table[*u]) { ++nBad ; return FALSE ; }
  U32 v = switchBase (*u, table[*u]) ;
  if (v != *u) { ++nFixed ; ++nFixBase[15 - (table[*u]-1)/4] ; *u = v ; }
  return TRUE ;
}

// Assembly:
movq 0x6302(%rip), %rax      # 0x7958
movl (%rdi), %esi
movzbl (%rax,%rsi), %ecx
testl %ecx, %ecx
je 0x169c
decl %ecx
leaq 0x62f7(%rip), %rax      # 0x7960
movl (%rax,%rcx,4), %edx
andl %esi, %edx
leaq 0x63eb(%rip), %rax      # 0x7a60
orl (%rax,%rcx,4), %edx
movb $0x1, %al
cmpl %esi, %edx
je 0x169b
incl 0x64e0(%rip)            # 0x7b64
shrl $0x2, %ecx
pushq $0xf
popq %rsi
subl %ecx, %esi
movslq %esi, %rcx
leaq 0x64da(%rip), %rsi      # 0x7b70
incl (%rsi,%rcx,4)
movl %edx, (%rdi)
retq
incl 0x64be(%rip)            # 0x7b60
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_create_payload_options
uint8_t ff_client_create_payload_options(struct ff_request *request, struct ff_client_config *config)
{
    uint64_t now = (uint64_t)time(NULL);
    now = htonll(now);

    struct ff_request_payload_node *payload = NULL;
    struct ff_request_option_node **options = malloc(sizeof(struct ff_request_option_node *) * FF_REQUEST_MAX_OPTIONS);
    uint8_t option_i = 0;
    uint16_t length = 0;

    if (config->https)
    {
        options[option_i] = ff_request_option_node_alloc();
        options[option_i]->type = FF_REQUEST_OPTION_TYPE_HTTPS;
        options[option_i]->length = 1;
        options[option_i]->value = malloc(1);
        options[option_i]->value[0] = 1;
        length += sizeof(struct __raw_ff_request_option_header) + options[option_i]->length;
        option_i++;
    }

    options[option_i] = ff_request_option_node_alloc();
    options[option_i]->type = FF_REQUEST_OPTION_TYPE_TIMESTAMP;
    options[option_i]->length = 8;
    options[option_i]->value = malloc(8);
    memcpy(options[option_i]->value, &now, 8);
    length += sizeof(struct __raw_ff_request_option_header) + options[option_i]->length;
    option_i++;

    options[option_i] = ff_request_option_node_alloc();
    options[option_i]->type = FF_REQUEST_OPTION_TYPE_EOL;
    length += sizeof(struct __raw_ff_request_option_header) + options[option_i]->length;
    option_i++;

    payload = ff_request_payload_node_alloc();
    payload->value = malloc(length);
    payload->length = length;

    ff_client_write_options(payload->value, options, option_i);

    ff_client_request_add_payload(request, payload);

    for (uint8_t i = 0; i < option_i; i++)
    {
        ff_request_option_node_free(options[i]);
    }

    FREE(options);

    return option_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
xorl %edi, %edi
callq 0x2170
movq %rax, %r12
bswapq %r12
movl $0xa0, %edi
callq 0x2220
movq %rax, %rbx
cmpb $0x1, 0x10(%r15)
jne 0x25c3
callq 0x38cc
movq %rax, %r15
movq %rax, (%rbx)
movl $0x4, (%rax)
movw $0x1, 0x4(%rax)
pushq $0x1
popq %rdi
callq 0x2220
movq %rax, 0x8(%r15)
movb $0x1, (%rax)
movw $0x12, %r14w
movb $0x1, %r15b
jmp 0x25cb
movw $0xe, %r14w
xorl %r15d, %r15d
callq 0x38cc
movq %rax, %r13
movzbl %r15b, %r15d
movq %rax, (%rbx,%r15,8)
movl $0x8, (%rax)
movw $0x8, 0x4(%rax)
pushq $0x8
popq %rdi
callq 0x2220
movq %rax, 0x8(%r13)
movq %r12, (%rax)
callq 0x38cc
movq %rax, 0x8(%rbx,%r15,8)
andl $0x0, (%rax)
addw 0x4(%rax), %r14w
orb $0x2, %r15b
callq 0x394c
movq %rax, %r13
movzwl %r14w, %r12d
movq %r12, %rdi
callq 0x2220
movq %rax, 0x8(%r13)
movw %r12w, 0x2(%r13)
movzbl %r15b, %r12d
movq %rax, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x2b09
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2b7e
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x265d
movq (%rbx,%r14,8), %rdi
callq 0x3926
incq %r14
jmp 0x264a
movq %rbx, %rdi
callq 0x21d0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_read_payload_from_file
void ff_client_read_payload_from_file(struct ff_request *request, FILE *fd)
{
    uint8_t buffer[1024];
    uint16_t payload_length = 0;
    uint16_t chunk_length = 0;

    struct ff_request_payload_node *payload = ff_request_payload_node_alloc();
    payload->value = malloc(sizeof(buffer));

    while ((chunk_length = fread(buffer, 1, sizeof(buffer), fd)) != 0)
    {
        payload_length += chunk_length;
        payload->value = realloc(payload->value, payload_length);

        if (payload->value == NULL)
        {
            ff_log(FF_FATAL, "Could not reallocate payload buffer");
            exit(1);
        }

        memcpy(payload->value, buffer, chunk_length);
    }

    ff_log(FF_DEBUG, "Read %u bytes from STDIN", payload_length);

    payload->length = payload_length;
    ff_client_request_add_payload(request, payload);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0x394c
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x2220
movq %rax, 0x8(%r14)
xorl %r13d, %r13d
leaq -0x430(%rbp), %r12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
pushq $0x1
popq %rsi
movq %r15, %rcx
callq 0x2260
movq %rax, %rbx
andq $0xffff, %rbx           # imm = 0xFFFF
je 0x26fa
addl %eax, %r13d
movq 0x8(%r14), %rdi
movzwl %r13w, %esi
callq 0x22a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2731
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2150
jmp 0x26b2
movzwl %r13w, %edx
leaq 0x29a5(%rip), %rsi      # 0x50aa
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x37ac
movw %r13w, 0x2(%r14)
movq -0x30(%rbp), %rdi
movq %r14, %rsi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b7e
leaq 0x294e(%rip), %rsi      # 0x5086
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x37ac
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_write_options
uint32_t ff_client_write_options(void *buffer, struct ff_request_option_node **options, uint8_t amount)
{
    uint32_t buff_i = 0;

    for (uint8_t i = 0; i < amount; i++)
    {
        struct __raw_ff_request_option_header *option_header = (struct __raw_ff_request_option_header *)(buffer + buff_i);
        option_header->type = options[i]->type;
        option_header->length = htons(options[i]->length);
        buff_i += sizeof(struct __raw_ff_request_option_header);
        memcpy(buffer + buff_i, options[i]->value, options[i]->length);
        buff_i += options[i]->length;
    }

    return buff_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r13, %r12
je 0x2b6c
movl %r15d, %eax
movq (%rbx,%r13,8), %rcx
movb (%rcx), %dl
movb %dl, (%r14,%rax)
movzwl 0x4(%rcx), %edx
movl %edx, %esi
rolw $0x8, %si
movw %si, 0x1(%r14,%rax)
leal 0x3(%r15), %edi
addq %r14, %rdi
movq 0x8(%rcx), %rsi
callq 0x2150
movq (%rbx,%r13,8), %rax
movzwl 0x4(%rax), %eax
addl %eax, %r15d
addl $0x3, %r15d
incq %r13
jmp 0x2b26
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_calculate_request_size
uint32_t ff_client_calculate_request_size(struct ff_request *request)
{
    uint32_t length = 0;

    length += sizeof(struct __raw_ff_request_header);

    for (int i = 0; i < request->options_length; i++)
    {
        length += sizeof(struct __raw_ff_request_option_header);
        length += request->options[i]->length;
    }

    length += request->payload_length;

    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x28(%rdi), %ecx
movl $0x14, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2bd3
movq 0x30(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movzwl 0x4(%rsi), %esi
addl %esi, %eax
addl $0x3, %eax
incq %rdx
jmp 0x2bb8
addl 0x40(%rdi), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_generate_request_id
uint64_t ff_client_generate_request_id()
{
    uint8_t buffer[8];

    if (!RAND_bytes(buffer, sizeof(buffer)))
    {
        ff_log(FF_FATAL, "Failed to generate request ID");
        exit(EXIT_FAILURE);
    }

    return (uint64_t)(
        (uint64_t)buffer[0] | ((uint64_t)buffer[1] << 8) | ((uint64_t)buffer[2] << 16) | ((uint64_t)buffer[3] << 24) | ((uint64_t)buffer[4] << 32) | ((uint64_t)buffer[5] << 40) | ((uint64_t)buffer[6] << 48) | ((uint64_t)buffer[7] << 56));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
pushq $0x8
popq %rsi
callq 0x2240
testl %eax, %eax
je 0x2bfa
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x24e5(%rip), %rsi      # 0x50e6
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x37ac
pushq $0x1
popq %rdi
callq 0x21e0
nop
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/client/c/main.c
// Function: main
int main(int argc, char **argv)
{
    enum ff_client_action action = ff_client_parse_arguments(&ff_global_config, argc, argv);
    int ret = EXIT_SUCCESS;

    switch (action)
    {
    case FF_CLIENT_ACTION_MAKE_REQUEST:
        ret = ff_client_make_request(&ff_global_config, stdin);
        break;

    case FF_CLIENT_ACTION_PRINT_VERSION:
        ff_print_version(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_PRINT_USAGE:
        ff_client_print_usage(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_INVALID_ARGS:
        ff_client_print_usage(stderr);
        ret = EXIT_FAILURE;
        break;
    }

    ff_log(FF_INFO, "Exiting...");
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movl %edi, %esi
leaq 0x4e22(%rip), %rdi      # 0x81a8
callq 0x2c14
xorl %ebx, %ebx
decl %eax
cmpl $0x3, %eax
ja 0x33f2
leaq 0x22cd(%rip), %rcx      # 0x5668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x4c2d(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x4df3(%rip), %rdi      # 0x81a8
callq 0x240c
movl %eax, %ebx
jmp 0x33f2
movq 0x4bfb(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x2e91
jmp 0x33f2
movq 0x4c0a(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
callq 0x2e91
pushq $0x1
popq %rbx
jmp 0x33f2
movq 0x4bd6(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x3766
leaq 0x227f(%rip), %rsi      # 0x5678
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x37ac
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/src/hide.c
// Function: progress_current_update
static void progress_current_update(uint64_t i, uint64_t j)
{
	if (i < j && i > 0)
	{
		ui.current->offset = i;
		ui.current->size = j;
	}
	return;
}

// Assembly:
cmpq %rsi, %rdi
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2a2d
movq 0x57ea(%rip), %rax      # 0x8210
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/error.c
// Function: on_error
extern void on_error(int s)
{
	if (fatal_error_in_progress)
		raise(s);
	fatal_error_in_progress = 1;

	write(STDERR_FILENO, ERROR_CURSOR, ERROR_CURSOR_LEN);
	write(STDERR_FILENO, ERROR_DIVIDE, ERROR_DIVIDE_LEN);

	char m[32] = { 0x0 };
	strcat(m, "Received fatal signal [");
	strcat(m, int_to_ascii(s));
	strcat(m, "]");
	psignal(s, m);

#ifdef BUILD_GUI
	error_gui_alert(m);
#endif

#if !defined _WIN32 && !defined __CYGWIN__ && !defined __FreeBSD__
	void *bt[BACKTRACE_BUFFER_LIMIT];
	int c = backtrace(bt, BACKTRACE_BUFFER_LIMIT);
	char **sym = backtrace_symbols(bt, c);
	if (sym)
		for (int i = 0; i < c; i++)
		{
			write(STDERR_FILENO, sym[i], strlen(sym[i]));
			write(STDERR_FILENO, "\n", 1);
		}
#endif

	write(STDERR_FILENO, ERROR_DIVIDE, ERROR_DIVIDE_LEN);

#ifndef __APPLE__
	signal(s, SIG_DFL);
	raise(s);
	__builtin_unreachable();
#else
	exit(errno);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movl %edi, %ebx
cmpl $0x0, 0x518a(%rip)      # 0x8220
je 0x309f
movl %ebx, %edi
callq 0x2040
movl $0x1, 0x5177(%rip)      # 0x8220
leaq 0x2190(%rip), %rsi      # 0x5240
pushq $0x2
popq %rbp
pushq $0x7
popq %rdx
movl %ebp, %edi
callq 0x20e0
leaq 0x2184(%rip), %rsi      # 0x5248
pushq $0x2e
popq %rdx
movl %ebp, %edi
callq 0x20e0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x2100
movabsq $0x5b206c616e6769, %rcx # imm = 0x5B206C616E6769
movq %rcx, 0x20(%rsp,%rax)
movups 0x217f(%rip), %xmm0     # 0x5277
movups %xmm0, 0x10(%rsp,%rax)
testl %ebx, %ebx
movl %ebx, 0xc(%rsp)
js 0x3129
leaq 0x5138(%rip), %rsi      # 0x8244
pushq $0xa
popq %rdi
movl %ebx, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %edi
orb $0x30, %dl
movb %dl, -0x1(%rsi)
decq %rsi
cmpl $0xa, %ecx
movl %eax, %ecx
jae 0x3111
jmp 0x3155
leaq 0x5113(%rip), %rsi      # 0x8243
pushq $0xa
popq %rdi
movl %ebx, %eax
cltd
idivl %edi
movb $0x30, %r8b
subb %dl, %r8b
movb %r8b, (%rsi)
addl $0x9, %ebx
decq %rsi
cmpl $0x12, %ebx
movl %eax, %ebx
ja 0x3133
movb $0x2d, (%rsi)
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2320
movq %r14, %rdi
callq 0x2100
movw $0x5d, 0x10(%rsp,%rax)
movl %ebx, %edi
movq %r14, %rsi
callq 0x2390
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2110
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x20d0
testq %rax, %rax
je 0x31e7
movq %rax, %r15
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
pushq $0x2
popq %rbp
pushq $0x1
popq %r13
cmpq %r12, %r14
je 0x31e7
movq (%r15,%r12,8), %rbx
movq %rbx, %rdi
callq 0x2100
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20e0
movl %ebp, %edi
leaq 0x209b(%rip), %rsi      # 0x5275
movq %r13, %rdx
callq 0x20e0
incq %r12
jmp 0x31b3
leaq 0x205a(%rip), %rsi      # 0x5248
pushq $0x2
popq %rdi
pushq $0x2e
popq %rdx
callq 0x20e0
movl 0xc(%rsp), %ebx
movl %ebx, %edi
xorl %esi, %esi
callq 0x21f0
movl %ebx, %edi
callq 0x2040
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/error.c
// Function: error_init
extern void error_init(void)
{
	if (error_inited)
		return;

	signal(SIGILL,  on_error);
	signal(SIGSEGV, on_error);
	signal(SIGBUS,  on_error);
	signal(SIGABRT, on_error);
	signal(SIGSYS,  on_error);
	//signal(SIGPROF, on_error);

	error_inited = 1;

	return;
}

// Assembly:
cmpl $0x0, 0x5010(%rip)      # 0x8224
je 0x3217
retq
pushq %rbx
leaq -0x1a3(%rip), %rbx      # 0x307c
pushq $0x4
popq %rdi
movq %rbx, %rsi
callq 0x21f0
pushq $0xb
popq %rdi
movq %rbx, %rsi
callq 0x21f0
pushq $0x7
popq %rdi
movq %rbx, %rsi
callq 0x21f0
pushq $0x6
popq %rdi
movq %rbx, %rsi
callq 0x21f0
pushq $0x1f
popq %rdi
movq %rbx, %rsi
callq 0x21f0
movl $0x1, 0x4fc4(%rip)      # 0x8224
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/error.c
// Function: die
extern void die(const char * const restrict s, ...)
{
	int ex = errno;
	char *d = NULL;
	va_list ap;
	va_start(ap, s);
#ifndef _WIN32
	vasprintf(&d, s, ap);
#else
	uint8_t l = 0xFF;
	if ((d = calloc(l, sizeof l)))
		vsnprintf(d, l - 1, s, ap);
#endif
	fprintf(stderr, "%s", d);
	va_end(ap);
	fprintf(stderr, "\n");
#ifdef BUILD_GUI
	error_gui_alert(d);
#endif
	free(d);
	if (ex)
	{
		char * const restrict e = strdup(strerror(ex));
		for (uint32_t i = 0; e && i < strlen(e); i++)
			e[i] = tolower((unsigned char)e[i]);
		fprintf(stderr, "%s\n", e);
		free(e);
#if !defined _WIN32 && !defined __CYGWIN__ && !defined __FreeBSD__
		void *bt[BACKTRACE_BUFFER_LIMIT];
		int c = backtrace(bt, BACKTRACE_BUFFER_LIMIT);
		char **sym = backtrace_symbols(bt, c);
		if (sym)
		{
			for (int i = 0; i < c; i++)
				fprintf(stderr, "%s\n", sym[i]);
			free(sym);
		}
#endif
	}
	exit(ex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp           # imm = 0x20E8
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x32d2
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
callq 0x2060
movl (%rax), %ebx
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %rdx
movq %r12, 0x10(%rdx)
leaq 0x2120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0x4ce2(%rip), %r13      # 0x7ff8
movq (%r13), %rsi
movq (%r15), %rdi
callq 0x2170
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0x21b0
movq (%r15), %rdi
callq 0x2050
testl %ebx, %ebx
je 0x3403
movl %ebx, %edi
callq 0x2380
movq %rax, %rdi
callq 0x2370
movq %rax, %r14
testq %rax, %rax
jne 0x33cb
movq (%r13), %rdi
leaq 0x1fe1(%rip), %rsi      # 0x5341
xorl %r12d, %r12d
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
movq %r14, %rdi
callq 0x2050
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2110
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x20d0
testq %rax, %rax
je 0x3403
movq %rax, %r15
testl %r14d, %r14d
cmovlel %r12d, %r14d
leaq 0x1f94(%rip), %r12      # 0x5341
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x33fb
movq (%r13), %rdi
movq (%r15,%rbp,8), %rdx
movq %r12, %rsi
xorl %eax, %eax
callq 0x2210
incq %rbp
jmp 0x33af
xorl %eax, %eax
movl %eax, %r15d
movq %r14, %rdi
callq 0x2100
cmpq %r15, %rax
jbe 0x3355
callq 0x23c0
movq (%rax), %rax
movzbl (%r14,%r15), %ecx
movb (%rax,%rcx,4), %al
movb %al, (%r14,%r15)
leal 0x1(%r15), %eax
jmp 0x33cd
movq %r15, %rdi
callq 0x2050
movl %ebx, %edi
callq 0x2340
nop
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_printf
extern int cli_printf(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(stdout, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3457
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4dd1(%rip)      # 0x8248
jne 0x347e
callq 0x34e2
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x4b18(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x352c
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_print
static int cli_print(FILE *stream, const char *text)
{
	size_t l = strlen(text);
	char *copy = m_calloc(1, l + 1);
#ifndef _WIN32
	bool strip = !((stream == stdout && isatty(STDOUT_FILENO)) || (stream == stderr && isatty(STDERR_FILENO)));
#else
	#ifdef __DEBUG__
	bool strip = cli_inited != 1;
	#else
	bool strip = false;
	#endif
#endif
	if (strip)
	{
		char *ptr = (char *)text;
		for (size_t i = 0, j = 0; i < l; i++)
		{
			char *e = strstr(ptr, "\x1b[");
			if (!e)
				break;
			memcpy(copy + j, ptr, e - ptr);
			j += e - ptr;
			ptr = strchr(e, 'm') + 1;
		}
		strcat(copy, ptr);
	}
	else
		strcpy(copy, text);
	int x = fprintf(stream, "%s", copy);
	//fprintf(stream, "\n");
	free(copy);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r12
leaq 0x1(%rax), %r8
leaq 0x1df2(%rip), %rdi      # 0x5345
leaq 0x1ead(%rip), %rdx      # 0x5407
pushq $0x1
popq %rcx
movl $0x16a, %esi            # imm = 0x16A
callq 0x418b
movq %rax, %r14
movq 0x4a67(%rip), %rax      # 0x7fd8
cmpq %rbx, (%rax)
je 0x35e2
movq 0x4a7b(%rip), %rax      # 0x7ff8
cmpq %rbx, (%rax)
je 0x35f0
movq %rbx, (%rsp)
xorl %r13d, %r13d
subq $0x1, %r12
jb 0x35d1
movq %r15, %rdi
leaq 0x1e78(%rip), %rsi      # 0x5411
callq 0x23b0
testq %rax, %rax
je 0x35d1
movq %rax, %rbp
leaq (%r14,%r13), %rdi
movq %rax, %rbx
subq %r15, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2220
addq %rbx, %r13
movq %rbp, %rdi
pushq $0x6d
popq %rsi
callq 0x2130
movq %rax, %r15
incq %r15
jmp 0x3589
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
movq (%rsp), %rbx
jmp 0x3607
pushq $0x1
popq %rdi
callq 0x20c0
testl %eax, %eax
jne 0x35fc
jmp 0x3576
pushq $0x2
popq %rdi
callq 0x20c0
testl %eax, %eax
je 0x3582
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
leaq 0x1bb3(%rip), %rsi      # 0x51c1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
movl %eax, %ebx
movq %r14, %rdi
callq 0x2050
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_eprintf
extern int cli_eprintf(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(stderr, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3681
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4ba7(%rip)      # 0x8248
jne 0x36a8
callq 0x34e2
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x490e(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x352c
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: logger
extern int logger(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	int x = 0;
#if 0
	time_t now = time(NULL);
	char at[24];
	struct tm t;
	localtime_r(&now, &t);
	strftime(at, sizeof at, "%F %T : ", &t);
	x += cli_print(stderr, at);
#endif
	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	x += cli_print(stderr, d);
	va_end(ap);
	free(d);

	static const char nl[] = "\n";
	x += cli_print(stderr, nl);

	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3759
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4acf(%rip)      # 0x8248
jne 0x3780
callq 0x34e2
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x4836(%rip), %r15      # 0x7ff8
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x352c
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movq (%r15), %rdi
leaq 0x1b53(%rip), %rsi      # 0x5334
callq 0x352c
addl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintf
extern int cli_fprintf(FILE *f, const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(f, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb %al, %al
je 0x3845
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x49e8(%rip)      # 0x8248
jne 0x3867
callq 0x34e2
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x352c
movl %eax, %ebx
movq (%r15), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintx
extern int cli_fprintx(FILE *f, const uint8_t * const restrict x, size_t z)
{
	CLI_DO_INIT;

#define CLI_PRINTX_W 16
	// TODO allow variable width lines
	int l = 0, o = 0;
	char r[CLI_PRINTX_W * 2 + CLI_PRINTX_W] = { 0x0 };
	for (size_t i = 0; i < z; i++)
	{
		char c[4] = { 0x0 };
		sprintf(c, "%02x", x[i]);
		strcat(r, c);
		if (i % 2 == 1)
			strcat(r, " ");
		if (i % CLI_PRINTX_W == (CLI_PRINTX_W - 1))
		{
			l += cli_fprintf(f, "%08x: %s\n", o, r);
			memset(r, 0x00, sizeof r);
			o += CLI_PRINTX_W;
		}
	}
	if (strlen(r))
		l += cli_fprintf(f, "%08x: %s\n", o, r);
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
cmpb $0x0, 0x492c(%rip)      # 0x8248
jne 0x3923
callq 0x34e2
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
leaq 0xc(%rsp), %rbx
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x39d2
andl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax,%r15), %edx
movq %rbx, %rdi
leaq 0x19cd(%rip), %rsi      # 0x5336
xorl %eax, %eax
callq 0x2330
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2320
testb $0x1, %r15b
je 0x3990
movq %r13, %rdi
callq 0x2100
movw $0x20, 0x20(%rsp,%rax)
movl %r15d, %eax
notl %eax
testb $0xf, %al
jne 0x39ca
movq 0x10(%rsp), %rdi
leaq 0x1996(%rip), %rsi      # 0x533b
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x37f5
addl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
addl $0x10, %r12d
incq %r15
jmp 0x3947
cmpb $0x0, 0x20(%rsp)
je 0x39f6
leaq 0x195b(%rip), %rsi      # 0x533b
leaq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x37f5
addl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_calc_bps
extern double cli_calc_bps(cli_bps_s *bps)
{
	CLI_DO_INIT;

	cli_bps_s *copy = m_calloc(BPS, sizeof( cli_bps_s ));
	for (int i = 0; i < BPS; i++)
	{
		copy[i].time  = bps[i].time;
		copy[i].bytes = bps[i].bytes;
	}
	qsort(copy, BPS, sizeof( cli_bps_s ), cli_bps_sort);
	double avg[BPS - 1] = { 0.0f };
	for (int i = 0; i < BPS - 1; i++)
		/*
		 * requires scale factor of MILLION as time is in microseconds
		 * not seconds (millions of bytes / micros of seconds, so to
		 * speak)
		 */
		avg[i] = MILLION * (double)(copy[i + 1].bytes - copy[i].bytes) / (double)(copy[i + 1].time - copy[i].time);
	double val = 0.0;
	for (int i = 0; i < BPS - 1; i++)
		val += avg[i];
	free(copy);
	return val /= (BPS - 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %r14
cmpb $0x0, 0x47f9(%rip)      # 0x8248
jne 0x3a56
callq 0x34e2
leaq 0x18e8(%rip), %rdi      # 0x5345
leaq 0x18f2(%rip), %rdx      # 0x5356
pushq $0x10
popq %r8
movl $0x80, %ecx
movl $0xbd, %esi
callq 0x418b
movq %rax, %rbx
xorl %eax, %eax
cmpq $0x800, %rax            # imm = 0x800
je 0x3a93
movups (%r14,%rax), %xmm0
movups %xmm0, (%rbx,%rax)
addq $0x10, %rax
jmp 0x3a7c
leaq 0xdd(%rip), %rcx        # 0x3b77
pushq $0x10
popq %rdx
movl $0x80, %esi
movq %rbx, %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
xorl %r14d, %r14d
movl $0x3f8, %edx            # imm = 0x3F8
xorl %esi, %esi
callq 0x2180
movq 0x17ca(%rip), %xmm0     # 0x5290
movapd 0x17d2(%rip), %xmm1     # 0x52a0
movsd 0x17ea(%rip), %xmm2     # 0x52c0
cmpq $0x3f8, %r14            # imm = 0x3F8
je 0x3b39
movq 0x10(%rbx,%r14,2), %rax
movq 0x18(%rbx,%r14,2), %rcx
subq 0x8(%rbx,%r14,2), %rcx
movq %rcx, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm4
subq (%rbx,%r14,2), %rax
movq %rax, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5            # xmm5 = xmm5[1],xmm3[1]
addsd %xmm3, %xmm5
divsd %xmm5, %xmm4
movsd %xmm4, 0x10(%rsp,%r14)
addq $0x8, %r14
jmp 0x3ad6
pxor %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x7f, %rax
je 0x3b50
addsd 0x10(%rsp,%rax,8), %xmm0
incq %rax
jmp 0x3b3f
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2050
movsd 0x8(%rsp), %xmm0
divsd 0x175c(%rip), %xmm0     # 0x52c8
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display
extern void cli_display(cli_s *p)
{
	CLI_DO_INIT;

#ifndef _WIN32
	cli_sigwinch(SIGWINCH);
#endif
	cli_size_width = 0;

	cli_bps_s bps[BPS];
	memset(bps, 0x00, BPS * sizeof( cli_bps_s ));
	int b = 0;

	fprintf(stderr, "\e[?25l\n"); /* hide cursor */
	while (*p->status == CLI_INIT || *p->status == CLI_RUN)
	{
		struct timespec s = { 0, 10 * MILLION }; /* 10 milliseconds */
		nanosleep(&s, NULL);
		if (*p->status == CLI_INIT)
			continue;
		struct timeval tv;
		gettimeofday(&tv, NULL);
		bps[b].time = tv.tv_sec * MILLION + tv.tv_usec;
		bps[b].bytes = p->current->offset;
		b++;
		if (b >= BPS)
			b = 0;
		cli_display_bars(p->total, p->current, bps);
	}
	if (*p->status == CLI_DONE)
	{
		p->total->offset = p->total->size;
		p->current->offset = p->current->size;
		cli_display_bars(p->total, p->current, bps);
	}
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rdi, %rbx
cmpb $0x0, 0x46a7(%rip)      # 0x8248
jne 0x3ba8
callq 0x34e2
callq 0x3cb2
leaq 0x20(%rsp), %r14
xorl %ebp, %ebp
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
xorl %esi, %esi
callq 0x2180
movq 0x442e(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x178f(%rip), %rdi      # 0x5363
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
leaq 0x10(%rsp), %r15
movq %rsp, %r12
xorl %r13d, %r13d
movq (%rbx), %rax
movl (%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x3c60
movups 0x16b2(%rip), %xmm0     # 0x52b0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x2150
movq (%rbx), %rax
cmpl $0x1, (%rax)
je 0x3bea
movq %r12, %rdi
xorl %esi, %esi
callq 0x2160
imulq $0xf4240, (%rsp), %rax  # imm = 0xF4240
addq 0x8(%rsp), %rax
movslq %r13d, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq %rax, 0x20(%rsp,%rdx)
movq 0x8(%rbx), %rsi
movq (%rsi), %rax
movq %rax, 0x28(%rsp,%rdx)
leal 0x1(%rcx), %r13d
cmpl $0x7f, %ecx
cmovgel %ebp, %r13d
movq 0x10(%rbx), %rdi
movq %r14, %rdx
callq 0x3ced
jmp 0x3bea
testl %eax, %eax
jne 0x3c84
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rbx), %rsi
movq 0x8(%rsi), %rax
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdx
callq 0x3ced
movq 0x436d(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x15ab(%rip), %rdi      # 0x5240
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: on_quit
extern void on_quit(int s)
{
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */
	signal(s, SIG_DFL);
	raise(s);
	_exit(EXIT_FAILURE); // this shouldn't happen as the raise above will handle things
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x4014(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x1252(%rip), %rdi      # 0x5240
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
movl %ebx, %edi
xorl %esi, %esi
callq 0x21f0
movl %ebx, %edi
callq 0x2040
pushq $0x1
popq %rdi
callq 0x2090