LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/sszllzss[P]webSocket_Libevent_ThreadPool/ev_client_main.c
// Function: sig_cb(int, short, void*)
static void sig_cb(evutil_socket_t sig, short events,void *ctx)
{
    int ret;
    if(sig==SIGALRM)
    {
        struct bufferevent *bev=(struct bufferevent *)ctx;
        ret = ev_webSocket_send(bev,(unsigned char *) "#%^#@@@DTG%^&&+_)+(*^%!HHI", strlen("#%^#@@@DTG%^&&+_)+(*^%!HHI"), true, WCT_TXTDATA);
        if(ret < 0)
        {
            
            De_printf("断开连接!\r\n");
            event_base_loopbreak(bufferevent_get_base(bev));
            bufferevent_free(bev);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0xe, %edi
jne 0x4271
movq %rdx, %rbx
leaq 0x13d0(%rip), %rsi      # 0x5625
movq %rdx, %rdi
movl $0x1a, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x3c75
testl %eax, %eax
js 0x4278
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xf2c(%rip), %rdi       # 0x51ab
leaq 0x13ba(%rip), %rsi      # 0x5640
leaq 0x12b7(%rip), %rdx      # 0x5544
movl $0x45, %ecx
xorl %eax, %eax
callq 0x2040
leaq 0x13d9(%rip), %rdi      # 0x5679
callq 0x22c0
leaq 0x13da(%rip), %rdi      # 0x5686
callq 0x22c0
movq %rbx, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2260
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20a0
nop
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/tlb_flush2.c
// Function: testcase
void testcase(unsigned long *iteration, unsigned long nr)
{
	unsigned long pgsize = getpagesize();
	unsigned long i;

	while (1) {
		char *addr = mmap(NULL, MEMORYSIZE, PROT_READ|PROT_WRITE,
						MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
		for (i = 0; i < MEMORYSIZE; i += pgsize) {
			*(addr + i) = 1;
			madvise(addr + i, pgsize, MADV_DONTNEED);
			assert(*(addr + i) == 0);
			(*iteration)++;
		}
		munmap(addr, MEMORYSIZE);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1270
movslq %eax, %r14
movl $0x100000, %esi         # imm = 0x100000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x10f0
movq %rax, %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rdi
movb $0x1, (%r15,%r12)
movq %r14, %rsi
movl $0x4, %edx
callq 0x1210
cmpb $0x0, (%r15,%r12)
jne 0x1ce3
incq (%rbx)
addq %r14, %r12
cmpq $0x100000, %r12         # imm = 0x100000
jb 0x1ca8
movl $0x100000, %esi         # imm = 0x100000
movq %r15, %rdi
callq 0x11f0
jmp 0x1c83
leaq 0x59c(%rip), %rdi       # 0x2286
leaq 0x5a6(%rip), %rsi       # 0x2297
leaq 0x5b2(%rip), %rcx       # 0x22aa
movl $0x1b, %edx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_malloc.cold.2
JEMALLOC_ALWAYS_INLINE size_t
s2u_compute(size_t size)
{

#if (NTBINS > 0)
	if (size <= (ZU(1) << LG_TINY_MAXCLASS)) {
		size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1;
		size_t lg_ceil = lg_floor(pow2_ceil(size));
		return (lg_ceil < lg_tmin ? (ZU(1) << lg_tmin) :
		    (ZU(1) << lg_ceil));
	}
#endif
	{
		size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
		    (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
		    : lg_floor((size<<1)-1);
		size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
		    ?  LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1;
		size_t delta = ZU(1) << lg_delta;
		size_t delta_mask = delta - 1;
		size_t usize = (size + delta_mask) & ~delta_mask;
		return (usize);
	}
}

// Assembly:
testq %rdi, %rdi
js 0x12deb
leaq -0x1(,%rdi,2), %rax
bsrq %rax, %rax
leal -0x3(%rax), %ecx
pushq $-0x1
popq %rdx
shlq %cl, %rdx
cmpq $0x7, %rax
notq %rdx
pushq $0xf
popq %rax
cmovaeq %rdx, %rax
addq %rax, %rdi
notq %rax
andq %rdi, %rax
movq %rax, (%rsi)
retq
movq %rdi, %rax
btrq $0x3f, %rax
cmpq $0x1, %rax
pushq $0x40
popq %rax
sbbq $0x0, %rax
jmp 0x12dc7
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/adlist.c
// Function: listDup
list *listDup(list *orig)
{
    list *copy;
    listIter *iter;
    listNode *node;

    if ((copy = listCreate()) == NULL)
        return NULL;
    copy->dup = orig->dup;
    copy->free = orig->free;
    copy->match = orig->match;
    iter = listGetIterator(orig, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        void *value;

        if (copy->dup) {
            value = copy->dup(node->value);
            if (value == NULL) {
                listRelease(copy);
                listReleaseIterator(iter);
                return NULL;
            }
        } else
            value = node->value;
        if (listAddNodeTail(copy, value) == NULL) {
            listRelease(copy);
            listReleaseIterator(iter);
            return NULL;
        }
    }
    listReleaseIterator(iter);
    return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x1fea5
testq %rax, %rax
je 0x16cd2
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x16cd4
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x16d13
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movl $0x10, %edi
callq 0x1fea5
testq %rax, %rax
je 0x16d17
movq %rax, %r14
movq (%r15), %rax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
jmp 0x16d1a
xorl %ebx, %ebx
jmp 0x16d6c
xorl %r14d, %r14d
movq (%r14), %rax
testq %rax, %rax
je 0x16d64
xorl %ecx, %ecx
cmpl $0x0, 0x8(%r14)
sete %cl
movq (%rax,%rcx,8), %rcx
movq %rcx, (%r14)
movq 0x10(%rbx), %rcx
movq 0x10(%rax), %rax
testq %rcx, %rcx
je 0x16d4a
movq %rax, %rdi
callq *%rcx
testq %rax, %rax
je 0x16d5a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16aff
testq %rax, %rax
jne 0x16d1a
movq %rbx, %rdi
callq 0x16a50
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1ffff
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/adlist.c
// Function: listSearchKey
listNode *listSearchKey(list *list, void *key)
{
    listIter *iter;
    listNode *node;

    iter = listGetIterator(list, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        if (list->match) {
            if (list->match(node->value, key)) {
                listReleaseIterator(iter);
                return node;
            }
        } else {
            if (key == node->value) {
                listReleaseIterator(iter);
                return node;
            }
        }
    }
    listReleaseIterator(iter);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movl $0x10, %edi
callq 0x1fea5
movq %rax, %rbx
movq (%r12), %r14
movq %r14, (%rax)
movl $0x0, 0x8(%rax)
testq %r14, %r14
je 0x16dd6
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
sete %al
movq (%r14,%rax,8), %rax
movq %rax, (%rbx)
movq 0x20(%r12), %rax
movq 0x10(%r14), %rdi
testq %rax, %rax
je 0x16dcc
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x16dd1
jmp 0x16dd9
cmpq %r15, %rdi
je 0x16dd9
movq (%rbx), %r14
jmp 0x16d9e
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1ffff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ae.c
// Function: aeDeleteTimeEvent
int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te, *prev = NULL;

    te = eventLoop->timeEventHead;
    while(te) {
        if (te->id == id) {
            if (prev == NULL)
                eventLoop->timeEventHead = te->next;
            else
                prev->next = te->next;
            if (te->finalizerProc)
                te->finalizerProc(eventLoop, te->clientData);
            zfree(te);
            return AE_OK;
        }
        prev = te;
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x1736d
cmpq %rsi, (%rbx)
jne 0x17327
xorl %ecx, %ecx
jmp 0x1733e
movq %rbx, %rdx
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
je 0x1736d
movq %rdx, %rcx
movq %rbx, %rdx
cmpq %rsi, (%rbx)
jne 0x1732a
leaq 0x28(%rdi), %rax
leaq 0x30(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rax, %rdx
movq 0x30(%rbx), %rax
movq %rax, (%rdx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x17363
movq 0x28(%rbx), %rsi
callq *%rax
movq %rbx, %rdi
callq 0x1ffff
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/anet.c
// Function: anetSetReuseAddr
static int anetSetReuseAddr(char *err, int fd) {
    int yes = 1;
    /* Make sure connection-intensive things like the discnt benckmark
     * will be able to close/open sockets a zillion of times */
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %esi, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x121b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x187a1
callq 0x120d0
movl (%rax), %edi
callq 0x128f0
leaq 0x399ab(%rip), %rsi     # 0x5213a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17855
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGenHashFunction
unsigned int dictGenHashFunction(const void *key, int len) {
    /* 'm' and 'r' are mixing constants generated offline.
     They're not really 'magic', they just happen to work well.  */
    uint32_t seed = dict_hash_function_seed;
    const uint32_t m = 0x5bd1e995;
    const int r = 24;

    /* Initialize the hash to a 'random' value */
    uint32_t h = seed ^ len;

    /* Mix 4 bytes at a time into the hash */
    const unsigned char *data = (const unsigned char *)key;

    while(len >= 4) {
        uint32_t k = *(uint32_t*)data;

        k *= m;
        k ^= k >> r;
        k *= m;

        h *= m;
        h ^= k;

        data += 4;
        len -= 4;
    }

    /* Handle the last few bytes of the input array  */
    switch(len) {
    case 3: h ^= data[2] << 16;
    case 2: h ^= data[1] << 8;
    case 1: h ^= data[0]; h *= m;
    };

    /* Do a few final mixes of the hash to ensure the last few
     * bytes are well-incorporated. */
    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;

    return (unsigned int)h;
}

// Assembly:
movl 0x55d54(%rip), %eax     # 0x6e510
xorl %esi, %eax
cmpl $0x4, %esi
jl 0x187ee
imull $0x5bd1e995, (%rdi), %ecx # imm = 0x5BD1E995
movl %ecx, %edx
shrl $0x18, %edx
xorl %ecx, %edx
imull $0x5bd1e995, %edx, %ecx # imm = 0x5BD1E995
imull $0x5bd1e995, %eax, %eax # imm = 0x5BD1E995
xorl %ecx, %eax
addq $0x4, %rdi
leal -0x4(%rsi), %ecx
cmpl $0x7, %esi
movl %ecx, %esi
jg 0x187c3
jmp 0x187f0
movl %esi, %ecx
cmpl $0x1, %ecx
je 0x18811
cmpl $0x2, %ecx
je 0x18808
cmpl $0x3, %ecx
jne 0x1881c
movzbl 0x2(%rdi), %ecx
shll $0x10, %ecx
xorl %ecx, %eax
movzbl 0x1(%rdi), %ecx
shll $0x8, %ecx
xorl %ecx, %eax
movzbl (%rdi), %ecx
xorl %eax, %ecx
imull $0x5bd1e995, %ecx, %eax # imm = 0x5BD1E995
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0x5bd1e995, %ecx, %ecx # imm = 0x5BD1E995
movl %ecx, %eax
shrl $0xf, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGenCaseHashFunction
unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) {
    unsigned int hash = (unsigned int)dict_hash_function_seed;

    while (len--)
        hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x55cd4(%rip), %r14d    # 0x6e510
testl %esi, %esi
je 0x1886d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x129a0
movq (%rax), %rcx
movl %ebp, %edx
xorl %esi, %esi
movl %r14d, %eax
shll $0x5, %eax
addl %r14d, %eax
movzbl (%rbx,%rsi), %edi
addl (%rcx,%rdi,4), %eax
incq %rsi
movl %eax, %r14d
cmpl %esi, %edx
jne 0x18854
jmp 0x18870
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictResize
int dictResize(dict *d)
{
    int minimal;

    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    minimal = d->ht[0].used;
    if (minimal < DICT_HT_INITIAL_SIZE)
        minimal = DICT_HT_INITIAL_SIZE;
    return dictExpand(d, minimal);
}

// Assembly:
cmpb $0x0, 0x567c2(%rip)     # 0x6f084
jne 0x188cb
cmpq $-0x1, 0x50(%rdi)
je 0x188d1
movl $0x1, %eax
retq
movl 0x28(%rdi), %eax
cmpl $0x5, %eax
movl $0x4, %esi
cmovgel %eax, %esi
jmp 0x188e4
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictExpand
int dictExpand(dict *d, unsigned long size)
{
    dictht n; /* the new hash table */
    unsigned long realsize = _dictNextPower(size);

    /* the size is invalid if it is smaller than the number of
     * elements already inside the hash table */
    if (dictIsRehashing(d) || d->ht[0].used > size)
        return DICT_ERR;

    /* Rehashing to the same table size is not useful. */
    if (realsize == d->ht[0].size) return DICT_ERR;

    /* Allocate the new hash table and initialize all pointers to NULL */
    n.size = realsize;
    n.sizemask = realsize-1;
    n.table = zcalloc(realsize*sizeof(dictEntry*));
    n.used = 0;

    /* Is this the first initialization? If so it's not really a rehashing
     * we just set the first hash table so that it can accept keys. */
    if (d->ht[0].table == NULL) {
        d->ht[0] = n;
        return DICT_OK;
    }

    /* Prepare a second hash table for incremental rehashing */
    d->ht[1] = n;
    d->rehashidx = 0;
    return DICT_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x7ffffffffffffffe, %r14 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r14, %rsi
jbe 0x18900
incq %r14
jmp 0x18910
movl $0x4, %eax
movq %rax, %r14
addq %rax, %rax
cmpq %rsi, %r14
jb 0x18905
movl $0x1, %eax
cmpq $-0x1, 0x50(%rbx)
jne 0x1896b
cmpq %rsi, 0x28(%rbx)
ja 0x1896b
cmpq 0x18(%rbx), %r14
je 0x1896b
leaq -0x1(%r14), %r15
leaq (,%r14,8), %rdi
callq 0x1feff
cmpq $0x0, 0x10(%rbx)
je 0x18955
movq %rax, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movq %r15, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
jmp 0x18969
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictRehash
int dictRehash(dict *d, int n) {
    int empty_visits = n*10; /* Max number of empty buckets to visit. */
    if (!dictIsRehashing(d)) return 0;

    while(n-- && d->ht[0].used != 0) {
        dictEntry *de, *nextde;

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
        assert(d->ht[0].size > (unsigned long)d->rehashidx);
        while(d->ht[0].table[d->rehashidx] == NULL) {
            d->rehashidx++;
            if (--empty_visits == 0) return 1;
        }
        de = d->ht[0].table[d->rehashidx];
        /* Move all the keys in this bucket from the old to the new hash HT */
        while(de) {
            unsigned int h;

            nextde = de->next;
            /* Get the index in the new hash table */
            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
            de->next = d->ht[1].table[h];
            d->ht[1].table[h] = de;
            d->ht[0].used--;
            d->ht[1].used++;
            de = nextde;
        }
        d->ht[0].table[d->rehashidx] = NULL;
        d->rehashidx++;
    }

    /* Check if we already rehashed the whole table... */
    if (d->ht[0].used == 0) {
        zfree(d->ht[0].table);
        d->ht[0] = d->ht[1];
        _dictReset(&d->ht[1]);
        d->rehashidx = -1;
        return 0;
    }

    /* More to rehash... */
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpq $-0x1, 0x50(%rdi)
je 0x18a73
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %ebp
subl $0x1, %r14d
jb 0x18a39
cmpq $0x0, 0x28(%rbx)
je 0x18a39
movq 0x18(%rbx), %rax
cmpq 0x50(%rbx), %rax
jbe 0x18a82
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rcx
movq -0x8(%rax,%rcx,8), %r15
testq %r15, %r15
jne 0x189dd
movq %rcx, 0x50(%rbx)
incq %rcx
decl %ebp
jne 0x189c4
xorl %ebp, %ebp
jmp 0x18a29
movq %r15, %r12
movq (%r12), %rdi
movq 0x10(%r12), %r13
movq (%rbx), %rax
callq *(%rax)
andl 0x40(%rbx), %eax
movq 0x30(%rbx), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x10(%r12)
movq %r12, (%rcx,%rax,8)
decq 0x28(%rbx)
incq 0x48(%rbx)
movq %r13, %r12
testq %r13, %r13
jne 0x189e0
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq $0x0, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x50(%rbx)
testq %r15, %r15
jne 0x18996
movl $0x1, %eax
jmp 0x18a73
movl $0x1, %eax
cmpq $0x0, 0x28(%rbx)
jne 0x18a73
movq 0x10(%rbx), %rdi
callq 0x1ffff
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $-0x1, 0x50(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3970f(%rip), %rdi     # 0x52198
leaq 0x39734(%rip), %rsi     # 0x521c4
movl $0xf6, %edx
callq 0x2a9ff
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictRehashMilliseconds
int dictRehashMilliseconds(dict *d, int ms) {
    long long start = timeInMilliseconds();
    int rehashes = 0;

    while(dictRehash(d,100)) {
        rehashes += 100;
        if (timeInMilliseconds()-start > ms) break;
    }
    return rehashes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r13d
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x12340
movabsq $-0x20c49ba5e353f7cf, %rax # imm = 0xDF3B645A1CAC0831
imulq 0x8(%r15)
movq %rdx, %r12
movq (%r15), %rbp
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r12
addq %rax, %r12
movslq %r13d, %r15
movabsq $0x20c49ba5e353f7cf, %r13 # imm = 0x20C49BA5E353F7CF
movq %r14, %rdi
movl $0x64, %esi
callq 0x18971
testl %eax, %eax
je 0x18b86
addl $0x64, %ebx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x12340
movq 0x8(%rsp), %rcx
subq %rbp, %rcx
movq %r13, %rax
imulq 0x10(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
addq %r12, %rdx
imulq $0x3e8, %rcx, %rax      # imm = 0x3E8
addq %rdx, %rax
cmpq %r15, %rax
jle 0x18b36
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictAddRaw
dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
{
    int index;
    dictEntry *entry;
    dictht *ht;

    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    if ((index = _dictKeyIndex(d, key, dictHashKey(d,key), existing)) == -1)
        return NULL;

    /* Allocate the memory and store the new entry.
     * Insert the element in top, with the assumption that in a database
     * system it is more likely that recently added entries are accessed
     * more frequently. */
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    /* Set the hash entry fields. */
    dictSetKey(d, entry, key);
    return entry;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpq $-0x1, 0x50(%rdi)
je 0x18c0e
cmpq $0x0, 0x58(%r14)
jne 0x18c0e
movq %r14, %rdi
movl $0x1, %esi
callq 0x18971
movq (%r14), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, 0xc(%rsp)
testq %r15, %r15
je 0x18c26
movq $0x0, (%r15)
movq %r15, 0x10(%rsp)
cmpq $-0x1, 0x50(%r14)
je 0x18ca4
leaq 0x10(%r14), %r13
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x5, %rax
movl 0x10(%r13,%rax), %r12d
andl 0xc(%rsp), %r12d
movq (%r13,%rax), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x18c7e
movq (%r15), %rdx
cmpq %rbx, %rdx
je 0x18c8f
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18c78
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
jne 0x18c8f
movq 0x10(%r15), %r15
jmp 0x18c52
testq %rbp, %rbp
jne 0x18cf5
incq %rbp
cmpq $-0x1, 0x50(%r14)
jne 0x18c38
jmp 0x18cf5
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18cf5
movq %r15, (%rax)
jmp 0x18cf5
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x18cda
movq 0x28(%r14), %rsi
cmpq %rcx, %rsi
jb 0x18c32
cmpb $0x1, 0x563c3(%rip)     # 0x6f084
jne 0x18cd5
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
cmpq $0x6, %rax
jb 0x18c32
addq %rsi, %rsi
jmp 0x18cdf
movl $0x4, %esi
movq %r14, %rdi
callq 0x188e4
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x18c32
cmpl $-0x1, %r12d
je 0x18d4e
xorl %r13d, %r13d
cmpq $-0x1, 0x50(%r14)
setne %r13b
shll $0x5, %r13d
movl $0x18, %edi
callq 0x1fea5
movq %rax, %r15
movq 0x10(%r14,%r13), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%r15)
movq %r15, (%rax,%rcx,8)
incq 0x28(%r14,%r13)
movq (%r14), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x18d49
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %rbx
movq %rbx, (%r15)
jmp 0x18d51
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictReplace
int dictReplace(dict *d, void *key, void *val)
{
    dictEntry *entry, *existing, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
    entry = dictAddRaw(d,key,&existing);
    if (entry) {
        dictSetVal(d, entry, val);
        return 1;
    }

    /* Set the new value and free the old one. Note that it is important
     * to do that in this order, as the value may just be exactly the same
     * as the previous one. In this context, think to reference counting,
     * you want to increment (set), and then decrement (free), and not the
     * reverse. */
    auxentry = *existing;
    dictSetVal(d, existing, val);
    dictFreeVal(d, &auxentry);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x18bdc
testq %rax, %rax
je 0x18d9b
movq %rax, %r15
movq (%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x18dc2
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *%rax
movq %rax, 0x8(%r15)
jmp 0x18dc6
movq (%rsp), %rcx
movq 0x8(%rcx), %r15
movq (%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x18dcd
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *%rax
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
jmp 0x18dd1
movq %r14, 0x8(%r15)
movl $0x1, %ebp
jmp 0x18de8
movq %r14, 0x8(%rcx)
movq (%rbx), %rax
movq 0x28(%rax), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x18de8
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq *%rax
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGenericDelete
static dictEntry *dictGenericDelete(dict *d, const void *key, int nofree) {
    unsigned int h, idx;
    dictEntry *he, *prevHe;
    int table;

    if (d->ht[0].used == 0 && d->ht[1].used == 0) return NULL;

    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);

    for (table = 0; table <= 1; table++) {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        prevHe = NULL;
        while(he) {
            if (key==he->key || dictCompareKeys(d, key, he->key)) {
                /* Unlink the element from the list */
                if (prevHe)
                    prevHe->next = he->next;
                else
                    d->ht[table].table[idx] = he->next;
                if (!nofree) {
                    dictFreeKey(d, he);
                    dictFreeVal(d, he);
                    zfree(he);
                }
                d->ht[table].used--;
                return he;
            }
            prevHe = he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) break;
    }
    return NULL; /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x18e43
cmpq $0x0, 0x48(%rbx)
je 0x18f93
movl %edx, 0xc(%rsp)
cmpq $-0x1, 0x50(%rbx)
je 0x18e62
cmpq $0x0, 0x58(%rbx)
jne 0x18e62
movq %rbx, %rdi
movl $0x1, %esi
callq 0x18971
leaq 0x10(%rbx), %r15
movq (%rbx), %rax
movq %r14, %rdi
callq *(%rax)
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movq %r15, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movq %r13, 0x30(%rsp)
shlq $0x5, %r13
movl 0x10(%r15,%r13), %ecx
andl %eax, %ecx
movq (%r15,%r13), %rax
movq %rcx, 0x28(%rsp)
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x18ee6
movq (%r15), %rdx
cmpq %r14, %rdx
je 0x18f9e
xorl %r12d, %r12d
movq %r15, %rbp
movq (%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18ed0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jne 0x18f0e
movq 0x10(%rbp), %r15
testq %r15, %r15
je 0x18ee6
movq (%r15), %rdx
movq %rbp, %r12
cmpq %r14, %rdx
jne 0x18eb4
jmp 0x18f14
cmpq $-0x1, 0x50(%rbx)
je 0x18f7f
movq 0x30(%rsp), %rcx
leaq 0x1(%rcx), %r13
testq %rcx, %rcx
movq 0x20(%rsp), %r15
movl 0x1c(%rsp), %eax
je 0x18e83
jmp 0x18f7f
movq %rbp, %r15
movq %r12, %rbp
movq 0x20(%rsp), %r14
addq %r13, %r14
movq 0x10(%r15), %rax
testq %rbp, %rbp
je 0x18f2b
addq $0x10, %rbp
jmp 0x18f37
movq 0x28(%rsp), %rbp
shlq $0x3, %rbp
addq (%r14), %rbp
movl 0xc(%rsp), %ecx
movq %rax, (%rbp)
testl %ecx, %ecx
jne 0x18f76
movq (%rbx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x18f58
movq 0x8(%rbx), %rdi
movq (%r15), %rsi
callq *%rax
movq (%rbx), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x18f6e
movq 0x8(%rbx), %rdi
movq 0x8(%r15), %rsi
callq *%rax
movq %r15, %rdi
callq 0x1ffff
decq 0x18(%r14)
movq %r15, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x10(%rsp)
jmp 0x18f7f
xorl %ebp, %ebp
jmp 0x18f14
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictFreeUnlinkedEntry
void dictFreeUnlinkedEntry(dict *d, dictEntry *he) {
    if (he == NULL) return;
    dictFreeKey(d, he);
    dictFreeVal(d, he);
    zfree(he);
}

// Assembly:
testq %rsi, %rsi
je 0x18ff8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x18fd3
movq 0x8(%r14), %rdi
movq (%rbx), %rsi
callq *%rax
movq (%r14), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x18fe9
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ffff
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictClear
int _dictClear(dict *d, dictht *ht, void(callback)(void *)) {
    unsigned long i;

    /* Free all the elements */
    for (i = 0; i < ht->size && ht->used > 0; i++) {
        dictEntry *he, *nextHe;

        if (callback && (i & 65535) == 0) callback(d->privdata);

        if ((he = ht->table[i]) == NULL) continue;
        while(he) {
            nextHe = he->next;
            dictFreeKey(d, he);
            dictFreeVal(d, he);
            zfree(he);
            ht->used--;
            he = nextHe;
        }
    }
    /* Free the table and the allocated cache structure */
    zfree(ht->table);
    /* Re-initialize the table */
    _dictReset(ht);
    return DICT_OK; /* never fails */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x19095
movq %rdx, %r14
movq %rdi, %r15
xorl %r13d, %r13d
cmpq $0x0, 0x18(%rbx)
je 0x19095
testq %r14, %r14
sete %al
testw %r13w, %r13w
setne %cl
orb %al, %cl
jne 0x1903a
movq 0x8(%r15), %rdi
callq *%r14
movq (%rbx), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x1908c
movq 0x10(%r12), %rbp
movq (%r15), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x19061
movq 0x8(%r15), %rdi
movq (%r12), %rsi
callq *%rax
movq (%r15), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x19078
movq 0x8(%r15), %rdi
movq 0x8(%r12), %rsi
callq *%rax
movq %r12, %rdi
callq 0x1ffff
decq 0x18(%rbx)
movq %rbp, %r12
testq %rbp, %rbp
jne 0x19046
incq %r13
cmpq 0x8(%rbx), %r13
jb 0x1901b
movq (%rbx), %rdi
callq 0x1ffff
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictFind
dictEntry *dictFind(dict *d, const void *key)
{
    dictEntry *he;
    unsigned int h, idx, table;

    if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */
    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);
    for (table = 0; table <= 1; table++) {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        while(he) {
            if (key==he->key || dictCompareKeys(d, key, he->key))
                return he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) return NULL;
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
jne 0x19108
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
cmpq $-0x1, 0x50(%rdi)
je 0x19129
cmpq $0x0, 0x58(%r14)
jne 0x19129
movq %r14, %rdi
movl $0x1, %esi
callq 0x18971
leaq 0x10(%r14), %r12
movq (%r14), %rax
movq %rbx, %rdi
callq *(%rax)
xorl %r13d, %r13d
movq %r13, %rdx
shlq $0x5, %rdx
movl 0x10(%r12,%rdx), %ecx
movl %eax, %ebp
andl %eax, %ecx
movq (%r12,%rdx), %rax
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x1917c
movq (%r15), %rdx
cmpq %rbx, %rdx
je 0x190f6
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x19176
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
jne 0x190f6
movq 0x10(%r15), %r15
jmp 0x19150
cmpq $-0x1, 0x50(%r14)
je 0x190f3
leaq 0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
movl %ebp, %eax
movl $0x0, %r15d
je 0x19138
jmp 0x190f6
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictFingerprint
long long dictFingerprint(dict *d) {
    long long integers[6], hash = 0;
    int j;

    integers[0] = (long) d->ht[0].table;
    integers[1] = d->ht[0].size;
    integers[2] = d->ht[0].used;
    integers[3] = (long) d->ht[1].table;
    integers[4] = d->ht[1].size;
    integers[5] = d->ht[1].used;

    /* We hash N integers by summing every successive integer with the integer
     * hashing of the previous sum. Basically:
     *
     * Result = hash(hash(hash(int1)+int2)+int3) ...
     *
     * This way the same set of integers in a different order will (likely) hash
     * to a different number. */
    for (j = 0; j < 6; j++) {
        hash += integers[j];
        /* For the hashing step we use Tomas Wang's 64 bit integer hash. */
        hash = (~hash) + (hash << 21); // hash = (hash << 21) - hash - 1;
        hash = hash ^ (hash >> 24);
        hash = (hash + (hash << 3)) + (hash << 8); // hash * 265
        hash = hash ^ (hash >> 14);
        hash = (hash + (hash << 2)) + (hash << 4); // hash * 21
        hash = hash ^ (hash >> 28);
        hash = hash + (hash << 31);
    }
    return hash;
}

// Assembly:
movq 0x10(%rdi), %rax
movq %rax, -0x38(%rsp)
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rsp)
movq 0x28(%rdi), %rax
movq %rax, -0x28(%rsp)
movq 0x30(%rdi), %rax
movq %rax, -0x20(%rsp)
movq 0x38(%rdi), %rax
movq %rax, -0x18(%rsp)
movq 0x48(%rdi), %rax
movq %rax, -0x10(%rsp)
xorl %ecx, %ecx
xorl %eax, %eax
addq -0x38(%rsp,%rcx,8), %rax
movq %rax, %rdx
notq %rdx
shlq $0x15, %rax
addq %rdx, %rax
movq %rax, %rdx
sarq $0x18, %rdx
xorq %rax, %rdx
imulq $0x109, %rdx, %rax      # imm = 0x109
movq %rax, %rdx
sarq $0xe, %rdx
xorq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rdx,%rax,4), %rax
movq %rax, %rdx
sarq $0x1c, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shlq $0x1f, %rax
addq %rdx, %rax
incq %rcx
cmpq $0x6, %rcx
jne 0x191ef
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGetIterator
dictIterator *dictGetIterator(dict *d)
{
    dictIterator *iter = zmalloc(sizeof(*iter));

    iter->d = d;
    iter->table = 0;
    iter->index = -1;
    iter->safe = 0;
    iter->entry = NULL;
    iter->nextEntry = NULL;
    return iter;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x30, %edi
callq 0x1fea5
movq %rbx, (%rax)
xorl %ecx, %ecx
movl %ecx, 0x10(%rax)
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rax)
movl %ecx, 0x24(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictNext
dictEntry *dictNext(dictIterator *iter)
{
    while (1) {
        if (iter->entry == NULL) {
            dictht *ht = &iter->d->ht[iter->table];
            if (iter->index == -1 && iter->table == 0) {
                if (iter->safe)
                    iter->d->iterators++;
                else
                    iter->fingerprint = dictFingerprint(iter->d);
            }
            iter->index++;
            if (iter->index >= (long) ht->size) {
                if (dictIsRehashing(iter->d) && iter->table == 0) {
                    iter->table++;
                    iter->index = 0;
                    ht = &iter->d->ht[1];
                } else {
                    break;
                }
            }
            iter->entry = ht->table[iter->index];
        } else {
            iter->entry = iter->nextEntry;
        }
        if (iter->entry) {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->nextEntry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x192b8
leaq 0x20(%rbx), %rax
jmp 0x19339
movq (%rbx), %r14
movq 0x8(%rbx), %r12
movl 0x10(%rbx), %ebp
movslq %ebp, %rax
movq %rax, %rcx
shlq $0x5, %rcx
leaq (%r14,%rcx), %r15
addq $0x10, %r15
cmpq $-0x1, %r12
sete %cl
testl %eax, %eax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x192fe
cmpl $0x0, 0x14(%rbx)
je 0x192f2
incq 0x58(%r14)
jmp 0x192fe
movq %r14, %rdi
callq 0x191b5
movq %rax, 0x28(%rbx)
incq %r12
movq %r12, 0x8(%rbx)
cmpq 0x8(%r15), %r12
jl 0x1932e
xorl %eax, %eax
cmpq $-0x1, 0x50(%r14)
je 0x19351
testl %ebp, %ebp
jne 0x19351
movl $0x1, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x30, %r14
movq %r14, %r15
movq 0x8(%rbx), %rax
shlq $0x3, %rax
addq (%r15), %rax
movq (%rax), %rax
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x192b8
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictReleaseIterator
void dictReleaseIterator(dictIterator *iter)
{
    if (!(iter->index == -1 && iter->table == 0)) {
        if (iter->safe)
            iter->d->iterators--;
        else
            assert(iter->fingerprint == dictFingerprint(iter->d));
    }
    zfree(iter);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1, 0x8(%rdi)
jne 0x1936e
cmpl $0x0, 0x10(%rbx)
je 0x1938e
cmpl $0x0, 0x14(%rbx)
je 0x1937d
movq (%rbx), %rax
decq 0x58(%rax)
jmp 0x1938e
movq (%rbx), %rdi
movq 0x28(%rbx), %r14
callq 0x191b5
cmpq %rax, %r14
jne 0x1939d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ffff
leaq 0x38e27(%rip), %rdi     # 0x521cb
leaq 0x38e19(%rip), %rsi     # 0x521c4
movl $0x28c, %edx            # imm = 0x28C
callq 0x2a9ff
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGetRandomKey
dictEntry *dictGetRandomKey(dict *d)
{
    dictEntry *he, *orighe;
    unsigned int h;
    int listlen, listele;

    if (dictSize(d) == 0) return NULL;
    if (dictIsRehashing(d)) _dictRehashStep(d);
    if (dictIsRehashing(d)) {
        do {
            /* We are sure there are no elements in indexes from 0
             * to rehashidx-1 */
            h = d->rehashidx + (random() % (d->ht[0].size +
                                            d->ht[1].size -
                                            d->rehashidx));
            he = (h >= d->ht[0].size) ? d->ht[1].table[h - d->ht[0].size] :
                                      d->ht[0].table[h];
        } while(he == NULL);
    } else {
        do {
            h = random() & d->ht[0].sizemask;
            he = d->ht[0].table[h];
        } while(he == NULL);
    }

    /* Now we found a non empty bucket, but it is a linked
     * list and we need to get a random element from the list.
     * The only sane way to do so is counting the elements and
     * select a random index. */
    listlen = 0;
    orighe = he;
    while(he) {
        he = he->next;
        listlen++;
    }
    listele = random() % listlen;
    he = orighe;
    while(listele--) he = he->next;
    return he;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
jne 0x193d5
xorl %r14d, %r14d
jmp 0x1947c
movq %rdi, %rbx
cmpq $-0x1, 0x50(%rdi)
je 0x193f3
cmpq $0x0, 0x58(%rbx)
jne 0x193f3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x18971
cmpq $-0x1, 0x50(%rbx)
je 0x1943f
movl 0x50(%rbx), %ebp
callq 0x125a0
movq 0x18(%rbx), %rcx
movq 0x38(%rbx), %rsi
addq %rcx, %rsi
subq 0x50(%rbx), %rsi
xorl %edx, %edx
divq %rsi
addl %ebp, %edx
movq %rdx, %rax
subq %rcx, %rax
jae 0x1942d
shlq $0x3, %rdx
addq 0x10(%rbx), %rdx
movq %rdx, %rax
jmp 0x19435
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x193fa
jmp 0x19454
callq 0x125a0
movq 0x10(%rbx), %rcx
andl 0x20(%rbx), %eax
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x1943f
xorl %ebx, %ebx
movq %r14, %rax
movq 0x10(%rax), %rax
incq %rbx
testq %rax, %rax
jne 0x19459
callq 0x125a0
cqto
idivq %rbx
testq %rdx, %rdx
je 0x1947c
movq 0x10(%r14), %r14
decl %edx
jne 0x19474
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictEmpty
void dictEmpty(dict *d, void(callback)(void*)) {
    _dictClear(d,&d->ht[0],callback);
    _dictClear(d,&d->ht[1],callback);
    d->rehashidx = -1;
    d->iterators = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq %rbx, %rdx
callq 0x18ff9
leaq 0x30(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x18ff9
movq $-0x1, 0x50(%r14)
movq $0x0, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGetStats
void dictGetStats(char *buf, size_t bufsize, dict *d) {
    size_t l;
    char *orig_buf = buf;
    size_t orig_bufsize = bufsize;

    l = _dictGetStatsHt(buf,bufsize,&d->ht[0],0);
    buf += l;
    bufsize -= l;
    if (dictIsRehashing(d) && bufsize > 0) {
        _dictGetStatsHt(buf,bufsize,&d->ht[1],1);
    }
    /* Make sure there is a NULL term at the end. */
    if (orig_bufsize) orig_buf[orig_bufsize-1] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x197fc
cmpq $-0x1, 0x50(%r15)
setne %cl
movq %rbx, %rsi
subq %rax, %rsi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x19ab1
addq %r14, %rax
addq $0x30, %r15
movq %rax, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x197fc
testq %rbx, %rbx
je 0x19abc
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: authCommand
void authCommand(client *c) {
    if (!server.requirepass) {
        addReplyError(c,"Client sent AUTH, but no password is set");
    } else if (!time_independent_strcmp(c->argv[1]->ptr, server.requirepass)) {
      c->authenticated = 1;
      addReply(c,shared.ok);
    } else {
      c->authenticated = 0;
      addReplyError(c,"invalid password");
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x55601(%rip), %rsi     # 0x6f0d0
testq %rsi, %rsi
je 0x19afc
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c652
testl %eax, %eax
je 0x19b0c
movl $0x0, 0x8c(%rbx)
leaq 0x39767(%rip), %rsi     # 0x53261
jmp 0x19b03
leaq 0x39735(%rip), %rsi     # 0x53238
movq %rbx, %rdi
popq %rbx
jmp 0x2230a
movl $0x1, 0x8c(%rbx)
movq 0x55c83(%rip), %rsi     # 0x6f7a0
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: pingCommand
void pingCommand(client *c) {
    /* The command takes zero or one arguments. */
    if (c->argc > 2) {
        addReplyErrorFormat(c,"wrong number of arguments for '%s' command",
            c->cmd->name);
        return;
    }

    if (c->flags & CLIENT_PUBSUB) {
        addReply(c,shared.mbulkhdr[2]);
        addReplyBulkCBuffer(c,"pong",4);
        if (c->argc == 1)
            addReplyBulkCBuffer(c,"",0);
        else
            addReplyBulk(c,c->argv[1]);
    } else {
        if (c->argc == 1)
            addReply(c,shared.pong);
        else
            addReplyBulk(c,c->argv[1]);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
jl 0x19b4b
movq 0x38(%rbx), %rax
movq (%rax), %rdx
leaq 0x39587(%rip), %rsi     # 0x530c7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x22331
testb $0x4, 0x8a(%rbx)
jne 0x19b69
cmpl $0x1, %eax
jne 0x19ba4
movq 0x55c70(%rip), %rsi     # 0x6f7d0
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
movq 0x69600(%rip), %rsi     # 0x83170
movq %rbx, %rdi
callq 0x21f58
leaq 0x396f3(%rip), %rsi     # 0x53272
movl $0x4, %edx
movq %rbx, %rdi
callq 0x22a7d
cmpl $0x1, 0x28(%rbx)
jne 0x19ba4
leaq 0x3b66c(%rip), %rsi     # 0x55205
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x22a7d
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x22a4a
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: infoCommand
void infoCommand(client *c) {
    char *section = c->argc == 2 ? c->argv[1]->ptr : "default";

    if (c->argc > 2) {
        addReply(c,shared.syntaxerr);
        return;
    }
    addReplyBulkSds(c, genDiscntInfoString(section));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x2, %eax
jne 0x19bcf
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdi
jmp 0x19bd6
leaq 0x39762(%rip), %rdi     # 0x53338
cmpl $0x3, %eax
jl 0x19beb
movq 0x55c36(%rip), %rsi     # 0x6f818
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
callq 0x1c9d2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x22abd
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: shutdownCommand
void shutdownCommand(client *c) {
    int flags = 0;

    if (c->argc > 2) {
        addReply(c,shared.syntaxerr);
        return;
    } else if (c->argc == 2) {
        if (!strcasecmp(c->argv[1]->ptr,"nosave")) {
            flags |= SHUTDOWN_NOSAVE;
        } else if (!strcasecmp(c->argv[1]->ptr,"save")) {
            flags |= SHUTDOWN_SAVE;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    }
    /* When SHUTDOWN is called while the server is loading a dataset in
     * memory we need to make sure no attempt is performed to save
     * the dataset on shutdown (otherwise it could overwrite the current DB
     * with half-read data).
     */
    if (server.loading)
        flags = (flags & ~SHUTDOWN_SAVE) | SHUTDOWN_NOSAVE;
    if (prepareForShutdown(flags) == C_OK) exit(0);
    addReplyError(c,"Errors trying to SHUTDOWN. Check logs.");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %ecx
cmpl $0x3, %ecx
jl 0x19c21
movq 0x55c06(%rip), %rsi     # 0x6f818
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f58
xorl %eax, %eax
cmpl $0x2, %ecx
jne 0x19c66
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
leaq 0x3963c(%rip), %rsi     # 0x53277
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
je 0x19c61
leaq 0x3ef4f(%rip), %rsi     # 0x58b9d
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
jne 0x19c0b
movl $0x1, %eax
jmp 0x19c66
movl $0x2, %eax
cmpl $0x0, 0x5573b(%rip)     # 0x6f3a8
movl $0x2, %edi
cmovel %eax, %edi
callq 0x1c570
testl %eax, %eax
je 0x19c94
leaq 0x395f9(%rip), %rsi     # 0x5327e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230a
xorl %edi, %edi
callq 0x12870
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: monitorCommand
void monitorCommand(client *c) {
    /* ignore MONITOR if already in monitor mode */
    if (c->flags & CLIENT_MONITOR) return;

    c->flags |= CLIENT_MONITOR;
    listAddNodeTail(server.monitors,c);
    addReply(c,shared.ok);
}

// Assembly:
movl 0x88(%rdi), %eax
testb $0x4, %al
jne 0x19cdd
pushq %rbx
movq %rdi, %rbx
orl $0x4, %eax
movl %eax, 0x88(%rdi)
movq 0x555bb(%rip), %rdi     # 0x6f280
movq %rbx, %rsi
callq 0x16aff
movq 0x55acc(%rip), %rsi     # 0x6f7a0
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: timeCommand
void timeCommand(client *c) {
    struct timeval tv;

    /* gettimeofday() can only fail if &tv is a bad address so we
     * don't check for errors. */
    gettimeofday(&tv,NULL);
    addReplyMultiBulkLen(c,2);
    addReplyBulkLongLong(c,tv.tv_sec);
    addReplyBulkLongLong(c,tv.tv_usec);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x12340
movl $0x2, %esi
movq %rbx, %rdi
callq 0x22976
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x22b4c
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x22b4c
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/server.c
// Function: commandCommand
void commandCommand(client *c) {
    dictIterator *di;
    dictEntry *de;

    if (c->argc == 1) {
        addReplyMultiBulkLen(c, dictSize(server.commands));
        di = dictGetIterator(server.commands);
        while ((de = dictNext(di)) != NULL) {
            addReplyCommand(c, dictGetVal(de));
        }
        dictReleaseIterator(di);
    } else if (!strcasecmp(c->argv[1]->ptr, "info")) {
        int i;
        addReplyMultiBulkLen(c, c->argc-2);
        for (i = 2; i < c->argc; i++) {
            addReplyCommand(c, dictFetchValue(server.commands, c->argv[i]->ptr));
        }
    } else if (!strcasecmp(c->argv[1]->ptr, "count") && c->argc == 2) {
        addReplyLongLong(c, dictSize(server.commands));
    } else {
        addReplyError(c, "Unknown subcommand or wrong number of arguments.");
        return;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x28(%rdi), %r14
cmpq $0x1, %r14
jne 0x19d78
movq 0x55375(%rip), %rax     # 0x6f0b0
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x22976
movq 0x5535e(%rip), %rdi     # 0x6f0b0
callq 0x19242
movq %rax, %r14
movq %rax, %rdi
callq 0x1929d
testq %rax, %rax
je 0x19dcc
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x1c74b
movq %r14, %rdi
jmp 0x19d5d
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r15
leaq 0x3870e(%rip), %rsi     # 0x52499
movq %r15, %rdi
callq 0x12090
testl %eax, %eax
je 0x19dd9
leaq 0x3953f(%rip), %rsi     # 0x532dd
movq %r15, %rdi
callq 0x12090
cmpl $0x2, %r14d
jne 0x19e29
testl %eax, %eax
jne 0x19e29
movq 0x552f9(%rip), %rax     # 0x6f0b0
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x22941
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1935a
addq $-0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22976
cmpl $0x3, 0x28(%rbx)
jl 0x19e23
movl $0x2, %r14d
movq 0x552b5(%rip), %rdi     # 0x6f0b0
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
callq 0x191a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c74b
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x19df4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x394b3(%rip), %rsi     # 0x532e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2230a