LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/wire/wire_readpacket.c
// Function: wire_readpacket_wait
void *
wire_readpacket_wait(struct netbuf_read * R,
    int (* callback)(void *, int), void * cookie)
{
	struct wait_cookie * W;

	/* Bake a cookie. */
	if ((W = mpool_wait_cookie_malloc()) == NULL)
		goto err0;
	W->R = R;
	W->callback = callback;
	W->cookie = cookie;

	/* Wait for a header to be available. */
	if (netbuf_read_wait(W->R, 16, callback_wait_gotheader, W))
		goto err0;

	/* Success! */
	return (W);

err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0xd550
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xd4e5
jmp 0xd535
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
movl $0x10, %esi
leaq 0x51(%rip), %rdx        # 0xd570
callq 0xb6e0
cmpl $0x0, %eax
je 0xd52b
jmp 0xd535
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd53d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/wire/wire_readpacket.c
// Function: callback_wait_gotheader
static int
callback_wait_gotheader(void * cookie, int status)
{
	CRC32C_CTX ctx;
	struct wait_cookie * W = cookie;
	uint8_t * data;
	size_t datalen;
	size_t len;
	uint8_t cbuf[4];
	int rc;

	/* Did we fail or prematurely EOF? */
	if (status)
		goto failed;

	/* Grab the header and verify the checksum. */
	netbuf_read_peek(W->R, &data, &datalen);
	CRC32C_Init(&ctx);
	CRC32C_Update(&ctx, data, 12);
	CRC32C_Final(cbuf, &ctx);
	if (memcmp(&data[12], cbuf, 4)) {
		warn0("Incorrect CRC on packet header");
		goto failed;
	}

	/* Parse length and wait for the complete packet to be available. */
	len = be32dec(&data[8]);
	if (len > SIZE_MAX - 20)
		goto failed;
	if (netbuf_read_wait(W->R, len + 20, callback_wait_gotdata, W))
		goto failed;

	/* Success! */
	return (0);

failed:
	/* Perform a failure callback. */
	rc = (W->callback)(W->cookie, 1);

	/* Free the cookie. */
	mpool_wait_cookie_free(W);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd592
jmp 0xd653
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xb6a0
leaq -0x18(%rbp), %rdi
callq 0x9ff0
movq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movl $0xc, %edx
callq 0xa190
leaq -0x3c(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa300
movq -0x28(%rbp), %rax
addq $0xc, %rax
leaq -0x3c(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xd608
jmp 0xd5ed
leaq 0x3129(%rip), %rdi      # 0x1071d
movb $0x0, %al
callq 0x6a10
callq 0x20a0
movl $0x0, (%rax)
jmp 0xd653
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0xd480
movl %eax, %eax
movq %rax, -0x38(%rbp)
cmpq $-0x15, -0x38(%rbp)
jbe 0xd624
jmp 0xd653
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
addq $0x14, %rsi
movq -0x20(%rbp), %rcx
leaq 0x202(%rip), %rdx       # 0xd840
callq 0xb6e0
cmpl $0x0, %eax
je 0xd64a
jmp 0xd653
movl $0x0, -0x4(%rbp)
jmp 0xd67c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl $0x1, %esi
callq *%rax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd6c0
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/wire/wire_readpacket.c
// Function: callback_wait_gotdata
static int
callback_wait_gotdata(void * cookie, int status)
{
	struct wait_cookie * W = cookie;
	int rc;
	int st;

	/* Did we fail or prematurely EOF? */
	if ((status == -1) || (status == 1))
		st = 1;
	else
		st = 0;

	/* Invoke the upstream callback. */
	rc = (W->callback)(W->cookie, st);

	/* Free the cookie. */
	mpool_wait_cookie_free(W);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xd863
cmpl $0x1, -0xc(%rbp)
jne 0xd86c
movl $0x1, -0x20(%rbp)
jmp 0xd873
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl -0x20(%rbp), %esi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd6c0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/elasticqueue.c
// Function: elasticqueue_init
struct elasticqueue *
elasticqueue_init(size_t reclen)
{
	struct elasticqueue * EQ;

	/* Sanity check. */
	assert(reclen > 0);

	/* Allocate structure. */
	if ((EQ = malloc(sizeof(struct elasticqueue))) == NULL)
		goto err0;
	EQ->reclen = reclen;

	/* Create (empty) elastic array. */
	if ((EQ->EA = elasticarray_init(0, EQ->reclen)) == NULL)
		goto err1;

	/* The queue is empty so far. */
	EQ->offset = EQ->len = 0;

	/* Success! */
	return (EQ);

err1:
	free(EQ);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xda25
jmp 0xda44
leaq 0x269c(%rip), %rdi      # 0x100c8
leaq 0x2d26(%rip), %rsi      # 0x10759
movl $0x1b, %edx
leaq 0x2d43(%rip), %rcx      # 0x10782
callq 0x21a0
movl $0x20, %edi
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xda5a
jmp 0xdab1
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xa8d0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xda86
jmp 0xdaa8
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdab9
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/elasticqueue.c
// Function: elasticqueue_add
int
elasticqueue_add(struct elasticqueue * EQ, const void * rec)
{

	/* Add the record to the end of the elastic array. */
	if (elasticarray_append(EQ->EA, rec, 1, EQ->reclen))
		goto err0;

	/* The queue just gained a record. */
	EQ->len += 1;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movl $0x1, %edx
callq 0xab90
cmpl $0x0, %eax
je 0xdb04
jmp 0xdb1d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xdb24
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/elasticqueue.c
// Function: elasticqueue_delete
void
elasticqueue_delete(struct elasticqueue * EQ)
{
	size_t i;
	void * oldpos;
	void * newpos;

	/* Return immediately if the queue is empty. */
	if (EQ->len == 0)
		return;

	/* Adjust pointers to remove the record from the logical queue. */
	EQ->offset += 1;
	EQ->len -= 1;

	/* Should we move everything to the front of the array? */
	if (EQ->offset > EQ->len) {
		/* Move records. */
		for (i = 0; i < EQ->len; i++) {
			newpos = elasticarray_get(EQ->EA, i, EQ->reclen);
			oldpos = elasticarray_get(EQ->EA, i + EQ->offset,
			    EQ->reclen);
			memcpy(newpos, oldpos, EQ->reclen);
		}

		/* Remove the unused space at the end. */
		elasticarray_shrink(EQ->EA, EQ->offset, EQ->reclen);

		/* And remember that everything is now at the front. */
		EQ->offset = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdb4c
jmp 0xdc23
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xdc23
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xdbfb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xade0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xade0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xdb8a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xaca0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/elasticqueue.c
// Function: elasticqueue_free
void
elasticqueue_free(struct elasticqueue * EQ)
{

	/* Behave consistently with free(NULL). */
	if (EQ == NULL)
		return;

	/* Free the underlying elastic array. */
	elasticarray_free(EQ->EA);

	/* Free the elastic queue structure. */
	free(EQ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdcc5
jmp 0xdcda
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xaa00
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/keyboard.c
// Function: handle_in
uint8_t handle_in(uint8_t dev) {
  switch (dev) {
    case 16:
      return has_keyboard_input() ? 0x03 : 0x02;
    case 17: {
      char ret = has_keyboard_input() ? read_keyboard_input() : '\0';
      return ret;
    }
    case 255:
      return 0;
    default:
      printf("Invalid device read %02X\n", dev);
      return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x10, %eax
je 0x8ca2
jmp 0x8c8c
movl -0x8(%rbp), %eax
subl $0x11, %eax
je 0x8cbe
jmp 0x8c96
movl -0x8(%rbp), %eax
subl $0xff, %eax
je 0x8cea
jmp 0x8cf0
callq 0x8d10
movl %eax, %edx
movl $0x2, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x8d06
callq 0x8d10
cmpl $0x0, %eax
je 0x8cd5
callq 0x8e30
movsbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x8cdc
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x8cdc
movl -0xc(%rbp), %eax
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x8d06
movb $0x0, -0x1(%rbp)
jmp 0x8d06
movzbl -0x2(%rbp), %esi
leaq 0x131c(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/keyboard.c
// Function: has_keyboard_input
int has_keyboard_input(void) {
#ifdef OVERRIDE_INPUT
  if (*input_override)
    return 1;
#endif

#ifdef __unix__
  struct timeval timeout;
  timeout.tv_sec = 0;
  timeout.tv_usec = 10;

  fd_set fds;
  FD_SET(fileno(stdin), &fds);

  if (select(fileno(stdin) + 1, &fds, NULL, NULL, &timeout) == -1) {
    return 0;
  }

  return FD_ISSET(fileno(stdin), &fds);
#else
  if (last_input)
    return 1;

  volatile int *PS2 = (int *)0xFF200100;
  while ((*PS2) & 0x8000 /* RVALID */) {
    ps2_buffer[0] = ps2_buffer[1];
    ps2_buffer[1] = ps2_buffer[2];
    ps2_buffer[2] = (*PS2) & 0xFF;

    if (ps2_buffer[1] == 0xAA && ps2_buffer[2] == 0x00) {
      printf("Inserted keyboard!\n");
    } else {
      // printf("Code %02X %02X %02X\n", ps2_buffer[0], ps2_buffer[1],
      //	   ps2_buffer[2]);
    }

    switch (ps2_buffer[2]) {
      case 0x00: // Key detection error or internal buffer overrun
      case 0xEE: // Response to echo command
      case 0xFA: // Command ACK
      case 0xFC: // Self test failed
      case 0xFD: // ^^
      case 0xFE: // Resend request
      case 0xFF: // Key detection error
        printf("Keyboard notification %02X\n", ps2_buffer[2]);
        continue;
      case 0xAA: // Self test passed or keyboard connected
        printf("Keyboard connected!\n");
        continue;
      case 0xF0:
        is_release = true;
        continue;
      default:
        keydown[ps2_buffer[2]] = !is_release;
        if (!is_release) {
          last_input = ps2_to_ascii[ps2_buffer[2] |
                                    ((keydown[0x12] | keydown[0x59]) << 8)];
        }
        is_release = false;
        break;
    }
  }

  return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq $0x0, -0x18(%rbp)
movq $0xa, -0x10(%rbp)
movq 0x32ae(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x2060
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0xa0(%rbp)
movq 0x3284(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x2060
movq -0xa0(%rbp), %rcx
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x98(%rbp,%rax,8), %rcx
movq %rcx, -0x98(%rbp,%rax,8)
movq 0x3254(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x2060
movl %eax, %edi
addl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rdx
callq 0x2070
cmpl $-0x1, %eax
jne 0x8dbe
movl $0x0, -0x4(%rbp)
jmp 0x8e23
movq 0x321b(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x2060
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq -0x98(%rbp,%rax,8), %rax
movq %rax, -0xa8(%rbp)
movq 0x31f3(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x2060
movl $0x40, %ecx
cltd
idivl %ecx
movq -0xa8(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/keyboard.c
// Function: read_keyboard_input
char read_keyboard_input(void) {
#ifdef OVERRIDE_INPUT
  if (*input_override) {
    char ret = *input_override;
    input_override++;
    return ret;
  }
#endif

#ifdef __unix__
  char ret = toupper(getchar());
  return ret == '\n' ? '\r' : ret;
#else
  char ret = toupper(last_input);
  last_input = 0;
  return ret;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2050
movl %eax, %edi
callq 0x2030
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0xa, %eax
jne 0x8e5a
movl $0xd, %eax
movl %eax, -0x8(%rbp)
jmp 0x8e61
movsbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/terminal.c
// Function: terminal_scroll_buffer
void terminal_scroll_buffer(void) {
  for (int y = 0; y < TERM_HEIGHT - 1; y++) {
    for (int x = 0; x < TERM_WIDTH; x++) {
      write_char(x, y, char_at(x, y + 1));
    }
  }

  for (int x = 0; x < TERM_WIDTH; x++) {
    write_char(x, TERM_HEIGHT - 1, ' ');
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x3a, -0x4(%rbp)
jge 0x8f22
movl $0x0, -0x8(%rbp)
cmpl $0x4f, -0x8(%rbp)
jge 0x8f15
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
addl $0x1, %esi
callq 0x8eb0
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
movsbl %al, %edx
callq 0x8e90
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8edc
jmp 0x8f17
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ecf
movl $0x0, -0xc(%rbp)
cmpl $0x4f, -0xc(%rbp)
jge 0x8f4c
movl -0xc(%rbp), %edi
movl $0x3a, %esi
movl $0x20, %edx
callq 0x8e90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f29
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/terminal.c
// Function: terminal_clear
void terminal_clear(void) {
  for (int x = 0; x < VGA_WIDTH; x++) {
    for (int y = 0; y < VGA_HEIGHT; y++) {
      write_pixel(x, y, BLACK);
    }
  }

  for (int x = 0; x < TERM_WIDTH + 1; x++) {
    for (int y = 0; y < TERM_HEIGHT + 1; y++) {
      write_char(x, y, ' ');
    }
  }

  term_x = 0;
  term_y = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x140, -0x4(%rbp)      # imm = 0x140
jge 0x8fad
movl $0x0, -0x8(%rbp)
cmpl $0xf0, -0x8(%rbp)
jge 0x8fa0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x8e70
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8f7f
jmp 0x8fa2
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8f6f
movl $0x0, -0xc(%rbp)
cmpl $0x50, -0xc(%rbp)
jge 0x8fef
movl $0x0, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0x8fe2
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl $0x20, %edx
callq 0x8e90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8fc1
jmp 0x8fe4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8fb4
movl $0x0, 0x1387b(%rip)     # 0x1c874
movl $0x0, 0x13875(%rip)     # 0x1c878
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Xyene[P]macro8080/terminal.c
// Function: handle_out
void handle_out(uint8_t dev, uint8_t A) {
  // printf("Printing %02X to dev=%02X\n", A, dev);
  if (dev == 0x11) {
    char c = A & 0x7F;
    if ((' ' <= c && c <= '~') || c == '\r' || c == '\n') {
      terminal_out(c);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x11, %eax
jne 0x90aa
movzbl -0x2(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x3(%rbp)
movsbl -0x3(%rbp), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
jg 0x908d
movsbl -0x3(%rbp), %eax
cmpl $0x7e, %eax
jle 0x909f
movsbl -0x3(%rbp), %eax
cmpl $0xd, %eax
je 0x909f
movsbl -0x3(%rbp), %eax
cmpl $0xa, %eax
jne 0x90a8
movsbl -0x3(%rbp), %edi
callq 0x9010
jmp 0x90aa
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSetBlock
int anetSetBlock(char *err, int fd, int non_block) {
    int flags;

    /* Set the socket blocking (if non_block is zero) or non-blocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno));
        return ANET_ERR;
    }

    if (non_block)
        flags |= O_NONBLOCK;
    else
        flags &= ~O_NONBLOCK;

    if (fcntl(fd, F_SETFL, flags) == -1) {
        anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x104f0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x1087b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x76799(%rip), %rsi     # 0x87004
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108e9
cmpl $0x0, -0x18(%rbp)
je 0x1088e
movl -0x1c(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x1c(%rbp)
jmp 0x10899
movl -0x1c(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x104f0
cmpl $-0x1, %eax
jne 0x108e2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x76745(%rip), %rsi     # 0x87017
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSetError
static void anetSetError(char *err, const char *fmt, ...)
{
    va_list ap;

    if (!err) return;
    va_start(ap, fmt);
    vsnprintf(err, ANET_ERR_LEN, fmt, ap);
    va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x10938
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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10965
jmp 0x109a3
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x100f0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSetTcpNoDelay
static int anetSetTcpNoDelay(char *err, int fd, int val)
{
    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) == -1)
    {
        anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x10c45
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x764cd(%rip), %rsi     # 0x87102
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10c4c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSetSendBuffer
int anetSetSendBuffer(char *err, int fd, int buffsize)
{
    if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffsize, sizeof(buffsize)) == -1)
    {
        anetSetError(err, "setsockopt SO_SNDBUF: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x7, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x10cf5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x763c3(%rip), %rsi     # 0x870a8
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10cfc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetTcpKeepAlive
int anetTcpKeepAlive(char *err, int fd)
{
    int yes = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x10d79
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x762cc(%rip), %rsi     # 0x87035
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10d80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSendTimeout
int anetSendTimeout(char *err, int fd, long long ms) {
    struct timeval tv;

    tv.tv_sec = ms/1000;
    tv.tv_usec = (ms%1000)*1000;
    if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) == -1) {
        anetSetError(err, "setsockopt SO_SNDTIMEO: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x15, %edx
leaq -0x30(%rbp), %rcx
movl $0x10, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x10e21
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x762b0(%rip), %rsi     # 0x870c1
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10e28
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetGenericResolve
int anetGenericResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len,
                       int flags)
{
    struct addrinfo hints, *info;
    int rv;

    memset(&hints,0,sizeof(hints));
    if (flags & ANET_IP_ONLY) hints.ai_flags = AI_NUMERICHOST;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;  /* specify socktype to avoid dups */

    if ((rv = getaddrinfo(host, NULL, &hints, &info)) != 0) {
        anetSetError(err, "%s", gai_strerror(rv));
        return ANET_ERR;
    }
    if (info->ai_family == AF_INET) {
        struct sockaddr_in *sa = (struct sockaddr_in *)info->ai_addr;
        inet_ntop(AF_INET, &(sa->sin_addr), ipbuf, ipbuf_len);
    } else {
        struct sockaddr_in6 *sa = (struct sockaddr_in6 *)info->ai_addr;
        inet_ntop(AF_INET6, &(sa->sin6_addr), ipbuf, ipbuf_len);
    }

    freeaddrinfo(info);
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10250
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x10e81
movl $0x4, -0x60(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x1, -0x58(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x10640
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x10ee0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x6c(%rbp), %edi
callq 0x10200
movq -0x88(%rbp), %rdi
movq %rax, %rdx
leaq 0x76162(%rip), %rsi     # 0x87032
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10f4c
movq -0x68(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x10f14
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
addq $0x4, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0x2, %edi
callq 0x10030
jmp 0x10f3c
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0xa, %edi
callq 0x10030
movq -0x68(%rbp), %rdi
callq 0x10700
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetUnixGenericConnect
int anetUnixGenericConnect(char *err, char *path, int flags)
{
    int s;
    struct sockaddr_un sa;

    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
        return ANET_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (flags & ANET_CONNECT_NONBLOCK) {
        if (anetNonBlock(err,s) != ANET_OK)
            return ANET_ERR;
    }
    if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {
        if (errno == EINPROGRESS &&
            flags & ANET_CONNECT_NONBLOCK)
            return s;

        anetSetError(err, "connect: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11550
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
jne 0x11468
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1153e
movw $0x1, -0x8e(%rbp)
leaq -0x8e(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movl $0x6b, %edx
callq 0x10090
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x114b4
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x109b0
cmpl $0x0, %eax
je 0x114b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1153e
jmp 0x114b4
movl -0x20(%rbp), %edi
leaq -0x8e(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rsi
movl $0x6e, %edx
callq 0x10610
cmpl $-0x1, %eax
jne 0x11538
callq 0x10080
cmpl $0x73, (%rax)
jne 0x114f8
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x114f8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1153e
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0xa0(%rbp), %rdi
movq %rax, %rdx
leaq 0x75bbc(%rip), %rsi     # 0x870dc
movb $0x0, %al
callq 0x10900
movl -0x20(%rbp), %edi
callq 0x10280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1153e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetCreateSocket
static int anetCreateSocket(char *err, int domain) {
    int s;
    if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {
        anetSetError(err, "creating socket: %s", strerror(errno));
        return ANET_ERR;
    }

    /* Make sure connection-intensive things like the redis benchmark
     * will be able to close/open sockets a zillion of times */
    if (anetSetReuseAddr(err,s) == ANET_ERR) {
        close(s);
        return ANET_ERR;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x10710
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x115a8
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x75b8e(%rip), %rsi     # 0x87126
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x115d0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x12170
cmpl $-0x1, %eax
jne 0x115ca
movl -0x18(%rbp), %edi
callq 0x10280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x115d0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetRead
int anetRead(int fd, char *buf, int count)
{
    ssize_t nread, totlen = 0;
    while(totlen != count) {
        nread = read(fd,buf,count-totlen);
        if (nread == 0) return totlen;
        if (nread == -1) return -1;
        totlen += nread;
        buf += nread;
    }
    return totlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x116b9
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
subq -0x28(%rbp), %rdx
callq 0x102b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1168f
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x116c0
cmpq $-0x1, -0x20(%rbp)
jne 0x1169f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x116c0
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1165a
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetWrite
int anetWrite(int fd, char *buf, int count)
{
    ssize_t nwritten, totlen = 0;
    while(totlen != count) {
        nwritten = write(fd,buf,count-totlen);
        if (nwritten == 0) return totlen;
        if (nwritten == -1) return -1;
        totlen += nwritten;
        buf += nwritten;
    }
    return totlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x11749
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
subq -0x28(%rbp), %rdx
callq 0x10150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1171f
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x11750
cmpq $-0x1, -0x20(%rbp)
jne 0x1172f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11750
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x116ea
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetUnixServer
int anetUnixServer(char *err, char *path, mode_t perm, int backlog)
{
    int s;
    struct sockaddr_un sa;

    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
        return ANET_ERR;

    memset(&sa,0,sizeof(sa));
    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa),backlog) == ANET_ERR)
        return ANET_ERR;
    if (perm)
        chmod(sa.sun_path, perm);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11550
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x119c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11a46
leaq -0x92(%rbp), %rdi
xorl %esi, %esi
movl $0x6e, %edx
callq 0x10250
movw $0x1, -0x92(%rbp)
leaq -0x92(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movl $0x6b, %edx
callq 0x10090
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %r8d
leaq -0x92(%rbp), %rdx
movl $0x6e, %ecx
callq 0x11a60
cmpl $-0x1, %eax
jne 0x11a27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11a46
cmpl $0x0, -0x1c(%rbp)
je 0x11a40
leaq -0x92(%rbp), %rdi
addq $0x2, %rdi
movl -0x1c(%rbp), %esi
callq 0x104b0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetListen
static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len, int backlog) {
    if (bind(s,sa,len) == -1) {
        anetSetError(err, "bind: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }

    if (listen(s, backlog) == -1) {
        anetSetError(err, "listen: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rsi
callq 0x104c0
cmpl $-0x1, %eax
jne 0x11ad0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x75665(%rip), %rsi     # 0x8711d
movb $0x0, %al
callq 0x10900
movl -0x14(%rbp), %edi
callq 0x10280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b21
movl -0x14(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x10450
cmpl $-0x1, %eax
jne 0x11b1a
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x75684(%rip), %rsi     # 0x87186
movb $0x0, %al
callq 0x10900
movl -0x14(%rbp), %edi
callq 0x10280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetTcpAccept
int anetTcpAccept(char *err, int s, char *ip, size_t ip_len, int *port) {
    int fd;
    struct sockaddr_storage sa;
    socklen_t salen = sizeof(sa);
    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == -1)
        return ANET_ERR;

    if (sa.ss_family == AF_INET) {
        struct sockaddr_in *s = (struct sockaddr_in *)&sa;
        if (ip) inet_ntop(AF_INET,(void*)&(s->sin_addr),ip,ip_len);
        if (port) *port = ntohs(s->sin_port);
    } else {
        struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;
        if (ip) inet_ntop(AF_INET6,(void*)&(s->sin6_addr),ip,ip_len);
        if (port) *port = ntohs(s->sin6_port);
    }
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x80, -0xbc(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0xb8(%rbp), %rdx
leaq -0xbc(%rbp), %rcx
callq 0x11c50
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
jne 0x11b86
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11c44
movzwl -0xb8(%rbp), %eax
cmpl $0x2, %eax
jne 0x11be8
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11bc6
movq -0xc8(%rbp), %rsi
addq $0x4, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0x2, %edi
callq 0x10030
cmpq $0x0, -0x30(%rbp)
je 0x11be6
movq -0xc8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10480
movzwl %ax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x11c3e
leaq -0xb8(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11c1c
movq -0xd0(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0xa, %edi
callq 0x10030
cmpq $0x0, -0x30(%rbp)
je 0x11c3c
movq -0xd0(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10480
movzwl %ax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x11c3e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetGenericAccept
static int anetGenericAccept(char *err, int s, struct sockaddr *sa, socklen_t *len) {
    int fd;
    while(1) {
        fd = accept(s,sa,len);
        if (fd == -1) {
            if (errno == EINTR)
                continue;
            else {
                anetSetError(err, "accept: %s", strerror(errno));
                return ANET_ERR;
            }
        }
        break;
    }
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rsi
callq 0x10590
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x11cc6
callq 0x10080
cmpl $0x4, (%rax)
jne 0x11c94
jmp 0x11c67
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x754db(%rip), %rsi     # 0x87191
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11cce
jmp 0x11cc8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetUnixAccept
int anetUnixAccept(char *err, int s) {
    int fd;
    struct sockaddr_un sa;
    socklen_t salen = sizeof(sa);
    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == -1)
        return ANET_ERR;

    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x6e, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x86(%rbp), %rdx
leaq -0x8c(%rbp), %rcx
callq 0x11c50
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x11d27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d2d
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSockName
int anetSockName(int fd, char *ip, size_t ip_len, int *port) {
    struct sockaddr_storage sa;
    socklen_t salen = sizeof(sa);

    if (getsockname(fd,(struct sockaddr*)&sa,&salen) == -1) {
        if (port) *port = 0;
        ip[0] = '?';
        ip[1] = '\0';
        return -1;
    }
    if (sa.ss_family == AF_INET) {
        struct sockaddr_in *s = (struct sockaddr_in *)&sa;
        if (ip) inet_ntop(AF_INET,(void*)&(s->sin_addr),ip,ip_len);
        if (port) *port = ntohs(s->sin_port);
    } else {
        struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;
        if (ip) inet_ntop(AF_INET6,(void*)&(s->sin6_addr),ip,ip_len);
        if (port) *port = ntohs(s->sin6_port);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x80, -0xa4(%rbp)
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rsi
leaq -0xa4(%rbp), %rdx
callq 0x105a0
cmpl $-0x1, %eax
jne 0x12049
cmpq $0x0, -0x20(%rbp)
je 0x1202e
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x3f, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12108
movzwl -0xa0(%rbp), %eax
cmpl $0x2, %eax
jne 0x120ab
leaq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12089
movq -0xb8(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movl $0x2, %edi
callq 0x10030
cmpq $0x0, -0x20(%rbp)
je 0x120a9
movq -0xb8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10480
movzwl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x12101
leaq -0xa0(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x120df
movq -0xc0(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movl $0xa, %edi
callq 0x10030
cmpq $0x0, -0x20(%rbp)
je 0x120ff
movq -0xc0(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10480
movzwl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x12101
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetSetReuseAddr
static int anetSetReuseAddr(char *err, int fd) {
    int yes = 1;
    /* Make sure connection-intensive things like the redis benckmark
     * will be able to close/open sockets a zillion of times */
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x121d9
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x74f71(%rip), %rsi     # 0x8713a
movb $0x0, %al
callq 0x10900
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x121e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/anet.c
// Function: anetV6Only
static int anetV6Only(char *err, int s) {
    int yes = 1;
    if (setsockopt(s,IPPROTO_IPV6,IPV6_V6ONLY,&yes,sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x29, %esi
movl $0x1a, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x12261
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x74f2e(%rip), %rsi     # 0x87177
movb $0x0, %al
callq 0x10900
movl -0x14(%rbp), %edi
callq 0x10280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12268
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/adlist.c
// Function: listCreate
list *listCreate(void)
{
    struct list *list;

    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;
    list->head = list->tail = NULL;
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x19760
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x122a6
movq $0x0, -0x8(%rbp)
jmp 0x122f5
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/adlist.c
// Function: listRelease
void listRelease(list *list)
{
    unsigned long len;
    listNode *current, *next;

    current = list->head;
    len = list->len;
    while(len--) {
        next = current->next;
        if (list->free) list->free(current->value);
        zfree(current);
        current = next;
    }
    zfree(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x12374
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12361
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x19a30
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x12323
movq -0x8(%rbp), %rdi
callq 0x19a30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)