LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_preload.c
// Function: lv_preload_spinner_anim
void lv_preload_spinner_anim(void * ptr, lv_anim_value_t val)
{
    lv_obj_t * preload     = ptr;
    lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);

    int16_t angle_start = val - ext->arc_length / 2 + 180;
    int16_t angle_end   = angle_start + ext->arc_length;

    angle_start = angle_start % 360;
    angle_end   = angle_end % 360;

    lv_arc_set_angles(preload, angle_start, angle_end);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x6af7
movzwl 0x4(%rax), %eax
movl %eax, %ecx
shrl $0xf, %ecx
addl %eax, %ecx
movswl %cx, %ecx
sarl %ecx
subl %ecx, %r14d
movl %r14d, %esi
addl $0xb4, %esi
leal (%r14,%rax), %edx
addl $0xb4, %edx
movswl %si, %eax
imull $0x2d83, %eax, %eax     # imm = 0x2D83
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x16, %eax
addl %ecx, %eax
imull $0x168, %eax, %eax      # imm = 0x168
subl %eax, %esi
movswl %dx, %eax
imull $0x2d83, %eax, %eax     # imm = 0x2D83
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x16, %eax
addl %ecx, %eax
imull $0x168, %eax, %eax      # imm = 0x168
subl %eax, %edx
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %edx
andl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8bcd
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_preload.c
// Function: lv_preload_set_dir
void lv_preload_set_dir(lv_obj_t * preload, lv_preload_dir_t dir)
{
    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);

    lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);

    ext->anim_dir = dir;
    lv_preload_set_type(preload, ext->anim_type);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xe6b3
movq %rbx, %rdi
callq 0x6af7
movzbl 0x8(%rax), %esi
shlb $0x2, %bpl
andb $0x4, %bpl
movl %esi, %ecx
andb $-0x5, %cl
orb %bpl, %cl
movb %cl, 0x8(%rax)
andl $0x3, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe3e8
leaq 0x30b2a(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xe6c2
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_preload.c
// Function: lv_preload_get_style
const lv_style_t * lv_preload_get_style(const lv_obj_t * preload, lv_preload_style_t type)
{
    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);

    const lv_style_t * style = NULL;

    switch(type) {
        case LV_PRELOAD_STYLE_MAIN: style = lv_arc_get_style(preload, LV_ARC_STYLE_MAIN); 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 0xe73b
testb %bpl, %bpl
je 0xe74c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x30aa2(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xe74a
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8c7d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_set_visible_row_count
void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    lv_roller_ext_t * ext          = lv_obj_get_ext_attr(roller);
    const lv_style_t * style_label = lv_obj_get_style(ext->ddlist.label);
    uint8_t n_line_space           = (row_cnt > 1) ? row_cnt - 1 : 1;
    lv_ddlist_set_fix_height(roller, lv_font_get_line_height(style_label->text.font) * row_cnt +
                                         style_label->text.line_space * n_line_space);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xefe0
movq %rbx, %rdi
callq 0x6af7
movq 0x50(%rax), %rdi
callq 0x66b6
movzbl %bpl, %ecx
leal -0x1(%rcx), %edx
cmpb $0x2, %cl
movzbl %dl, %edx
movl $0x1, %esi
cmovael %edx, %esi
movq 0x28(%rax), %rdx
movzbl 0x10(%rdx), %edx
imull %ecx, %edx
movzbl %sil, %ecx
imulw 0x32(%rax), %cx
addl %edx, %ecx
movswl %cx, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc207
leaq 0x301fd(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xefef
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_set_style
void lv_roller_set_style(lv_obj_t * roller, lv_roller_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    switch(type) {
        case LV_ROLLER_STYLE_BG: lv_obj_set_style(roller, style); break;
        case LV_ROLLER_STYLE_SEL: lv_ddlist_set_style(roller, LV_DDLIST_STYLE_SEL, style); break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0xf182
cmpb $0x1, %bpl
je 0xf193
movzbl %bpl, %eax
testl %eax, %eax
jne 0xf1a7
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d9f
leaq 0x3005b(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0xf191
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xbdc6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: refr_height
static void refr_height(lv_obj_t * roller)
{
    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
    lv_align_t obj_align  = LV_ALIGN_IN_LEFT_MID;
    if(ext->ddlist.label) {
        lv_label_align_t label_align = lv_label_get_align(ext->ddlist.label);
        if(LV_LABEL_ALIGN_CENTER == label_align)
            obj_align = LV_ALIGN_CENTER;
        else if(LV_LABEL_ALIGN_RIGHT == label_align)
            obj_align = LV_ALIGN_IN_RIGHT_MID;
    }

    lv_obj_set_height(lv_page_get_scrl(roller), lv_obj_get_height(ext->ddlist.label) + lv_obj_get_height(roller));
    lv_obj_align(ext->ddlist.label, NULL, obj_align, 0, 0);
#if LV_USE_ANIMATION
    lv_anim_del(lv_page_get_scrl(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
    lv_ddlist_set_selected(roller, ext->ddlist.sel_opt_id);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6af7
movq %rax, %r14
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0xf327
callq 0x1a9c6
cmpb $0x2, %al
sete %cl
addb $0x7, %cl
xorl %edx, %edx
cmpb $0x1, %al
movzbl %cl, %r12d
cmovel %edx, %r12d
jmp 0xf32a
movb $0x7, %r12b
movq %rbx, %rdi
callq 0x2695e
movq %rax, %r15
movq 0x50(%r14), %rdi
callq 0x5697
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5697
addl %ebp, %eax
movswl %ax, %esi
movq %r15, %rdi
callq 0x574b
movq 0x50(%r14), %rdi
movzbl %r12b, %edx
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5789
movq %rbx, %rdi
callq 0x2695e
leaq -0x9e5f(%rip), %rsi     # 0x5519
movq %rax, %rdi
callq 0x29c44
movzwl 0x62(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc112
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_set_selected
void lv_roller_set_selected(lv_obj_t * roller, uint16_t sel_opt, lv_anim_enable_t anim)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

#if LV_USE_ANIMATION == 0
    anim = LV_ANIM_OFF;
#endif

    if(lv_roller_get_selected(roller) == sel_opt) return;

    lv_ddlist_set_selected(roller, sel_opt);
    refr_position(roller, anim);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xf3bd
movq %rbx, %rdi
callq 0xf460
cmpw %r14w, %ax
jne 0xf3ce
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2fe20(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xf3cc
movzwl %r14w, %esi
movq %rbx, %rdi
callq 0xc112
movzbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xf4cb
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_set_align
void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);

    lv_obj_t * label = ext->ddlist.label;

    if(label == NULL) return; /*Probably the roller is being deleted if the label is NULL.*/
    lv_label_set_align(label, align);

    switch(lv_label_get_align(label)) {
        case LV_LABEL_ALIGN_LEFT: lv_obj_align(label, NULL, LV_ALIGN_IN_LEFT_MID, 0, 0); break;
        case LV_LABEL_ALIGN_CENTER: lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0); break;
        case LV_LABEL_ALIGN_RIGHT: lv_obj_align(label, NULL, LV_ALIGN_IN_RIGHT_MID, 0, 0); break;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xf448
movq %rbx, %rdi
callq 0x6af7
movq 0x50(%rax), %rbx
testq %rbx, %rbx
je 0xf459
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x1a95d
movq %rbx, %rdi
callq 0x1a9c6
cmpb $0x2, %al
ja 0xf459
shlb $0x3, %al
movl $0x80007, %edx          # imm = 0x80007
movl %eax, %ecx
shrl %cl, %edx
movzbl %dl, %edx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5789
leaq 0x2fd95(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xf457
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_get_selected
uint16_t lv_roller_get_selected(const lv_obj_t * roller)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
    if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
        uint16_t real_id_cnt = ext->ddlist.option_cnt / LV_ROLLER_INF_PAGES;
        return lv_ddlist_get_selected(roller) % real_id_cnt;
    } else {
        return lv_ddlist_get_selected(roller);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xf48b
movq %rbx, %rdi
callq 0x6af7
testb $0x1, 0x70(%rax)
jne 0xf49c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc414
leaq 0x2fd52(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xf49a
movzwl 0x60(%rax), %eax
imull $0x2493, %eax, %ecx     # imm = 0x2493
shrl $0x10, %ecx
subl %ecx, %eax
movzwl %ax, %ebp
shrl %ebp
addl %ecx, %ebp
shrl $0x2, %ebp
movq %rbx, %rdi
callq 0xc414
xorl %edx, %edx
divw %bp
movl %edx, %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_roller.c
// Function: lv_roller_get_align
lv_label_align_t lv_roller_get_align(const lv_obj_t * roller)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
    LV_ASSERT_MEM(ext);
    LV_ASSERT_MEM(ext->ddlist.label);
    return lv_label_get_align(ext->ddlist.label);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xf63c
movq %rbx, %rdi
callq 0x6af7
movq %rax, %rbx
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0xf64d
movq 0x50(%rbx), %rdi
callq 0x80e4
movq 0x50(%rbx), %rsi
testb %al, %al
je 0xf65e
movq %rsi, %rdi
popq %rbx
jmp 0x1a9c6
leaq 0x2fba1(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xf64b
leaq 0x2fa7c(%rip), %rdi     # 0x3f0d0
movq %rbx, %rsi
callq 0x8294
jmp 0xf65c
leaq 0x2fa6b(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0xf66a
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_roller.c
// Function: lv_roller_get_style
const lv_style_t * lv_roller_get_style(const lv_obj_t * roller, lv_roller_style_t type)
{
    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);

    switch(type) {
        case LV_ROLLER_STYLE_BG: return lv_obj_get_style(roller);
        case LV_ROLLER_STYLE_SEL: return lv_ddlist_get_style(roller, LV_DDLIST_STYLE_SEL);
        default: return NULL;
    }

    /*To avoid warning*/
    return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xf6ce
cmpb $0x1, %bpl
je 0xf6df
movzbl %bpl, %eax
testl %eax, %eax
jne 0xf6f2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
leaq 0x2fb0f(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xf6dd
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe51
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_roller.c
// Function: inf_normalize
static void inf_normalize(void * scrl)
{
    lv_obj_t * roller_scrl = (lv_obj_t *)scrl;
    lv_obj_t * roller      = lv_obj_get_parent(roller_scrl);
    lv_roller_ext_t * ext  = lv_obj_get_ext_attr(roller);

    if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
        uint16_t real_id_cnt = ext->ddlist.option_cnt / LV_ROLLER_INF_PAGES;

        ext->ddlist.sel_opt_id = ext->ddlist.sel_opt_id % real_id_cnt;

        ext->ddlist.sel_opt_id += (LV_ROLLER_INF_PAGES / 2) * real_id_cnt; /*Select the middle page*/

        /*Move to the new id*/
        const lv_style_t * style_label = lv_obj_get_style(ext->ddlist.label);
        const lv_font_t * font         = style_label->text.font;
        lv_coord_t font_h              = lv_font_get_line_height(font);
        lv_coord_t h                   = lv_obj_get_height(roller);

        lv_coord_t line_y1 = ext->ddlist.sel_opt_id * (font_h + style_label->text.line_space) +
                             ext->ddlist.label->coords.y1 - roller_scrl->coords.y1;
        lv_coord_t new_y = -line_y1 + (h - font_h) / 2;
        lv_obj_set_y(roller_scrl, new_y);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x4ab5
movq %rax, %r15
movq %rax, %rdi
callq 0x6af7
testb $0x1, 0x70(%rax)
jne 0xf725
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movzwl 0x60(%rax), %eax
imull $0x2493, %eax, %ecx     # imm = 0x2493
shrl $0x10, %ecx
subl %ecx, %eax
movzwl %ax, %esi
shrl %esi
addl %ecx, %esi
shrl $0x2, %esi
movzwl 0x62(%r14), %eax
xorl %edx, %edx
divw %si
leal (%rsi,%rsi,2), %eax
addl %edx, %eax
movw %ax, 0x62(%r14)
movq 0x50(%r14), %rdi
callq 0x66b6
movq %rax, %r12
movq 0x28(%rax), %rax
movzbl 0x10(%rax), %ebp
movq %r15, %rdi
callq 0x5697
movzwl %bp, %ecx
movzwl 0x32(%r12), %edx
addw %cx, %dx
imulw 0x62(%r14), %dx
movq 0x50(%r14), %rsi
cwtl
subl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
addw 0x22(%rsi), %dx
shrl %ecx
subl %edx, %ecx
addw 0x22(%rbx), %cx
movswl %cx, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5519
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_signal
static lv_res_t lv_table_signal(lv_obj_t * table, lv_signal_t sign, void * param)
{
    lv_res_t res;

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

    if(sign == LV_SIGNAL_CLEANUP) {
        /*Free the cell texts*/
        lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
        uint16_t cell;
        for(cell = 0; cell < ext->col_cnt * ext->row_cnt; cell++) {
            if(ext->cell_data[cell]) {
                lv_mem_free(ext->cell_data[cell]);
                ext->cell_data[cell] = NULL;
            }
        }
        if(ext->cell_data != NULL)
            lv_mem_free(ext->cell_data);
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq *0x508ba(%rip)          # 0x60320
movl %eax, %ebx
cmpb $0x1, %al
jne 0xfb12
movb $0x1, %bl
testb %bpl, %bpl
je 0xfa9d
movzbl %bpl, %eax
cmpl $0x7, %eax
jne 0xfb12
leaq 0x2fbdd(%rip), %rsi     # 0x3f668
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r15, %rdi
callq 0x6af7
movq %rax, %r14
movzwl (%rax), %eax
movzwl 0x2(%r14), %ecx
testw %ax, %ax
sete %dl
testw %cx, %cx
sete %sil
orb %dl, %sil
jne 0xfb04
xorl %r15d, %r15d
movq 0x8(%r14), %rdx
movzwl %r15w, %r15d
movq (%rdx,%r15,8), %rdi
testq %rdi, %rdi
je 0xfaf0
callq 0x2a006
movq 0x8(%r14), %rax
movq $0x0, (%rax,%r15,8)
movzwl (%r14), %eax
movzwl 0x2(%r14), %ecx
incl %r15d
movzwl %r15w, %edx
movzwl %ax, %esi
movzwl %cx, %edi
imull %esi, %edi
cmpl %edx, %edi
ja 0xfac5
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xfb12
callq 0x2a006
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_table.c
// Function: lv_table_set_style
void lv_table_set_style(lv_obj_t * table, lv_table_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);

    switch(type) {
        case LV_TABLE_STYLE_BG:
            lv_obj_set_style(table, style);
            refr_size(table);
            break;
        case LV_TABLE_STYLE_CELL1:
            ext->cell_style[0] = style;
            refr_size(table);
            break;
        case LV_TABLE_STYLE_CELL2:
            ext->cell_style[1] = style;
            refr_size(table);
            break;
        case LV_TABLE_STYLE_CELL3:
            ext->cell_style[2] = style;
            refr_size(table);
            break;
        case LV_TABLE_STYLE_CELL4:
            ext->cell_style[3] = style;
            refr_size(table);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0xffb8
movq %rbx, %rdi
callq 0x6af7
cmpb $0x4, %bpl
ja 0xffeb
movzbl %bpl, %ecx
leaq 0x2f69e(%rip), %rdx     # 0x3f640
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d9f
jmp 0xffdf
leaq 0x2f225(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0xffc7
movq %r14, 0x28(%rax)
jmp 0xffdf
movq %r14, 0x18(%rax)
jmp 0xffdf
movq %r14, 0x20(%rax)
jmp 0xffdf
movq %r14, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10252
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_row_cnt
void lv_table_set_row_cnt(lv_obj_t * table, uint16_t row_cnt)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    uint16_t old_row_cnt = ext->row_cnt;
    ext->row_cnt         = row_cnt;

    if(ext->row_cnt > 0 && ext->col_cnt > 0) {
        ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));

        /*Initilize the new fields*/
        if(old_row_cnt < row_cnt) {
            uint16_t old_cell_cnt = old_row_cnt * ext->col_cnt;
            uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
            memset(&ext->cell_data[old_cell_cnt], 0, (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
        }
    } else {
        lv_mem_free(ext->cell_data);
        ext->cell_data = NULL;
    }

    refr_size(table);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x1006c
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r14
movzwl 0x2(%rax), %r15d
movw %bp, 0x2(%rax)
testw %bp, %bp
je 0x1007d
movzwl (%r14), %eax
testq %rax, %rax
je 0x1007d
movzwl %bp, %esi
movq 0x8(%r14), %rdi
imulq %rax, %rsi
shlq $0x3, %rsi
callq 0x2a06f
movq %rax, 0x8(%r14)
cmpw %bp, %r15w
jae 0x1008e
movzwl (%r14), %ecx
imull %ecx, %r15d
movzwl 0x2(%r14), %edx
imull %ecx, %edx
movzwl %r15w, %ecx
leaq (%rax,%rcx,8), %rdi
subl %ecx, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x20a0
jmp 0x1008e
leaq 0x2f171(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1007b
movq 0x8(%r14), %rdi
callq 0x2a006
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10252
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_col_cnt
void lv_table_set_col_cnt(lv_obj_t * table, uint16_t col_cnt)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    if(col_cnt >= LV_TABLE_COL_MAX) {
        LV_LOG_WARN("lv_table_set_col_cnt: too many columns. Must be < LV_TABLE_COL_MAX.");
        return;
    }

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    uint16_t old_col_cnt = ext->col_cnt;
    ext->col_cnt         = col_cnt;

    if(ext->row_cnt > 0 && ext->col_cnt > 0) {
        ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
        /*Initilize the new fields*/
        if(old_col_cnt < col_cnt) {
            uint16_t old_cell_cnt = old_col_cnt * ext->row_cnt;
            uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
            memset(&ext->cell_data[old_cell_cnt], 0, (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
        }

    } else {
        lv_mem_free(ext->cell_data);
        ext->cell_data = NULL;
    }
    refr_size(table);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x100c8
cmpw $0xb, %r14w
jbe 0x100d9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f115(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x100d7
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r15
movzwl (%rax), %ebp
movw %r14w, (%rax)
movzwl 0x2(%rax), %eax
testq %rax, %rax
sete %cl
testw %r14w, %r14w
sete %dl
orb %cl, %dl
je 0x10113
movq 0x8(%r15), %rdi
callq 0x2a006
movq $0x0, 0x8(%r15)
jmp 0x10158
movq 0x8(%r15), %rdi
leal (,%r14,8), %ecx
movzwl %cx, %esi
imulq %rax, %rsi
callq 0x2a06f
movq %rax, 0x8(%r15)
cmpw %r14w, %bp
jae 0x10158
movzwl 0x2(%r15), %ecx
imull %ecx, %ebp
movzwl (%r15), %edx
imull %ecx, %edx
movzwl %bp, %ecx
leaq (%rax,%rcx,8), %rdi
subl %ecx, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x20a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10252
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_cell_value
void lv_table_set_cell_value(lv_obj_t * table, uint16_t row, uint16_t col, const char * txt)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
    LV_ASSERT_NULL(txt);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_value: invalid row or column");
        return;
    }
    uint32_t cell = row * ext->col_cnt + col;
    lv_table_cell_format_t format;

    /*Save the format byte*/
    if(ext->cell_data[cell]) {
        format.format_byte = ext->cell_data[cell][0];
    }
    /*Initialize the format byte*/
    else {
#if LV_USE_BIDI
        lv_bidi_dir_t base_dir = lv_obj_get_base_dir(table);
        if(base_dir == LV_BIDI_DIR_LTR) format.s.align = LV_LABEL_ALIGN_LEFT;
        else if(base_dir == LV_BIDI_DIR_RTL) format.s.align = LV_LABEL_ALIGN_RIGHT;
        else if(base_dir == LV_BIDI_DIR_AUTO) format.s.align = lv_bidi_detect_base_dir(txt);
#else
        format.s.align = LV_LABEL_ALIGN_LEFT;
#endif

        format.s.right_merge = 0;
        format.s.type        = 0;
        format.s.crop        = 0;
    }

    ext->cell_data[cell] = lv_mem_realloc(ext->cell_data[cell], strlen(txt) + 2); /*+1: trailing '\0; +1: format byte*/
    strcpy(ext->cell_data[cell] + 1, txt);  /*+1 to skip the format byte*/

    ext->cell_data[cell][0] = format.format_byte;
    refr_size(table);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x101d2
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x101e3
movq %rbx, %rdi
callq 0x6af7
cmpw %r12w, 0x2(%rax)
jbe 0x101f4
movq %rax, %r15
movzwl (%rax), %r13d
cmpw %bp, %r13w
jbe 0x101f4
movzwl %r12w, %eax
movzwl %bp, %ecx
imulq %rax, %r13
addq %rcx, %r13
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x10203
movb (%r12), %bpl
jmp 0x10205
leaq 0x2f00b(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x101e1
leaq 0x2effa(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x101f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2070
leaq 0x2(%rax), %rsi
movq %r12, %rdi
callq 0x2a06f
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rdi
incq %rdi
movq %r14, %rsi
callq 0x2040
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rax
movb %bpl, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10252
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: refr_size
static void refr_size(lv_obj_t * table)
{
    lv_coord_t h = 0;
    lv_coord_t w = 0;

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);

    uint16_t i;
    for(i = 0; i < ext->col_cnt; i++) {
        w += ext->col_w[i];
    }
    for(i = 0; i < ext->row_cnt; i++) {
        h += get_row_height(table, i);
    }

    const lv_style_t * bg_style = lv_obj_get_style(table);

    w += bg_style->body.padding.left + bg_style->body.padding.right;
    h += bg_style->body.padding.top + bg_style->body.padding.bottom;

    lv_obj_set_size(table, w + 1, h + 1);
    lv_obj_invalidate(table);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6af7
movq %rax, %r14
movzwl (%rax), %eax
movw $0x1, %bp
movw $0x1, %r15w
testq %rax, %rax
je 0x1028c
xorl %ecx, %ecx
xorl %r15d, %r15d
addw 0x30(%r14,%rcx,2), %r15w
incq %rcx
cmpq %rcx, %rax
jne 0x1027b
incl %r15d
cmpw $0x0, 0x2(%r14)
je 0x102b3
xorl %ebp, %ebp
xorl %r12d, %r12d
movzwl %r12w, %esi
movq %rbx, %rdi
callq 0x10941
addl %eax, %ebp
incl %r12d
cmpw 0x2(%r14), %r12w
jb 0x10299
incl %ebp
movq %rbx, %rdi
callq 0x66b6
addw 0x1a(%rax), %r15w
addw 0x1c(%rax), %r15w
addw 0x16(%rax), %bp
addw 0x18(%rax), %bp
movswl %r15w, %esi
movswl %bp, %edx
movq %rbx, %rdi
callq 0x5557
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_col_width
void lv_table_set_col_width(lv_obj_t * table, uint16_t col_id, lv_coord_t w)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    if(col_id >= LV_TABLE_COL_MAX) {
        LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
        return;
    }

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    ext->col_w[col_id]   = w;
    refr_size(table);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x1030d
cmpw $0xb, %r14w
jbe 0x1031e
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2eed0(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1031c
movq %rbx, %rdi
callq 0x6af7
movzwl %r14w, %ecx
movw %bp, 0x30(%rax,%rcx,2)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10252
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_cell_align
void lv_table_set_cell_align(lv_obj_t * table, uint16_t row, uint16_t col, lv_label_align_t align)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_align: invalid row or column");
        return;
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL) {
        ext->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
        ext->cell_data[cell][0] = 0;
        ext->cell_data[cell][1] = '\0';
    }

    lv_table_cell_format_t format;
    format.format_byte      = ext->cell_data[cell][0];
    format.s.align          = align;
    ext->cell_data[cell][0] = format.format_byte;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x103d3
movq %r14, %rdi
callq 0x6af7
cmpw %r15w, 0x2(%rax)
jbe 0x103ca
movq %rax, %r14
movzwl (%rax), %r12d
cmpw %bp, %r12w
jbe 0x103ca
movzwl %r15w, %eax
movzwl %bp, %ecx
imulq %rax, %r12
addq %rcx, %r12
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
jne 0x103be
movl $0x2, %edi
callq 0x29f85
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movb %cl, 0x1(%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movb (%rax), %cl
andb $0x3, %bl
andb $-0x4, %cl
orb %bl, %cl
movb %cl, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ee0a(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x103e2
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_cell_type
void lv_table_set_cell_type(lv_obj_t * table, uint16_t row, uint16_t col, uint8_t type)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_type: invalid row or column");
        return;
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL) {
        ext->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
        ext->cell_data[cell][0] = 0;
        ext->cell_data[cell][1] = '\0';
    }

    if(type > 0) type--; /*User gives 1,2,3,4 but easier to handle 0, 1, 2, 3*/
    if(type >= LV_TABLE_CELL_STYLE_CNT) type = LV_TABLE_CELL_STYLE_CNT - 1;

    lv_table_cell_format_t format;
    format.format_byte      = ext->cell_data[cell][0];
    format.s.type           = type;
    ext->cell_data[cell][0] = format.format_byte;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x10496
movq %r14, %rdi
callq 0x6af7
cmpw %r15w, 0x2(%rax)
jbe 0x1048d
movq %rax, %r14
movzwl (%rax), %r12d
cmpw %bp, %r12w
jbe 0x1048d
movzwl %r15w, %eax
movzwl %bp, %ecx
imulq %rax, %r12
addq %rcx, %r12
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
jne 0x1046b
movl $0x2, %edi
callq 0x29f85
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movb %cl, 0x1(%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
subb $0x1, %bl
movzbl %bl, %edx
cmovbl %ecx, %edx
cmpb $0x3, %dl
movl $0x3, %ecx
cmovbl %edx, %ecx
movb (%rax), %dl
shlb $0x3, %cl
andb $-0x19, %dl
orb %cl, %dl
movb %dl, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ed47(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x104a5
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_cell_crop
void lv_table_set_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col, bool crop)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_crop: invalid row or column");
        return;
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL) {
        ext->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
        ext->cell_data[cell][0] = 0;
        ext->cell_data[cell][1] = '\0';
    }

    lv_table_cell_format_t format;
    format.format_byte      = ext->cell_data[cell][0];
    format.s.crop           = crop;
    ext->cell_data[cell][0] = format.format_byte;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x1053f
movq %r14, %rdi
callq 0x6af7
cmpw %r15w, 0x2(%rax)
jbe 0x10536
movq %rax, %r14
movzwl (%rax), %r12d
cmpw %bp, %r12w
jbe 0x10536
movzwl %r15w, %eax
movzwl %bp, %ecx
imulq %rax, %r12
addq %rcx, %r12
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
jne 0x1052a
movl $0x2, %edi
callq 0x29f85
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movb %cl, 0x1(%rax)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movb (%rax), %cl
shlb $0x5, %bl
andb $-0x21, %cl
orb %bl, %cl
movb %cl, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ec9e(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1054e
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_set_cell_merge_right
void lv_table_set_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col, bool en)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_merge_right: invalid row or column");
        return;
    }

    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL) {
        ext->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
        ext->cell_data[cell][0] = 0;
        ext->cell_data[cell][1] = '\0';
    }

    lv_table_cell_format_t format;
    format.format_byte      = ext->cell_data[cell][0];
    format.s.right_merge    = en ? 1 : 0;
    ext->cell_data[cell][0] = format.format_byte;
    refr_size(table);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x10608
movq %rbx, %rdi
callq 0x6af7
cmpw %r12w, 0x2(%rax)
jbe 0x10619
movq %rax, %r14
movzwl (%rax), %r13d
cmpw %r15w, %r13w
jbe 0x10619
movzwl %r12w, %eax
movzwl %r15w, %ecx
imulq %rax, %r13
addq %rcx, %r13
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
jne 0x105e4
movl $0x2, %edi
callq 0x29f85
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movb %cl, 0x1(%rax)
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movb (%rax), %cl
shlb $0x2, %bpl
andb $-0x5, %cl
orb %bpl, %cl
movb %cl, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10252
leaq 0x2ebd5(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x10617
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_table.c
// Function: lv_table_get_cell_value
const char * lv_table_get_cell_value(lv_obj_t * table, uint16_t row, uint16_t col)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_value: invalid row or column");
        return "";
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL) return "";

    return &ext->cell_data[cell][1]; /*Skip the format byte*/
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x10689
movq %r14, %rdi
callq 0x6af7
leaq 0x32f72(%rip), %rcx     # 0x435bd
cmpw %bp, 0x2(%rax)
jbe 0x10681
movzwl (%rax), %edx
cmpw %bx, %dx
jbe 0x10681
movzwl %bp, %ecx
imulq %rcx, %rdx
shlq $0x3, %rdx
addq 0x8(%rax), %rdx
movzwl %bx, %eax
movq (%rdx,%rax,8), %rax
leaq 0x1(%rax), %rdx
testq %rax, %rax
leaq 0x32f40(%rip), %rcx     # 0x435bd
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2eb54(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x10698
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_get_col_width
lv_coord_t lv_table_get_col_width(lv_obj_t * table, uint16_t col_id)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    if(col_id >= LV_TABLE_COL_MAX) {
        LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
        return 0;
    }

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    return ext->col_w[col_id];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x1070d
cmpw $0xb, %bx
jbe 0x1071e
xorl %eax, %eax
jmp 0x1072e
leaq 0x2ead0(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1071c
movq %r14, %rdi
callq 0x6af7
movzwl %bx, %ecx
movzwl 0x30(%rax,%rcx,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_get_cell_align
lv_label_align_t lv_table_get_cell_align(lv_obj_t * table, uint16_t row, uint16_t col)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_set_cell_align: invalid row or column");
        return LV_LABEL_ALIGN_LEFT; /*Just return with something*/
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL)
        return LV_LABEL_ALIGN_LEFT; /*Just return with something*/
    else {
        lv_table_cell_format_t format;
        format.format_byte = ext->cell_data[cell][0];
        return format.s.align;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x10781
movq %r14, %rdi
callq 0x6af7
cmpw %bp, 0x2(%rax)
jbe 0x10792
movzwl (%rax), %ecx
cmpw %bx, %cx
jbe 0x10792
movzwl %bp, %edx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq 0x8(%rax), %rcx
movzwl %bx, %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x10792
movb (%rax), %al
andb $0x3, %al
jmp 0x10794
leaq 0x2ea5c(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x10790
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_table.c
// Function: lv_table_get_cell_type
lv_label_align_t lv_table_get_cell_type(lv_obj_t * table, uint16_t row, uint16_t col)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_get_cell_type: invalid row or column");
        return 1; /*Just return with something*/
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL)
        return 1; /*Just return with something*/
    else {
        lv_table_cell_format_t format;
        format.format_byte = ext->cell_data[cell][0];
        return format.s.type + 1; /*0,1,2,3 is stored but user sees 1,2,3,4*/
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x107f1
movq %r14, %rdi
callq 0x6af7
movq %rax, %rcx
movb $0x1, %al
cmpw %bp, 0x2(%rcx)
jbe 0x107ec
movzwl (%rcx), %edx
cmpw %bx, %dx
jbe 0x107ec
movzwl %bp, %esi
imulq %rsi, %rdx
shlq $0x3, %rdx
addq 0x8(%rcx), %rdx
movzwl %bx, %ecx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x107ec
movb (%rcx), %al
shrb $0x3, %al
andb $0x3, %al
incb %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2e9ec(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x10800
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_table.c
// Function: lv_table_get_cell_crop
lv_label_align_t lv_table_get_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_get_cell_crop: invalid row or column");
        return false; /*Just return with something*/
    }
    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL)
        return false; /*Just return with something*/
    else {
        lv_table_cell_format_t format;
        format.format_byte = ext->cell_data[cell][0];
        return format.s.crop;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x10850
movq %r14, %rdi
callq 0x6af7
cmpw %bp, 0x2(%rax)
jbe 0x10861
movzwl (%rax), %ecx
cmpw %bx, %cx
jbe 0x10861
movzwl %bp, %edx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq 0x8(%rax), %rcx
movzwl %bx, %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x10861
movb (%rax), %al
shrb $0x5, %al
andb $0x1, %al
jmp 0x10863
leaq 0x2e98d(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1085f
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_table.c
// Function: lv_table_get_cell_merge_right
bool lv_table_get_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
    if(row >= ext->row_cnt || col >= ext->col_cnt) {
        LV_LOG_WARN("lv_table_get_cell_merge_right: invalid row or column");
        return false;
    }

    uint32_t cell = row * ext->col_cnt + col;

    if(ext->cell_data[cell] == NULL)
        return false;
    else {
        lv_table_cell_format_t format;
        format.format_byte = ext->cell_data[cell][0];
        return format.s.right_merge ? true : false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x108b6
movq %r14, %rdi
callq 0x6af7
cmpw %bp, 0x2(%rax)
jbe 0x108c7
movzwl (%rax), %ecx
cmpw %bx, %cx
jbe 0x108c7
movzwl %bp, %edx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq 0x8(%rax), %rcx
movzwl %bx, %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x108c7
movb (%rax), %al
andb $0x4, %al
shrb $0x2, %al
jmp 0x108c9
leaq 0x2e927(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x108c5
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_table.c
// Function: lv_table_get_style
const lv_style_t * lv_table_get_style(const lv_obj_t * table, lv_table_style_t type)
{
    LV_ASSERT_OBJ(table, LV_OBJX_NAME);

    lv_table_ext_t * ext     = lv_obj_get_ext_attr(table);
    const lv_style_t * style = NULL;

    switch(type) {
        case LV_TABLE_STYLE_BG: style = lv_obj_get_style(table); break;
        case LV_TABLE_STYLE_CELL1: style = ext->cell_style[0]; break;
        case LV_TABLE_STYLE_CELL2: style = ext->cell_style[1]; break;
        case LV_TABLE_STYLE_CELL3: style = ext->cell_style[2]; break;
        case LV_TABLE_STYLE_CELL4: style = ext->cell_style[3]; break;
        default: return NULL;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x1090f
movq %rbx, %rdi
callq 0x6af7
cmpb $0x4, %bpl
ja 0x10938
movzbl %bpl, %ecx
leaq 0x2ed5c(%rip), %rdx     # 0x3f654
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
leaq 0x2e8ce(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1091e
movq 0x28(%rax), %rax
jmp 0x1093a
movq 0x18(%rax), %rax
jmp 0x1093a
movq 0x20(%rax), %rax
jmp 0x1093a
movq 0x10(%rax), %rax
jmp 0x1093a
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_tabview.c
// Function: tab_btnm_event_cb
static void tab_btnm_event_cb(lv_obj_t * tab_btnm, lv_event_t event)
{
    if(event != LV_EVENT_CLICKED) return;

    uint16_t btn_id = lv_btnm_get_active_btn(tab_btnm);
    if(btn_id == LV_BTNM_BTN_NONE) return;

    lv_btnm_clear_btn_ctrl_all(tab_btnm, LV_BTNM_CTRL_TGL_STATE);
    lv_btnm_set_btn_ctrl(tab_btnm, btn_id, LV_BTNM_CTRL_TGL_STATE);

    lv_obj_t * tabview = lv_obj_get_parent(tab_btnm);

    uint32_t id_prev = lv_tabview_get_tab_act(tabview);
    lv_tabview_set_tab_act(tabview, btn_id, LV_ANIM_ON);
    uint32_t id_new = lv_tabview_get_tab_act(tabview);

    lv_res_t res = LV_RES_OK;
    if(id_prev != id_new) res = lv_event_send(tabview, LV_EVENT_VALUE_CHANGED, &id_new);

    if(res != LV_RES_OK) return;
}

// Assembly:
cmpl $0x6, %esi
jne 0x11180
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x228e6
cmpw $-0x1, %ax
je 0x11178
movl %eax, %ebp
movq %rbx, %rdi
movl $0x80, %esi
callq 0x22768
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x80, %edx
callq 0x225f2
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %rbx
movq %rax, %rdi
callq 0x1210d
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x11c83
movq %rbx, %rdi
callq 0x1210d
movzwl %ax, %eax
movl %eax, 0xc(%rsp)
cmpw %ax, %r14w
je 0x11178
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0xe, %esi
callq 0x5018
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_tabview.c
// Function: lv_tabview_set_style
void lv_tabview_set_style(lv_obj_t * tabview, lv_tabview_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);

    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);

    switch(type) {
        case LV_TABVIEW_STYLE_BG: lv_obj_set_style(tabview, style); break;
        case LV_TABVIEW_STYLE_BTN_BG:
            lv_btnm_set_style(ext->btns, LV_BTNM_STYLE_BG, style);
            tabview_realign(tabview);
            break;
        case LV_TABVIEW_STYLE_BTN_REL:
            lv_btnm_set_style(ext->btns, LV_BTNM_STYLE_BTN_REL, style);
            tabview_realign(tabview);
            break;
        case LV_TABVIEW_STYLE_BTN_PR: lv_btnm_set_style(ext->btns, LV_BTNM_STYLE_BTN_PR, style); break;
        case LV_TABVIEW_STYLE_BTN_TGL_REL: lv_btnm_set_style(ext->btns, LV_BTNM_STYLE_BTN_TGL_REL, style); break;
        case LV_TABVIEW_STYLE_BTN_TGL_PR: lv_btnm_set_style(ext->btns, LV_BTNM_STYLE_BTN_TGL_PR, style); break;
        case LV_TABVIEW_STYLE_INDIC:
            lv_obj_set_style(ext->indic, style);

            switch(ext->btns_pos) {
                case LV_TABVIEW_BTNS_POS_TOP:
                case LV_TABVIEW_BTNS_POS_BOTTOM: lv_obj_set_height(ext->indic, style->body.padding.inner); break;
                case LV_TABVIEW_BTNS_POS_LEFT:
                case LV_TABVIEW_BTNS_POS_RIGHT: lv_obj_set_width(ext->indic, style->body.padding.inner); break;
            }

            tabview_realign(tabview);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x111d3
movq %rbx, %rdi
callq 0x6af7
cmpb $0x6, %bpl
ja 0x11217
movq %rax, %r15
movzbl %bpl, %eax
leaq 0x2e4bf(%rip), %rcx     # 0x3f674
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d9f
leaq 0x2e00a(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x111e2
movq (%r15), %rdi
movl $0x2, %esi
jmp 0x1125a
movq (%r15), %rdi
xorl %esi, %esi
jmp 0x111fd
movq (%r15), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x223df
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11808
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x5d9f
testb $0x40, 0x2a(%r15)
movq 0x8(%r15), %rdi
movzwl 0x1e(%r14), %eax
movswl %ax, %esi
jne 0x1126c
callq 0x574b
jmp 0x11205
movq (%r15), %rdi
movl $0x3, %esi
jmp 0x1125a
movq (%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x223df
callq 0x570d
jmp 0x11205