LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xf6(%rip), %rdi       # 0x55e0
xorl %eax, %eax
movl %eax, %esi
callq 0x5d50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe700
callq 0x56a0
movq -0x10(%rbp), %rdi
callq 0x32de0
cmpl $0x0, %eax
je 0x5706
callq 0x56a0
jmp 0x56f1
movq -0x10(%rbp), %rdi
callq 0x61b0
callq 0x56a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x820, %rsp            # imm = 0x820
movq %rdi, -0x10(%rbp)
leaq 0x2324(%rip), %rdi      # 0x3511a
movb $0x0, %al
callq 0x5170
leaq -0x810(%rbp), %rdi
movq 0xe1c5(%rip), %rax      # 0x40fd0
movq (%rax), %rdx
movl $0x800, %esi            # imm = 0x800
callq 0x5220
cmpq $0x0, %rax
jne 0x32e38
leaq 0xd06(%rip), %rdi       # 0x33b2b
movb $0x0, %al
callq 0x5170
movl $0x0, -0x4(%rbp)
jmp 0x32ecd
movq -0x10(%rbp), %rdi
leaq -0x810(%rbp), %rsi
callq 0x22ec0
movl %eax, -0x814(%rbp)
cmpl $0x0, -0x814(%rbp)
jne 0x32e74
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movl %ecx, %edx
movq %r9, %r8
callq 0x10e80
movl %eax, -0x814(%rbp)
cmpl $0x0, -0x814(%rbp)
je 0x32ec6
movq 0xe16c(%rip), %rax      # 0x40ff0
movq (%rax), %rax
movq %rax, -0x820(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0xf440
movq -0x820(%rbp), %rdi
movq %rax, %rdx
leaq 0x1c67(%rip), %rsi      # 0x34b18
movb $0x0, %al
callq 0x5270
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xea30
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x1377
movq 0x3ca5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1ca0(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1120
movl $0x1, -0x4(%rbp)
jmp 0x1428
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11c0
movw %ax, -0x1a(%rbp)
movw -0x1a(%rbp), %ax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movzwl %ax, %edi
callq 0x2220
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x13b9
leaq 0x1c6e(%rip), %rdi      # 0x3019
callq 0x11a0
movl $0x1, -0x4(%rbp)
jmp 0x1428
movq 0x3c38(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1080
movq -0x30(%rbp), %rdi
movslq %eax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x1c51(%rip), %rsi      # 0x3033
movb $0x0, %al
callq 0x1120
movl -0x18(%rbp), %esi
xorl %edi, %edi
callq 0x17f0
movl %eax, -0x14(%rbp)
movq 0x3bfb(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1080
movq -0x28(%rbp), %rdi
movslq %eax, %rdx
movl -0x14(%rbp), %ecx
leaq 0x1c2d(%rip), %rsi      # 0x3047
movb $0x0, %al
callq 0x1120
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x3287(%rip), %rdi      # 0x5130
callq 0x1200
cmpl $-0x1, %eax
jne 0x1eeb
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
callq 0x1090
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x1040
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1f66
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x11d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1f30
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
callq 0x1090
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x1040
jmp 0x1f49
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x1040
leaq 0x31e0(%rip), %rdi      # 0x5130
callq 0x1150
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1210
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1fb3
movq -0x10(%rbp), %rdi
callq 0x1100
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x201e
leaq 0x3176(%rip), %rdi      # 0x5130
callq 0x1200
cmpl $-0x1, %eax
jne 0x1fcd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2025
movq -0x10(%rbp), %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ff6
leaq 0x3148(%rip), %rdi      # 0x5130
callq 0x1150
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2025
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x1130
leaq 0x3117(%rip), %rdi      # 0x5130
callq 0x1150
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x11a8
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
movq 0x2e63(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x117b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.3/thread-create3.c
// Function: main
int main ()
{
	pthread_t thread1_id;
	pthread_t thread2_id;
	struct char_print_parms thread1_args;
	struct char_print_parms thread2_args;

  /* Create a new thread to print 30,000 x's. */
	thread1_args.character = 'x';
	thread1_args.count = 30000;
	pthread_create (&thread1_id, NULL, &char_print, &thread1_args);

  /* Create a new thread to print 20,000 o's. */
	thread2_args.character = 'o';
	thread2_args.count = 20000;
	pthread_create (&thread2_id, NULL, &char_print, &thread2_args);
  // Asegurarse que el primer hilo haya acabado
	pthread_join(thread1_id, NULL);
  // Asegurarse que el segundo hilo haya acabado
	pthread_join(thread2_id, NULL);

  //Ahora podemos hacer return
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movb $0x78, -0x20(%rbp)
movl $0x7530, -0x1c(%rbp)    # imm = 0x7530
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x79(%rip), %rdx       # 0x1160
leaq -0x20(%rbp), %rcx
callq 0x1040
movb $0x6f, -0x28(%rbp)
movl $0x4e20, -0x24(%rbp)    # imm = 0x4E20
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c(%rip), %rdx       # 0x1160
leaq -0x28(%rbp), %rcx
callq 0x1040
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x6e45(%rip)      # 0x8160
je 0x131f
jmp 0x138f
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x135b
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq -0x4(%rbp), %rcx
leaq 0x6dde(%rip), %rax      # 0x8120
movslq (%rax,%rcx,4), %rcx
leaq 0x6e23(%rip), %rax      # 0x8170
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1326
movl $0x38, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x1388
movslq -0x4(%rbp), %rcx
leaq 0x71fa(%rip), %rax      # 0x8570
movl $0x1, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1362
movb $0x1, 0x6dd1(%rip)      # 0x8160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpb $0x0, 0x6da6(%rip)      # 0x8160
je 0x13be
jmp 0x13dd
leaq 0x3c4b(%rip), %rdi      # 0x5010
leaq 0x3c56(%rip), %rsi      # 0x5022
movl $0x23, %edx
leaq 0x3c51(%rip), %rcx      # 0x5029
callq 0x10b0
jmp 0x13df
cmpl $0x10, -0x14(%rbp)
jle 0x144a
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x1433
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rax), %rdx
leaq 0x6d51(%rip), %rax      # 0x8170
orl (%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13f6
movl -0x14(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x13df
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x149a
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rax), %rdx
leaq 0x6cea(%rip), %rax      # 0x8170
orl (%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x145b
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpb $0x0, 0x6c26(%rip)      # 0x8160
je 0x153e
jmp 0x155d
leaq 0x3acb(%rip), %rdi      # 0x5010
leaq 0x3ad6(%rip), %rsi      # 0x5022
movl $0x36, %edx
leaq 0x3af2(%rip), %rcx      # 0x504a
callq 0x10b0
jmp 0x155f
cmpl $0x20, -0x14(%rbp)
jle 0x15c9
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x15b2
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rax), %rdx
leaq 0x6fd2(%rip), %rax      # 0x8570
orl (%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1576
movl -0x14(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x155f
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1618
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rax), %rdx
leaq 0x6f6c(%rip), %rax      # 0x8570
orl (%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15da
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x70f5(%rip), %rax      # 0x8988
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x18b7
movl 0x72eb(%rip), %eax      # 0x8b90
addl $0x1, %eax
movl %eax, 0x72e2(%rip)      # 0x8b90
movb $0x0, -0x1(%rbp)
jmp 0x193c
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq 0x70c4(%rip), %rax      # 0x8988
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %esi
callq 0x1840
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x1938
movl 0x72ad(%rip), %eax      # 0x8b94
addl $0x1, %eax
movl %eax, 0x72a4(%rip)      # 0x8b94
movq 0x7091(%rip), %rax      # 0x8988
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
subl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl $0xf, %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x7281(%rip), %rax      # 0x8ba0
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x7274(%rip), %rax      # 0x8ba0
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x0, -0x412(%rbp)
movw $0x0, -0x414(%rbp)
callq 0x4700
movq %rax, -0x420(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x2250
movq %rax, %rcx
movq -0x420(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2290
movw %ax, -0x414(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x29f4
movzwl -0x414(%rbp), %ecx
movzwl -0x412(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x412(%rbp)
movq -0x420(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x412(%rbp), %eax
movl %eax, %esi
callq 0x22d0
movq %rax, %rcx
movq -0x420(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x420(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29cf
movl $0x5, %edi
leaq 0x36c8(%rip), %rsi      # 0x6086
movb $0x0, %al
callq 0x4480
movl $0x1, %edi
callq 0x2210
movq -0x420(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x410(%rbp), %rsi
movzwl -0x414(%rbp), %eax
movl %eax, %edx
callq 0x2180
jmp 0x2939
movzwl -0x412(%rbp), %edx
movl $0x1, %edi
leaq 0x36a3(%rip), %rsi      # 0x60aa
movb $0x0, %al
callq 0x4480
movw -0x412(%rbp), %cx
movq -0x420(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rdi
movq -0x420(%rbp), %rsi
callq 0x3150
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3142
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %edi
callq 0x2050
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x1(%rax)
movl -0x18(%rbp), %eax
addq $0x3, %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2180
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x3090
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_request_add_payload
void ff_client_request_add_payload(struct ff_request *request, struct ff_request_payload_node *node)
{
    struct ff_request_payload_node *last_node = request->payload, *next_node = NULL;
    while (next_node != NULL)
    {
        last_node = next_node;
        next_node = node->next;
    }

    if (last_node == NULL)
    {
        request->payload = node;
    }
    else
    {
        last_node->next = node;
        node->offset = last_node->offset + last_node->length;
    }

    request->payload_length += node->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x318d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3170
cmpq $0x0, -0x18(%rbp)
jne 0x31a2
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x31c9
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x14, %rax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jge 0x324e
movl -0xc(%rbp), %eax
addq $0x3, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movl -0xc(%rbp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl $0x8, %esi
callq 0x2270
cmpl $0x0, %eax
jne 0x32a8
movl $0x5, %edi
leaq 0x2e4f(%rip), %rsi      # 0x60e6
movb $0x0, %al
callq 0x4480
movl $0x1, %edi
callq 0x2210
movzbl -0x8(%rbp), %eax
movzbl -0x7(%rbp), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movzbl -0x6(%rbp), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movzbl -0x5(%rbp), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movzbl -0x4(%rbp), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movzbl -0x3(%rbp), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movzbl -0x2(%rbp), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movzbl -0x1(%rbp), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq 0x534c(%rip), %rdi      # 0x91d0
callq 0x3300
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x3f18
movq -0x20(%rbp), %rax
leaq 0x27da(%rip), %rcx      # 0x6688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x511a(%rip), %rax      # 0x8fd8
movq (%rax), %rsi
leaq 0x5308(%rip), %rdi      # 0x91d0
callq 0x2440
movl %eax, -0x18(%rbp)
jmp 0x3f18
movq 0x50e7(%rip), %rax      # 0x8fc0
movq (%rax), %rdi
callq 0x4410
movl $0x0, -0x18(%rbp)
jmp 0x3f18
movq 0x50cf(%rip), %rax      # 0x8fc0
movq (%rax), %rdi
callq 0x3690
movl $0x0, -0x18(%rbp)
jmp 0x3f18
movq 0x50d7(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
callq 0x3690
movl $0x1, -0x18(%rbp)
movl $0x2, %edi
leaq 0x2774(%rip), %rsi      # 0x6698
movb $0x0, %al
callq 0x4480
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2bea
cmpq $0x0, -0x8(%rbp)
jbe 0x2bea
movq -0x8(%rbp), %rcx
movq 0x5628(%rip), %rax      # 0x8200
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x561a(%rip), %rax      # 0x8200
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/hide.c
// Function: will_fit
static bool will_fit(data_info_t *data_info, image_info_t image_info)
{
	/*
	 * figure out how much data we can hide
	 */
	struct stat s;
	stat(data_info->file, &s);
	if ((uint64_t)s.st_size > HIDE_CAPACITY)
	{
		errno = ENOSPC;
		return false;
	}
	data_info->size = htonll(s.st_size);
	data_info->hide = true;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2120
movq -0xa8(%rbp), %rdx
movq -0x70(%rbp), %rax
movq 0x30(%rdx), %rcx
imulq 0x28(%rdx), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
jbe 0x2c4e
callq 0x2060
movl $0x1c, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x2cfb
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq -0x70(%rbp), %rcx
shrq $0x38, %rcx
movabsq $0xff000000000000, %rax # imm = 0xFF000000000000
andq -0x70(%rbp), %rax
shrq $0x28, %rax
orq %rax, %rcx
movabsq $0xff0000000000, %rax   # imm = 0xFF0000000000
andq -0x70(%rbp), %rax
shrq $0x18, %rax
orq %rax, %rcx
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
andq -0x70(%rbp), %rax
shrq $0x8, %rax
orq %rax, %rcx
movabsq $0xff000000, %rax       # imm = 0xFF000000
andq -0x70(%rbp), %rax
shlq $0x8, %rax
orq %rax, %rcx
movq -0x70(%rbp), %rax
andq $0xff0000, %rax         # imm = 0xFF0000
shlq $0x18, %rax
orq %rax, %rcx
movq -0x70(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
shlq $0x28, %rax
orq %rax, %rcx
movq -0x70(%rbp), %rax
andq $0xff, %rax
shlq $0x38, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2060, %rsp           # imm = 0x2060
movl %edi, -0x4(%rbp)
movl 0x460c(%rip), %eax      # 0x8210
cmpl $0x0, %eax
je 0x3c11
movl -0x4(%rbp), %edi
callq 0x2040
movl $0x1, 0x45f5(%rip)      # 0x8210
movl $0x2, %edi
leaq 0x2649(%rip), %rsi      # 0x6270
movl $0x7, %edx
callq 0x20e0
movl $0x2, %edi
leaq 0x263b(%rip), %rsi      # 0x6278
movl $0x2e, %edx
callq 0x20e0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2170
leaq -0x30(%rbp), %rdi
leaq 0x2645(%rip), %rsi      # 0x62a7
callq 0x2320
leaq -0x30(%rbp), %rax
movq %rax, -0x2050(%rbp)
movl -0x4(%rbp), %edi
callq 0x3da0
movq -0x2050(%rbp), %rdi
movq %rax, %rsi
callq 0x2320
leaq -0x30(%rbp), %rdi
leaq 0x27d0(%rip), %rsi      # 0x6464
callq 0x2320
movl -0x4(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x2380
leaq -0x2030(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2110
movl %eax, -0x2034(%rbp)
leaq -0x2030(%rbp), %rdi
movl -0x2034(%rbp), %esi
callq 0x20d0
movq %rax, -0x2040(%rbp)
cmpq $0x0, -0x2040(%rbp)
je 0x3d68
movl $0x0, -0x2044(%rbp)
movl -0x2044(%rbp), %eax
cmpl -0x2034(%rbp), %eax
jge 0x3d66
movq -0x2040(%rbp), %rax
movslq -0x2044(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x2058(%rbp)
movq -0x2040(%rbp), %rax
movslq -0x2044(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2100
movq -0x2058(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x20e0
movl $0x2, %edi
leaq 0x255a(%rip), %rsi      # 0x62a5
movl $0x1, %edx
callq 0x20e0
movl -0x2044(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2044(%rbp)
jmp 0x3ced
jmp 0x3d68
movl $0x2, %edi
leaq 0x2504(%rip), %rsi      # 0x6278
movl $0x2e, %edx
callq 0x20e0
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
movl -0x4(%rbp), %edi
callq 0x2040
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/error.c
// Function: int_to_ascii
static char *int_to_ascii(int i)
{
	/* Room for INT_DIGITS digits, - and '\0' */
	static char buf[INT_DIGITS + 2];
	char *p = buf + INT_DIGITS + 1; /* points to terminating '\0' */
	if (i >= 0)
		do
		{
			*--p = '0' + (i % 10);
			i /= 10;
		}
		while (i != 0);
	else
	{          /* i < 0 */
		do
		{
			*--p = '0' - (i % 10);
			i /= 10;
		}
		while (i != 0);
		*--p = '-';
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x4472(%rip), %rax      # 0x8220
addq $0x13, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x3dfa
jmp 0x3dc2
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, -0x1(%rax)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x3dc2
jmp 0x3e49
jmp 0x3dfc
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0x30, %eax
subl %edx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, -0x1(%rax)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x3dfc
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl 0x43ba(%rip), %eax      # 0x8214
cmpl $0x0, %eax
je 0x3e61
jmp 0x3ec0
movl $0x4, %edi
leaq -0x27d(%rip), %rsi      # 0x3bf0
callq 0x21e0
movl $0xb, %edi
leaq -0x28e(%rip), %rsi      # 0x3bf0
callq 0x21e0
movl $0x7, %edi
leaq -0x29f(%rip), %rsi      # 0x3bf0
callq 0x21e0
movl $0x6, %edi
leaq -0x2b0(%rip), %rsi      # 0x3bf0
callq 0x21e0
movl $0x1f, %edi
leaq -0x2c1(%rip), %rsi      # 0x3bf0
callq 0x21e0
movl $0x1, 0x4354(%rip)      # 0x8214
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4158
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x4062(%rip)      # 0x81e8
je 0x418d
callq 0x4200
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x20f0
movq 0x3e0a(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4260
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2050
movl -0x2c(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %r8
addq $0x1, %r8
leaq 0x20e9(%rip), %rdi      # 0x6375
movl $0x16a, %esi            # imm = 0x16A
leaq 0x21a2(%rip), %rdx      # 0x643a
movl $0x1, %ecx
callq 0x5560
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x3d27(%rip), %rcx      # 0x7fd8
cmpq (%rcx), %rax
jne 0x42cc
movl $0x1, %edi
callq 0x20c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x4d(%rbp)
jne 0x42fa
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movq 0x3d1f(%rip), %rdx      # 0x7ff8
cmpq (%rdx), %rcx
movb %al, -0x4e(%rbp)
jne 0x42f4
movl $0x2, %edi
callq 0x20c0
cmpl $0x0, %eax
setne %al
movb %al, -0x4e(%rbp)
movb -0x4e(%rbp), %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x43af
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x43a0
movq -0x30(%rbp), %rdi
leaq 0x2109(%rip), %rsi      # 0x6444
callq 0x23a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x434d
jmp 0x43a0
movq -0x20(%rbp), %rdi
addq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
subq %rax, %rdx
callq 0x2210
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movl $0x6d, %esi
callq 0x2130
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4326
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2320
jmp 0x43bc
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1df9(%rip), %rsi      # 0x61c4
movb $0x0, %al
callq 0x2200
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2050
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4428
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x3d92(%rip)      # 0x81e8
je 0x445d
callq 0x4200
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x20f0
movq 0x3b5a(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4260
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2050
movl -0x2c(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x450b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x3caf(%rip)      # 0x81e8
je 0x4540
callq 0x4200
movl $0x0, -0xc(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x20f0
movq 0x3a70(%rip), %rax      # 0x7ff8
movq %rax, -0xf8(%rbp)
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x4260
movl %eax, %ecx
movl -0xc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2050
movq -0xf8(%rbp), %rax
movq (%rax), %rdi
leaq 0x1da5(%rip), %rsi      # 0x6364
callq 0x4260
movl %eax, %ecx
movl -0xc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x461b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, 0x3ba2(%rip)      # 0x81e8
je 0x464d
callq 0x4200
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x20f0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4260
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2050
movl -0x3c(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x1, 0x3add(%rip)      # 0x81e8
je 0x4712
callq 0x4200
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2170
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x47f8
leaq -0x5c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2170
leaq -0x5c(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x1bf9(%rip), %rsi      # 0x6366
movb $0x0, %al
callq 0x2330
leaq -0x50(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x2320
movq -0x58(%rbp), %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x479f
leaq -0x50(%rbp), %rdi
leaq 0x1c22(%rip), %rsi      # 0x63bc
callq 0x2320
movq -0x58(%rbp), %rax
andq $0xf, %rax
cmpq $0xf, %rax
jne 0x47e5
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq -0x50(%rbp), %rcx
leaq 0x1bac(%rip), %rsi      # 0x636b
movb $0x0, %al
callq 0x45e0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2170
movl -0x20(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x20(%rbp)
jmp 0x47e7
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x4738
leaq -0x50(%rbp), %rdi
callq 0x2100
cmpq $0x0, %rax
je 0x4826
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq -0x50(%rbp), %rcx
leaq 0x1b52(%rip), %rsi      # 0x636b
movb $0x0, %al
callq 0x45e0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x2ee6(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1154(%rip), %rsi      # 0x6270
movb $0x0, %al
callq 0x2200
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
movl -0x4(%rbp), %edi
callq 0x2040
movl $0x1, %edi
callq 0x2090
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/mem.c
// Function: mem_mod
extern void *mem_mod(const char *file, int line, const char *func, size_t size)
{
	void *m = malloc(size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5548
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0xf06(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/mem.c
// Function: mem_cod
extern void *mem_cod(const char *file, int line, const char *func, size_t count, size_t size)
{
	void *m = calloc(count, size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x21c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x55b0
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xe9e(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/mem.c
// Function: mem_rod
extern void *mem_rod(const char *file, int line, const char *func, void *ptr, size_t newsize)
{
	void *m = realloc(ptr, newsize);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, newsize);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2290
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5610
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xe3e(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/mem.c
// Function: mem_sod
extern char *mem_sod(const char *file, int line, const char *func, const char *str)
{
	size_t len = strlen(str);
	char *new = strdup(str);
	if (!new)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, len);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2360
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5675
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xdd9(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop