LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_background
int storage_save_background(const char *filename)
{
	pid_t child_pid;

	if (server->child_pid != -1)
		return EG_STATUS_ERR;

	if ((child_pid = fork()) == 0)
	{
		if (server->fd > 0)
			close(server->fd);

		if (server->sfd > 0)
			close(server->sfd);

		_exit(storage_save(filename));
	}
	else
	{
		if (child_pid == -1)
		{
			warning("Error save data in background: %s\n", strerror(errno));
			return EG_STATUS_ERR;
		}

		server->child_pid = child_pid;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7ccd(%rip), %rax      # 0x172b0
movq (%rax), %rax
cmpl $-0x1, 0x34(%rax)
je 0xf5f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf69c
callq 0x24d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0xf659
leaq 0x7ca4(%rip), %rax      # 0x172b0
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jle 0xf627
leaq 0x7c94(%rip), %rax      # 0x172b0
movq (%rax), %rax
movl 0x8(%rax), %edi
callq 0x2200
leaq 0x7c82(%rip), %rax      # 0x172b0
movq (%rax), %rax
cmpl $0x0, 0xc(%rax)
jle 0xf649
leaq 0x7c72(%rip), %rax      # 0x172b0
movq (%rax), %rax
movl 0xc(%rax), %edi
callq 0x2200
movq -0x10(%rbp), %rdi
callq 0xf150
movl %eax, %edi
callq 0x2090
cmpl $-0x1, -0x14(%rbp)
jne 0xf685
callq 0x2050
movl (%rax), %edi
callq 0x24c0
movq %rax, %rsi
leaq 0x3159(%rip), %rdi      # 0x127ce
movb $0x0, %al
callq 0x5840
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf69c
movl -0x14(%rbp), %ecx
leaq 0x7c21(%rip), %rax      # 0x172b0
movq (%rax), %rax
movl %ecx, 0x34(%rax)
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/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_read_data
static int storage_read_data(FILE *fp, void *data, uint32_t maxlen)
{
	uint32_t comprlen;
	uint32_t length;
	void *compressed;

	if (storage_read(fp, &comprlen, sizeof(comprlen)) == -1)
		return EG_STATUS_ERR;

	if (storage_read(fp, &length, sizeof(length)) == -1)
		return EG_STATUS_ERR;

	if ((length > maxlen && !comprlen) || comprlen > maxlen)
		return EG_STATUS_ERR;

	if (comprlen)
	{
		compressed = xmalloc(length);

		if (storage_read(fp, compressed, length) == -1) {
			xfree(compressed);
			return EG_STATUS_ERR;
		}

		if (lzf_decompress(compressed, length, data, comprlen) == 0) {
			xfree(compressed);
			return EG_STATUS_ERR;
		}

		xfree(compressed);
	}
	else
	{
		if (storage_read(fp, data, length) == -1)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf776
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf799
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0xf7a7
cmpl $0x0, -0x20(%rbp)
je 0xf7af
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0xf7bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
cmpl $0x0, -0x20(%rbp)
je 0xf82d
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x5090
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf7f8
movq -0x30(%rbp), %rdi
callq 0x5410
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
callq 0x11450
cmpl $0x0, %eax
jne 0xf822
movq -0x30(%rbp), %rdi
callq 0x5410
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
movq -0x30(%rbp), %rdi
callq 0x5410
jmp 0xf84f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf84d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf856
jmp 0xf84f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_queue_message
static int storage_load_queue_message(FILE *fp, Queue_t *queue_t)
{
	Object *data;
	uint32_t expiration;

	if (storage_read_type(fp) != EG_STORAGE_TYPE_MESSAGE)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &expiration, sizeof(expiration)) == -1)
		return EG_STATUS_ERR;

	if ((data = storage_read_data_object(fp)) == NULL)
		return EG_STATUS_ERR;

	push_message_queue_t(queue_t, data, expiration);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed50
cmpl $0x3, %eax
je 0xf887
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf8da
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xf8a7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf8da
movq -0x10(%rbp), %rdi
callq 0xf8f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xf8c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf8da
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xd150
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/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_read_data_object
static Object *storage_read_data_object(FILE *fp)
{
	uint32_t comprlen;
	uint32_t length;
	void *compressed;
	void *data;

	if (storage_read(fp, &comprlen, sizeof(comprlen)) == -1)
		return NULL;

	if (storage_read(fp, &length, sizeof(length)) == -1)
		return NULL;

	if (comprlen)
	{
		compressed = xmalloc(length);

		if (storage_read(fp, compressed, length) == -1) {
			xfree(compressed);
			return NULL;
		}

		data = xmalloc(comprlen);

		if (lzf_decompress(compressed, length, data, comprlen) == 0) {
			xfree(compressed);
			xfree(data);
			return NULL;
		}

		xfree(compressed);

		return create_object(data, comprlen);
	}
	else
	{
		data = xmalloc(length);

		if (storage_read(fp, data, length) == -1) {
			xfree(data);
			return NULL;
		}

		return create_object(data, length);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf920
movq $0x0, -0x8(%rbp)
jmp 0xfa32
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf944
movq $0x0, -0x8(%rbp)
jmp 0xfa32
cmpl $0x0, -0x14(%rbp)
je 0xf9e8
movl -0x18(%rbp), %eax
movl %eax, %edi
callq 0x5090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xf989
movq -0x20(%rbp), %rdi
callq 0x5410
movq $0x0, -0x8(%rbp)
jmp 0xfa32
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x5090
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x11450
cmpl $0x0, %eax
jne 0xf9cb
movq -0x20(%rbp), %rdi
callq 0x5410
movq -0x28(%rbp), %rdi
callq 0x5410
movq $0x0, -0x8(%rbp)
jmp 0xfa32
movq -0x20(%rbp), %rdi
callq 0x5410
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x6710
movq %rax, -0x8(%rbp)
jmp 0xfa32
movl -0x18(%rbp), %eax
movl %eax, %edi
callq 0x5090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xfa20
movq -0x28(%rbp), %rdi
callq 0x5410
movq $0x0, -0x8(%rbp)
jmp 0xfa32
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x6710
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_route_key
static int storage_load_route_key(FILE *fp, Route_t *route)
{
	char key[32];
	uint32_t queue_size;
	int i;

	if (storage_read_type(fp) != EG_STORAGE_TYPE_ROUTE_KEY)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &key, sizeof(key)) == -1)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &queue_size, sizeof(queue_size)) == -1)
		return EG_STATUS_ERR;

	for (i = 0; i < queue_size; i++)
	{
		if (storage_load_route_key_queues(fp, route, key) != EG_STATUS_OK) {
			return EG_STATUS_ERR;
		}
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed50
cmpl $0x5, %eax
je 0xfa6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfaec
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xfa8a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfaec
movq -0x10(%rbp), %rdi
leaq -0x44(%rbp), %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xfaaa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfaec
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jae 0xfae5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xfb00
cmpl $0x0, %eax
je 0xfad8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfaec
jmp 0xfada
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xfab1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_route_key_queues
static int storage_load_route_key_queues(FILE *fp, Route_t *route, const char *key)
{
	Queue_t *queue_t;
	char name[64];

	if (storage_read_data(fp, &name, sizeof(name)) == -1)
		return EG_STATUS_ERR;

	queue_t = find_queue_t(server->queues, name);
	if (!queue_t)
		return EG_STATUS_OK;

	bind_route_t(route, queue_t, key);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xfb34
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfb7a
leaq 0x7775(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x170(%rax), %rdi
leaq -0x70(%rbp), %rsi
callq 0xd500
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xfb62
movl $0x0, -0x4(%rbp)
jmp 0xfb7a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xde50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_user
static int storage_save_user(FILE *fp, EagleUser *user)
{
	if (storage_write_type(fp, EG_STORAGE_TYPE_USER) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, user->name, strlenz(user->name)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, user->password, strlenz(user->password)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &user->perm, sizeof(user->perm)) == -1)
		return EG_STATUS_ERR;

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0xfc0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcb6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xfc49
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcb6
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x2160
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xfc8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcb6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movl $0x8, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xfcaf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcb6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_write_data
static int storage_write_data(FILE *fp, void *data, uint32_t length)
{
	int err;
	uint32_t comprlen = 0;

	err = storage_write_lzf_data(fp, data, length);

	if (err == -1)
		return EG_STATUS_ERR;

	if (err)
		return EG_STATUS_OK;

	if (storage_write(fp, &comprlen, sizeof(comprlen)) == -1)
		return EG_STATUS_ERR;

	if (storage_write(fp, &length, sizeof(length)) == -1)
		return EG_STATUS_ERR;

	if (storage_write(fp, data, length) == -1)
		return EG_STATUS_ERR;

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xfd80
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0xfcfc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd72
cmpl $0x0, -0x20(%rbp)
je 0xfd0b
movl $0x0, -0x4(%rbp)
jmp 0xfd72
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfd2b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd72
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfd4b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd72
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfd6b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd72
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_write_lzf_data
static int storage_write_lzf_data(FILE *fp, void *data, uint32_t length)
{
	uint32_t comprlen, outlen;
	void *out;

	if (length <= 4)
		return 0;

	outlen = length - 4;
	out = xmalloc(outlen + 1);

	comprlen = lzf_compress(data, length, out, outlen);
	if (comprlen == 0) {
		xfree(out);
		return 0;
	}

	if (storage_write(fp, &length, sizeof(length)) == -1)
		goto error;

	if (storage_write(fp, &comprlen, sizeof(comprlen)) == -1)
		goto error;

	if (storage_write(fp, out, comprlen) == -1)
		goto error;

	xfree(out);

	return 1;

error:
	xfree(out);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
ja 0xfda5
movl $0x0, -0x4(%rbp)
jmp 0xfe5c
movl -0x1c(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5090
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x108f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xfdef
movq -0x30(%rbp), %rdi
callq 0x5410
movl $0x0, -0x4(%rbp)
jmp 0xfe5c
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfe08
jmp 0xfe4c
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfe21
jmp 0xfe4c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xfe3a
jmp 0xfe4c
movq -0x30(%rbp), %rdi
callq 0x5410
movl $0x1, -0x4(%rbp)
jmp 0xfe5c
movq -0x30(%rbp), %rdi
callq 0x5410
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_queue
static int storage_save_queue(FILE *fp, Queue_t *queue_t)
{
	uint32_t queue_size = get_size_queue_t(queue_t);

	if (storage_write_type(fp, EG_STORAGE_TYPE_QUEUE) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, queue_t->name, strlenz(queue_t->name)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &queue_t->max_msg, sizeof(queue_t->max_msg)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &queue_t->max_msg_size, sizeof(queue_t->max_msg_size)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &queue_t->flags, sizeof(queue_t->flags)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &queue_size, sizeof(queue_size)) == -1)
		return EG_STATUS_ERR;

	return storage_save_queue_messages(fp, queue_t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd610
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0xfeab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xfee8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xff0c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x44, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xff30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xff54
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0xff74
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff84
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_queue_messages
static int storage_save_queue_messages(FILE *fp, Queue_t *queue_t)
{
	QueueIterator *iterator;
	QueueNode *node;
	Message *msg;

	iterator = queue_get_iterator(queue_t->queue, EG_START_TAIL);

	while ((node = queue_next_node(iterator)) != NULL)
	{
		msg = EG_QUEUE_NODE_VALUE(node);

		if (storage_save_queue_message(fp, msg) != EG_STATUS_OK) {
			queue_release_iterator(iterator);
			return EG_STATUS_ERR;
		}
	}

	queue_release_iterator(iterator);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movl $0x1, %esi
callq 0xc980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xca00
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xfffb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10020
cmpl $0x0, %eax
je 0xfff9
movq -0x20(%rbp), %rdi
callq 0xc9e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1000b
jmp 0xffb6
movq -0x20(%rbp), %rdi
callq 0xc9e0
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/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_queue_message
static int storage_save_queue_message(FILE *fp, Message *msg)
{
	if (storage_write_type(fp, EG_STORAGE_TYPE_MESSAGE) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &msg->expiration, sizeof(msg->expiration)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, EG_MESSAGE_VALUE(msg), EG_MESSAGE_SIZE(msg)) == -1)
		return EG_STATUS_ERR;

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0x1004c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x100a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x14, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x10070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x100a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x1009e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x100a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_route
static int storage_save_route(FILE *fp, Route_t *route)
{
	uint32_t keys = EG_KEYLIST_LENGTH(route->keys);

	if (storage_write_type(fp, EG_STORAGE_TYPE_ROUTE) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, route->name, strlenz(route->name)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &route->flags, sizeof(route->flags)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &keys, sizeof(keys)) == -1)
		return EG_STATUS_ERR;

	return storage_save_route_keys(fp, route);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0x100ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1017b
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x10127
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1017b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x1014b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1017b
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x1016b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1017b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10190
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_route_keys
static int storage_save_route_keys(FILE *fp, Route_t *route)
{
	KeylistIterator iterator;
	KeylistNode *node;

	keylist_rewind(route->keys, &iterator);
	while ((node = keylist_next_node(&iterator)) != NULL)
	{
		if (storage_save_route_key(fp, EG_KEYLIST_NODE_KEY(node),
			EG_KEYLIST_NODE_VALUE(node)) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xbde0
leaq -0x20(%rbp), %rdi
callq 0xbe00
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x101ed
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x10200
cmpl $0x0, %eax
je 0x101eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x101f4
jmp 0x101b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_route_key
static int storage_save_route_key(FILE *fp, const char *key, List *queues)
{
	uint32_t queue_size = EG_LIST_LENGTH(queues);

	if (storage_write_type(fp, EG_STORAGE_TYPE_ROUTE_KEY) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, (void*)key, strlenz(key)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &queue_size, sizeof(queue_size)) == -1)
		return EG_STATUS_ERR;

	return storage_save_route_key_queues(fp, queues);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0x1023a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102a4
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x10274
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102a4
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x10294
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102a4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x102b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_route_key_queues
static int storage_save_route_key_queues(FILE *fp, List *queues)
{
	ListIterator iterator;
	ListNode *node;
	Queue_t *queue_t;

	list_rewind(queues, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		queue_t = EG_LIST_NODE_VALUE(node);

		if (storage_write_data(fp, queue_t->name, strlenz(queue_t->name)) == -1)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc520
leaq -0x28(%rbp), %rdi
callq 0xc450
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x10328
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2160
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x10326
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1032f
jmp 0x102cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_channel
static int storage_save_channel(FILE *fp, Channel_t *channel)
{
	if (storage_write_type(fp, EG_STORAGE_TYPE_CHANNEL) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, channel->name, strlenz(channel->name)) == -1)
		return EG_STATUS_ERR;

	if (storage_write_data(fp, &channel->flags, sizeof(channel->flags)) == -1)
		return EG_STATUS_ERR;

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0x1036c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x103d1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rax
movl %eax, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x103a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x103d1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xfcc0
cmpl $-0x1, %eax
jne 0x103ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x103d1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/config.c
// Function: parse_on_off
static int parse_on_off(char *value)
{
	int result = 0;

	if (!strcmp(value, "on"))
		result = 1;

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x20e2(%rip), %rsi      # 0x12820
callq 0x2270
cmpl $0x0, %eax
jne 0x1074f
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/config.c
// Function: config_load
int config_load(const char *filename)
{
	char line[512];
	FILE *fp;

	fp = fopen(filename, "r");
	if (!fp)
		return EG_STATUS_ERR;

	while (fgets(line, sizeof(line), fp) != NULL)
	{
		if (parse_config_line(line) != EG_STATUS_OK)
		{
			fclose(fp);
			return EG_STATUS_ERR;
		}
	}

	fclose(fp);

	return EG_STATUS_OK; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20b8(%rip), %rsi      # 0x12832
callq 0x2400
movq %rax, -0x218(%rbp)
cmpq $0x0, -0x218(%rbp)
jne 0x10799
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x107f4
jmp 0x1079b
leaq -0x210(%rbp), %rdi
movq -0x218(%rbp), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x2250
cmpq $0x0, %rax
je 0x107e1
leaq -0x210(%rbp), %rdi
callq 0x10800
cmpl $0x0, %eax
je 0x107df
movq -0x218(%rbp), %rdi
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x107f4
jmp 0x1079b
movq -0x218(%rbp), %rdi
callq 0x2130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/config.c
// Function: parse_config_line
static int parse_config_line(char *line)
{
	char *ptr;
	char *key = NULL;
	char *value = NULL;

	if (line[0] == '#' || line[0] == '\0' || line[0] == '\n')
		return EG_STATUS_OK;

	ptr = strtok(line, "\t\n ");
	while (ptr != NULL)
	{
		if (!key) {
			key = ptr;
		} else if (!value) {
			value = ptr;
		} else {
			return EG_STATUS_ERR;
		}

		ptr = strtok(NULL, "\t\n ");
	}

	if (key && value)
	{
		if (config_parse_key_value(key, value) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	} else {
		return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x10840
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x10840
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1084c
movl $0x0, -0x4(%rbp)
jmp 0x108e5
movq -0x10(%rbp), %rdi
leaq 0x2078(%rip), %rsi      # 0x128cf
callq 0x2420
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x108aa
cmpq $0x0, -0x20(%rbp)
jne 0x10878
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x10894
cmpq $0x0, -0x28(%rbp)
jne 0x10889
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x10892
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108e5
jmp 0x10894
xorl %eax, %eax
movl %eax, %edi
leaq 0x2030(%rip), %rsi      # 0x128cf
callq 0x2420
movq %rax, -0x18(%rbp)
jmp 0x10860
cmpq $0x0, -0x20(%rbp)
je 0x108d5
cmpq $0x0, -0x28(%rbp)
je 0x108d5
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x103e0
cmpl $0x0, %eax
je 0x108d3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108e5
jmp 0x108de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/lock1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		struct flock lck;

		lck.l_type = F_WRLCK;
		lck.l_whence = SEEK_SET;
		lck.l_start = 0;
		lck.l_len = 1;
		assert(fcntl(fd, F_SETLKW, &lck) == 0);

		lck.l_type = F_UNLCK;
		lck.l_whence = SEEK_SET;
		lck.l_start = 0;
		lck.l_len = 1;
		assert(fcntl(fd, F_SETLKW, &lck) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x12a9(%rip), %rax      # 0x32e0
movq %rax, -0x30(%rbp)
movq 0x12a6(%rip), %rax      # 0x32e8
movq %rax, -0x28(%rbp)
movq 0x12a3(%rip), %rax      # 0x32f0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11e0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x2065
jmp 0x2084
leaq 0x120c(%rip), %rdi      # 0x3278
leaq 0x120d(%rip), %rsi      # 0x3280
movl $0xe, %edx
leaq 0x120f(%rip), %rcx      # 0x328e
callq 0x1130
leaq -0x30(%rbp), %rdi
callq 0x1080
movw $0x1, -0x58(%rbp)
movw $0x0, -0x56(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
movl -0x34(%rbp), %edi
movl $0x7, %esi
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x10c0
cmpl $0x0, %eax
jne 0x20c3
jmp 0x20e2
leaq 0x11f7(%rip), %rdi      # 0x32c1
leaq 0x11af(%rip), %rsi      # 0x3280
movl $0x18, %edx
leaq 0x11b1(%rip), %rcx      # 0x328e
callq 0x1130
movw $0x2, -0x58(%rbp)
movw $0x0, -0x56(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
movl -0x34(%rbp), %edi
movl $0x7, %esi
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x10c0
cmpl $0x0, %eax
jne 0x2118
jmp 0x2137
leaq 0x11a2(%rip), %rdi      # 0x32c1
leaq 0x115a(%rip), %rsi      # 0x3280
movl $0x1e, %edx
leaq 0x115c(%rip), %rcx      # 0x328e
callq 0x1130
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x208d
// File: /workspace/github_c_makefile_star2_O0/sadistech[P]nesromtool2/./src/tilec_main.c
// Function: is_in_bank
bool is_in_bank(nrt_chrbank *bank, int bank_size, nrt_tile *tile) {
  int i;
  for (i = 0; i < bank_size; i++) {
    if (memcmp(&(bank->tile[i]), tile, NRT_TILE_SIZE) == 0) {
      // they match!
      last_offset = i;
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x713b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x712e
movl -0x24(%rbp), %eax
movl %eax, 0x58bc(%rip)      # 0xc9e4
movb $0x1, -0x1(%rbp)
jmp 0x713f
jmp 0x7130
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x70e6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/random_read/main.c
// Function: randomread
static int
randomread(struct wire_requestqueue * Q, uint64_t N)
{
	struct randomread_state C;
	uint8_t buf[40];	/* dummy */

	/* Initialize. */
	C.Q = Q;
	C.Nip = 0;
	C.Nmax = N;
	C.failed = 0;
	C.done = 0;

	/* Allocate key structure. */
	memset(buf, 0, 40);
	if ((C.key = kvldskey_create(buf, 40)) == NULL)
		goto err0;

	/* Prepare benchmark time handling. */
	if ((C.B = bench_init(BENCHMARK_START, BENCHMARK_SECONDS)) == NULL) {
		warn0("bench_init");
		goto err1;
	}

	/* Send an initial batch of 4096 requests. */
	if (sendbatch(&C))
		goto err2;

	/* Wait until we've finished. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		goto err2;
	}

	/* Print median number of reads performed in a single second. */
	printf("%" PRIu64 "\n", bench_median(C.B));

	/* Free the key structure. */
	bench_free(C.B);
	kvldskey_free(C.key);

	/* Success! */
	return (0);

err2:
	bench_free(C.B);
err1:
	kvldskey_free(C.key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x21a0
leaq -0x80(%rbp), %rdi
movl $0x28, %esi
callq 0x7630
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2916
jmp 0x29fa
movl $0x32, %edi
movl $0x64, %esi
callq 0x6e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x294f
jmp 0x2931
leaq 0x148b8(%rip), %rdi     # 0x171f0
movb $0x0, %al
callq 0x6c20
callq 0x20a0
movl $0x0, (%rax)
jmp 0x29f1
leaq -0x50(%rbp), %rdi
callq 0x2a10
cmpl $0x0, %eax
je 0x2962
jmp 0x29e8
leaq -0x50(%rbp), %rdi
addq $0x24, %rdi
callq 0x2e60
cmpl $0x0, %eax
jne 0x297a
cmpl $0x0, -0x30(%rbp)
je 0x29b3
jmp 0x297c
callq 0x20a0
cmpl $0x0, (%rax)
je 0x29a1
leaq 0x1486e(%rip), %rdi     # 0x171fb
movb $0x0, %al
callq 0x69d0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x29af
leaq 0x14853(%rip), %rdi     # 0x171fb
movb $0x0, %al
callq 0x6c20
jmp 0x29b1
jmp 0x29e8
movq -0x20(%rbp), %rdi
callq 0x72d0
movq %rax, %rsi
leaq 0x14848(%rip), %rdi     # 0x1720e
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x73f0
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2a01
movq -0x20(%rbp), %rdi
callq 0x73f0
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/random_read/main.c
// Function: sendbatch
static int
sendbatch(struct randomread_state * C)
{
	unsigned long N;
	uint64_t X, Y;

	while (C->Nip < 4096) {
		/* Generate a random key. */
		N = (size_t)random() % C->Nmax;
		X = N >> 16;
		Y = N - (X << 16);
		mkkey(X, Y, C->key->buf);

		/* Send the request. */
		if (proto_kvlds_request_get(C->Q, C->key,
		    callback_get, C))
			goto err0;
		C->Nip += 1;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x10(%rax)     # imm = 0x1000
jae 0x2ab4
callq 0x2220
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x10, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
addq $0x1, %rdx
callq 0x7430
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rcx
leaq 0x3d(%rip), %rdx        # 0x2ad0
callq 0x85f0
cmpl $0x0, %eax
je 0x2a9f
jmp 0x2abd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2a1c
movl $0x0, -0x4(%rbp)
jmp 0x2ac4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/random_read/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, struct kvldskey * value)
{
	struct randomread_state * C = cookie;

	/* This request is no longer in progress. */
	C->Nip -= 1;

	/* Did we fail? */
	if (failed) {
		C->done = 1;
		C->failed = 1;
	}

	/* If we have a value, free it. */
	if (failed == 0)
		kvldskey_free(value);

	/* Notify the benchmarking code, and check if we should quit. */
	if (bench_tick(C->B, &C->done)) {
		warnp("bench_tick");
		goto err0;
	}

	/* Send more requests if possible. */
	if ((!C->done) && sendbatch(C))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x2b17
movq -0x28(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x20(%rax)
cmpl $0x0, -0x14(%rbp)
jne 0x2b26
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x24, %rsi
callq 0x7060
cmpl $0x0, %eax
je 0x2b79
jmp 0x2b42
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2b67
leaq 0x146c0(%rip), %rdi     # 0x17213
movb $0x0, %al
callq 0x69d0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2b75
leaq 0x146a5(%rip), %rdi     # 0x17213
movb $0x0, %al
callq 0x6c20
jmp 0x2b77
jmp 0x2b9c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x2b93
movq -0x28(%rbp), %rdi
callq 0x2a10
cmpl $0x0, %eax
je 0x2b93
jmp 0x2b9c
movl $0x0, -0x4(%rbp)
jmp 0x2ba3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/bench/mkpair.c
// Function: mkkey
void
mkkey(uint64_t X, uint64_t Y, uint8_t * buf)
{
	SHA256_CTX ctx;
	uint8_t hbuf[17];

	/* Store big-endian X. */
	be64enc(&buf[0], X);

	/* Generate \000.X.Y. */
	hbuf[0] = 0;
	be64enc(&hbuf[1], X);
	be64enc(&hbuf[9], Y);

	/* Compute sha256(\000.X.Y). */
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, hbuf, 17);
	SHA256_Final(&buf[8], &ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x74c0
movb $0x0, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rsi
callq 0x74c0
leaq -0xa0(%rbp), %rdi
addq $0x9, %rdi
movq -0x10(%rbp), %rsi
callq 0x74c0
leaq -0x80(%rbp), %rdi
callq 0xab80
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x11, %edx
callq 0xad20
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x80(%rbp), %rsi
callq 0xaef0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/bench/mkpair.c
// Function: mkval
void
mkval(uint64_t X, uint64_t Y, uint8_t * buf)
{
	SHA256_CTX ctx;
	uint8_t hbuf[17];

	/* Store big-endian X * 2^16 + Y. */
	be64enc(&buf[0], (X << 16) + Y);

	/* Generate \001.X.Y. */
	hbuf[0] = 0;
	be64enc(&hbuf[1], X);
	be64enc(&hbuf[9], Y);

	/* Compute sha256(\001.X.Y). */
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, hbuf, 17);
	SHA256_Final(&buf[8], &ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
shlq $0x10, %rsi
addq -0x10(%rbp), %rsi
callq 0x74c0
movb $0x0, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rsi
callq 0x74c0
leaq -0xa0(%rbp), %rdi
addq $0x9, %rdi
movq -0x10(%rbp), %rsi
callq 0x74c0
leaq -0x80(%rbp), %rdi
callq 0xab80
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x11, %edx
callq 0xad20
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x80(%rbp), %rsi
callq 0xaef0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/main.c
// Function: main
int main(int argc, char *argv[])
{
	int i;
	if (argc < 2)
		goto over;
	EXEC = argv[0];
	for (i = 0; i < ARRAYSIZE(cmds); i++) {
		if (strcmp(cmds[i].cmd, argv[1]) == 0) {
			cmds[i].handler(argc-1, &argv[1]);
			break;
		}
	}
	if (i >= ARRAYSIZE(cmds)) {
		over:
		fprintf(stderr, "usage: %s <command> [<args>]\n", argv[0]);
		exit(EINVAL);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x23e1
jmp 0x2468
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xde09(%rip)      # 0x101f8
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jae 0x245c
movslq -0x14(%rbp), %rcx
leaq 0xdd65(%rip), %rax      # 0x10170
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x244f
movslq -0x14(%rbp), %rcx
leaq 0xdd3e(%rip), %rax      # 0x10170
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq *%rax
jmp 0x245c
jmp 0x2451
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23f6
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jb 0x2491
jmp 0x2468
movq 0xdb89(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x9b84(%rip), %rsi      # 0xc004
movb $0x0, %al
callq 0x21a0
movl $0x16, %edi
callq 0x2270
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/main.c
// Function: help
static void
help(int argc, char *argv[])
{
	int i;
	(void)argc;
	(void)argv;
	fprintf(stdout, "sub command list:\n");
	for (i = 0; i < ARRAYSIZE(cmds); i++) {
		fprintf(stdout, "%s\n", cmds[i].cmd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xdb1a(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x9b95(%rip), %rsi      # 0xc055
movb $0x0, %al
callq 0x21a0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jae 0x2510
movq 0xdaf1(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xdc83(%rip), %rax      # 0x10170
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x9cba(%rip), %rsi      # 0xc1b8
movb $0x0, %al
callq 0x21a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x24ce
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/main.c
// Function: history_h
static void
history_h(int argc, char *argv[])
{
	int c, n = 0;
	(void)argc;
	(void)argv;
	while ((c = getopt(argc, argv, "n:?")) != -1) {
		switch (c) {
		case 'n':
			n = strtol(optarg, NULL, 0);
			break;
		case '?':
			exit(EINVAL);
			break;
		}
	}
	history(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x9b04(%rip), %rdx      # 0xc068
callq 0x2250
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x25ae
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x3f, %eax
je 0x25a2
jmp 0x257e
movl -0x1c(%rbp), %eax
subl $0x6e, %eax
jne 0x25ac
jmp 0x2588
movq 0xda49(%rip), %rax      # 0xffd8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21c0
movl %eax, -0x18(%rbp)
jmp 0x25ac
movl $0x16, %edi
callq 0x2270
jmp 0x2556
movl -0x18(%rbp), %edi
callq 0x3440
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/main.c
// Function: list_h
static void
list_h(int argc, char *argv[])
{
	(void)argc;
	(void)argv;
	struct list_args args;
	if (argc < 2) {
		fprintf(stderr, "usage: %s list hash\n", EXEC);
		exit(EINVAL);
	}
	args.hash = dr_newstr(argv[1]);
	list(&args);
	dr_unref(args.hash);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x25fe
movq 0xda1c(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0xdc12(%rip), %rdx      # 0x101f8
leaq 0x9a7f(%rip), %rsi      # 0xc06c
movb $0x0, %al
callq 0x21a0
movl $0x16, %edi
callq 0x2270
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2aa0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4d40
movq -0x18(%rbp), %rdi
callq 0x2ae0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)