LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x20a5d
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r14
movq 0x50(%rax), %r15
movq %rbx, %rdi
callq 0x1f823
movzwl %ax, %esi
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x1b484
movq 0x50(%r14), %rdi
callq 0x66b6
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 0x1b78e
movzwl 0x80(%r14), %ebp
movswl %ax, %esi
movq %rbx, %rdi
callq 0x1f5c6
movw %bp, 0x80(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e780(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x20a6c
// File: /workspace/github_c_makefile_star2_O3/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 0x6af7
movq %rax, %r14
movq 0x50(%rax), %rdi
callq 0x66b6
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x20a9e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x799d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x799d
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_O3/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 0x80e4
testb %al, %al
je 0x20f71
movq %rbx, %rdi
callq 0x6af7
testq %rax, %rax
je 0x20f82
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 0x210c9
leaq 0x1e26c(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x20f80
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x20fdf
movq %rbx, %rdi
callq 0x6af7
testq %rax, %rax
je 0x20ff0
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 0x210c9
leaq 0x1e1fe(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x20fee
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x2106f
movq %rbx, %rdi
callq 0x6af7
testq %rax, %rax
je 0x21080
movq %rax, %r14
movl %r15d, 0xa4(%rax)
movl %ebp, 0xa8(%rax)
movl 0xa0(%rax), %eax
cmpl %r15d, %eax
jle 0x21052
movl %r15d, 0xa0(%r14)
movq %rbx, %rdi
callq 0x4c4d
movl 0xa0(%r14), %eax
movl 0xa8(%r14), %ebp
cmpl %ebp, %eax
jge 0x21080
movl %ebp, 0xa0(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
leaq 0x1e16e(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2107e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x210b8
movq %r14, %rdi
callq 0x6af7
testq %rax, %rax
je 0x210b0
movl %ebx, 0xac(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1e125(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x210c7
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x212d7
movq %rbx, %rdi
callq 0x6af7
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 0x210c9
leaq 0x1df06(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x212e6
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x21358
movq %rbx, %rdi
callq 0x6af7
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 0x210c9
leaq 0x1de85(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x21367
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x213b4
movq %rbx, %rdi
callq 0x6af7
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 0x213ab
movl %ecx, 0xac(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x210c9
leaq 0x1de29(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x213c3
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x21410
movq %rbx, %rdi
callq 0x6af7
movl 0xa0(%rax), %edx
movl 0xa4(%rax), %edi
movl 0xac(%rax), %ecx
leal (%rcx,%rdx), %esi
cmpl %edi, %esi
jg 0x21401
subl %edx, %ecx
testl %esi, %esi
cmovlel %esi, %ecx
testl %edx, %edx
cmovnsl %esi, %ecx
movl %ecx, %edi
movl %edi, 0xa0(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x210c9
leaq 0x1ddcd(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2141f
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x21478
movq %rbx, %rdi
callq 0x6af7
movl 0xa0(%rax), %ecx
movl 0xa8(%rax), %esi
movl 0xac(%rax), %edx
movl %ecx, %edi
subl %edx, %edi
cmpl %esi, %edi
jl 0x21469
testl %edi, %edi
setns %sil
testl %ecx, %ecx
setle %r8b
orb %sil, %r8b
movl %edi, %esi
jne 0x21469
addl %edx, %ecx
negl %ecx
movl %ecx, %esi
movl %esi, 0xa0(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x210c9
leaq 0x1dd65(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x21487
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x22425
movq %rbx, %rdi
callq 0x6af7
cmpb $0x5, %bpl
ja 0x2245e
movzbl %bpl, %ecx
leaq 0x1d69f(%rip), %rdx     # 0x3faac
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d9f
leaq 0x1cdb8(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22434
movq %r14, 0x30(%rax)
jmp 0x22452
movq %r14, 0x20(%rax)
jmp 0x22452
movq %r14, 0x28(%rax)
jmp 0x22452
movq %r14, 0x18(%rax)
jmp 0x22452
movq %r14, 0x38(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c4d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x224cf
movq %rbx, %rdi
callq 0x6af7
cmpb $0x5, %bpl
ja 0x224fe
movzbl %bpl, %ecx
leaq 0x1d60c(%rip), %rdx     # 0x3fac4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
leaq 0x1cd0e(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x224de
movq 0x30(%rax), %rax
jmp 0x22500
movq 0x20(%rax), %rax
jmp 0x22500
movq 0x28(%rax), %rax
jmp 0x22500
movq 0x18(%rax), %rax
jmp 0x22500
movq 0x38(%rax), %rax
jmp 0x22500
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x22548
movq %rbx, %rdi
callq 0x6af7
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 0x21f33
leaq 0x1cc95(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22557
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x2258b
movq %rbx, %rdi
callq 0x6af7
cmpw $-0x1, %bp
je 0x2257e
cmpw %bp, 0x40(%rax)
jbe 0x22584
cmpw %bp, 0x42(%rax)
jne 0x2259c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1cc52(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2259a
movw %bp, 0x42(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x225e1
movq %rbx, %rdi
callq 0x6af7
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 0x4c4d
leaq 0x1cbfc(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x225f0
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x2262b
movq %rbx, %rdi
callq 0x6af7
cmpw %r14w, 0x40(%rax)
jbe 0x2263c
movq 0x10(%rax), %rax
movzwl %r14w, %esi
orw %bp, (%rax,%rsi,2)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x22641
leaq 0x1cbb2(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2263a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x226af
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6af7
movq 0x8(%rax), %rax
movzwl %bp, %ecx
movsd (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rsp)
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x542b
movd (%r14), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
paddw (%rsp), %xmm0
leaq 0x10(%rsp), %r14
movq %xmm0, (%r14)
movq %rbx, %rdi
callq 0x5061
movq %rax, %rdi
movq %r14, %rsi
callq 0x7170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x22757
movq %rbx, %rdi
callq 0x6af7
cmpw $0x0, 0x40(%rax)
je 0x2274c
movq %rax, %r14
xorl %r15d, %r15d
movzwl %bp, %ebp
movzwl %r15w, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x225f2
incl %r15d
cmpw 0x40(%r14), %r15w
jb 0x22731
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ca86(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22766
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x227bb
movq %rbx, %rdi
callq 0x6af7
cmpw $0x0, 0x40(%rax)
je 0x227b0
movq %rax, %r14
xorl %r15d, %r15d
movzwl %bp, %ebp
movzwl %r15w, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x226b0
incl %r15d
cmpw 0x40(%r14), %r15w
jb 0x22795
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ca22(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x227ca
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x2281c
movq %rbx, %rdi
callq 0x6af7
cmpw %r14w, 0x40(%rax)
jbe 0x2282d
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 0x21f33
leaq 0x1c9c1(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2282b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x22867
movq %rbx, %rdi
callq 0x6af7
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 0x22878
leaq 0x1c976(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22876
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x2293d
movq %rbx, %rdi
callq 0x6af7
movzwl 0x44(%rax), %eax
cmpw $-0x1, %ax
je 0x2294e
movzwl %ax, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x22952
leaq 0x1c8a0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2294c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x229b1
movq %r14, %rdi
callq 0x6af7
movzwl 0x40(%rax), %ecx
cmpw %bx, %cx
jb 0x229c9
testw %bx, %bx
je 0x229c2
movq (%rax), %rdx
xorl %edi, %edi
movl %ebx, %esi
leal 0x1(%rdi), %r8d
movzwl %r8w, %r9d
movq (%rdx,%r9,8), %r9
cmpb $0xa, (%r9)
jne 0x2299f
cmpb $0x0, 0x1(%r9)
je 0x229a4
movl %r8d, %edi
jmp 0x229a7
movl %r8d, %edi
jmp 0x229a7
addl $0x2, %edi
decw %si
jne 0x22981
movzwl %di, %edx
jmp 0x229c4
leaq 0x1c82c(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x229c0
xorl %edx, %edx
cmpw %bx, %cx
jne 0x229cd
xorl %eax, %eax
jmp 0x229d4
movq (%rax), %rax
movq (%rax,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x22a3a
movq %r14, %rdi
callq 0x6af7
cmpw %bp, 0x40(%rax)
jbe 0x22a4b
movq 0x10(%rax), %rax
movzwl %bp, %ecx
testw %bx, (%rax,%rcx,2)
setne %al
jmp 0x22a4d
leaq 0x1c7a3(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x22a49
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r15
callq 0x6af7
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x542b
cmpw $0x0, 0x40(%r14)
je 0x22af7
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq 0x8(%r14), %rax
movd 0x10(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movq (%rax,%r12,8), %xmm1
paddw %xmm0, %xmm1
movq %xmm1, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28d87
movzwl 0x40(%r14), %ecx
testb %al, %al
jne 0x22afc
movzwl %cx, %eax
incq %r12
cmpq %rax, %r12
jb 0x22ab7
jmp 0x22afc
xorl %ecx, %ecx
xorl %r12d, %r12d
cmpw %cx, %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_O3/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 *0x3d7a0(%rip)          # 0x60430
movl %eax, %ebx
cmpb $0x1, %al
jne 0x22cc3
movzbl %bpl, %eax
movb $0x1, %bl
decl %eax
cmpl $0x6, %eax
ja 0x22cc3
leaq 0x1ce56(%rip), %rcx     # 0x3fb00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x22f49
movq %r14, %rdi
callq 0x2335b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x566d
movzwl 0x4(%r15), %ecx
subw (%r15), %cx
incl %ecx
cmpw %cx, %ax
jne 0x22cb3
movq %r14, %rdi
callq 0x5697
movzwl 0x6(%r15), %ecx
subw 0x2(%r15), %cx
incl %ecx
cmpw %cx, %ax
jne 0x22cb3
jmp 0x22cc3
leaq 0x1ce52(%rip), %rsi     # 0x3fb5c
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x22d4d
movq %rbx, %rdi
callq 0x6af7
movzwl (%rax), %ecx
movl %ecx, %edx
andl $0xf, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x22d5e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1c490(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22d5c
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_O3/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 0x80e4
testb %al, %al
je 0x22e03
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x6af7
movzwl (%rax), %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0x3, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x22e14
movl %ecx, %edx
shrl $0x6, %edx
andl $0x3, %edx
movzbl %r12b, %esi
cmpw %si, %dx
jne 0x22e14
movl %ecx, %edx
shrl $0x8, %edx
andl $0x3, %edx
movzbl %r15b, %esi
cmpw %si, %dx
jne 0x22e14
movl %ecx, %edx
shrl $0xa, %edx
andl $0x3, %edx
movzbl %r14b, %esi
cmpw %si, %dx
jne 0x22e14
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c3da(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x22e12
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_O3/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 *0x3c673(%rip)          # 0x60438
movl %eax, %ebx
cmpb $0x1, %al
jne 0x23e3c
cmpb $0x7, %bpl
jne 0x23dea
leaq 0x1bb50(%rip), %rsi     # 0x3f928
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r14, %rdi
callq 0x6af7
movq %rax, %r15
movb $0x1, %bl
cmpb $0x4, %bpl
je 0x23e27
movzbl %bpl, %eax
testl %eax, %eax
jne 0x23e3c
movb 0x10(%r15), %al
andb $0x3, %al
decb %al
cmpb $0x1, %al
ja 0x23e3c
movq (%r15), %rdi
callq 0x2a006
movq $0x0, (%r15)
orb $0x3, 0x10(%r15)
jmp 0x23e3c
movb 0x10(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x23e3c
movq (%r15), %rsi
movq %r14, %rdi
callq 0x24066
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x242fb
movq %rbx, %rdi
callq 0x6af7
movswl %bp, %ecx
movswl 0xc(%rax), %edx
decl %edx
cmpl %ecx, %edx
jle 0x2430c
movw %bp, 0x8(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
leaq 0x1aee2(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2430a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x2434b
movq %rbx, %rdi
callq 0x6af7
movswl %bp, %ecx
movswl 0xe(%rax), %edx
decl %edx
cmpl %ecx, %edx
jle 0x2435c
movw %bp, 0xa(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
leaq 0x1ae92(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x2435a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x243b3
movq %rbx, %rdi
callq 0x6af7
movb 0x10(%rax), %cl
andb $0x3, %cl
cmpb $0x1, %cl
jne 0x243c4
movq (%rax), %rax
jmp 0x243cb
leaq 0x1ae2a(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x243c2
leaq 0x1f1f2(%rip), %rax     # 0x435bd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 *0x3beed(%rip)          # 0x60440
movl %eax, %ebp
cmpb $0x1, %al
jne 0x2458c
movb $0x1, %bpl
cmpb $0x4, %r15b
je 0x24584
movzbl %r15b, %eax
cmpl $0x7, %eax
jne 0x2458c
leaq 0x1b5f2(%rip), %rsi     # 0x3fb64
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r14, %rdi
callq 0x246e0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x246cf
movq %rbx, %rdi
callq 0x6af7
movzbl %bpl, %ecx
movq %r14, 0x38(%rax,%rcx,8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x246e0
leaq 0x1ab0e(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x246de
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6af7
movq %rax, %r14
movq %rbx, %rdi
callq 0x136d6
movzbl %al, %r12d
movq 0x38(%r14,%r12,8), %r15
movq %r15, %rdi
callq 0x3c88e
cmpb $0x2, %al
jne 0x24757
movq 0x8(%r14,%r12,8), %r13
movq 0x28(%r13), %r12
movzbl 0x10(%r12), %ebp
shll $0x15, %ebp
movq %r15, %rdi
callq 0x2070
movswl 0x30(%r13), %ecx
movzwl %ax, %esi
movq %r15, %rdi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x2b2a4
andl $0x7ff, %eax            # imm = 0x7FF
shll $0xa, %eax
leal (%rax,%rbp), %edx
addl $0xb, %edx
movl %edx, 0x4(%rsp)
jmp 0x2476c
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x3e49e
cmpb $0x1, %al
jne 0x2478c
movl 0x4(%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 0x5557
jmp 0x24791
movb $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x4c4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x454f
movq %rax, %rbx
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x2490a
testq %rbx, %rbx
je 0x2491b
cmpq $0x0, 0x3bbcf(%rip)     # 0x60450
jne 0x24892
movq %rbx, %rdi
callq 0x6a8b
movq %rax, 0x3bbbe(%rip)     # 0x60450
cmpq $0x0, 0x3bbbe(%rip)     # 0x60458
jne 0x248ab
movq %rbx, %rdi
callq 0x6aaf
movq %rax, 0x3bbad(%rip)     # 0x60458
movq %rbx, %rdi
movl $0x1, %esi
callq 0x64db
movq %rax, %r15
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x24926
testq %r15, %r15
je 0x2491b
movb $-0x1, (%r15)
leaq 0x96(%rip), %rsi        # 0x2496d
movq %rbx, %rdi
callq 0x647b
leaq 0xcf(%rip), %rsi        # 0x249b5
movq %rbx, %rdi
callq 0x64ab
testq %r14, %r14
je 0x24937
movq %r14, %rdi
callq 0x6af7
movb (%rax), %al
movb %al, (%r15)
movq %rbx, %rdi
callq 0x5e54
jmp 0x2491d
leaq 0x1a7bf(%rip), %rdi     # 0x3f0d0
movq %rbx, %rsi
callq 0x8294
jmp 0x24919
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a7a3(%rip), %rdi     # 0x3f0d0
movq %r15, %rsi
callq 0x8294
jmp 0x24935
movq %rbx, %rdi
movl $0x21, %esi
movl $0x21, %edx
callq 0x5557
callq 0x2e91c
testq %rax, %rax
je 0x2495c
movq 0xa0(%rax), %rsi
jmp 0x24963
leaq 0x3b68d(%rip), %rsi     # 0x5fff0
movq %rbx, %rdi
callq 0x5d9f
jmp 0x2491d
// File: /workspace/github_c_makefile_star2_O3/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 *0x3bad5(%rip)          # 0x60450
movl %eax, %ecx
xorb $0x1, %cl
xorb $0x7, %bpl
orb %cl, %bpl
jne 0x249ae
xorl %ecx, %ecx
cmpq $0x0, (%rbx,%rcx,8)
je 0x249a0
incq %rcx
cmpq $0x7, %rcx
jne 0x2498b
movl $0x7, %ecx
movzbl %cl, %ecx
leaq 0x1b1d6(%rip), %rdx     # 0x3fb80
movq %rdx, (%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x24b34
movq %rbx, %rdi
callq 0x6af7
cmpb %bpl, (%rax)
jne 0x24b45
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1a6a9(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x24b43
movb %bpl, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x24bd0
movq %rbx, %rdi
callq 0x24be7
movq %rbx, %rdi
cmpb $-0x4e, %al
jb 0x24be1
popq %rbx
jmp 0x24b82
leaq 0x1a60d(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x24bdf
popq %rbx
jmp 0x24b56