LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/asprintf.c
// Function: vasprintf
int vasprintf(char **ret, const char *fmt, va_list ap)
{
    int n;
    va_list ap2;

    va_copy(ap2, ap);

    if ((n = vsnprintf(NULL, 0, fmt, ap2)) < 0)
        goto error;

    va_end(ap2);

    if ((*ret = malloc(n + 1)) == NULL)
        goto error;

    if ((n = vsnprintf(*ret, n + 1, fmt, ap)) < 0) {
        free(*ret);
        goto error;
    }

    return n;

  error:
    *ret = NULL;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1060
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x24d8
jmp 0x2534
leaq -0x40(%rbp), %rax
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x24f9
jmp 0x2534
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1060
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x252c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
jmp 0x2534
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2546
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: get_next
ll *get_next(ll * node)
{
    if (!node)
        return NULL;

    if (!(node->nxt))
        return NULL;

    return node->nxt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2609
movq $0x0, -0x8(%rbp)
jmp 0x262a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x261e
movq $0x0, -0x8(%rbp)
jmp 0x262a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: set_next
ll *set_next(ll * node, ll * next)
{
    if (!node)
        return NULL;

    node->nxt = next;

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x264d
movq $0x0, -0x8(%rbp)
jmp 0x2661
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: set_tag
ll *set_tag(ll * node, int tag)
{
    if (!node)
        return NULL;

    node->tag = tag;

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26bc
movq $0x0, -0x8(%rbp)
jmp 0x26cd
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: set_data
ll *set_data(ll * node, void *data)
{
    if (!node)
        return NULL;

    node->data = data;

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x272d
movq $0x0, -0x8(%rbp)
jmp 0x2741
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: get_end
ll *get_end(ll * node)
{
    if (!node)
        return NULL;

    if (!(node->nxt))
        return node;

    while (node->nxt)
        node = get_next(node);

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x276d
movq $0x0, -0x8(%rbp)
jmp 0x27a6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2782
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27a6
jmp 0x2784
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x279e
movq -0x10(%rbp), %rdi
callq 0x25f0
movq %rax, -0x10(%rbp)
jmp 0x2784
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: append_node
ll *append_node(ll * cur, ll * new)
{
    if (!cur || !new)
        return NULL;

    if (!(cur->nxt)) {
        cur->nxt = new;
        return cur;
    }

    cur = get_end(cur);
    cur->nxt = new;
    return cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27ce
cmpq $0x0, -0x18(%rbp)
jne 0x27d8
movq $0x0, -0x8(%rbp)
jmp 0x281a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x27f9
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x281a
movq -0x10(%rbp), %rdi
callq 0x2750
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: prepend_node
ll *prepend_node(ll * cur, ll * new)
{
    if (!cur || !new)
        return NULL;

    new->nxt = cur;
    return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x284a
cmpq $0x0, -0x18(%rbp)
jne 0x2854
movq $0x0, -0x8(%rbp)
jmp 0x2868
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: new_node
ll *new_node(int tag, void *data, ll * next)
{
    ll *new;

    if (!(new = malloc(sizeof(ll))))
        return NULL;

    new->tag = tag;
    new->data = data;
    new->nxt = next;

    return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x28a1
movq $0x0, -0x8(%rbp)
jmp 0x28ca
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%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/chbarts[P]aa-tree/ll3.c
// Function: map
ll *map(ll * beg, void *(proc) (int, void *))
{
    ll *tmp = beg;

    if (!beg)
        return NULL;

    while (beg) {
        beg->data = proc(beg->tag, beg->data);
        beg = beg->nxt;
    }

    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2909
movq $0x0, -0x8(%rbp)
jmp 0x2947
jmp 0x290b
cmpq $0x0, -0x10(%rbp)
je 0x293f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %edi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x290b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: reverse
ll *reverse(ll * beg)
{
    ll *nxt1, *nxt2;

    if (!beg)
        return NULL;

    if (!(beg->nxt))
        return beg;

    nxt1 = beg->nxt;
    beg->nxt = NULL;

    while (1) {
        nxt2 = nxt1->nxt;
        nxt1->nxt = beg;
        if (!nxt2) {
            return nxt1;
        }

        beg = nxt1;
        nxt1 = nxt2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2979
movq $0x0, -0x8(%rbp)
jmp 0x29e1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x298e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29e1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x29cf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29e1
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x29a6
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: free_all_data
ll *free_all_data(ll * beg)
{
    ll *tmp = beg;

    if (!beg)
        return NULL;

    while (beg) {
        free(beg->data);
        beg->data = NULL;
        beg = beg->nxt;
    }

    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2a15
movq $0x0, -0x8(%rbp)
jmp 0x2a4d
jmp 0x2a17
cmpq $0x0, -0x10(%rbp)
je 0x2a45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a17
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ll3.c
// Function: free_all_nodes
void free_all_nodes(ll * beg)
{
    ll *tmp;

    if (!beg)
        return;

    while (beg) {
        tmp = beg->nxt;
        beg->nxt = NULL;
        free(beg);
        beg = tmp;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2a75
jmp 0x2aab
jmp 0x2a77
cmpq $0x0, -0x8(%rbp)
je 0x2aa9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a77
jmp 0x2aab
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: comparator
static int comparator(void *left, void *right)
{
    char *cl, *cr;
    int r;

    cl = (char *) get_data((ll *) left);
    cr = (char *) get_data((ll *) right);

    r = strcmp(cl, cr);

    if (r > 0) {
        r = 1;
    } else if (r < 0) {
        r = -1;
    }

    return (rev * r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x2f99
movl $0x1, -0x24(%rbp)
jmp 0x2fa8
cmpl $0x0, -0x24(%rbp)
jge 0x2fa6
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x2fa8
movl 0x412e(%rip), %eax      # 0x70dc
imull -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: dofile
static void dofile(char *fname, FILE * fin, aa * tree, bool bylen)
{
    char *ln, *lnl;
    ll *lln;

    while (fggets(&ln, fin) == 0) {
#ifdef DEBUG
        printf("read: %s\n", ln);
#endif

        if (bylen) {
            if (asprintf
                (&lnl, "%llu:%s", (unsigned long long int) strlen(ln),
                 ln) == -1) {
                free(ln);
                error(tree);
            }

            free(ln);
            ln = lnl;
#ifdef DEBUG
            printf("%s\n", ln);
#endif
        }

        if ((lln = new_node(1, ln, NULL)) == NULL) {
            free(ln);
            error(tree);
        }

        switch (aa_add(tree, (void *) lln, duplicate)) {
        case 0:                /* no error */
            break;
        case 2:                /* memory error */
            free(ln);
            free(lln);
            error(tree);
            break;
        default:               /* can't happen */
            fprintf(stderr, "can't happen\n");
            free(ln);
            free(lln);
            cleanup(tree);
            exit(EXIT_FAILURE);
            break;
        }
    }

    if (ferror(fin) != 0)
        handle_ferr(fname, "sort2");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1290
cmpl $0x0, %eax
jne 0x30f9
testb $0x1, -0x19(%rbp)
je 0x3041
movq -0x28(%rbp), %rdi
callq 0x1080
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq 0x110e(%rip), %rsi      # 0x4120
movb $0x0, %al
callq 0x2550
cmpl $-0x1, %eax
jne 0x3030
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x34f0
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x2870
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x306f
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x34f0
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x4b2(%rip), %rdx       # 0x3530
callq 0x14d0
movl %eax, %ecx
movl %ecx, -0x3c(%rbp)
testl %eax, %eax
je 0x3098
jmp 0x308e
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x309a
jmp 0x30b7
jmp 0x30f4
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x34f0
jmp 0x30f4
movq 0x3f3a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1060(%rip), %rsi      # 0x4128
movb $0x0, %al
callq 0x1100
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x3180
movl $0x1, %edi
callq 0x1170
jmp 0x2fdb
movq -0x10(%rbp), %rdi
callq 0x1050
cmpl $0x0, %eax
je 0x3117
movq -0x8(%rbp), %rdi
leaq 0x1008(%rip), %rsi      # 0x411a
callq 0x1410
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: printall
static void *printall(void *data)
{
    ll *node = (ll *) data;
    char *ln;
    int n;

    n = get_tag(node);
    ln = get_data(node);
    while (n-- > 0)
        puts(ln);

    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2670
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x3168
movq -0x18(%rbp), %rdi
callq 0x1040
jmp 0x314d
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: usage
static void usage(char *pname)
{
    printf("Usage: %s [OPTION] [FILE...]\n", pname);
    puts("Sort files or, if no files on the command line, sort stdin.");
    puts("Multiple sorting criteria can be combined.");
    puts("All files sorted together into one output.");
    puts("");
    puts("  -u, --uniqify     Only print identical lines once");
    puts("  -r, --reverse     Reverse the sense of the comparison");
    puts("  -n, --numer       Sort numerically, then non-numerically");
    puts("  -b, --bylen       Sort by length first, then by other critera");
    puts("  -h, --help        Print this help");
    puts("  -v, --version     Print version information");
    puts("");
    puts("Report bugs to <chbarts@gmail.com>.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xf7d(%rip), %rdi       # 0x4144
movb $0x0, %al
callq 0x10b0
leaq 0xf8d(%rip), %rdi       # 0x4162
callq 0x1040
leaq 0xfbd(%rip), %rdi       # 0x419e
callq 0x1040
leaq 0xfdc(%rip), %rdi       # 0x41c9
callq 0x1040
leaq 0xe94(%rip), %rdi       # 0x408d
callq 0x1040
leaq 0xfef(%rip), %rdi       # 0x41f4
callq 0x1040
leaq 0x1017(%rip), %rdi      # 0x4228
callq 0x1040
leaq 0x1043(%rip), %rdi      # 0x4260
callq 0x1040
leaq 0x1072(%rip), %rdi      # 0x429b
callq 0x1040
leaq 0x10a6(%rip), %rdi      # 0x42db
callq 0x1040
leaq 0x10be(%rip), %rdi      # 0x42ff
callq 0x1040
leaq 0xe40(%rip), %rdi       # 0x408d
callq 0x1040
leaq 0x10d4(%rip), %rdi      # 0x432d
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: version
static void version(void)
{
    puts("sort2 version 0.1.0");
    puts("Copyright 2014 Chris Barts.");
    puts("sort2 comes with NO WARRANTY to the extent permitted by law.");
    puts("You may redistribute this software under the terms");
    puts("of the GNU General Public License.");
    puts("For more information, see the file named COPYING");
    puts("in this program's distribution file.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10d6(%rip), %rdi      # 0x4351
callq 0x1040
leaq 0x10de(%rip), %rdi      # 0x4365
callq 0x1040
leaq 0x10ee(%rip), %rdi      # 0x4381
callq 0x1040
leaq 0x111f(%rip), %rdi      # 0x43be
callq 0x1040
leaq 0x1146(%rip), %rdi      # 0x43f1
callq 0x1040
leaq 0x115d(%rip), %rdi      # 0x4414
callq 0x1040
leaq 0x1182(%rip), %rdi      # 0x4445
callq 0x1040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: lncomparator
static int lncomparator(void *left, void *right)
{
    ll *l = (ll *) left, *r = (ll *) right;
    unsigned long long int ln, rn;
    char *ls, *rs, *cro, *clo;
    int res = 0;

    ls = (char *) get_data(l);
    rs = (char *) get_data(r);

    ln = strtoll(ls, &clo, 10);
    rn = strtoll(rs, &cro, 10);

    if (ln < rn) {
        res = -1;
    } else if (ln > rn) {
        res = 1;
    } else {
        return sncomp(clo + 1, cro + 1);
    }

    return (rev * res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x26e0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x26e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0xa, %edx
callq 0x10f0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0xa, %edx
callq 0x10f0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x3350
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
jmp 0x337f
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x3363
movl $0x1, -0x5c(%rbp)
jmp 0x337d
movq -0x58(%rbp), %rdi
addq $0x1, %rdi
movq -0x50(%rbp), %rsi
addq $0x1, %rsi
callq 0x35e0
movl %eax, -0x4(%rbp)
jmp 0x338c
jmp 0x337f
movl 0x3d57(%rip), %eax      # 0x70dc
imull -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: lprint
static void *lprint(void *data)
{
    ll *node = (ll *) data;
    char *ln;

    ln = get_data(node);
    puts(strchr(ln, ':') + 1);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x10a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1040
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: lprintall
static void *lprintall(void *data)
{
    ll *node = (ll *) data;
    char *ln, *lno;
    int n;

    ln = get_data(node);
    lno = strchr(ln, ':') + 1;
    n = get_tag(data);
    while (n-- > 0)
        puts(lno);

    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x10a0
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2670
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x349e
movq -0x20(%rbp), %rdi
callq 0x1040
jmp 0x3483
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: print
static void *print(void *data)
{
    ll *node = (ll *) data;
    char *ln;

    ln = get_data(node);
    puts(ln);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: duplicate
static int duplicate(void *orig, void *new)
{
    int n;
    ll *node = (ll *) orig, *node2 = (ll *) new;
    char *ln;

    n = get_tag(node);
    set_tag(node, n + 1);
    ln = get_data(node2);
    free(ln);
    free(node2);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2670
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x26a0
movq -0x28(%rbp), %rdi
callq 0x26e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: freedata
static void *freedata(void *data)
{
    ll *node = (ll *) data;
    char *ln;

    ln = get_data(node);
    free(ln);
    free(node);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort2.c
// Function: sncomp
static int sncomp(char *left, char *right)
{
    long long int nl, nr;
    char *clo, *cro;
    int r = 0;

    nl = strtoll(left, &clo, 10);
    nr = strtoll(right, &cro, 10);

    if (nl < nr) {
        r = -1;
    } else if (nl > nr) {
        r = 1;
    } else {
        r = strcmp(clo, cro);

        if (r < 0) {
            r = -1;
        } else if (r > 0) {
            r = 1;
        }
    }

    return (rev * r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x10f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x3636
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0x367b
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x3649
movl $0x1, -0x34(%rbp)
jmp 0x3679
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10e0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x3668
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0x3677
cmpl $0x0, -0x34(%rbp)
jle 0x3675
movl $0x1, -0x34(%rbp)
jmp 0x3677
jmp 0x3679
jmp 0x367b
movl 0x3a5b(%rip), %eax      # 0x70dc
imull -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/main.c
// Function: event_handler
static void event_handler(lv_obj_t * obj, lv_event_t event)
{
  if(event == LV_EVENT_CLICKED) {
    printf("Clicked\n");
  }
  else if(event == LV_EVENT_VALUE_CHANGED) {
    printf("Toggled\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x6, %eax
jne 0x23eb
leaq 0x65c50(%rip), %rdi     # 0x68032
movb $0x0, %al
callq 0x2080
jmp 0x2404
movzbl -0x9(%rbp), %eax
cmpl $0xe, %eax
jne 0x2402
leaq 0x65c40(%rip), %rdi     # 0x6803b
movb $0x0, %al
callq 0x2080
jmp 0x2404
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_create
lv_group_t * lv_group_create(void)
{
    lv_group_t * group = lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
    LV_ASSERT_MEM(group);
    if(group == NULL) return NULL;
    lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));

    group->obj_focus      = NULL;
    group->frozen         = 0;
    group->focus_cb       = NULL;
    group->click_focus    = 1;
    group->editing        = 0;
    group->refocus_policy = LV_GROUP_REFOCUS_POLICY_PREV;
    group->wrap           = 1;

#if LV_USE_USER_DATA
    memset(&group->user_data, 0, sizeof(lv_group_user_data_t));
#endif

    /*Initialize style modification callbacks from current theme*/
    refresh_theme(group, lv_theme_get_current());

    return group;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x8f201(%rip), %rdi     # 0x91640
callq 0x453f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x2467
movq -0x10(%rbp), %rsi
leaq 0x65be4(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x2465
cmpq $0x0, -0x10(%rbp)
jne 0x247b
movq $0x0, -0x8(%rbp)
jmp 0x2530
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x453a0
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x4cfc0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x2540
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: refresh_theme
static void refresh_theme(lv_group_t * g, lv_theme_t * th)
{
    g->style_mod_cb      = style_mod_def;
    g->style_mod_edit_cb = style_mod_edit_def;
    if(th) {
        if(th->group.style_mod_xcb) g->style_mod_cb = th->group.style_mod_xcb;
        if(th->group.style_mod_edit_xcb) g->style_mod_edit_cb = th->group.style_mod_edit_xcb;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0xee9(%rip), %rcx       # 0x3440
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x115a(%rip), %rcx      # 0x36c0
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x25b5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x350(%rax)
je 0x2592
movq -0x10(%rbp), %rax
movq 0x350(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x358(%rax)
je 0x25b3
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x25b5
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_del
void lv_group_del(lv_group_t * group)
{
    /*Defocus the the currently focused object*/
    if(group->obj_focus != NULL) {
        (*group->obj_focus)->signal_cb(*group->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        lv_obj_invalidate(*group->obj_focus);
    }

    /*Remove the objects from the group*/
    lv_obj_t ** obj;
    LV_LL_READ(group->obj_ll, obj)
    {
        (*obj)->group_p = NULL;
    }

    lv_ll_clear(&(group->obj_ll));
    lv_ll_rem(&LV_GC_ROOT(_lv_group_ll), group);
    lv_mem_free(group);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x260c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdi
movl $0x11, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
callq 0x7430
movq -0x8(%rbp), %rdi
callq 0x45660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2642
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x10(%rbp)
jmp 0x2619
movq -0x8(%rbp), %rdi
callq 0x45910
movq -0x8(%rbp), %rsi
leaq 0x8efea(%rip), %rdi     # 0x91640
callq 0x45790
movq -0x8(%rbp), %rdi
callq 0x44ec0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_add_obj
void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
{
    if(group == NULL) return;

    /*Do not add the object twice*/
    lv_obj_t ** obj_i;
    LV_LL_READ(group->obj_ll, obj_i)
    {
        if((*obj_i) == obj) {
            LV_LOG_INFO("lv_group_add_obj: the object is already added to this group");
            return;
        }
    }

    /*If the object is already in a group and focused then defocus it*/
    if(obj->group_p) {
        if(lv_obj_is_focused(obj)) {
            lv_group_refocus(obj->group_p);

            LV_LOG_INFO("lv_group_add_obj: assign object to an other group");
        }
    }

    obj->group_p     = group;
    lv_obj_t ** next = lv_ll_ins_tail(&group->obj_ll);
    LV_ASSERT_MEM(next);
    if(next == NULL) return;
    *next = obj;

    /* If the head and the tail is equal then there is only one object in the linked list.
     * In this case automatically activate it*/
    if(lv_ll_get_head(&group->obj_ll) == next) {
        lv_group_refocus(group);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x268c
jmp 0x2754
movq -0x8(%rbp), %rdi
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26c7
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x26b2
jmp 0x2754
jmp 0x26b4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x2699
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x26f0
movq -0x10(%rbp), %rdi
callq 0xaa20
testb $0x1, %al
jne 0x26e1
jmp 0x26ee
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2760
jmp 0x26f0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x456d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x2728
movq -0x20(%rbp), %rsi
leaq 0x65923(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x2726
cmpq $0x0, -0x20(%rbp)
jne 0x2731
jmp 0x2754
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x45660
cmpq -0x20(%rbp), %rax
jne 0x2754
movq -0x8(%rbp), %rdi
callq 0x2760
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_refocus
static void lv_group_refocus(lv_group_t * g)
{
    /*Refocus must temporarily allow wrapping to work correctly*/
    uint8_t temp_wrap = g->wrap;
    g->wrap           = 1;

    if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_NEXT)
        lv_group_focus_next(g);
    else if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_PREV)
        lv_group_focus_prev(g);
    /*Restore wrap property*/
    g->wrap = temp_wrap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x80(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x80(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x80(%rax)
movq -0x8(%rbp), %rax
movb 0x80(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x27b6
movq -0x8(%rbp), %rdi
callq 0x2cb0
jmp 0x27d8
movq -0x8(%rbp), %rax
movb 0x80(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x27d6
movq -0x8(%rbp), %rdi
callq 0x2f00
jmp 0x27d8
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movb 0x80(%rax), %cl
andb $0x1, %dl
shlb $0x4, %dl
andb $-0x11, %cl
orb %dl, %cl
movb %cl, 0x80(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_remove_obj
void lv_group_remove_obj(lv_obj_t * obj)
{
    lv_group_t * g = obj->group_p;
    if(g == NULL) return;
    if(g->obj_focus == NULL) return; /*Just to be sure (Not possible if there is at least one object in the group)*/

    /*Focus on the next object*/
    if(*g->obj_focus == obj) {
        /*If this is the only object in the group then focus to nothing.*/
        if(lv_ll_get_head(&g->obj_ll) == g->obj_focus && lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
            (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        }
        /*If there more objects in the group then focus to the next/prev object*/
        else {
            lv_group_refocus(g);
        }
    }

    /* If the focuses object is still the same then it was the only object in the group but it will
     * be deleted. Set the `obj_focus` to NULL to get back to the initial state of the group with
     * zero objects*/
    if(*g->obj_focus == obj) {
        g->obj_focus = NULL;
    }

    /*Search the object and remove it from its group */
    lv_obj_t ** i;
    LV_LL_READ(g->obj_ll, i)
    {
        if(*i == obj) {
            lv_ll_rem(&g->obj_ll, i);
            lv_mem_free(i);
            obj->group_p = NULL;
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2824
jmp 0x2914
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2834
jmp 0x2914
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x289d
movq -0x10(%rbp), %rdi
callq 0x45660
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x2892
movq -0x10(%rbp), %rdi
callq 0x458e0
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x2892
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdi
movl $0x11, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
jmp 0x289b
movq -0x10(%rbp), %rdi
callq 0x2760
jmp 0x289d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x28ba
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2914
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x28ff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45790
movq -0x18(%rbp), %rdi
callq 0x44ec0
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
jmp 0x2914
jmp 0x2901
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x28c7
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_remove_all_objs
void lv_group_remove_all_objs(lv_group_t * group)
{
    /*Defocus the the currently focused object*/
    if(group->obj_focus != NULL) {
        (*group->obj_focus)->signal_cb(*group->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        lv_obj_invalidate(*group->obj_focus);
        group->obj_focus = NULL;
    }

    /*Remove the objects from the group*/
    lv_obj_t ** obj;
    LV_LL_READ(group->obj_ll, obj)
    {
        (*obj)->group_p = NULL;
    }

    lv_ll_clear(&(group->obj_ll));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2978
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdi
movl $0x11, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
callq 0x7430
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x45660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29ae
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x10(%rbp)
jmp 0x2985
movq -0x8(%rbp), %rdi
callq 0x45910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_set_editing
void lv_group_set_editing(lv_group_t * group, bool edit)
{
    uint8_t en_val = edit ? 1 : 0;

    if(en_val == group->editing) return; /*Do not set the same mode again*/

    group->editing     = en_val;
    lv_obj_t * focused = lv_group_get_focused(group);

    if(focused) {
        focused->signal_cb(focused, LV_SIGNAL_FOCUS, NULL); /*Focus again to properly leave/open edit/navigate mode*/
        lv_res_t res = lv_event_send(*group->obj_focus, LV_EVENT_FOCUSED, NULL);
        if(res != LV_RES_OK) return;
    }

    lv_obj_invalidate(focused);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movq -0x8(%rbp), %rcx
movb 0x80(%rcx), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2bb3
jmp 0x2c2d
movb -0xa(%rbp), %dl
movq -0x8(%rbp), %rax
movb 0x80(%rax), %cl
andb $0x1, %dl
shlb %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0x80(%rax)
movq -0x8(%rbp), %rdi
callq 0x3010
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c24
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdi
movl $0x10, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movl $0xc, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7990
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x1, %eax
je 0x2c22
jmp 0x2c2d
jmp 0x2c24
movq -0x18(%rbp), %rdi
callq 0x7430
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: obj_to_foreground
static void obj_to_foreground(lv_obj_t * obj)
{
    /*Search for 'top' attribute*/
    lv_obj_t * i        = obj;
    lv_obj_t * last_top = NULL;
    while(i != NULL) {
        if(i->top != 0) last_top = i;
        i = lv_obj_get_parent(i);
    }

    if(last_top != NULL) {
        /*Move the last_top object to the foreground*/
        lv_obj_move_foreground(last_top);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c92
movq -0x10(%rbp), %rax
movw 0x58(%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2c83
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71b0
movq %rax, -0x10(%rbp)
jmp 0x2c5c
cmpq $0x0, -0x18(%rbp)
je 0x2ca2
movq -0x18(%rbp), %rdi
callq 0x7e70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_send_data
lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c)
{
    lv_obj_t * act = lv_group_get_focused(group);
    if(act == NULL) return LV_RES_OK;

    lv_res_t res;

    res = act->signal_cb(act, LV_SIGNAL_CONTROL, &c);
    if(res != LV_RES_OK) return res;

    res = lv_event_send(act, LV_EVENT_KEY, &c);
    if(res != LV_RES_OK) return res;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3010
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2fa9
movb $0x1, -0x1(%rbp)
jmp 0x3000
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdi
movl $0x12, %esi
leaq -0x14(%rbp), %rdx
callq *%rax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0x2fd4
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3000
movq -0x20(%rbp), %rdi
movl $0xb, %esi
leaq -0x14(%rbp), %rdx
callq 0x7990
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0x2ffa
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3000
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_mod_style
lv_style_t * lv_group_mod_style(lv_group_t * group, const lv_style_t * style)
{
    /*Load the current style. It will be modified by the callback*/
    lv_style_copy(&group->style_tmp, style);

    if(group->editing) {
        if(group->style_mod_edit_cb) group->style_mod_edit_cb(group, &group->style_tmp);
    } else {
        if(group->style_mod_cb) group->style_mod_cb(group, &group->style_tmp);
    }
    return &group->style_tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0xc550
movq -0x8(%rbp), %rax
movb 0x80(%rax), %al
shrb %al
andb $0x1, %al
cmpb $0x0, %al
je 0x3216
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3214
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
callq *%rax
jmp 0x3239
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3237
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
callq *%rax
jmp 0x3239
movq -0x8(%rbp), %rax
addq $0x38, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_report_style_mod
void lv_group_report_style_mod(lv_group_t * group)
{
    lv_theme_t * th = lv_theme_get_current();

    if(group != NULL) {
        refresh_theme(group, th);
        return;
    }

    lv_group_t * i;
    LV_LL_READ(LV_GC_ROOT(_lv_group_ll), i)
    {
        refresh_theme(i, th);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4cfc0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x33fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2540
jmp 0x3435
leaq 0x8e23e(%rip), %rdi     # 0x91640
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3435
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2540
movq -0x18(%rbp), %rsi
leaq 0x8e216(%rip), %rdi     # 0x91640
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x340b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/../lv_misc/lv_color.h
// Function: lv_color_mix
static inline lv_color_t lv_color_mix(lv_color_t c1, lv_color_t c2, uint8_t mix)
{
    lv_color_t ret;
#if LV_COLOR_DEPTH != 1
    /*LV_COLOR_DEPTH == 8, 16 or 32*/
    LV_COLOR_SET_R(ret, (uint16_t)((uint16_t) LV_COLOR_GET_R(c1) * mix + LV_COLOR_GET_R(c2) * (255 - mix)) >> 8);
    LV_COLOR_SET_G(ret, (uint16_t)((uint16_t) LV_COLOR_GET_G(c1) * mix + LV_COLOR_GET_G(c2) * (255 - mix)) >> 8);
    LV_COLOR_SET_B(ret, (uint16_t)((uint16_t) LV_COLOR_GET_B(c1) * mix + LV_COLOR_GET_B(c2) * (255 - mix)) >> 8);
    LV_COLOR_SET_A(ret, 0xFF);
#else
    /*LV_COLOR_DEPTH == 1*/
    ret.full = mix > LV_OPA_50 ? c1.full : c2.full;
#endif

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movb %al, -0x7(%rbp)
movw -0x4(%rbp), %ax
shrw $0xb, %ax
movzwl %ax, %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
movw -0x6(%rbp), %cx
shrw $0xb, %cx
movzwl %cx, %ecx
movzbl -0x7(%rbp), %esi
movl $0xff, %edx
subl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movzwl %ax, %eax
sarl $0x8, %eax
movzbl %al, %eax
andl $0x1f, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1f, %cx
shlw $0xb, %cx
andw $0x7ff, %ax             # imm = 0x7FF
orw %cx, %ax
movw %ax, -0x2(%rbp)
movw -0x4(%rbp), %ax
shrw $0x5, %ax
andw $0x3f, %ax
movzwl %ax, %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
movw -0x6(%rbp), %cx
shrw $0x5, %cx
andw $0x3f, %cx
movzwl %cx, %ecx
movzbl -0x7(%rbp), %esi
movl $0xff, %edx
subl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movzwl %ax, %eax
sarl $0x8, %eax
andl $0x3f, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x3f, %cx
shlw $0x5, %cx
andw $0xf81f, %ax            # imm = 0xF81F
orw %cx, %ax
movw %ax, -0x2(%rbp)
movw -0x4(%rbp), %ax
andw $0x1f, %ax
movzwl %ax, %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
movw -0x6(%rbp), %cx
andw $0x1f, %cx
movzwl %cx, %ecx
movzbl -0x7(%rbp), %esi
movl $0xff, %edx
subl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movzwl %ax, %eax
sarl $0x8, %eax
andl $0x1f, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1f, %cx
andw $-0x20, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
jmp 0x3a59
movw -0x2(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_indev.c
// Function: lv_indev_reset
void lv_indev_reset(lv_indev_t * indev)
{
    if(indev)
        indev->proc.reset_query = 1;
    else {
        lv_indev_t * i = lv_indev_get_next(NULL);
        while(i) {
            i->proc.reset_query = 1;

            i = lv_indev_get_next(i);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a95
movq -0x8(%rbp), %rax
movb 0x78(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x78(%rax)
jmp 0x3aca
xorl %eax, %eax
movl %eax, %edi
callq 0xded0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ac8
movq -0x10(%rbp), %rax
movb 0x78(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x78(%rax)
movq -0x10(%rbp), %rdi
callq 0xded0
movq %rax, -0x10(%rbp)
jmp 0x3aa2
jmp 0x3aca
addq $0x10, %rsp
popq %rbp
retq