LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_get_active_btn_text
const char * lv_btnm_get_active_btn_text(const lv_obj_t * btnm)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    if(ext->btn_id_act != LV_BTNM_BTN_NONE) {
        return lv_btnm_get_btn_text(btnm, ext->btn_id_act);
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x22188
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x44(%rax), %eax
cmpw $-0x1, %ax
je 0x22199
movzwl %ax, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2219d
leaq 0x1cfa5(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x22197
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_get_btn_text
const char * lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    if(btn_id > ext->btn_cnt) return NULL;

    uint16_t txt_i = 0;
    uint16_t btn_i = 0;

    /* Search the text of ext->btn_pr the buttons text in the map
     * Skip "\n"-s*/
    while(btn_i != btn_id) {
        btn_i++;
        txt_i++;
        if(strcmp(ext->map_p[txt_i], "\n") == 0) txt_i++;
    }

    if(btn_i == ext->btn_cnt) return NULL;

    return ext->map_p[txt_i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x22220
movq %r14, %rdi
callq 0x6ad8
movzwl 0x40(%rax), %ecx
cmpw %bx, %cx
jb 0x2223a
testw %bx, %bx
je 0x22231
movw %cx, 0xe(%rsp)
movq %rax, 0x10(%rsp)
movq (%rax), %r12
xorl %r14d, %r14d
leaq 0x211e6(%rip), %r15     # 0x433cc
movl %ebx, %r13d
leal 0x1(%r14), %ebp
movzwl %bp, %eax
movq (%r12,%rax,8), %rdi
movq %r15, %rsi
callq 0x20e0
testl %eax, %eax
jne 0x22207
addl $0x2, %r14d
movl %r14d, %ebp
movl %ebp, %r14d
decw %r13w
jne 0x221e9
movzwl %r14w, %edx
movq 0x10(%rsp), %rax
movzwl 0xe(%rsp), %ecx
jmp 0x22235
leaq 0x1cf0d(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x2222f
xorl %edx, %edx
xorl %ebx, %ebx
cmpw %cx, %bx
jne 0x2223e
xorl %eax, %eax
jmp 0x22245
movq (%rax), %rcx
movq (%rcx,%rdx,8), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_get_btn_ctrl
bool lv_btnm_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t ctrl)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    if(btn_id >= ext->btn_cnt) return false;

    return ext->ctrl_bits[btn_id] & ctrl ? true : false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x222b2
movq %r14, %rdi
callq 0x6ad8
cmpw %bp, 0x40(%rax)
jbe 0x222c3
movq 0x10(%rax), %rax
movzwl %bp, %ecx
testw %bx, (%rax,%rcx,2)
setne %al
jmp 0x222c5
leaq 0x1ce7b(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x222c1
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: get_button_from_point
static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
{
    lv_area_t btnm_cords;
    lv_area_t btn_area;
    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    uint16_t i;
    lv_obj_get_coords(btnm, &btnm_cords);

    for(i = 0; i < ext->btn_cnt; i++) {
        lv_area_copy(&btn_area, &ext->button_areas[i]);
        btn_area.x1 += btnm_cords.x1;
        btn_area.y1 += btnm_cords.y1;
        btn_area.x2 += btnm_cords.x1;
        btn_area.y2 += btnm_cords.y1;
        if(lv_area_is_point_on(&btn_area, p) != false) {
            break;
        }
    }

    if(i == ext->btn_cnt) i = LV_BTNM_BTN_NONE;

    return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x6ad8
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x5427
cmpw $0x0, 0x40(%rbx)
je 0x22378
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x8(%rsp)
movzwl 0x10(%rsp), %ecx
addl %ecx, %eax
movw %ax, 0x8(%rsp)
movzwl 0x12(%rsp), %eax
addw %ax, 0xa(%rsp)
addw %cx, 0xc(%rsp)
addw %ax, 0xe(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x28702
testb %al, %al
jne 0x2237b
incq %r12
movzwl 0x40(%rbx), %eax
cmpq %rax, %r12
jb 0x2232e
jmp 0x2237b
xorl %r12d, %r12d
cmpw 0x40(%rbx), %r12w
movl $0xffff, %eax           # imm = 0xFFFF
cmovnel %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cont.c
// Function: lv_cont_signal
static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(cont, 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_STYLE_CHG) { /*Recalculate the padding if the style changed*/
        lv_cont_refr_layout(cont);
        lv_cont_refr_autofit(cont);
    } else if(sign == LV_SIGNAL_CHILD_CHG) {
        lv_cont_refr_layout(cont);
        lv_cont_refr_autofit(cont);
    } else if(sign == LV_SIGNAL_CORD_CHG) {
        if(lv_obj_get_width(cont) != lv_area_get_width(param) || lv_obj_get_height(cont) != lv_area_get_height(param)) {
            lv_cont_refr_layout(cont);
            lv_cont_refr_autofit(cont);
        }
    } else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
        /*FLOOD and FILL fit needs to be refreshed if the parent size has changed*/
        lv_cont_refr_autofit(cont);

    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq *0x3df20(%rip)          # 0x60430
movl %eax, %ebx
cmpb $0x1, %al
jne 0x22541
movzbl %bpl, %eax
decl %eax
cmpl $0x6, %eax
ja 0x22541
leaq 0x1d454(%rip), %rcx     # 0x3f97c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x227c7
movq %r14, %rdi
callq 0x22be7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x5651
movzwl 0x4(%r15), %ecx
subw (%r15), %cx
incl %ecx
cmpw %cx, %ax
jne 0x22531
movq %r14, %rdi
callq 0x567b
movzwl 0x6(%r15), %ecx
subw 0x2(%r15), %cx
incl %ecx
cmpw %cx, %ax
jne 0x22531
jmp 0x22541
leaq 0x1d450(%rip), %rsi     # 0x3f9d8
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cont.c
// Function: lv_cont_set_layout
void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout)
{
    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);

    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
    if(ext->layout == layout) return;

    ext->layout = layout;

    /*Send a signal to refresh the layout*/
    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x225cb
movq %rbx, %rdi
callq 0x6ad8
movzwl (%rax), %ecx
movl %ecx, %edx
andl $0xf, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x225dc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1cb62(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x225da
andb $0xf, %bpl
movzbl %bpl, %edx
andl $-0x10, %ecx
orl %edx, %ecx
movw %cx, (%rax)
movq 0x30(%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_cont.c
// Function: lv_cont_set_fit4
void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom)
{
    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);

    lv_obj_invalidate(cont);
    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
    if(ext->fit_left == left && ext->fit_right == right && ext->fit_top == top && ext->fit_bottom == bottom) {
        return;
    }

    ext->fit_left   = left;
    ext->fit_right  = right;
    ext->fit_top    = top;
    ext->fit_bottom = bottom;

    /*Send a signal to refresh the layout*/
    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x22681
movq %rbx, %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x6ad8
movzwl (%rax), %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0x3, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x22692
movl %ecx, %edx
shrl $0x6, %edx
andl $0x3, %edx
movzbl %r12b, %esi
cmpw %si, %dx
jne 0x22692
movl %ecx, %edx
shrl $0x8, %edx
andl $0x3, %edx
movzbl %r15b, %esi
cmpw %si, %dx
jne 0x22692
movl %ecx, %edx
shrl $0xa, %edx
andl $0x3, %edx
movzbl %r14b, %esi
cmpw %si, %dx
jne 0x22692
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1caac(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x22690
shlb $0x4, %bpl
andl $0xfffff00f, %ecx       # imm = 0xFFFFF00F
shlb $0x6, %r12b
andb $0x30, %bpl
orb %r12b, %bpl
andb $0x3, %r15b
movzbl %r15b, %edx
shll $0x8, %edx
andb $0x3, %r14b
movzbl %r14b, %esi
shll $0xa, %esi
movzbl %bpl, %edi
orl %edx, %edi
orl %esi, %edi
orl %ecx, %edi
movw %di, (%rax)
movq 0x30(%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_img.c
// Function: lv_img_signal
static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(img, 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_img_ext_t * ext = lv_obj_get_ext_attr(img);
    if(sign == LV_SIGNAL_CLEANUP) {
        if(ext->src_type == LV_IMG_SRC_FILE || ext->src_type == LV_IMG_SRC_SYMBOL) {
            lv_mem_free(ext->src);
            ext->src      = NULL;
            ext->src_type = LV_IMG_SRC_UNKNOWN;
        }
    } else if(sign == LV_SIGNAL_STYLE_CHG) {
        /*Refresh the file name to refresh the symbol text size*/
        if(ext->src_type == LV_IMG_SRC_SYMBOL) {
            lv_img_set_src(img, ext->src);
        }
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq *0x3cda3(%rip)          # 0x60438
movl %eax, %ebx
cmpb $0x1, %al
jne 0x2370a
cmpb $0x7, %bpl
jne 0x236ba
leaq 0x1c138(%rip), %rsi     # 0x3f7e0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
movq %r14, %rdi
callq 0x6ad8
movq %rax, %r15
cmpb $0x4, %bpl
je 0x236f5
movzbl %bpl, %eax
testl %eax, %eax
jne 0x2370a
movb 0x10(%r15), %al
andb $0x3, %al
decb %al
cmpb $0x1, %al
ja 0x2370a
movq (%r15), %rdi
callq 0x29984
movq $0x0, (%r15)
orb $0x3, 0x10(%r15)
jmp 0x2370a
movb 0x10(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x2370a
movq (%r15), %rsi
movq %r14, %rdi
callq 0x23916
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_img.c
// Function: lv_img_set_offset_x
void lv_img_set_offset_x(lv_obj_t * img, lv_coord_t x)
{
    LV_ASSERT_OBJ(img, LV_OBJX_NAME);

    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);

    if(x < ext->w - 1) {
        ext->offset.x = x;
        lv_obj_invalidate(img);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x23ba0
movq %rbx, %rdi
callq 0x6ad8
movswl %bp, %ecx
movswl 0xc(%rax), %edx
decl %edx
cmpl %ecx, %edx
jle 0x23bb1
movw %bp, 0x8(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
leaq 0x1b58d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x23baf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_img.c
// Function: lv_img_set_offset_y
void lv_img_set_offset_y(lv_obj_t * img, lv_coord_t y)
{
    LV_ASSERT_OBJ(img, LV_OBJX_NAME);

    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);

    if(y < ext->h - 1) {
        ext->offset.y = y;
        lv_obj_invalidate(img);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x23bf0
movq %rbx, %rdi
callq 0x6ad8
movswl %bp, %ecx
movswl 0xe(%rax), %edx
decl %edx
cmpl %ecx, %edx
jle 0x23c01
movw %bp, 0xa(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
leaq 0x1b53d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x23bff
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_img.c
// Function: lv_img_get_file_name
const char * lv_img_get_file_name(const lv_obj_t * img)
{
    LV_ASSERT_OBJ(img, LV_OBJX_NAME);

    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);

    if(ext->src_type == LV_IMG_SRC_FILE)
        return ext->src;
    else
        return "";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x23c58
movq %rbx, %rdi
callq 0x6ad8
movb 0x10(%rax), %cl
andb $0x3, %cl
cmpb $0x1, %cl
jne 0x23c69
movq (%rax), %rax
jmp 0x23c70
leaq 0x1b4d5(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x23c67
leaq 0x1f75d(%rip), %rax     # 0x433cd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_imgbtn.c
// Function: lv_imgbtn_signal
static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(imgbtn, 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_STYLE_CHG) {
        /* If the style changed then the button was clicked, released etc. so probably the state was
         * changed as well Set the new image for the new state.*/
        refr_img(imgbtn);
    } else if(sign == LV_SIGNAL_CLEANUP) {
        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq *0x3c649(%rip)          # 0x60440
movl %eax, %ebp
cmpb $0x1, %al
jne 0x23e2d
cmpb $0x4, %r15b
je 0x23e25
movzbl %r15b, %eax
cmpl $0x7, %eax
jne 0x23e2d
leaq 0x1bbcd(%rip), %rsi     # 0x3f9e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
movq %r14, %rdi
callq 0x23f81
movl %ebp, %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_imgbtn.c
// Function: lv_imgbtn_set_src
void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src)
{
    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);

    lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);

    ext->img_src[state] = src;

    refr_img(imgbtn);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x23f70
movq %rbx, %rdi
callq 0x6ad8
movzbl %bpl, %ecx
movq %r14, 0x38(%rax,%rcx,8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x23f81
leaq 0x1b1bd(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x23f7f
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_imgbtn.c
// Function: refr_img
static void refr_img(lv_obj_t * imgbtn)
{
    lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
    lv_btn_state_t state  = lv_imgbtn_get_state(imgbtn);
    lv_img_header_t header;

#if LV_IMGBTN_TILED == 0
    const void * src = ext->img_src[state];
#else
    const void * src = ext->img_src_mid[state];
#endif

    lv_res_t info_res = LV_RES_OK;
    if(lv_img_src_get_type(src) == LV_IMG_SRC_SYMBOL) {
        const lv_style_t * style = ext->btn.styles[state];
        header.h = lv_font_get_line_height(style->text.font);
        header.w = lv_txt_get_width(src, (uint16_t)strlen(src), style->text.font, style->text.letter_space, LV_TXT_FLAG_NONE);
        header.always_zero = 0;
        header.cf = LV_IMG_CF_ALPHA_1BIT;
    } else {
        info_res = lv_img_decoder_get_info(src, &header);
    }

    if(info_res == LV_RES_OK) {
        ext->act_cf = header.cf;
#if LV_IMGBTN_TILED == 0
        lv_obj_set_size(imgbtn, header.w, header.h);
#else
        lv_obj_set_height(imgbtn, header.h);
#endif
    } else {
        ext->act_cf = LV_IMG_CF_UNKNOWN;
    }

    lv_obj_invalidate(imgbtn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x6ad8
movq %rax, %r14
movq %rbx, %rdi
callq 0x136de
movzbl %al, %r12d
movq 0x38(%r14,%r12,8), %r15
movq %r15, %rdi
callq 0x3c49f
cmpb $0x2, %al
jne 0x24011
movq 0x8(%r14,%r12,8), %r13
movq 0x28(%r13), %r12
movzbl 0x10(%r12), %eax
shll $0x15, %eax
movl $0x1fffff, %ecx         # imm = 0x1FFFFF
andl 0xc(%rsp), %ecx
orl %eax, %ecx
movl %ecx, 0xc(%rsp)
movq %r15, %rdi
callq 0x2070
movswl 0x30(%r13), %ecx
movzwl %ax, %esi
movq %r15, %rdi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x2ab49
andl $0x7ff, %eax            # imm = 0x7FF
shll $0xa, %eax
movl $0xffe00300, %ecx       # imm = 0xFFE00300
andl 0xc(%rsp), %ecx
addl %ecx, %eax
addl $0xb, %eax
movl %eax, 0xc(%rsp)
jmp 0x24022
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x3e0f7
cmpb $0x1, %al
jne 0x24046
movl 0xc(%rsp), %edx
movl %edx, %eax
andb $0x1f, %al
movb %al, 0x60(%r14)
movl %edx, %esi
shrl $0xa, %esi
shrl $0x15, %edx
andl $0x7ff, %esi            # imm = 0x7FF
movq %rbx, %rdi
callq 0x553f
jmp 0x2404b
movb $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x4c36
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_led.c
// Function: lv_led_create
lv_obj_t * lv_led_create(lv_obj_t * par, const lv_obj_t * copy)
{
    LV_LOG_TRACE("led create started");

    /*Create the ancestor basic object*/
    lv_obj_t * new_led = lv_obj_create(par, copy);
    LV_ASSERT_MEM(new_led);
    if(new_led == NULL) return NULL;

    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(new_led);
    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_cb(new_led);

    /*Allocate the object type specific extended data*/
    lv_led_ext_t * ext = lv_obj_allocate_ext_attr(new_led, sizeof(lv_led_ext_t));
    LV_ASSERT_MEM(ext);
    if(ext == NULL) return NULL;

    ext->bright = LV_LED_BRIGHT_ON;

    lv_obj_set_signal_cb(new_led, lv_led_signal);
    lv_obj_set_design_cb(new_led, lv_led_design);

    /*Init the new led object*/
    if(copy == NULL) {
        lv_obj_set_size(new_led, LV_LED_WIDTH_DEF, LV_LED_HEIGHT_DEF);

        /*Set the default styles*/
        lv_theme_t * th = lv_theme_get_current();
        if(th) {
            lv_led_set_style(new_led, LV_LED_STYLE_MAIN, th->style.led);
        } else {
            lv_led_set_style(new_led, LV_LED_STYLE_MAIN, &lv_style_pretty_color);
        }
    }
    /*Copy an existing object*/
    else {
        lv_led_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
        ext->bright             = copy_ext->bright;

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

    LV_LOG_INFO("led created");

    return new_led;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x455f
movq %rax, %rbx
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x241c6
testq %rbx, %rbx
je 0x241d7
cmpq $0x0, 0x3c313(%rip)     # 0x60450
jne 0x2414e
movq %rbx, %rdi
callq 0x6a6c
movq %rax, 0x3c302(%rip)     # 0x60450
cmpq $0x0, 0x3c302(%rip)     # 0x60458
jne 0x24167
movq %rbx, %rdi
callq 0x6a90
movq %rax, 0x3c2f1(%rip)     # 0x60458
movq %rbx, %rdi
movl $0x1, %esi
callq 0x64bc
movq %rax, %r15
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x241e2
testq %r15, %r15
je 0x241d7
movb $-0x1, (%r15)
leaq 0x96(%rip), %rsi        # 0x24229
movq %rbx, %rdi
callq 0x645c
leaq 0xcf(%rip), %rsi        # 0x24271
movq %rbx, %rdi
callq 0x648c
testq %r14, %r14
je 0x241f3
movq %r14, %rdi
callq 0x6ad8
movb (%rax), %al
movb %al, (%r15)
movq %rbx, %rdi
callq 0x5e38
jmp 0x241d9
leaq 0x1ae73(%rip), %rdi     # 0x3f040
movq %rbx, %rsi
callq 0x829e
jmp 0x241d5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ae57(%rip), %rdi     # 0x3f040
movq %r15, %rsi
callq 0x829e
jmp 0x241f1
movq %rbx, %rdi
movl $0x21, %esi
movl $0x21, %edx
callq 0x553f
callq 0x2e244
testq %rax, %rax
je 0x24218
movq 0xa0(%rax), %rsi
jmp 0x2421f
leaq 0x3bdd1(%rip), %rsi     # 0x5fff0
movq %rbx, %rdi
callq 0x5d83
jmp 0x241d9
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_led.c
// Function: lv_led_signal
static lv_res_t lv_led_signal(lv_obj_t * led, lv_signal_t sign, void * param)
{
    lv_res_t res;

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

    if(sign == LV_SIGNAL_GET_TYPE) {
        lv_obj_type_t * buf = param;
        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] = "lv_led";
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
callq *0x3c219(%rip)          # 0x60450
movl %eax, %ecx
xorb $0x1, %cl
xorb $0x7, %bpl
orb %cl, %bpl
jne 0x2426a
xorl %ecx, %ecx
cmpq $0x0, (%rbx,%rcx,8)
je 0x2425c
incq %rcx
cmpq $0x7, %rcx
jne 0x24247
movl $0x7, %ecx
movzbl %cl, %ecx
leaq 0x1b784(%rip), %rdx     # 0x3f9ea
movq %rdx, (%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_led.c
// Function: lv_led_set_bright
void lv_led_set_bright(lv_obj_t * led, uint8_t bright)
{
    LV_ASSERT_OBJ(led, LV_OBJX_NAME);

    /*Set the brightness*/
    lv_led_ext_t * ext = lv_obj_get_ext_attr(led);
    if(ext->bright == bright) return;

    ext->bright = bright;

    /*Invalidate the object there fore it will be redrawn*/
    lv_obj_invalidate(led);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x24417
movq %rbx, %rdi
callq 0x6ad8
cmpb %bpl, (%rax)
jne 0x24428
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1ad16(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x24426
movb %bpl, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_led.c
// Function: lv_led_toggle
void lv_led_toggle(lv_obj_t * led)
{
    LV_ASSERT_OBJ(led, LV_OBJX_NAME);

    uint8_t bright = lv_led_get_bright(led);
    if(bright > (LV_LED_BRIGHT_OFF + LV_LED_BRIGHT_ON) >> 1)
        lv_led_off(led);
    else
        lv_led_on(led);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x244b3
movq %rbx, %rdi
callq 0x244ca
movq %rbx, %rdi
cmpb $-0x4e, %al
jb 0x244c4
popq %rbx
jmp 0x24465
leaq 0x1ac7a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x244c2
popq %rbx
jmp 0x24439
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_lmeter.c
// Function: lv_lmeter_signal
static lv_res_t lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param)
{
    lv_res_t res;

    /* Include the ancient signal function */
    res = ancestor_signal(lmeter, 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_CLEANUP) {
        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
    } else if(sign == LV_SIGNAL_STYLE_CHG) {
        lv_obj_refresh_ext_draw_pad(lmeter);
    } else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
        const lv_style_t * style = lv_lmeter_get_style(lmeter, LV_LMETER_STYLE_MAIN);
        lmeter->ext_draw_pad     = LV_MATH_MAX(lmeter->ext_draw_pad, style->line.width);
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq *0x3be14(%rip)          # 0x60460
movl %eax, %ebx
cmpb $0x1, %al
jne 0x246a4
cmpb $0x4, %bpl
je 0x2469c
movzbl %bpl, %eax
cmpl $0x6, %eax
je 0x2467f
cmpl $0x7, %eax
jne 0x246a4
leaq 0x1b384(%rip), %rsi     # 0x3f9f1
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bf5
movq %r14, %rdi
callq 0x6697
movl 0x5c(%r14), %ecx
movzwl 0x3e(%rax), %eax
cmpw %ax, %cx
cmovgl %ecx, %eax
movw %ax, 0x5c(%r14)
jmp 0x246a4
movq %r14, %rdi
callq 0x64f5
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_lmeter.c
// Function: lv_lmeter_set_value
void lv_lmeter_set_value(lv_obj_t * lmeter, int16_t value)
{
    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);

    lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
    if(ext->cur_value == value) return;

    ext->cur_value = value > ext->max_value ? ext->max_value : value;
    ext->cur_value = ext->cur_value < ext->min_value ? ext->min_value : ext->cur_value;
    lv_obj_invalidate(lmeter);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x24a67
movq %rbx, %rdi
callq 0x6ad8
cmpw %bp, 0x6(%rax)
jne 0x24a78
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1a6c6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x24a76
movzwl 0xa(%rax), %ecx
cmpw %bp, %cx
cmovgel %ebp, %ecx
movzwl 0x8(%rax), %edx
cmpw %dx, %cx
cmovlel %edx, %ecx
movw %cx, 0x6(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_lmeter.c
// Function: lv_lmeter_set_range
void lv_lmeter_set_range(lv_obj_t * lmeter, int16_t min, int16_t max)
{
    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);

    lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
    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_lmeter_set_value(lmeter, ext->cur_value);
    }
    if(ext->cur_value < min) {
        ext->cur_value = min;
        lv_lmeter_set_value(lmeter, ext->cur_value);
    }
    lv_obj_invalidate(lmeter);
}

// 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 0x24ad9
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
cmpw %bp, 0x8(%rax)
jne 0x24aea
cmpw %r14w, 0xa(%r15)
jne 0x24aea
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a654(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x24ae8
movw %r14w, 0xa(%r15)
movw %bp, 0x8(%r15)
cmpw %r14w, 0x6(%r15)
jle 0x24b0c
movw %r14w, 0x6(%r15)
movswl %r14w, %esi
movq %rbx, %rdi
callq 0x24a41
cmpw %bp, 0x6(%r15)
jge 0x24b23
movw %bp, 0x6(%r15)
movswl %bp, %esi
movq %rbx, %rdi
callq 0x24a41
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_lmeter.c
// Function: lv_lmeter_set_scale
void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint16_t line_cnt)
{
    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);

    lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
    if(ext->scale_angle == angle && ext->line_cnt == line_cnt) return;

    ext->scale_angle = angle;
    ext->line_cnt    = line_cnt;

    lv_obj_invalidate(lmeter);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x24b63
movq %rbx, %rdi
callq 0x6ad8
cmpw %r14w, (%rax)
jne 0x24b74
cmpw %bp, 0x4(%rax)
jne 0x24b74
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a5ca(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x24b72
movw %r14w, (%rax)
movw %bp, 0x4(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_lmeter.c
// Function: lv_lmeter_set_angle_offset
void lv_lmeter_set_angle_offset(lv_obj_t * lmeter, uint16_t angle)
{
    lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
    if(ext->angle_ofs == angle) return;

    ext->angle_ofs = angle;

    lv_obj_invalidate(lmeter);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6ad8
cmpw %bp, 0x2(%rax)
jne 0x24ba2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movw %bp, 0x2(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_scrl_design
static bool lv_scrl_design(lv_obj_t * scrl, const lv_area_t * mask, lv_design_mode_t mode)
{
    if(mode == LV_DESIGN_COVER_CHK) {
        return ancestor_design(scrl, mask, mode);
    } else if(mode == LV_DESIGN_DRAW_MAIN) {
#if LV_USE_GROUP
        /* If the page is focused in a group and
         * the background object is not visible (transparent)
         * then "activate" the style of the scrollable*/
        const lv_style_t * style_scrl_ori = lv_obj_get_style(scrl);
        lv_obj_t * page                   = lv_obj_get_parent(scrl);
        const lv_style_t * style_page     = lv_obj_get_style(page);
        lv_group_t * g                    = lv_obj_get_group(page);
        if((style_page->body.opa == LV_OPA_TRANSP) &&
           style_page->body.border.width == 0) { /*Is the background visible?*/
            if(lv_group_get_focused(g) == page) {
                lv_style_t * style_mod;
                style_mod = lv_group_mod_style(g, style_scrl_ori);
                /*If still not visible modify the style a littel bit*/
                if((style_mod->body.opa == LV_OPA_TRANSP) && style_mod->body.border.width == 0) {
                    style_mod->body.opa          = LV_OPA_50;
                    style_mod->body.border.width = 1;
                    style_mod                    = lv_group_mod_style(g, style_mod);
                }

                scrl->style_p = style_mod; /*Temporally change the style to the activated */
            }
        }
#endif
        ancestor_design(scrl, mask, mode);

#if LV_USE_GROUP
        scrl->style_p = style_scrl_ori; /*Revert the style*/
#endif
    } else if(mode == LV_DESIGN_DRAW_POST) {
        ancestor_design(scrl, mask, mode);
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x25545
cmpl $0x1, %ebp
je 0x25530
cmpl $0x2, %ebp
jne 0x255d4
movq 0x3af5a(%rip), %rax     # 0x60470
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x3af30(%rip)          # 0x60470
jmp 0x255d4
movq %rbx, %rdi
callq 0x6697
movq %rax, %r15
movq %rbx, %rdi
callq 0x4abf
movq %rax, %r13
movq %rax, %rdi
callq 0x6697
movq %rax, %r12
movq %r13, %rdi
callq 0x4ea3
cmpb $0x0, 0x8(%r12)
jne 0x255c0
cmpw $0x0, 0xc(%r12)
jne 0x255c0
movq %rax, %rdi
movq %rax, %r12
callq 0x2a39
cmpq %r13, %rax
jne 0x255c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2ac5
cmpb $0x0, 0x8(%rax)
jne 0x255bc
cmpw $0x0, 0xc(%rax)
jne 0x255bc
movb $0x7f, 0x8(%rax)
movw $0x1, 0xc(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x2ac5
movq %rax, 0x48(%rbx)
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x3aea0(%rip)          # 0x60470
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_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_set_sb_mode
void lv_page_set_sb_mode(lv_obj_t * page, lv_sb_mode_t sb_mode)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
    if(ext->sb.mode == sb_mode) return;

    if(sb_mode == LV_SB_MODE_HIDE)
        ext->sb.mode |= LV_SB_MODE_HIDE; /*Set the hidden flag*/
    else if(sb_mode == LV_SB_MODE_UNHIDE)
        ext->sb.mode &= (~LV_SB_MODE_HIDE); /*Clear the hidden flag*/
    else {
        if(ext->sb.mode & LV_SB_MODE_HIDE) sb_mode |= LV_SB_MODE_HIDE;
        ext->sb.mode = sb_mode;
    }

    ext->sb.hor_draw = 0;
    ext->sb.ver_draw = 0;

    lv_page_sb_refresh(page);
    lv_obj_invalidate(page);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x25cb3
movq %rbx, %rdi
callq 0x6ad8
movb 0x28(%rax), %cl
movl %ecx, %edx
shrb $0x2, %dl
andb $0x7, %dl
cmpb %bpl, %dl
jne 0x25cc4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1947a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x25cc2
cmpb $0x5, %bpl
je 0x25ce0
movzbl %bpl, %esi
cmpl $0x4, %esi
jne 0x25ce5
shlb $0x2, %dl
andb $-0x1d, %cl
orb %dl, %cl
orb $0x10, %cl
jmp 0x25d03
andb $-0x11, %cl
jmp 0x25d03
shlb $0x2, %bpl
movzbl %bpl, %esi
orb $0x10, %bpl
cmpb $0x4, %dl
movzbl %bpl, %edx
cmovbl %esi, %edx
andb $0x1c, %dl
andb $-0x1d, %cl
orb %dl, %cl
andb $-0x4, %cl
movb %cl, 0x28(%rax)
movq %rbx, %rdi
callq 0x25e4c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_set_style
void lv_page_set_style(lv_obj_t * page, lv_page_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);

    switch(type) {
        case LV_PAGE_STYLE_BG: lv_obj_set_style(page, style); break;
        case LV_PAGE_STYLE_SCRL: lv_obj_set_style(ext->scrl, style); break;
        case LV_PAGE_STYLE_SB:
            ext->sb.style = style;
            lv_area_set_height(&ext->sb.hor_area, ext->sb.style->body.padding.inner);
            lv_area_set_width(&ext->sb.ver_area, ext->sb.style->body.padding.inner);
            lv_page_sb_refresh(page);
            lv_obj_refresh_ext_draw_pad(page);
            lv_obj_invalidate(page);
            break;
#if LV_USE_ANIMATION
        case LV_PAGE_STYLE_EDGE_FLASH: ext->edge_flash.style = style; break;
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x25d61
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x3, %bpl
ja 0x25dbe
movq %rax, %r15
movzbl %bpl, %eax
leaq 0x19cd1(%rip), %rcx     # 0x3fa24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
jmp 0x25dcd
leaq 0x193cc(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x25d70
movq %r14, 0x10(%r15)
leaq 0x18(%r15), %rdi
movswl 0x1e(%r14), %esi
callq 0x28613
movq %r15, %rdi
addq $0x20, %rdi
movq 0x10(%r15), %rax
movswl 0x1e(%rax), %esi
callq 0x28609
movq %rbx, %rdi
callq 0x25e4c
movq %rbx, %rdi
callq 0x64f5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c36
movq %r14, 0x38(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d83
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_get_style
const lv_style_t * lv_page_get_style(const lv_obj_t * page, lv_page_style_t type)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_page_ext_t * ext      = lv_obj_get_ext_attr(page);

    switch(type) {
        case LV_PAGE_STYLE_BG: style = lv_obj_get_style(page); break;
        case LV_PAGE_STYLE_SCRL: style = lv_obj_get_style(ext->scrl); break;
        case LV_PAGE_STYLE_SB: style = ext->sb.style; break;
#if LV_USE_ANIMATION
        case LV_PAGE_STYLE_EDGE_FLASH: style = ext->edge_flash.style; break;
#endif
        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 0x25e17
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x3, %bpl
ja 0x25e43
movzbl %bpl, %ecx
leaq 0x19c2b(%rip), %rdx     # 0x3fa34
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
jmp 0x25e38
leaq 0x19316(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x25e26
movq 0x10(%rax), %rax
jmp 0x25e45
movq 0x38(%rax), %rax
jmp 0x25e45
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6697
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_set_anim_time
void lv_page_set_anim_time(lv_obj_t * page, uint16_t anim_time)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
    ext->anim_time      = anim_time;
#else
    (void)page;      /*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 0x262da
movq %r14, %rdi
callq 0x6ad8
movw %bx, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18e53(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x262e9
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_set_edge_flash
void lv_page_set_edge_flash(lv_obj_t * page, bool en)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_page_ext_t * ext     = lv_obj_get_ext_attr(page);
    ext->edge_flash.enabled = en ? 1 : 0;
#else
    (void)page;
    (void)en;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x26356
movq %r14, %rdi
callq 0x6ad8
movb 0x40(%rax), %cl
andb $-0x2, %cl
orb %bl, %cl
movb %cl, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18dd7(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x26365
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_get_anim_time
uint16_t lv_page_get_anim_time(const lv_obj_t * page)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x26382
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x48(%rax), %eax
popq %rbx
retq
leaq 0x18dab(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x26391
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_get_edge_flash
bool lv_page_get_edge_flash(lv_obj_t * page)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
    return ext->edge_flash.enabled == 0 ? false : true;
#else
    (void)page;
    return false;
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x2640c
movq %rbx, %rdi
callq 0x6ad8
movb 0x40(%rax), %al
andb $0x1, %al
popq %rbx
retq
leaq 0x18d21(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x2641b
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_get_fit_width
lv_coord_t lv_page_get_fit_width(lv_obj_t * page)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

    const lv_style_t * bg_style   = lv_page_get_style(page, LV_PAGE_STYLE_BG);
    const lv_style_t * scrl_style = lv_page_get_style(page, LV_PAGE_STYLE_SCRL);

    return lv_obj_get_width(page) - bg_style->body.padding.left - bg_style->body.padding.right -
           scrl_style->body.padding.left - scrl_style->body.padding.right;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x2646f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25ddf
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x25ddf
movq %rax, %r15
movq %rbx, %rdi
callq 0x5651
movzwl 0x1a(%r14), %ecx
addw 0x1c(%r14), %cx
addw 0x1a(%r15), %cx
addw 0x1c(%r15), %cx
subl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18cbe(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x2647e
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_get_fit_height
lv_coord_t lv_page_get_fit_height(lv_obj_t * page)
{
    LV_ASSERT_OBJ(page, LV_OBJX_NAME);

    const lv_style_t * bg_style   = lv_page_get_style(page, LV_PAGE_STYLE_BG);
    const lv_style_t * scrl_style = lv_page_get_style(page, LV_PAGE_STYLE_SCRL);

    return lv_obj_get_height(page) - bg_style->body.padding.top - bg_style->body.padding.bottom -
           scrl_style->body.padding.top - scrl_style->body.padding.bottom;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x264d2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25ddf
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x25ddf
movq %rax, %r15
movq %rbx, %rdi
callq 0x567b
movzwl 0x16(%r14), %ecx
addw 0x18(%r14), %cx
addw 0x16(%r15), %cx
addw 0x18(%r15), %cx
subl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18c5b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x264e1
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_on_edge
bool lv_page_on_edge(lv_obj_t * page, lv_page_edge_t edge)
{
    const lv_style_t * page_style = lv_obj_get_style(page);
    lv_obj_t * scrl               = lv_page_get_scrl(page);
    lv_area_t page_coords;
    lv_area_t scrl_coords;

    lv_obj_get_coords(scrl, &scrl_coords);
    lv_obj_get_coords(page, &page_coords);

    if((edge & LV_PAGE_EDGE_TOP) && scrl_coords.y1 == page_coords.y1 + page_style->body.padding.top) return true;
    if((edge & LV_PAGE_EDGE_BOTTOM) && scrl_coords.y2 == page_coords.y2 - page_style->body.padding.bottom) return true;
    if((edge & LV_PAGE_EDGE_LEFT) && scrl_coords.x1 == page_coords.x1 + page_style->body.padding.left) return true;
    if((edge & LV_PAGE_EDGE_RIGHT) && scrl_coords.x2 == page_coords.x2 - page_style->body.padding.right) return true;

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0x6697
movq %rax, %rbx
movq %r14, %rdi
callq 0x26288
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5427
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5427
testb $0x2, %bpl
je 0x26534
movswl 0x2(%rsp), %ecx
movswl 0xa(%rsp), %eax
movswl 0x16(%rbx), %edx
addl %eax, %edx
movb $0x1, %al
cmpl %ecx, %edx
je 0x26589
testb $0x8, %bpl
je 0x26550
movswl 0x6(%rsp), %ecx
movswl 0xe(%rsp), %edx
movswl 0x18(%rbx), %eax
subl %eax, %edx
movb $0x1, %al
cmpl %ecx, %edx
je 0x26589
testb $0x1, %bpl
je 0x2656b
movswl (%rsp), %ecx
movswl 0x8(%rsp), %eax
movswl 0x1a(%rbx), %edx
addl %eax, %edx
movb $0x1, %al
cmpl %ecx, %edx
je 0x26589
testb $0x4, %bpl
je 0x26587
movswl 0x4(%rsp), %ecx
movswl 0xc(%rsp), %edx
movswl 0x1c(%rbx), %eax
subl %eax, %edx
movb $0x1, %al
cmpl %ecx, %edx
je 0x26589
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_scroll_hor
void lv_page_scroll_hor(lv_obj_t * page, lv_coord_t dist)
{
    lv_obj_t * scrl = lv_page_get_scrl(page);

#if LV_USE_ANIMATION
    lv_anim_t a;
    a.var            = scrl;
    a.start          = lv_obj_get_x(scrl);
    a.end            = a.start + dist;
    a.exec_cb        = (lv_anim_exec_xcb_t)lv_obj_set_x;
    a.path_cb        = lv_anim_path_linear;
    a.ready_cb       = NULL;
    a.act_time       = 0;
    a.time           = LV_PAGE_SCROLL_ANIM_TIME;
    a.playback       = 0;
    a.playback_pause = 0;
    a.repeat         = 0;
    a.repeat_pause   = 0;
    lv_anim_create(&a);
#else
    lv_obj_set_x(scrl, lv_obj_get_x(scrl) + dist);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
callq 0x26288
movq %rsp, %r14
movq %rax, (%r14)
movq %rax, %rdi
callq 0x4bc6
cwtl
movl %eax, 0x20(%r14)
addl %eax, %ebx
movl %ebx, 0x24(%r14)
leaq -0x213f9(%rip), %rax    # 0x54c3
movq %rax, 0x8(%r14)
leaq 0x2c2e(%rip), %rax      # 0x294f5
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq $0xc8, 0x28(%r14)
andb $-0x4, 0x30(%r14)
movq %r14, %rdi
callq 0x29521
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_scroll_ver
void lv_page_scroll_ver(lv_obj_t * page, lv_coord_t dist)
{
    lv_obj_t * scrl = lv_page_get_scrl(page);

#if LV_USE_ANIMATION
    lv_anim_t a;
    a.var            = scrl;
    a.start          = lv_obj_get_y(scrl);
    a.end            = a.start + dist;
    a.exec_cb        = (lv_anim_exec_xcb_t)lv_obj_set_y;
    a.path_cb        = lv_anim_path_linear;
    a.ready_cb       = NULL;
    a.act_time       = 0;
    a.time           = LV_PAGE_SCROLL_ANIM_TIME;
    a.playback       = 0;
    a.playback_pause = 0;
    a.repeat         = 0;
    a.repeat_pause   = 0;
    lv_anim_create(&a);
#else
    lv_obj_set_y(scrl, lv_obj_get_y(scrl) + dist);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
callq 0x26288
movq %rsp, %r14
movq %rax, (%r14)
movq %rax, %rdi
callq 0x4bfe
cwtl
movl %eax, 0x20(%r14)
addl %eax, %ebx
movl %ebx, 0x24(%r14)
leaq -0x2141d(%rip), %rax    # 0x5501
movq %rax, 0x8(%r14)
leaq 0x2bcc(%rip), %rax      # 0x294f5
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq $0xc8, 0x28(%r14)
andb $-0x4, 0x30(%r14)
movq %r14, %rdi
callq 0x29521
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_page.c
// Function: lv_page_start_edge_flash
void lv_page_start_edge_flash(lv_obj_t * page)
{
#if LV_USE_ANIMATION
    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
    if(ext->edge_flash.enabled) {
        lv_anim_t a;
        a.var            = page;
        a.start          = 0;
        a.end            = LV_PAGE_END_FLASH_SIZE;
        a.exec_cb        = (lv_anim_exec_xcb_t)edge_flash_anim;
        a.path_cb        = lv_anim_path_linear;
        a.ready_cb       = edge_flash_anim_end;
        a.act_time       = 0;
        a.time           = LV_PAGE_END_ANIM_TIME;
        a.playback       = 1;
        a.playback_pause = LV_PAGE_END_ANIM_WAIT_TIME;
        a.repeat         = 0;
        a.repeat_pause   = 0;
        lv_anim_create(&a);
    }
#else
    (void)page; /*Unused*/
#endif
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x6ad8
testb $0x1, 0x40(%rax)
je 0x269b9
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movabsq $0x1900000000, %rax     # imm = 0x1900000000
movq %rax, 0x20(%rdi)
leaq 0x3d(%rip), %rax        # 0x269bf
movq %rax, 0x8(%rdi)
leaq 0x2b68(%rip), %rax      # 0x294f5
movq %rax, 0x10(%rdi)
leaq 0x48(%rip), %rax        # 0x269e0
movq %rax, 0x18(%rdi)
movabsq $0x12c0000012c, %rax    # imm = 0x12C0000012C
movq %rax, 0x28(%rdi)
movb 0x30(%rdi), %al
orb $0x1, %al
andb $-0x3, %al
movb %al, 0x30(%rdi)
callq 0x29521
addq $0x40, %rsp
popq %rbx
retq