LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_count_children
uint16_t lv_obj_count_children(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * i;
    uint16_t cnt = 0;

    LV_LL_READ(obj->child_ll, i) cnt++;

    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x9ebb
movq -0x8(%rbp), %rsi
leaq 0x5e248(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0x9eb9
movw $0x0, -0x12(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x45660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9efc
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x10(%rbp)
jmp 0x9ed2
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_count_children_recursive
uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * i;
    uint16_t cnt = 0;

    LV_LL_READ(obj->child_ll, i)
    {
        cnt++;                                     /*Count the child*/
        cnt += lv_obj_count_children_recursive(i); /*recursively count children's children*/
    }

    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x9f3b
movq -0x8(%rbp), %rsi
leaq 0x5e1c8(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0x9f39
movw $0x0, -0x12(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x45660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9f92
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f10
movzwl %ax, %ecx
movzwl -0x12(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x458a0
movq %rax, -0x10(%rbp)
jmp 0x9f52
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_inner_coords
void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    const lv_style_t * style = lv_obj_get_style(obj);
    if(style->body.border.part & LV_BORDER_LEFT) coords_p->x1 += style->body.border.width;

    if(style->body.border.part & LV_BORDER_RIGHT) coords_p->x2 -= style->body.border.width;

    if(style->body.border.part & LV_BORDER_TOP) coords_p->y1 += style->body.border.width;

    if(style->body.border.part & LV_BORDER_BOTTOM) coords_p->y2 -= style->body.border.width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x9fcf
movq -0x8(%rbp), %rsi
leaq 0x5e134(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0x9fcd
movq -0x8(%rbp), %rdi
callq 0xa080
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa000
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movswl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa026
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %ecx
subl %edx, %ecx
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xa04c
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa072
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %ecx
subl %edx, %ecx
movw %cx, 0x6(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_style
const lv_style_t * lv_obj_get_style(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    const lv_style_t * style_act = obj->style_p;
    if(style_act == NULL) {
        lv_obj_t * par = obj->par;

        while(par) {
            if(par->style_p) {
                if(par->style_p->glass == 0) {
#if LV_USE_GROUP == 0
                    style_act = par->style_p;
#else
                    /*If a parent is focused then use then focused style*/
                    lv_group_t * g = lv_obj_get_group(par);
                    if(lv_group_get_focused(g) == par) {
                        style_act = lv_group_mod_style(g, par->style_p);
                    } else {
                        style_act = par->style_p;
                    }
#endif
                    break;
                }
            }
            par = par->par;
        }
    }
#if LV_USE_GROUP
    if(obj->group_p) {
        if(lv_group_get_focused(obj->group_p) == obj) {
            style_act = lv_group_mod_style(obj->group_p, style_act);
        }
    }
#endif

    if(style_act == NULL) style_act = &lv_style_plain;

    return style_act;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xa0ab
movq -0x8(%rbp), %rsi
leaq 0x5e058(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0xa0a9
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa145
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa143
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xa136
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa134
movq -0x18(%rbp), %rdi
callq 0x77c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3010
cmpq -0x18(%rbp), %rax
jne 0xa126
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x31c0
movq %rax, -0x10(%rbp)
jmp 0xa132
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa143
jmp 0xa136
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa0cd
jmp 0xa145
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xa17a
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3010
cmpq -0x8(%rbp), %rax
jne 0xa178
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x31c0
movq %rax, -0x10(%rbp)
jmp 0xa17a
cmpq $0x0, -0x10(%rbp)
jne 0xa18c
leaq 0x7ee60(%rip), %rax     # 0x88fe8
movq %rax, -0x10(%rbp)
movq -0x10(%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_core/lv_obj.c
// Function: lv_obj_get_opa_scale
lv_opa_t lv_obj_get_opa_scale(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    const lv_obj_t * parent = obj;

    while(parent) {
        if(parent->opa_scale_en) return parent->opa_scale;
        parent = lv_obj_get_parent(parent);
    }

    return LV_OPA_COVER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xa73b
movq -0x10(%rbp), %rsi
leaq 0x5d9c8(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0xa739
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa779
movq -0x18(%rbp), %rax
movw 0x58(%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
cmpb $0x0, %al
je 0xa76a
movq -0x18(%rbp), %rax
movb 0x5b(%rax), %al
movb %al, -0x1(%rbp)
jmp 0xa77d
movq -0x18(%rbp), %rdi
callq 0x71b0
movq %rax, -0x18(%rbp)
jmp 0xa743
movb $-0x1, -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_core/lv_obj.c
// Function: lv_obj_get_type
void lv_obj_get_type(const lv_obj_t * obj, lv_obj_type_t * buf)
{
    LV_ASSERT_NULL(buf);
    LV_ASSERT_NULL(obj);

    lv_obj_type_t tmp;

    memset(buf, 0, sizeof(lv_obj_type_t));
    memset(&tmp, 0, sizeof(lv_obj_type_t));

    obj->signal_cb((lv_obj_t *)obj, LV_SIGNAL_GET_TYPE, &tmp);

    uint8_t cnt;
    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
        if(tmp.type[cnt] == NULL) break;
    }

    /*Swap the order. The real type comes first*/
    uint8_t i;
    for(i = 0; i < cnt; i++) {
        buf->type[i] = tmp.type[cnt - 1 - i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xa95f
movq -0x10(%rbp), %rsi
leaq 0x5d7a4(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0xa95d
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xa97e
movq -0x8(%rbp), %rsi
leaq 0x5d785(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0xa97c
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x7, %esi
leaq -0x50(%rbp), %rdx
callq *%rax
movb $0x0, -0x51(%rbp)
movzbl -0x51(%rbp), %eax
cmpl $0x8, %eax
jge 0xa9dc
movzbl -0x51(%rbp), %eax
cmpq $0x0, -0x50(%rbp,%rax,8)
jne 0xa9d0
jmp 0xa9dc
jmp 0xa9d2
movb -0x51(%rbp), %al
addb $0x1, %al
movb %al, -0x51(%rbp)
jmp 0xa9b9
movb $0x0, -0x52(%rbp)
movzbl -0x52(%rbp), %eax
movzbl -0x51(%rbp), %ecx
cmpl %ecx, %eax
jge 0xaa16
movzbl -0x51(%rbp), %eax
subl $0x1, %eax
movzbl -0x52(%rbp), %ecx
subl %ecx, %eax
cltq
movq -0x50(%rbp,%rax,8), %rdx
movq -0x10(%rbp), %rax
movzbl -0x52(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movb -0x52(%rbp), %al
addb $0x1, %al
movb %al, -0x52(%rbp)
jmp 0xa9e0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_is_focused
bool lv_obj_is_focused(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    if(obj->group_p) {
        if(lv_group_get_focused(obj->group_p) == obj) return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xaa4b
movq -0x10(%rbp), %rsi
leaq 0x5d6b8(%rip), %rdi     # 0x680fc
callq 0xd410
jmp 0xaa49
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xaa71
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3010
cmpq -0x10(%rbp), %rax
jne 0xaa6f
movb $0x1, -0x1(%rbp)
jmp 0xaa75
jmp 0xaa71
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_handle_get_type_signal
lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name)
{
    uint8_t i;
    for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
        if(buf->type[i] == NULL) break;
    }
    buf->type[i] = name;

    return LV_RES_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x7, %eax
jge 0xaab6
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0xaaaa
jmp 0xaab6
jmp 0xaaac
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xaa90
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_refr_now
void lv_refr_now(lv_disp_t * disp)
{
    if(disp) {
        lv_disp_refr_task(disp->refr_task);
    } else {
        lv_disp_t * d;
        d = lv_disp_get_next(NULL);
        while(d) {
            lv_disp_refr_task(d->refr_task);
            d = lv_disp_get_next(d);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xab02
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xab40
jmp 0xab34
xorl %eax, %eax
movl %eax, %edi
callq 0xdb80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xab32
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xab40
movq -0x10(%rbp), %rdi
callq 0xdb80
movq %rax, -0x10(%rbp)
jmp 0xab0f
jmp 0xab34
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_refr_areas
static void lv_refr_areas(void)
{
    px_num = 0;
    uint32_t i;

    for(i = 0; i < disp_refr->inv_p; i++) {
        /*Refresh the unjoined areas*/
        if(disp_refr->inv_area_joined[i] == 0) {

            lv_refr_area(&disp_refr->inv_areas[i]);

            if(disp_refr->driver.monitor_cb) px_num += lv_area_get_size(&disp_refr->inv_areas[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x7ddc6(%rip)     # 0x88f98
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x7ddad(%rip), %rcx     # 0x88f90
movw 0x198(%rcx), %cx
andw $0x3ff, %cx             # imm = 0x3FF
movzwl %cx, %ecx
cmpl %ecx, %eax
jae 0xb26d
movq 0x7dd93(%rip), %rax     # 0x88f90
movl -0x4(%rbp), %ecx
movzbl 0x178(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb25d
movq 0x7dd7c(%rip), %rdi     # 0x88f90
addq $0x78, %rdi
movl -0x4(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xb380
movq 0x7dd62(%rip), %rax     # 0x88f90
cmpq $0x0, 0x30(%rax)
je 0xb25b
movq 0x7dd54(%rip), %rdi     # 0x88f90
addq $0x78, %rdi
movl -0x4(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x42790
addl 0x7dd43(%rip), %eax     # 0x88f98
movl %eax, 0x7dd3d(%rip)     # 0x88f98
jmp 0xb25d
jmp 0xb25f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb1d9
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_refr_vdb_flush
static void lv_refr_vdb_flush(void)
{
    lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);

    /*In double buffered mode wait until the other buffer is flushed before flushing the current
     * one*/
    if(lv_disp_is_double_buf(disp_refr)) {
        while(vdb->flushing)
            ;
    }

    vdb->flushing = 1;

    /*Flush the rendered content to the display*/
    lv_disp_t * disp = lv_refr_get_disp_refreshing();
    if(disp->driver.flush_cb) disp->driver.flush_cb(&disp->driver, &vdb->area, vdb->buf_act);

    if(vdb->buf1 && vdb->buf2) {
        if(vdb->buf_act == vdb->buf1)
            vdb->buf_act = vdb->buf2;
        else
            vdb->buf_act = vdb->buf1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x7dd01(%rip), %rdi     # 0x88f90
callq 0xdbd0
movq %rax, -0x8(%rbp)
movq 0x7dcf1(%rip), %rdi     # 0x88f90
callq 0xdc90
testb $0x1, %al
jne 0xb2aa
jmp 0xb2c1
jmp 0xb2ac
movq -0x8(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xb2bf
jmp 0xb2ac
jmp 0xb2c1
movq -0x8(%rbp), %rax
movb 0x24(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x24(%rax)
callq 0xafe0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb303
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1c, %rsi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdx
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb34c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb34c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xb33b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xb34a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xb34c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_refr_area_part
static void lv_refr_area_part(const lv_area_t * area_p)
{

    lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);

    /*In non double buffered mode, before rendering the next part wait until the previous image is
     * flushed*/
    if(lv_disp_is_double_buf(disp_refr) == false) {
        while(vdb->flushing)
            ;
    }

    lv_obj_t * top_p;

    /*Get the new mask from the original area and the act. VDB
     It will be a part of 'area_p'*/
    lv_area_t start_mask;
    lv_area_intersect(&start_mask, area_p, &vdb->area);

    /*Get the most top object which is not covered by others*/
    top_p = lv_refr_get_top_obj(&start_mask, lv_disp_get_scr_act(disp_refr));

    /*Do the refreshing from the top object*/
    lv_refr_obj_and_children(top_p, &start_mask);

    /*Also refresh top and sys layer unconditionally*/
    lv_refr_obj_and_children(lv_disp_get_layer_top(disp_refr), &start_mask);
    lv_refr_obj_and_children(lv_disp_get_layer_sys(disp_refr), &start_mask);

    /* In true double buffered mode flush only once when all areas were rendered.
     * In normal mode flush after every area */
    if(lv_disp_is_true_double_buf(disp_refr) == false) {
        lv_refr_vdb_flush();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7d94d(%rip), %rdi     # 0x88f90
callq 0xdbd0
movq %rax, -0x10(%rbp)
movq 0x7d93d(%rip), %rdi     # 0x88f90
callq 0xdc90
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb679
jmp 0xb664
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xb677
jmp 0xb664
jmp 0xb679
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x1c, %rdx
leaq -0x20(%rbp), %rdi
callq 0x427d0
movq 0x7d8fb(%rip), %rdi     # 0x88f90
callq 0x6340
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0xb730
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb840
movq 0x7d8d2(%rip), %rdi     # 0x88f90
callq 0x63d0
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0xb840
movq 0x7d8ba(%rip), %rdi     # 0x88f90
callq 0x6420
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0xb840
movq 0x7d8a2(%rip), %rdi     # 0x88f90
callq 0xdcd0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb702
callq 0xb280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_refr_get_top_obj
static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
{
    lv_obj_t * found_p = NULL;

    /*If this object is fully cover the draw area check the children too */
    if(lv_area_is_in(area_p, &obj->coords) && obj->hidden == 0) {
        lv_obj_t * i;
        LV_LL_READ(obj->child_ll, i)
        {
            found_p = lv_refr_get_top_obj(area_p, i);

            /*If a children is ok then break*/
            if(found_p != NULL) {
                break;
            }
        }

        /*If no better children check this object*/
        if(found_p == NULL) {
            const lv_style_t * style = lv_obj_get_style(obj);
            if(style->body.opa == LV_OPA_COVER && obj->design_cb(obj, area_p, LV_DESIGN_COVER_CHK) != false &&
               lv_obj_get_opa_scale(obj) == LV_OPA_COVER) {
                found_p = obj;
            }
        }
    }

    return found_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x42ae0
testb $0x1, %al
jne 0xb762
jmp 0xb82c
movq -0x10(%rbp), %rax
movw 0x58(%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb82c
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x45660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb7c9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb730
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb7b0
jmp 0xb7c9
jmp 0xb7b2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x458a0
movq %rax, -0x20(%rbp)
jmp 0xb78f
cmpq $0x0, -0x18(%rbp)
jne 0xb82a
movq -0x10(%rbp), %rdi
callq 0xa080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0xff, %eax
jne 0xb828
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x2, %edx
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xb828
movq -0x10(%rbp), %rdi
callq 0xa710
movzbl %al, %eax
cmpl $0xff, %eax
jne 0xb828
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb82a
jmp 0xb82c
movq -0x18(%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_core/lv_refr.c
// Function: lv_refr_obj_and_children
static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
{
    /* Normally always will be a top_obj (at least the screen)
     * but in special cases (e.g. if the screen has alpha) it won't.
     * In this case use the screen directly */
    if(top_p == NULL) top_p = lv_disp_get_scr_act(disp_refr);

    /*Refresh the top object and its children*/
    lv_refr_obj(top_p, mask_p);

    /*Draw the 'younger' sibling objects because they can be on top_obj */
    lv_obj_t * par;
    lv_obj_t * border_p = top_p;

    par = lv_obj_get_parent(top_p);

    /*Do until not reach the screen*/
    while(par != NULL) {
        /*object before border_p has to be redrawn*/
        lv_obj_t * i = lv_ll_get_prev(&(par->child_ll), border_p);

        while(i != NULL) {
            /*Refresh the objects*/
            lv_refr_obj(i, mask_p);
            i = lv_ll_get_prev(&(par->child_ll), i);
        }

        /*Call the post draw design function of the parents of the to object*/
        par->design_cb(par, mask_p, LV_DESIGN_DRAW_POST);

        /*The new border will be there last parents,
         *so the 'younger' brothers of parent will be refreshed*/
        border_p = par;
        /*Go a level deeper*/
        par = lv_obj_get_parent(par);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb867
movq 0x7d732(%rip), %rdi     # 0x88f90
callq 0x6340
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb910
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x71b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb8fe
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x45690
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb8d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb910
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x45690
movq %rax, -0x28(%rbp)
jmp 0xb8a5
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71b0
movq %rax, -0x18(%rbp)
jmp 0xb889
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_style.c
// Function: lv_style_anim_init
void lv_style_anim_init(lv_anim_t * a)
{
    lv_anim_init(a);
    a->start    = 0;
    a->end      = STYLE_MIX_MAX;
    a->exec_cb  = (lv_anim_exec_xcb_t)style_animator;
    a->path_cb  = lv_anim_path_linear;
    a->ready_cb = style_animation_common_end_cb;

    lv_style_anim_dsc_t * dsc;
    dsc = lv_mem_alloc(sizeof(lv_style_anim_dsc_t));
    LV_ASSERT_MEM(dsc);
    if(dsc == NULL) return;
    dsc->ready_cb   = NULL;
    dsc->style_anim = NULL;
    lv_style_copy(&dsc->style_start, &lv_style_plain);
    lv_style_copy(&dsc->style_end, &lv_style_plain);

    a->var = (void *)dsc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x443d0
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x100, 0x24(%rax)      # imm = 0x100
movq -0x8(%rbp), %rax
leaq 0xba(%rip), %rcx        # 0xcfe0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x374fb(%rip), %rcx     # 0x44430
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x10c(%rip), %rcx       # 0xd050
movq %rcx, 0x18(%rax)
movl $0xa0, %edi
callq 0x44d20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xcf75
movq -0x10(%rbp), %rsi
leaq 0x5b0d6(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0xcf73
cmpq $0x0, -0x10(%rbp)
jne 0xcf7e
jmp 0xcfcb
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
leaq 0x7c041(%rip), %rsi     # 0x88fe8
callq 0xc550
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
leaq 0x7c02d(%rip), %rsi     # 0x88fe8
callq 0xc550
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%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_core/lv_style.c
// Function: style_animator
static void style_animator(lv_style_anim_dsc_t * dsc, lv_anim_value_t val)
{
    const lv_style_t * start = &dsc->style_start;
    const lv_style_t * end   = &dsc->style_end;
    lv_style_t * act         = dsc->style_anim;

    lv_style_mix(start, end, act, val);

    lv_obj_report_style_mod(dsc->style_anim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movzwl -0xa(%rbp), %ecx
callq 0xc580
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x92b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_style.c
// Function: lv_style_anim_set_styles
void lv_style_anim_set_styles(lv_anim_t * a, lv_style_t * to_anim, const lv_style_t * start, const lv_style_t * end)
{

    lv_style_anim_dsc_t * dsc = a->var;
    dsc->style_anim           = to_anim;
    memcpy(&dsc->style_start, start, sizeof(lv_style_t));
    memcpy(&dsc->style_end, end, sizeof(lv_style_t));
    memcpy(dsc->style_anim, start, sizeof(lv_style_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x48, %edx
callq 0x20e0
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq -0x20(%rbp), %rsi
movl $0x48, %edx
callq 0x20e0
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x48, %edx
callq 0x20e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: lv_debug_check_obj_type
bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type)
{
    if(obj_type[0] == '\0') return true;

    lv_obj_type_t types;
    lv_obj_get_type((lv_obj_t *)obj, &types);

    uint8_t i;
    for(i = 0; i < LV_MAX_ANCESTOR_NUM; i++) {
        if(strcmp(types.type[i], obj_type) == 0) return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd162
movb $0x1, -0x1(%rbp)
jmp 0xd1a9
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa930
movb $0x0, -0x59(%rbp)
movzbl -0x59(%rbp), %eax
cmpl $0x8, %eax
jge 0xd1a5
movzbl -0x59(%rbp), %eax
movq -0x58(%rbp,%rax,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0xd199
movb $0x1, -0x1(%rbp)
jmp 0xd1a9
jmp 0xd19b
movb -0x59(%rbp), %al
addb $0x1, %al
movb %al, -0x59(%rbp)
jmp 0xd173
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: lv_debug_check_obj_valid
bool lv_debug_check_obj_valid(const lv_obj_t * obj)
{
    lv_disp_t * disp = lv_disp_get_next(NULL);
    while(disp) {
        lv_obj_t * scr;
        LV_LL_READ(disp->scr_ll, scr) {

            if(scr == obj) return true;
            bool found = obj_valid_child(scr, obj);
            if(found) return true;
        }

        disp = lv_disp_get_next(disp);
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xdb80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd24e
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x45660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd23f
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xd208
movb $0x1, -0x1(%rbp)
jmp 0xd252
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd260
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0xd226
movb $0x1, -0x1(%rbp)
jmp 0xd252
jmp 0xd228
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movq -0x20(%rbp), %rsi
callq 0x458a0
movq %rax, -0x20(%rbp)
jmp 0xd1f1
movq -0x18(%rbp), %rdi
callq 0xdb80
movq %rax, -0x18(%rbp)
jmp 0xd1d9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: obj_valid_child
static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find)
{
    /*Check all children of `parent`*/
    lv_obj_t * child;
    LV_LL_READ(parent->child_ll, child) {
        if(child == obj_to_find) return true;

        /*Check the children*/
        bool found = obj_valid_child(child, obj_to_find);
        if(found) return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x45660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd2cf
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xd298
movb $0x1, -0x1(%rbp)
jmp 0xd2d3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd260
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0xd2b6
movb $0x1, -0x1(%rbp)
jmp 0xd2d3
jmp 0xd2b8
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x458a0
movq %rax, -0x20(%rbp)
jmp 0xd281
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: lv_debug_check_style
bool lv_debug_check_style(const lv_style_t * style)
{
    if(style == NULL) return true;  /*NULL style is still valid*/

#if LV_USE_ASSERT_STYLE
    if(style->debug_sentinel != LV_STYLE_DEGUG_SENTINEL_VALUE) {
        LV_LOG_WARN("Invalid style (local variable or not initialized?)");
        return false;
    }
#endif

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd2f5
movb $0x1, -0x1(%rbp)
jmp 0xd30c
movq -0x10(%rbp), %rax
cmpl $0x12345678, 0x44(%rax) # imm = 0x12345678
je 0xd308
movb $0x0, -0x1(%rbp)
jmp 0xd30c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: lv_debug_check_str
bool lv_debug_check_str(const void * str)
{
    const uint8_t * s = (const uint8_t *)str;
    uint8_t last_byte = 0;
    uint32_t rep = 0;
    uint32_t i;

    for(i = 0; s[i] != '\0' && i < LV_DEBUG_STR_MAX_LENGTH; i++) {
        if(s[i] != last_byte) {
            last_byte = s[i];
            rep = 1;
        } else if(s[i] > 0x7F){
            rep++;
            if(rep > LV_DEBUG_STR_MAX_REPEAT) {
                LV_LOG_WARN("lv_debug_check_str: a non-ASCII char has repeated more than LV_DEBUG_STR_MAX_REPEAT times)");
                return false;
            }
        }

        if(s[i] < 10) {
            LV_LOG_WARN("lv_debug_check_str: invalid char in the string (< 10 value)");
            return false;   /*Shouldn't occur in strings*/
        }
    }

    if(s[i] == '\0') return true;

    LV_LOG_WARN("lv_debug_check_str: string is longer than LV_DEBUG_STR_MAX_LENGTH");
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0xd364
cmpl $0x2000, -0x24(%rbp)    # imm = 0x2000
setb %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xd36d
jmp 0xd3e5
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0xd396
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0xd3bf
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jle 0xd3bd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jbe 0xd3bb
movb $0x0, -0x1(%rbp)
jmp 0xd3ff
jmp 0xd3bd
jmp 0xd3bf
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jge 0xd3d5
movb $0x0, -0x1(%rbp)
jmp 0xd3ff
jmp 0xd3d7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd342
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xd3fb
movb $0x1, -0x1(%rbp)
jmp 0xd3ff
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_debug.c
// Function: lv_debug_log_error
void lv_debug_log_error(const char * msg, uint64_t value)
{
    static const char hex[] = "0123456789ABCDEF";

    size_t msg_len = strlen(msg);
    uint32_t value_len = sizeof(unsigned long int);

    if(msg_len < 230) {
        char buf[255];
        char * bufp = buf;

        /*Add the function name*/
        memcpy(bufp, msg, msg_len);
        bufp += msg_len;

        /*Add value in hey*/
        *bufp = ' ';
        bufp ++;
        *bufp = '(';
        bufp ++;
        *bufp = '0';
        bufp ++;
        *bufp = 'x';
        bufp ++;

        int8_t i;
        for(i = value_len * 2 - 1; i >= 0; i--) {
            uint8_t x = (unsigned long int)((unsigned long int)value >> (i * 4)) & 0xF;

            *bufp = hex[x];
            bufp++;
        }

        *bufp = ')';
        bufp ++;

        *bufp = '\0';
        LV_LOG_ERROR(buf);
    } else {
        LV_LOG_ERROR(msg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
movl $0x8, -0x1c(%rbp)
cmpq $0xe6, -0x18(%rbp)
jae 0xd586
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20e0
movq -0x18(%rbp), %rax
addq -0x128(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb $0x20, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb $0x28, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb $0x30, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb $0x78, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
subl $0x1, %eax
movb %al, -0x129(%rbp)
movsbl -0x129(%rbp), %eax
cmpl $0x0, %eax
jl 0xd55e
movq -0x10(%rbp), %rax
movsbl -0x129(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xf, %rax
movb %al, -0x12a(%rbp)
movzbl -0x12a(%rbp), %eax
movl %eax, %ecx
leaq 0x5abf0(%rip), %rax     # 0x68120
movb (%rax,%rcx), %cl
movq -0x128(%rbp), %rax
movb %cl, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movb -0x129(%rbp), %al
addb $-0x1, %al
movb %al, -0x129(%rbp)
jmp 0xd4f7
movq -0x128(%rbp), %rax
movb $0x29, (%rax)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb $0x0, (%rax)
jmp 0xd588
jmp 0xd588
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_drv_init
void lv_disp_drv_init(lv_disp_drv_t * driver)
{
    memset(driver, 0, sizeof(lv_disp_drv_t));

    driver->flush_cb         = NULL;
    driver->hor_res          = LV_HOR_RES_MAX;
    driver->ver_res          = LV_VER_RES_MAX;
    driver->buffer           = NULL;
    driver->rotated          = 0;
    driver->color_chroma_key = LV_COLOR_TRANSP;

#if LV_ANTIALIAS
    driver->antialiasing = true;
#endif

#if LV_COLOR_SCREEN_TRANSP
    driver->screen_transp = 1;
#endif

#if LV_USE_GPU
    driver->gpu_blend_cb = NULL;
    driver->gpu_fill_cb  = NULL;
#endif

#if LV_USE_USER_DATA
    driver->user_data = NULL;
#endif

    driver->set_px_cb = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movw $0x140, (%rax)          # imm = 0x140
movq -0x8(%rbp), %rax
movw $0xf0, 0x2(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movw -0xa(%rbp), %cx
andw $-0x20, %cx
orw $0x0, %cx
movw %cx, -0xa(%rbp)
movw -0xa(%rbp), %cx
andw $0xf81f, %cx            # imm = 0xF81F
orw $0x7e0, %cx             # imm = 0x7E0
movw %cx, -0xa(%rbp)
movw -0xa(%rbp), %cx
andw $0x7ff, %cx             # imm = 0x7FF
orw $0x0, %cx
movw %cx, -0xa(%rbp)
movw -0xa(%rbp), %cx
movw %cx, 0x38(%rax)
movq -0x8(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_buf_init
void lv_disp_buf_init(lv_disp_buf_t * disp_buf, void * buf1, void * buf2, uint32_t size_in_px_cnt)
{
    memset(disp_buf, 0, sizeof(lv_disp_buf_t));

    disp_buf->buf1    = buf1;
    disp_buf->buf2    = buf2;
    disp_buf->buf_act = disp_buf->buf1;
    disp_buf->size    = size_in_px_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2090
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_drv_update
void lv_disp_drv_update(lv_disp_t * disp, lv_disp_drv_t * new_drv)
{
    memcpy(&disp->driver, new_drv, sizeof(lv_disp_drv_t));

    lv_obj_t * scr;
    LV_LL_READ(disp->scr_ll, scr)
    {
        lv_obj_set_size(scr, lv_disp_get_hor_res(disp), lv_disp_get_ver_res(disp));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x20e0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x45660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd932
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd940
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd9b0
movq -0x28(%rbp), %rdi
movw -0x1a(%rbp), %cx
movswl %cx, %esi
movswl %ax, %edx
callq 0x8180
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
callq 0x458a0
movq %rax, -0x18(%rbp)
jmp 0xd8e3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_get_hor_res
lv_coord_t lv_disp_get_hor_res(lv_disp_t * disp)
{
    if(disp == NULL) disp = lv_disp_get_default();

    if(disp == NULL)
        return LV_HOR_RES_MAX;
    else
        return disp->driver.rotated == 0 ? disp->driver.hor_res : disp->driver.ver_res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd95c
callq 0xdad0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd96b
movw $0x140, -0x2(%rbp)      # imm = 0x140
jmp 0xd99c
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd98a
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xd995
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_get_ver_res
lv_coord_t lv_disp_get_ver_res(lv_disp_t * disp)
{
    if(disp == NULL) disp = lv_disp_get_default();

    if(disp == NULL)
        return LV_VER_RES_MAX;
    else
        return disp->driver.rotated == 0 ? disp->driver.ver_res : disp->driver.hor_res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd9cc
callq 0xdad0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd9db
movw $0xf0, -0x2(%rbp)
jmp 0xda0c
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd9fb
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xda05
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_remove
void lv_disp_remove(lv_disp_t * disp)
{
    bool was_default = false;
    if(disp == lv_disp_get_default()) was_default = true;

    /*Detach the input devices */
    lv_indev_t * indev;
    indev = lv_indev_get_next(NULL);
    while(indev) {
        if(indev->driver.disp == disp) {
            indev->driver.disp = NULL;
        }
        indev = lv_indev_get_next(indev);
    }

    lv_ll_rem(&LV_GC_ROOT(_lv_disp_ll), disp);
    lv_mem_free(disp);

    if(was_default) lv_disp_set_default(lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xdad0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0xda4d
movb $0x1, -0x9(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xded0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xda8a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xda7b
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0xded0
movq %rax, -0x18(%rbp)
jmp 0xda5a
movq -0x8(%rbp), %rsi
leaq 0x83b33(%rip), %rdi     # 0x915c8
callq 0x45790
movq -0x8(%rbp), %rdi
callq 0x44ec0
testb $0x1, -0x9(%rbp)
je 0xdabd
leaq 0x83b18(%rip), %rdi     # 0x915c8
callq 0x45660
movq %rax, %rdi
callq 0xdae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_is_true_double_buf
bool lv_disp_is_true_double_buf(lv_disp_t * disp)
{
    uint32_t scr_size = disp->driver.hor_res * disp->driver.ver_res;

    if(lv_disp_is_double_buf(disp) && disp->driver.buffer->size == scr_size) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x2(%rcx), %ecx
imull %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc90
testb $0x1, %al
jne 0xdd00
jmp 0xdd16
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xdd16
movb $0x1, -0x1(%rbp)
jmp 0xdd1a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_indev.c
// Function: lv_indev_drv_init
void lv_indev_drv_init(lv_indev_drv_t * driver)
{
    memset(driver, 0, sizeof(lv_indev_drv_t));

    driver->type                = LV_INDEV_TYPE_NONE;
    driver->drag_limit          = LV_INDEV_DEF_DRAG_LIMIT;
    driver->drag_throw          = LV_INDEV_DEF_DRAG_THROW;
    driver->long_press_time     = LV_INDEV_DEF_LONG_PRESS_TIME;
    driver->long_press_rep_time = LV_INDEV_DEF_LONG_PRESS_REP_TIME;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2090
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0xa, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x14, 0x29(%rax)
movq -0x8(%rbp), %rax
movw $0x190, 0x2a(%rax)      # imm = 0x190
movq -0x8(%rbp), %rax
movw $0x64, 0x2c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_indev.c
// Function: lv_indev_drv_register
lv_indev_t * lv_indev_drv_register(lv_indev_drv_t * driver)
{

    if(driver->disp == NULL) driver->disp = lv_disp_get_default();

    if(driver->disp == NULL) {
        LV_LOG_WARN("lv_indev_drv_register: no display registered hence can't attache the indev to "
                    "a display");
        return NULL;
    }

    lv_indev_t * indev = lv_ll_ins_head(&LV_GC_ROOT(_lv_indev_ll));
    if(!indev) {
        LV_ASSERT_MEM(indev);
        return NULL;
    }

    memset(indev, 0, sizeof(lv_indev_t));
    memcpy(&indev->driver, driver, sizeof(lv_indev_drv_t));

    indev->proc.reset_query = 1;
    indev->cursor           = NULL;
    indev->group            = NULL;
    indev->btn_points       = NULL;

    indev->driver.read_task = lv_task_create(lv_indev_read_task, LV_INDEV_DEF_READ_PERIOD, LV_TASK_PRIO_MID, indev);

    return indev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xdda7
callq 0xdad0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xddbf
movq $0x0, -0x8(%rbp)
jmp 0xde8e
leaq 0x8381a(%rip), %rdi     # 0x915e0
callq 0x453f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xde02
movq -0x18(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0xddf5
movq -0x18(%rbp), %rsi
leaq 0x5a256(%rip), %rdi     # 0x68044
callq 0xd410
jmp 0xddf3
movq $0x0, -0x8(%rbp)
jmp 0xde8e
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2090
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x30, %edx
callq 0x20e0
movq -0x18(%rbp), %rax
movb 0x78(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x78(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x18(%rbp), %rcx
leaq -0xa39c(%rip), %rdi     # 0x3ad0
movl $0x1e, %esi
movl $0x3, %edx
callq 0x430d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)