LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;

    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    LakeKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rax
movq 0x130(%rsp), %rax
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movq %r9, 0xf8(%rsp)
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rcx
leaq 0x18(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5390
movq 0x110(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x108(%rsp), %rcx
movq 0x100(%rsp), %r8
movq 0xf8(%rsp), %r9
movq 0x120(%rsp), %rax
addq 0x108(%rsp), %rax
leaq 0x18(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5180
movq 0x108(%rsp), %rcx
addq $0x10, %rcx
movq 0x118(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( LakeKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char *)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq 0x150(%rsp), %rax
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rax
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
movq %rdx, 0x118(%rsp)
movq %rcx, 0x110(%rsp)
movq %r8, 0x108(%rsp)
movq %r9, 0x100(%rsp)
cmpq $0x10, 0x108(%rsp)
jae 0x1af3a
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x1b00d
movq 0x150(%rsp), %rsi
movq 0x148(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5390
movq 0x108(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x120(%rsp), %rax
movq %rcx, (%rax)
movq 0x110(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x100(%rsp), %r8
movq 0x140(%rsp), %r9
movq 0x110(%rsp), %rax
addq 0x18(%rsp), %rax
leaq 0x20(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5180
cmpl $0x1, %eax
jne 0x1b002
movl $0x0, 0x134(%rsp)
jmp 0x1b00d
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
movl 0x134(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_int_hash_function
unsigned int dict_int_hash_function(unsigned int key)
{
    key += ~(key << 15);
    key ^= (key >> 10);
    key += (key << 3);
    key ^= (key >> 6);
    key += ~(key << 11);
    key ^= (key >> 16);
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0xf, %eax
xorl $-0x1, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0xa, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x3, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x6, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0xb, %eax
xorl $-0x1, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_gen_hash_function
unsigned int dict_gen_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1505, -0x10(%rbp)    # imm = 0x1505
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x2574
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x2542
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_gen_case_hash_function
unsigned int dict_gen_case_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1505, -0x10(%rbp)    # imm = 0x1505
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x25d5
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %edi
callq 0x2290
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x2596
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_init
int _dict_init(dict *d, void *priv_data_ptr)
{
    _dict_reset(&d->ht[0]);
    _dict_reset(&d->ht[1]);
    d->privdata = priv_data_ptr;
    d->rehashidx = -1;
    d->iterators = 0;

    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x29e0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x20, %rdi
callq 0x29e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_resize
int dict_resize(dict *d)
{
    int minimal;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0xbb5d(%rip)      # 0xe1f0
je 0x269f
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
je 0x26a8
movl $0x1, -0x4(%rbp)
jmp 0x26d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x26c0
movl $0x4, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x26e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_expand
int dict_expand(dict *d, unsigned long size)
{
    dictht n;                   /* the new hashtable */
    unsigned long realsize = _dict_next_power(size);

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

    /* Allocate the new hashtable and initialize all pointers to NULL */
    n.size = realsize;
    n.sizemask = realsize - 1;
    n.table = (dict_entry**)calloc(1, realsize * sizeof(dict_entry *));
    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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27d0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x2715
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2721
movl $0x1, -0x4(%rbp)
jmp 0x27c1
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rsi
shlq $0x3, %rsi
movl $0x1, %edi
callq 0x21f0
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x278b
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x27c1
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x48(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_next_power
static unsigned long _dict_next_power(unsigned long size)
{
    unsigned long i = DICT_HT_INITIAL_SIZE;

    if (size >= LONG_MAX)
        return LONG_MAX;
    while (1)
    {
        if (i >= size)
            return i;
        i *= 2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x4, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jb 0x2800
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x2823
jmp 0x2802
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x2816
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2823
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x2802
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_reset
static void _dict_reset(dictht *ht)
{
    ht->table = NULL;
    ht->size = 0;
    ht->sizemask = 0;
    ht->used = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_rehash_milliseconds
int dict_rehash_milliseconds(dict *d, int ms)
{
    long long start = time_in_milliseconds();
    int rehashes = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x2a20
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x64, %esi
callq 0x2830
cmpl $0x0, %eax
je 0x2ab1
movl -0x1c(%rbp), %eax
addl $0x64, %eax
movl %eax, -0x1c(%rbp)
callq 0x2a20
subq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jle 0x2aaf
jmp 0x2ab1
jmp 0x2a7f
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_add
int dict_add(dict *d, void *key, int keylen, void *val, int vallen)
{
    int index;
    dict_entry *entry;
    dictht *ht;

    if (dict_is_rehashing(d))
        _dict_rehash_step(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    if ((index = _dict_key_index(d, key, keylen)) == -1)
    {
        return DICT_ERR;
    }

    /* Allocates the memory and stores key */
    ht = dict_is_rehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = (dict_entry*)malloc(sizeof(*entry));

    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    /* Set the hash entry fields. */
    entry->key = key;
    entry->keylen = keylen;
    entry->val = val;
    entry->vallen = vallen;

    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
je 0x2aee
movq -0x10(%rbp), %rdi
callq 0x2bd0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2c00
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x2b12
movl $0x1, -0x4(%rbp)
jmp 0x2bbc
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
je 0x2b2e
movq -0x10(%rbp), %rax
addq $0x8, %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
jmp 0x2b3a
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x22b0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_key_index
static int _dict_key_index(dict *d, const void *key, int keylen)
{
    unsigned int h, idx, table;
    dict_entry *he;

    /* Expand the hashtable if needed */
    if (_dict_expand_if_needed(d) == DICT_ERR)
    {
        return -1;
    }
    /* Compute the key hash value */
    h = dict_gen_hash_function((const unsigned char*)key, keylen);

    for (table = 0; table <= 1; table++)
    {
        idx = h & d->ht[table].sizemask;
        /* Search if this slot does not already contain the given key */
        he = d->ht[table].table[idx];
        while (he)
        {
            if ((keylen == (int)he->keylen) && (memcmp(key, he->key, keylen) == 0))
            {
                return -1;
            }
            he = he->next;
        }
        if (!dict_is_rehashing(d))
            break;
    }

    return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bd0
cmpl $0x1, %eax
jne 0x2c2d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cee
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2530
movl %eax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
ja 0x2ce8
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movl -0x28(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
andq 0x10(%rcx), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x28(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2ccc
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2cbe
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21e0
cmpl $0x0, %eax
jne 0x2cbe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cee
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2c89
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x2cd8
jmp 0x2ce8
jmp 0x2cda
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2c43
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_replace
int dict_replace(dict *d, void *key, int keylen, void *val, int vallen)
{
    dict_entry *entry, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
    if (dict_add(d, key, keylen, val, vallen) == DICT_OK)
        return 1;
    /* It already exists, get the entry */
    entry = dict_find(d, key, keylen);
    /* Free the old value and set the new one */
    /* 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 = *entry;
    entry->val = val;
    entry->vallen = vallen;

    free(auxentry.val);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x2ac0
cmpl $0x0, %eax
jne 0x2d41
movl $0x1, -0x4(%rbp)
jmp 0x2d9e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2db0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x48(%rbp), %rdi
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_find
dict_entry *dict_find(dict *d, const void *key, int keylen)
{
    dict_entry *he;
    unsigned int h, idx, table;

    if (d->ht[0].size == 0)
        return NULL;            /* We don't have a table at all */
    if (dict_is_rehashing(d))
        _dict_rehash_step(d);
    h = dict_gen_hash_function((const unsigned char*)key, keylen);

    unsigned int keylen_ = keylen;

    for (table = 0; table <= 1; table++)
    {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        while (he)
        {
            if ((keylen_ == he->keylen) && (memcmp(key, he->key, keylen_) == 0))
            {
                return he;
            }
            he = he->next;
        }
        if (!dict_is_rehashing(d))
            return NULL;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2ddb
movq $0x0, -0x8(%rbp)
jmp 0x2ec1
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
je 0x2dee
movq -0x10(%rbp), %rdi
callq 0x2bd0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2530
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
ja 0x2eb9
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movl -0x34(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
andq 0x10(%rcx), %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x34(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e95
movl -0x38(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2e87
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x21e0
cmpl $0x0, %eax
jne 0x2e87
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ec1
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2e50
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x2ea9
movq $0x0, -0x8(%rbp)
jmp 0x2ec1
jmp 0x2eab
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2e0a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_clear
int _dict_clear(dict *d, dictht *ht)
{
    unsigned long i;

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

        if ((he = ht->table[i]) == NULL)
            continue;
        while (he)
        {
            next_he = he->next;

            free(he->key);
            free(he->val);
            free(he);

            ht->used--;
            he = next_he;
        }
    }
    /* Free the table and the allocated cache structure */
    free(ht->table);
    /* Re-initialize the table */
    _dict_reset(ht);

    return DICT_OK;             /* never fails */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0x312a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3136
jmp 0x31b6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3151
jmp 0x31a5
jmp 0x3153
cmpq $0x0, -0x20(%rbp)
je 0x31a3
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3153
jmp 0x31a5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3108
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x29e0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_get_iterator
dict_iterator *dict_get_iterator(dict *d)
{
    dict_iterator *iter = (dict_iterator*)malloc(sizeof(*iter));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x22b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_next
dict_entry *dict_next(dict_iterator *iter)
{
    while (1)
    {
        if (iter->entry == NULL)
        {
            dictht *ht = &iter->d->ht[iter->table];
            if (iter->safe && iter->index == -1 && iter->table == 0)
                iter->d->iterators++;
            iter->index++;
            if (iter->index >= (signed) ht->size)
            {
                if (dict_is_rehashing(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->next_entry;
        }
        if (iter->entry)
        {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->next_entry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3408
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x3383
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x3383
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3383
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jl 0x33eb
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x48(%rax)
je 0x33e7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x33e7
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x33e9
jmp 0x344a
jmp 0x33eb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3418
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3445
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3452
jmp 0x3328
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_empty
void dict_empty(dict *d)
{
    _dict_clear(d, &d->ht[0]);
    _dict_clear(d, &d->ht[1]);
    d->rehashidx = -1;
    d->iterators = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x30f0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
addq $0x20, %rsi
callq 0x30f0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_print_stats
void dict_print_stats(dict *d)
{
    _dict_print_stats_ht(&d->ht[0]);
    if (dict_is_rehashing(d))
    {
        printf("-- Rehashing into ht[1]:\n");
        _dict_print_stats_ht(&d->ht[1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x36d0
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
je 0x36c2
leaq 0x695e(%rip), %rdi      # 0xa008
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x20, %rdi
callq 0x36d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dict.c
// Function: dict_expand_if_needed
static int _dict_expand_if_needed(dict *d)
{
    /* Incremental rehashing already in progress. Return. */
    if (dict_is_rehashing(d))
        return DICT_OK;

    /* If the hash table is empty expand it to the intial size. */
    if (d->ht[0].size == 0)
        return dict_expand(d, DICT_HT_INITIAL_SIZE);

    /* If we reached the 1:1 ratio, and we are allowed to resize the hash
     * table (global setting) or we should avoid it but the ratio between
     * elements/buckets is over the "safe" threshold, we resize doubling
     * the number of buckets. */
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize ||
         d->ht[0].used / d->ht[0].size > dict_force_resize_ratio))
    {
        return dict_expand(d, ((d->ht[0].size > d->ht[0].used) ?
                              d->ht[0].size : 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, 0x48(%rax)
je 0x3bf2
movl $0x0, -0x4(%rbp)
jmp 0x3c9b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3c13
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x26e0
movl %eax, -0x4(%rbp)
jmp 0x3c9b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x3c94
cmpl $0x0, 0xa5c4(%rip)      # 0xe1f0
jne 0x3c4b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movl 0xa5ae(%rip), %ecx      # 0xe1f4
cmpq %rcx, %rax
jbe 0x3c94
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x3c73
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3c7f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq %rsi
callq 0x26e0
movl %eax, -0x4(%rbp)
jmp 0x3c9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_create
list *list_create(void)
{
    struct list *list;

    if ((list = malloc(sizeof(*list))) == NULL)
        return NULL;
    list->head = list->tail = NULL;
    list->len = 0;
/*    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;*/
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x22b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3cd6
movq $0x0, -0x8(%rbp)
jmp 0x3d01
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_release
void list_release(list *list, int nofree)
{
    unsigned long len;
    list_node *current, *next;

    current = list->head;
    len = list->len;
    while(len--) {
        next = current->next;
        if (AL_FREE == nofree)
            free(current->value);
        free(current);
        current = next;
    }
    free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3d7e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x3d6b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3d36
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_add_node_head
list *list_add_node_head(list *list, void *value)
{
    list_node *node;

    if ((node = malloc(sizeof(*node))) == NULL)
        return NULL;
    node->value = value;
    if (list->len == 0) {
        list->head = list->tail = node;
        node->prev = node->next = NULL;
    } else {
        node->prev = NULL;
        node->next = list->head;
        list->head->prev = node;
        list->head = node;
    }
    list->len++;
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3dc1
movq $0x0, -0x8(%rbp)
jmp 0x3e4f
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3e04
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3e37
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_add_node_tail
list *list_add_node_tail(list *list, void *value)
{
    list_node *node;

    if ((node = malloc(sizeof(*node))) == NULL)
        return NULL;
    node->value = value;
    if (list->len == 0) {
        list->head = list->tail = node;
        node->prev = node->next = NULL;
    } else {
        node->prev = list->tail;
        node->next = NULL;
        list->tail->next = node;
        list->tail = node;
    }
    list->len++;
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3e91
movq $0x0, -0x8(%rbp)
jmp 0x3f23
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3ed4
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3f0b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_insert_node
list *list_insert_node(list *list, list_node *old_node, void *value, int after) {
    list_node *node;

    if ((node = malloc(sizeof(*node))) == NULL)
        return NULL;
    node->value = value;
    if (after) {
        node->prev = old_node;
        node->next = old_node->next;
        if (list->tail == old_node) {
            list->tail = node;
        }
    } else {
        node->next = old_node;
        node->prev = old_node->prev;
        if (list->head == old_node) {
            list->head = node;
        }
    }
    if (node->prev != NULL) {
        node->prev->next = node;
    }
    if (node->next != NULL) {
        node->next->prev = node;
    }
    list->len++;
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x18, %edi
callq 0x22b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3f68
movq $0x0, -0x8(%rbp)
jmp 0x4030
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x3fb1
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3faf
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3fe5
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3fe3
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3fe5
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ffe
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4018
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_del_node
void list_del_node(list *list, list_node *node, int nofree)
{
    if (node->prev)
        node->prev->next = node->next;
    else
        list->head = node->next;
    if (node->next)
        node->next->prev = node->prev;
    else
        list->tail = node->prev;
    if(AL_FREE == nofree)
        free(node->value);
    free(node);
    list->len--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4072
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x4081
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x40a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x40af
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x40c3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_get_iterator
list_iter *list_get_iterator(list *list, int direction)
{
    list_iter *iter;
    
    if ((iter = malloc(sizeof(*iter))) == NULL) return NULL;
    if (direction == AL_START_HEAD)
        iter->next = list->head;
    else
        iter->next = list->tail;
    iter->direction = direction;
    return iter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x10, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x411d
movq $0x0, -0x8(%rbp)
jmp 0x4154
cmpl $0x0, -0x14(%rbp)
jne 0x4133
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4142
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_next
list_node *list_next(list_iter *iter)
{
    list_node *current = iter->next;

    if (current != NULL) {
        if (iter->direction == AL_START_HEAD)
            iter->next = current->next;
        else
            iter->next = current->prev;
    }
    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4225
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4215
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4223
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4225
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_search_key
list_node *list_search_key(list *list, void *key, int len)
{
    list_iter *iter;
    list_node *node;

    iter = list_get_iterator(list, AL_START_HEAD);
    while((node = list_next(iter)) != NULL) {
        if (len > 0) {
            if (memcmp(node->value, key, len) == 0) {
                list_release_iterator(iter);
                return node;
            }
        } else {
            if (key == node->value) {
                list_release_iterator(iter);
                return node;
            }
        }
    }
    list_release_iterator(iter);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x40f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x41e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x42bf
cmpl $0x0, -0x1c(%rbp)
jle 0x429a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21e0
cmpl $0x0, %eax
jne 0x4298
movq -0x28(%rbp), %rdi
callq 0x4160
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42d0
jmp 0x42bd
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x42bb
movq -0x28(%rbp), %rdi
callq 0x4160
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42d0
jmp 0x42bd
jmp 0x4252
movq -0x28(%rbp), %rdi
callq 0x4160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_index
list_node *list_index(list *list, long index) {
    list_node *n;

    if (index < 0) {
        index = (-index)-1;
        n = list->tail;
        while(index-- && n) n = n->prev;
    } else {
        n = list->head;
        while(index-- && n) n = n->next;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x434a
xorl %eax, %eax
subq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x4332
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x433b
jmp 0x4348
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x430d
jmp 0x4393
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1a(%rbp)
je 0x437a
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x4383
jmp 0x4391
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4355
jmp 0x4393
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/dlist.c
// Function: list_rotate
void list_rotate(list *list) {
    list_node *tail = list->tail;

    if (list_length(list) <= 1) return;

    /* Detach current tail */
    list->tail = tail->prev;
    list->tail->next = NULL;
    /* Move it as head */
    list->head->prev = tail;
    tail->prev = NULL;
    tail->next = list->head;
    list->head = tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x10(%rax)
ja 0x43c1
jmp 0x4413
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/iniconf.c
// Function: ini_destroy
int ini_destroy(ini_conf_t* ini)
{
    dict_iterator* it = dict_get_safe_iterator(ini);
    dict_entry* de = NULL;
    while((de = dict_next(it)) != NULL) {
        dict* v = (dict*)dict_get_entry_val(de);
        dict_delete_no_free(ini, de->key, de->keylen);

        free(de->key);

        dict_release(v);
    }
    dict_release_iterator(it);
    dict_release(ini);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32f0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x448f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x30c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x31e0
jmp 0x4441
movq -0x10(%rbp), %rdi
callq 0x3460
movq -0x8(%rbp), %rdi
callq 0x31e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/iniconf.c
// Function: read_line
static int read_line(int fd, char* buf, int size)
{
    int index = 0;
    int rd = 0;
    char ch;

    memset(buf, 0, size);

    while((rd = read(fd, &ch, 1)) > 0){
        if(ch != '\n'){
            if(index <= size){
                buf[index++] = ch;
            }else{
                return -1;
            }
        }else{
            break;
        }
    }
    if(index > 0){
        if(buf[index - 1] == '\r'){
            buf[index - 1] = 0;
            index--;
        }
    }
    if(rd <= 0){
        return -1;
    }

    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
movl -0x8(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x4912
movsbl -0x1d(%rbp), %eax
cmpl $0xa, %eax
je 0x490e
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x4903
movb -0x1d(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x490c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x495f
jmp 0x4910
jmp 0x4912
jmp 0x48bf
cmpl $0x0, -0x18(%rbp)
jle 0x494a
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x4948
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x494a
cmpl $0x0, -0x1c(%rbp)
jg 0x4959
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x495f
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/iniconf.c
// Function: ini_insert_sec
ini_sec_t* ini_insert_sec(ini_conf_t* ini, const char* key)
{
    if (!ini || !key)
        return NULL ;

    int len = strlen(key);
    char* k = (char*)malloc(len + 1);
    strcpy(k, key);

    dict* v = dict_create(NULL);

    if(dict_add(ini, k, len, v, sizeof(v)) == DICT_OK){
        return v;
    }

    dict_release(v);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x498e
cmpq $0x0, -0x18(%rbp)
jne 0x4998
movq $0x0, -0x8(%rbp)
jmp 0x4a0a
movq -0x18(%rbp), %rdi
callq 0x2120
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x22b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
xorl %eax, %eax
movl %eax, %edi
callq 0x25e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
movl $0x8, %r8d
callq 0x2ac0
cmpl $0x0, %eax
jne 0x49f9
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a0a
movq -0x30(%rbp), %rdi
callq 0x31e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)