LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x65ab
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x29cce
xorl %ebp, %ebp
testq %rax, %rax
je 0x65bc
incl %ebp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29dfb
jmp 0x6597
leaq 0x38b82(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x65ba
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x6610
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x29cce
testq %rax, %rax
je 0x6621
movq %rax, %r15
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x65c5
addl %eax, %r14d
incl %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29dfb
movq %rax, %r15
testq %rax, %rax
jne 0x65ed
jmp 0x6624
leaq 0x38b1d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x661f
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x6686
movq %r14, %rdi
callq 0x6697
movb 0xe(%rax), %cl
testb $0x4, %cl
je 0x6657
movzwl 0xc(%rax), %edx
addw %dx, (%rbx)
testb $0x8, %cl
je 0x6664
movzwl 0xc(%rax), %edx
subw %dx, 0x4(%rbx)
testb $0x2, %cl
je 0x6671
movzwl 0xc(%rax), %edx
addw %dx, 0x2(%rbx)
testb $0x1, %cl
je 0x667e
movzwl 0xc(%rax), %eax
subw %ax, 0x6(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38aa7(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x6695
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x66f1
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x6702
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x66d6
callq 0x2a39
cmpq %rbx, %rax
jne 0x66d6
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x2ac5
movq %rax, %r14
testq %r14, %r14
jne 0x66e2
leaq 0x59836(%rip), %r14     # 0x5ff18
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38a3c(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x6700
movq (%rbx), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x66b4
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x671b
testb $0x1, (%rax)
je 0x6720
movq (%r15), %r15
jmp 0x6708
movq %r15, %rdi
callq 0x4ea3
movq %rax, %r12
movq %rax, %rdi
callq 0x2a39
movq 0x48(%r15), %r14
cmpq %r15, %rax
jne 0x66b4
movq %r12, %rdi
movq %r14, %rsi
callq 0x2ac5
movq %rax, %r14
jmp 0x66b4
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x69fb
movb $-0x1, %bpl
testq %rbx, %rbx
je 0x6a10
testb $0x40, 0x58(%rbx)
jne 0x6a0c
movq %rbx, %rdi
callq 0x4abf
movq %rax, %rbx
testq %rax, %rax
jne 0x69e3
jmp 0x6a10
leaq 0x38732(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x6a0a
movb 0x5b(%rbx), %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x6b6c
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x6b7d
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 0x6b8e
incq %rax
cmpq $0x8, %rax
jne 0x6b53
movl $0x8, %eax
movb $0x8, %cl
jmp 0x6b90
leaq 0x385c1(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x6b7b
leaq 0x385b0(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x6b8c
movl %eax, %ecx
testb %cl, %cl
je 0x6bb4
movzbl %cl, %ecx
leaq (%rsp,%rax,8), %rax
addq $-0x8, %rax
xorl %edx, %edx
movq (%rax), %rsi
movq %rsi, (%rbx,%rdx,8)
incq %rdx
addq $-0x8, %rax
cmpq %rdx, %rcx
jne 0x6ba1
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x80d4
testb %al, %al
je 0x6be0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x6bdc
callq 0x2a39
cmpq %rbx, %rax
je 0x6bf1
xorl %eax, %eax
jmp 0x6bf3
leaq 0x3854d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x6bef
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6c0c
incq %rax
cmpq $0x7, %rax
jne 0x6bf7
movl $0x7, %eax
movzbl %al, %eax
movq %rsi, (%rdi,%rax,8)
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x6c27
movq 0x40(%rdi), %rdi
jmp 0x6c52
pushq %rbx
xorl %edi, %edi
callq 0x8640
testq %rax, %rax
je 0x6c50
movq %rax, %rbx
movq 0x40(%rbx), %rdi
callq 0x6c52
movq %rbx, %rdi
callq 0x8640
movq %rax, %rbx
testq %rax, %rax
jne 0x6c37
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x71a2
callq 0x860d
movq %rax, %rbx
testq %rbx, %rbx
je 0x72a1
testq %r14, %r14
je 0x7264
leaq 0x10(%rsp), %r15
movl $0x0, (%r15)
movq %rbx, %rdi
callq 0x8564
decl %eax
movw %ax, 0x4(%r15)
movq %rbx, %rdi
callq 0x8586
decl %eax
movw %ax, 0x6(%r15)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2865e
testb %al, %al
je 0x72a1
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x7209
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *%rax
movzwl 0x198(%rbx), %eax
movl %eax, %ecx
andw $0x3ff, %cx             # imm = 0x3FF
je 0x724f
leaq 0x78(%rbx), %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28750
testb %al, %al
jne 0x72a1
incq %r12
movzwl 0x198(%rbx), %eax
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
addq $0x8, %r14
cmpq %rcx, %r12
jb 0x7225
cmpw $0x1f, %cx
ja 0x726f
movzwl %cx, %eax
movq 0x8(%rsp), %rcx
movq %rcx, 0x78(%rbx,%rax,8)
jmp 0x7284
andw $0xfc00, 0x198(%rbx)    # imm = 0xFC00
jmp 0x72a1
andl $0xfc00, %eax           # imm = 0xFC00
movw %ax, 0x198(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rbx)
movl 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_O1/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 0x58bfb(%rip), %rdi     # 0x5fec0
callq 0x8660
movq %rax, %rbx
movq 0x58bec(%rip), %rdi     # 0x5fec0
callq 0x86a6
testb %al, %al
je 0x72e3
testb $0x1, 0x24(%rbx)
jne 0x72dd
orb $0x1, 0x24(%rbx)
movq 0x58bd2(%rip), %rdi     # 0x5fec0
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x7304
movq %rbx, %rsi
addq $0x1c, %rsi
movq 0x10(%rbx), %rdx
callq *%rax
movq (%rbx), %rax
testq %rax, %rax
je 0x7321
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7321
cmpq %rax, 0x10(%rbx)
cmovneq %rax, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58b8a(%rip), %rdi     # 0x5fec0
callq 0x8660
movq %rax, %r15
movq 0x58b7b(%rip), %rdi     # 0x5fec0
callq 0x86a6
testb %al, %al
jne 0x7355
testb $0x1, 0x24(%r15)
jne 0x734e
addq $0x1c, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2865e
movq 0x58b4d(%rip), %rdi     # 0x5fec0
callq 0x43d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73db
movq %rax, %rdi
movq %rbx, %rsi
callq 0x747d
movq 0x58b2b(%rip), %rdi     # 0x5fec0
callq 0x4403
movq %rax, %rdi
movq %rbx, %rsi
callq 0x747d
movq 0x58b14(%rip), %rdi     # 0x5fec0
callq 0x4420
movq %rax, %rdi
movq %rbx, %rsi
callq 0x747d
movq 0x58afd(%rip), %rdi     # 0x5fec0
callq 0x86bd
testb %al, %al
jne 0x73d1
callq 0x72bd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x28750
testb %al, %al
je 0x746f
testb $0x10, 0x58(%rbx)
jne 0x746f
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x29cce
testq %rax, %rax
je 0x7433
movq %rax, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x73db
testq %rax, %rax
jne 0x7435
movq %r15, %rdi
movq %r12, %rsi
callq 0x29dfb
movq %rax, %r12
testq %rax, %rax
jne 0x7410
xorl %eax, %eax
testq %rax, %rax
jne 0x7471
movq %rbx, %rdi
callq 0x6697
cmpb $-0x1, 0x8(%rax)
jne 0x746f
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq *0x38(%rbx)
testb %al, %al
je 0x746f
movq %rbx, %rdi
callq 0x69cc
movl %eax, %ecx
xorl %eax, %eax
cmpb $-0x1, %cl
cmoveq %rbx, %rax
jmp 0x7471
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x749f
movq 0x58a29(%rip), %rdi     # 0x5fec0
callq 0x43d0
movq %rax, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x751d
movq %r15, %rdi
callq 0x4abf
testq %rax, %rax
je 0x7511
movq %rax, %r14
leaq 0x8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x29cdb
testq %rax, %rax
je 0x74ef
movq %rax, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x751d
movq %r12, %rdi
movq %r15, %rsi
callq 0x29cdb
movq %rax, %r15
testq %rax, %rax
jne 0x74d1
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq *0x38(%r14)
movq %r14, %rdi
callq 0x4abf
movq %r14, %r15
movq %rax, %r14
testq %rax, %rax
jne 0x74ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x294bf
movabsq $0x10000000000, %rax    # imm = 0x10000000000
movq %rax, 0x20(%rbx)
leaq 0x86(%rip), %rax        # 0x8052
movq %rax, 0x8(%rbx)
leaq 0x2151e(%rip), %rax     # 0x294f5
movq %rax, 0x10(%rbx)
leaq 0x97(%rip), %rax        # 0x8079
movq %rax, 0x18(%rbx)
movl $0xa0, %edi
callq 0x298d9
movq %rax, %r14
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x8041
testq %r14, %r14
je 0x8039
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
leaq 0x57f02(%rip), %rax     # 0x5ff18
movl $0x9, %ecx
movq %r14, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
addq $0x48, %rdi
movl $0x9, %ecx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x36ff8(%rip), %rdi     # 0x3f040
movq %r14, %rsi
callq 0x829e
jmp 0x8050
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %rax
movq 0x90(%rdi), %rdx
movzwl %si, %ecx
movq %rax, %rsi
callq 0x7996
movq 0x90(%rbx), %rdi
popq %rbx
jmp 0x5e74
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rcx, %rax
movq %rsi, %r8
movq (%rdi), %r9
movq %rsi, 0x90(%r9)
movl $0x9, %ecx
movq %r9, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x48, %r9
movl $0x9, %ecx
movq %r9, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x9, %ecx
movq %r8, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, (%rsi)
je 0x812f
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x6afc
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x20e0
testl %eax, %eax
je 0x8132
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0x7, %rcx
je 0x8126
movq 0x10(%rsp,%r14,8), %rdi
movq %rbx, %rsi
callq 0x20e0
leaq 0x1(%r14), %rcx
testl %eax, %eax
jne 0x8108
cmpq $0x7, %r14
setb %al
jmp 0x8134
movb $0x1, %al
retq
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x8640
movq %rax, %r14
testq %rax, %rax
je 0x81b4
leaq 0x48(%r14), %r15
movq %r15, %rdi
callq 0x29cce
testq %rax, %rax
sete %bpl
je 0x81a6
movq %rax, %r12
movq %r14, %rax
cmpq %rbx, %r12
je 0x81ae
movq %r12, %rdi
movq %rbx, %rsi
callq 0x81c3
testb %al, %al
jne 0x81a1
movq %r15, %rdi
movq %r12, %rsi
callq 0x29dfb
testq %rax, %rax
sete %bpl
je 0x81a6
movq %rax, %r12
cmpq %rbx, %rax
jne 0x8176
movq %r14, %rax
jmp 0x81ae
movq %r14, %rdi
callq 0x8640
testb $0x1, %bpl
jne 0x814e
testq %r14, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %al
testb %al, %al
je 0x8298
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %eax, %esi
cmpb %r9b, %al
jne 0x8274
testb %al, %al
js 0x8267
movl %r9d, %esi
movl %edx, %r8d
jmp 0x8274
incl %edx
movl %r9d, %esi
movl %edx, %r8d
cmpl $0x8, %edx
ja 0x829b
cmpb $0xa, %al
jb 0x829b
movb 0x1(%rdi,%rcx), %al
cmpq $0x1ffe, %rcx           # imm = 0x1FFE
ja 0x8292
incq %rcx
movl %r8d, %edx
movl %esi, %r9d
testb %al, %al
jne 0x824e
testb %al, %al
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movl %ecx, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x29cce
testq %rax, %rax
je 0x855e
movq %rax, %r15
movq %rbx, %rax
testq %rbx, %rbx
jne 0x8510
movq 0x57d68(%rip), %rax     # 0x60278
testq %rax, %rax
je 0x8522
movzbl 0x10(%rax), %ecx
andl $0x2, %ecx
movzwl (%rax,%rcx), %ecx
jmp 0x8526
movw $0x140, %cx             # imm = 0x140
testq %rax, %rax
je 0x8539
movl 0x10(%rax), %edx
notl %edx
andl $0x2, %edx
movzwl (%rax,%rdx), %eax
jmp 0x853d
movw $0xf0, %ax
movswl %cx, %esi
movswl %ax, %edx
movq %r15, %rdi
callq 0x553f
movq %r14, %rdi
movq %r15, %rsi
callq 0x29dfb
movq %rax, %r15
testq %rax, %rax
jne 0x8501
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x57cc1(%rip), %r14     # 0x60278
xorl %edi, %edi
callq 0x87d5
testq %rax, %rax
je 0x85d6
cmpq %rbx, 0x18(%rax)
jne 0x85d1
movq $0x0, 0x18(%rax)
movq %rax, %rdi
jmp 0x85b9
leaq 0x5ff1b(%rip), %rdi     # 0x684f8
movq %rbx, %rsi
callq 0x29d38
movq %rbx, %rdi
callq 0x29984
cmpq %rbx, %r14
jne 0x8605
leaq 0x5feff(%rip), %rdi     # 0x684f8
callq 0x29cce
movq %rax, 0x57c73(%rip)     # 0x60278
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
jne 0x8717
callq 0x860d
movq %rax, 0x18(%r14)
cmpq $0x0, 0x18(%r14)
je 0x8792
leaq 0x5fdeb(%rip), %rdi     # 0x68510
callq 0x29c08
testq %rax, %rax
je 0x8796
movq %rax, %rbx
movl $0x98, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x20a0
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
orb $0x2, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
leaq -0x5856(%rip), %rdi     # 0x2f24
movl $0x1e, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x28a94
movq %rax, 0x20(%rbx)
jmp 0x87a3
xorl %ebx, %ebx
jmp 0x87a3
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x80d4
testb %al, %al
je 0x87ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3688b(%rip), %rdi     # 0x3f040
xorl %esi, %esi
callq 0x829e
jmp 0x87bc
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_arc.c
// Function: lv_arc_create
lv_obj_t * lv_arc_create(lv_obj_t * par, const lv_obj_t * copy)
{

    LV_LOG_TRACE("arc create started");

    /*Create the ancestor of arc*/
    lv_obj_t * new_arc = lv_obj_create(par, copy);
    LV_ASSERT_MEM(new_arc);
    if(new_arc == NULL) return NULL;

    /*Allocate the arc type specific extended data*/
    lv_arc_ext_t * ext = lv_obj_allocate_ext_attr(new_arc, sizeof(lv_arc_ext_t));
    LV_ASSERT_MEM(ext);
    if(ext == NULL) return NULL;

    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(new_arc);
    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(new_arc);

    /*Initialize the allocated 'ext' */
    ext->angle_start = 45;
    ext->angle_end   = 315;

    /*The signal and design functions are not copied so set them here*/
    lv_obj_set_signal_cb(new_arc, lv_arc_signal);
    lv_obj_set_design_cb(new_arc, lv_arc_design);

    /*Init the new arc arc*/
    if(copy == NULL) {
        /*Set the default styles*/
        lv_theme_t * th = lv_theme_get_current();
        if(th) {
            lv_arc_set_style(new_arc, LV_ARC_STYLE_MAIN, th->style.arc);
        } else {
            lv_arc_set_style(new_arc, LV_ARC_STYLE_MAIN, &lv_style_plain_color);
        }

    }
    /*Copy an existing arc*/
    else {
        lv_arc_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
        ext->angle_start        = copy_ext->angle_start;
        ext->angle_end          = copy_ext->angle_end;

        /*Refresh the style with new signal function*/
        lv_obj_refresh_style(new_arc);
    }

    LV_LOG_INFO("arc created");

    return new_arc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x455f
movq %rax, %rbx
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x8940
testq %rbx, %rbx
je 0x8951
movq %rbx, %rdi
movl $0x4, %esi
callq 0x64bc
movq %rax, %r15
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x895c
testq %r15, %r15
je 0x8951
cmpq $0x0, 0x579be(%rip)     # 0x60288
jne 0x88db
movq %rbx, %rdi
callq 0x6a6c
movq %rax, 0x579ad(%rip)     # 0x60288
cmpq $0x0, 0x579ad(%rip)     # 0x60290
jne 0x88f4
movq %rbx, %rdi
callq 0x6a90
movq %rax, 0x5799c(%rip)     # 0x60290
movl $0x13b002d, (%r15)      # imm = 0x13B002D
leaq 0x91(%rip), %rsi        # 0x8993
movq %rbx, %rdi
callq 0x645c
leaq 0xba(%rip), %rsi        # 0x89cb
movq %rbx, %rdi
callq 0x648c
testq %r14, %r14
je 0x896d
movq %r14, %rdi
callq 0x6ad8
movzwl (%rax), %ecx
movw %cx, (%r15)
movzwl 0x2(%rax), %eax
movw %ax, 0x2(%r15)
movq %rbx, %rdi
callq 0x5e38
jmp 0x8953
leaq 0x366f9(%rip), %rdi     # 0x3f040
movq %rbx, %rsi
callq 0x829e
jmp 0x894f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x366dd(%rip), %rdi     # 0x3f040
movq %r15, %rsi
callq 0x829e
jmp 0x896b
callq 0x2e244
testq %rax, %rax
je 0x8980
movq 0xe0(%rax), %rdx
jmp 0x8987
leaq 0x575d9(%rip), %rdx     # 0x5ff60
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8c21
jmp 0x8953
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_arc.c
// Function: lv_arc_set_angles
void lv_arc_set_angles(lv_obj_t * arc, uint16_t start, uint16_t end)
{
    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);

    lv_arc_ext_t * ext = lv_obj_get_ext_attr(arc);

    if(start > 360) start = 360;
    if(end > 360) end = 360;

    ext->angle_start = start;
    ext->angle_end   = end;

    lv_obj_invalidate(arc);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x8ca8
movq %rbx, %rdi
callq 0x6ad8
movzwl %r14w, %ecx
movl $0x168, %edx            # imm = 0x168
cmpl %edx, %ecx
cmovael %edx, %r14d
movzwl %bp, %ecx
cmpl %edx, %ecx
cmovael %edx, %ebp
movw %r14w, (%rax)
movw %bp, 0x2(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c36
leaq 0x36485(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x8cb7
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_arc.c
// Function: lv_arc_get_style
const lv_style_t * lv_arc_get_style(const lv_obj_t * arc, lv_arc_style_t type)
{
    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);

    const lv_style_t * style = NULL;

    switch(type) {
        case LV_ARC_STYLE_MAIN: style = lv_obj_get_style(arc); break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x8d2f
testb %bpl, %bpl
je 0x8d40
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x363fe(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x8d3e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6697
nop
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_signal
static lv_res_t lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(bar, sign, param);
    if(res != LV_RES_OK) return res;
    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);

    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
        const lv_style_t * style_indic = lv_bar_get_style(bar, LV_BAR_STYLE_INDIC);
        if(style_indic->body.shadow.width > bar->ext_draw_pad) bar->ext_draw_pad = style_indic->body.shadow.width;
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq *0x5736a(%rip)          # 0x60298
movl %eax, %ebx
cmpb $0x1, %al
jne 0x8f79
cmpb $0x6, %bpl
je 0x8f5c
movzbl %bpl, %eax
cmpl $0x7, %eax
jne 0x8f79
leaq 0x3622e(%rip), %rsi     # 0x3f178
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
movq %r14, %rdi
movl $0x1, %esi
callq 0x960c
movzwl 0x12(%rax), %eax
cmpw 0x5c(%r14), %ax
jle 0x8f79
movw %ax, 0x5c(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_set_value
void lv_bar_set_value(lv_obj_t * bar, int16_t value, lv_anim_enable_t anim)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

#if LV_USE_ANIMATION == 0
    anim = false;
#endif
    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
    if(ext->cur_value == value) return;

    int16_t new_value;
    new_value = value > ext->max_value ? ext->max_value : value;
    new_value = new_value < ext->min_value ? ext->min_value : new_value;

    if(ext->cur_value == new_value) return;

    if(anim == LV_ANIM_OFF) {
        ext->cur_value = new_value;
        lv_obj_invalidate(bar);
    } else {
#if LV_USE_ANIMATION
        /*No animation in progress -> simply set the values*/
        if(ext->anim_state == LV_BAR_ANIM_STATE_INV) {
            ext->anim_start = ext->cur_value;
            ext->anim_end   = new_value;
        }
        /*Animation in progress. Start from the animation end value*/
        else {
            ext->anim_start = ext->anim_end;
            ext->anim_end   = new_value;
        }

        lv_anim_t a;
        a.var            = bar;
        a.start          = LV_BAR_ANIM_STATE_START;
        a.end            = LV_BAR_ANIM_STATE_END;
        a.exec_cb        = (lv_anim_exec_xcb_t)lv_bar_anim;
        a.path_cb        = lv_anim_path_linear;
        a.ready_cb       = lv_bar_anim_ready;
        a.act_time       = 0;
        a.time           = ext->anim_time;
        a.playback       = 0;
        a.playback_pause = 0;
        a.repeat         = 0;
        a.repeat_pause   = 0;

        lv_anim_create(&a);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x9353
movq %rbx, %rdi
callq 0x6ad8
movzwl (%rax), %edx
cmpw %r14w, %dx
je 0x934a
movl 0x4(%rax), %ecx
cmpw %r14w, %cx
cmovgel %r14d, %ecx
movzwl 0x2(%rax), %esi
cmpw %si, %cx
cmovlel %esi, %ecx
cmpw %cx, %dx
je 0x934a
testb %bpl, %bpl
je 0x9364
cmpw $-0x1, 0xa(%rax)
je 0x92ed
movzwl 0x8(%rax), %edx
movw %dx, 0x6(%rax)
movw %cx, 0x8(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movabsq $0x10000000000, %rcx    # imm = 0x10000000000
movq %rcx, 0x20(%rdi)
leaq 0xc5(%rip), %rcx        # 0x93d7
movq %rcx, 0x8(%rdi)
leaq 0x201d8(%rip), %rcx     # 0x294f5
movq %rcx, 0x10(%rdi)
leaq 0xd0(%rip), %rcx        # 0x93f8
movq %rcx, 0x18(%rdi)
movw $0x0, 0x2a(%rdi)
movzwl 0xc(%rax), %eax
movw %ax, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
andb $-0x4, 0x30(%rdi)
callq 0x29521
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x35dda(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x9362
movw %cx, (%rax)
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_set_style
void lv_bar_set_style(lv_obj_t * bar, lv_bar_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);

    switch(type) {
        case LV_BAR_STYLE_BG: lv_obj_set_style(bar, style); break;
        case LV_BAR_STYLE_INDIC:
            ext->style_indic = style;
            lv_obj_refresh_ext_draw_pad(bar);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x93b1
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x1, %bpl
je 0x93c2
movzbl %bpl, %eax
testl %eax, %eax
jne 0x93d2
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d83
leaq 0x35d7c(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x93c0
movq %r14, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x64f5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_set_range
void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
    if(ext->min_value == min && ext->max_value == max) return;

    ext->max_value = max;
    ext->min_value = min;
    if(ext->cur_value > max) {
        ext->cur_value = max;
        lv_bar_set_value(bar, ext->cur_value, false);
    }
    if(ext->cur_value < min) {
        ext->cur_value = min;
        lv_bar_set_value(bar, ext->cur_value, false);
    }
    lv_obj_invalidate(bar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x9454
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
cmpw %bp, 0x2(%rax)
jne 0x9465
cmpw %r14w, 0x4(%r15)
jne 0x9465
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35cd9(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x9463
movw %r14w, 0x4(%r15)
movw %bp, 0x2(%r15)
cmpw %r14w, (%r15)
jle 0x9487
movw %r14w, (%r15)
movswl %r14w, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x928d
cmpw %bp, (%r15)
jge 0x949e
movw %bp, (%r15)
movswl %bp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x928d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_set_anim_time
void lv_bar_set_anim_time(lv_obj_t * bar, uint16_t anim_time)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
    ext->anim_time     = anim_time;
#else
    (void)bar;       /*Unused*/
    (void)anim_time; /*Unused*/
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x9514
movq %r14, %rdi
callq 0x6ad8
movw %bx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35c19(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x9523
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_get_value
int16_t lv_bar_get_value(const lv_obj_t * bar)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
    /*If animated tell that it's already at the end value*/
#if LV_USE_ANIMATION
    if(ext->anim_state != LV_BAR_ANIM_STATE_INV) return ext->anim_end;
#endif
    /*No animation, simple return the current value*/
    return ext->cur_value;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x954a
movq %rbx, %rdi
callq 0x6ad8
xorl %ecx, %ecx
cmpw $-0x1, 0xa(%rax)
setne %cl
movzwl (%rax,%rcx,8), %eax
popq %rbx
retq
leaq 0x35be3(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x9559
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_get_anim_time
uint16_t lv_bar_get_anim_time(lv_obj_t * bar)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
    return ext->anim_time;
#else
    (void)bar;       /*Unused*/
    return 0;
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x95fb
movq %rbx, %rdi
callq 0x6ad8
movzwl 0xc(%rax), %eax
popq %rbx
retq
leaq 0x35b32(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x960a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_bar.c
// Function: lv_bar_get_style
const lv_style_t * lv_bar_get_style(const lv_obj_t * bar, lv_bar_style_t type)
{
    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_bar_ext_t * ext       = lv_obj_get_ext_attr(bar);

    switch(type) {
        case LV_BAR_STYLE_BG: style = lv_obj_get_style(bar); break;
        case LV_BAR_STYLE_INDIC: style = ext->style_indic; break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x9641
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x1, %bpl
je 0x9652
movzbl %bpl, %eax
testl %eax, %eax
jne 0x9658
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6697
leaq 0x35aec(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x9650
movq 0x10(%rax), %rax
jmp 0x965a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cb.c
// Function: lv_cb_signal
static lv_res_t lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(cb, sign, param);
    if(res != LV_RES_OK) return res;
    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);

    lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);

    if(sign == LV_SIGNAL_STYLE_CHG) {
        const lv_style_t * label_style = lv_label_get_style(ext->label, LV_LABEL_STYLE_MAIN);
        lv_obj_set_size(ext->bullet, lv_font_get_line_height(label_style->text.font),
                        lv_font_get_line_height(label_style->text.font));
        lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
    } else if(sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST) {
        lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
    } else if(sign == LV_SIGNAL_CONTROL) {
        char c = *((char *)param);
        if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN || c == LV_KEY_LEFT || c == LV_KEY_UP) {
            /*Follow the backgrounds state with the bullet*/
            lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
        }
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
callq *0x569c2(%rip)          # 0x602a8
movl %eax, %ebx
cmpb $0x1, %al
jne 0x9979
cmpb $0x7, %bpl
jne 0x990d
leaq 0x358bd(%rip), %rsi     # 0x3f1ba
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
movq %r14, %rdi
callq 0x6ad8
movq %rax, %r15
movzbl %bpl, %eax
cmpl $0x9, %eax
jle 0x993a
leal -0xa(%rax), %ecx
cmpl $0x2, %ecx
jb 0x9962
cmpl $0x12, %eax
jne 0x9979
movb (%r12), %al
addb $-0x11, %al
cmpb $0x3, %al
jbe 0x9962
jmp 0x9979
cmpl $0x4, %eax
je 0x9946
cmpl $0x8, %eax
je 0x9962
jmp 0x9979
movq 0x40(%r15), %rdi
callq 0x6697
movq 0x38(%r15), %rdi
movq 0x28(%rax), %rax
movzbl 0x10(%rax), %edx
movl %edx, %esi
callq 0x553f
movq 0x38(%r15), %r15
movq %r14, %rdi
callq 0x136de
movzbl %al, %esi
movq %r15, %rdi
callq 0x135d2
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq