LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_init
int list_init(list_t *restrict l) {
    if (l == NULL) return -1;

    seed_random();

    l->numels = 0;

    /* head/tail sentinels and mid pointer */
    l->head_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->tail_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->head_sentinel->next = l->tail_sentinel;
    l->tail_sentinel->prev = l->head_sentinel;
    l->head_sentinel->prev = l->tail_sentinel->next = l->mid = NULL;
    l->head_sentinel->data = l->tail_sentinel->data = NULL;

    /* iteration attributes */
    l->iter_active = 0;
    l->iter_pos = 0;
    l->iter_curentry = NULL;

    /* free-list attributes */
    l->spareels = (struct list_entry_s **)malloc(SIMCLIST_MAX_SPARE_ELEMS * sizeof(struct list_entry_s *));
    l->spareelsnum = 0;

#ifdef SIMCLIST_WITH_THREADS
    l->threadcount = 0;
#endif

    list_attributes_setdefaults(l);

    assert(list_repOk(l));
    assert(list_attrOk(l));

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x3ce4
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x18(%rdi)
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x3160
movq %rax, %r15
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3160
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq %r15, 0x10(%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x8(%r15)
andq $0x0, 0x10(%r15)
andq $0x0, (%rax)
andq $0x0, (%r15)
andq $0x0, 0x2c(%rbx)
andq $0x0, 0x38(%rbx)
pushq $0x28
popq %rdi
callq 0x3160
movq %rax, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
movups %xmm0, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_destroy
void list_destroy(list_t *restrict l) {
    unsigned int i;

    list_clear(l);
    for (i = 0; i < l->spareelsnum; i++) {
        free(l->spareels[i]);
    }
    free(l->spareels);
    free(l->head_sentinel);
    free(l->tail_sentinel);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3d3a
movl 0x28(%rbx), %r15d
movq 0x20(%rbx), %r14
xorl %r12d, %r12d
cmpq %r15, %r12
jae 0x3d16
movq (%r14,%r12,8), %rdi
callq 0x3030
incq %r12
jmp 0x3d03
movq %r14, %rdi
callq 0x3030
movq (%rbx), %rdi
callq 0x3030
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_clear
int list_clear(list_t *restrict l) {
    struct list_entry_s *s;

    if (l->iter_active) return -1;
    
    if (l->attrs.copy_data) {        /* also free user data */
        /* spare a loop conditional with two loops: spareing elems and freeing elems */
        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
            /* move elements as spares as long as there is room */
            if (s->data != NULL) free(s->data);
            l->spareels[l->spareelsnum++] = s;
        }
        while (s != l->tail_sentinel) {
            /* free the remaining elems */
            if (s->data != NULL) free(s->data);
            s = s->next;
            free(s->prev);
        }
        l->head_sentinel->next = l->tail_sentinel;
        l->tail_sentinel->prev = l->head_sentinel;
    } else { /* only free element containers */
        /* spare a loop conditional with two loops: spareing elems and freeing elems */
        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
            /* move elements as spares as long as there is room */
            l->spareels[l->spareelsnum++] = s;
        }
        while (s != l->tail_sentinel) {
            /* free the remaining elems */
            s = s->next;
            free(s->prev);
        }
        l->head_sentinel->next = l->tail_sentinel;
        l->tail_sentinel->prev = l->head_sentinel;
    }
    l->numels = 0;
    l->mid = NULL;

    assert(list_repOk(l));

    return 0;
}

// Assembly:
cmpl $0x0, 0x2c(%rdi)
je 0x3d44
pushq $-0x1
popq %rax
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x58(%rdi)
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movl 0x28(%rdi), %r12d
movq %r14, %r13
je 0x3dc1
movq 0x8(%r13), %r13
cmpq $0x4, %r12
ja 0x3da7
cmpq %r15, %r13
je 0x3da7
movq (%r13), %rdi
callq 0x3030
movq 0x20(%rbx), %rax
leaq 0x1(%r12), %rcx
movl %ecx, 0x28(%rbx)
movq %r13, (%rax,%r12,8)
movq %rcx, %r12
jmp 0x3d64
movq (%r13), %rdi
callq 0x3030
movq 0x8(%r13), %r13
movq 0x10(%r13), %rdi
callq 0x3030
cmpq %r15, %r13
jne 0x3d91
jmp 0x3de4
movq 0x20(%rbx), %rax
leaq 0x1(%r12), %rcx
movl %ecx, 0x28(%rbx)
movq %r13, (%rax,%r12,8)
movq %rcx, %r12
movq 0x8(%r13), %r13
cmpq $0x4, %r12
ja 0x3ddf
cmpq %r15, %r13
jne 0x3dae
jmp 0x3ddf
movq 0x8(%r13), %r13
movq 0x10(%r13), %rdi
callq 0x3030
cmpq %r15, %r13
jne 0x3dd2
movq %r15, 0x8(%r14)
movq %r14, 0x10(%r15)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_attributes_copy
int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data) {
    if (l == NULL || (metric_fun == NULL && copy_data != 0)) return -1;

    l->attrs.meter = metric_fun;
    l->attrs.copy_data = copy_data;

    assert(list_attrOk(l));

    return 0;
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x3e43
testq %rsi, %rsi
sete %cl
testl %edx, %edx
setne %r8b
testb %r8b, %cl
jne 0x3e43
movq %rsi, 0x50(%rdi)
movl %edx, 0x58(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_insert_at
int list_insert_at(list_t *restrict l, const void *data, unsigned int pos) {
    struct list_entry_s *lent, *succ, *prec;
    
    if (l->iter_active || pos > l->numels) return -1;
    
    /* this code optimizes malloc() with a free-list */
    if (l->spareelsnum > 0) {
        lent = l->spareels[l->spareelsnum-1];
        l->spareelsnum--;
    } else {
        lent = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
        if (lent == NULL)
            return -1;
    }

    if (l->attrs.copy_data) {
        /* make room for user' data (has to be copied) */
        size_t datalen = l->attrs.meter(data);
        lent->data = (struct list_entry_s *)malloc(datalen);
        memcpy(lent->data, data, datalen);
    } else {
        lent->data = (void*)data;
    }

    /* actually append element */
    prec = list_findpos(l, pos-1);
    succ = prec->next;
    
    prec->next = lent;
    lent->prev = prec;
    lent->next = succ;
    succ->prev = lent;

    l->numels++;

    /* fix mid pointer */
    if (l->numels == 1) { /* first element, set pointer */
        l->mid = lent;
    } else if (l->numels % 2) {    /* now odd */
        if (pos >= (l->numels-1)/2) l->mid = l->mid->next;
    } else {                /* now even */
        if (pos <= (l->numels-1)/2) l->mid = l->mid->prev;
    }

    assert(list_repOk(l));

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbp
cmpl $0x0, 0x2c(%rdi)
jne 0x3f63
movl %edx, %r14d
movq %rdi, %rbx
movl 0x18(%rdi), %r13d
cmpl %edx, %r13d
jb 0x3f63
movq %rsi, %r12
movl 0x28(%rbx), %eax
testl %eax, %eax
je 0x3ec0
movq 0x20(%rbx), %rcx
decl %eax
movq (%rcx,%rax,8), %r15
movl %eax, 0x28(%rbx)
jmp 0x3ed4
pushq $0x18
popq %rdi
callq 0x3160
movq %rax, %r15
testq %rax, %rax
je 0x3f63
cmpl $0x0, 0x58(%rbx)
je 0x3efe
movq %r12, %rdi
callq *0x50(%rbx)
movq %rax, %rbp
movq %rax, %rdi
callq 0x3160
movq %rax, (%r15)
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x3130
jmp 0x3f01
movq %r12, (%r15)
leal -0x1(%r14), %esi
movq %rbx, %rdi
callq 0x3fd8
movq 0x8(%rax), %rcx
movq %r15, 0x8(%rax)
movq %rax, 0x10(%r15)
movq %rcx, 0x8(%r15)
movq %r15, 0x10(%rcx)
leal 0x1(%r13), %eax
movl %eax, 0x18(%rbx)
testl %r13d, %r13d
je 0x3f49
movl %r13d, %eax
shrl %r13d
pushq $0x1
popq %rbp
testb $0x1, %al
jne 0x3f52
cmpl %r14d, %r13d
ja 0x3f63
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
jmp 0x3f5f
movq %r15, 0x10(%rbx)
pushq $0x1
popq %rbp
jmp 0x3f63
cmpl %r14d, %r13d
jb 0x3f63
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_extract_at
void *list_extract_at(list_t *restrict l, unsigned int pos) {
    struct list_entry_s *tmp;
    void *data;
    
    if (l->iter_active || pos >= l->numels) return NULL;

    tmp = list_findpos(l, pos);
    data = tmp->data;

    tmp->data = NULL;   /* save data from list_drop_elem() free() */
    list_drop_elem(l, tmp, pos);
    l->numels--;
    
    assert(list_repOk(l));

    return data;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x2c(%rdi)
jne 0x3fb9
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x18(%rdi)
jbe 0x3fb9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3fd8
movq (%rax), %r14
andq $0x0, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x40cc
decl 0x18(%rbx)
jmp 0x3fbc
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_findpos
static inline struct list_entry_s *list_findpos(const list_t *restrict l, int posstart) {
    struct list_entry_s *ptr;
    float x;
    int i;

    /* accept 1 slot overflow for fetching head and tail sentinels */
    if (posstart < -1 || posstart > (int)l->numels) return NULL;

    x = (float)(posstart+1) / l->numels;
    if (x <= 0.25) {
        /* first quarter: get to posstart from head */
        for (i = -1, ptr = l->head_sentinel; i < posstart; ptr = ptr->next, i++);
    } else if (x < 0.5) {
        /* second quarter: get to posstart from mid */
        for (i = (l->numels-1)/2, ptr = l->mid; i > posstart; ptr = ptr->prev, i--);
    } else if (x <= 0.75) {
        /* third quarter: get to posstart from mid */
        for (i = (l->numels-1)/2, ptr = l->mid; i < posstart; ptr = ptr->next, i++);
    } else {
        /* fourth quarter: get to posstart from tail */
        for (i = l->numels, ptr = l->tail_sentinel; i > posstart; ptr = ptr->prev, i--);
    }

    return ptr;
}

// Assembly:
cmpl $-0x1, %esi
jl 0x3fe7
movq %rdi, %rax
movl 0x18(%rdi), %ecx
cmpl %esi, %ecx
jge 0x3fea
xorl %eax, %eax
retq
leal 0x1(%rsi), %edx
cvtsi2ss %edx, %xmm0
movl %ecx, %edi
cvtsi2ss %rdi, %xmm1
divss %xmm1, %xmm0
movss 0x2dc0(%rip), %xmm1     # 0x6dc4
ucomiss %xmm0, %xmm1
jae 0x4028
movss 0x2db7(%rip), %xmm1     # 0x6dc8
ucomiss %xmm0, %xmm1
jbe 0x4036
decl %ecx
shrl %ecx
incl %ecx
movq 0x10(%rax), %rax
decl %ecx
cmpl %esi, %ecx
jg 0x401c
jmp 0x3fe9
movq (%rax), %rax
subl $0x1, %edx
jb 0x3fe9
addq $0x8, %rax
jmp 0x4028
movss 0x2d8e(%rip), %xmm1     # 0x6dcc
ucomiss %xmm0, %xmm1
jae 0x4056
addq $0x8, %rax
movq (%rax), %rax
cmpl %esi, %ecx
jle 0x3fe9
addq $0x10, %rax
decl %ecx
jmp 0x4047
decl %ecx
shrl %ecx
addq $0x10, %rax
movq (%rax), %rax
cmpl %esi, %ecx
jge 0x3fe9
addq $0x8, %rax
incl %ecx
jmp 0x405e
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_get_minmax
static void *list_get_minmax(const list_t *restrict l, int versus) {
    void *curminmax;
    struct list_entry_s *s;

    if (l->attrs.comparator == NULL || l->numels == 0)
        return NULL;
    
    curminmax = l->head_sentinel->next->data;
    for (s = l->head_sentinel->next->next; s != l->tail_sentinel; s = s->next) {
        if (l->attrs.comparator(curminmax, s->data) * versus > 0)
            curminmax = s->data;
    }

    return curminmax;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x40(%rdi), %r15
testq %r15, %r15
je 0x40b7
cmpl $0x0, 0x18(%rdi)
je 0x40b7
movl %esi, %ebx
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq 0x8(%rax), %r13
movq (%r13), %r14
movq 0x8(%r13), %r13
cmpq %r12, %r13
je 0x40ba
movq (%r13), %rsi
movq %r14, %rdi
callq *%r15
imull %ebx, %eax
testl %eax, %eax
jle 0x409b
jmp 0x4097
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_drop_elem
static int list_drop_elem(list_t *restrict l, struct list_entry_s *tmp, unsigned int pos) {
    if (tmp == NULL) return -1;

    /* fix mid pointer. This is wrt the PRE situation */
    if (l->numels % 2) {    /* now odd */
        /* sort out the base case by hand */
        if (l->numels == 1) l->mid = NULL;
        else if (pos >= l->numels/2) l->mid = l->mid->prev;
    } else {                /* now even */
        if (pos < l->numels/2) l->mid = l->mid->next;
    }
    
    tmp->prev->next = tmp->next;
    tmp->next->prev = tmp->prev;

    /* free what's to be freed */
    if (l->attrs.copy_data && tmp->data != NULL)
        free(tmp->data);

    if (l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS) {
        l->spareels[l->spareelsnum++] = tmp;
    } else {
        free(tmp);
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4148
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %eax
testb $0x1, %al
jne 0x40f2
shrl %eax
cmpl %edx, %eax
jbe 0x4110
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
jmp 0x410c
cmpl $0x1, %eax
jne 0x40fe
andq $0x0, 0x10(%r14)
jmp 0x4110
shrl %eax
cmpl %edx, %eax
ja 0x4110
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
cmpl $0x0, 0x58(%r14)
je 0x412f
movq (%rbx), %rdi
callq 0x3030
movl 0x28(%r14), %eax
cmpq $0x4, %rax
ja 0x4150
movq 0x20(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x28(%r14)
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_locate
int list_locate(const list_t *restrict l, const void *data) {
    struct list_entry_s *el;
    int pos = 0;
    
    if (l->attrs.comparator != NULL) {
        /* use comparator */
        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
            if (l->attrs.comparator(data, el->data) == 0) break;
        }
    } else {
        /* compare references */
        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
            if (el->data == data) break;
        }
    }
    if (el == l->tail_sentinel) return -1;

    return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x40(%rdi), %r12
movq (%rdi), %r15
movq 0x8(%rdi), %r14
xorl %ebp, %ebp
testq %r12, %r12
je 0x41ba
movq 0x8(%r15), %r15
cmpq %r14, %r15
je 0x41c3
movq (%r15), %rsi
movq %rbx, %rdi
callq *%r12
testl %eax, %eax
je 0x41c6
incl %ebp
jmp 0x4199
cmpq %rbx, (%r15)
je 0x41c6
incl %ebp
movq 0x8(%r15), %r15
cmpq %r14, %r15
jne 0x41b3
movq %r14, %r15
cmpq %r14, %r15
pushq $-0x1
popq %rax
cmovnel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_delete_at
int list_delete_at(list_t *restrict l, unsigned int pos) {
    struct list_entry_s *delendo;


    if (l->iter_active || pos >= l->numels) return -1;

    delendo = list_findpos(l, pos);

    list_drop_elem(l, delendo, pos);

    l->numels--;


    assert(list_repOk(l));

    return  0;
}

// Assembly:
pushq $-0x1
popq %rax
cmpl $0x0, 0x2c(%rdi)
je 0x41e2
retq
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x18(%rdi)
jbe 0x420b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3fd8
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x40cc
decl 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_seek
void *list_seek(list_t *restrict l, const void *indicator) {
    const struct list_entry_s *iter;

    if (l->attrs.seeker == NULL) return NULL;

    for (iter = l->head_sentinel->next; iter != l->tail_sentinel; iter = iter->next) {
        if (l->attrs.seeker(iter->data, indicator) != 0) return iter->data;
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x4398
movq %rsi, %r14
movq (%rdi), %r12
movq 0x8(%rdi), %r13
xorl %ebx, %ebx
movq 0x8(%r12), %r12
cmpq %r13, %r12
je 0x439a
movq (%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
je 0x437a
movq (%r12), %rbx
jmp 0x439a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_sort
int list_sort(list_t *restrict l, int versus) {
    if (l->iter_active || l->attrs.comparator == NULL) /* cannot modify list in the middle of an iteration */
        return -1;

    if (l->numels <= 1)
        return 0;
    list_sort_quicksort(l, versus, 0, l->head_sentinel->next, l->numels-1, l->tail_sentinel->prev);
    assert(list_repOk(l));
    return 0;
}

// Assembly:
pushq %rbx
pushq $-0x1
popq %rbx
cmpl $0x0, 0x2c(%rdi)
je 0x450e
movl %ebx, %eax
popq %rbx
retq
cmpq $0x0, 0x40(%rdi)
je 0x450a
movl 0x18(%rdi), %r8d
xorl %ebx, %ebx
cmpl $0x2, %r8d
jb 0x450a
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x8(%rax), %rcx
decl %r8d
movq 0x10(%rdx), %r9
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x453e
jmp 0x450a
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_iterator_start
int list_iterator_start(list_t *restrict l) {
    if (l->iter_active) return 0;
    l->iter_pos = 0;
    l->iter_active = 1;
    l->iter_curentry = l->head_sentinel->next;
    return 1;
}

// Assembly:
xorl %eax, %eax
cmpl $0x0, 0x2c(%rdi)
je 0x4783
retq
movq $0x1, 0x2c(%rdi)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_iterator_next
void *list_iterator_next(list_t *restrict l) {
    void *toret;

    if (! l->iter_active) return NULL;

    toret = l->iter_curentry->data;
    l->iter_curentry = l->iter_curentry->next;
    l->iter_pos++;

    return toret;
}

// Assembly:
cmpl $0x0, 0x2c(%rdi)
je 0x47b3
movq 0x38(%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x38(%rdi)
incl 0x30(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_hash
int list_hash(const list_t *restrict l, list_hash_t *restrict hash) {
    struct list_entry_s *x;
    list_hash_t tmphash;
    
    assert(hash != NULL);

    tmphash = l->numels * 2 + 100;
    if (l->attrs.hasher == NULL) {
#ifdef SIMCLIST_ALLOW_LOCATIONBASED_HASHES
        /* ENABLE WITH CARE !! */
#warning "Memlocation-based hash is consistent only for testing modification in the same program run."
        int i;

        /* only use element references */
        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
            for (i = 0; i < sizeof(x->data); i++) {
                tmphash += (tmphash ^ (uintptr_t)x->data);
            }
            tmphash += tmphash % l->numels;
        }
#else
        return -1;
#endif
    } else {
        /* hash each element with the user-given function */
        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
            tmphash += tmphash ^ l->attrs.hasher(x->data);
            tmphash +=* hash % l->numels;
        }
    }

    *hash = tmphash;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0x4831
movq %rsi, %rbx
movl 0x18(%rdi), %r15d
leal 0x64(,%r15,2), %ebp
movq (%rdi), %r12
movq 0x8(%rdi), %r13
movq 0x8(%r12), %r12
cmpq %r13, %r12
je 0x482b
movq (%r12), %rdi
callq *%r14
movl %eax, %ecx
xorl %ebp, %ecx
movl (%rbx), %eax
xorl %edx, %edx
divl %r15d
addl %ebp, %edx
addl %ecx, %edx
movl %edx, %ebp
jmp 0x4807
movl %ebp, (%rbx)
xorl %eax, %eax
jmp 0x4834
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_dump_getinfo_file
int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info) {
    int fd, ret;

    fd = open(filename, O_RDONLY, 0);
    if (fd < 0) return -1;

    ret = list_dump_getinfo_filedescriptor(fd, info);
    close(fd);

    return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x49ce
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x4843
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x49d1
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_dump_file
int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len) {
    int fd;
    size_t sizetoret;

    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (fd < 0) return -1;

    sizetoret = list_dump_filedescriptor(l, fd, len);
    close(fd);

    return sizetoret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x511d
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x49d8
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x5120
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/simclist.c
// Function: list_restore_file
int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *restrict len) {
    int fd;
    size_t totdata;

    fd = open(filename, O_RDONLY, 0);
    if (fd < 0) return -1;

    totdata = list_restore_filedescriptor(l, fd, len);
    close(fd);

    return totdata;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x515d
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x4d58
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x5160
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/interpose.c
// Function: onSyscallEntry
void onSyscallEntry() {
    if (clee_syscall_num() == 1 && option_write2read) {
        clee_syscall_set(0);
    }
    if (clee_syscall_num() == 1 && option_write_stdout) {
        clee_set_arg(0, 1);
    }
    if (clee_syscall_num() == 1 && clee_get_arg(0) == 1 && option_nullify_stdout) {
        char null = '\0';
        int len = clee_get_arg(2);
        void *pos = (void*)clee_get_arg(1);
        int i;
        for (i = 0; i < len; i++) {
            clee_write(&null, pos + i, 1);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x3967
cmpq $0x1, %rax
jne 0x52e9
cmpb $0x1, 0x6008(%rip)      # 0xb2e8
jne 0x52e9
xorl %edi, %edi
callq 0x396f
xorl %eax, %eax
callq 0x3967
cmpq $0x1, %rax
jne 0x5309
cmpb $0x1, 0x5fec(%rip)      # 0xb2e9
jne 0x5309
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x39c6
xorl %eax, %eax
callq 0x3967
cmpq $0x1, %rax
jne 0x5371
xorl %edi, %edi
callq 0x3990
cmpq $0x1, %rax
jne 0x5371
cmpb $0x1, 0x5fc0(%rip)      # 0xb2ea
jne 0x5371
leaq 0x7(%rsp), %rbx
movb $0x0, (%rbx)
pushq $0x2
popq %rdi
callq 0x3990
movq %rax, %r15
pushq $0x1
popq %rdi
callq 0x3990
movq %rax, %r14
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
pushq $0x1
popq %r15
subq $0x1, %r12
jb 0x5371
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3ad0
incq %r14
jmp 0x5358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/turquoise-hexagon[P]st/x.c
// Function: xloadcolor
int
xloadcolor(int i, const char *name, Color *ncolor)
{
	if (!name)
		if (BETWEEN(i, 16, 255))
			name = colorname[7];
		else
			name = colorname[i];

	return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor);
}

// Assembly:
movq %rdx, %r8
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x987f
leal -0x10(%rdi), %eax
cmpl $0xf0, %eax
jae 0x9871
leaq 0x43aa(%rip), %rcx      # 0xdc19
jmp 0x987f
movslq %edi, %rax
leaq 0x81b5(%rip), %rcx      # 0x11a30
movq (%rcx,%rax,8), %rcx
movq 0xd422(%rip), %rdi      # 0x16ca8
movq 0xd493(%rip), %rsi      # 0x16d20
movq 0xd41c(%rip), %rdx      # 0x16cb0
jmp 0x54e0
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_16/longest_line.c
// Function: main
int main(void)
{
  int len;
  char line[MAXLINE];

  int maxlen;
  char maxline[MAXLINE];

  maxlen = 0;
  while ((len = get_line(line, MAXLINE)) > 0)
  {
    if (maxlen < len)
    {
      maxlen = len;
      copy(line, maxline);
    }

    printf("line_length: %d\n", len);
  }

  if (maxlen > 0)
  {
    printf("%s", maxline);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
leaq 0x3f0(%rsp), %rbx
movq %rsp, %r14
leaq 0xe97(%rip), %r15       # 0x2004
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11cc
testl %eax, %eax
jle 0x11a4
movl %eax, %ebp
cmpl %eax, %r12d
jge 0x1196
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1233
movl %ebp, %r12d
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
jmp 0x1170
testl %r12d, %r12d
je 0x11ba
leaq 0xe65(%rip), %rdi       # 0x2015
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_16/longest_line.c
// Function: get_line
int get_line(char line[], int maxline)
{
  int c, i;

  for (i = 0; i < maxline - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }
  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }
  
  line[i] = '\0';
  
  while(c != EOF && c != '\n')
  {
    ++i;
    c = getchar();
  }
  
  if (c == '\n')
    ++i;

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0x2, %esi
pushq $0x1
popq %rbx
cmovgel %esi, %ebx
decl %ebx
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x1202
callq 0x1040
cmpl $-0x1, %eax
je 0x11ff
cmpl $0xa, %eax
je 0x11ff
movb %al, (%r14,%r15)
incq %r15
jmp 0x11e2
movl %r15d, %ebx
cmpl $0xa, %eax
jne 0x1210
movl %ebx, %ecx
movb $0xa, (%r14,%rcx)
incl %ebx
movslq %ebx, %rcx
movb $0x0, (%r14,%rcx)
cmpl $-0x1, %eax
je 0x122b
incl %ebx
cmpl $0xa, %eax
je 0x122b
callq 0x1040
jmp 0x1218
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: safe_open
FILE *safe_open(const char *name, const char *mode)
{
	FILE *f = fopen(name, mode);
	if (!f) {
		perror(name);
		exit(1);
	}
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x10a0
testq %rax, %rax
je 0x11dc
popq %rbx
retq
movq %rbx, %rdi
callq 0x10b0
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: oplen
int oplen(char op)
{
	if (lens[op] < 0) {
		fprintf(stderr, "unknown operand: %c\n", op);
		exit(1);
	}
	return lens[op];
}

// Assembly:
movslq %edi, %rax
leaq 0x2e77(%rip), %rcx      # 0x4090
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x1221
retq
pushq %rax
movq 0x2dcf(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movsbl %dil, %edx
leaq 0xe67(%rip), %rsi       # 0x209e
movq %rax, %rdi
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: instr_len
int instr_len(const char *args)
{
	const char *c;
	int len = 1; /* opcode length is 1 */

	for (c = args; *c; ++c)
		len += oplen(*c);

	return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movb (%r14), %al
testb %al, %al
je 0x1269
movsbl %al, %edi
callq 0x120f
addl %eax, %ebx
incq %r14
jmp 0x1253
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: read_file
void read_file(const char *fname, void (*fn)(FILE *f, void *ctx), void *ctx)
{
	FILE *in = safe_open(fname, "r");

	for (;;) {
		int c = fgetc(in);

		if (c == EOF)
			break;
		if (c == '\n')
			continue;
		if (c == '#')
			goto nextline;

		ungetc(c, in);
		(*fn)(in, ctx);
nextline:
		do {
			c = fgetc(in);
		} while (c != '\n' && c != EOF);
	}
	fclose(in);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xe2e(%rip), %rsi       # 0x20b3
callq 0x11cc
movq %rax, %r15
movq %r15, %rdi
callq 0x1060
cmpl $0xa, %eax
je 0x128d
cmpl $0x23, %eax
je 0x12b7
cmpl $-0x1, %eax
je 0x12cb
movl %eax, %edi
movq %r15, %rsi
callq 0x1090
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
movq %r15, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x128d
cmpl $0xa, %eax
jne 0x12b7
jmp 0x128d
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: read_operands
void read_operands(FILE *in, void *ctx)
{
	char op;
	int len;

	(void)ctx;
	if (fscanf(in, "%c %d", &op, &len) != 2) {
		fprintf(stderr, "operand parse error near byte %ld\n", ftell(in));
		exit(1);
	}
	if (lens[op] != -1) {
		fprintf(stderr, "'%c': operand duplicated\n", op);
		exit(1);
	}
	lens[op] = len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xdb3(%rip), %rsi       # 0x20b5
leaq 0x3(%rsp), %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x1030
cmpl $0x2, %eax
jne 0x133a
movsbq 0x3(%rsp), %rdx
leaq 0x2d6b(%rip), %rax      # 0x4090
cmpl $-0x1, (%rax,%rdx,4)
jne 0x1362
movl 0x4(%rsp), %ecx
movl %ecx, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2cb7(%rip), %rax      # 0x3ff8
movq (%rax), %r14
movq %rbx, %rdi
callq 0x1080
leaq 0xd68(%rip), %rsi       # 0x20bb
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1070
jmp 0x137a
movq 0x2c8f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd6b(%rip), %rsi       # 0x20de
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: write_table
void write_table(FILE *in, void *ctx)
{
	FILE *out = ctx;
	char name[16], args[8], code[3];

	if (fscanf(in, "%15s %7s %2s", name, args, code) != 3) {
		fprintf(stderr, "instruction parse error near byte %ld\n", ftell(in));
		exit(1);
	}
	fprintf(out, "\t{ \"%s\", { 0x%s, %d, \"%s\" } },\n",
			name, code, instr_len(args), args);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd62(%rip), %rsi       # 0x20f8
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x5(%rsp), %r8
xorl %eax, %eax
callq 0x1030
cmpl $0x3, %eax
jne 0x13e7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1249
leaq 0xd67(%rip), %rsi       # 0x212c
leaq 0x10(%rsp), %rdx
leaq 0x5(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %r8d
movq %r14, %r9
xorl %eax, %eax
callq 0x1070
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x2c0a(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
movq %r14, %rdi
callq 0x1080
leaq 0xd05(%rip), %rsi       # 0x2105
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/gen.c
// Function: main
int main(void)
{
	FILE *out;

	init_operands();
	read_file(oper_name, read_operands, NULL);

	out = safe_open(out_name, "w");
	fputs(head, out);
	read_file(instr_name, write_table, out);
	fputs(tail, out);
	safe_close(out_name, out);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x12d8
leaq 0xbeb(%rip), %rdi       # 0x2010
leaq -0x138(%rip), %rsi      # 0x12f4
xorl %edx, %edx
callq 0x1273
leaq 0xbf8(%rip), %rbx       # 0x2032
leaq 0xd0b(%rip), %rsi       # 0x214c
movq %rbx, %rdi
callq 0x11cc
movq %rax, %r14
leaq 0xbed(%rip), %rdi       # 0x2040
movq %rax, %rsi
callq 0x1050
leaq 0xbc1(%rip), %rdi       # 0x2023
leaq -0xe7(%rip), %rsi       # 0x1382
movq %r14, %rdx
callq 0x1273
leaq 0xc23(%rip), %rdi       # 0x209b
movq %r14, %rsi
callq 0x1050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11ec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_16_xsh_rs_8_boundedrand_r
inline uint8_t pcg_oneseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng,
                                                    uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_oneseq_16_xsh_rs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x163f
cmpb %bpl, %al
jb 0x1675
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_16_xsh_rs_8_boundedrand_r
inline uint8_t
pcg_setseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_setseq_16* rng,
                                     uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_setseq_16_xsh_rs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x16e1
cmpb %bpl, %al
jb 0x1716
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_16_xsh_rs_8_boundedrand_r
inline uint8_t pcg_mcg_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng,
                                                 uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_mcg_16_xsh_rs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x1730
cmpb %bpl, %al
jb 0x1761
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_16_xsh_rr_8_boundedrand_r
inline uint8_t pcg_oneseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
                                                    uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_oneseq_16_xsh_rr_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x177b
cmpb %bpl, %al
jb 0x17a9
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_16_xsh_rr_8_boundedrand_r
inline uint8_t pcg_unique_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
                                                    uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_unique_16_xsh_rr_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x17c3
cmpb %bpl, %al
jb 0x17f2
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_16_xsh_rr_8_boundedrand_r
inline uint8_t
pcg_setseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_setseq_16* rng,
                                     uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_setseq_16_xsh_rr_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x180c
cmpb %bpl, %al
jb 0x1838
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_16_xsh_rr_8_boundedrand_r
inline uint8_t pcg_mcg_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
                                                 uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_mcg_16_xsh_rr_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x1852
cmpb %bpl, %al
jb 0x187a
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_16_rxs_m_xs_16_boundedrand_r
inline uint16_t
pcg_oneseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng,
                                        uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_oneseq_16_rxs_m_xs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1894
cmpw %bp, %ax
jb 0x18d7
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_16_rxs_m_xs_16_boundedrand_r
inline uint16_t
pcg_unique_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng,
                                        uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_unique_16_rxs_m_xs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x18f0
cmpw %bp, %ax
jb 0x1938
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_16_rxs_m_xs_16_boundedrand_r
inline uint16_t
pcg_setseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_setseq_16* rng,
                                        uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_setseq_16_rxs_m_xs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1951
cmpw %bp, %ax
jb 0x1992
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/pcg-advance-16.c
// Function: pcg_advance_lcg_16
uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta, uint16_t cur_mult,
                            uint16_t cur_plus)
{
    uint16_t acc_mult = 1u;
    uint16_t acc_plus = 0u;
    while (delta > 0) {
        if (delta & 1) {
            acc_mult *= cur_mult;
            acc_plus = acc_plus * cur_mult + cur_plus;
        }
        cur_plus = (cur_mult + 1) * cur_plus;
        cur_mult *= cur_mult;
        delta /= 2;
    }
    return acc_mult * state + acc_plus;
}

// Assembly:
movw $0x1, %r8w
xorl %eax, %eax
pushq $0x1
popq %r9
testw %si, %si
je 0x2242
movl %eax, %r10d
imull %edx, %r10d
addl %ecx, %r10d
testb $0x1, %sil
movzwl %si, %esi
movl %edx, %r11d
cmovel %r9d, %r11d
cmovel %eax, %r10d
imull %r11d, %r8d
leal 0x1(%rdx), %eax
imull %ecx, %eax
imull %edx, %edx
shrl %esi
movl %eax, %ecx
movl %r10d, %eax
jmp 0x220b
imull %edi, %r8d
addl %r8d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/pivot.c
// Function: main
int main(int argc, char **argv) {
  int old, new;

  if (argc < 2) {
    fprintf(stderr, "Usage: %s NEW-ROOT [PUT-OLD]\n", argv[0]);
    return 64;
  }

  if (argc > 2) {
    if (syscall(__NR_pivot_root, argv[1], argv[2]) < 0)
      err(EXIT_FAILURE, "cannot pivot to new root %s", argv[1]);
    return EXIT_SUCCESS;
  }

  if (old = open("/", O_DIRECTORY | O_RDONLY), old < 0)
    err(EXIT_FAILURE, "cannot open /");
  if (new = open(argv[1], O_DIRECTORY | O_RDONLY), new < 0)
    err(EXIT_FAILURE, "cannot open %s", argv[1]);
  if (fchdir(new) < 0 || syscall(__NR_pivot_root, ".", ".") < 0)
    err(EXIT_FAILURE, "cannot pivot to new root %s", argv[1]);

  if (fchdir(old) < 0)
    err(EXIT_FAILURE, "cannot re-enter old root");
  if (mount("", ".", "", MS_SLAVE | MS_REC, NULL) < 0)
    err(EXIT_FAILURE, "cannot disable old root mount propagation");
  if (umount2(".", MNT_DETACH) < 0)
    err(EXIT_FAILURE, "cannot detach old root");

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x1293
cmpl $0x2, %edi
jne 0x126f
leaq 0xe8e(%rip), %rdi       # 0x204a
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
js 0x12c1
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
js 0x12ca
movl %eax, %edi
callq 0x1080
testl %eax, %eax
js 0x12b4
leaq 0xe5b(%rip), %rdx       # 0x205b
movl $0x9b, %edi
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1060
testq %rax, %rax
js 0x12b4
movl %ebp, %edi
callq 0x1080
testl %eax, %eax
js 0x12df
leaq 0xe2d(%rip), %rsi       # 0x205b
leaq 0xdec(%rip), %rdi       # 0x2021
xorl %r14d, %r14d
movl $0x84000, %ecx          # imm = 0x84000
movq %rdi, %rdx
xorl %r8d, %r8d
callq 0x1040
testl %eax, %eax
js 0x12e8
leaq 0xe04(%rip), %rdi       # 0x205b
pushq $0x2
popq %rsi
callq 0x1030
testl %eax, %eax
jns 0x128b
leaq 0xe36(%rip), %rsi       # 0x20a0
jmp 0x12ef
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
xorl %r14d, %r14d
movl $0x9b, %edi
xorl %eax, %eax
callq 0x1060
testq %rax, %rax
js 0x12b4
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2d5e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xd5d(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1050
pushq $0x40
popq %r14
jmp 0x128b
movq 0x8(%rbx), %rdx
leaq 0xd63(%rip), %rsi       # 0x2022
jmp 0x12d5
leaq 0xd76(%rip), %rsi       # 0x203e
jmp 0x12ef
movq 0x8(%rbx), %rdx
leaq 0xd77(%rip), %rsi       # 0x204c
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1070
leaq 0xd77(%rip), %rsi       # 0x205d
jmp 0x12ef
leaq 0xd87(%rip), %rsi       # 0x2076
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/gmcvicker[P]check_fastq/split_fastq.c
// Function: check_line_len
static void check_line_len(ReadSeq *read, char *line, gzFile f) {
  size_t len, n;
  char c;

  len = strlen(line);
  if(len == 0) {
    return;
  }
  if(line[len-1] == '\n') {
    return;
  }
  
  /* line did not terminate with a '\n' */
  my_warn("%s:%d: line did not terminate with '\\n':  \n'%s'\n", 
          __FILE__, __LINE__, line, len);

  read->status = FASTQ_ERR;

  /* seek in file until next '\n' is found */
  n = 0;
  while((c = gzgetc(f)) != -1) {
    n++;

    if(n < 10) {
      if(isprint(c)) {
        fprintf(stderr, "  extra character %ld: '%c'\n", n, c);
      }
      else {
        fprintf(stderr, "  unprintable extra character %ld: '\\%d'\n", n, c);
      }
    } else if(n == 10) {
      fprintf(stderr, "  ...\n");      
    }
    
    if(c == '\n') {
      fprintf(stderr, "  read %ld extra characters to reach end of line\n", n);
      return;
    }
  }

  fprintf(stderr, "  read %ld extra characters to reach end of file\n", n);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1110
testq %rax, %rax
je 0x1d6c
cmpb $0xa, -0x1(%r15,%rax)
jne 0x1d7b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24f4(%rip), %rdi      # 0x4276
leaq 0x22dd(%rip), %rsi      # 0x4066
pushq $0x44
popq %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2efd
movl $0x1, 0x1420(%r14)
movq 0x524d(%rip), %r14      # 0x6ff8
xorl %r13d, %r13d
movq %r13, %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x1dd0
decl %eax
movl %eax, (%rbx)
incq 0x10(%rbx)
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %r12b
jmp 0x1ddb
movq %rbx, %rdi
callq 0x10f0
movl %eax, %r12d
cmpb $-0x1, %r12b
je 0x1e48
leaq 0x1(%r15), %r13
cmpq $0x9, %r13
jbe 0x1df9
cmpq $0x9, %r15
je 0x1e1b
cmpb $0xa, %r12b
jne 0x1dae
jmp 0x1e57
movsbl %r12b, %r15d
callq 0x12a0
movq (%rax), %rax
movslq %r15d, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
movq (%r14), %rdi
jne 0x1e32
leaq 0x24ab(%rip), %rsi      # 0x42c4
jmp 0x1e39
movq (%r14), %rcx
leaq 0x24c9(%rip), %rdi      # 0x42ee
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x1260
jmp 0x1df1
leaq 0x246e(%rip), %rsi      # 0x42a7
movq %r13, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1170
jmp 0x1df1
movq (%r14), %rdi
leaq 0x24d5(%rip), %rsi      # 0x4327
movq %r15, %rdx
jmp 0x1e64
movq (%r14), %rdi
leaq 0x2494(%rip), %rsi      # 0x42f5
movq %r13, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Marinouel[P]Network-Lab/client.c
// Function: writen
ssize_t writen(int fd, const void *vptr, size_t n)				//function given from the lessons
 {
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;
    ptr = vptr;
	nleft = n;
	while (nleft > 0) {

		if  ((nwritten = write(fd, ptr, nleft)) <= 0 ){ 
			if (errno == EINTR) 
				nwritten = 0;
          	else 
          		return -1; /* error */ 
		} 
		nleft -= nwritten;
        ptr += nwritten;
	} 
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
pushq $-0x1
popq %r13
movq %rdx, %r12
testq %r12, %r12
je 0x1259
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1060
testq %rax, %rax
jg 0x124e
callq 0x1050
cmpl $0x4, (%rax)
jne 0x1256
xorl %eax, %eax
subq %rax, %r12
addq %rax, %r14
jmp 0x122a
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq