LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_area.c
// Function: lv_area_join
void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
{
    a_res_p->x1 = LV_MATH_MIN(a1_p->x1, a2_p->x1);
    a_res_p->y1 = LV_MATH_MIN(a1_p->y1, a2_p->y1);
    a_res_p->x2 = LV_MATH_MAX(a1_p->x2, a2_p->x2);
    a_res_p->y2 = LV_MATH_MAX(a1_p->y2, a2_p->y2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x18(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4292e
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x42938
movq -0x18(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x42966
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x42971
movq -0x18(%rbp), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jle 0x429a0
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x429ab
movq -0x18(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jle 0x429da
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x429e5
movq -0x18(%rbp), %rax
movswl 0x6(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_area.c
// Function: lv_area_is_point_on
bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p)
{
    bool is_on = false;

    if((p_p->x >= a_p->x1 && p_p->x <= a_p->x2) && ((p_p->y >= a_p->y1 && p_p->y <= a_p->y2))) {
        is_on = true;
    }

    return is_on;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x8(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x42a61
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jg 0x42a61
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jl 0x42a61
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jg 0x42a61
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_area.c
// Function: lv_area_is_in
bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p)
{
    bool is_in = false;

    if(ain_p->x1 >= aholder_p->x1 && ain_p->y1 >= aholder_p->y1 && ain_p->x2 <= aholder_p->x2 &&
       ain_p->y2 <= aholder_p->y2) {
        is_in = true;
    }

    return is_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x42b42
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jl 0x42b42
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jg 0x42b42
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jg 0x42b42
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_area.c
// Function: lv_area_increment
void lv_area_increment(lv_area_t * a_p, const lv_coord_t amount)
{
    a_p->x1 -= amount;
    a_p->y1 -= amount;
    a_p->x2 += amount;
    a_p->y2 += amount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movswl (%rax), %ecx
subl %edx, %ecx
movw %cx, (%rax)
movswl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %ecx
subl %edx, %ecx
movw %cx, 0x2(%rax)
movswl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x4(%rax)
movswl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_task.c
// Function: lv_task_exec
static bool lv_task_exec(lv_task_t * task)
{
    bool exec = false;

    /*Execute if at least 'period' time elapsed*/
    uint32_t elp = lv_tick_elaps(task->last_run);
    if(elp >= task->period) {
        task->last_run = lv_tick_get();
        task_deleted   = false;
        task_created   = false;
        if(task->task_cb) task->task_cb(task);

        /*Delete if it was a one shot lv_task*/
        if(task_deleted == false) { /*The task might be deleted by itself as well*/
            if(task->once != 0) {
                lv_task_del(task);
            }
        }
        exec = true;
    }

    return exec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xe010
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x42f22
callq 0xdfe0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x0, 0x466ba(%rip)     # 0x89589
movb $0x0, 0x466b4(%rip)     # 0x8958a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42eef
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movb 0x46694(%rip), %al      # 0x89589
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42f1e
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x42f1c
movq -0x8(%rbp), %rdi
callq 0x43280
jmp 0x42f1e
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_task.c
// Function: lv_task_create
lv_task_t * lv_task_create(lv_task_cb_t task_cb, uint32_t period, lv_task_prio_t prio, void * user_data)
{
    lv_task_t * new_task = lv_task_create_basic();
    LV_ASSERT_MEM(new_task);
    if(new_task == NULL) return NULL;

    lv_task_set_cb(new_task, task_cb);
    lv_task_set_period(new_task, period);
    lv_task_set_prio(new_task, prio);
    new_task->user_data = user_data;

    return new_task;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x42f30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x43110
movq -0x28(%rbp), %rsi
leaq 0x24f3b(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x4310e
cmpq $0x0, -0x28(%rbp)
jne 0x43121
movq $0x0, -0x8(%rbp)
jmp 0x4315b
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43170
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43190
movq -0x28(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x431b0
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/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_task.c
// Function: lv_task_set_prio
void lv_task_set_prio(lv_task_t * task, lv_task_prio_t prio)
{
    if(task->prio == prio) return;

    /*Find the tasks with new priority*/
    lv_task_t * i;
    LV_LL_READ(LV_GC_ROOT(_lv_task_ll), i)
    {
        if(i->prio <= prio) {
            if(i != task) lv_ll_move_before(&LV_GC_ROOT(_lv_task_ll), task, i);
            break;
        }
    }

    /*There was no such a low priority so far then add the node to the tail*/
    if(i == NULL) {
        lv_ll_move_before(&LV_GC_ROOT(_lv_task_ll), task, NULL);
    }

    task->prio = prio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
andb $0x7, %al
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x431db
jmp 0x4326e
leaq 0x4e3ce(%rip), %rdi     # 0x915b0
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4323e
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
andb $0x7, %al
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jg 0x43226
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x43224
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x4e391(%rip), %rdi     # 0x915b0
callq 0x45ad0
jmp 0x4323e
jmp 0x43228
movq -0x18(%rbp), %rsi
leaq 0x4e37d(%rip), %rdi     # 0x915b0
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x431eb
cmpq $0x0, -0x18(%rbp)
jne 0x43259
movq -0x8(%rbp), %rsi
leaq 0x4e360(%rip), %rdi     # 0x915b0
xorl %eax, %eax
movl %eax, %edx
callq 0x45ad0
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movb 0x18(%rax), %cl
andb $0x7, %dl
andb $-0x8, %cl
orb %dl, %cl
movb %cl, 0x18(%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_fs.c
// Function: lv_fs_is_ready
bool lv_fs_is_ready(char letter)
{
    lv_fs_drv_t * drv = lv_fs_get_drv(letter);

    if(drv == NULL) return false; /*An unknown driver in not ready*/

    if(drv->ready_cb == NULL) return true; /*Assume the driver is always ready if no handler provided*/

    return drv->ready_cb(drv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %edi
callq 0x433d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x43398
movb $0x0, -0x1(%rbp)
jmp 0x433bc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x433a9
movb $0x1, -0x1(%rbp)
jmp 0x433bc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_fs.c
// Function: lv_fs_get_drv
lv_fs_drv_t * lv_fs_get_drv(char letter)
{
    lv_fs_drv_t * drv;

    LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv)
    {
        if(drv->letter == letter) {
            return drv;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
leaq 0x4e213(%rip), %rdi     # 0x915f8
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x43426
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4340e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4342e
jmp 0x43410
movq -0x18(%rbp), %rsi
leaq 0x4e1dd(%rip), %rdi     # 0x915f8
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0x433ee
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_get_real_path
static const char * lv_fs_get_real_path(const char * path)
{
    /* Example path: "S:/folder/file.txt"
     * Leave the letter and the : / \ characters*/

    path++; /*Ignore the driver letter*/

    while(*path != '\0') {
        if(*path == ':' || *path == '\\' || *path == '/') {
            path++;
        } else {
            break;
        }
    }

    return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x43646
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x43634
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x43634
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x43642
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x43644
jmp 0x43646
jmp 0x43604
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_close
lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
{
    if(file_p->drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->close_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = file_p->drv->close_cb(file_p->drv, file_p->file_d);

    lv_mem_free(file_p->file_d); /*Clean up*/
    file_p->file_d = NULL;
    file_p->drv    = NULL;
    file_p->file_d = NULL;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4366d
movb $0xb, -0x1(%rbp)
jmp 0x436d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x43682
movb $0x9, -0x1(%rbp)
jmp 0x436d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x44ec0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_remove
lv_fs_res_t lv_fs_remove(const char * path)
{
    if(path == NULL) return LV_FS_RES_INV_PARAM;
    lv_fs_drv_t * drv = NULL;

    char letter = path[0];

    drv = lv_fs_get_drv(letter);
    if(drv == NULL) return LV_FS_RES_NOT_EX;
    if(drv->ready_cb != NULL) {
        if(drv->ready_cb(drv) == false) return LV_FS_RES_HW_ERR;
    }

    if(drv->remove_cb == NULL) return LV_FS_RES_NOT_IMP;

    const char * real_path = lv_fs_get_real_path(path);
    lv_fs_res_t res        = drv->remove_cb(drv, real_path);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x436fc
movb $0xb, -0x1(%rbp)
jmp 0x4378b
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %edi
callq 0x433d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x43727
movb $0x3, -0x1(%rbp)
jmp 0x4378b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x43752
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x43750
movb $0x1, -0x1(%rbp)
jmp 0x4378b
jmp 0x43752
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x43763
movb $0x9, -0x1(%rbp)
jmp 0x4378b
movq -0x10(%rbp), %rdi
callq 0x435f0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_fs.c
// Function: lv_fs_read
lv_fs_res_t lv_fs_read(lv_fs_file_t * file_p, void * buf, uint32_t btr, uint32_t * br)
{
    if(br != NULL) *br = 0;
    if(file_p->drv == NULL) return LV_FS_RES_INV_PARAM;
    if(file_p->drv->read_cb == NULL) return LV_FS_RES_NOT_IMP;

    uint32_t br_tmp = 0;
    lv_fs_res_t res = file_p->drv->read_cb(file_p->drv, file_p->file_d, buf, btr, &br_tmp);
    if(br != NULL) *br = br_tmp;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x437c8
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x437d9
movb $0xb, -0x1(%rbp)
jmp 0x43836
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x437ee
movb $0x9, -0x1(%rbp)
jmp 0x43836
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x2c(%rbp), %r8
callq *%rax
movb %al, -0x2d(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x43830
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb -0x2d(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_write
lv_fs_res_t lv_fs_write(lv_fs_file_t * file_p, const void * buf, uint32_t btw, uint32_t * bw)
{
    if(bw != NULL) *bw = 0;

    if(file_p->drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->write_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    uint32_t bw_tmp = 0;
    lv_fs_res_t res = file_p->drv->write_cb(file_p->drv, file_p->file_d, buf, btw, &bw_tmp);
    if(bw != NULL) *bw = bw_tmp;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x43868
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43879
movb $0xb, -0x1(%rbp)
jmp 0x438d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4388e
movb $0x9, -0x1(%rbp)
jmp 0x438d6
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x2c(%rbp), %r8
callq *%rax
movb %al, -0x2d(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x438d0
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb -0x2d(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_seek
lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos)
{
    if(file_p->drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->seek_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, pos);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43900
movb $0xb, -0x1(%rbp)
jmp 0x4393e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x43915
movb $0x9, -0x1(%rbp)
jmp 0x4393e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_fs.c
// Function: lv_fs_tell
lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t * pos)
{
    if(file_p->drv == NULL) {
        pos = 0;
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->tell_cb == NULL) {
        pos = 0;
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = file_p->drv->tell_cb(file_p->drv, file_p->file_d, pos);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43979
movq $0x0, -0x18(%rbp)
movb $0xb, -0x1(%rbp)
jmp 0x439c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x40(%rax)
jne 0x43996
movq $0x0, -0x18(%rbp)
movb $0x9, -0x1(%rbp)
jmp 0x439c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_trunc
lv_fs_res_t lv_fs_trunc(lv_fs_file_t * file_p)
{
    if(file_p->drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->tell_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = file_p->drv->trunc_cb(file_p->drv, file_p->file_d);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x439ed
movb $0xb, -0x1(%rbp)
jmp 0x43a28
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x40(%rax)
jne 0x43a02
movb $0x9, -0x1(%rbp)
jmp 0x43a28
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_fs.c
// Function: lv_fs_size
lv_fs_res_t lv_fs_size(lv_fs_file_t * file_p, uint32_t * size)
{
    if(file_p->drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    if(file_p->drv->size_cb == NULL) return LV_FS_RES_NOT_IMP;

    if(size == NULL) return LV_FS_RES_INV_PARAM;

    lv_fs_res_t res = file_p->drv->size_cb(file_p->drv, file_p->file_d, size);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43a61
movb $0xb, -0x1(%rbp)
jmp 0x43aad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x50(%rax)
jne 0x43a76
movb $0x9, -0x1(%rbp)
jmp 0x43aad
cmpq $0x0, -0x18(%rbp)
jne 0x43a83
movb $0xb, -0x1(%rbp)
jmp 0x43aad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_fs.c
// Function: lv_fs_rename
lv_fs_res_t lv_fs_rename(const char * oldname, const char * newname)
{
    if(!oldname || !newname) return LV_FS_RES_INV_PARAM;

    char letter = oldname[0];

    lv_fs_drv_t * drv = lv_fs_get_drv(letter);

    if(!drv) {
        return LV_FS_RES_NOT_EX;
    }

    if(drv->ready_cb != NULL) {
        if(drv->ready_cb(drv) == false) {
            return LV_FS_RES_HW_ERR;
        }
    }

    if(drv->rename_cb == NULL) return LV_FS_RES_NOT_IMP;

    const char * old_real = lv_fs_get_real_path(oldname);
    const char * new_real = lv_fs_get_real_path(newname);

    lv_fs_res_t res = drv->rename_cb(drv, old_real, new_real);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43ade
cmpq $0x0, -0x18(%rbp)
jne 0x43ae7
movb $0xb, -0x1(%rbp)
jmp 0x43b7f
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %edi
callq 0x433d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x43b0a
movb $0x3, -0x1(%rbp)
jmp 0x43b7f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x43b35
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x43b33
movb $0x1, -0x1(%rbp)
jmp 0x43b7f
jmp 0x43b35
movq -0x28(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x43b46
movb $0x9, -0x1(%rbp)
jmp 0x43b7f
movq -0x10(%rbp), %rdi
callq 0x435f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x435f0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq *%rax
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_dir_open
lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
{
    if(path == NULL) return LV_FS_RES_INV_PARAM;

    char letter = path[0];

    rddir_p->drv = lv_fs_get_drv(letter);

    if(rddir_p->drv == NULL) {
        rddir_p->dir_d = NULL;
        return LV_FS_RES_NOT_EX;
    }

    rddir_p->dir_d = lv_mem_alloc(rddir_p->drv->rddir_size);
    LV_ASSERT_MEM(rddir_p->dir_d);
    if(rddir_p->dir_d == NULL) {
        rddir_p->dir_d = NULL;
        return LV_FS_RES_OUT_OF_MEM; /* Out of memory */
    }

    if(rddir_p->drv->dir_open_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    const char * real_path = lv_fs_get_real_path(path);

    lv_fs_res_t res = rddir_p->drv->dir_open_cb(rddir_p->drv, rddir_p->dir_d, real_path);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x43bb0
movb $0xb, -0x1(%rbp)
jmp 0x43c95
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %edi
callq 0x433d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43bec
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x3, -0x1(%rbp)
jmp 0x43c95
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x4(%rax), %eax
movl %eax, %edi
callq 0x44d20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xd120
testb $0x1, %al
jne 0x43c2e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x2441d(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x43c2c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x43c49
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0xa, -0x1(%rbp)
jmp 0x43c95
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x68(%rax)
jne 0x43c5e
movb $0x9, -0x1(%rbp)
jmp 0x43c95
movq -0x18(%rbp), %rdi
callq 0x435f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_dir_read
lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn)
{
    if(rddir_p->drv == NULL || rddir_p->dir_d == NULL) {
        fn[0] = '\0';
        return LV_FS_RES_INV_PARAM;
    }

    if(rddir_p->drv->dir_read_cb == NULL) {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = rddir_p->drv->dir_read_cb(rddir_p->drv, rddir_p->dir_d, fn);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x43cc5
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x43cd2
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movb $0xb, -0x1(%rbp)
jmp 0x43d11
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x70(%rax)
jne 0x43ce7
movb $0x9, -0x1(%rbp)
jmp 0x43d11
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_fs.c
// Function: lv_fs_dir_close
lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p)
{
    if(rddir_p->drv == NULL || rddir_p->dir_d == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    lv_fs_res_t res;

    if(rddir_p->drv->dir_close_cb == NULL) {
        res = LV_FS_RES_NOT_IMP;
    } else {
        res = rddir_p->drv->dir_close_cb(rddir_p->drv, rddir_p->dir_d);
    }

    lv_mem_free(rddir_p->dir_d); /*Clean up*/
    rddir_p->dir_d = NULL;
    rddir_p->drv   = NULL;
    rddir_p->dir_d = NULL;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x43d41
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x43d47
movb $0xb, -0x1(%rbp)
jmp 0x43db0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x78(%rax)
jne 0x43d5c
movb $0x9, -0x11(%rbp)
jmp 0x43d7c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x44ec0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_free_space
lv_fs_res_t lv_fs_free_space(char letter, uint32_t * total_p, uint32_t * free_p)
{
    lv_fs_drv_t * drv = lv_fs_get_drv(letter);

    if(drv == NULL) {
        return LV_FS_RES_INV_PARAM;
    }

    lv_fs_res_t res;

    if(drv->free_space_cb == NULL) {
        res = LV_FS_RES_NOT_IMP;
    } else {
        uint32_t total_tmp = 0;
        uint32_t free_tmp  = 0;
        res                = drv->free_space_cb(drv, &total_tmp, &free_tmp);

        if(total_p != NULL) *total_p = total_tmp;
        if(free_p != NULL) *free_p = free_tmp;
    }

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x2(%rbp), %edi
callq 0x433d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x43df0
movb $0xb, -0x1(%rbp)
jmp 0x43e50
movq -0x20(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x43e01
movb $0x9, -0x21(%rbp)
jmp 0x43e4a
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq *%rax
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43e38
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x43e48
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x43e4a
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_misc/lv_fs.c
// Function: lv_fs_drv_register
void lv_fs_drv_register(lv_fs_drv_t * drv_p)
{
    /*Save the new driver*/
    lv_fs_drv_t * new_drv;
    new_drv = lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
    LV_ASSERT_MEM(new_drv);
    if(new_drv == NULL) return;

    memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4d755(%rip), %rdi     # 0x915f8
callq 0x453f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x43ecb
movq -0x10(%rbp), %rsi
leaq 0x24180(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x43ec9
cmpq $0x0, -0x10(%rbp)
jne 0x43ed4
jmp 0x43ee6
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_get_letters
char * lv_fs_get_letters(char * buf)
{
    lv_fs_drv_t * drv;
    uint8_t i = 0;

    LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv)
    {
        buf[i] = drv->letter;
        i++;
    }

    buf[i] = '\0';

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x11(%rbp)
leaq 0x4d6f1(%rip), %rdi     # 0x915f8
callq 0x45660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43f46
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x4d6bd(%rip), %rdi     # 0x915f8
callq 0x458a0
movq %rax, -0x10(%rbp)
jmp 0x43f10
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_get_ext
const char * lv_fs_get_ext(const char * fn)
{
    size_t i;
    for(i = strlen(fn); i > 0; i--) {
        if(fn[i] == '.') {
            return &fn[i + 1];
        } else if(fn[i] == '/' || fn[i] == '\\') {
            return ""; /*No extension if a '\' or '/' found*/
        }
    }

    return ""; /*Empty string if no '.' in the file name. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x43fe7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x43fa6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x43ff2
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x43fc8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x43fd5
leaq 0x28146(%rip), %rax     # 0x6c115
movq %rax, -0x8(%rbp)
jmp 0x43ff2
jmp 0x43fd7
jmp 0x43fd9
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x43f79
leaq 0x28127(%rip), %rax     # 0x6c115
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_up
char * lv_fs_up(char * path)
{
    size_t len = strlen(path);
    if(len == 0) return path;

    len--; /*Go before the trailing '\0'*/

    /*Ignore trailing '/' or '\'*/
    while(path[len] == '/' || path[len] == '\\') {
        path[len] = '\0';
        if(len > 0)
            len--;
        else
            return path;
    }

    size_t i;
    for(i = len; i > 0; i--) {
        if(path[i] == '/' || path[i] == '\\') break;
    }

    if(i > 0) path[i] = '\0';

    return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4402d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x440f8
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x21(%rbp)
je 0x44064
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4406d
jmp 0x4409a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
jbe 0x4408e
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x44098
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x440f8
jmp 0x44039
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x440dd
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x440cb
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x440cd
jmp 0x440dd
jmp 0x440cf
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x440a2
cmpq $0x0, -0x20(%rbp)
jbe 0x440f0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%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/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_fs.c
// Function: lv_fs_get_last
const char * lv_fs_get_last(const char * path)
{
    size_t len = strlen(path);
    if(len == 0) return path;

    len--; /*Go before the trailing '\0'*/

    /*Ignore trailing '/' or '\'*/
    while(path[len] == '/' || path[len] == '\\') {
        if(len > 0)
            len--;
        else
            return path;
    }

    size_t i;
    for(i = len; i > 0; i--) {
        if(path[i] == '/' || path[i] == '\\') break;
    }

    /*No '/' or '\' in the path so return with path itself*/
    if(i == 0) return path;

    return &path[i + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4413d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44205
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x21(%rbp)
je 0x44174
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4417d
jmp 0x4419e
cmpq $0x0, -0x18(%rbp)
jbe 0x44192
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4419c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44205
jmp 0x44149
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x441e1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x441cf
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x441d1
jmp 0x441e1
jmp 0x441d3
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x441a6
cmpq $0x0, -0x20(%rbp)
jne 0x441f2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44205
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_init
void lv_anim_init(lv_anim_t * a)
{
    memset(a, 0, sizeof(lv_anim_t));
    a->time    = 500;
    a->start   = 0;
    a->end     = 100;
    a->path_cb = lv_anim_path_linear;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2090
movq -0x8(%rbp), %rax
movw $0x1f4, 0x28(%rax)      # imm = 0x1F4
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x64, 0x24(%rax)
movq -0x8(%rbp), %rax
leaq 0x19(%rip), %rcx        # 0x44430
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_path_linear
lv_anim_value_t lv_anim_path_linear(const lv_anim_t * a)
{
    /*Calculate the current step*/
    uint32_t step;
    if(a->time == a->act_time) {
        step = LV_ANIM_RESOLUTION; /*Use the last value if the time fully elapsed*/
    } else {
        step = ((int32_t)a->act_time * LV_ANIM_RESOLUTION) / a->time;
    }

    /* Get the new value which will be proportional to `step`
     * and the `start` and `end` values*/
    int32_t new_value;
    new_value = (int32_t)step * (a->end - a->start);
    new_value = new_value >> LV_ANIM_RES_SHIFT;
    new_value += a->start;

    return (lv_anim_value_t)new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x2a(%rcx), %ecx
cmpl %ecx, %eax
jne 0x44455
movl $0x400, -0xc(%rbp)      # imm = 0x400
jmp 0x4446e
movq -0x8(%rbp), %rax
movswl 0x2a(%rax), %eax
shll $0xa, %eax
movq -0x8(%rbp), %rcx
movzwl 0x28(%rcx), %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x20(%rdx), %ecx
imull %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
sarl $0xa, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_create
void lv_anim_create(lv_anim_t * a)
{
    LV_LOG_TRACE("animation create started")
    /* Do not let two animations for the  same 'var' with the same 'fp'*/
    if(a->exec_cb != NULL) lv_anim_del(a->var, a->exec_cb); /*fp == NULL would delete all animations of var*/

    /*Add the new animation to the animation linked list*/
    lv_anim_t * new_anim = lv_ll_ins_head(&LV_GC_ROOT(_lv_anim_ll));
    LV_ASSERT_MEM(new_anim);
    if(new_anim == NULL) return;

    /*Initialize the animation descriptor*/
    a->playback_now = 0;
    memcpy(new_anim, a, sizeof(lv_anim_t));

    /*Set the start value*/
    if(new_anim->exec_cb) new_anim->exec_cb(new_anim->var, new_anim->start);

    /* Creating an animation changed the linked list.
     * It's important if it happens in a ready callback. (see `anim_task`)*/
    anim_list_changed = true;

    LV_LOG_TRACE("animation created")
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x444cb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x44560
leaq 0x4d156(%rip), %rdi     # 0x91628
callq 0x453f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x444fa
movq -0x10(%rbp), %rsi
leaq 0x23b51(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0x444f8
cmpq $0x0, -0x10(%rbp)
jne 0x44503
jmp 0x44552
movq -0x8(%rbp), %rax
movb 0x30(%rax), %cl
andb $-0x5, %cl
orb $0x0, %cl
movb %cl, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x38, %edx
callq 0x20e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4454b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movswl %cx, %esi
callq *%rax
movb $0x1, 0x4503e(%rip)     # 0x89590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_del
bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
{
    lv_anim_t * a;
    lv_anim_t * a_next;
    bool del = false;
    a        = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
    while(a != NULL) {
        /*'a' might be deleted, so get the next object while 'a' is valid*/
        a_next = lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);

        if(a->var == var && (a->exec_cb == exec_cb || exec_cb == NULL)) {
            lv_ll_rem(&LV_GC_ROOT(_lv_anim_ll), a);
            lv_mem_free(a);
            anim_list_changed = true; /*Read by `anim_task`. It need to know if a delete occurred in
                                         the linked list*/
            del = true;
        }

        a = a_next;
    }

    return del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x21(%rbp)
leaq 0x4d0ad(%rip), %rdi     # 0x91628
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x445ef
movq -0x18(%rbp), %rsi
leaq 0x4d092(%rip), %rdi     # 0x91628
callq 0x458a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x445e5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x445c1
cmpq $0x0, -0x10(%rbp)
jne 0x445e5
movq -0x18(%rbp), %rsi
leaq 0x4d05c(%rip), %rdi     # 0x91628
callq 0x45790
movq -0x18(%rbp), %rdi
callq 0x44ec0
movb $0x1, 0x44faf(%rip)     # 0x89590
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x44584
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_anim.c
// Function: lv_anim_speed_to_time
uint16_t lv_anim_speed_to_time(uint16_t speed, lv_anim_value_t start, lv_anim_value_t end)
{
    int32_t d     = LV_MATH_ABS((int32_t)start - end);
    uint32_t time = (int32_t)((int32_t)(d * 1000) / speed);

    if(time > UINT16_MAX) time = UINT16_MAX;

    if(time == 0) {
        time++;
    }

    return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movw %di, %dx
movw %dx, -0x2(%rbp)
movw %cx, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movswl -0x4(%rbp), %eax
movswl -0x6(%rbp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jle 0x44697
movswl -0x4(%rbp), %eax
movswl -0x6(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x446a8
movswl -0x4(%rbp), %ecx
movswl -0x6(%rbp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
imull $0x3e8, -0xc(%rbp), %eax # imm = 0x3E8
movzwl -0x2(%rbp), %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jbe 0x446cf
movl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
cmpl $0x0, -0x10(%rbp)
jne 0x446de
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%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_anim.c
// Function: lv_anim_path_ease_in
lv_anim_value_t lv_anim_path_ease_in(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, 1, 1, 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 0x44719
movl $0x400, -0xc(%rbp)      # imm = 0x400
jmp 0x44733
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 $0x1, %ecx
movl $0x400, %r8d            # imm = 0x400
movl %ecx, %edx
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_anim.c
// Function: lv_anim_path_ease_in_out
lv_anim_value_t lv_anim_path_ease_in_out(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, 100, 924, 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 0x44859
movl $0x400, -0xc(%rbp)      # imm = 0x400
jmp 0x44873
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 $0x64, %edx
movl $0x39c, %ecx            # imm = 0x39C
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)