LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x4577
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x454c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_comparator
int list_attributes_comparator(list_t *restrict l, element_comparator comparator_fun) {
    if (l == NULL) return -1;

    l->attrs.comparator = comparator_fun;

    assert(list_attrOk(l));
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x47cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47df
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_seeker
int list_attributes_seeker(list_t *restrict l, element_seeker seeker_fun) {
    if (l == NULL) return -1;

    l->attrs.seeker = seeker_fun;
    assert(list_attrOk(l));

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x480c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x481f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4853
cmpq $0x0, -0x18(%rbp)
jne 0x485c
cmpl $0x0, -0x1c(%rbp)
je 0x485c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4879
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_hash_computer
int list_attributes_hash_computer(list_t *restrict l, element_hash_computer hash_computer_fun) {
    if (l == NULL) return -1;

    l->attrs.hasher = hash_computer_fun;
    assert(list_attrOk(l));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x489c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48af
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_serializer
int list_attributes_serializer(list_t *restrict l, element_serializer serializer_fun) {
    if (l == NULL) return -1;

    l->attrs.serializer = serializer_fun;
    assert(list_attrOk(l));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x48dc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48ef
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_unserializer
int list_attributes_unserializer(list_t *restrict l, element_unserializer unserializer_fun) {
    if (l == NULL) return -1;

    l->attrs.unserializer = unserializer_fun;
    assert(list_attrOk(l));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x491c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x492f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x4bb5
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jb 0x4bbf
movq $0x0, -0x8(%rbp)
jmp 0x4c0a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4c70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4ef0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4e44
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x4e4e
movq $0x0, -0x8(%rbp)
jmp 0x4ec2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x4eba
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
imull -0x14(%rbp), %eax
cmpl $0x0, %eax
jle 0x4eaa
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4eac
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4e73
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f16
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5010
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f65
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x4f3d
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x4f63
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
shrl %ecx
cmpl %ecx, %eax
jb 0x4f61
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4f63
jmp 0x4f8b
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
shrl %ecx
cmpl %ecx, %eax
jae 0x4f89
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4f8b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x4fd3
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4fd3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
cmpl $0x5, 0x28(%rax)
jae 0x5000
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x5009
movq -0x18(%rbp), %rdi
callq 0x3030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_delete
int list_delete(list_t *restrict l, const void *data) {
	int pos, r;

	pos = list_locate(l, data);
	if (pos < 0)
		return -1;

	r = list_delete_at(l, pos);
	if (r < 0)
		return -1;

    assert(list_repOk(l));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x504f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5074
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5170
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x506d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5074
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x50f6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x50f4
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x50db
jmp 0x50f4
jmp 0x50dd
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50b1
jmp 0x513d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x513b
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x5122
jmp 0x513b
jmp 0x5124
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5105
jmp 0x513d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5154
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x515a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x5195
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jb 0x519e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51d2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4ef0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x5495
movq $0x0, -0x8(%rbp)
jmp 0x54f1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x54e9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x54d9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54f1
jmp 0x54db
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x54a4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x57a4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x57ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x57f8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
ja 0x57c0
movl $0x0, -0x4(%rbp)
jmp 0x57f8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %r8d
subl $0x1, %r8d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r9
xorl %edx, %edx
callq 0x5810
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5c1b
movl $0x0, -0x4(%rbp)
jmp 0x5c4b
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x5c6c
movq $0x0, -0x8(%rbp)
jmp 0x5ca4
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_iterator_stop
int list_iterator_stop(list_t *restrict l) {
    if (! l->iter_active) return 0;
    l->iter_pos = 0;
    l->iter_active = 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x5d0b
movl $0x0, -0x4(%rbp)
jmp 0x5d28
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
shll %eax
addl $0x64, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x5d63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5dd9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x5dc7
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movl %eax, %ecx
movl -0x28(%rbp), %eax
xorl %ecx, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x18(%rcx)
addl -0x24(%rbp), %edx
movl %edx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5d72
jmp 0x5dc9
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x31c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x6171
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x618e
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x5df0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
callq 0x30f0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x31c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x6cfb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d20
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x61a0
cltq
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x30f0
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x31c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x6d65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d8a
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x67b0
cltq
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x30f0
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_sort_selectionsort
static inline void list_sort_selectionsort(list_t *restrict l, int versus, 
        unsigned int first, struct list_entry_s *fel,
        unsigned int last, struct list_entry_s *lel) {
    struct list_entry_s *cursor, *toswap, *firstunsorted;
    void *tmpdata;

    if (last <= first) /* <= 1-element lists are always sorted */
        return;
    
    for (firstunsorted = fel; firstunsorted != lel; firstunsorted = firstunsorted->next) {
        /* find min or max in the remainder of the list */
        for (toswap = firstunsorted, cursor = firstunsorted->next; cursor != lel->next; cursor = cursor->next)
            if (l->attrs.comparator(toswap->data, cursor->data) * -versus > 0) toswap = cursor;
        if (toswap != firstunsorted) { /* swap firstunsorted with toswap */
            tmpdata = firstunsorted->data;
            firstunsorted->data = toswap->data;
            toswap->data = tmpdata;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x73fb
jmp 0x74b1
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x74b1
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x7470
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdi
movq -0x30(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
imull %ecx, %eax
cmpl $0x0, %eax
jle 0x7460
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x7462
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x7425
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x749e
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x74a0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x7403
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, %al
callq 0x3ba0
cmpq $0x1, %rax
jne 0x74e7
testb $0x1, 0x4e34(%rip)      # 0xc310
je 0x74e7
xorl %eax, %eax
movl %eax, %edi
callq 0x3bb0
movb $0x0, %al
callq 0x3ba0
cmpq $0x1, %rax
jne 0x7509
testb $0x1, 0x4e16(%rip)      # 0xc311
je 0x7509
xorl %edi, %edi
movl $0x1, %esi
callq 0x3cc0
movb $0x0, %al
callq 0x3ba0
cmpq $0x1, %rax
jne 0x7580
xorl %edi, %edi
callq 0x3c10
cmpq $0x1, %rax
jne 0x7580
testb $0x1, 0x4de8(%rip)      # 0xc312
je 0x7580
movb $0x0, -0x1(%rbp)
movl $0x2, %edi
callq 0x3c10
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3c10
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x757e
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
leaq -0x1(%rbp), %rdi
movl $0x1, %edx
callq 0x4120
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7552
jmp 0x7580
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbf9f
movl $0x10, %eax
cmpl -0x4(%rbp), %eax
jg 0xbf8a
cmpl $0xff, -0x4(%rbp)
jg 0xbf8a
movq 0xb7f4(%rip), %rax      # 0x17778
movq %rax, -0x10(%rbp)
jmp 0xbf9d
movslq -0x4(%rbp), %rcx
leaq 0xb7ab(%rip), %rax      # 0x17740
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbf9f
movq 0x10312(%rip), %rdi     # 0x1c2b8
movq 0x10383(%rip), %rsi     # 0x1c330
movq 0x1030c(%rip), %rdx     # 0x1c2c0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x54e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
movl $0x0, -0x3f4(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11f0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x11bf
movl -0x3f4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11ac
movl -0x8(%rbp), %eax
movl %eax, -0x3f4(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq -0x7e0(%rbp), %rsi
callq 0x12d0
movl -0x8(%rbp), %esi
leaq 0xe4e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x116c
cmpl $0x0, -0x3f4(%rbp)
jle 0x11dd
leaq -0x7e0(%rbp), %rsi
leaq 0xe3f(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x1236
callq 0x1040
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x1236
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x123f
jmp 0x125a
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1206
cmpl $0xa, -0x10(%rbp)
jne 0x1279
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
cmpl $-0x1, -0x10(%rbp)
movb %al, -0x16(%rbp)
je 0x129a
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x12a3
jmp 0x12b6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
callq 0x1040
movl %eax, -0x10(%rbp)
jmp 0x1285
cmpl $0xa, -0x10(%rbp)
jne 0x12c5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x120c
movq 0x10(%rsp), %rdi
callq 0x10b0
movl $0x1, %edi
callq 0x10c0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movb %dil, %al
movb %al, 0x7(%rsp)
movsbq 0x7(%rsp), %rcx
leaq 0x2e1b(%rip), %rax      # 0x4090
cmpl $0x0, (%rax,%rcx,4)
jge 0x12a2
movq 0x2d76(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movsbl 0x7(%rsp), %edx
leaq 0xe0d(%rip), %rsi       # 0x209e
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
movsbq 0x7(%rsp), %rcx
leaq 0x2de1(%rip), %rax      # 0x4090
movl (%rax,%rcx,4), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x130a
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
callq 0x1260
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x12db
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xd74(%rip), %rsi       # 0x20b3
callq 0x11d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1060
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x1360
jmp 0x13c4
cmpl $0xa, 0x4(%rsp)
jne 0x1369
jmp 0x1349
cmpl $0x23, 0x4(%rsp)
jne 0x1372
jmp 0x1391
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x1090
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
jmp 0x1393
movq 0x8(%rsp), %rdi
callq 0x1060
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpl $0xa, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x13ba
cmpl $-0x1, 0x4(%rsp)
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x1393
jmp 0x1349
movq 0x8(%rsp), %rdi
callq 0x1040
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xc7b(%rip), %rsi       # 0x20b5
leaq 0x17(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movb $0x0, %al
callq 0x1030
cmpl $0x2, %eax
je 0x1489
movq 0x2ba1(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0xc43(%rip), %rsi       # 0x20bb
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
movsbq 0x17(%rsp), %rcx
leaq 0x2bfa(%rip), %rax      # 0x4090
cmpl $-0x1, (%rax,%rcx,4)
je 0x14c3
movq 0x2b55(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movsbl 0x17(%rsp), %edx
leaq 0xc2c(%rip), %rsi       # 0x20de
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
movl 0x10(%rsp), %edx
movsbq 0x17(%rsp), %rcx
leaq 0x2bbc(%rip), %rax      # 0x4090
movl %edx, (%rax,%rcx,4)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x25(%rsp), %r8
leaq 0xbe5(%rip), %rsi       # 0x20f8
movb $0x0, %al
callq 0x1030
cmpl $0x3, %eax
je 0x1558
movq 0x2ad2(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1080
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0xbbe(%rip), %rsi       # 0x2105
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x25(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl %eax, %r8d
leaq 0x28(%rsp), %r9
leaq 0xb90(%rip), %rsi       # 0x212c
movb $0x0, %al
callq 0x1070
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x13e0
leaq 0xa48(%rip), %rdi       # 0x2010
leaq -0x1af(%rip), %rsi      # 0x1420
xorl %eax, %eax
movl %eax, %edx
callq 0x1320
leaq 0xa53(%rip), %rdi       # 0x2032
leaq 0xb66(%rip), %rsi       # 0x214c
callq 0x11d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0xa44(%rip), %rdi       # 0x2040
callq 0x1050
movq 0x8(%rsp), %rdx
leaq 0xa16(%rip), %rdi       # 0x2023
leaq -0x134(%rip), %rsi      # 0x14e0
callq 0x1320
movq 0x8(%rsp), %rsi
leaq 0xa76(%rip), %rdi       # 0x209b
callq 0x1050
movq 0x8(%rsp), %rsi
leaq 0x9fc(%rip), %rdi       # 0x2032
callq 0x1220
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_16_srandom_r
inline void pcg_oneseq_16_srandom_r(struct pcg_state_16* rng,
                                    uint16_t initstate)
{
    rng->state = 0U;
    pcg_oneseq_16_step_r(rng);
    rng->state += initstate;
    pcg_oneseq_16_step_r(rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x16d0
movzwl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movzwl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x16d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_16_srandom_r
inline void pcg_setseq_16_srandom_r(struct pcg_state_setseq_16* rng,
                                    uint16_t initstate, uint16_t initseq)
{
    rng->state = 0U;
    rng->inc = (initseq << 1u) | 1u;
    pcg_setseq_16_step_r(rng);
    rng->state += initstate;
    pcg_setseq_16_step_r(rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movzwl -0xc(%rbp), %eax
shll %eax
orl $0x1, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rdi
callq 0x1830
movzwl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movzwl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1830
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19e0
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1a64
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1a39
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_16_xsh_rs_8_boundedrand_r
inline uint8_t pcg_unique_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_unique_16_xsh_rs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a70
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1af4
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1ac9
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b00
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1b84
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1b59
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1ca4
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1c79
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cb0
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1d34
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1d09
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d40
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1dc4
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1d99
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd0
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1e54
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1e29
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzwl %ax, %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e60
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1ee9
movzwl -0xe(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1ebc
nopl (%rax,%rax)