LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TTLIUJJ[P]acker_redis/adlist.cpp
// Function: listRelease(list*)
void listRelease(list *l)
{
	listNode *next, *cur;
	unsigned long len;

	if (l == NULL)
		return;
	cur = l->head;
	len = l->len;
	while (len--) {
		next = cur->next;
		if (l->free)
			l->free(cur->value);
		zfree(cur);
		cur = next;
	}
	zfree(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x18d5
jmp 0x1946
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x193d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x192a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x5a10
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x18ec
movq -0x8(%rbp), %rdi
callq 0x5a10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/adlist.cpp
// Function: listmatchsds(void*, void*)
int listmatchsds(void *key1, void *key2)
{
	int cmp;
	char *k1 = (char *)key1;
	char *k2 = (char *)key2;

	int len1 = strlen(k1);
	int len2 = strlen(k2);
	if (len1 != len2)
		return 0;

	cmp = memcmp(k1, k2, len1);
	if (cmp == 0)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10a0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10a0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x1999
movl $0x0, -0x4(%rbp)
jmp 0x19c3
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x10c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x19bc
movl $0x1, -0x4(%rbp)
jmp 0x19c3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: getCommand(redisClient*)
void getCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	if (de != NULL) {
		robj *val = (robj *)de->val;
		if (val->type == REDIS_STRING) {
			size_t len = sdslen((sds)val->ptr);
			memcpy(client->buf + client->bufpos, sds(val->ptr), len);
			memset(client->buf+len, 0, 1);
			client->bufpos += len;
		}
		else {
			explainNotForThat(client, val->type);
			return;
		}
	}
	else {
		memcpy(client->buf + client->bufpos, "(not found)\n\0", 13);
		client->bufpos += 13;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1dcf
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1dbc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2cf0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
addq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
addq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10e0
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
jmp 0x1dcd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
jmp 0x1e08
jmp 0x1e08
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x53c7(%rip), %rdx      # 0x71a9
movq %rdx, 0x34(%rax,%rcx)
movl 0x53c4(%rip), %edx      # 0x71b1
movl %edx, 0x3c(%rax,%rcx)
movb 0x53be(%rip), %dl       # 0x71b5
movb %dl, 0x40(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xd, %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: setCommand(redisClient*)
void setCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	//three conditions if we			 set A - B
	//and it may be like that in db:		 C - D
	//										 A - B
	//										 A - E
	if (de != NULL) {
		robj *val = (robj *)de->val;
		if (val->type == REDIS_STRING) {
			//if argv[2] == val, it shouldn't be created again or change.
			if (keyStringObjectCompare(NULL, client->argv[2], val)) {
				//do noting.       
			}
			else {
				robj *val2 = createStringObject((char *)(client->argv[2])->ptr);
				if (dbModifyStringVal(client->db, de->key, val2) != REDIS_OK)
					assert(0);
			}
		}
		else {
			explainNotForThat(client, val->type);
			return;
		}
	}
	else {
		char *k = (char *)client->argv[1]->ptr;
		char *v = (char *)client->argv[2]->ptr;
		robj *key = createStringObject(k);
		robj *val = createStringObject(v);
		dictAdd(client->db->dict, key, val);
	}
	memcpy(client->buf + client->bufpos, "(set OK)\n\0", 10);
	client->bufpos += 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ef9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1ee3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x6320
cmpl $0x0, %eax
je 0x1e8b
jmp 0x1ee1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x6420
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x5f60
cmpl $0x0, %eax
je 0x1edf
leaq 0x5265(%rip), %rdi      # 0x712c
leaq 0x5190(%rip), %rsi      # 0x705e
movl $0xba, %edx
leaq 0x5190(%rip), %rcx      # 0x706a
callq 0x1100
jmp 0x1ee1
jmp 0x1ef7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
jmp 0x1f83
jmp 0x1f52
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6420
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6420
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x4520
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x5252(%rip), %rdx      # 0x71b7
movq %rdx, 0x34(%rax,%rcx)
movw 0x524e(%rip), %dx       # 0x71bf
movw %dx, 0x3c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: delCommand(redisClient*)
void delCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	if (de != NULL) {
		robj *val = (robj*)de->val;
		if (val->type == REDIS_STRING) {
			robj *key = (robj *)de->key;
			dbRemoveHashEntry(client->db, key, val);
		}
		else {
			explainNotForThat(client, val->type);
			return;
		}
	}
	//generally speaking, if the argv[1] cann't find in dictEntry
	//so we can delete it in a wrong buf safe way.
	memcpy(client->buf + client->bufpos, "(del OK)\n\0", 10);
	client->bufpos += 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x201b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2008
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6000
jmp 0x2019
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
jmp 0x204c
jmp 0x201b
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x5194(%rip), %rdx      # 0x71c2
movq %rdx, 0x34(%rax,%rcx)
movw 0x5190(%rip), %dx       # 0x71ca
movw %dx, 0x3c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: lpushCommand(redisClient*)
void lpushCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	robj *key;
	robj *val;
	if (de != NULL) {
		int type = ((robj *)de->val)->type;
		if (type != REDIS_LIST) {
			explainNotForThat(client, type);
			return;
		}
		else {
			key = (robj *)de->key;
			val = (robj *)de->val;
		}
	}
	else {
		key = createStringObject((char *)o->ptr);
		val = createListObject();
		dictAdd(d, key, val);
	}

	for (int i = 2; i < client->argc; ++i) {
		list *l = (list *)val->ptr;
		robj *v = createStringObject((char *)(client->argv[i]->ptr));
		listAddNodeHead(l, v);
	}
	memcpy(client->buf + client->bufpos, "(lpush OK)", 10);
	client->bufpos += 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x20df
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
je 0x20c6
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x2d10
jmp 0x218f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x210a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6420
movq %rax, -0x28(%rbp)
callq 0x6450
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4520
movl $0x2, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x215e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x6420
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1400
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2111
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4f18(%rip), %rdx      # 0x7089
movq %rdx, 0x34(%rax,%rcx)
movw 0x4f14(%rip), %dx       # 0x7091
movw %dx, 0x3c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: lpopCommand(redisClient*)
void lpopCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	if (de != NULL) {
		robj *val = (robj *)de->val;
		if (val->type != REDIS_LIST) {
			explainNotForThat(client, val->type);
		}
		list *l = (list *)val->ptr;
		if (l->len == 0) {
			memcpy(client->buf + client->bufpos, "(empty)", 7);
			client->bufpos += 7;
			return;
		}
		listNode *node = l->head;
		char *p = (sds)((robj *)node->value)->ptr;
		memcpy(client->buf + client->bufpos, p, strlen(p));
		client->bufpos += strlen(p);
		listDelNode(l, node);
	}
	else {
		memcpy(client->buf + client->bufpos, "(no such list)", 14);
		client->bufpos += 14;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x22db
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x220a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x225f
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl 0x4e61(%rip), %edx      # 0x7094
movl %edx, 0x34(%rax,%rcx)
movw 0x4e5a(%rip), %dx       # 0x7098
movw %dx, 0x38(%rax,%rcx)
movb 0x4e51(%rip), %dl       # 0x709a
movb %dl, 0x3a(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x7, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2316
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
addq $0x34, %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x10a0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1120
movq -0x40(%rbp), %rdi
callq 0x10a0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1830
jmp 0x2316
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4dae(%rip), %rdx      # 0x709c
movq %rdx, 0x34(%rax,%rcx)
movl 0x4dab(%rip), %edx      # 0x70a4
movl %edx, 0x3c(%rax,%rcx)
movw 0x4da4(%rip), %dx       # 0x70a8
movw %dx, 0x40(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xe, %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: hgetCommand(redisClient*)
void hgetCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	if (de != NULL) {
		robj *val = (robj *)de->val;
		if (val->type != REDIS_HASH) {
			explainNotForThat(client, val->type);
			return;
		}

		robj *k = client->argv[2];
		dictEntry *nde = dictFind((dict *)val->ptr, k);
		if (nde != NULL) {
			robj *v = (robj *)nde->val;
			char *p = (char *)v->ptr;
			size_t plen = strlen(p);
			memcpy(client->buf + client->bufpos, p, plen);
			client->bufpos += plen;
		}
		else {
			memcpy(client->buf + client->bufpos, "(no such key in dict)", 21);
			client->bufpos += 21;
		}
	}
	else {
		memcpy(client->buf + client->bufpos, "(no such dictory)", 17);
		client->bufpos += 17;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x264b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
je 0x257f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
jmp 0x2686
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3d40
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2604
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x10a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
addq %rax, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1120
movq -0x50(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
jmp 0x2649
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4aa3(%rip), %rdx      # 0x70ba
movq %rdx, 0x34(%rax,%rcx)
movq 0x4a9f(%rip), %rdx      # 0x70c2
movq %rdx, 0x3c(%rax,%rcx)
movl 0x4a9c(%rip), %edx      # 0x70ca
movl %edx, 0x44(%rax,%rcx)
movb 0x4a96(%rip), %dl       # 0x70ce
movb %dl, 0x48(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x15, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2686
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4a72(%rip), %rdx      # 0x70d0
movq %rdx, 0x34(%rax,%rcx)
movq 0x4a6e(%rip), %rdx      # 0x70d8
movq %rdx, 0x3c(%rax,%rcx)
movb 0x4a6b(%rip), %dl       # 0x70e0
movb %dl, 0x44(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x11, %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: hlenCommand(redisClient*)
void hlenCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *o = client->argv[1];
	dictEntry *de = dictFind(d, o);

	if (de != NULL) {
		robj *val = (robj *)de->val;
		if (val->type != REDIS_HASH) {
			explainNotForThat(client, val->type);
			return;
		}
		int len = ((dict *)(val->ptr))->ht[0].used + ((dict *)(val->ptr))->ht[1].used;
		char p[16];
		parseDigitToString(len, p);
		size_t plen = strlen(p);
		memcpy(client->buf + client->bufpos, p, plen);
		client->bufpos += plen;
		client->buf[client->bufpos] = '\0';
	}
	else {
		memcpy(client->buf + client->bufpos, "(no such dictory)", 17);
		client->bufpos += 17;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2a28
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
je 0x29af
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2d10
jmp 0x2a63
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0x38(%rcx), %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
leaq -0x40(%rbp), %rsi
callq 0x2ff0
leaq -0x40(%rbp), %rdi
callq 0x10a0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
addq %rax, %rdi
leaq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x1120
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movb $0x0, 0x34(%rax,%rcx)
jmp 0x2a63
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4695(%rip), %rdx      # 0x70d0
movq %rdx, 0x34(%rax,%rcx)
movq 0x4691(%rip), %rdx      # 0x70d8
movq %rdx, 0x3c(%rax,%rcx)
movb 0x468e(%rip), %dl       # 0x70e0
movb %dl, 0x44(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x11, %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: typeCommand(redisClient*)
void typeCommand(redisClient *client)
{
	dict *d = client->db->dict;
	robj *q = client->argv[1];
	dictEntry *de = dictFind(d, q);

	if (de != NULL) {
		robj *val = (robj *)de->val;
		switch (val->type) {
		case REDIS_STRING:
			memcpy(client->buf + client->bufpos, "string", 6);
			client->bufpos += 6;
			break;
		case REDIS_LIST:
			memcpy(client->buf + client->bufpos, "list", 4);
			client->bufpos += 4;
			break;
		case REDIS_HASH:
			memcpy(client->buf + client->bufpos, "hash", 4);
			client->bufpos += 4;
			break;
		default:
			memcpy(client->buf + client->bufpos, "(none)", 6);
			client->bufpos += 6;
			break;
		}
	}
	else
		NOT_FOUND(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2b92
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x2ae6
jmp 0x2ad2
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x2b17
jmp 0x2adc
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x2b3c
jmp 0x2b61
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl 0x4601(%rip), %edx      # 0x70f9
movl %edx, 0x34(%rax,%rcx)
movw 0x45fa(%rip), %dx       # 0x70fd
movw %dx, 0x38(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x6, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2b90
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl 0x45d7(%rip), %edx      # 0x7100
movl %edx, 0x34(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2b90
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl 0x45b7(%rip), %edx      # 0x7105
movl %edx, 0x34(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2b90
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl 0x4597(%rip), %edx      # 0x710a
movl %edx, 0x34(%rax,%rcx)
movw 0x4590(%rip), %dx       # 0x710e
movw %dx, 0x38(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x6, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2bd1
jmp 0x2b94
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x456a(%rip), %rdx      # 0x7111
movq %rdx, 0x34(%rax,%rcx)
movw 0x4566(%rip), %dx       # 0x7119
movw %dx, 0x3c(%rax,%rcx)
movb 0x455d(%rip), %dl       # 0x711b
movb %dl, 0x3e(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xb, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2bd1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: dbCommand(redisClient*)
void dbCommand(redisClient *client)
{
	robj *o1 = client->argv[1];
	char* cmd1 = (sds)o1->ptr;
	size_t cmdlen = strlen(cmd1);

	if(*cmd1 != '-' || cmdlen != 2){
		NOT_FOUND(client);
		return;
	}
	
	char type = cmd1[1];
	switch(type){
	case 's':
		dbSaveCommand(client);
		break;
	case 'l':
		dbLoadCommand(client);
		break;
	default:
		NOT_FOUND(client);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2c28
cmpq $0x2, -0x20(%rbp)
je 0x2c67
jmp 0x2c2a
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x44d4(%rip), %rdx      # 0x7111
movq %rdx, 0x34(%rax,%rcx)
movw 0x44d0(%rip), %dx       # 0x7119
movw %dx, 0x3c(%rax,%rcx)
movb 0x44c7(%rip), %dl       # 0x711b
movb %dl, 0x3e(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xb, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2cde
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x6c, %eax
je 0x2c94
jmp 0x2c7f
movl -0x28(%rbp), %eax
subl $0x73, %eax
jne 0x2c9f
jmp 0x2c89
movq -0x8(%rbp), %rdi
callq 0x30b0
jmp 0x2cde
movq -0x8(%rbp), %rdi
callq 0x31f0
jmp 0x2cde
jmp 0x2ca1
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x445d(%rip), %rdx      # 0x7111
movq %rdx, 0x34(%rax,%rcx)
movw 0x4459(%rip), %dx       # 0x7119
movw %dx, 0x3c(%rax,%rcx)
movb 0x4450(%rip), %dl       # 0x711b
movb %dl, 0x3e(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xb, %ecx
movl %ecx, 0x30(%rax)
jmp 0x2cde
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: explainNotForThat(redisClient*, int)
static void explainNotForThat(redisClient *client, int type)
{
	char s[] = "(Exist for a String Object)";
	char l[] = "(Exist for a List Object)";
	char h[] = "(Exist for a Hash Object)";

	switch (type) {
	case REDIS_STRING:
		EXIST_FOR_ANTHOR_OBJECT(client, s);
		break;
	case REDIS_LIST:
		EXIST_FOR_ANTHOR_OBJECT(client, l);
		break;
	case REDIS_HASH:
		EXIST_FOR_ANTHOR_OBJECT(client, h);
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movups 0x44d3(%rip), %xmm0     # 0x71fc
movups %xmm0, -0x24(%rbp)
movaps 0x44bc(%rip), %xmm0     # 0x71f0
movaps %xmm0, -0x30(%rbp)
movups 0x44db(%rip), %xmm0     # 0x721a
movups %xmm0, -0x46(%rbp)
movaps 0x44c6(%rip), %xmm0     # 0x7210
movaps %xmm0, -0x50(%rbp)
movups 0x44e5(%rip), %xmm0     # 0x723a
movups %xmm0, -0x66(%rbp)
movaps 0x44d0(%rip), %xmm0     # 0x7230
movaps %xmm0, -0x70(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
subl $0x1, %eax
je 0x2d90
jmp 0x2d71
movl -0x74(%rbp), %eax
subl $0x2, %eax
je 0x2e00
jmp 0x2d7f
movl -0x74(%rbp), %eax
subl $0x3, %eax
je 0x2e76
jmp 0x2ee9
jmp 0x2d92
movq -0x8(%rbp), %rax
addq $0x34, %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10a0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x1120
leaq -0x30(%rbp), %rdi
callq 0x10a0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movb $0x0, 0x34(%rax,%rcx)
jmp 0x2f08
jmp 0x2e02
movq -0x8(%rbp), %rax
addq $0x34, %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0x1120
leaq -0x50(%rbp), %rdi
callq 0x10a0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movb $0x0, 0x34(%rax,%rcx)
jmp 0x2f08
jmp 0x2e78
movq -0x8(%rbp), %rax
addq $0x34, %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10a0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x1120
leaq -0x70(%rbp), %rdi
callq 0x10a0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movb $0x0, 0x34(%rax,%rcx)
jmp 0x2f08
leaq 0x423c(%rip), %rdi      # 0x712c
leaq 0x4167(%rip), %rsi      # 0x705e
movl $0x83, %edx
leaq 0x4255(%rip), %rcx      # 0x7158
callq 0x1100
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: parseObjectToDigit(redisObject*)
static int parseObjectToDigit(robj *o)
{
	int ret = 0;
	char s[16];
	int index = 1;

	sds buf = (sds)o->ptr;
	int len = sdslen(buf);
	memcpy(s, buf, len);
	char *p = s + len;

	if (*s == '-')
		--len;

	while (len--) {
		--p;
		int i = *p - '0';
		ret = ret + i * index;
		index *= 10;
	}
	if (*s == '-') {
		return -ret;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2cf0
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x1120
leaq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movsbl -0x30(%rbp), %eax
cmpl $0x2d, %eax
jne 0x2f84
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2f86
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x44(%rbp)
cmpl $0x0, %eax
je 0x2fc7
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x54(%rbp)
movl -0x14(%rbp), %eax
movl -0x54(%rbp), %ecx
imull -0x34(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
imull $0xa, -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x2f86
movsbl -0x30(%rbp), %eax
cmpl $0x2d, %eax
jne 0x2fda
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fe0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: parseDigitToString(int, char*)
static void parseDigitToString(int len, char *b)
{
	//example   123
	int i = 0, j = 0;
	char rbuf[16];

	while (len > 0) {
		char c = (len % 10) + '0';
		rbuf[i] = c;
		++i;
		len /= 10;
	}
	char *p = rbuf + i;
	while (i--) {
		--p;
		b[j] = *p;
		++j;
	}
	memset(b + j, 0, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x304a
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x30(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x300d
leaq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x3091
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3059
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: dbSaveCommand(redisClient*)
static void dbSaveCommand(redisClient *client)
{
	robj *o = client->argv[2];
	char *filename = (sds)o->ptr;
	FILE *fp = fopen(filename, "r");
	
	size_t pos = 0;
	char buf[BIG_BUF];
	memset(buf, 0, BIG_BUF);
	
	if(fp == NULL){
		size_t size = startCompressRDB(client->db, buf, &pos);
		fp = fopen(filename, "w");
		fwrite(buf, size, 1, fp);
		fclose(fp);
		memcpy(client->buf + client->bufpos, "(save OK)", 9);
		client->bufpos += 9;
	}
	else{
		fclose(fp);
		memcpy(client->buf + client->bufpos, "(file exists)", 13);
		client->bufpos += 13;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100040, %rsp         # imm = 0x100040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x409d(%rip), %rsi      # 0x7183
callq 0x1170
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x100030(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x10e0
cmpq $0x0, -0x20(%rbp)
jne 0x319d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x100030(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x45b0
movq %rax, -0x100038(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4047(%rip), %rsi      # 0x7185
callq 0x1170
movq %rax, -0x20(%rbp)
leaq -0x100030(%rbp), %rdi
movq -0x100038(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x1230
movq -0x20(%rbp), %rdi
callq 0x1140
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x4008(%rip), %rdx      # 0x7187
movq %rdx, 0x34(%rax,%rcx)
movb 0x4005(%rip), %dl       # 0x718f
movb %dl, 0x3c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x9, %ecx
movl %ecx, 0x30(%rax)
jmp 0x31df
movq -0x20(%rbp), %rdi
callq 0x1140
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x3fd8(%rip), %rdx      # 0x7191
movq %rdx, 0x34(%rax,%rcx)
movl 0x3fd5(%rip), %edx      # 0x7199
movl %edx, 0x3c(%rax,%rcx)
movb 0x3fcf(%rip), %dl       # 0x719d
movb %dl, 0x40(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xd, %ecx
movl %ecx, 0x30(%rax)
addq $0x100040, %rsp         # imm = 0x100040
popq %rbp
retq
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: dbLoadCommand(redisClient*)
static void dbLoadCommand(redisClient *client)
{
	robj *o = client->argv[2];
	char *filename = (sds)o->ptr;
	FILE *fp = fopen(filename, "r");
	size_t pos = 0;
	char buf[BIG_BUF];
	memset(buf, 0, BIG_BUF);

	if(fp != NULL){
		size_t nread = fread(buf, 1, BIG_BUF, fp);
		startLoadFromRDB(client, buf, &pos);
		fclose(fp);
		memcpy(client->buf + client->bufpos, "(load OK)", 9);
		client->bufpos += 9;
	}
	else{
		NOT_FOUND(client);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100040, %rsp         # imm = 0x100040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3f5d(%rip), %rsi      # 0x7183
callq 0x1170
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x100030(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x10e0
cmpq $0x0, -0x20(%rbp)
je 0x32c0
leaq -0x100030(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x1, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x11f0
movq %rax, -0x100038(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x100030(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x4d00
movq -0x20(%rbp), %rdi
callq 0x1140
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x3efd(%rip), %rdx      # 0x719f
movq %rdx, 0x34(%rax,%rcx)
movb 0x3efa(%rip), %dl       # 0x71a7
movb %dl, 0x3c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x9, %ecx
movl %ecx, 0x30(%rax)
jmp 0x32ff
jmp 0x32c2
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x3e3c(%rip), %rdx      # 0x7111
movq %rdx, 0x34(%rax,%rcx)
movw 0x3e38(%rip), %dx       # 0x7119
movw %dx, 0x3c(%rax,%rcx)
movb 0x3e2f(%rip), %dl       # 0x711b
movb %dl, 0x3e(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xb, %ecx
movl %ecx, 0x30(%rax)
jmp 0x32ff
addq $0x100040, %rsp         # imm = 0x100040
popq %rbp
retq
nopl (%rax,%rax)
// File: TTLIUJJ[P]acker_redis/command.cpp
// Function: deduceCommandForQuery(redisClient*)
void deduceCommandForQuery(redisClient *client)
{
	assert(client->argc > 0);
	memset(client->buf, 0, REDIS_QUERY_CHUNK_BYTES);
	client->bufpos = 0;
	client->cmd = NULL;

	robj *o = client->argv[0];
	char *name = (sds)o->ptr;
	dictEntry *de = dictFind(cmdTable, name);
	
	if (de != NULL) {
		redisCommand *cmd = (redisCommand *)de->val;
		client->cmd = cmd;
		if ((cmd->arbity > 0 && client->argc != cmd->arbity) ||
			(cmd->arbity < 0 && client->argc < (-cmd->arbity))) {
			memcpy(client->buf + client->bufpos, "(argc error)\n\0", 14);
			client->bufpos += 14;
			client->cmd = NULL;
			return;
		}
		((client->cmd)->proc)(client);
	}
	else {
		client->cmd = NULL;
		memcpy(client->buf + client->bufpos, "(command error)\n\0", 17);
		client->bufpos += 17;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x3328
jmp 0x3347
leaq 0x3dee(%rip), %rdi      # 0x711d
leaq 0x3d28(%rip), %rsi      # 0x705e
movl $0x23a, %edx            # imm = 0x23A
leaq 0x3dec(%rip), %rcx      # 0x712e
callq 0x1100
movq -0x8(%rbp), %rdi
addq $0x34, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10e0
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x6e24(%rip), %rdi      # 0xa1b8
movq -0x18(%rbp), %rsi
callq 0x3d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3459
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x33de
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x33fc
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x3445
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
subl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x3445
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x3dbe(%rip), %rdx      # 0x71cd
movq %rdx, 0x34(%rax,%rcx)
movl 0x3dbb(%rip), %edx      # 0x71d5
movl %edx, 0x3c(%rax,%rcx)
movw 0x3db4(%rip), %dx       # 0x71d9
movw %dx, 0x40(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0xe, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x34a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x34a0
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq 0x3d64(%rip), %rdx      # 0x71dc
movq %rdx, 0x34(%rax,%rcx)
movq 0x3d60(%rip), %rdx      # 0x71e4
movq %rdx, 0x3c(%rax,%rcx)
movb 0x3d5d(%rip), %dl       # 0x71ec
movb %dl, 0x44(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x11, %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictGenCaseHashFunction(void const*)
unsigned int dictGenCaseHashFunction(const void *buf)
{
	const char *p = (const char *)buf;
	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 %rax, -0x10(%rbp)
movl 0x6ca6(%rip), %eax      # 0xa170
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 0x3518
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 0x34d9
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictSdsCompare(void*, void const*, void const*)
int dictSdsCompare(void *privdata, const void *key1, const void *key2)
{
	char *k1 = (char *)key1;
	char *k2 = (char *)key2;

	int len1 = strlen(k1);
	int len2 = strlen(k2);
	if (len1 != len2)
		return 0;

	int cmp = memcmp(key1, key2, len1);
	if (cmp == 0)
		return 1;
	else
		return 0;
}

// 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 %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10a0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10a0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x357d
movl $0x0, -0x4(%rbp)
jmp 0x35a7
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x10c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x35a0
movl $0x1, -0x4(%rbp)
jmp 0x35a7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictExpandIfNeeded(dict*)
int _dictExpandIfNeeded(dict *d)
{
	if (dictIsRehashing(d))
		return DICT_ERR;

	if (d->ht[0].size == 0)
		return dictExpand(d, DICT_HT_INITIAL_SIZE);

	unsigned int ratio = d->ht[0].used / d->ht[0].size;
	if (d->ht[0].used >= d->ht[0].size && (dict_can_resize || ratio > dict_force_resize_ratio))
		return dictExpand(d, d->ht[0].used * 2);

	return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x35cf
movl $0x1, -0x4(%rbp)
jmp 0x3648
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x35ed
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x3660
movl %eax, -0x4(%rbp)
jmp 0x3648
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x20(%rcx)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x3641
cmpl $0x0, 0x6b4d(%rip)      # 0xa168
jne 0x3628
movl -0x14(%rbp), %eax
cmpl 0x6b46(%rip), %eax      # 0xa16c
jbe 0x3641
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
shlq %rsi
callq 0x3660
movl %eax, -0x4(%rbp)
jmp 0x3648
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictExpand(dict*, unsigned long)
int dictExpand(dict *d, unsigned long size)
{
	dictht ht;
	unsigned long realsize = _dictNextPower(size);

	if (dictIsRehashing(d) || d->ht[0].used > size)
		return DICT_ERR;

	if (realsize == d->ht[0].size)
		return DICT_ERR;

	ht.size = realsize;
	ht.size_mask = realsize - 1;
	ht.table = (dictEntry **)(zcalloc(realsize * sizeof(dictEntry *)));
	ht.used = 0;

	if (d->ht[0].table == NULL) {
		d->ht[0] = ht;
		return DICT_OK;
	}
	d->ht[1] = ht;
	d->rehashidx = 0;	//ready for rehashing

	return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3ca0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
jne 0x3695
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x36a1
movl $0x1, -0x4(%rbp)
jmp 0x3756
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x36bb
movl $0x1, -0x4(%rbp)
jmp 0x3756
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x3, %rdi
callq 0x5800
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3720
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3756
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictAddRaw(dict*, void*)
dictEntry* dictAddRaw(dict *d, void *key)
{
	int index;
	dictht *ht;

	if (dictIsRehashing(d))
		_dictRehashStep(d);
	
	if ((index = _dictKeyIndex(d, key)) == -1)
		return NULL;
	
	ht = (dictIsRehashing(d)) ? &d->ht[1] : &d->ht[0];
	dictEntry *de = (dictEntry *)zmalloc(sizeof(struct dictEntry));
	de->next = ht->table[index];
	ht->table[index] = de;
	++ht->used;
	
	dictSetKey(d, de, key);
	
	return de;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x39d3
movq -0x10(%rbp), %rdi
callq 0x3760
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ac0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x39f5
movq $0x0, -0x8(%rbp)
jmp 0x3ab5
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x3a11
movq -0x10(%rbp), %rax
addq $0x10, %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
jmp 0x3a1d
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x18, %edi
callq 0x5710
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x3aa0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3aab
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3aad
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictKeyIndex(dict*, void const*)
static int _dictKeyIndex(dict *d, const void *key)
{
	unsigned int h, idx, table;
	dictEntry *de;
		
	_dictExpandIfNeeded(d);
	
	h = dictHashKey(d, key);
	
	for (table = 0; table < 2; ++table) {
		idx = h & d->ht[table].size_mask;
		de = d->ht[table].table[idx];
		while (de != NULL) {
			if (dictCompareKeys(d, key, de->key))
				return -1;
			
			de = de->next;
		}

		if (!dictIsRehashing(d))
			break;
	}
	
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jae 0x3bc4
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movl -0x24(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
andq 0x18(%rcx), %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movl -0x24(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3ba8
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x3b73
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
jmp 0x3b89
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
je 0x3b9a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bca
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3b39
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
jne 0x3bb4
jmp 0x3bc4
jmp 0x3bb6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3af3
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TTLIUJJ[P]acker_redis/dict.cpp
// Function: dictInit(dict*, dictType*, void*)
static int _dictInit(dict *d, dictType *type, void *privdata)
{
	_dictReset(&d->ht[0]);
	_dictReset(&d->ht[1]);
	d->privdata = privdata;
	d->rehashidx = -1;
	d->iterator = 0;
	if (type == NULL) {
		d->type = &defaultDictType;
	}
	else
		d->type = type;
	
	return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x3d00
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
addq $0x20, %rdi
callq 0x3d00
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x54(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x3c8b
movq -0x8(%rbp), %rax
leaq 0x64b2(%rip), %rcx      # 0xa138
movq %rcx, (%rax)
jmp 0x3c96
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop