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

    if(lv_obj_get_hidden(obj)) return;

    /*Invalidate the object only if it belongs to the 'LV_GC_ROOT(_lv_act_scr)'*/
    lv_obj_t * obj_scr = lv_obj_get_screen(obj);
    lv_disp_t * disp   = lv_obj_get_disp(obj_scr);
    if(obj_scr == lv_disp_get_scr_act(disp) || obj_scr == lv_disp_get_layer_top(disp) ||
       obj_scr == lv_disp_get_layer_sys(disp)) {
        /*Truncate recursively to the parents*/
        lv_area_t area_trunc;
        lv_obj_t * par = lv_obj_get_parent(obj);
        bool union_ok  = true;
        /*Start with the original coordinates*/
        lv_coord_t ext_size = obj->ext_draw_pad;
        lv_area_copy(&area_trunc, &obj->coords);
        area_trunc.x1 -= ext_size;
        area_trunc.y1 -= ext_size;
        area_trunc.x2 += ext_size;
        area_trunc.y2 += ext_size;

        /*Check through all parents*/
        while(par != NULL) {
            union_ok = lv_area_intersect(&area_trunc, &area_trunc, &par->coords);
            if(union_ok == false) break;       /*If no common parts with parent break;*/
            if(lv_obj_get_hidden(par)) return; /*If the parent is hidden then the child is hidden and won't be drawn*/

            par = lv_obj_get_parent(par);
        }

        if(union_ok) lv_inv_area(disp, &area_trunc);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x4d48
movq %r14, %rdi
callq 0x51f2
testb %al, %al
jne 0x4d3e
movq %r14, %rdi
callq 0x521a
movq %rax, %r15
movq %rax, %rdi
callq 0x5061
movq %rax, %rbx
movq %rax, %rdi
callq 0x43c0
cmpq %rax, %r15
je 0x4cb7
movq %rbx, %rdi
callq 0x43f3
cmpq %rax, %r15
je 0x4cb7
movq %rbx, %rdi
callq 0x4410
cmpq %rax, %r15
jne 0x4d3e
movq %r14, %rdi
callq 0x4ab5
movq %rax, %r15
movl 0x5c(%r14), %eax
movq 0x20(%r14), %rcx
movl %ecx, %edx
subl %eax, %edx
movw %dx, 0x8(%rsp)
movl %ecx, %edx
shrl $0x10, %edx
subl %eax, %edx
movw %dx, 0xa(%rsp)
movq %rcx, %rdx
shrq $0x20, %rdx
addl %eax, %edx
movw %dx, 0xc(%rsp)
shrq $0x30, %rcx
addl %eax, %ecx
movw %cx, 0xe(%rsp)
testq %r15, %r15
je 0x4d31
leaq 0x8(%rsp), %r14
leaq 0x20(%r15), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x28d24
testb %al, %al
je 0x4d3e
movq %r15, %rdi
callq 0x51f2
testb %al, %al
jne 0x4d3e
movq %r15, %rdi
callq 0x4ab5
movq %rax, %r15
testq %rax, %rax
jne 0x4d02
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7170
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3a495(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x4d57
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_event_send
lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data)
{
    if(obj == NULL) return LV_RES_OK;

    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_res_t res;
    res = lv_event_send_func(obj->event_cb, obj, event, data);
    return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5049
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5050
movq 0x28(%rbx), %rdi
movzbl %bpl, %edx
movq %rbx, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x6393
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3a18d(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x505f
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_disp
lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    const lv_obj_t * scr;

    if(obj->par == NULL)
        scr = obj; /*`obj` is a screen*/
    else
        scr = lv_obj_get_screen(obj); /*get the screen of `obj`*/

    lv_disp_t * d;
    LV_LL_READ(LV_GC_ROOT(_lv_disp_ll), d)
    {
        lv_obj_t * s;
        LV_LL_READ(d->scr_ll, s)
        {
            if(s == scr) return d;
        }
    }

    LV_LOG_WARN("lv_scr_get_disp: screen not found")
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x50e9
cmpq $0x0, (%rbx)
je 0x5086
movq %rbx, %rdi
callq 0x521a
movq %rax, %rbx
leaq 0x6346b(%rip), %rdi     # 0x684f8
callq 0x2a35c
testq %rax, %rax
je 0x50d7
movq %rax, %r14
leaq 0x63457(%rip), %r15     # 0x684f8
leaq 0x48(%r14), %r12
movq %r12, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x50c4
cmpq %rbx, %rax
je 0x50da
movq %r12, %rdi
movq %rax, %rsi
callq 0x2a448
jmp 0x50ad
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a448
movq %rax, %r14
testq %rax, %rax
jne 0x50a1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3a0f4(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x50f8
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_clean
void lv_obj_clean(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
    lv_obj_t * child = lv_obj_get_child(obj, NULL);
    lv_obj_t * child_next;
    while(child) {
        /* Read the next child before deleting the current
         * because the next couldn't be read from a deleted (invalid) node*/
        child_next = lv_obj_get_child(obj, child);
        lv_obj_del(child);
        child = child_next;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5196
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51a7
testq %rax, %rax
je 0x5190
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a7
movq %rax, %r15
movq %r14, %rdi
callq 0x4d59
movq %r15, %r14
testq %r15, %r15
jne 0x5172
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3a047(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x51a5
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_child
lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, const lv_obj_t * child)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * result = NULL;

    if(child == NULL) {
        result = lv_ll_get_head(&obj->child_ll);
    } else {
        result = lv_ll_get_next(&obj->child_ll, child);
    }

    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x51d5
addq $0x8, %rbx
movq %rbx, %rdi
testq %r14, %r14
je 0x51e6
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a448
leaq 0x3a008(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x51e4
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a35c
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_screen
lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    const lv_obj_t * par = obj;
    const lv_obj_t * act_p;

    do {
        act_p = par;
        par   = lv_obj_get_parent(act_p);
    } while(par != NULL);

    return (lv_obj_t *)act_p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5248
movq %rbx, %r14
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %rbx
testq %rax, %rax
jne 0x522a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x39f95(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5257
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_parent
void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
    LV_ASSERT_OBJ(parent, LV_OBJX_NAME);

    if(obj->par == NULL) {
        LV_LOG_WARN("Can't set the parent of a screen");
        return;
    }

    if(parent == NULL) {
        LV_LOG_WARN("Can't set parent == NULL to an object");
        return;
    }

    lv_obj_invalidate(obj);

    lv_point_t old_pos;
    old_pos.x = lv_obj_get_x(obj);
    old_pos.y = lv_obj_get_y(obj);

    lv_obj_t * old_par = obj->par;

    lv_ll_chg_list(&obj->par->child_ll, &parent->child_ll, obj, true);
    obj->par = parent;
    lv_obj_set_pos(obj, old_pos.x, old_pos.y);

    /*Notify the original parent because one of its children is lost*/
    old_par->signal_cb(old_par, LV_SIGNAL_CHILD_CHG, NULL);

    /*Notify the new parent about the child*/
    parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);

    lv_obj_invalidate(obj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x530d
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x531e
testq %r14, %r14
je 0x532f
cmpq $0x0, (%rbx)
je 0x532f
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x4bdd
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4c15
movl %eax, %r15d
movq (%rbx), %r12
leaq 0x8(%r12), %rdi
leaq 0x8(%r14), %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2a4ad
movq %r14, (%rbx)
movswl %bp, %esi
movswl %r15w, %edx
movq %rbx, %rdi
callq 0x4ad8
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x30(%r12)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *0x30(%r14)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
leaq 0x39ed0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x531c
leaq 0x39ebf(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x532d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_move_foreground
void lv_obj_move_foreground(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * parent = lv_obj_get_parent(obj);

    /*Do nothing of already in the foreground*/
    if(lv_ll_get_head(&parent->child_ll) == obj) return;

    lv_obj_invalidate(parent);

    lv_ll_chg_list(&parent->child_ll, &parent->child_ll, obj, true);

    /*Notify the new parent about the child*/
    parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);

    lv_obj_invalidate(parent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x539c
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %r14
leaq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x2a35c
cmpq %rbx, %rax
je 0x53ad
movq %r14, %rdi
callq 0x4c4d
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2a4ad
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *0x30(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4c4d
leaq 0x39e41(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x53ab
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_move_background
void lv_obj_move_background(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * parent = lv_obj_get_parent(obj);

    /*Do nothing of already in the background*/
    if(lv_ll_get_tail(&parent->child_ll) == obj) return;

    lv_obj_invalidate(parent);

    lv_ll_chg_list(&parent->child_ll, &parent->child_ll, obj, false);

    /*Notify the new parent about the child*/
    parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);

    lv_obj_invalidate(parent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5414
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %r14
leaq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x2a458
cmpq %rbx, %rax
je 0x5425
movq %r14, %rdi
callq 0x4c4d
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2a4ad
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *0x30(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4c4d
leaq 0x39dc9(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5423
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: refresh_children_position
static void refresh_children_position(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff)
{
    lv_obj_t * i;
    LV_LL_READ(obj->child_ll, i)
    {
        i->coords.x1 += x_diff;
        i->coords.y1 += y_diff;
        i->coords.x2 += x_diff;
        i->coords.y2 += y_diff;

        refresh_children_position(i, x_diff, y_diff);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x54d0
movq %rax, %r14
movd %ebp, %xmm0
pinsrw $0x1, %r15d, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movdqa %xmm0, (%rsp)
movswl %bp, %ebp
movswl %r15w, %r15d
movq 0x20(%r14), %xmm0
paddw (%rsp), %xmm0
movq %xmm0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x545e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a448
movq %rax, %r14
testq %rax, %rax
jne 0x549f
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_size
void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);


    /* Do nothing if the size is not changed */
    /* It is very important else recursive resizing can
     * occur without size change*/
    if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
        return;
    }

    /*Invalidate the original area*/
    lv_obj_invalidate(obj);

    /*Save the original coordinates*/
    lv_area_t ori;
    lv_obj_get_coords(obj, &ori);

    /*Set the length and height*/
    obj->coords.y2 = obj->coords.y1 + h - 1;
    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
        obj->coords.x1 = obj->coords.x2 - w + 1;
    } else {
        obj->coords.x2 = obj->coords.x1 + w - 1;
    }

    /*Send a signal to the object with its new coordinates*/
    obj->signal_cb(obj, LV_SIGNAL_CORD_CHG, &ori);

    /*Send a signal to the parent too*/
    lv_obj_t * par = lv_obj_get_parent(obj);
    if(par != NULL) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);

    /*Tell the children the parent's size has changed*/
    lv_obj_t * i;
    LV_LL_READ(obj->child_ll, i)
    {
        i->signal_cb(i, LV_SIGNAL_PARENT_SIZE_CHG, NULL);
    }

    /*Invalidate the new area*/
    lv_obj_invalidate(obj);

    /*Automatically realign the object if required*/
#if LV_USE_OBJ_REALIGN
    if(obj->realign.auto_realign) lv_obj_realign(obj);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x564b
movq %rbx, %rdi
callq 0x566d
cmpw %r15w, %ax
jne 0x5596
movq %rbx, %rdi
callq 0x5697
cmpw %r14w, %ax
je 0x5641
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x565c
movq 0x20(%rbx), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leal (%r15,%rax), %ecx
decl %ecx
shrl $0x10, %eax
addl %r14d, %eax
decl %eax
movw %ax, 0x26(%rbx)
movw %cx, 0x24(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
callq *0x30(%rbx)
movq %rbx, %rdi
callq 0x4ab5
testq %rax, %rax
je 0x55f6
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *0x30(%rax)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x562b
movq %rax, %r15
movq %r15, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq *0x30(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a448
movq %rax, %r15
testq %rax, %rax
jne 0x560a
movq %rbx, %rdi
callq 0x4c4d
testb $0x1, 0x6d(%rbx)
je 0x5641
movq %rbx, %rdi
callq 0x56c1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x39b92(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x565a
leaq 0x39b81(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x566b
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_realign
void lv_obj_realign(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

#if LV_USE_OBJ_REALIGN
    if(obj->realign.origo_align)
        lv_obj_align_origo(obj, obj->realign.base, obj->realign.align, obj->realign.xofs, obj->realign.yofs);
    else
        lv_obj_align(obj, obj->realign.base, obj->realign.align, obj->realign.xofs, obj->realign.yofs);
#else
    (void)obj;
    LV_LOG_WARN("lv_obj_realaign: no effect because LV_USE_OBJ_REALIGN = 0");
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x56f6
testb $0x2, 0x6d(%rbx)
movq 0x60(%rbx), %rsi
movb 0x6c(%rbx), %dl
movzwl 0x68(%rbx), %ecx
movzwl 0x6a(%rbx), %eax
movzbl %dl, %edx
movswl %cx, %ecx
movswl %ax, %r8d
movq %rbx, %rdi
jne 0x5707
popq %rbx
jmp 0x5789
leaq 0x39ae7(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5705
popq %rbx
jmp 0x5b21
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_style
void lv_obj_set_style(lv_obj_t * obj, const lv_style_t * style)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
    LV_ASSERT_STYLE(style);

    obj->style_p = style;

    /*Send a signal about style change to every children with NULL style*/
    refresh_children_style(obj);

    /*Notify the object about the style change too*/
    lv_obj_refresh_style(obj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5dd9
movq %r14, %rdi
callq 0x822c
testb %al, %al
je 0x5dea
movq %r14, 0x48(%rbx)
movq %rbx, %rdi
callq 0x5dfb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e54
leaq 0x39404(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5de8
leaq 0x39400(%rip), %rdi     # 0x3f1f1
movq %r14, %rsi
callq 0x8294
jmp 0x5df9
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: refresh_children_style
static void refresh_children_style(lv_obj_t * obj)
{
    lv_obj_t * child = lv_obj_get_child(obj, NULL);
    while(child != NULL) {
        if(child->style_p == NULL) {
            refresh_children_style(child); /*Check children too*/
            lv_obj_refresh_style(child);   /*Notify the child about the style change*/
        } else if(child->style_p->glass) {
            /*Children with 'glass' parent might be effected if their style == NULL*/
            refresh_children_style(child);
        }
        child = lv_obj_get_child(obj, child);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x51a7
testq %rax, %rax
je 0x5e4c
movq %rax, %r14
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5e29
testb $0x1, (%rax)
je 0x5e39
movq %r14, %rdi
callq 0x5dfb
jmp 0x5e39
movq %r14, %rdi
callq 0x5dfb
movq %r14, %rdi
callq 0x5e54
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a7
movq %rax, %r14
testq %rax, %rax
jne 0x5e11
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_refresh_style
void lv_obj_refresh_style(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_invalidate(obj);
    obj->signal_cb(obj, LV_SIGNAL_STYLE_CHG, NULL);
    lv_obj_invalidate(obj);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5e7f
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq *0x30(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4c4d
leaq 0x3935e(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5e8e
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_report_style_mod
void lv_obj_report_style_mod(lv_style_t * style)
{
    LV_ASSERT_STYLE(style);

    lv_disp_t * d = lv_disp_get_next(NULL);

    while(d) {
        lv_obj_t * i;
        LV_LL_READ(d->scr_ll, i)
        {
            if(i->style_p == style || style == NULL) {
                lv_obj_refresh_style(i);
            }

            report_style_mod_core(style, i);
        }
        d = lv_disp_get_next(d);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x822c
testb %al, %al
je 0x5f15
xorl %edi, %edi
callq 0x85b8
testq %rax, %rax
je 0x5f09
movq %rax, %r14
leaq 0x48(%r14), %r15
movq %r15, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x5ef9
movq %rax, %r12
testq %rbx, %rbx
je 0x5ed3
cmpq %rbx, 0x48(%r12)
jne 0x5edb
movq %r12, %rdi
callq 0x5e54
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5f26
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a448
movq %rax, %r12
testq %rax, %rax
jne 0x5ec7
movq %r14, %rdi
callq 0x85b8
movq %rax, %r14
testq %rax, %rax
jne 0x5eb3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x392d5(%rip), %rdi     # 0x3f1f1
movq %rbx, %rsi
callq 0x8294
jmp 0x5f24
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: report_style_mod_core
static void report_style_mod_core(void * style_p, lv_obj_t * obj)
{
    lv_obj_t * i;
    LV_LL_READ(obj->child_ll, i)
    {
        if(i->style_p == style_p || style_p == NULL) {
            refresh_children_style(i);
            lv_obj_refresh_style(i);
        }

        report_style_mod_core(style_p, i);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x5f7e
movq %rax, %r15
testq %r14, %r14
je 0x5f50
cmpq %r14, 0x48(%r15)
jne 0x5f60
movq %r15, %rdi
callq 0x5dfb
movq %r15, %rdi
callq 0x5e54
movq %r14, %rdi
movq %r15, %rsi
callq 0x5f26
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a448
movq %rax, %r15
testq %rax, %rax
jne 0x5f45
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_hidden
void lv_obj_set_hidden(lv_obj_t * obj, bool en)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    if(!obj->hidden) lv_obj_invalidate(obj); /*Invalidate when not hidden (hidden objects are ignored) */

    obj->hidden = en == false ? 0 : 1;

    if(!obj->hidden) lv_obj_invalidate(obj); /*Invalidate when not hidden (hidden objects are ignored) */

    lv_obj_t * par = lv_obj_get_parent(obj);
    par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x5fe6
movzwl 0x58(%rbx), %eax
testb $0x10, %al
jne 0x5fa9
movq %rbx, %rdi
callq 0x4c4d
movzwl 0x58(%rbx), %eax
movzbl %bpl, %ecx
movl %ecx, %edx
shll $0x4, %edx
andl $-0x11, %eax
orl %edx, %eax
movw %ax, 0x58(%rbx)
testb %cl, %cl
jne 0x5fc7
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x4ab5
movq 0x30(%rax), %rcx
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
leaq 0x391f7(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x5ff5
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_base_dir
void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir)
{
    if(dir != LV_BIDI_DIR_LTR && dir != LV_BIDI_DIR_RTL &&
       dir != LV_BIDI_DIR_AUTO && dir != LV_BIDI_DIR_INHERIT) {

        LV_LOG_WARN("lv_obj_set_base_dir: invalid base dir");
        return;
    }

    obj->base_dir = dir;
    lv_signal_send(obj, LV_SIGNAL_BASE_DIR_CHG, NULL);

    /* Notify the children about the parent base dir has changed.
     * (The children might have `LV_BIDI_DIR_INHERIT`)*/
    base_dir_refr_children(obj);
}

// Assembly:
cmpb $0x3, %sil
jbe 0x61d2
retq
pushq %rbx
movq %rdi, %rbx
movzbl %sil, %eax
shll $0xa, %eax
movl $0xfffff3ff, %ecx       # imm = 0xFFFFF3FF
andl 0x58(%rdi), %ecx
orl %eax, %ecx
movw %cx, 0x58(%rdi)
movl $0x5, %esi
xorl %edx, %edx
callq 0x61fd
movq %rbx, %rdi
popq %rbx
jmp 0x6241
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: base_dir_refr_children
static void base_dir_refr_children(lv_obj_t * obj)
{
    lv_obj_t * child;
    child = lv_obj_get_child(obj, NULL);

    while(child) {
        if(child->base_dir == LV_BIDI_DIR_INHERIT) {
            lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
            base_dir_refr_children(child);
        }

        child = lv_obj_get_child(obj, child);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x51a7
testq %rax, %rax
je 0x628e
movq %rax, %r14
movl 0x58(%r14), %eax
notl %eax
testl $0xc00, %eax            # imm = 0xC00
jne 0x627b
movq %r14, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x61fd
movq %r14, %rdi
callq 0x6241
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a7
movq %rax, %r14
testq %rax, %rax
jne 0x6257
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_event_send_func
lv_res_t lv_event_send_func(lv_event_cb_t event_xcb, lv_obj_t * obj, lv_event_t event, const void * data)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    /* Build a simple linked list from the objects used in the events
     * It's important to know if an this object was deleted by a nested event
     * called from this `even_cb`. */
    lv_event_temp_data_t event_temp_data;
    event_temp_data.obj     = obj;
    event_temp_data.deleted = false;
    event_temp_data.prev    = NULL;

    if(event_temp_data_head) {
        event_temp_data.prev = event_temp_data_head;
    }
    event_temp_data_head = &event_temp_data;

    const void * event_act_data_save = event_act_data;
    event_act_data                   = data;

    /*Call the input device's feedback callback if set*/
    lv_indev_t * indev_act = lv_indev_get_act();
    if(indev_act) {
        if(indev_act->driver.feedback_cb) indev_act->driver.feedback_cb(&indev_act->driver, event);
    }

    /*Call the event callback itself*/
    if(event_xcb) event_xcb(obj, event);

    /*Restore the event data*/
    event_act_data = event_act_data_save;

    /*Remove this element from the list*/
    event_temp_data_head = event_temp_data_head->prev;

    if(event_temp_data.deleted) {
        return LV_RES_INV;
    }

    if(obj) {
        if(obj->parent_event && obj->par) {
            lv_res_t res = lv_event_send(obj->par, event, data);
            if(res != LV_RES_OK) {
                return LV_RES_INV;
            }
        }
    }

    return LV_RES_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x80e4
testb %al, %al
je 0x6431
leaq 0x8(%rsp), %rax
movq %r14, (%rax)
movb $0x0, 0x8(%rax)
movq 0x59ae7(%rip), %rcx     # 0x5feb0
movq %rcx, 0x10(%rax)
movq %rax, 0x59adc(%rip)     # 0x5feb0
movq 0x59add(%rip), %r12     # 0x5feb8
movq %rbx, 0x59ad6(%rip)     # 0x5feb8
callq 0x378a
movzbl %bpl, %ebp
testq %rax, %rax
je 0x6400
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6400
movq %rax, %rdi
movl %ebp, %esi
callq *%rcx
testq %r15, %r15
je 0x640d
movq %r14, %rdi
movl %ebp, %esi
callq *%r15
movq %r12, 0x59aa4(%rip)     # 0x5feb8
movq 0x59a95(%rip), %rax     # 0x5feb0
movq 0x10(%rax), %rax
movq %rax, 0x59a8a(%rip)     # 0x5feb0
cmpb $0x0, 0x10(%rsp)
je 0x6442
xorl %eax, %eax
jmp 0x6466
leaq 0x38dac(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x6440
testq %r14, %r14
je 0x6464
testb $-0x80, 0x58(%r14)
je 0x6464
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6464
movl %ebp, %esi
movq %rbx, %rdx
callq 0x5018
testb %al, %al
je 0x642d
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_refresh_ext_draw_pad
void lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    obj->ext_draw_pad = 0;
    obj->signal_cb(obj, LV_SIGNAL_REFR_EXT_DRAW_PAD, NULL);

    lv_obj_invalidate(obj);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x653d
movw $0x0, 0x5c(%rbx)
movq %rbx, %rdi
movl $0x6, %esi
xorl %edx, %edx
callq *0x30(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4c4d
leaq 0x38ca0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x654c
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_child_back
lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_obj_t * result = NULL;

    if(child == NULL) {
        result = lv_ll_get_tail(&obj->child_ll);
    } else {
        result = lv_ll_get_prev(&obj->child_ll, child);
    }

    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x657c
addq $0x8, %rbx
movq %rbx, %rdi
testq %r14, %r14
je 0x658d
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a369
leaq 0x38c61(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x658b
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a458
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x65ca
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2a35c
xorl %ebp, %ebp
testq %rax, %rax
je 0x65db
incl %ebp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a448
jmp 0x65b6
leaq 0x38c13(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x65d9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x662f
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x6640
movq %rax, %r15
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x65e4
addl %eax, %r14d
incl %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a448
movq %rax, %r15
testq %rax, %rax
jne 0x660c
jmp 0x6643
leaq 0x38bae(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x663e
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x66a5
movq %r14, %rdi
callq 0x66b6
movb 0xe(%rax), %cl
testb $0x4, %cl
je 0x6676
movzwl 0xc(%rax), %edx
addw %dx, (%rbx)
testb $0x8, %cl
je 0x6683
movzwl 0xc(%rax), %edx
subw %dx, 0x4(%rbx)
testb $0x2, %cl
je 0x6690
movzwl 0xc(%rax), %edx
addw %dx, 0x2(%rbx)
testb $0x1, %cl
je 0x669d
movzwl 0xc(%rax), %eax
subw %ax, 0x6(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38b38(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x66b4
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x6710
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x6721
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x66f5
callq 0x2a19
cmpq %rbx, %rax
jne 0x66f5
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x2aa5
movq %rax, %r14
testq %r14, %r14
jne 0x6701
leaq 0x59817(%rip), %r14     # 0x5ff18
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38acd(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x671f
movq (%rbx), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x66d3
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x673a
testb $0x1, (%rax)
je 0x673f
movq (%r15), %r15
jmp 0x6727
movq %r15, %rdi
callq 0x4ed1
movq %rax, %r12
movq %rax, %rdi
callq 0x2a19
movq 0x48(%r15), %r14
cmpq %r15, %rax
jne 0x66d3
movq %r12, %rdi
movq %r14, %rsi
callq 0x2aa5
movq %rax, %r14
jmp 0x66d3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x6a1a
movb $-0x1, %bpl
testq %rbx, %rbx
je 0x6a2f
testb $0x40, 0x58(%rbx)
jne 0x6a2b
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %rbx
testq %rax, %rax
jne 0x6a02
jmp 0x6a2f
leaq 0x387c3(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x6a29
movb 0x5b(%rbx), %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x80e4
testb %al, %al
je 0x6b89
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x6b9a
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rsp, %rdx
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rdi
movl $0x7, %esi
callq *0x30(%r14)
xorl %eax, %eax
cmpq $0x0, (%rsp,%rax,8)
je 0x6bab
incq %rax
cmpq $0x8, %rax
jne 0x6b72
movl $0x8, %eax
jmp 0x6bb0
leaq 0x38654(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x6b98
leaq 0x38643(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x6ba9
testq %rax, %rax
je 0x6bc1
movq -0x8(%rsp,%rax,8), %rcx
movq %rcx, (%rbx)
addq $0x8, %rbx
decq %rax
jne 0x6bb0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x6bed
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x6be9
callq 0x2a19
cmpq %rbx, %rax
je 0x6bfe
xorl %eax, %eax
jmp 0x6c00
leaq 0x385f0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x6bfc
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpq $0x0, (%rdi,%rax,8)
je 0x6c19
incq %rax
cmpq $0x7, %rax
jne 0x6c04
movl $0x7, %eax
movzbl %al, %eax
movq %rsi, (%rdi,%rax,8)
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x6c33
movq 0x40(%rdi), %rdi
jmp 0x6c5e
pushq %rbx
xorl %edi, %edi
callq 0x85b8
testq %rax, %rax
je 0x6c5c
movq %rax, %rbx
movq 0x40(%rbx), %rdi
callq 0x6c5e
movq %rbx, %rdi
callq 0x85b8
movq %rax, %rbx
testq %rax, %rax
jne 0x6c43
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_refr.c
// Function: lv_inv_area
void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) return;

    /*Clear the invalidate buffer if the parameter is NULL*/
    if(area_p == NULL) {
        disp->inv_p = 0;
        return;
    }

    lv_area_t scr_area;
    scr_area.x1 = 0;
    scr_area.y1 = 0;
    scr_area.x2 = lv_disp_get_hor_res(disp) - 1;
    scr_area.y2 = lv_disp_get_ver_res(disp) - 1;

    lv_area_t com_area;
    bool suc;

    suc = lv_area_intersect(&com_area, area_p, &scr_area);

    /*The area is truncated to the screen*/
    if(suc != false) {
        if(disp->driver.rounder_cb) disp->driver.rounder_cb(&disp->driver, &com_area);

        /*Save only if this area is not in one of the saved areas*/
        uint16_t i;
        for(i = 0; i < disp->inv_p; i++) {
            if(lv_area_is_in(&com_area, &disp->inv_areas[i]) != false) return;
        }

        /*Save the area*/
        if(disp->inv_p < LV_INV_BUF_SIZE) {
            lv_area_copy(&disp->inv_areas[disp->inv_p], &com_area);
        } else { /*If no place for the area add the screen*/
            disp->inv_p = 0;
            lv_area_copy(&disp->inv_areas[disp->inv_p], &scr_area);
        }
        disp->inv_p++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x7197
callq 0x8585
movq %rax, %rbx
testq %rax, %rax
je 0x7287
testq %r14, %r14
je 0x724f
leaq 0x10(%rsp), %r15
movl $0x0, (%r15)
movq %rbx, %rdi
callq 0x84dc
decl %eax
movw %ax, 0x4(%r15)
movq %rbx, %rdi
callq 0x84fe
decl %eax
movw %ax, 0x6(%r15)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28d24
testb %al, %al
je 0x7287
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x71f5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *%rax
movzwl 0x198(%rbx), %eax
testl $0x3ff, %eax            # imm = 0x3FF
je 0x725a
leaq 0x78(%rbx), %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28dd5
testb %al, %al
jne 0x7287
incq %r12
movzwl 0x198(%rbx), %eax
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
addq $0x8, %r14
cmpq %rcx, %r12
jb 0x720f
cmpw $0x1f, %cx
jbe 0x725c
andl $0xfc00, %eax           # imm = 0xFC00
movq 0x10(%rsp), %rcx
movq %rcx, 0x78(%rbx)
jmp 0x7270
andw $0xfc00, 0x198(%rbx)    # imm = 0xFC00
jmp 0x7287
xorl %ecx, %ecx
movzwl %cx, %eax
movq 0x8(%rsp), %rcx
movq %rcx, 0x78(%rbx,%rax,8)
movzwl 0x198(%rbx), %eax
leal 0x1(%rax), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
andl $0xfffffc00, %eax       # imm = 0xFFFFFC00
orl %ecx, %eax
movw %ax, 0x198(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x58c15(%rip), %rdi     # 0x5fec0
callq 0x85d8
movq %rax, %rbx
movq 0x58c06(%rip), %rdi     # 0x5fec0
callq 0x861e
testb %al, %al
je 0x72c9
testb $0x1, 0x24(%rbx)
jne 0x72c3
orb $0x1, 0x24(%rbx)
movq 0x58bec(%rip), %rdi     # 0x5fec0
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x72ea
movq %rbx, %rsi
addq $0x1c, %rsi
movq 0x10(%rbx), %rdx
callq *%rax
movq (%rbx), %rax
testq %rax, %rax
je 0x7307
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7307
cmpq %rax, 0x10(%rbx)
cmovneq %rax, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x58ba4(%rip), %rdi     # 0x5fec0
callq 0x85d8
movq %rax, %r15
movq 0x58b95(%rip), %rdi     # 0x5fec0
callq 0x861e
testb %al, %al
jne 0x733b
testb $0x1, 0x24(%r15)
jne 0x7334
addq $0x1c, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28d24
movq 0x58b67(%rip), %rdi     # 0x5fec0
callq 0x43c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73c1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x745c
movq 0x58b45(%rip), %rdi     # 0x5fec0
callq 0x43f3
movq %rax, %rdi
movq %rbx, %rsi
callq 0x745c
movq 0x58b2e(%rip), %rdi     # 0x5fec0
callq 0x4410
movq %rax, %rdi
movq %rbx, %rsi
callq 0x745c
movq 0x58b17(%rip), %rdi     # 0x5fec0
callq 0x8635
testb %al, %al
jne 0x73b7
callq 0x72a3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rsi
callq 0x28dd5
testb %al, %al
je 0x744e
testb $0x10, 0x58(%rbx)
jne 0x744e
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x7419
movq %rax, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x73c1
testq %rax, %rax
jne 0x7450
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a448
movq %rax, %r12
testq %rax, %rax
jne 0x73f6
movq %rbx, %rdi
callq 0x66b6
cmpb $-0x1, 0x8(%rax)
jne 0x744e
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq *0x38(%rbx)
testb %al, %al
je 0x744e
movq %rbx, %rdi
callq 0x69eb
movl %eax, %ecx
xorl %eax, %eax
cmpb $-0x1, %cl
cmoveq %rbx, %rax
jmp 0x7450
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
jne 0x747e
movq 0x58a4a(%rip), %rdi     # 0x5fec0
callq 0x43c0
movq %rax, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74fc
movq %r15, %rdi
callq 0x4ab5
testq %rax, %rax
je 0x74f0
movq %rax, %r14
leaq 0x8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a369
testq %rax, %rax
je 0x74ce
movq %rax, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74fc
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a369
movq %rax, %r15
testq %rax, %rax
jne 0x74b0
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq *0x38(%r14)
movq %r14, %rdi
callq 0x4ab5
movq %r14, %r15
movq %rax, %r14
testq %rax, %rax
jne 0x7499
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq