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

    lv_obj_invalidate(label);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

    /*If text is NULL then refresh */
    if(text == NULL) {
        lv_label_refr_text(label);
        return;
    }

    LV_ASSERT_STR(text);

    if(ext->text == text) {
        /*If set its own text then reallocate it (maybe its size changed)*/
        ext->text = lv_mem_realloc(ext->text, strlen(ext->text) + 1);
        LV_ASSERT_MEM(ext->text);
        if(ext->text == NULL) return;
    } else {
        /*Allocate space for the new text*/
        size_t len = strlen(text) + 1;
        if(ext->text != NULL && ext->static_txt == 0) {
            lv_mem_free(ext->text);
            ext->text = NULL;
        }

        ext->text = lv_mem_alloc(len);
        LV_ASSERT_MEM(ext->text);
        if(ext->text == NULL) return;

        strcpy(ext->text, text);

        /*Now the text is dynamically allocated*/
        ext->static_txt = 0;
    }

    lv_label_refr_text(label);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x19fc1
movq %rbx, %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x6ad8
testq %r14, %r14
je 0x1a00e
movq %rax, %r15
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x19fd2
movq (%r15), %r12
cmpq %r14, %r12
je 0x19fe3
movq %r14, %rdi
callq 0x2070
movq %rax, %r13
incq %r13
testq %r12, %r12
je 0x19f8c
testb $0x8, 0x18(%r15)
jne 0x19f8c
movq %r12, %rdi
callq 0x29984
movq $0x0, (%r15)
movq %r13, %rdi
callq 0x298d9
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80d4
movq (%r15), %rsi
testb %al, %al
je 0x1a01f
testq %rsi, %rsi
je 0x1a03b
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2040
andb $-0x9, 0x18(%r15)
jmp 0x1a00e
leaq 0x2516c(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x19fd0
leaq 0x2515b(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x19fe1
movq %r12, %rdi
callq 0x2070
leaq 0x1(%rax), %rsi
movq %r12, %rdi
callq 0x299f8
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80d4
movq (%r15), %rsi
testb %al, %al
je 0x1a02d
testq %rsi, %rsi
je 0x1a03b
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a365
leaq 0x2501a(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1a02b
leaq 0x2500c(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1a039
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_recolor
void lv_label_set_recolor(lv_obj_t * label, bool en)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->recolor == en) return;

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

    lv_label_refr_text(label); /*Refresh the text because the potential colo codes in text needs to
                                  be hided or revealed*/
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1a0a1
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x18(%rax), %ecx
testb $0x40, %cl
sete %dl
xorb %bpl, %dl
je 0x1a0b2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2508c(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1a0b0
movzbl %bpl, %edx
shll $0x6, %edx
andl $-0x41, %ecx
orl %edx, %ecx
movw %cx, 0x18(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a365
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_body_draw
void lv_label_set_body_draw(lv_obj_t * label, bool en)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->body_draw == en) return;

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

    lv_obj_refresh_ext_draw_pad(label);

    lv_obj_invalidate(label);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1a12f
movq %rbx, %rdi
callq 0x6ad8
movl 0x18(%rax), %ecx
btl $0x8, %ecx
setae %dl
xorb %bpl, %dl
je 0x1a140
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x24ffe(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1a13e
movzbl %bpl, %edx
shll $0x8, %edx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl %edx, %ecx
movw %cx, 0x18(%rax)
movq %rbx, %rdi
callq 0x64f5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_align
void lv_label_set_align(lv_obj_t * label, lv_label_align_t align)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->align == align) return;

    ext->align = align;

    lv_obj_invalidate(label); /*Enough to invalidate because alignment is only drawing related
                                 (lv_refr_label_text() not required)*/
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1a1cb
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x18(%rax), %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0x3, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x1a1dc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x24f62(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1a1da
shlb $0x4, %bpl
andb $0x30, %bpl
movzbl %bpl, %edx
andl $-0x31, %ecx
orl %edx, %ecx
movw %cx, 0x18(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_static_text
void lv_label_set_static_text(lv_obj_t * label, const char * text)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);
    LV_ASSERT_STR(text);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->static_txt == 0 && ext->text != NULL) {
        lv_mem_free(ext->text);
        ext->text = NULL;
    }

    if(text != NULL) {
        ext->static_txt = 1;
        ext->text       = (char *)text;
    }

    lv_label_refr_text(label);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1a2c3
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x1a2d4
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
testb $0x8, 0x18(%rax)
jne 0x1a2a9
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a2a9
callq 0x29984
movq $0x0, (%r15)
testq %r14, %r14
je 0x1a2b6
orb $0x8, 0x18(%r15)
movq %r14, (%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1a365
leaq 0x24e6a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1a2d2
leaq 0x24e59(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1a2e3
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_dot_tmp
static bool lv_label_set_dot_tmp(lv_obj_t * label, char * data, uint16_t len)
{
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    lv_label_dot_tmp_free(label); /* Deallocate any existing space */
    if(len > sizeof(char *)) {
        /* Memory needs to be allocated. Allocates an additional byte
         * for a NULL-terminator so it can be copied. */
        ext->dot.tmp_ptr = lv_mem_alloc(len + 1);
        if(ext->dot.tmp_ptr == NULL) {
            LV_LOG_ERROR("Failed to allocate memory for dot_tmp_ptr");
            return false;
        }
        memcpy(ext->dot.tmp_ptr, data, len);
        ext->dot.tmp_ptr[len] = '\0';
        ext->dot_tmp_alloc    = true;
    } else {
        /* Characters can be directly stored in object */
        ext->dot_tmp_alloc = false;
        memcpy(ext->dot.tmp, data, len);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x6ad8
movq %rax, %r14
movq %r15, %rdi
callq 0x1b76f
movl %ebp, %r15d
cmpw $0x9, %bp
jb 0x1a33d
leaq 0x1(%r15), %rdi
callq 0x298d9
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x1a361
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20f0
movq 0x8(%r14), %rax
movb $0x0, (%rax,%r15)
orb $0x2, 0x19(%r14)
jmp 0x1a354
andb $-0x3, 0x19(%r14)
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20f0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1a356
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_text_fmt
void lv_label_set_text_fmt(lv_obj_t * label, const char * fmt, ...)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);
    LV_ASSERT_STR(fmt);

    lv_obj_invalidate(label);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

    /*If text is NULL then refresh */
    if(fmt == NULL) {
        lv_label_refr_text(label);
        return;
    }

    if(ext->text != NULL && ext->static_txt == 0) {
            lv_mem_free(ext->text);
            ext->text = NULL;
    }

    va_list ap, ap2;
    va_start(ap, fmt);
    va_copy(ap2, ap);

    /*Allocate space for the new text by using trick from C99 standard section 7.19.6.12 */
    uint32_t len = lv_vsnprintf(NULL, 0, fmt, ap);

    va_end(ap);
    

    ext->text = lv_mem_alloc(len+1);
    LV_ASSERT_MEM(ext->text);
    if(ext->text == NULL) return;
    ext->text[len-1] = 0; /* Ensure NULL termination */

    lv_vsnprintf(ext->text, len+1, fmt, ap2);

    va_end(ap2);
    ext->static_txt = 0; /*Now the text is dynamically allocated*/

    lv_label_refr_text(label);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x68(%rsp)
testb %al, %al
je 0x1a924
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
callq 0x80d4
testb %al, %al
je 0x1aa1d
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x1aa2e
movq %rbx, %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x6ad8
testq %r14, %r14
je 0x1aa3f
movq %rax, %r15
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1a978
testb $0x8, 0x18(%r15)
jne 0x1a978
callq 0x29984
movq $0x0, (%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %rax, 0x10(%rsp)
movq (%rcx), %rax
movq %rax, (%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2bae4
movl %eax, %r13d
leal 0x1(%r13), %r12d
movq %r12, %rdi
callq 0x298d9
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80d4
movq (%r15), %rsi
testb %al, %al
je 0x1aa57
testq %rsi, %rsi
je 0x1aa0c
decl %r13d
movb $0x0, (%rsi,%r13)
movq (%r15), %rdi
movq %rsp, %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x2bae4
andb $-0x9, 0x18(%r15)
movq %rbx, %rdi
callq 0x1a365
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x24710(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1aa2c
leaq 0x246ff(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1aa3d
movq %rbx, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a365
leaq 0x245e2(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1aa63
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_array_text
void lv_label_set_array_text(lv_obj_t * label, const char * array, uint16_t size)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_obj_invalidate(label);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

    /*If trying to set its own text or the array is NULL then refresh */
    if(array == ext->text || array == NULL) {
        lv_label_refr_text(label);
        return;
    }

    /*Allocate space for the new text*/
    if(ext->text != NULL && ext->static_txt == 0) {
        lv_mem_free(ext->text);
        ext->text = NULL;
    }
    ext->text = lv_mem_alloc(size + 1);
    LV_ASSERT_MEM(ext->text);
    if(ext->text == NULL) return;

    memcpy(ext->text, array, size);
    ext->text[size] = '\0';
    ext->static_txt = 0; /*Now the text is dynamically allocated*/

    lv_label_refr_text(label);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1ab10
movq %rbx, %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r15
movq (%rax), %rdi
cmpq %r14, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1ab00
testq %rdi, %rdi
je 0x1aac0
testb $0x8, 0x18(%r15)
jne 0x1aac0
callq 0x29984
movq $0x0, (%r15)
movzwl %bp, %r12d
leaq 0x1(%r12), %rdi
callq 0x298d9
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80d4
movq (%r15), %rsi
testb %al, %al
je 0x1ab21
testq %rsi, %rsi
je 0x1ab2f
movq %rsi, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x20f0
movq (%r15), %rax
movb $0x0, (%rax,%r12)
andb $-0x9, 0x18(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1a365
leaq 0x2461d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1ab1f
leaq 0x24518(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1ab2d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_revert_dots
static void lv_label_revert_dots(lv_obj_t * label)
{
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->long_mode != LV_LABEL_LONG_DOT) return;
    if(ext->dot_end == LV_LABEL_DOT_END_INV) return;
    uint32_t letter_i = ext->dot_end - LV_LABEL_DOT_NUM;
    uint32_t byte_i   = lv_txt_encoded_get_byte_id(ext->text, letter_i);

    /*Restore the characters*/
    uint8_t i      = 0;
    char * dot_tmp = lv_label_get_dot_tmp(label);
    while(ext->text[byte_i + i] != '\0') {
        ext->text[byte_i + i] = dot_tmp[i];
        i++;
    }
    ext->text[byte_i + i] = dot_tmp[i];
    lv_label_dot_tmp_free(label);

    ext->dot_end = LV_LABEL_DOT_END_INV;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6ad8
movq %rax, %r14
movzwl 0x18(%rax), %eax
andl $0x7, %eax
cmpw $0x2, %ax
jne 0x1ac16
movzwl 0x10(%r14), %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x1ac16
addl $-0x3, %esi
leaq 0x38a92(%rip), %rax     # 0x53640
movq (%r14), %rdi
callq *(%rax)
movl %eax, %r15d
movq %rbx, %rdi
callq 0x6ad8
leaq 0x8(%rax), %rcx
testb $0x2, 0x19(%rax)
je 0x1abcb
movq (%rcx), %rcx
movq (%r14), %rdx
movl %r15d, %esi
leaq (%rdx,%rsi), %rax
cmpb $0x0, (%rdx,%rsi)
je 0x1ac00
xorl %edx, %edx
movzbl %dl, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax)
incb %dl
movq (%r14), %rdi
movzbl %dl, %esi
leal (%r15,%rsi), %r8d
leaq (%rdi,%r8), %rax
cmpb $0x0, (%rdi,%r8)
jne 0x1abdd
jmp 0x1ac02
xorl %esi, %esi
movb (%rcx,%rsi), %cl
movb %cl, (%rax)
movq %rbx, %rdi
callq 0x1b76f
movw $0xffff, 0x10(%r14)     # imm = 0xFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_anim_speed
void lv_label_set_anim_speed(lv_obj_t * label, uint16_t anim_speed)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->anim_speed == anim_speed) return;

    ext->anim_speed = anim_speed;

    if(ext->long_mode == LV_LABEL_LONG_SROLL || ext->long_mode == LV_LABEL_LONG_SROLL_CIRC) {
        lv_label_refr_text(label);
    }
#else
    (void)label;      /*Unused*/
    (void)anim_speed; /*Unused*/
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1ac5d
movq %rbx, %rdi
callq 0x6ad8
cmpw %bp, 0x16(%rax)
je 0x1ac6e
movw %bp, 0x16(%rax)
movzwl 0x18(%rax), %eax
andl $0x7, %eax
addl $-0x3, %eax
cmpw $0x1, %ax
ja 0x1ac6e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a365
leaq 0x244d0(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1ac6c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_get_anim_speed
uint16_t lv_label_get_anim_speed(const lv_obj_t * label)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

#if LV_USE_ANIMATION
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    return ext->anim_speed;
#else
    (void)label;      /*Unused*/
    return 0;
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1acd0
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x16(%rax), %eax
popq %rbx
retq
leaq 0x2445d(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1acdf
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_ins_text
void lv_label_ins_text(lv_obj_t * label, uint32_t pos, const char * txt)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);
    LV_ASSERT_STR(txt);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

    /*Can not append to static text*/
    if(ext->static_txt != 0) return;

    lv_obj_invalidate(label);

    /*Allocate space for the new text*/
    size_t old_len = strlen(ext->text);
    size_t ins_len = strlen(txt);
    size_t new_len = ins_len + old_len;
    ext->text        = lv_mem_realloc(ext->text, new_len + 1);
    LV_ASSERT_MEM(ext->text);
    if(ext->text == NULL) return;

    if(pos == LV_LABEL_POS_LAST) {
        pos = lv_txt_get_encoded_length(ext->text);
    }

    lv_txt_ins(ext->text, pos, txt);
    lv_label_refr_text(label);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1b6ce
movq %r14, %rdi
callq 0x80d4
testb %al, %al
je 0x1b6df
movq %rbx, %rdi
callq 0x6ad8
testb $0x8, 0x18(%rax)
jne 0x1b6f0
movq %rax, %r15
movq %rbx, %rdi
callq 0x4c36
movq (%r15), %r12
movq %r12, %rdi
callq 0x2070
movq %rax, %r13
movq %r14, %rdi
callq 0x2070
leaq (%rax,%r13), %rsi
incq %rsi
movq %r12, %rdi
callq 0x299f8
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80d4
movq (%r15), %rsi
testb %al, %al
je 0x1b6ff
testq %rsi, %rsi
je 0x1b6f0
cmpl $0xffff, %ebp           # imm = 0xFFFF
jne 0x1b6ab
leaq 0x37fac(%rip), %rax     # 0x53650
movq %rsi, %rdi
callq *(%rax)
movl %eax, %ebp
movq (%r15), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2acb7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a365
leaq 0x23a5f(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1b6dd
leaq 0x23a4e(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1b6ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2393a(%rip), %rdi     # 0x3f040
callq 0x829e
jmp 0x1b70b
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_cut_text
void lv_label_cut_text(lv_obj_t * label, uint32_t pos, uint32_t cnt)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

    /*Can not append to static text*/
    if(ext->static_txt != 0) return;

    lv_obj_invalidate(label);

    char * label_txt = lv_label_get_text(label);
    /*Delete the characters*/
    lv_txt_cut(label_txt, pos, cnt);

    /*Refresh the label*/
    lv_label_refr_text(label);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1b759
movq %rbx, %rdi
callq 0x6ad8
testb $0x8, 0x18(%rax)
jne 0x1b76a
movq %rbx, %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x1a239
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x2ad28
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a365
leaq 0x239d4(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1b768
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_dot_tmp_free
static void lv_label_dot_tmp_free(lv_obj_t * label)
{
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
    if(ext->dot_tmp_alloc && ext->dot.tmp_ptr) {
        lv_mem_free(ext->dot.tmp_ptr);
    }
    ext->dot_tmp_alloc = false;
    ext->dot.tmp_ptr   = NULL;
}

// Assembly:
pushq %rbx
callq 0x6ad8
movq %rax, %rbx
testb $0x2, 0x19(%rax)
je 0x1b78c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1b78c
callq 0x29984
andb $-0x3, 0x19(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_next_btn
lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    /* Not a good practice but user can add/create objects to the lists manually.
     * When getting the next button try to be sure that it is at least a button */

    lv_obj_t * btn;
    lv_obj_t * scrl = lv_page_get_scrl(list);

    btn = lv_obj_get_child_back(scrl, prev_btn);
    if(btn == NULL) return NULL;

    while(lv_list_is_list_btn(btn) == false) {
        btn = lv_obj_get_child_back(scrl, btn);
        if(btn == NULL) break;
    }

    return btn;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1becf
movq %r14, %rdi
callq 0x26288
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x652f
testq %rax, %rax
je 0x1bec2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1c7cd
testb %al, %al
jne 0x1bec4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x652f
movq %rax, %rbx
testq %rax, %rax
jne 0x1bea3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2325e(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1bede
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_btn_img
lv_obj_t * lv_list_get_btn_img(const lv_obj_t * btn)
{
    LV_ASSERT_OBJ(btn, "lv_btn");

#if LV_USE_IMG != 0
    lv_obj_t * img = lv_obj_get_child(btn, NULL);
    if(img == NULL) return NULL;

    while(lv_list_is_list_img(img) == false) {
        img = lv_obj_get_child(btn, img);
        if(img == NULL) break;
    }

    return img;
#else
    return NULL;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1bf6b
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51a3
testq %rax, %rax
je 0x1bf5a
movq %rsp, %r15
leaq 0x238cb(%rip), %r12     # 0x3f7e0
movq %rax, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6afc
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rdi
testq %rdi, %rdi
je 0x1bf44
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x1bf5a
incq %r13
cmpq $0x8, %r13
jne 0x1bf26
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a3
movq %rax, %r14
testq %rax, %rax
jne 0x1bf18
xorl %r14d, %r14d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x231c2(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1bf7a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_btn_text
const char * lv_list_get_btn_text(const lv_obj_t * btn)
{
    LV_ASSERT_OBJ(btn, "lv_btn");

    lv_obj_t * label = lv_list_get_btn_label(btn);
    if(label == NULL) return "";
    return lv_label_get_text(label);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c1c9
movq %rbx, %rdi
callq 0x1c731
testq %rax, %rax
je 0x1c1da
movq %rax, %rdi
popq %rbx
jmp 0x1a239
leaq 0x22f64(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c1d8
leaq 0x271ec(%rip), %rax     # 0x433cd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_clean
void lv_list_clean(lv_obj_t * list)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    lv_obj_t * scrl = lv_page_get_scrl(list);
    lv_obj_clean(scrl);
    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
    ext->size           = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c213
movq %rbx, %rdi
callq 0x26288
movq %rax, %rdi
callq 0x514b
movq %rbx, %rdi
callq 0x6ad8
movw $0x0, 0x80(%rax)
popq %rbx
retq
leaq 0x22f1a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c222
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_set_btn_selected
void lv_list_set_btn_selected(lv_obj_t * list, lv_obj_t * btn)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
    if(btn) LV_ASSERT_OBJ(list, "lv_btn");

    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);

    if(ext->selected_btn) {
        lv_btn_state_t s = lv_btn_get_state(ext->selected_btn);
        if(s == LV_BTN_STATE_PR)
            lv_btn_set_state(ext->selected_btn, LV_BTN_STATE_REL);
        else if(s == LV_BTN_STATE_TGL_PR)
            lv_btn_set_state(ext->selected_btn, LV_BTN_STATE_TGL_REL);
    }

    ext->selected_btn = btn;

    /*Don't forget which button was selected.
     * It will be restored when the list is focused.*/
    if(btn != NULL) {
        ext->last_sel = btn;
    }

    if(ext->selected_btn) {
        lv_btn_state_t s = lv_btn_get_state(ext->selected_btn);
        if(s == LV_BTN_STATE_REL)
            lv_btn_set_state(ext->selected_btn, LV_BTN_STATE_PR);
        else if(s == LV_BTN_STATE_TGL_REL)
            lv_btn_set_state(ext->selected_btn, LV_BTN_STATE_TGL_PR);

        lv_page_focus(list, ext->selected_btn, LV_ANIM_ON);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c455
testq %r15, %r15
je 0x1c429
movq %rbx, %rdi
callq 0x80d4
testb %al, %al
je 0x1c466
movq %rbx, %rdi
callq 0x6ad8
movq %rax, %r14
movq 0x90(%rax), %rdi
testq %rdi, %rdi
je 0x1c488
callq 0x136de
cmpb $0x1, %al
je 0x1c477
movzbl %al, %eax
cmpl $0x3, %eax
jne 0x1c488
movb $0x2, %al
jmp 0x1c479
leaq 0x22cd8(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c464
leaq 0x22cc7(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c475
xorl %eax, %eax
movq 0x90(%r14), %rdi
movzbl %al, %esi
callq 0x135d2
movq %r15, 0x90(%r14)
testq %r15, %r15
je 0x1c4b3
movq %r15, 0x88(%r14)
movq %r15, %rdi
callq 0x136de
testb %al, %al
je 0x1c4b9
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x1c4ca
movb $0x3, %al
jmp 0x1c4bb
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
movq 0x90(%r14), %rdi
movzbl %al, %esi
callq 0x135d2
movq 0x90(%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x265b1
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_remove
bool lv_list_remove(const lv_obj_t * list, uint16_t index)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
    if(index >= ext->size) return false;
    uint16_t count = 0;
    lv_obj_t * e   = lv_list_get_next_btn(list, NULL);
    while(e != NULL) {
        if(count == index) {
            lv_obj_del(e);
            ext->size--;
            return true;
        }
        e = lv_list_get_next_btn(list, e);
        count++;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c537
movq %rbx, %rdi
callq 0x6ad8
cmpw %bp, 0x80(%rax)
jbe 0x1c548
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1be72
testq %rax, %rax
setne %cl
je 0x1c55e
incl %ebp
decw %bp
je 0x1c54c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1be72
testq %rax, %rax
setne %cl
jne 0x1c51d
jmp 0x1c55e
leaq 0x22bf6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c546
xorl %ecx, %ecx
jmp 0x1c55e
movq %rax, %rdi
callq 0x4d2b
decw 0x80(%r14)
movb $0x1, %cl
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_prev_btn
lv_obj_t * lv_list_get_prev_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    /* Not a good practice but user can add/create objects to the lists manually.
     * When getting the next button try to be sure that it is at least a button */

    lv_obj_t * btn;
    lv_obj_t * scrl = lv_page_get_scrl(list);

    btn = lv_obj_get_child(scrl, prev_btn);
    if(btn == NULL) return NULL;

    while(lv_list_is_list_btn(btn) == false) {
        btn = lv_obj_get_child(scrl, btn);
        if(btn == NULL) break;
    }

    return btn;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1c606
movq %r14, %rdi
callq 0x26288
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51a3
testq %rax, %rax
je 0x1c5f9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1c7cd
testb %al, %al
jne 0x1c5fb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51a3
movq %rax, %rbx
testq %rax, %rax
jne 0x1c5da
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22b27(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1c615
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_set_layout
void lv_list_set_layout(lv_obj_t * list, lv_layout_t layout)
 {
     LV_ASSERT_OBJ(list, LV_OBJX_NAME);

	/* Update list layout if necessary */
	if (layout == lv_list_get_layout(list)) return;

    /* Get the first button on the list */
    lv_obj_t * btn = lv_list_get_prev_btn(list, NULL);

    /* Visit all buttons on the list and update their layout  */
    while(btn != NULL) {
        /*If a column layout set the buttons' width to list width*/
        if(layout == LV_LAYOUT_COL_M || layout == LV_LAYOUT_COL_L || layout == LV_LAYOUT_COL_R) {
            lv_btn_set_fit2(list, LV_FIT_FLOOD, LV_FIT_TIGHT);
        }
        /*If a row layout set the buttons' width according to the content*/
        else if (layout == LV_LAYOUT_ROW_M || layout == LV_LAYOUT_ROW_T || layout == LV_LAYOUT_ROW_B) {
            lv_btn_set_fit(list, LV_FIT_TIGHT);
        }

        btn = lv_list_get_prev_btn(list, btn);
    }

    lv_page_set_scrl_layout(list, layout);
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1c642
movq %r14, %rdi
callq 0x1c6d2
cmpb %bl, %al
jne 0x1c653
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22aeb(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1c651
movq %r14, %rdi
xorl %esi, %esi
callq 0x1c5a9
testq %rax, %rax
je 0x1c6b7
movq %rax, %r15
leal -0x2(%rbx), %ebp
leal -0x5(%rbx), %r12d
cmpb $0x2, %bpl
ja 0x1c681
movq %r14, %rdi
movl $0x2, %esi
movl $0x2, %edx
jmp 0x1c694
cmpb $0x2, %r12b
ja 0x1c6a4
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x22602
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c5a9
movq %rax, %r15
testq %rax, %rax
jne 0x1c66c
movq %r14, %rdi
callq 0x26288
movzbl %bl, %esi
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2259a
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_btn_label
lv_obj_t * lv_list_get_btn_label(const lv_obj_t * btn)
{
    LV_ASSERT_OBJ(btn, "lv_btn");

    lv_obj_t * label = lv_obj_get_child(btn, NULL);
    if(label == NULL) return NULL;

    while(lv_list_is_list_label(label) == false) {
        label = lv_obj_get_child(btn, label);
        if(label == NULL) break;
    }

    return label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c7bc
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51a3
testq %rax, %rax
je 0x1c7ab
movq %rsp, %r15
leaq 0x22fd3(%rip), %r12     # 0x3f739
movq %rax, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6afc
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rdi
testq %rdi, %rdi
je 0x1c795
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x1c7ab
incq %r13
cmpq $0x8, %r13
jne 0x1c777
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a3
movq %rax, %r14
testq %rax, %rax
jne 0x1c769
xorl %r14d, %r14d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x22971(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c7cb
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_is_list_btn
static bool lv_list_is_list_btn(lv_obj_t * list_btn)
{
    lv_obj_type_t type;

    lv_obj_get_type(list_btn, &type);
    uint8_t cnt;
    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
        if(type.type[cnt] == NULL) break;
        if(!strcmp(type.type[cnt], "lv_btn")) return true;
    }
    return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x8(%rsp), %rsi
callq 0x6afc
xorl %r14d, %r14d
leaq 0x22e10(%rip), %rbx     # 0x3f5f8
movq 0x8(%rsp,%r14,8), %rdi
testq %rdi, %rdi
je 0x1c807
movq %rbx, %rsi
callq 0x20e0
testl %eax, %eax
je 0x1c80b
incq %r14
cmpq $0x8, %r14
jne 0x1c7e8
xorl %eax, %eax
jmp 0x1c80d
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_btn_index
int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
    LV_ASSERT_OBJ(btn, "lv_btn");

    int index = 0;
    if(list == NULL) {
        /* no list provided, assuming btn is part of a list */
        list = lv_obj_get_parent(lv_obj_get_parent(btn));
    }
    lv_obj_t * e = lv_list_get_next_btn(list, NULL);
    while(e != NULL) {
        if(e == btn) {
            return index;
        }
        index++;
        e = lv_list_get_next_btn(list, e);
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1c87b
movq %rbx, %rdi
callq 0x80d4
testb %al, %al
je 0x1c88c
testq %r14, %r14
jne 0x1c84f
movq %rbx, %rdi
callq 0x4abf
movq %rax, %rdi
callq 0x4abf
movq %rax, %r14
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x1be72
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1c8a0
cmpq %rbx, %rax
je 0x1c89d
incl %r15d
movq %r14, %rdi
movq %rax, %rsi
callq 0x1be72
jmp 0x1c861
leaq 0x228b2(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1c88a
leaq 0x228a1(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c89b
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_get_style
const lv_style_t * lv_list_get_style(const lv_obj_t * list, lv_list_style_t type)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_list_ext_t * ext      = lv_obj_get_ext_attr(list);

    switch(type) {
        case LV_LIST_STYLE_BG: style = lv_page_get_style(list, LV_PAGE_STYLE_BG); break;
        case LV_LIST_STYLE_SCRL: style = lv_page_get_style(list, LV_PAGE_STYLE_SCRL); break;
        case LV_LIST_STYLE_SB: style = lv_page_get_style(list, LV_PAGE_STYLE_SB); break;
        case LV_LIST_STYLE_EDGE_FLASH: style = lv_page_get_style(list, LV_PAGE_STYLE_EDGE_FLASH); break;
        case LV_LIST_STYLE_BTN_REL: style = ext->styles_btn[LV_BTN_STATE_REL]; break;
        case LV_LIST_STYLE_BTN_PR: style = ext->styles_btn[LV_BTN_STATE_PR]; break;
        case LV_LIST_STYLE_BTN_TGL_REL: style = ext->styles_btn[LV_BTN_STATE_TGL_REL]; break;
        case LV_LIST_STYLE_BTN_TGL_PR: style = ext->styles_btn[LV_BTN_STATE_TGL_PR]; break;
        case LV_LIST_STYLE_BTN_INA: style = ext->styles_btn[LV_BTN_STATE_INA]; break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1c945
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x8, %bpl
ja 0x1c99b
movzbl %bpl, %ecx
leaq 0x22e7f(%rip), %rdx     # 0x3f7b4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1c97e
leaq 0x227e8(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1c954
movq 0x50(%rax), %rax
jmp 0x1c99d
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1c97e
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x1c97e
movq 0x68(%rax), %rax
jmp 0x1c99d
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25ddf
movq 0x58(%rax), %rax
jmp 0x1c99d
movq 0x60(%rax), %rax
jmp 0x1c99d
movq 0x70(%rax), %rax
jmp 0x1c99d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_up
void lv_list_up(const lv_obj_t * list)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    /*Search the first list element which 'y' coordinate is below the parent
     * and position the list to show this element on the bottom*/
    lv_obj_t * scrl = lv_page_get_scrl(list);
    lv_obj_t * e;
    lv_obj_t * e_prev = NULL;

    e                 = lv_list_get_prev_btn(list, NULL);
    while(e != NULL) {
        if(e->coords.y2 <= list->coords.y2) {
            if(e_prev != NULL) {
                lv_coord_t new_y = lv_obj_get_height(list) - (lv_obj_get_y(e_prev) + lv_obj_get_height(e_prev));
                if(lv_list_get_anim_time(list) == 0) {
                    lv_obj_set_y(scrl, new_y);
                } else {
#if LV_USE_ANIMATION
                    lv_anim_t a;
                    a.var            = scrl;
                    a.start          = lv_obj_get_y(scrl);
                    a.end            = new_y;
                    a.exec_cb        = (lv_anim_exec_xcb_t)lv_obj_set_y;
                    a.path_cb        = lv_anim_path_linear;
                    a.ready_cb       = NULL;
                    a.act_time       = 0;
                    a.time           = LV_LIST_DEF_ANIM_TIME;
                    a.playback       = 0;
                    a.playback_pause = 0;
                    a.repeat         = 0;
                    a.repeat_pause   = 0;
                    lv_anim_create(&a);
#endif
                }
            }
            break;
        }
        e_prev = e;
        e      = lv_list_get_prev_btn(list, e);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1ca0d
movq %rbx, %rdi
callq 0x26288
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c5a9
testq %rax, %rax
je 0x1caa1
movq %rax, %r15
movzwl 0x26(%rax), %eax
cmpw 0x26(%rbx), %ax
jle 0x1ca1e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c5a9
testq %rax, %rax
je 0x1caa1
movzwl 0x26(%rax), %ecx
movq %r15, %r12
movq %rax, %r15
cmpw 0x26(%rbx), %cx
jg 0x1c9e7
jmp 0x1ca21
leaq 0x22720(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1ca1c
xorl %r12d, %r12d
testq %r12, %r12
je 0x1caa1
movq %rbx, %rdi
callq 0x567b
movl %eax, %ebp
movq %r12, %rdi
callq 0x4bfe
movl %eax, %r15d
movq %r12, %rdi
callq 0x567b
addl %r15d, %eax
subl %eax, %ebp
movq %rbx, %rdi
callq 0x26367
testw %ax, %ax
je 0x1caae
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x4bfe
cwtl
movl %eax, 0x20(%rbx)
movswl %bp, %eax
movl %eax, 0x24(%rbx)
leaq -0x17575(%rip), %rax    # 0x5501
movq %rax, 0x8(%rbx)
leaq 0xca74(%rip), %rax      # 0x294f5
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq $0x64, 0x28(%rbx)
andb $-0x4, 0x30(%rbx)
movq %rbx, %rdi
callq 0x29521
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movswl %bp, %esi
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5501
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_down
void lv_list_down(const lv_obj_t * list)
{
    LV_ASSERT_OBJ(list, LV_OBJX_NAME);

    /*Search the first list element which 'y' coordinate is above the parent
     * and position the list to show this element on the top*/
    lv_obj_t * scrl = lv_page_get_scrl(list);
    lv_obj_t * e;
    e = lv_list_get_prev_btn(list, NULL);
    while(e != NULL) {
        if(e->coords.y1 < list->coords.y1) {
            lv_coord_t new_y = -lv_obj_get_y(e);
            if(lv_list_get_anim_time(list) == 0) {
                lv_obj_set_y(scrl, new_y);
            } else {
#if LV_USE_ANIMATION
                lv_anim_t a;
                a.var            = scrl;
                a.start          = lv_obj_get_y(scrl);
                a.end            = new_y;
                a.exec_cb        = (lv_anim_exec_xcb_t)lv_obj_set_y;
                a.path_cb        = lv_anim_path_linear;
                a.ready_cb       = NULL;
                a.act_time       = 0;
                a.time           = LV_LIST_DEF_ANIM_TIME;
                a.playback       = 0;
                a.playback_pause = 0;
                a.repeat         = 0;
                a.repeat_pause   = 0;
                lv_anim_create(&a);
#endif
            }
            break;
        }
        e = lv_list_get_prev_btn(list, e);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1cb09
movq %rbx, %rdi
callq 0x26288
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c5a9
testq %rax, %rax
je 0x1cb7f
movzwl 0x22(%rax), %ecx
cmpw 0x22(%rbx), %cx
jl 0x1cb1a
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x1cae9
leaq 0x22624(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1cb18
movq %rax, %rdi
callq 0x4bfe
movl %eax, %ebp
negl %ebp
movq %rbx, %rdi
callq 0x26367
testw %ax, %ax
je 0x1cb88
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x4bfe
cwtl
movl %eax, 0x20(%rbx)
movswl %bp, %eax
movl %eax, 0x24(%rbx)
leaq -0x17653(%rip), %rax    # 0x5501
movq %rax, 0x8(%rbx)
leaq 0xc996(%rip), %rax      # 0x294f5
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq $0x64, 0x28(%rbx)
andb $-0x4, 0x30(%rbx)
movq %rbx, %rdi
callq 0x29521
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movswl %bp, %esi
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5501
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_list.c
// Function: lv_list_focus
void lv_list_focus(const lv_obj_t * btn, lv_anim_enable_t anim)
{
    LV_ASSERT_OBJ(btn, "");

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

    lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));

    lv_page_focus(list, btn, anim == LV_ANIM_OFF ? 0 : lv_list_get_anim_time(list));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1cbcf
movq %rbx, %rdi
callq 0x4abf
movq %rax, %rdi
callq 0x4abf
movq %rax, %r14
testb %bpl, %bpl
je 0x1cbe0
movq %r14, %rdi
callq 0x26367
jmp 0x1cbe2
leaq 0x2255e(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1cbde
xorl %eax, %eax
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x265b1
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_slider.c
// Function: lv_slider_set_style
void lv_slider_set_style(lv_obj_t * slider, lv_slider_style_t type, const lv_style_t * style)
{
    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);

    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);

    switch(type) {
        case LV_SLIDER_STYLE_BG: lv_bar_set_style(slider, LV_BAR_STYLE_BG, style); break;
        case LV_SLIDER_STYLE_INDIC: lv_bar_set_style(slider, LV_BAR_STYLE_INDIC, style); break;
        case LV_SLIDER_STYLE_KNOB:
            ext->style_knob = style;
            lv_obj_refresh_ext_draw_pad(slider);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80d4
testb %al, %al
je 0x1d81b
movq %r14, %rdi
callq 0x6ad8
cmpb $0x2, %bpl
je 0x1d840
movzbl %bpl, %eax
cmpl $0x1, %eax
je 0x1d82c
testl %eax, %eax
jne 0x1d850
movq %r14, %rdi
xorl %esi, %esi
jmp 0x1d834
leaq 0x21912(%rip), %rdi     # 0x3f134
movq %r14, %rsi
callq 0x829e
jmp 0x1d82a
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x9377
movq %rbx, 0x18(%rax)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x64f5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_slider.c
// Function: lv_slider_set_knob_in
void lv_slider_set_knob_in(lv_obj_t * slider, bool in)
{
    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);

    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
    if(ext->knob_in == in) return;

    ext->knob_in = in == false ? 0 : 1;
    lv_obj_invalidate(slider);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1d892
movq %rbx, %rdi
callq 0x6ad8
movb 0x22(%rax), %cl
movl %ecx, %edx
andb $0x1, %dl
cmpb %bpl, %dl
je 0x1d8a3
andb $-0x2, %cl
orb %bpl, %cl
movb %cl, 0x22(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c36
leaq 0x2189b(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1d8a1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_slider.c
// Function: lv_slider_get_value
int16_t lv_slider_get_value(const lv_obj_t * slider)
{
    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);

    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);

    if(ext->drag_value != LV_SLIDER_NOT_PRESSED)
        return ext->drag_value;
    else
        return lv_bar_get_value(slider);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1d8d3
movq %rbx, %rdi
callq 0x6ad8
movzwl 0x20(%rax), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x1d8e4
movq %rbx, %rdi
popq %rbx
jmp 0x9525
leaq 0x2185a(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1d8e2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_slider.c
// Function: lv_slider_get_style
const lv_style_t * lv_slider_get_style(const lv_obj_t * slider, lv_slider_style_t type)
{
    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);

    const lv_style_t * style = NULL;
    lv_slider_ext_t * ext    = lv_obj_get_ext_attr(slider);

    switch(type) {
        case LV_SLIDER_STYLE_BG: style = lv_bar_get_style(slider, LV_BAR_STYLE_BG); break;
        case LV_SLIDER_STYLE_INDIC: style = lv_bar_get_style(slider, LV_BAR_STYLE_INDIC); break;
        case LV_SLIDER_STYLE_KNOB: style = ext->style_knob; break;
        default: style = NULL; break;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80d4
testb %al, %al
je 0x1d977
movq %rbx, %rdi
callq 0x6ad8
cmpb $0x2, %bpl
je 0x1d99b
movzbl %bpl, %eax
cmpl $0x1, %eax
je 0x1d988
testl %eax, %eax
jne 0x1d9a1
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1d990
leaq 0x217b6(%rip), %rdi     # 0x3f134
movq %rbx, %rsi
callq 0x829e
jmp 0x1d986
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x960c
movq 0x18(%rax), %rax
jmp 0x1d9a3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop