LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: create_route_t
Route_t *create_route_t(const char *name, uint32_t flags)
{
	Route_t *route = (Route_t*)xmalloc(sizeof(*route));

	memcpy(route->name, name, strlenz(name));
	route->flags = flags;

	route->auto_delete = 0;
	route->round_robin = 0;

	if (BIT_CHECK(route->flags, EG_ROUTE_AUTODELETE_FLAG)) {
		route->auto_delete = 1;
	}

	if (BIT_CHECK(route->flags, EG_ROUTE_ROUND_ROBIN_FLAG)) {
		route->round_robin = 1;
	}

	route->keys = keylist_create();

	EG_KEYLIST_SET_FREE_METHOD(route->keys, free_route_keylist_handler);
	EG_KEYLIST_SET_MATCH_METHOD(route->keys, match_route_keylist_handler);

	return route;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x58, %edi
callq 0x5090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22c0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xdbe6
movq -0x18(%rbp), %rax
movl $0x1, 0x44(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x2, %rax
cmpq $0x0, %rax
je 0xdc02
movq -0x18(%rbp), %rax
movl $0x1, 0x48(%rax)
callq 0xbc60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
leaq 0x2f(%rip), %rcx        # 0xdc50
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
leaq 0x4c(%rip), %rcx        # 0xdc80
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: unbind_queues_route_t
static void unbind_queues_route_t(Route_t *route)
{
	KeylistIterator iterator;
	KeylistNode *node;

	keylist_rewind(route->keys, &iterator);
	while ((node = keylist_next_node(&iterator)) != NULL)
	{
		unbind_queues_key_route_t(route, EG_KEYLIST_NODE_VALUE(node), EG_KEYLIST_NODE_KEY(node));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0xbde0
leaq -0x10(%rbp), %rdi
callq 0xbe00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdd3b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xe120
jmp 0xdd0d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: push_message_route_t
int push_message_route_t(Route_t *route, const char *key, Object *msg, uint32_t expiration)
{
	KeylistNode *keylist_node;
	ListNode *list_node;
	ListIterator list_iterator;
	List *list;
	Queue_t *queue_t;
	int status = EG_STATUS_OK;

	keylist_node = keylist_get_value(route->keys, (void*)key);
	if (!keylist_node) {
		return EG_STATUS_ERR;
	}

	list = EG_KEYLIST_NODE_VALUE(keylist_node);

	if (route->round_robin)
	{
		list_rotate(list);

		queue_t = EG_LIST_NODE_VALUE(EG_LIST_FIRST(list));

		if (push_message_queue_t(queue_t, msg, expiration) != EG_STATUS_OK)
			status = EG_STATUS_ERR;

		increment_references_count(msg);
	}
	else
	{
		list_rewind(list, &list_iterator);
		while ((list_node = list_next_node(&list_iterator)) != NULL)
		{
			queue_t = EG_LIST_NODE_VALUE(list_node);

			if (push_message_queue_t(queue_t, msg, expiration) != EG_STATUS_OK)
				status = EG_STATUS_ERR;

			increment_references_count(msg);
		}
	}

	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xbd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xdd96
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xde46
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xddeb
movq -0x50(%rbp), %rdi
callq 0xc4a0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xd150
cmpl $0x0, %eax
je 0xdde0
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rdi
callq 0x6800
jmp 0xde40
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc520
leaq -0x48(%rbp), %rdi
callq 0xc450
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xde3e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xd150
cmpl $0x0, %eax
je 0xde33
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rdi
callq 0x6800
jmp 0xddf8
jmp 0xde40
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: bind_route_t
void bind_route_t(Route_t *route, Queue_t *queue_t, const char *key)
{
	List *list;
	KeylistNode *node = keylist_get_value(route->keys, (void*)key);
	int link = 0;

	if (!node)
	{
		list = list_create();
		keylist_set_value(route->keys, xstrdup(key), list);
		link = 1;
	}
	else
	{
		list = EG_KEYLIST_NODE_VALUE(node);
		if (!list_search_node(list, queue_t))
			link = 1;
	}

	if (link)
	{
		list_add_value_tail(list, queue_t);
		link_queue_route_t(queue_t, route, key);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xbd50
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xdebe
callq 0xbfe0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x53c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xbe30
movl $0x1, -0x2c(%rbp)
jmp 0xdee6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc270
cmpq $0x0, %rax
jne 0xdee4
movl $0x1, -0x2c(%rbp)
jmp 0xdee6
cmpl $0x0, -0x2c(%rbp)
je 0xdf0a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc170
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xd7f0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: unbind_route_t
int unbind_route_t(Route_t *route, Queue_t *queue_t, const char *key)
{
	List *list;
	KeylistNode *node = keylist_get_value(route->keys, (void*)key);

	if (!node) {
		return EG_STATUS_ERR;
	}

	list = EG_KEYLIST_NODE_VALUE(node);
	list_delete_value(list, queue_t);

	if (!EG_LIST_LENGTH(list)) {
		keylist_delete_node(route->keys, node);
	}

	unlink_queue_route_t(queue_t, route, key);

	if (route->auto_delete)
	{
		if (EG_KEYLIST_LENGTH(route->keys) == 0) {
			list_delete_value(server->routes, route);
		}
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xbd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xdf4c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdfcc
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc220
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xdf80
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd8a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0xdfc5
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xdfc3
leaq 0x9300(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x178(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc220
jmp 0xdfc5
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/route_t.c
// Function: find_route_t
Route_t *find_route_t(List *list, const char *name)
{
	Route_t *route;
	ListNode *node;
	ListIterator iterator;

	list_rewind(list, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		route = EG_LIST_NODE_VALUE(node);
		if (!strcmp(route->name, name)) {
			return route;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc520
leaq -0x38(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe03a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0xe038
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe042
jmp 0xdffd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: get_queue_number_route_t
uint32_t get_queue_number_route_t(Route_t *route)
{
	KeylistIterator iterator;
	KeylistNode *node;
	List *list;
	uint32_t queues = 0;

	keylist_rewind(route->keys, &iterator);
	while ((node = keylist_next_node(&iterator)) != NULL)
	{
		list = EG_KEYLIST_NODE_VALUE(node);
		queues += EG_LIST_LENGTH(list);
	}

	return queues;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0xbde0
leaq -0x10(%rbp), %rdi
callq 0xbe00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xe0f2
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xe0c4
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/route_t.c
// Function: unbind_queues_key_route_t
static inline void unbind_queues_key_route_t(Route_t *route, List *queues, const char *key)
{
	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);

		unlink_queue_route_t(queue_t, route, key);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc520
leaq -0x28(%rbp), %rdi
callq 0xc450
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe173
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xd8a0
jmp 0xe141
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: create_channel_t
Channel_t *create_channel_t(const char *name, uint32_t flags)
{
	Channel_t *channel = (Channel_t*)xmalloc(sizeof(*channel));

	memcpy(channel->name, name, strlenz(name));
	channel->flags = flags;

	channel->auto_delete = 0;
	channel->round_robin = 0;

	if (BIT_CHECK(channel->flags, EG_CHANNEL_AUTODELETE_FLAG)) {
		channel->auto_delete = 1;
	}

	if (BIT_CHECK(channel->flags, EG_CHANNEL_ROUND_ROBIN_FLAG)) {
		channel->round_robin = 1;
	}

	channel->topics = keylist_create();
	channel->patterns = keylist_create();

	EG_KEYLIST_SET_FREE_METHOD(channel->topics, free_channel_keylist_handler);
	EG_KEYLIST_SET_MATCH_METHOD(channel->topics, match_channel_keylist_handler);

	EG_KEYLIST_SET_FREE_METHOD(channel->patterns, free_channel_keylist_handler);
	EG_KEYLIST_SET_MATCH_METHOD(channel->patterns, match_channel_keylist_handler);

	return channel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x60, %edi
callq 0x5090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22c0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xe206
movq -0x18(%rbp), %rax
movl $0x1, 0x44(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x2, %rax
cmpq $0x0, %rax
je 0xe222
movq -0x18(%rbp), %rax
movl $0x1, 0x48(%rax)
callq 0xbc60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
callq 0xbc60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
leaq 0x4f(%rip), %rcx        # 0xe2a0
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
leaq 0x6c(%rip), %rcx        # 0xe2d0
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
leaq 0x29(%rip), %rcx        # 0xe2a0
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
leaq 0x46(%rip), %rcx        # 0xe2d0
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: delete_channel_t
void delete_channel_t(Channel_t *channel)
{
	eject_clients_channel_t(channel);

	keylist_release(channel->topics);
	keylist_release(channel->patterns);

	xfree(channel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe340
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xbcc0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xbcc0
movq -0x8(%rbp), %rdi
callq 0x5410
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: eject_clients_channel_t
static void eject_clients_channel_t(Channel_t *channel)
{
	ListIterator list_iterator;
	ListNode *list_node;
	KeylistIterator keylist_iterator;
	KeylistNode *keylist_node;
	EagleClient *client;
	List *list;

	keylist_rewind(channel->topics, &keylist_iterator);
	while ((keylist_node = keylist_next_node(&keylist_iterator)) != NULL)
	{
		list = EG_KEYLIST_NODE_VALUE(keylist_node);

		list_rewind(list, &list_iterator);
		while ((list_node = list_next_node(&list_iterator)) != NULL)
		{
			client = EG_LIST_NODE_VALUE(list_node);
			unsubscribe_channel_t(channel, client, EG_KEYLIST_NODE_KEY(keylist_node));
		}
	}

	keylist_rewind(channel->patterns, &keylist_iterator);
	while ((keylist_node = keylist_next_node(&keylist_iterator)) != NULL)
	{
		list = EG_KEYLIST_NODE_VALUE(keylist_node);

		list_rewind(list, &list_iterator);
		while ((list_node = list_next_node(&list_iterator)) != NULL)
		{
			client = EG_LIST_NODE_VALUE(list_node);
			punsubscribe_channel_t(channel, client, EG_KEYLIST_NODE_KEY(keylist_node));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbde0
leaq -0x28(%rbp), %rdi
callq 0xbe00
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe3c1
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc520
leaq -0x18(%rbp), %rdi
callq 0xc450
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe3bf
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xe8e0
jmp 0xe389
jmp 0xe35d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbde0
leaq -0x28(%rbp), %rdi
callq 0xbe00
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe436
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc520
leaq -0x18(%rbp), %rdi
callq 0xc450
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe434
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xea40
jmp 0xe3fe
jmp 0xe3d2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: find_channel_t
Channel_t *find_channel_t(List *list, const char *name)
{
	Channel_t *channel;
	ListNode *node;
	ListIterator iterator;

	list_rewind(list, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		channel = EG_LIST_NODE_VALUE(node);
		if (!strcmp(channel->name, name)) {
			return channel;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc520
leaq -0x38(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe61a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0xe618
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe622
jmp 0xe5dd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: subscribe_channel_t
void subscribe_channel_t(Channel_t *channel, EagleClient *client, const char *topic)
{
	List *list;
	KeylistNode *node = keylist_get_value(channel->topics, (void*)topic);
	int subscribe = 0;

	if (!node)
	{
		list = list_create();
		keylist_set_value(channel->topics, xstrdup(topic), list);
		node = EG_KEYLIST_LAST(channel->topics);
		subscribe = 1;
	}
	else
	{
		list = EG_KEYLIST_NODE_VALUE(node);
		if (!list_search_node(list, client))
			subscribe = 1;
	}

	if (subscribe)
	{
		list_add_value_tail(list, client);
		add_keylist_channel_t(client->subscribed_topics, channel, node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xbd50
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe6fe
callq 0xbfe0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x53c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xbe30
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0xe726
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc270
cmpq $0x0, %rax
jne 0xe724
movl $0x1, -0x2c(%rbp)
jmp 0xe726
cmpl $0x0, -0x2c(%rbp)
je 0xe74e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc170
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xe760
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: add_keylist_channel_t
static void add_keylist_channel_t(Keylist *keylist, Channel_t *channel, KeylistNode *keylist_node)
{
	List *list;
	KeylistNode *node = keylist_get_value(keylist, channel);
	int add = 0;

	if (!node)
	{
		list = list_create();
		keylist_set_value(keylist, channel, list);
		add = 1;
	}
	else
	{
		list = EG_KEYLIST_NODE_VALUE(node);
		if (!list_search_node(list, keylist_node))
			add = 1;
	}

	if (add)
	{
		list_add_value_tail(list, keylist_node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbd50
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe7b6
callq 0xbfe0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbe30
movl $0x1, -0x2c(%rbp)
jmp 0xe7de
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc270
cmpq $0x0, %rax
jne 0xe7dc
movl $0x1, -0x2c(%rbp)
jmp 0xe7de
cmpl $0x0, -0x2c(%rbp)
je 0xe7f1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc170
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: psubscribe_channel_t
void psubscribe_channel_t(Channel_t *channel, EagleClient *client, const char *pattern)
{
	List *list;
	KeylistNode *node = keylist_get_value(channel->patterns, (void*)pattern);
	int subscribe = 0;

	if (!node)
	{
		list = list_create();
		keylist_set_value(channel->patterns, xstrdup(pattern), list);
		node = EG_KEYLIST_LAST(channel->patterns);
		subscribe = 1;
	}
	else
	{
		list = EG_KEYLIST_NODE_VALUE(node);
		if (!list_search_node(list, client))
			subscribe = 1;
	}

	if (subscribe)
	{
		list_add_value_tail(list, client);
		add_keylist_channel_t(client->subscribed_patterns, channel, node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xbd50
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe87e
callq 0xbfe0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x53c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xbe30
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0xe8a6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc270
cmpq $0x0, %rax
jne 0xe8a4
movl $0x1, -0x2c(%rbp)
jmp 0xe8a6
cmpl $0x0, -0x2c(%rbp)
je 0xe8ce
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc170
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xe760
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/channel_t.c
// Function: unsubscribe_channel_t
int unsubscribe_channel_t(Channel_t *channel, EagleClient *client, const char *topic)
{
	List *list;
	KeylistNode *node = keylist_get_value(channel->topics, (void*)topic);

	if (!node) {
		return EG_STATUS_ERR;
	}

	list = EG_KEYLIST_NODE_VALUE(node);

	list_delete_value(list, client);
	remove_keylist_channel_t(client->subscribed_topics, channel, node);

	if (!EG_LIST_LENGTH(list)) {
		keylist_delete_node(channel->topics, node);
	}

	if (channel->auto_delete)
	{
		if (EG_KEYLIST_LENGTH(channel->topics) == 0 &&
			EG_KEYLIST_LENGTH(channel->patterns) == 0) {
			list_delete_value(server->channels, channel);
		}
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xbd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe91c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe9ae
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc220
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xe9c0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xe965
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf30
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0xe9a7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xe9a5
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xe9a5
leaq 0x891e(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x180(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc220
jmp 0xe9a7
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/channel_t.c
// Function: remove_keylist_channel_t
static int remove_keylist_channel_t(Keylist *keylist, Channel_t *channel, KeylistNode *keylist_node)
{
	List *list;
	KeylistNode *node = keylist_get_value(keylist, channel);

	if (!node) {
		return EG_STATUS_ERR;
	}

	list = EG_KEYLIST_NODE_VALUE(node);
	list_delete_value(list, keylist_node);

	if (!EG_LIST_LENGTH(list)) {
		list_release(list);
		keylist_delete_node(keylist, node);
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe9f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xea35
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc220
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xea2e
movq -0x28(%rbp), %rdi
callq 0xc040
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf30
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/channel_t.c
// Function: punsubscribe_channel_t
int punsubscribe_channel_t(Channel_t *channel, EagleClient *client, const char *pattern)
{
	List *list;
	KeylistNode *node = keylist_get_value(channel->patterns, (void*)pattern);

	if (!node) {
		return EG_STATUS_ERR;
	}

	list = EG_KEYLIST_NODE_VALUE(node);

	list_delete_value(list, client);
	remove_keylist_channel_t(client->subscribed_patterns, channel, node);

	if (!EG_LIST_LENGTH(list)) {
		keylist_delete_node(channel->patterns, node);
	}

	if (channel->auto_delete)
	{
		if (EG_KEYLIST_LENGTH(channel->topics) == 0 &&
			EG_KEYLIST_LENGTH(channel->patterns) == 0) {
			list_delete_value(server->channels, channel);
		}
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xbd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xea7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeb0e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc220
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xe9c0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xeac5
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf30
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0xeb07
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xeb05
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xeb05
leaq 0x87be(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x180(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc220
jmp 0xeb07
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/storage.c
// Function: storage_load
int storage_load(const char *filename)
{
	FILE *fp;
	int type;
	int state = 1;

	fp = fopen(filename, "r");
	if (!fp) {
		warning("Failed opening storage for loading: %s",  strerror(errno));
		return EG_STATUS_ERR;
	}

	if (storage_read_magic(fp) != EG_STATUS_OK)
		goto error;

	while (state)
	{
		if ((type = storage_read_type(fp)) == -1)
			goto error;

		switch (type)
		{
			case EG_STORAGE_TYPE_USER:
				if (storage_load_user(fp) != EG_STATUS_OK) goto error;
				break;

			case EG_STORAGE_TYPE_QUEUE:
				if (storage_load_queue(fp) != EG_STATUS_OK) goto error;
				break;

			case EG_STORAGE_TYPE_ROUTE:
				if (storage_load_route(fp) != EG_STATUS_OK) goto error;
				break;

			case EG_STORAGE_TYPE_CHANNEL:
				if (storage_load_channel(fp) != EG_STATUS_OK) goto error;
				break;

			case EG_STORAGE_EOF:
				state = 0;
				break;

			default:
				goto error;
		}
	}

	fclose(fp);

	return EG_STATUS_OK;

error:
	fclose(fp);

	fatal("Error read storage %s", filename);

	return EG_STATUS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3cd4(%rip), %rsi      # 0x12832
callq 0x2400
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xeb97
callq 0x2050
movl (%rax), %edi
callq 0x24c0
movq %rax, %rsi
leaq 0x3b8c(%rip), %rdi      # 0x12710
movb $0x0, %al
callq 0x5840
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec8f
movq -0x18(%rbp), %rdi
callq 0xeca0
cmpl $0x0, %eax
je 0xebaa
jmp 0xec6d
jmp 0xebac
cmpl $0x0, -0x20(%rbp)
je 0xec5b
movq -0x18(%rbp), %rdi
callq 0xed50
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0xebcc
jmp 0xec6d
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xec03
jmp 0xebd9
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xec15
jmp 0xebe3
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0xec27
jmp 0xebed
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0xec39
jmp 0xebf7
movl -0x24(%rbp), %eax
subl $0xff, %eax
je 0xec4b
jmp 0xec54
movq -0x18(%rbp), %rdi
callq 0xed90
cmpl $0x0, %eax
je 0xec13
jmp 0xec6d
jmp 0xec56
movq -0x18(%rbp), %rdi
callq 0xee50
cmpl $0x0, %eax
je 0xec25
jmp 0xec6d
jmp 0xec56
movq -0x18(%rbp), %rdi
callq 0xefc0
cmpl $0x0, %eax
je 0xec37
jmp 0xec6d
jmp 0xec56
movq -0x18(%rbp), %rdi
callq 0xf0c0
cmpl $0x0, %eax
je 0xec49
jmp 0xec6d
jmp 0xec56
movl $0x0, -0x20(%rbp)
jmp 0xec56
jmp 0xec6d
jmp 0xebac
movq -0x18(%rbp), %rdi
callq 0x2130
movl $0x0, -0x4(%rbp)
jmp 0xec8f
movq -0x18(%rbp), %rdi
callq 0x2130
movq -0x10(%rbp), %rsi
leaq 0x3ab6(%rip), %rdi      # 0x12737
movb $0x0, %al
callq 0x5ab0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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_read_magic
static int storage_read_magic(FILE *fp)
{
	char magic[16];
	int version;

	if (storage_read(fp, magic, 11) == -1)
		return EG_STATUS_ERR;

	magic[11] = '\0';

	if (memcmp(magic, "EagleMQ", 7))
	{
		warning("Bad storage signature");
		return EG_STATUS_ERR;
	}

	version = atoi(magic + 7);
	if (version < 1 || version > EG_STORAGE_VERSION) {
		warning("Bad storage version");
		return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xb, %edx
callq 0xf6f0
cmpl $-0x1, %eax
jne 0xeccc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed3b
movb $0x0, -0x15(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x3b16(%rip), %rsi      # 0x127f1
movl $0x7, %edx
callq 0x2240
cmpl $0x0, %eax
je 0xed01
leaq 0x3b08(%rip), %rdi      # 0x127f9
movb $0x0, %al
callq 0x5840
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed3b
leaq -0x20(%rbp), %rdi
addq $0x7, %rdi
callq 0x2460
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0xed1d
cmpl $0x1, -0x24(%rbp)
jle 0xed34
leaq 0x3aeb(%rip), %rdi      # 0x1280f
movb $0x0, %al
callq 0x5840
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed3b
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_load_user
static int storage_load_user(FILE *fp)
{
	EagleUser user;

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

	if (storage_read_data(fp, user.password, sizeof(user.password)) == -1)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &user.perm, sizeof(user.perm)) == -1)
		return EG_STATUS_ERR;

	list_add_value_tail(server->users, create_user(user.name, user.password, user.perm));

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x20, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xedbf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xee44
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x20, %rsi
movl $0x20, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xede3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xee44
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x40, %rsi
movl $0x8, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xee07
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xee44
leaq 0x84a2(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x168(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdx
callq 0xca80
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xc170
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_queue
static int storage_load_queue(FILE *fp)
{
	Queue_t *queue_t;
	Queue_t data;
	uint32_t queue_size;
	int i;

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

	if (storage_read_data(fp, &data.max_msg, sizeof(data.max_msg)) == -1)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &data.max_msg_size, sizeof(data.max_msg_size)) == -1)
		return EG_STATUS_ERR;

	if (storage_read_data(fp, &data.flags, sizeof(data.flags)) == -1)
		return EG_STATUS_ERR;

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

	queue_t = create_queue_t(data.name, data.max_msg, data.max_msg_size, data.flags);

	for (i = 0; i < queue_size; i++)
	{
		if (storage_load_queue_message(fp, queue_t) != EG_STATUS_OK) {
			delete_queue_t(queue_t);
			return EG_STATUS_ERR;
		}
	}

	list_add_value_tail(server->queues, queue_t);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x40, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xee85
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xeeaf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
addq $0x44, %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xeed9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
addq $0x48, %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xef03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
movq -0x10(%rbp), %rdi
leaq -0xac(%rbp), %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xef29
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
leaq -0xa8(%rbp), %rdi
movl -0x68(%rbp), %esi
movl -0x64(%rbp), %edx
movl -0x60(%rbp), %ecx
callq 0xcd50
movq %rax, -0x18(%rbp)
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpl -0xac(%rbp), %eax
jae 0xef91
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf860
cmpl $0x0, %eax
je 0xef7e
movq -0x18(%rbp), %rdi
callq 0xcf60
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xefb2
jmp 0xef80
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0xef4c
leaq 0x8318(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x170(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc170
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_route
static int storage_load_route(FILE *fp)
{
	Route_t *route;
	Route_t data;
	uint32_t keys;
	int i;

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

	if (storage_read_data(fp, &data.flags, sizeof(data.flags)) == -1)
		return EG_STATUS_ERR;

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

	route = create_route_t(data.name, data.flags);

	for (i = 0; i < keys; i++)
	{
		if (storage_load_route_key(fp, route) != EG_STATUS_OK) {
			delete_route_t(route);
			return EG_STATUS_ERR;
		}
	}

	list_add_value_tail(server->routes, route);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xeff2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf0aa
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xf019
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf0aa
movq -0x10(%rbp), %rdi
leaq -0x74(%rbp), %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xf039
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf0aa
leaq -0x70(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0xdb60
movq %rax, -0x18(%rbp)
movl $0x0, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x74(%rbp), %eax
jae 0xf089
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfa40
cmpl $0x0, %eax
je 0xf07c
movq -0x18(%rbp), %rdi
callq 0xdcb0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf0aa
jmp 0xf07e
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0xf050
leaq 0x8220(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x178(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc170
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_load_channel
static int storage_load_channel(FILE *fp)
{
	Channel_t *channel;
	Channel_t data;

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

	if (storage_read_data(fp, &data.flags, sizeof(data.flags)) == -1)
		return EG_STATUS_ERR;

	channel = create_channel_t(data.name, data.flags);

	list_add_value_tail(server->channels, channel);

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x40, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xf0ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf144
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
addq $0x40, %rsi
movl $0x4, %edx
callq 0xf740
cmpl $-0x1, %eax
jne 0xf113
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf144
leaq -0x78(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0xe180
movq %rax, -0x18(%rbp)
leaq 0x8186(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x180(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc170
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save
int storage_save(const char *filename)
{
	FILE *fp;
	char tmpfile[32];

	snprintf(tmpfile, sizeof(tmpfile), "eaglemq-%d.dat", (int)getpid());

	fp = fopen(tmpfile, "w");
	if (!fp) {
		warning("Failed opening storage for saving: %s",  strerror(errno));
		return EG_STATUS_ERR;
	}

	if (storage_write_magic(fp) != EG_STATUS_OK)
		goto error;

	if (storage_save_users(fp) != EG_STATUS_OK)
		goto error;

	if (storage_save_queues(fp) != EG_STATUS_OK)
		goto error;

	if (storage_save_routes(fp) != EG_STATUS_OK)
		goto error;

	if (storage_save_channels(fp) != EG_STATUS_OK)
		goto error;

	if (storage_write_type(fp, EG_STORAGE_EOF) == -1)
		goto error;

	fflush(fp);
	fsync(fileno(fp));
	fclose(fp);

	if (rename(tmpfile, filename) == -1)
	{
		warning("Error rename temp storage file %s to %s: %s", tmpfile, filename, strerror(errno));
		unlink(tmpfile);
		return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;

error:
	warning("Error write data to the storage");

	fclose(fp);
	unlink(tmpfile);

	return EG_STATUS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2110
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl $0x20, %esi
leaq 0x35d2(%rip), %rdx      # 0x1274d
movb $0x0, %al
callq 0x21b0
leaq -0x40(%rbp), %rdi
leaq 0x2ec4(%rip), %rsi      # 0x12051
callq 0x2400
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf1c6
callq 0x2050
movl (%rax), %edi
callq 0x24c0
movq %rax, %rsi
leaq 0x35a9(%rip), %rdi      # 0x1275c
movb $0x0, %al
callq 0x5840
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf2e8
movq -0x18(%rbp), %rdi
callq 0xf300
cmpl $0x0, %eax
je 0xf1d9
jmp 0xf2c1
movq -0x18(%rbp), %rdi
callq 0xf360
cmpl $0x0, %eax
je 0xf1ec
jmp 0xf2c1
movq -0x18(%rbp), %rdi
callq 0xf3f0
cmpl $0x0, %eax
je 0xf1ff
jmp 0xf2c1
movq -0x18(%rbp), %rdi
callq 0xf480
cmpl $0x0, %eax
je 0xf212
jmp 0xf2c1
movq -0x18(%rbp), %rdi
callq 0xf510
cmpl $0x0, %eax
je 0xf225
jmp 0xf2c1
movq -0x18(%rbp), %rdi
movl $0xff, %esi
callq 0xf5a0
cmpl $-0x1, %eax
jne 0xf23d
jmp 0xf2c1
movq -0x18(%rbp), %rdi
callq 0x2340
movq -0x18(%rbp), %rdi
callq 0x22f0
movl %eax, %edi
callq 0x23d0
movq -0x18(%rbp), %rdi
callq 0x2130
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2440
cmpl $-0x1, %eax
jne 0xf2b8
leaq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x24c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x34e3(%rip), %rdi      # 0x12782
movb $0x0, %al
callq 0x5840
leaq -0x40(%rbp), %rdi
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf2e8
movl $0x0, -0x4(%rbp)
jmp 0xf2e8
leaq 0x34e6(%rip), %rdi      # 0x127ae
movb $0x0, %al
callq 0x5840
movq -0x18(%rbp), %rdi
callq 0x2130
leaq -0x40(%rbp), %rdi
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_write_magic
static int storage_write_magic(FILE *fp)
{
	char magic[16];

	snprintf(magic, sizeof(magic), "EagleMQ%04d", EG_STORAGE_VERSION);
	if (storage_write(fp, magic, 11) == -1)
		return EG_STATUS_ERR;

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
leaq 0x3507(%rip), %rdx      # 0x12823
movl $0x1, %ecx
movb $0x0, %al
callq 0x21b0
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xb, %edx
callq 0xfb90
cmpl $-0x1, %eax
jne 0xf348
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf34f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yakushstanislav[P]EagleMQ/src/storage.c
// Function: storage_save_users
static int storage_save_users(FILE *fp)
{
	ListIterator iterator;
	ListNode *node;
	EagleUser *user;

	list_rewind(server->users, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		user = EG_LIST_NODE_VALUE(node);

		if (BIT_CHECK(user->perm, EG_USER_NOT_CHANGE_PERM))
			continue;

		if (storage_save_user(fp, user) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7f3d(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x168(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc520
leaq -0x20(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf3d6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0xf3b9
jmp 0xf386
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfbe0
cmpl $0x0, %eax
je 0xf3d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf3dd
jmp 0xf386
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_queues
static int storage_save_queues(FILE *fp)
{
	ListIterator iterator;
	ListNode *node;
	Queue_t *queue_t;

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

		if (!BIT_CHECK(queue_t->flags, EG_QUEUE_DURABLE_FLAG))
			continue;

		if (storage_save_queue(fp, queue_t) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7ead(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x170(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc520
leaq -0x20(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf465
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x48(%rax), %eax
andq $0x8, %rax
cmpq $0x0, %rax
jne 0xf448
jmp 0xf416
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfe70
cmpl $0x0, %eax
je 0xf463
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf46c
jmp 0xf416
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_routes
static int storage_save_routes(FILE *fp)
{
	ListIterator iterator;
	ListNode *node;
	Route_t *route;

	list_rewind(server->routes, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		route = EG_LIST_NODE_VALUE(node);

		if (!BIT_CHECK(route->flags, EG_ROUTE_DURABLE_FLAG))
			continue;

		if (storage_save_route(fp, route) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7e1d(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x178(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc520
leaq -0x20(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf4f5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x4, %rax
cmpq $0x0, %rax
jne 0xf4d8
jmp 0xf4a6
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x100b0
cmpl $0x0, %eax
je 0xf4f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf4fc
jmp 0xf4a6
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_channels
static int storage_save_channels(FILE *fp)
{
	ListIterator iterator;
	ListNode *node;
	Channel_t *channel;

	list_rewind(server->channels, &iterator);
	while ((node = list_next_node(&iterator)) != NULL)
	{
		channel = EG_LIST_NODE_VALUE(node);

		if (!BIT_CHECK(channel->flags, EG_CHANNEL_DURABLE_FLAG))
			continue;

		if (storage_save_channel(fp, channel) != EG_STATUS_OK)
			return EG_STATUS_ERR;
	}

	return EG_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7d8d(%rip), %rax      # 0x172b0
movq (%rax), %rax
movq 0x180(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc520
leaq -0x20(%rbp), %rdi
callq 0xc450
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf585
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x40(%rax), %eax
andq $0x4, %rax
cmpq $0x0, %rax
jne 0xf568
jmp 0xf536
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10340
cmpl $0x0, %eax
je 0xf583
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf58c
jmp 0xf536
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)