LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x29b59
movabsq $0x10000000000, %rax    # imm = 0x10000000000
movq %rax, 0x20(%rbx)
leaq 0x86(%rip), %rax        # 0x8062
movq %rax, 0x8(%rbx)
leaq 0x21ba1(%rip), %rax     # 0x29b88
movq %rax, 0x10(%rbx)
leaq 0x97(%rip), %rax        # 0x8089
movq %rax, 0x18(%rbx)
movl $0xa0, %edi
callq 0x29f85
movq %rax, %r14
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x8051
testq %r14, %r14
je 0x8049
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
leaq 0x57ef2(%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 0x37078(%rip), %rdi     # 0x3f0d0
movq %r14, %rsi
callq 0x8294
jmp 0x8060
// File: /workspace/github_c_makefile_star2_O3/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 0x79a6
movq 0x90(%rbx), %rdi
popq %rbx
jmp 0x5e90
// File: /workspace/github_c_makefile_star2_O3/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 0x813f
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x6b1b
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x20e0
testl %eax, %eax
je 0x8142
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0x7, %rcx
je 0x8136
movq 0x10(%rsp,%r14,8), %rdi
movq %rbx, %rsi
callq 0x20e0
leaq 0x1(%r14), %rcx
testl %eax, %eax
jne 0x8118
cmpq $0x7, %r14
setb %al
jmp 0x8144
movb $0x1, %al
retq
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x85b8
testq %rax, %rax
je 0x81bb
movq %rax, %r14
leaq 0x48(%r14), %r15
movq %r15, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x81a8
movq %rax, %r13
movb $0x1, %r12b
cmpq %rbx, %r13
je 0x81bb
movq %r13, %rdi
movq %rbx, %rsi
callq 0x81c8
testb %al, %al
jne 0x81bb
movq %r15, %rdi
movq %r13, %rsi
callq 0x2a448
movq %rax, %r13
testq %rax, %rax
jne 0x817e
movq %r14, %rdi
callq 0x85b8
movq %rax, %r14
testq %rax, %rax
jne 0x816a
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %sil
testb %sil, %sil
je 0x828a
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
movl %ecx, %r8d
movl %esi, %ecx
movl $0x1, %esi
cmpb %r8b, %cl
jne 0x8262
testb %cl, %cl
js 0x8280
movl %edx, %esi
movl %esi, %edx
cmpb $0xa, %cl
jb 0x8287
movb 0x1(%rdi,%rax), %sil
cmpq $0x1ffe, %rax           # imm = 0x1FFE
ja 0x828d
incq %rax
testb %sil, %sil
jne 0x824d
jmp 0x828d
incl %edx
cmpl $0x8, %edx
jbe 0x8269
xorl %eax, %eax
retq
movb $0x1, %al
retq
testb %sil, %sil
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a35c
testq %rax, %rax
je 0x84d6
movq %rax, %r15
movzbl 0x10(%rbx), %eax
andl $0x2, %eax
movswl (%rbx,%rax), %esi
xorq $0x2, %rax
movswl (%rbx,%rax), %edx
movq %r15, %rdi
callq 0x5557
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a448
movq %rax, %r15
testq %rax, %rax
jne 0x84a8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_get_hor_res
lv_coord_t lv_disp_get_hor_res(lv_disp_t * disp)
{
    if(disp == NULL) disp = lv_disp_get_default();

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

// Assembly:
testq %rdi, %rdi
jne 0x84ed
movq 0x57d90(%rip), %rdi     # 0x60278
testq %rdi, %rdi
je 0x84f9
movzbl 0x10(%rdi), %eax
andl $0x2, %eax
movzwl (%rdi,%rax), %eax
retq
movw $0x140, %ax             # imm = 0x140
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_get_ver_res
lv_coord_t lv_disp_get_ver_res(lv_disp_t * disp)
{
    if(disp == NULL) disp = lv_disp_get_default();

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

// Assembly:
testq %rdi, %rdi
jne 0x850f
movq 0x57d6e(%rip), %rdi     # 0x60278
testq %rdi, %rdi
je 0x851c
movl 0x10(%rdi), %eax
notl %eax
andl $0x2, %eax
movzwl (%rdi,%rax), %eax
retq
movw $0xf0, %ax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57d49(%rip), %r14     # 0x60278
xorl %edi, %edi
callq 0x874d
testq %rax, %rax
je 0x854e
cmpq %rbx, 0x18(%rax)
jne 0x8549
movq $0x0, 0x18(%rax)
movq %rax, %rdi
jmp 0x8531
leaq 0x5ffa3(%rip), %rdi     # 0x684f8
movq %rbx, %rsi
callq 0x2a3c2
movq %rbx, %rdi
callq 0x2a006
cmpq %rbx, %r14
jne 0x857d
leaq 0x5ff87(%rip), %rdi     # 0x684f8
callq 0x2a35c
movq %rax, 0x57cfb(%rip)     # 0x60278
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_hal/lv_hal_disp.c
// Function: lv_disp_get_antialiasing
bool lv_disp_get_antialiasing(lv_disp_t * disp)
{
#if LV_ANTIALIAS == 0
    return false;
#else
    if(disp == NULL) disp = lv_disp_get_default();
    if(disp == NULL) return false;

    return disp->driver.antialiasing ? true : false;
#endif
}

// Assembly:
testq %rdi, %rdi
jne 0x85a6
movq 0x57cd7(%rip), %rdi     # 0x60278
testq %rdi, %rdi
je 0x85ac
movb 0x10(%rdi), %al
andb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8698
callq 0x8585
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x8729
leaq 0x5fe71(%rip), %rdi     # 0x68510
callq 0x2a2a0
testq %rax, %rax
je 0x870c
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)
movb $0x2, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
leaq -0x585c(%rip), %rdi     # 0x2e98
movl $0x1e, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x29125
movq %rax, 0x20(%rbx)
jmp 0x872b
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x80e4
testb %al, %al
jne 0x872b
leaq 0x369b0(%rip), %rdi     # 0x3f0d0
xorl %esi, %esi
callq 0x8294
jmp 0x8727
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x454f
movq %rax, %rbx
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x88ad
testq %rbx, %rbx
je 0x88be
movq %rbx, %rdi
movl $0x4, %esi
callq 0x64db
movq %rax, %r15
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x88c9
testq %r15, %r15
je 0x88be
cmpq $0x0, 0x57a46(%rip)     # 0x60288
jne 0x8853
movq %rbx, %rdi
callq 0x6a8b
movq %rax, 0x57a35(%rip)     # 0x60288
cmpq $0x0, 0x57a35(%rip)     # 0x60290
jne 0x886c
movq %rbx, %rdi
callq 0x6aaf
movq %rax, 0x57a24(%rip)     # 0x60290
movl $0x13b002d, (%r15)      # imm = 0x13B002D
leaq 0x86(%rip), %rsi        # 0x8900
movq %rbx, %rdi
callq 0x647b
leaq 0xaf(%rip), %rsi        # 0x8938
movq %rbx, %rdi
callq 0x64ab
testq %r14, %r14
je 0x88da
movq %r14, %rdi
callq 0x6af7
movl (%rax), %eax
movl %eax, (%r15)
movq %rbx, %rdi
callq 0x5e54
jmp 0x88c0
leaq 0x3681c(%rip), %rdi     # 0x3f0d0
movq %rbx, %rsi
callq 0x8294
jmp 0x88bc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x36800(%rip), %rdi     # 0x3f0d0
movq %r15, %rsi
callq 0x8294
jmp 0x88d8
callq 0x2e91c
testq %rax, %rax
je 0x88ed
movq 0xe0(%rax), %rdx
jmp 0x88f4
leaq 0x5766c(%rip), %rdx     # 0x5ff60
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8b8e
jmp 0x88c0
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x8c15
movq %rbx, %rdi
callq 0x6af7
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 0x4c4d
leaq 0x365c8(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x8c24
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x8c9c
testb %bpl, %bpl
je 0x8cad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x36541(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x8cab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
nop
// File: /workspace/github_c_makefile_star2_O3/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 *0x5740d(%rip)          # 0x60298
movl %eax, %ebx
cmpb $0x1, %al
jne 0x8ed8
movb $0x1, %bl
cmpb $0x6, %bpl
je 0x8ebb
movzbl %bpl, %eax
cmpl $0x7, %eax
jne 0x8ed8
leaq 0x3637f(%rip), %rsi     # 0x3f228
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r14, %rdi
movl $0x1, %esi
callq 0x9591
movzwl 0x12(%rax), %eax
cmpw 0x5c(%r14), %ax
jle 0x8ed8
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_O3/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 0x80e4
testb %al, %al
je 0x92d1
movq %rbx, %rdi
callq 0x6af7
movzwl (%rax), %edx
cmpw %r14w, %dx
je 0x92c8
movl 0x4(%rax), %ecx
cmpw %r14w, %cx
cmovgel %r14d, %ecx
movzwl 0x2(%rax), %esi
cmpw %si, %cx
cmovlel %esi, %ecx
cmpw %cx, %dx
je 0x92c8
testb %bpl, %bpl
je 0x92e2
cmpw $-0x1, 0xa(%rax)
je 0x926b
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        # 0x9355
movq %rcx, 0x8(%rdi)
leaq 0x208ed(%rip), %rcx     # 0x29b88
movq %rcx, 0x10(%rdi)
leaq 0xd0(%rip), %rcx        # 0x9376
movq %rcx, 0x18(%rdi)
movw $0x0, 0x2a(%rdi)
movzwl 0xc(%rax), %eax
movw %ax, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movb $0x0, 0x30(%rdi)
callq 0x29bb4
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x35f0c(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x92e0
movw %cx, (%rax)
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x932f
movq %rbx, %rdi
callq 0x6af7
cmpb $0x1, %bpl
je 0x9340
movzbl %bpl, %eax
testl %eax, %eax
jne 0x9350
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d9f
leaq 0x35eae(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x933e
movq %r14, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6514
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x93d2
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r15
cmpw %bp, 0x2(%rax)
jne 0x93e3
cmpw %r14w, 0x4(%r15)
jne 0x93e3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35e0b(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x93e1
movw %r14w, 0x4(%r15)
movw %bp, 0x2(%r15)
movzwl (%r15), %eax
cmpw %r14w, %ax
jle 0x940d
movw %r14w, (%r15)
movswl %r14w, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x920b
movzwl (%r15), %eax
cmpw %bp, %ax
jge 0x9423
movw %bp, (%r15)
movswl %bp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x920b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x9499
movq %r14, %rdi
callq 0x6af7
movw %bx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35d44(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x94a8
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x94cf
movq %rbx, %rdi
callq 0x6af7
xorl %ecx, %ecx
cmpw $-0x1, 0xa(%rax)
setne %cl
movzwl (%rax,%rcx,8), %eax
popq %rbx
retq
leaq 0x35d0e(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x94de
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x9580
movq %rbx, %rdi
callq 0x6af7
movzwl 0xc(%rax), %eax
popq %rbx
retq
leaq 0x35c5d(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x958f
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x95c6
movq %rbx, %rdi
callq 0x6af7
cmpb $0x1, %bpl
je 0x95d7
movzbl %bpl, %eax
testl %eax, %eax
jne 0x95dd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
leaq 0x35c17(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x95d5
movq 0x10(%rax), %rax
jmp 0x95df
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 *0x56a3e(%rip)          # 0x602a8
movl %eax, %ebx
cmpb $0x1, %al
jne 0x98ff
cmpb $0x7, %bpl
jne 0x9891
leaq 0x359e9(%rip), %rsi     # 0x3f26a
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r14, %rdi
callq 0x6af7
movq %rax, %r15
movzbl %bpl, %eax
movb $0x1, %bl
cmpl $0x9, %eax
jle 0x98c0
leal -0xa(%rax), %ecx
cmpl $0x2, %ecx
jb 0x98e8
cmpl $0x12, %eax
jne 0x98ff
movb (%r12), %al
addb $-0x11, %al
cmpb $0x3, %al
jbe 0x98e8
jmp 0x98ff
cmpl $0x4, %eax
je 0x98cc
cmpl $0x8, %eax
je 0x98e8
jmp 0x98ff
movq 0x40(%r15), %rdi
callq 0x66b6
movq 0x38(%r15), %rdi
movq 0x28(%rax), %rax
movzbl 0x10(%rax), %edx
movl %edx, %esi
callq 0x5557
movq 0x38(%r15), %r15
movq %r14, %rdi
callq 0x136d6
movzbl %al, %esi
movq %r15, %rdi
callq 0x135ca
movl %ebx, %eax
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_objx/lv_cb.c
// Function: lv_cb_design
static bool lv_cb_design(lv_obj_t * cb, const lv_area_t * mask, lv_design_mode_t mode)
{
    bool result = true;

    if(mode == LV_DESIGN_COVER_CHK) {
        /*Return false if the object is not covers the mask_p area*/
        result = ancestor_bg_design(cb, mask, mode);
    } else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) {
        lv_cb_ext_t * cb_ext      = lv_obj_get_ext_attr(cb);
        lv_btn_ext_t * bullet_ext = lv_obj_get_ext_attr(cb_ext->bullet);

        /*Be sure the state of the bullet is the same as the parent button*/
        bullet_ext->state = cb_ext->bg_btn.state;

        result = ancestor_bg_design(cb, mask, mode);

    } else {
        result = ancestor_bg_design(cb, mask, mode);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x2, %al
cmpl $0x2, %edx
je 0x994e
movl %edx, %ebp
cmpb $0x1, %bpl
ja 0x994c
movq %r14, %rdi
callq 0x6af7
movq %rax, %r15
movq 0x38(%rax), %rdi
callq 0x6af7
movb 0x30(%r15), %cl
andb $0x7, %cl
movb 0x30(%rax), %dl
andb $-0x8, %dl
orb %cl, %dl
movb %dl, 0x30(%rax)
movl %ebp, %eax
movq 0x5695b(%rip), %rcx     # 0x602b0
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cb.c
// Function: lv_cb_set_style
void lv_cb_set_style(lv_obj_t * cb, lv_cb_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);

    lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);

    switch(type) {
        case LV_CB_STYLE_BG:
            lv_btn_set_style(cb, LV_BTN_STYLE_REL, style);
            lv_btn_set_style(cb, LV_BTN_STYLE_PR, style);
            lv_btn_set_style(cb, LV_BTN_STYLE_TGL_REL, style);
            lv_btn_set_style(cb, LV_BTN_STYLE_TGL_PR, style);
            lv_btn_set_style(cb, LV_BTN_STYLE_INA, style);
            break;
        case LV_CB_STYLE_BOX_REL: lv_btn_set_style(ext->bullet, LV_BTN_STYLE_REL, style); break;
        case LV_CB_STYLE_BOX_PR: lv_btn_set_style(ext->bullet, LV_BTN_STYLE_PR, style); break;
        case LV_CB_STYLE_BOX_TGL_REL: lv_btn_set_style(ext->bullet, LV_BTN_STYLE_TGL_REL, style); break;
        case LV_CB_STYLE_BOX_TGL_PR: lv_btn_set_style(ext->bullet, LV_BTN_STYLE_TGL_PR, style); break;
        case LV_CB_STYLE_BOX_INA: lv_btn_set_style(ext->bullet, LV_BTN_STYLE_INA, style); break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x9a26
movq %r14, %rdi
callq 0x6af7
cmpb $0x5, %bpl
ja 0x9a75
movzbl %bpl, %ecx
leaq 0x35855(%rip), %rdx     # 0x3f230
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x13534
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x13534
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x13534
movq %r14, %rdi
movl $0x3, %esi
movq %rbx, %rdx
callq 0x13534
movq %r14, %rdi
jmp 0x9a64
leaq 0x357b7(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x9a35
movq 0x38(%rax), %rdi
movl $0x3, %esi
jmp 0x9a69
movq 0x38(%rax), %rdi
movl $0x1, %esi
jmp 0x9a69
movq 0x38(%rax), %rdi
movl $0x2, %esi
jmp 0x9a69
movq 0x38(%rax), %rdi
xorl %esi, %esi
jmp 0x9a69
movq 0x38(%rax), %rdi
movl $0x4, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x13534
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cb.c
// Function: lv_bullet_design
static bool lv_bullet_design(lv_obj_t * bullet, const lv_area_t * mask, lv_design_mode_t mode)
{
    if(mode == LV_DESIGN_COVER_CHK) {
        return ancestor_bullet_design(bullet, mask, mode);
    } else if(mode == LV_DESIGN_DRAW_MAIN) {
#if LV_USE_GROUP
        /* If the check box is the active in a group and
         * the background is not visible (transparent)
         * then activate the style of the bullet*/
        const lv_style_t * style_ori  = lv_obj_get_style(bullet);
        lv_obj_t * bg                 = lv_obj_get_parent(bullet);
        const lv_style_t * style_page = lv_obj_get_style(bg);
        lv_group_t * g                = lv_obj_get_group(bg);
        if(style_page->body.opa == LV_OPA_TRANSP) { /*Is the Background visible?*/
            if(lv_group_get_focused(g) == bg) {
                lv_style_t * style_mod;
                style_mod       = lv_group_mod_style(g, style_ori);
                bullet->style_p = style_mod; /*Temporally change the style to the activated */
            }
        }
#endif
        ancestor_bullet_design(bullet, mask, mode);

#if LV_USE_GROUP
        bullet->style_p = style_ori; /*Revert the style*/
#endif
    } else if(mode == LV_DESIGN_DRAW_POST) {
        ancestor_bullet_design(bullet, mask, mode);
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x9ad2
cmpl $0x1, %edx
je 0x9abf
cmpl $0x2, %edx
jne 0x9b32
movq 0x56814(%rip), %rax     # 0x602b8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *0x567e8(%rip)          # 0x602b8
jmp 0x9b32
movq %rbx, %rdi
callq 0x66b6
movq %rax, %r15
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %r12
movq %rax, %rdi
callq 0x66b6
movq %rax, %rbp
movq %r12, %rdi
callq 0x4ed1
cmpb $0x0, 0x8(%rbp)
jne 0x9b20
movq %rax, %r13
movq %rax, %rdi
callq 0x2a19
cmpq %r12, %rax
jne 0x9b20
movq %r13, %rdi
movq %r15, %rsi
callq 0x2aa5
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x5678a(%rip)          # 0x602b8
movq %r15, 0x48(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cb.c
// Function: lv_cb_get_style
const lv_style_t * lv_cb_get_style(const lv_obj_t * cb, lv_cb_style_t type)
{
    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_cb_ext_t * ext        = lv_obj_get_ext_attr(cb);

    switch(type) {
        case LV_CB_STYLE_BG: style = lv_btn_get_style(cb, LV_BTN_STYLE_REL); break;
        case LV_CB_STYLE_BOX_REL: style = lv_btn_get_style(ext->bullet, LV_BTN_STYLE_REL); break;
        case LV_CB_STYLE_BOX_PR: style = lv_btn_get_style(ext->bullet, LV_BTN_STYLE_PR); break;
        case LV_CB_STYLE_BOX_TGL_REL: style = lv_btn_get_style(ext->bullet, LV_BTN_STYLE_TGL_REL); break;
        case LV_CB_STYLE_BOX_TGL_PR: style = lv_btn_get_style(ext->bullet, LV_BTN_STYLE_TGL_PR); break;
        case LV_CB_STYLE_BOX_INA: style = lv_btn_get_style(ext->bullet, LV_BTN_STYLE_INA); break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x9bea
movq %rbx, %rdi
callq 0x6af7
cmpb $0x5, %bpl
ja 0x9c38
movzbl %bpl, %ecx
leaq 0x3566c(%rip), %rdx     # 0x3f248
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
jmp 0x9c20
leaq 0x355f3(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x9bf9
movq 0x38(%rax), %rdi
movl $0x3, %esi
jmp 0x9c2d
movq 0x38(%rax), %rdi
movl $0x1, %esi
jmp 0x9c2d
movq 0x38(%rax), %rdi
movl $0x2, %esi
jmp 0x9c2d
movq 0x38(%rax), %rdi
xorl %esi, %esi
jmp 0x9c2d
movq 0x38(%rax), %rdi
movl $0x4, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13799
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_style
void lv_cpicker_set_style(lv_obj_t * cpicker, lv_cpicker_style_t type, lv_style_t * style)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);

    switch(type) {
    case LV_CPICKER_STYLE_MAIN:
        lv_obj_set_style(cpicker, style);
        break;
    case LV_CPICKER_STYLE_INDICATOR:
        ext->indic.style = style;
        lv_obj_invalidate(cpicker);
        break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xaaf1
movq %rbx, %rdi
callq 0x6af7
cmpb $0x1, %bpl
je 0xab02
movzbl %bpl, %eax
testl %eax, %eax
jne 0xab12
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d9f
leaq 0x346ec(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xab00
movq %r14, 0x8(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c4d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_type
void lv_cpicker_set_type(lv_obj_t * cpicker, lv_cpicker_type_t type)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    if(ext->type == type) return;

    ext->type = type;
    lv_obj_refresh_ext_draw_pad(cpicker);
    refr_indic_pos(cpicker);

    lv_obj_invalidate(cpicker);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xacd6
movq %rbx, %rdi
callq 0x6af7
movb 0x24(%rax), %cl
movl %ecx, %edx
shrb $0x3, %dl
andb $0x1, %dl
cmpb %bpl, %dl
jne 0xace7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x34507(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xace5
shlb $0x3, %bpl
andb $0x8, %bpl
andb $-0x9, %cl
orb %bpl, %cl
movb %cl, 0x24(%rax)
movq %rbx, %rdi
callq 0x6514
movq %rbx, %rdi
callq 0xab17
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_hsv
bool lv_cpicker_set_hsv(lv_obj_t * cpicker, lv_color_hsv_t hsv)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    if (hsv.h > 360) hsv.h %= 360;
    if (hsv.s > 100) hsv.s = 100;
    if (hsv.v > 100) hsv.v = 100;

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);

    if (ext->hsv.h == hsv.h && ext->hsv.s == hsv.s && ext->hsv.v == hsv.v) return false;

    ext->hsv = hsv;

    refr_indic_pos(cpicker);

    if (ext->preview && ext->type == LV_CPICKER_TYPE_DISC) {
        lv_obj_invalidate(cpicker);
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xadee
movl %ebp, %r15d
shrl $0x18, %r15d
movl %ebp, %r12d
shrl $0x10, %r12d
movzwl %bp, %eax
imull $0x2d83, %eax, %ecx     # imm = 0x2D83
shrl $0x16, %ecx
imull $0x168, %ecx, %ecx      # imm = 0x168
movl %ebp, %r13d
subl %ecx, %r13d
cmpl $0x169, %eax            # imm = 0x169
cmovbl %ebp, %r13d
movl %ebp, %eax
andl $0xff0000, %eax         # imm = 0xFF0000
cmpl $0x640001, %eax         # imm = 0x640001
movl $0x64, %eax
cmovael %eax, %r12d
cmpl $0x65000000, %ebp       # imm = 0x65000000
cmovael %eax, %r15d
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r14
cmpw %r13w, (%rax)
jne 0xadff
cmpb %r12b, 0x2(%r14)
jne 0xadff
cmpb %r15b, 0x3(%r14)
jne 0xadff
xorl %ebp, %ebp
jmp 0xae28
leaq 0x343ef(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xadfd
movw %r13w, (%r14)
movb %r12b, 0x2(%r14)
movb %r15b, 0x3(%r14)
movq %rbx, %rdi
callq 0xab17
movb 0x24(%r14), %al
notb %al
movb $0x1, %bpl
testb $0x18, %al
jne 0xae28
movq %rbx, %rdi
callq 0x4c4d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_color_mode
void lv_cpicker_set_color_mode(lv_obj_t * cpicker, lv_cpicker_color_mode_t mode)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);

    ext->color_mode = mode;
    refr_indic_pos(cpicker);
    lv_obj_invalidate(cpicker);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xaf26
movq %rbx, %rdi
callq 0x6af7
movb 0x24(%rax), %cl
andb $0x3, %bpl
andb $-0x4, %cl
orb %bpl, %cl
movb %cl, 0x24(%rax)
movq %rbx, %rdi
callq 0xab17
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
leaq 0x342b7(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xaf35
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_indic_colored
void lv_cpicker_set_indic_colored(lv_obj_t * cpicker, bool en)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    ext->indic.colored = en ? 1 : 0;
    invalidate_indic(cpicker);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xafa8
movq %rbx, %rdi
callq 0x6af7
movb 0x14(%rax), %cl
andb $-0x2, %cl
orb %bpl, %cl
movb %cl, 0x14(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xafb9
leaq 0x34235(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xafb7
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_set_preview
void lv_cpicker_set_preview(lv_obj_t * cpicker, bool en)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    ext->preview = en ? 1 : 0;
    lv_obj_invalidate(cpicker);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xb01d
movq %rbx, %rdi
callq 0x6af7
movb 0x24(%rax), %cl
shlb $0x4, %bpl
andb $-0x11, %cl
orb %bpl, %cl
movb %cl, 0x24(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
leaq 0x341c0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xb02c
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: lv_cpicker_get_style
const lv_style_t * lv_cpicker_get_style(const lv_obj_t * cpicker, lv_cpicker_style_t type)
{
    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);

    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);

    switch(type) {
    case LV_CPICKER_STYLE_MAIN:
        return lv_obj_get_style(cpicker);
    case LV_CPICKER_STYLE_INDICATOR:
        return ext->indic.style;
    default:
        return NULL;
    }

    /*To avoid warning*/
    return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xb0c0
movq %rbx, %rdi
callq 0x6af7
cmpb $0x1, %bpl
je 0xb0d1
movzbl %bpl, %eax
testl %eax, %eax
jne 0xb0d7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
leaq 0x3411d(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xb0cf
movq 0x8(%rax), %rax
jmp 0xb0d9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: angle_to_mode_color
static lv_color_t angle_to_mode_color(lv_obj_t * cpicker, uint16_t angle)
{
    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    lv_color_t color;
    switch(ext->color_mode)
    {
    default:
    case LV_CPICKER_COLOR_MODE_HUE:
        color = lv_color_hsv_to_rgb(angle % 360, ext->hsv.s, ext->hsv.v);
        break;
    case LV_CPICKER_COLOR_MODE_SATURATION:
        color = lv_color_hsv_to_rgb(ext->hsv.h, ((angle % 360) * 100) / 360, ext->hsv.v);
        break;
    case LV_CPICKER_COLOR_MODE_VALUE:
        color = lv_color_hsv_to_rgb(ext->hsv.h, ext->hsv.s, ((angle % 360) * 100) / 360);
        break;
    }
    return color;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x6af7
movzbl 0x24(%rax), %ecx
andl $0x3, %ecx
leaq 0x340e5(%rip), %rdx     # 0x3f2f0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movzwl %bx, %ecx
imull $0x2d83, %ecx, %ecx     # imm = 0x2D83
shrl $0x16, %ecx
imull $0x168, %ecx, %ecx      # imm = 0x168
subl %ecx, %ebx
movzbl 0x2(%rax), %esi
movzbl 0x3(%rax), %edx
movzwl %bx, %edi
jmp 0xb28b
movzwl (%rax), %edi
movzwl %bx, %ecx
imull $0x2d83, %ecx, %ecx     # imm = 0x2D83
shrl $0x16, %ecx
imull $0x168, %ecx, %ecx      # imm = 0x168
subl %ecx, %ebx
imull $0x64, %ebx, %ecx
movzwl %cx, %ecx
imull $0x2d83, %ecx, %esi     # imm = 0x2D83
shrl $0x16, %esi
movzbl 0x3(%rax), %edx
jmp 0xb28b
movzwl (%rax), %edi
movzbl 0x2(%rax), %esi
movzwl %bx, %eax
imull $0x2d83, %eax, %eax     # imm = 0x2D83
shrl $0x16, %eax
imull $0x168, %eax, %eax      # imm = 0x168
subl %eax, %ebx
imull $0x64, %ebx, %eax
movzwl %ax, %eax
imull $0x2d83, %eax, %edx     # imm = 0x2D83
shrl $0x16, %edx
popq %rbx
jmp 0x2a624
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cpicker.c
// Function: get_indic_area
static lv_area_t get_indic_area(lv_obj_t * cpicker)
{
    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    const lv_style_t * style_main = lv_cpicker_get_style(cpicker, LV_CPICKER_STYLE_MAIN);
    const lv_style_t * style_indic = lv_cpicker_get_style(cpicker, LV_CPICKER_STYLE_INDICATOR);

    uint16_t r = 0;
    if(ext->type == LV_CPICKER_TYPE_DISC) r = style_main->line.width / 2;
    else if(ext->type == LV_CPICKER_TYPE_RECT) {
        lv_coord_t h = lv_obj_get_height(cpicker);
        r = h / 2;
    }

    lv_area_t indic_area;
    indic_area.x1 = cpicker->coords.x1 + ext->indic.pos.x - r - style_indic->body.padding.left;
    indic_area.y1 = cpicker->coords.y1 + ext->indic.pos.y - r - style_indic->body.padding.right;
    indic_area.x2 = cpicker->coords.x1 + ext->indic.pos.x + r + style_indic->body.padding.top;
    indic_area.y2 = cpicker->coords.y1 + ext->indic.pos.y + r + style_indic->body.padding.bottom;

    return indic_area;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6af7
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xb08b
movq %rax, %r12
movq %r14, %rdi
movl $0x1, %esi
callq 0xb08b
movq %rax, %rbx
testb $0x8, 0x24(%r15)
jne 0xb2d2
movq %r14, %rdi
callq 0x5697
jmp 0xb2d8
movzwl 0x3e(%r12), %eax
movzwl %ax, %ecx
shrl $0xf, %ecx
addl %eax, %ecx
movswl %cx, %esi
shrl %esi
movzwl 0x20(%r14), %ecx
movzwl 0x10(%r15), %eax
addl %ecx, %eax
movl $0xffff, %ecx           # imm = 0xFFFF
movl %esi, %edi
andl %ecx, %edi
movzwl 0x1a(%rbx), %r8d
addl %edi, %r8d
movzwl 0x22(%r14), %r9d
movzwl 0x12(%r15), %edx
addl %r9d, %edx
movzwl 0x1c(%rbx), %r9d
addl %edi, %r9d
leal (%rsi,%rax), %edi
subl %r8d, %eax
addw 0x16(%rbx), %di
addl %edx, %esi
subl %r9d, %edx
addw 0x18(%rbx), %si
movzwl %si, %esi
shlq $0x30, %rsi
movzwl %di, %edi
shlq $0x20, %rdi
orq %rsi, %rdi
shll $0x10, %edx
orq %rdi, %rdx
andl %ecx, %eax
orq %rdx, %rax
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_objx/lv_cpicker.c
// Function: next_color_mode
static void next_color_mode(lv_obj_t * cpicker)
{
    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
    ext->color_mode = (ext->color_mode + 1) % 3;
    refr_indic_pos(cpicker);
    lv_obj_invalidate(cpicker);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6af7
movb 0x24(%rax), %cl
movl %ecx, %edx
andb $0x3, %dl
cmpb $0x2, %dl
movl $0xfe, %esi
movl $0x1, %edi
cmovael %esi, %edi
andb $-0x4, %cl
addb %dl, %cl
addb %dil, %cl
movb %cl, 0x24(%rax)
movq %rbx, %rdi
callq 0xab17
movq %rbx, %rdi
popq %rbx
jmp 0x4c4d
nop