LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_path_overshoot
lv_anim_value_t lv_anim_path_overshoot(const lv_anim_t * a)
{
    /*Calculate the current step*/

    uint32_t t;
    if(a->time == a->act_time)
        t = 1024;
    else
        t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;

    int32_t step = lv_bezier3(t, 0, 600, 1300, 1024);

    int32_t new_value;
    new_value = (int32_t)step * (a->end - a->start);
    new_value = new_value >> 10;
    new_value += a->start;

    return (lv_anim_value_t)new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x2a(%rcx), %ecx
cmpl %ecx, %eax
jne 0x448f9
movl $0x400, -0xc(%rbp)      # imm = 0x400
jmp 0x44913
movq -0x8(%rbp), %rax
movswl 0x2a(%rax), %eax
shll $0xa, %eax
movq -0x8(%rbp), %rcx
movzwl 0x28(%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
movl $0x514, %ecx            # imm = 0x514
movl $0x400, %r8d            # imm = 0x400
callq 0x47330
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x20(%rdx), %ecx
imull %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0xa, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: lv_mem_init
void lv_mem_init(void)
{
#if LV_MEM_CUSTOM == 0

#if LV_MEM_ADR == 0
    /*Allocate a large array to store the dynamically allocated data*/
    static LV_MEM_ATTR MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)];
    work_mem = (uint8_t *)work_mem_int;
#else
    work_mem = (uint8_t *)LV_MEM_ADR;
#endif

    lv_mem_ent_t * full = (lv_mem_ent_t *)work_mem;
    full->header.s.used = 0;
    /*The total mem size id reduced by the first header and the close patterns */
    full->header.s.d_size = LV_MEM_SIZE - sizeof(lv_mem_header_t);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x448b5(%rip), %rax     # 0x895a0
movq %rax, 0x4c8ae(%rip)     # 0x915a0
movq 0x4c8a7(%rip), %rax     # 0x915a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0x1, %ecx
orl $0xfff8, %ecx           # imm = 0xFFF8
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: ent_get_next
static lv_mem_ent_t * ent_get_next(lv_mem_ent_t * act_e)
{
    lv_mem_ent_t * next_e = NULL;

    if(act_e == NULL) { /*NULL means: get the first entry*/
        next_e = (lv_mem_ent_t *)work_mem;
    } else { /*Get the next entry */
        uint8_t * data = &act_e->first_data;
        next_e         = (lv_mem_ent_t *)&data[act_e->header.s.d_size];

        if(&next_e->first_data >= &work_mem[LV_MEM_SIZE]) next_e = NULL;
    }

    return next_e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x44e04
movq 0x4c7a2(%rip), %rax     # 0x915a0
movq %rax, -0x10(%rbp)
jmp 0x44e4a
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shrl %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq 0x4c76c(%rip), %rcx     # 0x915a0
addq $0x8000, %rcx           # imm = 0x8000
cmpq %rcx, %rax
jb 0x44e48
movq $0x0, -0x10(%rbp)
jmp 0x44e4a
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: ent_alloc
static void * ent_alloc(lv_mem_ent_t * e, size_t size)
{
    void * alloc = NULL;

    /*If the memory is free and big enough then use it */
    if(e->header.s.used == 0 && e->header.s.d_size >= size) {
        /*Truncate the entry to the desired size */
        ent_trunc(e, size),

            e->header.s.used = 1;

        /*Save the allocated data*/
        alloc = &e->first_data;
    }

    return alloc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44ead
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
cmpq -0x10(%rbp), %rax
jb 0x44ead
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x450e0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%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_misc/lv_mem.c
// Function: lv_mem_free
void lv_mem_free(const void * data)
{
    if(data == &zero_mem) return;
    if(data == NULL) return;

#if LV_MEM_ADD_JUNK
    memset((void *)data, 0xbb, lv_mem_get_size(data));
#endif

#if LV_ENABLE_GC == 0
    /*e points to the header*/
    lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *)data - sizeof(lv_mem_header_t));
    e->header.s.used = 0;
#endif

#if LV_MEM_CUSTOM == 0
#if LV_MEM_AUTO_DEFRAG
    /* Make a simple defrag.
     * Join the following free entries after this*/
    lv_mem_ent_t * e_next;
    e_next = ent_get_next(e);
    while(e_next != NULL) {
        if(e_next->header.s.used == 0) {
            e->header.s.d_size += e_next->header.s.d_size + sizeof(e->header);
        } else {
            break;
        }
        e_next = ent_get_next(e_next);
    }
#endif
#else /*Use custom, user defined free function*/
#if LV_ENABLE_GC == 0
    LV_MEM_CUSTOM_FREE(e);
#else
    LV_MEM_CUSTOM_FREE((void *)data);
#endif /*LV_ENABLE_GC*/
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4c6d5(%rip), %rax     # 0x915a8
cmpq %rax, -0x8(%rbp)
jne 0x44ede
jmp 0x44f66
cmpq $0x0, -0x8(%rbp)
jne 0x44ee7
jmp 0x44f66
movq -0x8(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x44de0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x44f66
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44f55
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
movl %eax, %edx
addq $0x4, %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl %ecx
movl %ecx, %ecx
addq %rdx, %rcx
movl %ecx, %edx
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
shll %edx
andl $0x1, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x44f57
jmp 0x44f66
movq -0x18(%rbp), %rdi
callq 0x44de0
movq %rax, -0x18(%rbp)
jmp 0x44f0e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: lv_mem_realloc
void * lv_mem_realloc(void * data_p, size_t new_size)
{
    /*data_p could be previously freed pointer (in this case it is invalid)*/
    if(data_p != NULL) {
        lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *)data_p - sizeof(lv_mem_header_t));
        if(e->header.s.used == 0) {
            data_p = NULL;
        }
    }

    uint32_t old_size = lv_mem_get_size(data_p);
    if(old_size == new_size) return data_p; /*Also avoid reallocating the same memory*/

#if LV_MEM_CUSTOM == 0
    /* Truncate the memory if the new size is smaller. */
    if(new_size < old_size) {
        lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *)data_p - sizeof(lv_mem_header_t));
        ent_trunc(e, new_size);
        return &e->first_data;
    }
#endif

    void * new_p;
    new_p = lv_mem_alloc(new_size);

    if(new_p != NULL && data_p != NULL) {
        /*Copy the old data to the new. Use the smaller size*/
        if(old_size != 0) {
            memcpy(new_p, data_p, LV_MATH_MIN(new_size, old_size));
            lv_mem_free(data_p);
        }
    }

    if(new_p == NULL) LV_LOG_WARN("Couldn't allocate memory");

    return new_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x44fab
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x44fa9
movq $0x0, -0x10(%rbp)
jmp 0x44fab
movq -0x10(%rbp), %rdi
callq 0x45090
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x18(%rbp), %rax
jne 0x44fcd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4507b
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpq %rcx, %rax
jae 0x45000
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x450e0
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x4507b
movq -0x18(%rbp), %rdi
callq 0x44d20
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4506a
cmpq $0x0, -0x10(%rbp)
je 0x4506a
cmpl $0x0, -0x24(%rbp)
je 0x45068
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpq %rcx, %rax
jae 0x45047
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4504e
movl -0x24(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
callq 0x20e0
movq -0x10(%rbp), %rdi
callq 0x44ec0
jmp 0x4506a
cmpq $0x0, -0x38(%rbp)
jne 0x45073
jmp 0x45073
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: lv_mem_get_size
uint32_t lv_mem_get_size(const void * data)
{
    if(data == NULL) return 0;
    if(data == &zero_mem) return 0;

    lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *)data - sizeof(lv_mem_header_t));

    return e->header.s.d_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x450a8
movl $0x0, -0x4(%rbp)
jmp 0x450d5
leaq 0x4c4f9(%rip), %rax     # 0x915a8
cmpq %rax, -0x10(%rbp)
jne 0x450be
movl $0x0, -0x4(%rbp)
jmp 0x450d5
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: ent_trunc
static void ent_trunc(lv_mem_ent_t * e, size_t size)
{
#ifdef LV_MEM_ENV64
    /*Round the size up to 8*/
    if(size & 0x7) {
        size = size & (~0x7);
        size += 8;
    }
#else
    /*Round the size up to 4*/
    if(size & 0x3) {
        size = size & (~0x3);
        size += 4;
    }
#endif

    /*Don't let empty space only for a header without data*/
    if(e->header.s.d_size == size + sizeof(lv_mem_header_t)) {
        size = e->header.s.d_size;
    }

    /* Create the new entry after the current if there is space for it */
    if(e->header.s.d_size != size) {
        uint8_t * e_data             = &e->first_data;
        lv_mem_ent_t * after_new_e   = (lv_mem_ent_t *)&e_data[size];
        after_new_e->header.s.used   = 0;
        after_new_e->header.s.d_size = e->header.s.d_size - size - sizeof(lv_mem_header_t);
    }

    /* Set the new size for the original entry */
    e->header.s.d_size = size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x45112
movq -0x10(%rbp), %rax
andq $-0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x45137
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x45196
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
subq -0x10(%rbp), %rax
subq $0x4, %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
shll %edx
andl $0x1, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
shll %edx
andl $0x1, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: lv_mem_defrag
void lv_mem_defrag(void)
{
#if LV_MEM_CUSTOM == 0
    lv_mem_ent_t * e_free;
    lv_mem_ent_t * e_next;
    e_free = ent_get_next(NULL);

    while(1) {
        /*Search the next free entry*/
        while(e_free != NULL) {
            if(e_free->header.s.used != 0) {
                e_free = ent_get_next(e_free);
            } else {
                break;
            }
        }

        if(e_free == NULL) return;

        /*Joint the following free entries to the free*/
        e_next = ent_get_next(e_free);
        while(e_next != NULL) {
            if(e_next->header.s.used == 0) {
                e_free->header.s.d_size += e_next->header.s.d_size + sizeof(e_next->header);
            } else {
                break;
            }

            e_next = ent_get_next(e_next);
        }

        if(e_next == NULL) return;

        /*Continue from the lastly checked entry*/
        e_free = e_next;
    }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x44de0
movq %rax, -0x8(%rbp)
jmp 0x451d7
cmpq $0x0, -0x8(%rbp)
je 0x451ff
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x451fb
movq -0x8(%rbp), %rdi
callq 0x44de0
movq %rax, -0x8(%rbp)
jmp 0x451fd
jmp 0x451ff
jmp 0x451d7
cmpq $0x0, -0x8(%rbp)
jne 0x45208
jmp 0x45283
movq -0x8(%rbp), %rdi
callq 0x44de0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4526d
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4525c
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl %eax, %eax
movl %eax, %edx
addq $0x4, %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl %ecx
movl %ecx, %ecx
addq %rdx, %rcx
movl %ecx, %edx
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
shll %edx
andl $0x1, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x4525e
jmp 0x4526d
movq -0x10(%rbp), %rdi
callq 0x44de0
movq %rax, -0x10(%rbp)
jmp 0x45215
cmpq $0x0, -0x10(%rbp)
jne 0x45276
jmp 0x45283
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x451d5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_mem.c
// Function: lv_mem_monitor
void lv_mem_monitor(lv_mem_monitor_t * mon_p)
{
    /*Init the data*/
    memset(mon_p, 0, sizeof(lv_mem_monitor_t));
#if LV_MEM_CUSTOM == 0
    lv_mem_ent_t * e;
    e = NULL;

    e = ent_get_next(e);

    while(e != NULL) {
        if(e->header.s.used == 0) {
            mon_p->free_cnt++;
            mon_p->free_size += e->header.s.d_size;
            if(e->header.s.d_size > mon_p->free_biggest_size) {
                mon_p->free_biggest_size = e->header.s.d_size;
            }
        } else {
            mon_p->used_cnt++;
        }

        e = ent_get_next(e);
    }
    mon_p->total_size = LV_MEM_SIZE;
    mon_p->used_pct   = 100 - (100U * mon_p->free_size) / mon_p->total_size;
    mon_p->frag_pct   = (uint32_t)mon_p->free_biggest_size * 100U / mon_p->free_size;
    mon_p->frag_pct   = 100 - mon_p->frag_pct;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2090
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44de0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45333
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x45317
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x45315
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x45324
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x44de0
movq %rax, -0x10(%rbp)
jmp 0x452c1
movq -0x8(%rbp), %rax
movl $0x8000, (%rax)         # imm = 0x8000
movq -0x8(%rbp), %rax
imull $0x64, 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %eax, %ecx
movl $0x64, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x8(%rbp), %rax
imull $0x64, 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x15(%rax)
movq -0x8(%rbp), %rax
movzbl 0x15(%rax), %ecx
movl $0x64, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x15(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_init
void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
{
    ll_p->head = NULL;
    ll_p->tail = NULL;
#ifdef LV_MEM_ENV64
    /*Round the size up to 8*/
    if(node_size & 0x7) {
        node_size = node_size & (~0x7);
        node_size += 8;
    }
#else
    /*Round the size up to 4*/
    if(node_size & 0x3) {
        node_size = node_size & (~0x3);
        node_size += 4;
    }
#endif

    ll_p->n_size = node_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x453e0
movl -0xc(%rbp), %eax
andl $-0x4, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_ins_head
void * lv_ll_ins_head(lv_ll_t * ll_p)
{
    lv_ll_node_t * n_new;

    n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);

    if(n_new != NULL) {
        node_set_prev(ll_p, n_new, NULL);       /*No prev. before the new head*/
        node_set_next(ll_p, n_new, ll_p->head); /*After new comes the old head*/

        if(ll_p->head != NULL) { /*If there is old head then before it goes the new*/
            node_set_prev(ll_p, ll_p->head, n_new);
        }

        ll_p->head = n_new;      /*Set the new head in the dsc.*/
        if(ll_p->tail == NULL) { /*If there is no tail (1. node) set the tail too*/
            ll_p->tail = n_new;
        }
    }

    return n_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
addq $0x10, %rdi
callq 0x44d20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45483
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45490
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x45500
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4545e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x45490
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x45481
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x45483
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: node_set_prev
static void node_set_prev(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * prev)
{
    if(act == NULL) return; /*Can't set the prev node of `NULL`*/

    uint32_t node_p_size = sizeof(lv_ll_node_t *);
    if(prev)
        memcpy(act + LL_PREV_P_OFFSET(ll_p), &prev, node_p_size);
    else
        memset(act + LL_PREV_P_OFFSET(ll_p), 0, node_p_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x454ad
jmp 0x454f1
movl $0x8, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x454d8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq -0x18(%rbp), %rsi
callq 0x20e0
jmp 0x454f1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: node_set_next
static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * next)
{
    if(act == NULL) return; /*Can't set the next node of `NULL`*/

    uint32_t node_p_size = sizeof(lv_ll_node_t *);
    if(next)
        memcpy(act + LL_NEXT_P_OFFSET(ll_p), &next, node_p_size);
    else
        memset(act + LL_NEXT_P_OFFSET(ll_p), 0, node_p_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4551d
jmp 0x45569
movl $0x8, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4554c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq $0x8, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq -0x18(%rbp), %rsi
callq 0x20e0
jmp 0x45569
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq $0x8, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_ins_prev
void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
{
    lv_ll_node_t * n_new;
    lv_ll_node_t * n_prev;

    if(NULL == ll_p || NULL == n_act) return NULL;

    if(lv_ll_get_head(ll_p) == n_act) {
        n_new = lv_ll_ins_head(ll_p);
        if(n_new == NULL) return NULL;
    } else {
        n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
        if(n_new == NULL) return NULL;

        n_prev = lv_ll_get_prev(ll_p, n_act);
        node_set_next(ll_p, n_prev, n_new);
        node_set_prev(ll_p, n_new, n_prev);
        node_set_prev(ll_p, n_act, n_new);
        node_set_next(ll_p, n_new, n_act);
    }

    return n_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x45590
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x4559d
movq $0x0, -0x8(%rbp)
jmp 0x45652
movq -0x10(%rbp), %rdi
callq 0x45660
cmpq -0x18(%rbp), %rax
jne 0x455cf
movq -0x10(%rbp), %rdi
callq 0x453f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x455cd
movq $0x0, -0x8(%rbp)
jmp 0x45652
jmp 0x4564a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
addq $0x10, %rdi
callq 0x44d20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x455f5
movq $0x0, -0x8(%rbp)
jmp 0x45652
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45690
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x45500
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x45490
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x45490
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45500
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/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_get_head
void * lv_ll_get_head(const lv_ll_t * ll_p)
{
    void * head = NULL;

    if(ll_p != NULL) {
        head = ll_p->head;
    }

    return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x45683
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_get_prev
void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
{
    void * prev = NULL;

    if(ll_p != NULL) {
        const lv_ll_node_t * n_act_d = n_act;
        memcpy(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *));
    }

    return prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x456c5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_ins_tail
void * lv_ll_ins_tail(lv_ll_t * ll_p)
{
    lv_ll_node_t * n_new;

    n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
    if(n_new == NULL) return NULL;

    if(n_new != NULL) {
        node_set_next(ll_p, n_new, NULL);       /*No next after the new tail*/
        node_set_prev(ll_p, n_new, ll_p->tail); /*The prev. before new is tho old tail*/
        if(ll_p->tail != NULL) {                /*If there is old tail then the new comes after it*/
            node_set_next(ll_p, ll_p->tail, n_new);
        }

        ll_p->tail = n_new;      /*Set the new tail in the dsc.*/
        if(ll_p->head == NULL) { /*If there is no head (1. node) set the head too*/
            ll_p->head = n_new;
        }
    }

    return n_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
addq $0x10, %rdi
callq 0x44d20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x45702
movq $0x0, -0x8(%rbp)
jmp 0x4577c
cmpq $0x0, -0x18(%rbp)
je 0x45774
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45500
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x45490
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4574f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x45500
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x45772
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x45774
movq -0x18(%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/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_rem
void lv_ll_rem(lv_ll_t * ll_p, void * node_p)
{
    if(lv_ll_get_head(ll_p) == node_p) {
        /*The new head will be the node after 'n_act'*/
        ll_p->head = lv_ll_get_next(ll_p, node_p);
        if(ll_p->head == NULL) {
            ll_p->tail = NULL;
        } else {
            node_set_prev(ll_p, ll_p->head, NULL);
        }
    } else if(lv_ll_get_tail(ll_p) == node_p) {
        /*The new tail will be the  node before 'n_act'*/
        ll_p->tail = lv_ll_get_prev(ll_p, node_p);
        if(ll_p->tail == NULL) {
            ll_p->head = NULL;
        } else {
            node_set_next(ll_p, ll_p->tail, NULL);
        }
    } else {
        lv_ll_node_t * n_prev = lv_ll_get_prev(ll_p, node_p);
        lv_ll_node_t * n_next = lv_ll_get_next(ll_p, node_p);

        node_set_next(ll_p, n_prev, n_next);
        node_set_prev(ll_p, n_next, n_prev);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45660
cmpq -0x10(%rbp), %rax
jne 0x457fa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x457e0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x457f5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45490
jmp 0x45897
movq -0x8(%rbp), %rdi
callq 0x458e0
cmpq -0x10(%rbp), %rax
jne 0x45851
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45690
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4583a
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x4584f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45500
jmp 0x45895
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45690
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x45500
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45490
jmp 0x45897
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_get_next
void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
{
    void * next = NULL;

    if(ll_p != NULL) {
        const lv_ll_node_t * n_act_d = n_act;
        memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *));
    }

    return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x458d6
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq 0x8(%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_get_tail
void * lv_ll_get_tail(const lv_ll_t * ll_p)
{
    void * tail = NULL;

    if(ll_p != NULL) {
        tail = ll_p->tail;
    }

    return tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x45903
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_clear
void lv_ll_clear(lv_ll_t * ll_p)
{
    void * i;
    void * i_next;

    i      = lv_ll_get_head(ll_p);
    i_next = NULL;

    while(i != NULL) {
        i_next = lv_ll_get_next(ll_p, i);

        lv_ll_rem(ll_p, i);
        lv_mem_free(i);

        i = i_next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45660
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45969
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45790
movq -0x10(%rbp), %rdi
callq 0x44ec0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x45931
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_chg_list
void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head)
{
    lv_ll_rem(ll_ori_p, node);

    if(head) {
        /*Set node as head*/
        node_set_prev(ll_new_p, node, NULL);
        node_set_next(ll_new_p, node, ll_new_p->head);

        if(ll_new_p->head != NULL) { /*If there is old head then before it goes the new*/
            node_set_prev(ll_new_p, ll_new_p->head, node);
        }

        ll_new_p->head = node;       /*Set the new head in the dsc.*/
        if(ll_new_p->tail == NULL) { /*If there is no tail (first node) set the tail too*/
            ll_new_p->tail = node;
        }
    } else {
        /*Set node as tail*/
        node_set_prev(ll_new_p, node, ll_new_p->tail);
        node_set_next(ll_new_p, node, NULL);

        if(ll_new_p->tail != NULL) { /*If there is old tail then after it goes the new*/
            node_set_next(ll_new_p, ll_new_p->tail, node);
        }

        ll_new_p->tail = node;       /*Set the new tail in the dsc.*/
        if(ll_new_p->head == NULL) { /*If there is no head (first node) set the head too*/
            ll_new_p->head = node;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45790
testb $0x1, -0x19(%rbp)
je 0x45a09
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45490
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x45500
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x459e4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x45490
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x45a07
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x45a74
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x45490
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x45500
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x45a4f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x45500
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x45a72
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x45a74
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_get_len
uint32_t lv_ll_get_len(const lv_ll_t * ll_p)
{
    uint32_t len = 0;
    void * node;

    for(node = lv_ll_get_head(ll_p); node != NULL; node = lv_ll_get_next(ll_p, node)) {
        len++;
    }

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x45ac3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x45aa0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_ll.c
// Function: lv_ll_move_before
void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after)
{
    if(n_act == n_after) return; /*Can't move before itself*/

    void * n_before;
    if(n_after != NULL)
        n_before = lv_ll_get_prev(ll_p, n_after);
    else
        n_before = lv_ll_get_tail(ll_p); /*if `n_after` is NULL `n_act` should be the new tail*/

    if(n_act == n_before) return; /*Already before `n_after`*/

    /*It's much easier to remove from the list and add again*/
    lv_ll_rem(ll_p, n_act);

    /*Add again by setting the prev. and next nodes*/
    node_set_next(ll_p, n_before, n_act);
    node_set_prev(ll_p, n_act, n_before);
    node_set_prev(ll_p, n_after, n_act);
    node_set_next(ll_p, n_act, n_after);

    /*If `n_act` was moved before NULL then it become the new tail*/
    if(n_after == NULL) ll_p->tail = n_act;

    /*If `n_act` was moved before `NULL` then it's the new head*/
    if(n_before == NULL) ll_p->head = n_act;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x45af3
jmp 0x45b9d
cmpq $0x0, -0x18(%rbp)
je 0x45b0d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45690
movq %rax, -0x20(%rbp)
jmp 0x45b1a
movq -0x8(%rbp), %rdi
callq 0x458e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x45b26
jmp 0x45b9d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45790
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x45500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x45490
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x45490
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45500
cmpq $0x0, -0x18(%rbp)
jne 0x45b8a
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x45b9d
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_size
static uint8_t lv_txt_utf8_size(const char * str)
{
    if((str[0] & 0x80) == 0)
        return 1;
    else if((str[0] & 0xE0) == 0xC0)
        return 2;
    else if((str[0] & 0xF0) == 0xE0)
        return 3;
    else if((str[0] & 0xF8) == 0xF0)
        return 4;
    return 0; /*If the char was invalid tell it's 1 byte long*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x4615f
movb $0x1, -0x1(%rbp)
jmp 0x461b4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x46178
movb $0x2, -0x1(%rbp)
jmp 0x461b4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x46191
movb $0x3, -0x1(%rbp)
jmp 0x461b4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x461aa
movb $0x4, -0x1(%rbp)
jmp 0x461b4
jmp 0x461ac
jmp 0x461ae
jmp 0x461b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_unicode_to_utf8
static uint32_t lv_txt_unicode_to_utf8(uint32_t letter_uni)
{
    if(letter_uni < 128) return letter_uni;
    uint8_t bytes[4];

    if(letter_uni < 0x0800) {
        bytes[0] = ((letter_uni >> 6) & 0x1F) | 0xC0;
        bytes[1] = ((letter_uni >> 0) & 0x3F) | 0x80;
        bytes[2] = 0;
        bytes[3] = 0;
    } else if(letter_uni < 0x010000) {
        bytes[0] = ((letter_uni >> 12) & 0x0F) | 0xE0;
        bytes[1] = ((letter_uni >> 6) & 0x3F) | 0x80;
        bytes[2] = ((letter_uni >> 0) & 0x3F) | 0x80;
        bytes[3] = 0;
    } else if(letter_uni < 0x110000) {
        bytes[0] = ((letter_uni >> 18) & 0x07) | 0xF0;
        bytes[1] = ((letter_uni >> 12) & 0x3F) | 0x80;
        bytes[2] = ((letter_uni >> 6) & 0x3F) | 0x80;
        bytes[3] = ((letter_uni >> 0) & 0x3F) | 0x80;
    }

    uint32_t * res_p = (uint32_t *)bytes;
    return *res_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0x461db
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x462b7
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0x46213
movl -0x8(%rbp), %eax
shrl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
movb %al, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0xb(%rbp)
movb $0x0, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
jmp 0x462a6
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0x46255
movl -0x8(%rbp), %eax
shrl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movb %al, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0xb(%rbp)
movl -0x8(%rbp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
jmp 0x462a4
cmpl $0x110000, -0x8(%rbp)   # imm = 0x110000
jae 0x462a2
movl -0x8(%rbp), %eax
shrl $0x12, %eax
andl $0x7, %eax
orl $0xf0, %eax
movb %al, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0xb(%rbp)
movl -0x8(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x9(%rbp)
jmp 0x462a4
jmp 0x462a6
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_conv_wc
static uint32_t lv_txt_utf8_conv_wc(uint32_t c)
{
    /*Swap the bytes (UTF-8 is big endian, but the MCUs are little endian)*/
    if((c & 0x80) != 0) {
        uint32_t swapped;
        uint8_t c8[4];
        memcpy(c8, &c, 4);
        swapped = (c8[0] << 24) + (c8[1] << 16) + (c8[2] << 8) + (c8[3]);
        uint8_t i;
        for(i = 0; i < 4; i++) {
            if((swapped & 0xFF) == 0)
                swapped = (swapped >> 8); /*Ignore leading zeros (they were in the end originally)*/
        }
        c = swapped;
    }

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x46331
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movzbl -0xc(%rbp), %eax
shll $0x18, %eax
movzbl -0xb(%rbp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movzbl -0xa(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movb $0x0, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x4, %eax
jge 0x4632b
movl -0x8(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x4631f
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
jmp 0x46321
movb -0xd(%rbp), %al
addb $0x1, %al
movb %al, -0xd(%rbp)
jmp 0x46300
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_prev
static uint32_t lv_txt_utf8_prev(const char * txt, uint32_t * i)
{
    uint8_t c_size;
    uint8_t cnt = 0;

    /*Try to find a !0 long UTF-8 char by stepping one character back*/
    (*i)--;
    do {
        if(cnt >= 4) return 0; /*No UTF-8 char found before the initial*/

        c_size = lv_txt_encoded_size(&txt[*i]);
        if(c_size == 0) {
            if(*i != 0)
                (*i)--;
            else
                return 0;
        }
        cnt++;
    } while(c_size == 0);

    uint32_t i_tmp  = *i;
    uint32_t letter = lv_txt_encoded_next(txt, &i_tmp); /*Character found, get it*/

    return letter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movzbl -0x1a(%rbp), %eax
cmpl $0x4, %eax
jl 0x46671
movl $0x0, -0x4(%rbp)
jmp 0x466e8
movq 0x36030(%rip), %rax     # 0x7c6a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rdi
callq *%rax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x466b4
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x466a9
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x466b2
movl $0x0, -0x4(%rbp)
jmp 0x466e8
jmp 0x466b4
movb -0x1a(%rbp), %al
addb $0x1, %al
movb %al, -0x1a(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x4665f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x35feb(%rip), %rax     # 0x7c6c0
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
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/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_get_byte_id
static uint32_t lv_txt_utf8_get_byte_id(const char * txt, uint32_t utf8_id)
{
    uint32_t i;
    uint32_t byte_cnt = 0;
    for(i = 0; i < utf8_id; i++) {
        uint8_t c_size = lv_txt_encoded_size(&txt[byte_cnt]);
        byte_cnt += c_size > 0 ? c_size : 1;
    }

    return byte_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x4676b
movq 0x35f7c(%rip), %rax     # 0x7c6a8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
addq %rcx, %rdi
callq *%rax
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jle 0x4674d
movzbl -0x15(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x46757
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46757
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4671d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_get_char_id
static uint32_t lv_txt_utf8_get_char_id(const char * txt, uint32_t byte_id)
{
    uint32_t i        = 0;
    uint32_t char_cnt = 0;

    while(i < byte_id) {
        lv_txt_encoded_next(txt, &i); /*'i' points to the next letter so use the prev. value*/
        char_cnt++;
    }

    return char_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x467c1
movq 0x35f14(%rip), %rax     # 0x7c6c0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq *%rax
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4679d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_utf8_get_length
static uint32_t lv_txt_utf8_get_length(const char * txt)
{
    uint32_t len = 0;
    uint32_t i   = 0;

    while(txt[i] != '\0') {
        lv_txt_encoded_next(txt, &i);
        len++;
    }

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x46816
movq 0x35ebf(%rip), %rax     # 0x7c6c0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x467ea
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop