LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_style
void lv_ta_set_style(lv_obj_t * ta, lv_ta_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);

    switch(type) {
        case LV_TA_STYLE_BG: lv_page_set_style(ta, LV_PAGE_STYLE_BG, style); break;
        case LV_TA_STYLE_SB: lv_page_set_style(ta, LV_PAGE_STYLE_SB, style); break;
        case LV_TA_STYLE_EDGE_FLASH: lv_page_set_style(ta, LV_PAGE_STYLE_EDGE_FLASH, style); break;
        case LV_TA_STYLE_CURSOR:
            ext->cursor.style = style;
            lv_obj_refresh_ext_draw_pad(lv_page_get_scrl(ta)); /*Refresh ext. size because of cursor drawing*/
            refr_cursor_area(ta);
            break;
        case LV_TA_STYLE_PLACEHOLDER:
            if(ext->placeholder) lv_label_set_style(ext->placeholder, LV_LABEL_STYLE_MAIN, style);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1e536
movq %r14, %rdi
callq 0x6ad8
cmpb $0x4, %bpl
ja 0x1e55c
movzbl %bpl, %ecx
leaq 0x2133e(%rip), %rdx     # 0x3f864
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
xorl %esi, %esi
jmp 0x1e593
leaq 0x20bf7(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1e545
movq 0x58(%rax), %rdi
testq %rdi, %rdi
je 0x1e55c
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d83
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, 0x78(%rax)
movq %r14, %rdi
callq 0x26288
movq %rax, %rdi
callq 0x64f5
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1f77a
movq %r14, %rdi
movl $0x3, %esi
jmp 0x1e593
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x25d1f
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: pwd_char_hider
static void pwd_char_hider(lv_obj_t * ta)
{
    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    if(ext->pwd_mode != 0) {
        char * txt  = lv_label_get_text(ext->label);
        int16_t len = lv_txt_get_encoded_length(txt);
        bool refr   = false;
        uint16_t i;
        for(i = 0; i < len; i++) {
            txt[i] = '*';
            refr   = true;
        }

        txt[i] = '\0';

        if(refr != false) lv_label_set_text(ext->label, txt);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x6ad8
testb $0x1, 0x98(%rax)
je 0x1e600
movq %rax, %rbx
movq 0x50(%rax), %rdi
callq 0x1a239
movq %rax, %r14
leaq 0x35089(%rip), %rax     # 0x53650
movq %r14, %rdi
callq *(%rax)
movl %eax, %ebp
movswl %bp, %eax
testl %eax, %eax
jle 0x1e5fc
movl %eax, %edx
movq %r14, %rdi
movl $0x2a, %esi
callq 0x20a0
movzwl %bp, %eax
movb $0x0, (%r14,%rax)
movq 0x50(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x19f13
movb $0x0, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_get_style
const lv_style_t * lv_ta_get_style(const lv_obj_t * ta, lv_ta_style_t type)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_ta_ext_t * ext        = lv_obj_get_ext_attr(ta);

    switch(type) {
        case LV_TA_STYLE_BG: style = lv_page_get_style(ta, LV_PAGE_STYLE_BG); break;
        case LV_TA_STYLE_SB: style = lv_page_get_style(ta, LV_PAGE_STYLE_SB); break;
        case LV_TA_STYLE_EDGE_FLASH: style = lv_page_get_style(ta, LV_PAGE_STYLE_EDGE_FLASH); break;
        case LV_TA_STYLE_CURSOR: style = ext->cursor.style; break;
        case LV_TA_STYLE_PLACEHOLDER:
            if(ext->placeholder) style = lv_label_get_style(ext->placeholder, LV_LABEL_STYLE_MAIN);
            break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1e7b9
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x4, %bpl
ja 0x1e7de
movzbl %bpl, %ecx
leaq 0x210cf(%rip), %rdx     # 0x3f878
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1e7ff
leaq 0x20974(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1e7c8
movq 0x58(%rax), %rdi
testq %rdi, %rdi
je 0x1e7de
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6697
xorl %eax, %eax
jmp 0x1e7e6
movq 0x78(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x1e7ff
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25ddf
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: cursor_blink_anim
static void cursor_blink_anim(lv_obj_t * ta, lv_anim_value_t show)
{
    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    if(show != ext->cursor.state) {
        ext->cursor.state = show == 0 ? 0 : 1;
        if(ext->cursor.type != LV_CURSOR_NONE && (ext->cursor.type & LV_CURSOR_HIDDEN) == 0) {
            lv_disp_t * disp = lv_obj_get_disp(ta);
            lv_area_t area_tmp;
            lv_area_copy(&area_tmp, &ext->cursor.area);
            area_tmp.x1 += ext->label->coords.x1;
            area_tmp.y1 += ext->label->coords.y1;
            area_tmp.x2 += ext->label->coords.x1;
            area_tmp.y2 += ext->label->coords.y1;
            lv_inv_area(disp, &area_tmp);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0x6ad8
movq %rax, %rbx
movzbl 0x90(%rax), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0x1, %ecx
cmpw %bp, %cx
je 0x1e892
testw %bp, %bp
setne %cl
shlb $0x4, %cl
movl %eax, %edx
andb $-0x11, %dl
orb %cl, %dl
movb %dl, 0x90(%rbx)
testb $0xf, %al
sete %cl
andb $0x8, %al
shrb $0x3, %al
orb %cl, %al
jne 0x1e892
movq %r14, %rdi
callq 0x5033
movq 0x86(%rbx), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x50(%rbx), %rdx
movl 0x20(%rdx), %edi
addl %edi, %ecx
movw %cx, (%rsi)
movzwl 0x22(%rdx), %ecx
addw %cx, 0x2(%rsi)
addw %di, 0x4(%rsi)
addw %cx, 0x6(%rsi)
movq %rax, %rdi
callq 0x7184
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_ta.c
// Function: placeholder_update
static void placeholder_update(lv_obj_t * ta)
{
    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    const char * ta_text;

    if(ext->placeholder == NULL) return;

    ta_text = lv_ta_get_text(ta);

    if(ta_text[0] == '\0') {
        /*Be sure the main label and the placeholder has the same coordinates*/
        lv_obj_t * scrl               = lv_page_get_scrl(ta);
        const lv_style_t * style_scrl = lv_obj_get_style(scrl);
        lv_obj_set_pos(ext->placeholder, style_scrl->body.padding.left, style_scrl->body.padding.top);
        lv_obj_set_pos(ext->label, style_scrl->body.padding.left, style_scrl->body.padding.top);

        lv_obj_set_width(ext->placeholder, lv_page_get_fit_width(ta));
        lv_obj_set_hidden(ext->placeholder, false);
    } else {
        lv_obj_set_hidden(ext->placeholder, true);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6ad8
cmpq $0x0, 0x58(%rax)
je 0x1f107
movq %rax, %rbx
movq %r14, %rdi
callq 0x1fea7
movb (%rax), %bpl
testb %bpl, %bpl
jne 0x1f0eb
movq %r14, %rdi
callq 0x26288
movq %rax, %rdi
callq 0x6697
movq %rax, %r15
movq 0x58(%rbx), %rdi
movswl 0x1a(%rax), %esi
movswl 0x16(%rax), %edx
callq 0x4ae2
movq 0x50(%rbx), %rdi
movswl 0x1a(%r15), %esi
movswl 0x16(%r15), %edx
callq 0x4ae2
movq 0x58(%rbx), %r15
movq %r14, %rdi
callq 0x2641d
movswl %ax, %esi
movq %r15, %rdi
callq 0x56f1
xorl %esi, %esi
testb %bpl, %bpl
setne %sil
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5f68
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_ta.c
// Function: lv_ta_del_char_forward
void lv_ta_del_char_forward(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    uint16_t cp = lv_ta_get_cursor_pos(ta);
    lv_ta_set_cursor_pos(ta, cp + 1);
    if(cp != lv_ta_get_cursor_pos(ta)) lv_ta_del_char(ta);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1f37e
movq %rbx, %rdi
callq 0x1f045
movl %eax, %r14d
leal 0x1(%r14), %eax
movswl %ax, %esi
movq %rbx, %rdi
callq 0x1edf8
movq %rbx, %rdi
callq 0x1f045
cmpw %ax, %r14w
jne 0x1f38f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1fdaf(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1f38d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f16a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_placeholder_text
void lv_ta_set_placeholder_text(lv_obj_t * ta, const char * txt)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
    LV_ASSERT_NULL(txt);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);

    /*Create the placeholder label only when it is needed*/
    if(ext->placeholder == NULL) {
        ext->placeholder = lv_label_create(ta, NULL);

        if(ext->one_line) {
            lv_label_set_long_mode(ext->placeholder, LV_LABEL_LONG_EXPAND);
        } else {
            lv_label_set_long_mode(ext->placeholder, LV_LABEL_LONG_BREAK);
        }
    }

    lv_label_set_text(ext->placeholder, txt);

    /*Refresh the placeholder's align*/
    lv_ta_set_text_align(ta, lv_label_get_align(ext->label));

    placeholder_update(ta);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1f647
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x1f658
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
cmpq $0x0, 0x58(%rax)
jne 0x1f61a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x196f4
movq %rax, 0x58(%r15)
xorl %esi, %esi
testb $0x2, 0x98(%r15)
sete %sil
movq %rax, %rdi
callq 0x19e3d
movq 0x58(%r15), %rdi
movq %r14, %rsi
callq 0x19f13
movq 0x50(%r15), %rdi
callq 0x1a1ff
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1f669
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1f074
leaq 0x1fae6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1f656
leaq 0x1fad5(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1f667
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_text_align
void lv_ta_set_text_align(lv_obj_t * ta, lv_label_align_t align)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    lv_obj_t * label  = lv_ta_get_label(ta);
    if(!ext->one_line) {
        lv_label_set_align(label, align);
        if(ext->placeholder) lv_label_set_align(ext->placeholder, align);
    } else {
        /*Normal left align. Just let the text expand*/
        if(align == LV_LABEL_ALIGN_LEFT) {
            lv_label_set_long_mode(label, LV_LABEL_LONG_EXPAND);
            lv_page_set_scrl_fit2(ta, LV_FIT_TIGHT, LV_FIT_FLOOD);
            lv_label_set_align(label, align);
            if(ext->placeholder) lv_label_set_align(ext->placeholder, align);

        }
        /*Else use fix label width equal to the Text area width*/
        else {
            lv_label_set_long_mode(label, LV_LABEL_LONG_CROP);
            lv_page_set_scrl_fit2(ta, LV_FIT_FLOOD, LV_FIT_FLOOD);
            lv_label_set_align(label, align);
            if(ext->placeholder) lv_label_set_align(ext->placeholder, align);

            lv_obj_set_width(label, lv_page_get_fit_width(ta));
        }
    }

    refr_cursor_area(ta);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1f710
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
movq %rbx, %rdi
callq 0x1fcf3
movq %rax, %r14
testb $0x2, 0x98(%r15)
je 0x1f74d
movq %r14, %rdi
testb %bpl, %bpl
je 0x1f721
movl $0x5, %esi
callq 0x19e3d
movq %rbx, %rdi
callq 0x26288
movq %rax, %rdi
movl $0x2, %esi
movl $0x2, %edx
movl $0x2, %ecx
movl $0x2, %r8d
callq 0x22602
movzbl %bpl, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1a196
movq 0x58(%r15), %rdi
testq %rdi, %rdi
je 0x1f6fb
movl %ebp, %esi
callq 0x1a196
movq %rbx, %rdi
callq 0x2641d
movswl %ax, %esi
movq %r14, %rdi
callq 0x56f1
jmp 0x1f76b
leaq 0x1fa1d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1f71f
xorl %esi, %esi
callq 0x19e3d
movq %rbx, %rdi
callq 0x26288
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
movl $0x2, %ecx
movl $0x2, %r8d
callq 0x22602
movzbl %bpl, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1a196
movq 0x58(%r15), %rdi
testq %rdi, %rdi
je 0x1f76b
movl %ebp, %esi
callq 0x1a196
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1f77a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_cursor_type
void lv_ta_set_cursor_type(lv_obj_t * ta, lv_cursor_type_t cur_type)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    if(ext->cursor.type == cur_type) return;

    ext->cursor.type = cur_type;

    refr_cursor_area(ta);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1fb03
movq %rbx, %rdi
callq 0x6ad8
movb 0x90(%rax), %cl
movl %ecx, %edx
andb $0xf, %dl
cmpb %bpl, %dl
jne 0x1fb14
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f62a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fb12
andb $0xf, %bpl
andb $-0x10, %cl
orb %bpl, %cl
movb %cl, 0x90(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1f77a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_pwd_mode
void lv_ta_set_pwd_mode(lv_obj_t * ta, bool en)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    if(ext->pwd_mode == en) return;

    /*Pwd mode is now enabled*/
    if(ext->pwd_mode == 0 && en != false) {
        char * txt   = lv_label_get_text(ext->label);
        size_t len = strlen(txt);
        ext->pwd_tmp = lv_mem_alloc(len + 1);
        LV_ASSERT_MEM(ext->pwd_tmp);
        if(ext->pwd_tmp == NULL) return;

        strcpy(ext->pwd_tmp, txt);

        uint16_t i;
        uint16_t encoded_len = lv_txt_get_encoded_length(txt); 
        for(i = 0; i < encoded_len; i++) {
            txt[i] = '*'; /*All char to '*'*/
        }
        txt[i] = '\0';

        lv_ta_clear_selection(ta);

        lv_label_set_text(ext->label, NULL);
    }
    /*Pwd mode is now disabled*/
    else if(ext->pwd_mode == 1 && en == false) {
        lv_ta_clear_selection(ta);
        lv_label_set_text(ext->label, ext->pwd_tmp);
        lv_mem_free(ext->pwd_tmp);
        ext->pwd_tmp = NULL;
    }

    ext->pwd_mode = en == false ? 0 : 1;

    refr_cursor_area(ta);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1fc31
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r14
movb 0x98(%rax), %al
movl %eax, %ecx
andb $0x1, %cl
cmpb %bpl, %cl
je 0x1fc42
movl %ebp, %ecx
notb %cl
orb %al, %cl
testb $0x1, %cl
jne 0x1fc4b
movq 0x50(%r14), %rdi
callq 0x1a239
movq %rax, %r15
movq %rax, %rdi
callq 0x2070
leaq 0x1(%rax), %rdi
callq 0x298d9
movq %rax, 0x60(%r14)
movq %rax, %rdi
callq 0x80d4
movq 0x60(%r14), %rsi
testb %al, %al
je 0x1fc81
testq %rsi, %rsi
je 0x1fc42
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2040
leaq 0x33a43(%rip), %rax     # 0x53650
movq %r15, %rdi
callq *(%rax)
testw %ax, %ax
je 0x1fca0
movzwl %ax, %r12d
movq %r15, %rdi
movl $0x2a, %esi
movq %r12, %rdx
callq 0x20a0
jmp 0x1fca3
leaq 0x1f4fc(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fc40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %al
sete %al
orb %bpl, %al
jne 0x1fcbf
movq %rbx, %rdi
callq 0x80d4
testb %al, %al
je 0x1fc8f
movq 0x50(%r14), %rdi
movq 0x60(%r14), %rsi
callq 0x19f13
movq 0x60(%r14), %rdi
callq 0x29984
movq $0x0, 0x60(%r14)
jmp 0x1fcbf
leaq 0x1f3b8(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1fc8d
leaq 0x1f49e(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fc9e
xorl %r12d, %r12d
movb $0x0, (%r15,%r12)
movq %rbx, %rdi
callq 0x80d4
testb %al, %al
je 0x1fce2
movq 0x50(%r14), %rdi
xorl %esi, %esi
callq 0x19f13
movb 0x98(%r14), %al
andb $-0x2, %al
orb %bpl, %al
movb %al, 0x98(%r14)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1f77a
leaq 0x1f44b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fcf1
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_pwd_show_time
void lv_ta_set_pwd_show_time(lv_obj_t * ta, uint16_t time)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

#if LV_USE_ANIMATION == 0
    time = 0;
#endif

    lv_ta_ext_t * ext  = lv_obj_get_ext_attr(ta);
    ext->pwd_show_time = time;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1fe07
movq %r14, %rdi
callq 0x6ad8
movw %bx, 0x72(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1f326(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1fe16
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_set_cursor_blink_time
void lv_ta_set_cursor_blink_time(lv_obj_t * ta, uint16_t time)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

#if LV_USE_ANIMATION == 0
    time = 0;
#endif

    lv_ta_ext_t * ext      = lv_obj_get_ext_attr(ta);
    ext->cursor.blink_time = time;

#if LV_USE_ANIMATION
    if(ext->cursor.blink_time) {
        /*Reset cursor blink animation*/
        lv_anim_t a;
        a.var            = ta;
        a.exec_cb        = (lv_anim_exec_xcb_t)cursor_blink_anim;
        a.time           = ext->cursor.blink_time;
        a.act_time       = 0;
        a.ready_cb       = NULL;
        a.start          = 1;
        a.end            = 0;
        a.repeat         = 1;
        a.repeat_pause   = 0;
        a.playback       = 1;
        a.playback_pause = 0;
        a.path_cb        = lv_anim_path_step;
        lv_anim_create(&a);
    } else {
        ext->cursor.state = 1;
    }
#else
    ext->cursor.state = 1;
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1fe88
movq %rbx, %rdi
callq 0x6ad8
movw %bp, 0x84(%rax)
testw %bp, %bp
je 0x1fe99
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq -0x1643(%rip), %rax     # 0x1e80a
movq %rax, 0x8(%rdi)
movw %bp, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
orb $0x3, 0x30(%rdi)
movl $0x0, 0x2c(%rdi)
leaq 0x9a2d(%rip), %rax      # 0x298aa
movq %rax, 0x10(%rdi)
callq 0x29521
jmp 0x1fea0
leaq 0x1f2a5(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fe97
orb $0x10, 0x90(%rax)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_get_text
const char * lv_ta_get_text(const lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);

    const char * txt;
    if(ext->pwd_mode == 0) {
        txt = lv_label_get_text(ext->label);
    } else {
        txt = ext->pwd_tmp;
    }

    return txt;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1fecf
movq %rbx, %rdi
callq 0x6ad8
testb $0x1, 0x98(%rax)
jne 0x1fee0
movq 0x50(%rax), %rdi
popq %rbx
jmp 0x1a239
leaq 0x1f25e(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1fede
movq 0x60(%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_get_placeholder_text
const char * lv_ta_get_placeholder_text(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);

    const char * txt = NULL;

    if(ext->placeholder) txt = lv_label_get_text(ext->placeholder);

    return txt;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1ff0a
movq %rbx, %rdi
callq 0x6ad8
movq 0x58(%rax), %rdi
testq %rdi, %rdi
je 0x1ff1b
popq %rbx
jmp 0x1a239
leaq 0x1f223(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1ff19
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_cursor_right
void lv_ta_cursor_right(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    uint16_t cp = lv_ta_get_cursor_pos(ta);
    cp++;
    lv_ta_set_cursor_pos(ta, cp);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x200a6
movq %rbx, %rdi
callq 0x1f045
incl %eax
movswl %ax, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1edf8
leaq 0x1f087(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x200b5
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_cursor_left
void lv_ta_cursor_left(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    uint16_t cp = lv_ta_get_cursor_pos(ta);
    if(cp > 0) {
        cp--;
        lv_ta_set_cursor_pos(ta, cp);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x200df
movq %rbx, %rdi
callq 0x1f045
testw %ax, %ax
je 0x200f0
decl %eax
movswl %ax, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1edf8
leaq 0x1f04e(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x200ee
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_cursor_down
void lv_ta_cursor_down(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    lv_point_t pos;

    /*Get the position of the current letter*/
    lv_label_get_letter_pos(ext->label, lv_ta_get_cursor_pos(ta), &pos);

    /*Increment the y with one line and keep the valid x*/
    const lv_style_t * label_style = lv_obj_get_style(ext->label);
    const lv_font_t * font_p       = label_style->text.font;
    lv_coord_t font_h              = lv_font_get_line_height(font_p);
    pos.y += font_h + label_style->text.line_space + 1;
    pos.x = ext->cursor.valid_x;

    /*Do not go below the last line*/
    if(pos.y < lv_obj_get_height(ext->label)) {
        /*Get the letter index on the new cursor position and set it*/
        uint16_t new_cur_pos = lv_label_get_letter_on(ext->label, &pos);

        lv_coord_t cur_valid_x_tmp = ext->cursor.valid_x; /*Cursor position set overwrites the valid positon */
        lv_ta_set_cursor_pos(ta, new_cur_pos);
        ext->cursor.valid_x = cur_valid_x_tmp;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x201ac
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r14
movq 0x50(%rax), %r15
movq %rbx, %rdi
callq 0x1f045
movzwl %ax, %esi
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x1ace1
movq 0x50(%r14), %rdi
callq 0x6697
movq 0x28(%rax), %rcx
movzbl 0x10(%rcx), %ebp
addw 0x32(%rax), %bp
addw 0x2(%r12), %bp
incl %ebp
movw %bp, 0x2(%r12)
movzwl 0x80(%r14), %eax
movw %ax, (%r12)
movq 0x50(%r14), %rdi
callq 0x567b
cmpw %ax, %bp
jge 0x2019f
movq 0x50(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1af91
movzwl 0x80(%r14), %ebp
movswl %ax, %esi
movq %rbx, %rdi
callq 0x1edf8
movw %bp, 0x80(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ef81(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x201bb
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: lv_ta_cursor_up
void lv_ta_cursor_up(lv_obj_t * ta)
{
    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);

    lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
    lv_point_t pos;

    /*Get the position of the current letter*/
    lv_label_get_letter_pos(ext->label, lv_ta_get_cursor_pos(ta), &pos);

    /*Decrement the y with one line and keep the valid x*/
    const lv_style_t * label_style = lv_obj_get_style(ext->label);
    const lv_font_t * font         = label_style->text.font;
    lv_coord_t font_h              = lv_font_get_line_height(font);
    pos.y -= font_h + label_style->text.line_space - 1;
    pos.x = ext->cursor.valid_x;

    /*Get the letter index on the new cursor position and set it*/
    uint16_t new_cur_pos       = lv_label_get_letter_on(ext->label, &pos);
    lv_coord_t cur_valid_x_tmp = ext->cursor.valid_x; /*Cursor position set overwrites the valid positon */
    lv_ta_set_cursor_pos(ta, new_cur_pos);
    ext->cursor.valid_x = cur_valid_x_tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20269
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r14
movq 0x50(%rax), %r15
movq %rbx, %rdi
callq 0x1f045
movzwl %ax, %esi
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x1ace1
movq 0x50(%r14), %rdi
callq 0x6697
movq 0x28(%rax), %rcx
movzbl 0x10(%rcx), %ecx
movzwl 0x2(%r12), %edx
addw 0x32(%rax), %cx
subl %ecx, %edx
incl %edx
movw %dx, 0x2(%r12)
movzwl 0x80(%r14), %eax
movw %ax, (%r12)
movq 0x50(%r14), %rdi
movq %r12, %rsi
callq 0x1af91
movzwl 0x80(%r14), %ebp
movswl %ax, %esi
movq %rbx, %rdi
callq 0x1edf8
movw %bp, 0x80(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eec4(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20278
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_ta.c
// Function: get_cursor_style
static void get_cursor_style(lv_obj_t * ta, lv_style_t * style_res)
{
    lv_ta_ext_t * ext              = lv_obj_get_ext_attr(ta);
    const lv_style_t * label_style = lv_obj_get_style(ext->label);

    if(ext->cursor.style) {
        lv_style_copy(style_res, ext->cursor.style);
    } else {
        /*If cursor style is not specified then use the modified label style */
        lv_style_copy(style_res, label_style);
        lv_color_t clv_color_tmp = style_res->text.color; /*Make letter color to cursor color*/
        style_res->text.color =
            style_res->body.main_color; /*In block mode the letter color will be current background color*/
        style_res->body.main_color     = clv_color_tmp;
        style_res->body.grad_color     = clv_color_tmp;
        style_res->body.border.color   = clv_color_tmp;
        style_res->body.border.opa     = LV_OPA_COVER;
        style_res->body.border.width   = 1;
        style_res->body.shadow.width   = 0;
        style_res->body.radius         = 0;
        style_res->body.opa            = LV_OPA_COVER;
        style_res->body.padding.left   = 0;
        style_res->body.padding.right  = 0;
        style_res->body.padding.top    = 0;
        style_res->body.padding.bottom = 0;
        style_res->line.width          = 1;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x6ad8
movq %rax, %r14
movq 0x50(%rax), %rdi
callq 0x6697
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x202aa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x798d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x798d
movzwl 0x2(%rbx), %eax
movzwl 0x20(%rbx), %ecx
movw %ax, 0x20(%rbx)
movw %cx, 0x2(%rbx)
movw %cx, 0x4(%rbx)
movw %cx, 0xa(%rbx)
movb $-0x1, %al
movb %al, 0xf(%rbx)
movw $0x1, %cx
movw %cx, 0xc(%rbx)
xorl %edx, %edx
movw %dx, 0x12(%rbx)
movw %dx, 0x6(%rbx)
movb %al, 0x8(%rbx)
movq $0x0, 0x16(%rbx)
movw %cx, 0x3e(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_set_value
void lv_spinbox_set_value(lv_obj_t * spinbox, int32_t i)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
    if(ext == NULL) return;

    if(i > ext->range_max) i = ext->range_max;
    if(i < ext->range_min) i = ext->range_min;

    ext->value = i;

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x2078b
movq %rbx, %rdi
callq 0x6ad8
testq %rax, %rax
je 0x2079c
movl 0xa4(%rax), %ecx
movl 0xa8(%rax), %edx
cmpl %ebp, %ecx
cmovll %ecx, %ebp
cmpl %edx, %ebp
cmovlel %edx, %ebp
movl %ebp, 0xa0(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x208de
leaq 0x1e9a2(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x2079a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_set_digit_format
void lv_spinbox_set_digit_format(lv_obj_t * spinbox, uint8_t digit_count, uint8_t separator_position)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
    if(ext == NULL) return;

    if(digit_count > LV_SPINBOX_MAX_DIGIT_COUNT) digit_count = LV_SPINBOX_MAX_DIGIT_COUNT;

    if(separator_position > LV_SPINBOX_MAX_DIGIT_COUNT) separator_position = LV_SPINBOX_MAX_DIGIT_COUNT;

    ext->digit_count   = digit_count;
    ext->dec_point_pos = separator_position;

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x207f9
movq %rbx, %rdi
callq 0x6ad8
testq %rax, %rax
je 0x2080a
movzbl %r14b, %ecx
cmpb $0x10, %cl
movl $0x10, %edx
cmovael %edx, %ecx
movzbl %bpl, %esi
cmpb $0x10, %sil
cmovbl %esi, %edx
shlb $0x4, %dl
andb $0xf, %cl
orb %dl, %cl
movb %cl, 0xb0(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x208de
leaq 0x1e934(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20808
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_set_range
void lv_spinbox_set_range(lv_obj_t * spinbox, int32_t range_min, int32_t range_max)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
    if(ext == NULL) return;

    ext->range_max = range_max;
    ext->range_min = range_min;

    if(ext->value > ext->range_max) {
        ext->value = ext->range_max;
        lv_obj_invalidate(spinbox);
    }
    if(ext->value < ext->range_min) {
        ext->value = ext->range_min;
        lv_obj_invalidate(spinbox);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20884
movq %rbx, %rdi
callq 0x6ad8
testq %rax, %rax
je 0x20895
movq %rax, %r14
movl %ebp, 0xa4(%rax)
movl %r15d, 0xa8(%rax)
cmpl %ebp, 0xa0(%rax)
jle 0x2085b
movl %ebp, 0xa0(%r14)
movq %rbx, %rdi
callq 0x4c36
movl 0xa8(%r14), %eax
cmpl %eax, 0xa0(%r14)
jge 0x20895
movl %eax, 0xa0(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c36
leaq 0x1e8a9(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20893
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_spinbox.c
// Function: lv_spinbox_set_step
void lv_spinbox_set_step(lv_obj_t * spinbox, uint32_t step)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
    if(ext == NULL) return;

    ext->step = step;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x208cd
movq %r14, %rdi
callq 0x6ad8
testq %rax, %rax
je 0x208c5
movl %ebx, 0xac(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1e860(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x208dc
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_set_padding_left
void lv_spinbox_set_padding_left(lv_obj_t * spinbox, uint8_t padding)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext  = lv_obj_get_ext_attr(spinbox);
    ext->digit_padding_left = padding;
    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20aeb
movq %rbx, %rdi
callq 0x6ad8
andb $0xf, %bpl
movzbl %bpl, %ecx
movl $0xfffff0ff, %edx       # imm = 0xFFFFF0FF
andl 0xb0(%rax), %edx
shll $0x8, %ecx
orl %ecx, %edx
movw %dx, 0xb0(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x208de
leaq 0x1e642(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20afa
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_step_next
void lv_spinbox_step_next(lv_obj_t * spinbox)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);

    int32_t new_step = ext->step / 10;
    if((new_step) > 0)
        ext->step = new_step;
    else
        ext->step = 1;

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20b6c
movq %rbx, %rdi
callq 0x6ad8
movl 0xac(%rax), %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
cmpl $0xa, %ecx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl %ecx, 0xac(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x208de
leaq 0x1e5c1(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20b7b
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_step_prev
void lv_spinbox_step_prev(lv_obj_t * spinbox)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
    int32_t step_limit;
    step_limit       = LV_MATH_MAX(ext->range_max, (ext->range_min < 0 ? (-ext->range_min) : ext->range_min));
    int32_t new_step = ext->step * 10;
    if(new_step <= step_limit) ext->step = new_step;

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20bc8
movq %rbx, %rdi
callq 0x6ad8
movl 0xa8(%rax), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movl 0xa4(%rax), %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movl 0xac(%rax), %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
cmpl %edx, %ecx
jg 0x20bbf
movl %ecx, 0xac(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x208de
leaq 0x1e565(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20bd7
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_increment
void lv_spinbox_increment(lv_obj_t * spinbox)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);

    if(ext->value + ext->step <= ext->range_max) {
        /*Special mode when zero crossing*/
        if((ext->value + ext->step) > 0 && ext->value < 0) ext->value = -ext->value;
        ext->value += ext->step;

    } else {
        ext->value = ext->range_max;
    }

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20c37
movq %rbx, %rdi
callq 0x6ad8
movl 0xa0(%rax), %edx
movl 0xa4(%rax), %esi
movl 0xac(%rax), %ecx
leal (%rcx,%rdx), %edi
cmpl %esi, %edi
jg 0x20c28
testl %edi, %edi
setle %sil
testl %edx, %edx
setns %dil
orb %sil, %dil
jne 0x20c20
negl %edx
movl %edx, 0xa0(%rax)
addl 0xa0(%rax), %ecx
movl %ecx, %esi
movl %esi, 0xa0(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x208de
leaq 0x1e4f6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20c46
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_spinbox.c
// Function: lv_spinbox_decrement
void lv_spinbox_decrement(lv_obj_t * spinbox)
{
    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);

    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);

    if(ext->value - ext->step >= ext->range_min) {
        /*Special mode when zero crossing*/
        if((ext->value - ext->step) < 0 && ext->value > 0) ext->value = -ext->value;
        ext->value -= ext->step;
    } else {
        ext->value = ext->range_min;
    }

    lv_spinbox_updatevalue(spinbox);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x20ca7
movq %rbx, %rdi
callq 0x6ad8
movl 0xa0(%rax), %edx
movl 0xa8(%rax), %esi
movl 0xac(%rax), %ecx
movl %edx, %edi
subl %ecx, %edi
cmpl %esi, %edi
jl 0x20c98
testl %edi, %edi
setns %sil
testl %edx, %edx
setle %dil
orb %sil, %dil
jne 0x20c90
negl %edx
movl %edx, 0xa0(%rax)
movl 0xa0(%rax), %esi
subl %ecx, %esi
movl %esi, 0xa0(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x208de
leaq 0x1e486(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x20cb6
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_set_style
void lv_btnm_set_style(lv_obj_t * btnm, lv_btnm_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);

    switch(type) {
        case LV_BTNM_STYLE_BG: lv_obj_set_style(btnm, style); break;
        case LV_BTNM_STYLE_BTN_REL:
            ext->styles_btn[LV_BTN_STATE_REL] = style;
            lv_obj_invalidate(btnm);
            break;
        case LV_BTNM_STYLE_BTN_PR:
            ext->styles_btn[LV_BTN_STATE_PR] = style;
            lv_obj_invalidate(btnm);
            break;
        case LV_BTNM_STYLE_BTN_TGL_REL:
            ext->styles_btn[LV_BTN_STATE_TGL_REL] = style;
            lv_obj_invalidate(btnm);
            break;
        case LV_BTNM_STYLE_BTN_TGL_PR:
            ext->styles_btn[LV_BTN_STATE_TGL_PR] = style;
            lv_obj_invalidate(btnm);
            break;
        case LV_BTNM_STYLE_BTN_INA:
            ext->styles_btn[LV_BTN_STATE_INA] = style;
            lv_obj_invalidate(btnm);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21c66
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x5, %bpl
ja 0x21c9f
movzbl %bpl, %ecx
leaq 0x1dcda(%rip), %rdx     # 0x3f928
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d83
leaq 0x1d4c7(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21c75
movq %r14, 0x30(%rax)
jmp 0x21c93
movq %r14, 0x20(%rax)
jmp 0x21c93
movq %r14, 0x28(%rax)
jmp 0x21c93
movq %r14, 0x18(%rax)
jmp 0x21c93
movq %r14, 0x38(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c36
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: lv_btnm_get_style
const lv_style_t * lv_btnm_get_style(const lv_obj_t * btnm, lv_btnm_style_t type)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_btnm_ext_t * ext      = lv_obj_get_ext_attr(btnm);

    switch(type) {
        case LV_BTNM_STYLE_BG: style = lv_obj_get_style(btnm); break;
        case LV_BTNM_STYLE_BTN_REL: style = ext->styles_btn[LV_BTN_STATE_REL]; break;
        case LV_BTNM_STYLE_BTN_PR: style = ext->styles_btn[LV_BTN_STATE_PR]; break;
        case LV_BTNM_STYLE_BTN_TGL_REL: style = ext->styles_btn[LV_BTN_STATE_TGL_REL]; break;
        case LV_BTNM_STYLE_BTN_TGL_PR: style = ext->styles_btn[LV_BTN_STATE_TGL_PR]; break;
        case LV_BTNM_STYLE_BTN_INA: style = ext->styles_btn[LV_BTN_STATE_INA]; break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21d10
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x5, %bpl
ja 0x21d3f
movzbl %bpl, %ecx
leaq 0x1dc47(%rip), %rdx     # 0x3f940
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6697
leaq 0x1d41d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21d1f
movq 0x30(%rax), %rax
jmp 0x21d41
movq 0x20(%rax), %rax
jmp 0x21d41
movq 0x28(%rax), %rax
jmp 0x21d41
movq 0x18(%rax), %rax
jmp 0x21d41
movq 0x38(%rax), %rax
jmp 0x21d41
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_btnm.c
// Function: lv_btnm_set_ctrl_map
void lv_btnm_set_ctrl_map(const lv_obj_t * btnm, const lv_btnm_ctrl_t ctrl_map[])
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    memcpy(ext->ctrl_bits, ctrl_map, sizeof(lv_btnm_ctrl_t) * ext->btn_cnt);

    lv_btnm_set_map(btnm, ext->map_p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21d89
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
movq 0x10(%rax), %rdi
movzwl 0x40(%rax), %edx
addl %edx, %edx
movq %r14, %rsi
callq 0x20f0
movq (%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21710
leaq 0x1d3a4(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21d98
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_set_pressed
void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);

    if(id >= ext->btn_cnt && id != LV_BTNM_BTN_NONE) return;

    if(id == ext->btn_id_pr) return;

    ext->btn_id_pr = id;
    lv_obj_invalidate(btnm);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21dcc
movq %rbx, %rdi
callq 0x6ad8
cmpw $-0x1, %bp
je 0x21dbf
cmpw %bp, 0x40(%rax)
jbe 0x21dc5
cmpw %bp, 0x42(%rax)
jne 0x21ddd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1d361(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21ddb
movw %bp, 0x42(%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_btnm.c
// Function: lv_btnm_set_recolor
void lv_btnm_set_recolor(const lv_obj_t * btnm, bool en)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);

    ext->recolor = en;
    lv_obj_invalidate(btnm);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21e22
movq %rbx, %rdi
callq 0x6ad8
movb 0x46(%rax), %cl
andb $-0x2, %cl
orb %bpl, %cl
movb %cl, 0x46(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
leaq 0x1d30b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21e31
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_set_btn_ctrl
void lv_btnm_set_btn_ctrl(const 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;

    ext->ctrl_bits[btn_id] |= ctrl;
    invalidate_button_area(btnm, btn_id);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21e6c
movq %rbx, %rdi
callq 0x6ad8
cmpw %r14w, 0x40(%rax)
jbe 0x21e7d
movq 0x10(%rax), %rax
movzwl %r14w, %esi
orw %bp, (%rax,%rsi,2)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21e82
leaq 0x1d2c1(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21e7b
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: invalidate_button_area
static void invalidate_button_area(const lv_obj_t * btnm, uint16_t btn_idx)
{
    if(btn_idx == LV_BTNM_BTN_NONE) return;

    lv_area_t btn_area;
    lv_area_t btnm_area;

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    lv_area_copy(&btn_area, &ext->button_areas[btn_idx]);
    lv_obj_get_coords(btnm, &btnm_area);

    /* Convert relative coordinates to absolute */
    btn_area.x1 += btnm_area.x1;
    btn_area.y1 += btnm_area.y1;
    btn_area.x2 += btnm_area.x1;
    btn_area.y2 += btnm_area.y1;

    lv_inv_area(lv_obj_get_disp(btnm), &btn_area);
}

// Assembly:
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x21efa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6ad8
movq 0x8(%rax), %rax
movzwl %bp, %ecx
movq (%rax,%rcx,8), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5427
movzwl (%r15), %eax
addw %ax, (%r14)
movzwl 0x2(%r15), %ecx
addw %cx, 0x2(%r14)
addw %ax, 0x4(%r14)
addw %cx, 0x6(%r14)
movq %rbx, %rdi
callq 0x5033
movq %rax, %rdi
movq %r14, %rsi
callq 0x7184
addq $0x18, %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_btnm.c
// Function: lv_btnm_set_btn_ctrl_all
void lv_btnm_set_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    uint16_t i;
    for(i = 0; i < ext->btn_cnt; i++) {
        lv_btnm_set_btn_ctrl(btnm, i, ctrl);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x21fa2
movq %rbx, %rdi
callq 0x6ad8
cmpw $0x0, 0x40(%rax)
je 0x21f97
movq %rax, %r14
xorl %r15d, %r15d
movzwl %bp, %ebp
movzwl %r15w, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21e33
incl %r15d
cmpw 0x40(%r14), %r15w
jb 0x21f7c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d18b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x21fb1
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_clear_btn_ctrl_all
void lv_btnm_clear_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    uint16_t i;
    for(i = 0; i < ext->btn_cnt; i++) {
        lv_btnm_clear_btn_ctrl(btnm, i, ctrl);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x22006
movq %rbx, %rdi
callq 0x6ad8
cmpw $0x0, 0x40(%rax)
je 0x21ffb
movq %rax, %r14
xorl %r15d, %r15d
movzwl %bp, %ebp
movzwl %r15w, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21efb
incl %r15d
cmpw 0x40(%r14), %r15w
jb 0x21fe0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d127(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x22015
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_btnm.c
// Function: lv_btnm_set_btn_width
void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width)
{
    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;
    ext->ctrl_bits[btn_id] &= (~LV_BTNM_WIDTH_MASK);
    ext->ctrl_bits[btn_id] |= (LV_BTNM_WIDTH_MASK & width);

    lv_btnm_set_map(btnm, ext->map_p);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x22067
movq %rbx, %rdi
callq 0x6ad8
cmpw %r14w, 0x40(%rax)
jbe 0x22078
movq 0x10(%rax), %rcx
movzwl %r14w, %edx
movzwl (%rcx,%rdx,2), %esi
andl $-0x8, %esi
andb $0x7, %bpl
movzbl %bpl, %edi
orl %esi, %edi
movw %di, (%rcx,%rdx,2)
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21710
leaq 0x1d0c6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x22076
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: lv_btnm_set_one_toggle
void lv_btnm_set_one_toggle(lv_obj_t * btnm, bool one_toggle)
{
    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);

    lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
    ext->one_toggle     = one_toggle;

    /*If more than one button is toggled only the first one should be*/
    make_one_button_toggled(btnm, 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x220b2
movq %rbx, %rdi
callq 0x6ad8
movb 0x46(%rax), %cl
addb %bpl, %bpl
andb $-0x3, %cl
orb %bpl, %cl
movb %cl, 0x46(%rax)
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x220c3
leaq 0x1d07b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x220c1