LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdict_search
int hdict_search(hdb_t *hdb, const char* label, const char* key, off_t *off, uint32_t *length, hdict_t **hdict){
    int hit = 0;
    if (NULL == label || NULL == key){
        return hit;
    }
    hdict_t *hd;
    uint64_t hdid = bkdr_hash(label);
    uint32_t hash = HASH(hdid);
    LOCK(hdb);
    hd = LIST_FIRST(&hdb->htab[hash]);

    while(hd){
        if (hd->hdid == hdid) {
            hd->ref++;
            *hdict = hd;
            if (hd->hdict_meta->idx_type == 2){
                hit = hdict_seek_v2(*hdict, key, off, length);
            }else{
                hit = hdict_seek(*hdict, key, off, length);
            }
            (*hdict)->num_qry++;
            if (hit){
                hd->ref--;
                UNLK(hdb);
                return hit;
            }
            hd->ref--;
            hd = LIST_NEXT(hd, h_link);
        }else{
            hd = LIST_NEXT(hd, h_link);
        }
    }
    UNLK(hdb);
    return hit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r12
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x2e44
movq %r9, %r14
movq %rdx, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x42a0
movq %rax, %rbp
movq %rbx, %r15
movl %ebp, %ebx
andl $0x3ff, %ebx            # imm = 0x3FF
movq %r15, %rdi
callq 0x2470
movq %r15, 0x10(%rsp)
movq 0x50(%r15,%rbx,8), %rbx
testq %rbx, %rbx
je 0x2e37
cmpq %rbp, 0x50(%rbx)
jne 0x2e31
incl 0x4c(%rbx)
movq %rbx, (%r14)
movq 0x58(%rbx), %rax
cmpb $0x2, 0x4(%rax)
jne 0x2e0d
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x2bce
jmp 0x2e20
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x2b3f
movl %eax, %r15d
movq (%r14), %rax
incl 0x48(%rax)
decl 0x4c(%rbx)
testl %r15d, %r15d
jne 0x2e3a
movq 0x10(%rbx), %rbx
jmp 0x2ddd
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
callq 0x22b0
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_mgr
void *hdb_mgr(void *arg)
{
    hdb_t *hdb = (hdb_t *)arg;

    for (;;) {
        if (TAILQ_FIRST(&hdb->close_list)) {
            hdict_t *hdict, *next;
            hdict_t *hdicts[100];
            int i, k = 0;

            LOCK(hdb);
            for (hdict = TAILQ_FIRST(&hdb->close_list); hdict; hdict = next) {
                next = TAILQ_NEXT(hdict, link);
                if (hdict->ref == 0) {
                    hdicts[k++] = hdict;
                    TAILQ_REMOVE(&hdb->close_list, hdict, link);
                    hdb->num_close--;
                    if (k == 100)
                        break;
                }
            }
            UNLK(hdb);

            for (i = 0; i < k; ++i) {
                hdict = hdicts[i];
                hdict_close(hdict);
            }
        }
        sleep(1);
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rdi, %rbx
cmpq $0x0, 0x38(%rbx)
je 0x2f26
movq %rbx, %rdi
callq 0x2470
movq 0x38(%rbx), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x2f03
movq (%rax), %rcx
cmpl $0x0, 0x4c(%rax)
jne 0x2ef4
movslq %ebp, %rdx
movq %rax, (%rsp,%rdx,8)
movq 0x8(%rax), %rdx
testq %rcx, %rcx
je 0x2edf
movq %rdx, 0x8(%rcx)
jmp 0x2ee3
movq %rdx, 0x40(%rbx)
incl %ebp
movq 0x8(%rax), %rax
movq %rcx, (%rax)
decl 0x4c(%rbx)
cmpl $0x64, %ebp
je 0x2efe
movq %rcx, %rax
testq %rcx, %rcx
jne 0x2ec0
jmp 0x2f03
movl $0x64, %ebp
movq %rbx, %rdi
callq 0x22b0
testl %ebp, %ebp
jle 0x2f26
movl %ebp, %r14d
xorl %r15d, %r15d
movq (%rsp,%r15,8), %rdi
callq 0x2b01
incq %r15
cmpq %r15, %r14
jne 0x2f15
movl $0x1, %edi
callq 0x2450
jmp 0x2ea6
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_init
int hdb_init(hdb_t *hdb)
{
    if (pthread_mutex_init(&hdb->mutex, NULL)) return -1;
    TAILQ_INIT(&hdb->open_list);
    TAILQ_INIT(&hdb->close_list);
    hdb->num_open = 0;
    hdb->num_close = 0;

    int i;
    for (i = 0; i < HTAB_SIZE; i++) {
        LIST_INIT((hdb->htab + i));
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x2460
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2f7e
leaq 0x28(%rbx), %rax
movq %r14, 0x28(%rbx)
movq %rax, 0x30(%rbx)
leaq 0x38(%rbx), %rax
movq %r14, 0x38(%rbx)
movq %rax, 0x40(%rbx)
addq $0x48, %rbx
movl $0x2008, %edx           # imm = 0x2008
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2190
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_append
int hdb_append(hdb_t *hdb, const char *hdict_path){
    hdict_t *hd, *ihd = NULL;
    char rpath[1024];
    realpath(hdict_path, rpath);

    int hdict_errno = 0;
    hdict_t *hdict = hdict_open(rpath, &hdict_errno);
    if(NULL == hdict) return hdict_errno;
    LOCK(hdb);
    //use the label to generate hash id
    uint64_t key_hash = bkdr_hash(hdict->hdict_meta->label);
    uint32_t hash = HASH(key_hash);
    for (hd = LIST_FIRST(&hdb->htab[hash]); hd; hd = LIST_NEXT(hd, h_link)) {
        if (hd->hdict_meta->version <= hdict->hdict_meta->version) {
            ihd = hd;
            break;
        }
    }
    hdict->hdid = key_hash;
    TAILQ_INSERT_TAIL(&hdb->open_list, hdict, link);
    if(NULL == ihd){
        LIST_INSERT_HEAD(&hdb->htab[hash], hdict, h_link);
    }else{
        LIST_INSERT_BEFORE(ihd, hdict, h_link);
    }
    hdb->num_open++;
    UNLK(hdb);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x285c
testq %rax, %rax
je 0x3041
movq %rax, %r14
movq %rbx, %rdi
callq 0x2470
movq 0x58(%r14), %rdi
addq $0x5, %rdi
callq 0x42a0
movl %eax, %edx
andl $0x3ff, %edx            # imm = 0x3FF
movq 0x50(%rbx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x3000
movq 0x58(%r14), %rsi
movl (%rsi), %esi
movq 0x58(%rcx), %rdi
cmpl %esi, (%rdi)
jbe 0x3002
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x2fef
xorl %ecx, %ecx
movq %rax, 0x50(%r14)
movq $0x0, (%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x30(%rbx)
testq %rcx, %rcx
je 0x3047
movq 0x18(%rcx), %rax
movq %r14, %rdx
addq $0x10, %rdx
movq %rax, 0x18(%r14)
movq %rcx, 0x10(%r14)
movq 0x18(%rcx), %rax
movq %r14, (%rax)
movq %rdx, 0x18(%rcx)
jmp 0x306d
movl 0xc(%rsp), %eax
jmp 0x307a
leaq (%rbx,%rdx,8), %rax
addq $0x50, %rax
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
testq %rcx, %rcx
je 0x3066
movq %r14, %rdx
addq $0x10, %rdx
movq %rdx, 0x18(%rcx)
movq %r14, (%rax)
movq %rax, 0x18(%r14)
incl 0x48(%rbx)
movq %rbx, %rdi
callq 0x22b0
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_reopen
int hdb_reopen(hdb_t *hdb, const char *hdict_path)
{
    hdict_t *hd, *next;
    uint32_t hash;
    char rpath[1024];
    realpath(hdict_path, rpath);

    int hdict_errno = 0;
    hdict_t *hdict = hdict_open(rpath, &hdict_errno);
    if (hdict == NULL) return hdict_errno;
    uint64_t hdid = bkdr_hash(hdict->hdict_meta->label);

    LOCK(hdb);
    for (hd = TAILQ_FIRST(&hdb->open_list); hd; hd = next) {
        next = TAILQ_NEXT(hd, link);
        if (hd->hdid == hdid && strcmp(hd->hdict_meta->label, hdict->hdict_meta->label) == 0) {
            LIST_REMOVE(hd, h_link);
            TAILQ_REMOVE(&hdb->open_list, hd, link);
            hdb->num_open--;
            TAILQ_INSERT_TAIL(&hdb->close_list, hd, link);
            hdb->num_close++;
            break;
        }
    }
    hdict->hdid = hdid;
    TAILQ_INSERT_TAIL(&hdb->open_list, hdict, link);
    /* put the hdb ptr to simple hash table */
    hash = HASH(hdict->hdid);
    LIST_INSERT_HEAD(&hdb->htab[hash], hdict, h_link);
    hdb->num_open++;
    UNLK(hdb);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x285c
testq %rax, %rax
je 0x3117
movq %rax, %r14
movq 0x58(%rax), %rdi
addq $0x5, %rdi
callq 0x42a0
movq %rax, %r15
movq %rbx, %rdi
callq 0x2470
movq 0x28(%rbx), %r12
testq %r12, %r12
je 0x3179
movq (%r12), %r13
cmpq %r15, 0x50(%r12)
jne 0x310d
movq 0x58(%r12), %rdi
addq $0x5, %rdi
movq 0x58(%r14), %rsi
addq $0x5, %rsi
callq 0x2220
testl %eax, %eax
je 0x3120
movq %r13, %r12
testq %r13, %r13
jne 0x30e8
jmp 0x3179
movl 0xc(%rsp), %eax
jmp 0x31cd
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x3133
movq 0x18(%r12), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%r12), %rcx
movq %rax, (%rcx)
movq (%r12), %rax
movq 0x8(%r12), %rcx
testq %rax, %rax
je 0x314f
movq %rcx, 0x8(%rax)
jmp 0x3153
movq %rcx, 0x30(%rbx)
movq 0x8(%r12), %rcx
movq %rax, (%rcx)
decl 0x48(%rbx)
movq $0x0, (%r12)
movq 0x40(%rbx), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x40(%rbx)
incl 0x4c(%rbx)
movq %r15, 0x50(%r14)
movq $0x0, (%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x30(%rbx)
andl $0x3ff, %r15d           # imm = 0x3FF
leaq (%rbx,%r15,8), %rax
addq $0x50, %rax
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
testq %rcx, %rcx
je 0x31b9
movq %r14, %rdx
addq $0x10, %rdx
movq %rdx, 0x18(%rcx)
movq %r14, (%rax)
movq %rax, 0x18(%r14)
incl 0x48(%rbx)
movq %rbx, %rdi
callq 0x22b0
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_close
int hdb_close(hdb_t *hdb, const char* label, uint32_t version_id)
{
    if(NULL == label){
        return 0;
    }
    uint64_t hdid = bkdr_hash(label);
    int found = 0;
    hdict_t *hd, *next;
    LOCK(hdb);
    for (hd = TAILQ_FIRST(&hdb->open_list); hd; hd = next) {
        next = TAILQ_NEXT(hd, link);
        if (hd->hdid == hdid && strcmp(hd->hdict_meta->label, label) == 0) {
            if (version_id != 0 && hd->hdict_meta->version != version_id){
                continue;
            }
            LIST_REMOVE(hd, h_link);
            TAILQ_REMOVE(&hdb->open_list, hd, link);
            hdb->num_open--;
            TAILQ_INSERT_TAIL(&hdb->close_list, hd, link);
            hdb->num_close++;
            found += 1;
            if (version_id != 0){
                break;
            }
        }
    }
    UNLK(hdb);

    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x32c7
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x42a0
movq %rax, %r12
movq %rbx, %rdi
callq 0x2470
movq 0x28(%rbx), %rbp
testq %rbp, %rbp
je 0x32cc
movq %r15, 0x10(%rsp)
movl %r14d, 0xc(%rsp)
xorl %r15d, %r15d
movq %rbp, %r13
movq (%rbp), %rbp
cmpq %r12, 0x50(%r13)
jne 0x32bc
movq 0x58(%r13), %r14
leaq 0x5(%r14), %rdi
movq 0x10(%rsp), %rsi
callq 0x2220
testl %eax, %eax
jne 0x32bc
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x325f
cmpl %eax, (%r14)
jne 0x32bc
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x3270
movq 0x18(%r13), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%r13), %rcx
movq %rax, (%rcx)
movq (%r13), %rax
movq 0x8(%r13), %rcx
testq %rax, %rax
je 0x328a
movq %rcx, 0x8(%rax)
jmp 0x328e
movq %rcx, 0x30(%rbx)
movq 0x8(%r13), %rcx
movq %rax, (%rcx)
decl 0x48(%rbx)
movq $0x0, (%r13)
movq 0x40(%rbx), %rax
movq %rax, 0x8(%r13)
movq %r13, (%rax)
incl 0x4c(%rbx)
incl %r15d
movq %r13, 0x40(%rbx)
cmpl $0x0, 0xc(%rsp)
jne 0x32cf
testq %rbp, %rbp
jne 0x322b
jmp 0x32cf
xorl %r15d, %r15d
jmp 0x32d7
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x22b0
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_ref
hdict_t *hdb_ref(hdb_t *hdb, const char* label)
{
    hdict_t *hdict = NULL;
    if (NULL == label){
        return hdict;
    }
    hdict_t *hd;
    LOCK(hdb);
    uint64_t hdid = bkdr_hash(label);
    uint32_t hash = HASH(hdid);
    for (hd = LIST_FIRST(&hdb->htab[hash]); hd; hd = LIST_NEXT(hd, h_link)) {
        if (hd->hdid == hdid) {
            hd->ref++;
            hdict = hd;
            break;
        }
    }
    UNLK(hdb);
    return hdict;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x34fd
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2470
movq %r14, %rdi
callq 0x42a0
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x50(%rbx,%rcx,8), %r14
testq %r14, %r14
je 0x34f8
cmpq %rax, 0x50(%r14)
je 0x3502
movq 0x10(%r14), %r14
jmp 0x34e7
xorl %r14d, %r14d
jmp 0x3506
xorl %r14d, %r14d
jmp 0x350e
incl 0x4c(%r14)
movq %rbx, %rdi
callq 0x22b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/hdict.c
// Function: hdb_deref
int hdb_deref(hdb_t *hdb, hdict_t *hdict)
{
    LOCK(hdb);
    hdict->ref--;
    UNLK(hdb);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2470
decl 0x4c(%rbx)
movq %r14, %rdi
callq 0x22b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection.c
// Function: conn_close
void conn_close(conn *c) {
    event_del(&c->event);

    if (settings.verbose > 1)
        fprintf(stderr, "<%d connection closed.\n", c->sfd);

    close(c->sfd);

    if (freecurr < freetotal) {
        freeconns[freecurr++] = c;
    } else {
        conn **new_freeconns = realloc(freeconns, sizeof(conn *)*freetotal*2);
        if (new_freeconns) {
            freetotal *= 2;
            freeconns = new_freeconns;
            freeconns[freecurr++] = c;
        } else {
            if (settings.verbose > 0)
                fprintf(stderr, "Couldn't realloc freeconns\n");
            free(c->rbuf);
            free(c->wbuf);
            free(c);

            STATS_LOCK(stats);
            stats.conn_structs--;
            STATS_UNLOCK(stats);
        }
    }

    STATS_LOCK(stats);
    stats.curr_conns--;
    STATS_UNLOCK(stats);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x2150
leaq 0x5a7d(%rip), %r14      # 0x9268
cmpl $0x2, 0x10(%r14)
jge 0x38bf
movl (%rbx), %edi
callq 0x21a0
leaq 0x5b78(%rip), %r15      # 0x937c
movslq (%r15), %rax
leaq 0x5b6a(%rip), %r12      # 0x9378
movslq (%r12), %rsi
leaq 0x5b57(%rip), %r13      # 0x9370
movq (%r13), %rdi
cmpl %esi, %eax
jge 0x382d
leal 0x1(%rax), %ecx
movl %ecx, (%r15)
movq %rbx, (%rdi,%rax,8)
jmp 0x3898
shlq $0x4, %rsi
callq 0x2310
testq %rax, %rax
je 0x3852
shll (%r12)
movq %rax, (%r13)
movslq (%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r15)
movq %rbx, (%rax,%rcx,8)
jmp 0x3898
cmpl $0x0, 0x10(%r14)
jg 0x38cc
movq 0x90(%rbx), %rdi
callq 0x2030
movq 0xa8(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
leaq 0x5b00(%rip), %r14      # 0x9380
leaq 0x28(%r14), %rbx
movq %rbx, %rdi
callq 0x2470
decl 0x4(%r14)
movq %rbx, %rdi
callq 0x22b0
leaq 0x5ae1(%rip), %r14      # 0x9380
leaq 0x28(%r14), %rbx
movq %rbx, %rdi
callq 0x2470
decl (%r14)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22b0
movq %rbx, %rdi
callq 0x24f7
jmp 0x37f6
callq 0x2514
jmp 0x3859
nop
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection_queue.c
// Function: cq_init
void cq_init(struct conn_queue *cq, int wakeup) {
    pthread_mutex_init(&cq->lock, NULL);
    pthread_cond_init(&cq->cond, NULL);
    cq->length = 0;
    cq->wakeup = wakeup;
    cq->head = NULL;
    cq->tail = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x18, %rdi
xorl %esi, %esi
callq 0x2460
leaq 0x40(%r14), %rdi
xorl %esi, %esi
callq 0x22a0
movl $0x0, 0x10(%r14)
movl %ebx, 0x14(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection_queue.c
// Function: cq_push
void cq_push(struct conn_queue *cq, conn *item) {
    item->next = NULL;

    pthread_mutex_lock(&cq->lock);
    if (NULL == cq->tail)
        cq->head = item;
    else
        cq->tail->next = item;
    cq->tail = item;
    cq->length++;
    if (cq->wakeup) pthread_cond_signal(&cq->cond);
    pthread_mutex_unlock(&cq->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq $0x0, 0xe0(%rsi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x2470
movq 0x8(%r14), %rax
leaq 0xe0(%rax), %rcx
testq %rax, %rax
cmoveq %r14, %rcx
movq %r15, (%rcx)
movq %r15, 0x8(%r14)
incl 0x10(%r14)
cmpl $0x0, 0x14(%r14)
je 0x3960
addq $0x40, %r14
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection_queue.c
// Function: cq_pop
conn *cq_pop(struct conn_queue *cq) {
    conn *item;

    assert(cq->wakeup);
    pthread_mutex_lock(&cq->lock);
    while (NULL == cq->head)
        pthread_cond_wait(&cq->cond, &cq->lock);
    item = cq->head;
    cq->head = item->next;
    if (NULL == cq->head)
        cq->tail = NULL;
    cq->length--;
    pthread_mutex_unlock(&cq->lock);

    return item;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x14(%rdi)
je 0x39da
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x2470
movq (%rbx), %r15
testq %r15, %r15
jne 0x39a9
leaq 0x40(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2110
movq (%rbx), %r15
testq %r15, %r15
je 0x3996
movq 0xe0(%r15), %rax
movq %rax, (%rbx)
testq %rax, %rax
jne 0x39c0
movq $0x0, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rdi
callq 0x22b0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2072(%rip), %rdi      # 0x5a53
leaq 0x2076(%rip), %rsi      # 0x5a5e
leaq 0x2082(%rip), %rcx      # 0x5a71
movl $0x1f, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection_queue.c
// Function: cq_peek
conn *cq_peek(struct conn_queue *cq) {
    conn *item;

    pthread_mutex_lock(&cq->lock);
    item = cq->head;
    if (NULL != item) {
        cq->head = item->next;
        if (NULL == cq->head)
            cq->tail = NULL;
        cq->length--;
    }
    pthread_mutex_unlock(&cq->lock);

    return item;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x2470
movq (%r15), %r14
testq %r14, %r14
je 0x3a30
movq 0xe0(%r14), %rax
movq %rax, (%r15)
testq %rax, %rax
jne 0x3a2c
movq $0x0, 0x8(%r15)
decl 0x10(%r15)
movq %rbx, %rdi
callq 0x22b0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/connection_queue.c
// Function: cq_length
uint32_t cq_length(struct conn_queue *cq) {
    int length;
    pthread_mutex_lock(&cq->lock);
    length = cq->length;
    pthread_mutex_unlock(&cq->lock);
    return length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x2470
movl 0x10(%rbx), %ebx
movq %r14, %rdi
callq 0x22b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: update_event
int update_event(conn *c, const int new_flags) {
    assert(c != NULL);

    struct event_base *base = c->event.ev_base;
    if (c->ev_flags == new_flags)
        return 1;
    if (c->ev_flags != 0) {
        if (event_del(&c->event) == -1) return 0;
    }
    event_set(&c->event, c->sfd, new_flags, event_handler, (void *)c);
    event_base_set(base, &c->event);
    c->ev_flags = new_flags;
    if (event_add(&c->event, 0) == -1) return 0;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3af5
movl %esi, %ebp
movq %rdi, %rbx
movswl 0x88(%rdi), %ecx
movl $0x1, %eax
cmpl %esi, %ecx
je 0x3aea
leaq 0x8(%rbx), %r14
movq 0x48(%rbx), %r15
testw %cx, %cx
je 0x3aa7
movq %r14, %rdi
callq 0x2150
cmpl $-0x1, %eax
je 0x3ae8
movl (%rbx), %esi
movswl %bp, %ebp
leaq 0x61(%rip), %rcx        # 0x3b14
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
callq 0x2360
movq %r15, %rdi
movq %r14, %rsi
callq 0x2060
movw %bp, 0x88(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2230
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
setne %al
jmp 0x3aea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fa8(%rip), %rdi      # 0x5aa4
leaq 0x1fab(%rip), %rsi      # 0x5aae
leaq 0x1fae(%rip), %rcx      # 0x5ab8
movl $0x11, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: event_handler
void event_handler(const int fd, const short which, void *arg) {
    conn *c;

    c = (conn *)arg;
    assert(c != NULL);

    c->which = which;

    if (fd != c->sfd) {
        if (settings.verbose > 0)
            fprintf(stderr, "Catastrophic: event fd doesn't match conn fd!\n");
        conn_close(c);
        return;
    }

    drive_machine(c);

    return;
}

// Assembly:
pushq %rbx
testq %rdx, %rdx
je 0x3b4e
movq %rdx, %rbx
movw %si, 0x8a(%rdx)
cmpl %edi, (%rdx)
jne 0x3b31
movq %rbx, %rdi
popq %rbx
jmp 0x3e23
leaq 0x5730(%rip), %rax      # 0x9268
cmpl $0x0, 0x10(%rax)
jg 0x3b47
movq %rbx, %rdi
popq %rbx
jmp 0x37cf
callq 0x2530
jmp 0x3b3e
leaq 0x1f4f(%rip), %rdi      # 0x5aa4
leaq 0x1f52(%rip), %rsi      # 0x5aae
leaq 0x206f(%rip), %rcx      # 0x5bd2
movl $0xe9, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: process_command
int process_command(conn *c, char *command) {
    if (strcmp(command, "quit") == 0) {
        c->state = conn_closing;
        return STAY_IN;
    } else if (strcmp(command, "stop") == 0) {
        exit(0);
    } else if (strcmp(command, "version") == 0) {
        // compat with old php Memcache client
        out_string(c, VERSION);
        return STAY_IN;
    } else {
        if (event_del(&c->event) == -1) {
            out_string(c, "SERVER_ERROR can't forward");
            return STAY_IN;
        }
        gettimeofday(&c->tv, NULL);
        c->ev_flags = 0;
        c->cmd = command;
        cq_push(&REQ, c);
        return FORWARD_OUT;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1f5e(%rip), %rsi      # 0x5adc
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
je 0x3bf6
leaq 0x1f50(%rip), %rsi      # 0x5ae1
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
je 0x3c24
leaq 0x1d5f(%rip), %rsi      # 0x5907
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
je 0x3bff
leaq 0x8(%rbx), %rdi
callq 0x2150
cmpl $-0x1, %eax
je 0x3c08
leaq 0xd0(%rbx), %rdi
xorl %esi, %esi
callq 0x2170
movw $0x0, 0x88(%rbx)
movq %r14, 0xc8(%rbx)
leaq 0x56a1(%rip), %rdi      # 0x9288
movq %rbx, %rsi
callq 0x390e
movl $0x1, %eax
jmp 0x3c1c
movl $0x3, 0x4(%rbx)
jmp 0x3c17
leaq 0x1ee0(%rip), %rsi      # 0x5ae6
jmp 0x3c0f
leaq 0x1ee5(%rip), %rsi      # 0x5af4
movq %rbx, %rdi
callq 0x432c
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
callq 0x2400
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: try_read_command
int try_read_command(conn *c) {
    char *el, *cont;

    if (!c->rbytes)
        return 0;
    el = (char *)memchr(c->rcurr, '\n', c->rbytes);
    if (!el)
        return 0;
    cont = el + 1;
    if (el - c->rcurr > 1 && *(el - 1) == '\r') {
        el--;
    }
    *el = '\0';

    int res = process_command(c, c->rcurr);

    c->rbytes -= (cont - c->rcurr);
    c->rcurr = cont;

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0xa4(%rdi), %rdx
testq %rdx, %rdx
je 0x3c9e
movq %rdi, %rbx
movq 0x98(%rdi), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
testq %rax, %rax
je 0x3c9e
leaq 0x1(%rax), %r15
movq %rax, %rcx
subq %r14, %rcx
cmpq $0x2, %rcx
jl 0x3c74
leaq -0x1(%rax), %rcx
cmpb $0xd, -0x1(%rax)
cmoveq %rcx, %rax
movb $0x0, (%rax)
movq 0x98(%rbx), %rsi
movq %rbx, %rdi
callq 0x3b6d
movl 0x98(%rbx), %ecx
subl %r15d, %ecx
addl %ecx, 0xa4(%rbx)
movq %r15, 0x98(%rbx)
jmp 0x3ca0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: notify_handler
void notify_handler(const int fd, const short which, void *arg) {
    if (fd != notify_receive_fd) {
        if (settings.verbose > 0)
            fprintf(stderr, "Catastrophic: event fd doesn't match conn fd!\n");
        return;
    }
    char buf[1];
    if (read(fd, buf, 1) != 1) {
        if (settings.verbose > 0)
            fprintf(stderr, "Can't read from event pipe\n");
    }

    conn *c = cq_peek(&RSP);
    if (c != NULL) {
        c->wcurr = c->wbuf;
        c->state = conn_write;
        c->write_and_go = conn_read;

        drive_machine(c);
    }

    return;
}

// Assembly:
pushq %rax
leaq 0x52d2(%rip), %rax      # 0x9368
cmpl %edi, (%rax)
jne 0x40f6
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x21d0
cmpq $0x1, %rax
je 0x40bc
leaq 0x51b2(%rip), %rax      # 0x9268
cmpl $0x0, 0x10(%rax)
jg 0x4105
leaq 0x5235(%rip), %rdi      # 0x92f8
callq 0x39f9
testq %rax, %rax
je 0x4103
movq 0xa8(%rax), %rcx
movq %rcx, 0xb0(%rax)
movl $0x2, 0x4(%rax)
movl $0x1, 0xc0(%rax)
movq %rax, %rdi
callq 0x3e23
jmp 0x4103
leaq 0x516b(%rip), %rax      # 0x9268
cmpl $0x0, 0x10(%rax)
jg 0x410c
popq %rax
retq
callq 0x260c
jmp 0x40bc
callq 0x25f0
jmp 0x4103
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/network.c
// Function: server_socket
int server_socket(const int port) {
    int sfd;
    struct linger ling = {0, 0};
    struct sockaddr_in addr;
    int flags = 1;

    if ((sfd = new_socket()) == -1) {
        return -1;
    }

    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
    setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
    setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
    setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));

    memset(&addr, 0, sizeof(addr));

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr = settings.interf;
    if (bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind()");
        close(sfd);
        return -1;
    }

    if (listen(sfd, 1024) == -1) {
        perror("listen()");
        close(sfd);
        return -1;
    }
    return sfd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %r14d
movq $0x0, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
callq 0x4113
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x4272
movl %eax, %ebp
leaq 0x4(%rsp), %r15
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r15, %rcx
movl $0x4, %r8d
callq 0x20d0
movl %ebp, %edi
movl $0x1, %esi
movl $0x9, %edx
movq %r15, %rcx
movl $0x4, %r8d
callq 0x20d0
leaq 0x8(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0xd, %edx
movl $0x8, %r8d
callq 0x20d0
movl %ebp, %edi
movl $0x6, %esi
movl $0x1, %edx
movq %r15, %rcx
movl $0x4, %r8d
callq 0x20d0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movw $0x2, (%rsi)
rolw $0x8, %r14w
movw %r14w, 0x2(%rsi)
leaq 0x5020(%rip), %rax      # 0x9268
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsi)
movl %ebp, %edi
movl $0x10, %edx
callq 0x2320
cmpl $-0x1, %eax
je 0x427f
movl %ebp, %edi
movl $0x400, %esi            # imm = 0x400
callq 0x22f0
cmpl $-0x1, %eax
je 0x4288
movl %ebp, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19d3(%rip), %rdi      # 0x5c59
jmp 0x428f
leaq 0x19d1(%rip), %rdi      # 0x5c60
callq 0x2390
movl %ebp, %edi
callq 0x21a0
jmp 0x4272
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/util.c
// Function: bkdr_hash
uint64_t bkdr_hash(const char* str){
    if(NULL == str){
        return 0;
    }
    uint64_t seed = 1313131313;
    uint64_t hash = 0;
    while(*str){
        hash = hash * seed + (*str++);
    }
    return hash;
}

// Assembly:
testq %rdi, %rdi
je 0x42c8
movb (%rdi), %cl
testb %cl, %cl
je 0x42c8
incq %rdi
xorl %eax, %eax
imulq $0x4e44cb31, %rax, %rdx # imm = 0x4E44CB31
movsbq %cl, %rax
addq %rdx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x42b0
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/util.c
// Function: pack_string
void pack_string(conn *c, const char *str) {
    int len;

    len = strlen(str);
    if (len + 2 > c->wsize) {
        /* ought to be always enough. just fail for simplicity */
        str = "SERVER_ERROR output line too long";
        len = strlen(str);
    }

    strcpy(c->wbuf, str);
    strcat(c->wbuf, "\r\n");
    c->wbytes = len + 2;

    return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2130
addl $0x2, %eax
cmpl 0xb8(%r14), %eax
leaq 0x197b(%rip), %rsi      # 0x5c69
cmovleq %rbx, %rsi
movq 0xa8(%r14), %rdi
movl $0x23, %ebp
cmovlel %eax, %ebp
callq 0x2090
movq 0xa8(%r14), %rbx
movq %rbx, %rdi
callq 0x2130
movb $0x0, 0x2(%rbx,%rax)
movw $0xa0d, (%rbx,%rax)     # imm = 0xA0D
movl %ebp, 0xbc(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/util.c
// Function: out_string
void out_string(conn *c, const char *str) {
    pack_string(c, str);
    c->wcurr = c->wbuf;
    c->state = conn_write;
    c->write_and_go = conn_read;
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x42cb
movq 0xa8(%rbx), %rax
movq %rax, 0xb0(%rbx)
movl $0x2, 0x4(%rbx)
movl $0x1, 0xc0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/desion[P]terminal/src/util.c
// Function: bigger_prime
static int isprime(int m) {
    if (m < 1)
        return 0;
    int i;
    for (i = 2; i < m; i++) {
        if (m % i == 0) {
            return 0;
        }
    }
    return 1;
}

// Assembly:
testl %edi, %edi
jle 0x4376
cmpl $0x3, %edi
jl 0x437a
movl $0x2, %ecx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x4376
incl %ecx
cmpl %ecx, %edi
jne 0x4364
jmp 0x437a
incl %edi
jmp 0x4356
movl %edi, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/build-lua/.out/LuaToC/test/cfl.c
// Function: requirefile
static int requirefile(lua_State *L)
{
   const char *path = lua_tostring(L, -1);
   size_t ndx;

   for (ndx = 0; ndx < ARRAYLENGTH(rfiles); ++ndx) {
      if (!strcmp(path, rfiles[ndx].pszPath)) {
         lua_pushlstring(L, rfiles[ndx].pc, rfiles[ndx].cb);
         return 1;
      }
   }
   return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x825c
movq %rax, %r14
leaq 0x245ea(%rip), %r12     # 0x2bed0
movq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x72d0
testl %eax, %eax
je 0x7904
addq $0x18, %r15
cmpq $0x18, %r15
je 0x78e6
xorl %eax, %eax
jmp 0x791b
movq 0x8(%r15,%r12), %rsi
movq 0x10(%r15,%r12), %rdx
movq %rbx, %rdi
callq 0x8447
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/build-lua/.out/LuaToC/test/cfl.c
// Function: main
int main (int argc, char **argv)
{
   int exitCode = EXIT_FAILURE;
   int nErr;
   lua_State *L;

   L = luaL_newstate();
   if (L == NULL) {
      fprintf(stderr, "lua_open failed: not enough memory\n");
      return EXIT_FAILURE;
   }

   lua_pushcfunction(L, &pmain);
   lua_pushinteger(L, argc);
   lua_pushlightuserdata(L, argv);
   nErr = lua_pcall(L, 2, 1, 0);

   if (nErr == LUA_ERRRUN) {
      fprintf(stderr, "pmain error:\n%s\n", lua_tostring(L, -1));
   } else if (nErr) {
      fprintf(stderr, "pmain failed: err = %d\n", nErr);
   } else if (lua_isnumber(L, 1)) {
      exitCode = lua_tointeger(L, 1);
   }

   lua_close(L);
   return exitCode;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0xaa23
testq %rax, %rax
je 0x79ce
movq %rax, %rbx
leaq 0xb5(%rip), %rsi        # 0x79fd
movq %rax, %rdi
xorl %edx, %edx
callq 0x85dd
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x8407
movq %rbx, %rdi
movq %r14, %rsi
callq 0x867b
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8cd2
testl %eax, %eax
jne 0x79bf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7f56
testl %eax, %eax
je 0x79af
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x819d
movq %rax, %r14
movq %rbx, %rdi
callq 0x14efc
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x2, %eax
jne 0x79db
movq %rbx, %rdi
callq 0x75f0
jmp 0x79f5
callq 0x761a
movl $0x1, %r14d
jmp 0x79b7
movq 0x2560e(%rip), %rcx     # 0x2cff0
movq (%rcx), %rdi
leaq 0x1864d(%rip), %rsi     # 0x20039
movl %eax, %edx
xorl %eax, %eax
callq 0x7300
movl $0x1, %r14d
jmp 0x79af
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/build-lua/.out/LuaToC/test/cfl.c
// Function: pmain
static int pmain(lua_State *L)
{
   int argc = lua_tointeger(L, 1);
   char **argv = (char **) lua_touserdata(L, 2);
   int n;

   lua_gc(L, LUA_GCSTOP, 0);
   luaL_openlibs(L);
   lua_gc(L, LUA_GCRESTART, 0);

   if (luaL_loadbuffer(L, mods[0].pc, mods[0].cb, mods[0].pszSource)) {
      return lua_error(L);
   }

   lua_createtable(L, argc-1, 1);        // argv
   for (n = 0; n < argc; ++n) {
      lua_pushstring(L, argv[n]);
      lua_rawseti(L, -2, n);
   }

   lua_pushcfunction(L, &getModInfo);    // getModInfo
   lua_pushcfunction(L, &getModFunc);    // getModFunc
   lua_pushliteral(L, "pre");      // preloads

   lua_call(L, 4, 1);

   return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x819d
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x832f
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8ea8
movq %rbx, %rdi
callq 0xe870
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8ea8
leaq 0x186bf(%rip), %rsi     # 0x20110
leaq 0x18616(%rip), %rcx     # 0x2006e
movl $0x1f7, %edx            # imm = 0x1F7
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa428
testl %eax, %eax
je 0x7a7f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8fe0
leal -0x1(%r14), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x8840
testl %r14d, %r14d
jle 0x7ac3
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
callq 0x8496
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x8a8d
incq %r12
cmpq %r12, %r14
jne 0x7a9f
leaq 0x57(%rip), %rsi        # 0x7b21
movq %rbx, %rdi
xorl %edx, %edx
callq 0x85dd
leaq 0x8a(%rip), %rsi        # 0x7b65
movq %rbx, %rdi
xorl %edx, %edx
callq 0x85dd
leaq 0x1857e(%rip), %rsi     # 0x2006a
movl $0x3, %edx
movq %rbx, %rdi
callq 0x8447
movq %rbx, %rdi
movl $0x4, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8c71
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/build-lua/.out/LuaToC/test/cfl.c
// Function: getModFunc
static int getModFunc(lua_State *L)
{
   size_t ndx = lua_tointeger(L, 1);
   if (ndx >= ARRAYLENGTH(mods)) {
      return 0;
   }

   if (mods[ndx].fn) {
      lua_pushcfunction(L, mods[ndx].fn);
   } else if (!mods[ndx].pszSource) {
      return 0;
   } else if (luaL_loadbuffer(L, mods[ndx].pc, mods[ndx].cb, mods[ndx].pszSource)) {
      return lua_error(L);
   }
   return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x819d
cmpq $0x4, %rax
ja 0x7ba6
leaq (%rax,%rax,4), %rax
leaq 0x24374(%rip), %rcx     # 0x2bf00
movq 0x20(%rcx,%rax,8), %rsi
testq %rsi, %rsi
je 0x7bb1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x85dd
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x7ba6
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa428
testl %eax, %eax
je 0x7ba0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8fe0
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/image3maker/image3maker.c
// Function: map_file
static void* map_file(char *path, int *size)
{
	FILE *f;
    long sz;
    void *p;
    
    assert((f = fopen(path, "rb")));
    
    fseek(f, 0, SEEK_END);
    sz = ftell(f);
    fseek(f, 0, SEEK_SET);
    assert(sz);
    
    assert((p = malloc(sz)) != NULL);
    assert((sz != (fread(p, sz, 1, f))));
    
    assert(size);
    *size = (int)sz;
    
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x564(%rip), %rsi       # 0x22ac
callq 0x1140
testq %rax, %rax
je 0x1dc3
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1120
movq %r14, %rdi
callq 0x10e0
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1120
testq %r15, %r15
je 0x1de2
movq %r15, %rdi
callq 0x1100
testq %rax, %rax
je 0x1e01
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1060
cmpq %rax, %r15
je 0x1e20
testq %rbx, %rbx
je 0x1e3f
movl %r15d, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4e5(%rip), %rdi       # 0x22af
leaq 0x383(%rip), %rsi       # 0x2154
leaq 0x4ef(%rip), %rcx       # 0x22c7
movl $0xb4, %edx
callq 0x10b0
leaq 0x4fc(%rip), %rdi       # 0x22e5
leaq 0x364(%rip), %rsi       # 0x2154
leaq 0x4d0(%rip), %rcx       # 0x22c7
movl $0xb9, %edx
callq 0x10b0
leaq 0x4e0(%rip), %rdi       # 0x22e8
leaq 0x345(%rip), %rsi       # 0x2154
leaq 0x4b1(%rip), %rcx       # 0x22c7
movl $0xbb, %edx
callq 0x10b0
leaq 0x4da(%rip), %rdi       # 0x2301
leaq 0x326(%rip), %rsi       # 0x2154
leaq 0x492(%rip), %rcx       # 0x22c7
movl $0xbc, %edx
callq 0x10b0
leaq 0x4d8(%rip), %rdi       # 0x231e
leaq 0x307(%rip), %rsi       # 0x2154
leaq 0x473(%rip), %rcx       # 0x22c7
movl $0xbe, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/image3maker/image3maker.c
// Function: image3_reserve_tag
static void *image3_reserve_tag(uint32_t tag, uint32_t length)
{
    uint32_t size, len;
    Image3Header* header;
    
    len = length + 24;
    size = image3core.rootHeader->header.size + len;
    
    assert((image3core.rootHeader = realloc(image3core.rootHeader, size)));
    
    header = (Image3Header*)add_ptr2(image3core.rootHeader, image3core.rootHeader->header.size);
    bzero((void*)(header), len);

    header->dataSize = length;
    header->size = len;
    header->magic = tag;
    
    image3core.rootHeader->header.size = size;
    image3core.rootHeader->header.dataSize += len;
    
    
    return (void*)(header + 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x244d(%rip), %rdi      # 0x42b8
movl 0x4(%rdi), %r14d
addl $0x1c, %r14d
movq %r14, %rsi
callq 0x1130
movq %rax, 0x2436(%rip)      # 0x42b8
testq %rax, %rax
je 0x1eca
movl 0x4(%rax), %edx
xorps %xmm0, %xmm0
movups %xmm0, (%rdx,%rax)
movups %xmm0, 0xc(%rdx,%rax)
leaq (%rdx,%rax), %rcx
addq $0xc, %rcx
movabsq $0x40000001c, %rsi      # imm = 0x40000001C
movq %rsi, 0x4(%rdx,%rax)
movl %ebx, (%rdx,%rax)
movq 0x2401(%rip), %rax      # 0x42b8
movl %r14d, 0x4(%rax)
addl $0x1c, 0x8(%rax)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x60b(%rip), %rdi       # 0x24dc
leaq 0x27c(%rip), %rsi       # 0x2154
leaq 0x6c9(%rip), %rcx       # 0x25a8
movl $0x133, %edx            # imm = 0x133
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/justinmeiners[P]text2image/./stb_truetype.h
// Function: stbtt_PackFontRangesPackRects
static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
{
   int i;
   for (i=0; i < num_rects; ++i) {
      if (con->x + rects[i].w > con->width) {
         con->x = 0;
         con->y = con->bottom_y;
      }
      if (con->y + rects[i].h > con->height)
         break;
      rects[i].x = con->x;
      rects[i].y = con->y;
      rects[i].was_packed = 1;
      con->x += rects[i].w;
      if (con->y + rects[i].h > con->bottom_y)
         con->bottom_y = con->y + rects[i].h;
   }
   for (   ; i < num_rects; ++i)
      rects[i].was_packed = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0x7483
movl %edx, %eax
movq 0x8(%rdi), %rdi
movl (%rdi), %r8d
movl 0x4(%rdi), %r9d
movl 0x8(%rdi), %ebx
movl 0xc(%rdi), %r11d
leaq 0x14(%rsi), %r10
xorl %ecx, %ecx
movl %ebx, %r14d
movl -0x8(%r10), %ebx
leal (%rbx,%r14), %ebp
cmpl %r8d, %ebp
jle 0x744a
movl $0x0, 0x8(%rdi)
movl 0x10(%rdi), %r11d
movl %r11d, 0xc(%rdi)
xorl %r14d, %r14d
movl -0x4(%r10), %ebp
addl %r11d, %ebp
cmpl %r9d, %ebp
jg 0x7485
movl %r14d, -0x14(%r10)
movl %r11d, -0x10(%r10)
movl $0x1, (%r10)
addl %r14d, %ebx
movl %ebx, 0x8(%rdi)
cmpl 0x10(%rdi), %ebp
jle 0x7473
movl %ebp, 0x10(%rdi)
incq %rcx
addq $0x18, %r10
cmpq %rcx, %rax
jne 0x7428
movl %eax, %ecx
jmp 0x7485
xorl %ecx, %ecx
cmpl %edx, %ecx
jge 0x7591
movl %ecx, %edi
notl %ecx
addl %edx, %ecx
leaq 0x4(%rcx), %rax
andq $-0x4, %rax
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rdi,2), %rcx
leaq (%rsi,%rcx,8), %rcx
addq $0x5c, %rcx
xorl %edx, %edx
movdqa 0x8655(%rip), %xmm1     # 0xfb10
movdqa 0x865d(%rip), %xmm2     # 0xfb20
movdqa 0x8605(%rip), %xmm3     # 0xfad0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x751d
movl $0x0, -0x48(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x7533
movl $0x0, -0x30(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x756f
movl $0x0, -0x18(%rcx)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x7580
movl $0x0, (%rcx)
addq $0x4, %rdx
addq $0x60, %rcx
cmpq %rdx, %rax
jne 0x74d3
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justinmeiners[P]text2image/text2image.c
// Function: read_font_file
unsigned char* read_font_file(const char* path)
{
    FILE* font_file = fopen("font/cmunrm.ttf", "rb");

    if (!font_file)
    {
        fprintf(stderr, "cannot find font: %s\n", path);
        exit(1);
    }

    /* get length of file */
    fseek(font_file, 0, SEEK_END);
    size_t file_size = ftell(font_file);
    fseek(font_file, 0, SEEK_SET);
    
    /* allocate buffer*/
    unsigned char* font_buffer = malloc(file_size);

    if (!font_buffer)
    {
        fprintf(stderr, "allocation failed. out of memory?");
        exit(2);
    }
   
    /* read into buffer */ 
    fread(font_buffer, file_size, 1, font_file);
    fclose(font_file);
    return font_buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x6083(%rip), %rdi      # 0xfe7e
leaq 0x608c(%rip), %rsi      # 0xfe8e
callq 0x11b0
testq %rax, %rax
je 0x9e69
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1180
movq %rbx, %rdi
callq 0x1120
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1180
movq %r14, %rdi
callq 0x1160
testq %rax, %rax
je 0x9e71
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1040
movq %rbx, %rdi
callq 0x1060
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1265
callq 0x1240
// File: /workspace/github_c_makefile_star2_O1/justinmeiners[P]text2image/text2image.c
// Function: show_usage
void show_usage(int help)
{
    const char* usage = "tex2image --out OUTPUT --height HEIGHT --font TTF --invert\n";

    if (help)
    {
        fputs(usage, stdout);
        fputs("--out\tspecify an output file instead of stdout.\n", stdout);
        fputs("--height\tspecify height of text in pixels.\n", stdout);
        fputs("--font\tprovide an alternative font file in TrueType format. (.ttf)\n", stdout);
        fputs("--invert\tdraw white text on black background.\n", stdout);
        fputs("--help\tshow the help text.\n", stdout);
        exit(0);
    }
    else
    {
        fputs(usage, stderr);
        exit(1);
    }
}

// Assembly:
pushq %rbx
testl %edi, %edi
jne 0x9e9b
movq 0xa176(%rip), %rax      # 0x13ff8
movq (%rax), %rsi
leaq 0x603d(%rip), %rdi      # 0xfec9
callq 0x1090
movl $0x1, %edi
callq 0x11f0
movq 0xa12e(%rip), %rbx      # 0x13fd0
movq (%rbx), %rsi
leaq 0x601d(%rip), %rdi      # 0xfec9
callq 0x1090
movq (%rbx), %rsi
leaq 0x604a(%rip), %rdi      # 0xff05
callq 0x1090
movq (%rbx), %rsi
leaq 0x606c(%rip), %rdi      # 0xff36
callq 0x1090
movq (%rbx), %rsi
leaq 0x6089(%rip), %rdi      # 0xff62
callq 0x1090
movq (%rbx), %rsi
leaq 0x60be(%rip), %rdi      # 0xffa6
callq 0x1090
movq (%rbx), %rsi
leaq 0x60de(%rip), %rdi      # 0xffd5
callq 0x1090
xorl %edi, %edi
callq 0x11f0
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/5-Signal/suicide.c
// Function: main
int main(void) {
	int i, sum, count = 0;;
	srand(time(NULL));
	while(1) {
		sum = 0;
		for(i = 0; i < 3; i++)
			sum += (rand() % 6) + 1;
		if(sum == 18) {
			printf("count = %d\n", count);
			kill(getpid(), SIGTERM);
		}
		else
			count++;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x1070
movl %eax, %edi
callq 0x1050
leaq 0xe5c(%rip), %rbx       # 0x2004
xorl %ebp, %ebp
xorl %r14d, %r14d
movl $0x3, %r15d
callq 0x1080
cltq
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
addl %eax, %r14d
incl %r14d
decl %r15d
jne 0x11b3
cmpl $0x12, %r14d
jne 0x1205
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1040
callq 0x1030
movl %eax, %edi
movl $0xf, %esi
callq 0x1060
jmp 0x11aa
incl %ebp
jmp 0x11aa
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_parse
static int
vl_file_meta_parse (VlFileMeta * self, char const * optarg)
{
  vl_size q ;
  self->active = 1 ;

  if (optarg) {
    int protocol ;
    char const * arg = vl_string_parse_protocol (optarg, &protocol) ;

    /* parse the (optional) protocol part */
    switch (protocol) {
    case VL_PROT_UNKNOWN :
      return VL_ERR_BAD_ARG  ;

    case VL_PROT_ASCII  :
    case VL_PROT_BINARY :
      self->protocol = protocol ;
      break ;

    case VL_PROT_NONE :
      break ;
    }

    if (vl_string_length (arg) > 0) {
      q = vl_string_copy
        (self->pattern, sizeof (self->pattern), arg) ;

      if (q >= sizeof(self->pattern)) {
        return VL_ERR_OVERFLOW ;
      }
    }

  }
  return VL_ERR_OK ;
}

// Assembly:
movl $0x1, (%rdi)
testq %rsi, %rsi
je 0x257c
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rax, %r14
movl (%r15), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x252e
movl %eax, 0x404(%rbx)
jmp 0x253a
cmpl $-0x1, %eax
jne 0x253a
movl $0x3, %eax
jmp 0x2568
movq %r14, %rdi
callq 0x10f0
testq %rax, %rax
je 0x256c
addq $0x4, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1200
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x256c
movl $0x1, %eax
xorl %ecx, %ecx
jmp 0x256e
movb $0x1, %cl
testb %cl, %cl
leaq 0x10(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
je 0x257e
xorl %eax, %eax
retq