LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TTLIUJJ[P]acker_redis/aefile.cpp
// Function: aeCreateFileEvent(int, int, int)
aeEventLoop *aeCreateFileEvent(int epollfd, int fd, int mask)
{
	aeEventLoop *el = (aeEventLoop *)zmalloc(sizeof(struct aeEventLoop));
	el->rproc = NULL;
	el->wproc = NULL;
	el->epollfd = epollfd;

	if (fd > el->maxfd)
		el->maxfd = fd;
	el->fd = fd;
	el->mask = mask;
	
	return el;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x20, %edi
callq 0x5710
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x5b55
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/aefile.cpp
// Function: fileProcFromNet(aeEventLoop*, redisClient*)
void fileProcFromNet(struct aeEventLoop *el, redisClient *client)
{
	if (!(el->mask & REDIS_READABLE))
		assert(0);
	client->fd = el->fd;
	client->querybuf = (char *)malloc(REDIS_QUERY_CHUNK_BYTES * sizeof(char));
	memset(client->querybuf, 0, REDIS_QUERY_CHUNK_BYTES);
	char query[REDIS_QUERY_CHUNK_BYTES];
	size_t totlen = REDIS_QUERY_CHUNK_BYTES;
	size_t nread = 0;
	
	if((nread = read(el->fd, client->querybuf, REDIS_QUERY_CHUNK_BYTES)) == -1){
		perror("read error:");
		close(el->fd);
		delete_event(el->epollfd, el->fd, EPOLLIN);
	}
	else if(nread == 0){
		fprintf(stderr, "client close.\n");
		close(el->fd);
		delete_event(el->epollfd, el->fd, EPOLLIN);
	}
	else{
		memset(client->querybuf + nread, 0, 1);
		parseQuery(client);
		deduceCommandForQuery(client);
		modify_event(el->epollfd, el->fd, EPOLLOUT);
		free(client->querybuf);
		client->querybuf = NULL;
		el->rproc = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5bc1
leaq 0x1583(%rip), %rdi      # 0x712c
leaq 0x17f9(%rip), %rsi      # 0x73a9
movl $0x24, %edx
leaq 0x17f8(%rip), %rcx      # 0x73b4
callq 0x1100
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x11a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10e0
movq $0x400, -0x418(%rbp) # imm = 0x400
movq $0x0, -0x420(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11d0
movq %rax, -0x420(%rbp)
cmpq $-0x1, %rax
jne 0x5c69
leaq 0x17b3(%rip), %rdi      # 0x73ee
callq 0x1130
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x1240
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %edx
callq 0x5d30
jmp 0x5d1d
cmpq $0x0, -0x420(%rbp)
jne 0x5cb1
movq 0x4366(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x1776(%rip), %rsi      # 0x73fa
movb $0x0, %al
callq 0x11c0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x1240
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %edx
callq 0x5d30
jmp 0x5d1b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10e0
movq -0x10(%rbp), %rdi
callq 0x66f0
movq -0x10(%rbp), %rdi
callq 0x3310
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x4, %edx
callq 0x5d70
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1180
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x5d1d
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/aefile.cpp
// Function: fileProcIntoNet(aeEventLoop*, redisClient*)
void fileProcIntoNet(struct aeEventLoop *el, redisClient *client)
{
	if (!(el->mask & 2))
		assert(0);
		
	client->fd = el->fd;
	size_t nwrite = 0;

	memcpy(client->buf+client->bufpos, "\n", 1);
	++client->bufpos;
	if((nwrite = write(el->fd, client->buf, client->bufpos)) == -1){
		perror("write error: ");
		close(el->fd);
		delete_event(el->epollfd, el->fd, EPOLLOUT);
	}
	else{
		modify_event(el->epollfd, el->fd, EPOLLIN);
		memset(client->buf, 0, client->bufpos);
		client->bufpos = 0;
		el->wproc = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x5dee
leaq 0x1356(%rip), %rdi      # 0x712c
leaq 0x15cc(%rip), %rsi      # 0x73a9
movl $0x46, %edx
leaq 0x1620(%rip), %rcx      # 0x7409
callq 0x1100
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movb 0x15f1(%rip), %dl       # 0x7407
movb %dl, 0x34(%rax,%rcx)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x34, %rsi
movq -0x10(%rbp), %rax
movslq 0x30(%rax), %rdx
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
jne 0x5e7f
leaq 0x15ef(%rip), %rdi      # 0x7443
callq 0x1130
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x1240
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x4, %edx
callq 0x5d30
jmp 0x5ec5
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %edx
callq 0x5d70
movq -0x10(%rbp), %rdi
addq $0x34, %rdi
movq -0x10(%rbp), %rax
movslq 0x30(%rax), %rdx
xorl %esi, %esi
callq 0x10e0
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/db.cpp
// Function: lookupKey(redisDb*, redisObject*)
dictEntry *lookupKey(redisDb *db, robj *key)
{
	dict *d = (dict *)db->dict;
	dictEntry *de = dictFind(d, key);

	if (de == NULL)
		return NULL;
	
	return de;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5f4d
movq $0x0, -0x8(%rbp)
jmp 0x5f55
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/db.cpp
// Function: dbModifyStringVal(redisDb*, void*, void*)
int dbModifyStringVal(redisDb *db, void *key, void *val)
{
	dict *d = db->dict;
	dictEntry *de = dictFind(d, key);
	if (de == NULL) 
		return REDIS_ERR;

	robj *old_val = (robj *)de->val;
	robj *new_val = (robj *)val;
	if (keyStringObjectCompare(NULL, old_val, new_val))
		return REDIS_ERR;

	decrRefCount(old_val);
	de->val = new_val;

	return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5fa0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fef
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x6320
cmpl $0x0, %eax
je 0x5fd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fef
movq -0x38(%rbp), %rdi
callq 0x6610
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: dictStringObjectHashFuction(void const*)
unsigned int dictStringObjectHashFuction(const void *key)
{	
	const char *p = (sds)((robj *)key)->ptr;

	unsigned int hash = (unsigned int)dict_hash_function_seed;
	unsigned len = strlen(p);
	while (len--) {
		hash = ((hash << 5) + hash) + (tolower(*p++));
	}

	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x3f4a(%rip), %eax      # 0xa1a8
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x62ac
movl -0x14(%rbp), %eax
shll $0x5, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x11e0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x626d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: stringObjectDup(void*, void const*)
void *stringObjectDup(void *pirvdata, const void *key)
{
	assert(((robj *)key)->type == REDIS_STRING);
	
	char *s = (char *)(((robj *)key)->ptr);
	robj *k = createStringObject(s);

	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x62db
jmp 0x62fa
leaq 0x1234(%rip), %rdi      # 0x7516
leaq 0x1182(%rip), %rsi      # 0x746b
movl $0x8b, %edx
leaq 0x1245(%rip), %rcx      # 0x753a
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: keyStringObjectCompare(void*, void const*, void const*)
int keyStringObjectCompare(void *privdata, const void *key1, const void *key2)
{
	//if (key1 == NULL || key2 == NULL)
	//	return 0;

	sds k1 = (sds)((robj *)key1)->ptr;
	sds k2 = (sds)((robj *)key2)->ptr;
	int cmp;
	int len1 = sdslen(k1);
	int len2 = sdslen(k2);
	if (len1 != len2)
		return 0;
	
	cmp = memcmp(k1, k2, len1);
	
	return cmp ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66d0
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x66d0
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
je 0x6375
movl $0x0, -0x4(%rbp)
jmp 0x639c
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x38(%rbp), %rdx
callq 0x10c0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: createObject(int, void*)
robj *createObject(int type, void *ptr)
{
	robj *o = (robj *)zmalloc(sizeof(robj));
	o->type = type;
	o->ptr = ptr;
	o->refcount = 1;

	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x5710
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: createListObject()
robj *createListObject()
{
	list *l = listCreate();
	robj *o = createObject(REDIS_LIST, l);
	listSetFreeMethod(l, decrRefCountVoid);

	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1380
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x63d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x12(%rip), %rcx        # 0x6490
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: freeStringObject(void*)
void freeStringObject(void *o) 
{
	robj *val = (robj *)o;
	assert(val->type == REDIS_STRING);
	sdsFree((sds)val->ptr);
	zfree(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x650f
jmp 0x652e
leaq 0xf3b(%rip), %rdi       # 0x7451
leaq 0xf4e(%rip), %rsi       # 0x746b
movl $0x32, %edx
leaq 0xf4d(%rip), %rcx       # 0x7476
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5430
movq -0x10(%rbp), %rdi
callq 0x5a10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: freeListObject(void*)
void freeListObject(void *o)
{
	robj *val = (robj *)o;
	assert(val->type == REDIS_LIST);
	listRelease((list *)val->ptr);
	zfree(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x656f
jmp 0x658e
leaq 0xf1e(%rip), %rdi       # 0x7494
leaq 0xeee(%rip), %rsi       # 0x746b
movl $0x3a, %edx
leaq 0xf23(%rip), %rcx       # 0x74ac
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x18c0
movq -0x10(%rbp), %rdi
callq 0x5a10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: freeHashObject(void*)
void freeHashObject(void *o)
{
	robj *val = (robj *)o;
	assert(val->type == REDIS_HASH);
	dictRelease((dict *)val->ptr);
	zfree(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x65cf
jmp 0x65ee
leaq 0xef2(%rip), %rdi       # 0x74c8
leaq 0xe8e(%rip), %rsi       # 0x746b
movl $0x42, %edx
leaq 0xef7(%rip), %rcx       # 0x74e0
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44d0
movq -0x10(%rbp), %rdi
callq 0x5a10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/object.cpp
// Function: decrRefCount(redisObject*)
void decrRefCount(robj *o)
{
	
	if (o->refcount > 1) {
		--o->refcount;
	}
	else if (o->refcount == 1) {
		switch (o->type) {
		case REDIS_STRING:
			freeStringObject(o);
			break;
		case REDIS_LIST:
			freeListObject(o);
			break;
		case REDIS_HASH:
			freeHashObject(o);
			break;
		default:
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jle 0x6635
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x66a7
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x66a5
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x6663
jmp 0x664f
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x666e
jmp 0x6659
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x6679
jmp 0x6684
movq -0x8(%rbp), %rdi
callq 0x64f0
jmp 0x66a3
movq -0x8(%rbp), %rdi
callq 0x6550
jmp 0x66a3
movq -0x8(%rbp), %rdi
callq 0x65b0
jmp 0x66a3
leaq 0xaa1(%rip), %rdi       # 0x712c
leaq 0xdd9(%rip), %rsi       # 0x746b
movl $0x59, %edx
leaq 0xe5e(%rip), %rcx       # 0x74fc
callq 0x1100
jmp 0x66a5
jmp 0x66a7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/redis.cpp
// Function: parseQuery(redisClient*)
void parseQuery(redisClient *client)
{
	size_t pos = 0;
	int argc = 0;
	int i = 0;
	size_t diff;
	size_t buflen = strlen(client->querybuf);
	//as far as I known, it will receive the 127 ASCII at first correspondence, so the 10 and ASCII must be deleted 	
	//and the last correspondence we just exclude the 10 ASCII
	//and it may be includes other situations beyond i known.
	//so in the loop more charcters are comsidered.
	char *p = client->querybuf + buflen;
	for(i = 1; i < 10; ++i){
		--p;
		if(*p == '\n')
			break;
	}
	buflen -= i;
	memset(client->querybuf + buflen, 0, 1);
	while (pos < buflen) {
		char *p = strchr(client->querybuf + pos, ' ');
		robj *o;
	
		if (p == NULL) {
			diff = buflen - pos;
			o = parseQueryObject(client->querybuf, &pos, diff);
		}
		else {
			diff = p - (client->querybuf + pos);
			if (diff == 0) {
				++pos;
				continue;
			}
			o = parseQueryObject(client->querybuf, &pos, diff);
			//for skip ' '
			++pos;
		}
		client->argv[argc] = o;
		++argc;
	}
	client->argc = argc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x6767
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x675a
jmp 0x6767
jmp 0x675c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x673a
movslq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10e0
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x685a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x1090
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x67e4
movq -0x28(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq -0x10(%rbp), %rsi
callq 0x6870
movq %rax, -0x40(%rbp)
jmp 0x6838
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6813
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x678e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq -0x10(%rbp), %rsi
callq 0x6870
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x678e
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/redis.cpp
// Function: parseQueryObject(char*, unsigned long*, unsigned long)
static robj* parseQueryObject(char *buf, size_t *pos, size_t slen)
{
	char query[MAXQUERY];
	memcpy(query, buf + *pos, slen);
	query[slen] = '\0';
	*pos += slen;
	robj *o = createStringObject(query);

	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
addq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1120
movq -0x18(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
leaq -0x420(%rbp), %rdi
callq 0x6420
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/redis.cpp
// Function: initRedisClient()
redisClient *initRedisClient()
{
	redisClient *client = (redisClient *)zmalloc(sizeof(struct redisClient));
	redisCommand *cmd = (redisCommand *)zmalloc(sizeof(struct redisCommand));
	redisDb *db = (redisDb *)zmalloc(sizeof(struct redisDb));
	dict *d = dictCreate(&dictObjectType, NULL);
	db->dict = d;
	client->db = db;
	
	client->fd = -1;
	client->argv = (robj **)zmalloc(MAXQUERYARGC * sizeof(robj *));
	client->argc = 0;
	client->cmd = NULL;
	client->querybuf = NULL;
	client->bufpos = 0;
	memset(client->buf, 0, REDIS_REPLY_CHUNK_BYTES);

	return client;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x4038, %edi           # imm = 0x4038
callq 0x5710
movq %rax, -0x8(%rbp)
movl $0x18, %edi
callq 0x5710
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x5710
movq %rax, -0x18(%rbp)
leaq 0x385f(%rip), %rdi      # 0xa178
xorl %eax, %eax
movl %eax, %esi
callq 0x3be0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x400, %edi            # imm = 0x400
callq 0x5710
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x10e0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/main.cpp
// Function: main
int main(int argc,char *argv[])
{
	
	
    int  listenfd;
    listenfd = socket_bind(IPADDRESS,PORT);
    listen(listenfd,LISTENQ);
    do_epoll(listenfd);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xb99(%rip), %rdi       # 0x7566
movl $0x2253, %esi           # imm = 0x2253
callq 0x6a00
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x5, %esi
callq 0x1150
movl -0x14(%rbp), %edi
callq 0x6ab0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/main.cpp
// Function: socket_bind(char const*, int)
static int socket_bind(const char* ip,int port)
{
    int  listenfd;
    struct sockaddr_in servaddr;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    if (listenfd == -1)
    {
        perror("socket error:");
        exit(1);
    }
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&servaddr.sin_addr);
    servaddr.sin_port = htons(port);
    if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
    {
        perror("bind error: ");
        exit(1);
    }
    return listenfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1060
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x6a3f
leaq 0xb40(%rip), %rdi       # 0x7570
callq 0x1130
movl $0x1, %edi
callq 0x1190
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10e0
movw $0x2, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x1220
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x1040
movw %ax, -0x1e(%rbp)
movl -0x10(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1050
cmpl $-0x1, %eax
jne 0x6aa6
leaq 0xae7(%rip), %rdi       # 0x757e
callq 0x1130
movl $0x1, %edi
callq 0x1190
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/main.cpp
// Function: do_epoll(int)
static void do_epoll(int listenfd)
{
    int epollfd;
    struct epoll_event events[EPOLLEVENTS];
    int ret;
    char buf[MAXSIZE];
    memset(buf,0,MAXSIZE);
    //创建一个描述符
    epollfd = epoll_create(FDSIZE);
    //添加监听描述符事件
    append_event(epollfd,listenfd,EPOLLIN);
	redisClient *client = initRedisClient(); 
    for ( ; ; )
    {
        //获取已经准备好的描述符事件
        ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
        handle_events(epollfd,events,ret,listenfd,buf, client);
		
		dict *d = client->db->dict;
		dictIterator *iter = dictGetSafeIterator(d);
		dictEntry *de;
    }
    close(epollfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movl %edi, -0x4(%rbp)
leaq -0x8d0(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10e0
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1210
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
movl $0x1, %edx
callq 0x5ed0
callq 0x68e0
movq %rax, -0x8d8(%rbp)
movl -0x8(%rbp), %edi
leaq -0x4c0(%rbp), %rsi
movl $0x64, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10d0
movl %eax, -0x4c4(%rbp)
movl -0x8(%rbp), %edi
leaq -0x4c0(%rbp), %rsi
movl -0x4c4(%rbp), %edx
movl -0x4(%rbp), %ecx
leaq -0x8d0(%rbp), %r8
movq -0x8d8(%rbp), %r9
callq 0x6b70
movq -0x8d8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8e0(%rbp)
movq -0x8e0(%rbp), %rdi
callq 0x3f60
movq %rax, -0x8e8(%rbp)
jmp 0x6afa
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/main.cpp
// Function: handle_events(int, epoll_event*, int, int, char*, redisClient*)
static void
handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf,redisClient *client)
{
    int i;
    int fd;
    //进行选好遍历
	aeEventLoop *el = aeCreateFileEvent(epollfd, 0, 0);
    for (i = 0;i < num;i++)
    {
        fd = events[i].data.fd;
        //根据描述符的类型和事件类型进行处理
		el->fd = fd;
        if ((fd == listenfd) &&(events[i].events & EPOLLIN))
            handle_accpet(epollfd,listenfd);
        else if (events[i].events & EPOLLIN){
			el->mask = 1;
			fileProcFromNet(el, client);
		}
        else if (events[i].events & EPOLLOUT){
			el->mask = 2;
            fileProcIntoNet(el, client);
		}
    }
		zfree(el);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x4(%rbp), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x5b00
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6c75
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x6bfd
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6bfd
movl -0x4(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x6c90
jmp 0x6c65
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6c30
movq -0x38(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5b80
jmp 0x6c63
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6c61
movq -0x38(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5db0
jmp 0x6c63
jmp 0x6c65
jmp 0x6c67
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ba4
movq -0x38(%rbp), %rdi
callq 0x5a10
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/main.cpp
// Function: handle_accpet(int, int)
static void handle_accpet(int epollfd,int listenfd)
{
    int clifd;
    struct sockaddr_in cliaddr;
    socklen_t  cliaddrlen;
    clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen);
    if (clifd == -1)
        perror("accpet error:");
    else
    {
        printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
        //添加一个客户描述符和事件
        append_event(epollfd,clifd,EPOLLIN);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1070
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x6cc5
leaq 0x8cd(%rip), %rdi       # 0x758b
callq 0x1130
jmp 0x6cf8
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x10b0
movq %rax, %rsi
movzwl -0x1a(%rbp), %edx
leaq 0x8b8(%rip), %rdi       # 0x7599
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x5ed0
addq $0x30, %rsp
popq %rbp
retq
// File: nompelis[P]INTecplotLib/utils.c
// Function: inUtils_TrimLeadingSpaceTextline
int inUtils_TrimLeadingSpaceTextline( char *buf )
{
   size_t i,ie=0,is=0;


   if( buf == NULL ) return(1);

   while( buf[is] == ' ' ) ++is;
   while( buf[ie] != '\0' ) ++ie;

   if( is == 0 ) return(0);

   for(i=0;i<ie-is;++i) {
      buf[i] = buf[i+is];
      buf[i+is] = '\0';
   }

   return(0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x130c
movl $0x1, -0x4(%rsp)
jmp 0x13cf
jmp 0x130e
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x1331
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x130e
jmp 0x1333
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1356
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1333
cmpq $0x0, -0x28(%rsp)
jne 0x1368
movl $0x0, -0x4(%rsp)
jmp 0x13cf
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
subq -0x28(%rsp), %rcx
cmpq %rcx, %rax
jae 0x13c7
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
addq -0x28(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
addq -0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x1371
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: printUnexpectedArgumentsMessage()
void printUnexpectedArgumentsMessage() {
    std::cout << RED;  //Color rojo
    std::cout << "Error, demasiados argumetos." << std::endl;
    std::cout << "El uso adecuado es: \"sudo ./Project_Hex.out <infoFile.txt>\"" << std::endl;
    std::cout << RESET;  //Reset de formato de letra (color, negrita,..)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x6aa5(%rip), %rdi      # 0x9fd0
leaq 0x3ad2(%rip), %rsi      # 0x7004
callq 0x31f0
movq 0x6a92(%rip), %rdi      # 0x9fd0
leaq 0x3ac7(%rip), %rsi      # 0x700c
callq 0x31f0
movq %rax, %rdi
movq 0x6a6c(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x6a70(%rip), %rdi      # 0x9fd0
leaq 0x3ac2(%rip), %rsi      # 0x7029
callq 0x31f0
movq %rax, %rdi
movq 0x6a4a(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x6a4e(%rip), %rdi      # 0x9fd0
leaq 0x3adc(%rip), %rsi      # 0x7065
callq 0x31f0
popq %rbp
retq
// File: AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: getFileInfoName[abi:cxx11](int, char**)
string getFileInfoName(int argc, char* argv[]) {
    if (argc > 2) {
        printUnexpectedArgumentsMessage();
        exit(-1);
    }
    if (argc == 2) {
        std::cerr << "info" << std::endl;

        return argv[1];
    }
    std::cerr << "info" << std::endl;

    return "info.txt";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x2, -0xc(%rbp)
jle 0x35c3
callq 0x3520
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3270
cmpl $0x2, -0xc(%rbp)
jne 0x3639
movq 0x6a20(%rip), %rdi      # 0x9ff0
leaq 0x3a93(%rip), %rsi      # 0x706a
callq 0x31f0
movq %rax, %rdi
movq 0x69da(%rip), %rsi      # 0x9fc0
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x3780
jmp 0x3617
leaq -0x19(%rbp), %rdi
callq 0x3240
jmp 0x36a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x3240
jmp 0x36aa
movq 0x69b0(%rip), %rdi      # 0x9ff0
leaq 0x3a23(%rip), %rsi      # 0x706a
callq 0x31f0
movq %rax, %rdi
movq 0x696a(%rip), %rsi      # 0x9fc0
callq 0x3220
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x39f8(%rip), %rsi      # 0x706f
callq 0x3780
jmp 0x367e
leaq -0x2d(%rbp), %rdi
callq 0x3240
jmp 0x36a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x3240
jmp 0x36aa
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
// File: AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: main
int main(int argc, char* argv[]) {
    string infoFileName = getFileInfoName(argc, argv);
    std::cout << infoFileName << std::endl;

    changeIconsFromFileController changeIconsFromFileController;
    changeIconsFromFileController.changeIconsFromFile(infoFileName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3590
movq -0x70(%rbp), %rsi
movq 0x68e2(%rip), %rdi      # 0x9fd0
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x36f9
movq -0x68(%rbp), %rdi
movq 0x68bc(%rip), %rsi      # 0x9fc0
callq 0x3220
jmp 0x370b
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x30d0
jmp 0x371a
leaq -0x3d(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3830
jmp 0x3729
leaq -0x60(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3766
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
movq -0x38(%rbp), %rdi
callq 0x3350
nopl (%rax,%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/changeIconsFromFileController.cc
// Function: changeIconsFromFileController::changeIconsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void changeIconsFromFile(string infoFileName) {
        printWelcomeMessage();

        NativeFileReaderMapper fileReaderMapper;
        vector<App> apps = (fileReaderMapper.mapFileToApps(infoFileName));

        NativeIconChanger iconChanger;

        for (std::vector<App>::iterator iterator = apps.begin(); iterator != apps.end(); ++iterator) {
            printChangingIconMessage(iterator->getSettingFileName());

            iconChanger.changeIconOf(iterator->getSettingFileName(), iterator->getNewIconName());
            printOKMessage();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x130(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x3a80
leaq -0x18(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x3b30
movq -0x130(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x30d0
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3b70
jmp 0x389a
leaq -0x50(%rbp), %rdi
callq 0x3140
leaq -0xa8(%rbp), %rdi
callq 0x3e60
jmp 0x38b1
leaq -0x30(%rbp), %rdi
callq 0x3f40
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3fb0
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3f70
testb $0x1, %al
jne 0x38ed
jmp 0x3a41
leaq -0xb0(%rbp), %rdi
callq 0x4040
movq %rax, %rsi
leaq -0xd8(%rbp), %rdi
callq 0x4060
jmp 0x390a
movq -0x138(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3fe0
jmp 0x391f
leaq -0xd8(%rbp), %rdi
callq 0x3140
leaq -0xb0(%rbp), %rdi
callq 0x4040
movq %rax, %rsi
leaq -0xf8(%rbp), %rdi
callq 0x4060
jmp 0x3948
leaq -0xb0(%rbp), %rdi
callq 0x4040
movq %rax, %rsi
leaq -0x118(%rbp), %rdi
callq 0x41a0
jmp 0x3965
leaq -0xa8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0x4090
jmp 0x3981
leaq -0x118(%rbp), %rdi
callq 0x3140
leaq -0xf8(%rbp), %rdi
callq 0x3140
movq -0x138(%rbp), %rdi
callq 0x41d0
jmp 0x39a7
jmp 0x39a9
leaq -0xb0(%rbp), %rdi
callq 0x4230
jmp 0x38c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3140
jmp 0x3a74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3a6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x3140
jmp 0x3a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3a33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3140
leaq -0xf8(%rbp), %rdi
callq 0x3140
jmp 0x3a5f
leaq -0xa8(%rbp), %rdi
callq 0x4250
leaq -0x30(%rbp), %rdi
callq 0x4290
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
leaq -0xa8(%rbp), %rdi
callq 0x4250
leaq -0x30(%rbp), %rdi
callq 0x4290
movq -0x58(%rbp), %rdi
callq 0x3350
nopl (%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/changeIconsFromFileController.cc
// Function: changeIconsFromFileController::printWelcomeMessage()
void printWelcomeMessage() {
        std::cout << CLEAR;  //hace un clear pero mas bonito
        std::cout << std::endl;
        std::cout << UBLUE;  //Color azul
        std::cout << "\t"
                  << "Project_Hex" << std::endl;
        std::cout << RESET;  //Reset de formato de letra (color, negrita,..)
        std::cout << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x653d(%rip), %rdi      # 0x9fd0
leaq 0x35de(%rip), %rsi      # 0x7078
callq 0x31f0
movq 0x652a(%rip), %rdi      # 0x9fd0
movq 0x6513(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x6517(%rip), %rdi      # 0x9fd0
leaq 0x35bd(%rip), %rsi      # 0x707d
callq 0x31f0
movq 0x6504(%rip), %rdi      # 0x9fd0
leaq 0x35b2(%rip), %rsi      # 0x7085
callq 0x31f0
movq %rax, %rdi
leaq 0x35a5(%rip), %rsi      # 0x7087
callq 0x31f0
movq %rax, %rdi
movq 0x64cf(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x64d3(%rip), %rdi      # 0x9fd0
leaq 0x3561(%rip), %rsi      # 0x7065
callq 0x31f0
movq 0x64c0(%rip), %rdi      # 0x9fd0
movq 0x64a9(%rip), %rsi      # 0x9fc0
callq 0x3220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/fileReaderMapper.cc
// Function: NativeFileReaderMapper::openFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ifstream openFile(string fileNameInfo) {
        ifstream fileInfo(fileNameInfo);
        if (!fileInfo) {
            printErrorOpeningInfoFileMessage();
            exit(-1);
        }

        return fileInfo;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rdi, -0x38(%rbp)
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x8, %edx
callq 0x3330
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x30f0
movb %al, -0x2d(%rbp)
jmp 0x43a8
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x43b1
jmp 0x43dd
movq -0x40(%rbp), %rdi
callq 0x45b0
jmp 0x43bc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3270
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3080
jmp 0x43fa
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x43f0
movq -0x38(%rbp), %rdi
callq 0x3080
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::openFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ifstream openFile(string infoFileName) {
        ifstream infoFile(infoFileName);
        if (!infoFile) {
            printErrorOpeningInfoFileMessage();
            exit(-1);
        }

        return infoFile;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rdi, -0x38(%rbp)
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x8, %edx
callq 0x3330
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x30f0
movb %al, -0x2d(%rbp)
jmp 0x57c8
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x57d1
jmp 0x57fd
movq -0x40(%rbp), %rdi
callq 0x5b70
jmp 0x57dc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3270
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3080
jmp 0x581a
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5810
movq -0x38(%rbp), %rdi
callq 0x3080
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::printErrorOpeningAppFileMessage()
void printErrorOpeningAppFileMessage() {
        std::cout << RED;  //Color rojo
        std::cout << "Error al abrir el archivo de la app" << std::endl;
        std::cout << "Compruebe que haya asignado privilegios al programa" << std::endl;
        std::cout << RESET;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x459d(%rip), %rdi      # 0x9fd0
leaq 0x15ca(%rip), %rsi      # 0x7004
callq 0x31f0
movq 0x458a(%rip), %rdi      # 0x9fd0
leaq 0x16be(%rip), %rsi      # 0x710b
callq 0x31f0
movq %rax, %rdi
movq 0x4564(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x4568(%rip), %rdi      # 0x9fd0
leaq 0x16c0(%rip), %rsi      # 0x712f
callq 0x31f0
movq %rax, %rdi
movq 0x4542(%rip), %rsi      # 0x9fc0
callq 0x3220
movq 0x4546(%rip), %rdi      # 0x9fd0
leaq 0x15d4(%rip), %rsi      # 0x7065
callq 0x31f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::getIconFolderPath[abi:cxx11]()
string getIconFolderPath() {
        char cwd[PATH_MAX];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
            string executionPath(cwd);           //Paso de char* a string con el constructor de string
            return (executionPath + "/icons/");  //ruta donde se esta ejecutando el programa
        } else {
            printErrorGettingExecutionPathMessage();
            return "error";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1070, %rsp           # imm = 0x1070
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1050(%rbp)
leaq -0x1010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3100
cmpq $0x0, %rax
je 0x5d15
leaq -0x1031(%rbp), %rdi
movq %rdi, -0x1068(%rbp)
callq 0x3360
movq -0x1068(%rbp), %rdx
leaq -0x1030(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x3780
jmp 0x5c99
leaq -0x1031(%rbp), %rdi
callq 0x3240
movq -0x1060(%rbp), %rdi
leaq 0x14b0(%rip), %rdx      # 0x7163
leaq -0x1030(%rbp), %rsi
callq 0x5da0
jmp 0x5cc1
leaq -0x1030(%rbp), %rdi
callq 0x3140
jmp 0x5d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1040(%rbp)
movl %eax, -0x1044(%rbp)
leaq -0x1031(%rbp), %rdi
callq 0x3240
jmp 0x5d8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1040(%rbp)
movl %eax, -0x1044(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x3140
jmp 0x5d8e
movq -0x1050(%rbp), %rdi
callq 0x5e20
leaq -0x1045(%rbp), %rdi
movq %rdi, -0x1070(%rbp)
callq 0x3360
movq -0x1060(%rbp), %rdi
movq -0x1070(%rbp), %rdx
leaq 0x142b(%rip), %rsi      # 0x7174
callq 0x3780
jmp 0x5d50
leaq -0x1045(%rbp), %rdi
callq 0x3240
jmp 0x5d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1040(%rbp)
movl %eax, -0x1044(%rbp)
leaq -0x1045(%rbp), %rdi
callq 0x3240
jmp 0x5d8e
movq -0x1058(%rbp), %rax
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
movq -0x1040(%rbp), %rdi
callq 0x3350
nopw (%rax,%rax)
// File: Agusyc[P]CTRPG/src/battle.cpp
// Function: Battle::showMenu()
int Battle::showMenu() {
    cout << "1. Attack" << endl << "2. Defend" << endl << "3. Item" << endl << "4. Flee" << endl << "HP: " << GREEN << player.hp << WHITE << " | Mana: " << GREEN << player.mana << WHITE << endl << "Your choice: ";

    int choice;
    cin >> choice;

    cout << endl;

    return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x13bb5(%rip), %rdi     # 0x17fd0
leaq 0xccc4(%rip), %rsi      # 0x110e6
callq 0x3290
movq %rax, %rdi
movq 0x13b8f(%rip), %rsi     # 0x17fc0
callq 0x32b0
movq %rax, %rdi
leaq 0xccb0(%rip), %rsi      # 0x110f0
callq 0x3290
movq %rax, %rdi
movq 0x13b71(%rip), %rsi     # 0x17fc0
callq 0x32b0
movq %rax, %rdi
leaq 0xcc9c(%rip), %rsi      # 0x110fa
callq 0x3290
movq %rax, %rdi
movq 0x13b53(%rip), %rsi     # 0x17fc0
callq 0x32b0
movq %rax, %rdi
leaq 0xcc86(%rip), %rsi      # 0x11102
callq 0x3290
movq %rax, %rdi
movq 0x13b35(%rip), %rsi     # 0x17fc0
callq 0x32b0
movq %rax, %rdi
leaq 0xcc70(%rip), %rsi      # 0x1110a
callq 0x3290
movq %rax, %rdi
leaq 0xcc66(%rip), %rsi      # 0x1110f
callq 0x3290
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcb75(%rip), %rsi      # 0x1103c
callq 0x3290
movq %rax, %rdi
leaq 0xcc3f(%rip), %rsi      # 0x11115
callq 0x3290
movq %rax, %rdi
leaq 0xcc2a(%rip), %rsi      # 0x1110f
callq 0x3290
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcb39(%rip), %rsi      # 0x1103c
callq 0x3290
movq %rax, %rdi
movq 0x13aae(%rip), %rsi     # 0x17fc0
callq 0x32b0
movq %rax, %rdi
leaq 0xcbfe(%rip), %rsi      # 0x1111f
callq 0x3290
movq 0x13ab3(%rip), %rdi     # 0x17fe0
leaq -0xc(%rbp), %rsi
callq 0x31a0
movq 0x13a93(%rip), %rdi     # 0x17fd0
movq 0x13a7c(%rip), %rsi     # 0x17fc0
callq 0x32b0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)