LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_chart.c
// Function: lv_chart_set_x_tick_texts
void lv_chart_set_x_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                               lv_chart_axis_options_t options)
{
    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
    LV_ASSERT_NULL(list_of_values);

    lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
    ext->x_axis.num_tick_marks = num_tick_marks;
    ext->x_axis.list_of_values = list_of_values;
    ext->x_axis.options        = options;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x80e4
testb %al, %al
je 0x16fba
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x16fcb
movq %r15, %rdi
callq 0x6af7
movb %r14b, 0x41(%rax)
movq %rbx, 0x38(%rax)
movb %bpl, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28223(%rip), %rdi     # 0x3f1e4
movq %r15, %rsi
callq 0x8294
jmp 0x16fc9
leaq 0x28212(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x16fda
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_chart.c
// Function: lv_chart_set_y_tick_texts
void lv_chart_set_y_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                               lv_chart_axis_options_t options)
{
    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
    LV_ASSERT_NULL(list_of_values);

    lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
    ext->y_axis.num_tick_marks = num_tick_marks;
    ext->y_axis.list_of_values = list_of_values;
    ext->y_axis.options        = options;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x80e4
testb %al, %al
je 0x17022
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x17033
movq %r15, %rdi
callq 0x6af7
movb %r14b, 0x31(%rax)
movq %rbx, 0x28(%rax)
movb %bpl, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x281bb(%rip), %rdi     # 0x3f1e4
movq %r15, %rsi
callq 0x8294
jmp 0x17031
leaq 0x281aa(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17042
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_chart.c
// Function: lv_chart_set_secondary_y_tick_texts
void lv_chart_set_secondary_y_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                                        lv_chart_axis_options_t options)
{
    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
    LV_ASSERT_NULL(list_of_values);

    lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
    ext->secondary_y_axis.num_tick_marks = num_tick_marks;
    ext->secondary_y_axis.list_of_values = list_of_values;
    ext->secondary_y_axis.options        = options;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x80e4
testb %al, %al
je 0x1708a
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x1709b
movq %r15, %rdi
callq 0x6af7
movb %r14b, 0x51(%rax)
movq %rbx, 0x48(%rax)
movb %bpl, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28153(%rip), %rdi     # 0x3f1e4
movq %r15, %rsi
callq 0x8294
jmp 0x17099
leaq 0x28142(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x170aa
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_chart.c
// Function: lv_chart_set_margin
void lv_chart_set_margin(lv_obj_t * chart, uint16_t margin)
{
    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);

    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
    ext->margin          = margin;
    lv_obj_refresh_ext_draw_pad(chart);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x170d7
movq %rbx, %rdi
callq 0x6af7
movw %bp, 0x58(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6514
leaq 0x28106(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x170e6
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_chart.c
// Function: lv_chart_get_next_label
static void lv_chart_get_next_label(lv_chart_label_iterator_t * iterator, char * buf)
{
    uint8_t label_len = 0;
    if (iterator->is_reverse_iter) {
        const char * label_start;
        /* count the length of the current label*/
        while ((*iterator->current_pos != '\n') &&
                (iterator->current_pos != iterator->list_start)) {
            iterator->current_pos--;
            label_len++;
        }

        label_start = iterator->current_pos;

        if (*iterator->current_pos == '\n') {
            /* do not copy \n symbol, +1 to skip it*/
            label_start++;
            /* skip newline*/
            iterator->current_pos--;
        } else {
            /* it is last label in list (first one from the beginning )*/
            label_len++;
        }

        /* do not allow output buffer overflow */
        if (label_len > LV_CHART_AXIS_TICK_LABEL_MAX_LEN) {
            label_len = LV_CHART_AXIS_TICK_LABEL_MAX_LEN;
        }

        strncpy(buf, label_start, label_len);
    } else {
        /* search for tick string */
        while(iterator->current_pos[label_len] != '\n' &&
            iterator->current_pos[label_len] != '\0') {
            /* do not overflow the buffer, but move to the end of the current label */
            if(label_len < LV_CHART_AXIS_TICK_LABEL_MAX_LEN) {
                buf[label_len] = iterator->current_pos[label_len];
                label_len++;
            } else {
                label_len++;
            }
        }

        iterator->current_pos += label_len;

        /* do not allow output buffer overflow */
        if (label_len > LV_CHART_AXIS_TICK_LABEL_MAX_LEN) {
            label_len = LV_CHART_AXIS_TICK_LABEL_MAX_LEN;
        }

        if(*iterator->current_pos == '\n') iterator->current_pos++;
    }

    /* terminate the string */
    buf[label_len] = '\0';
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x1776f
movq 0x8(%rdi), %rcx
cmpb $0xa, (%rcx)
jne 0x177b1
xorl %eax, %eax
jmp 0x177df
xorl %eax, %eax
movq 0x8(%rdi), %rcx
movzbl %al, %eax
movzbl (%rcx,%rax), %edx
testl %edx, %edx
je 0x17790
cmpl $0xa, %edx
je 0x17790
cmpb $0x13, %al
ja 0x1778c
movb %dl, (%rbx,%rax)
incb %al
jmp 0x17771
leaq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rdi)
cmpb $0x14, %al
movl $0x14, %ebp
cmovbl %eax, %ebp
cmpb $0xa, (%rcx,%rax)
jne 0x17809
incq %rdx
movq %rdx, 0x8(%rdi)
jmp 0x17809
movq (%rdi), %r8
movl %ecx, %edx
subb %r8b, %dl
decq %rcx
xorl %eax, %eax
leaq 0x1(%rcx), %rsi
cmpq %r8, %rsi
je 0x177ec
movq %rcx, 0x8(%rdi)
incb %al
leaq -0x1(%rcx), %rsi
cmpb $0xa, (%rcx)
movq %rsi, %rcx
jne 0x177be
incq %rsi
movq %rsi, %rcx
leaq 0x1(%rcx), %rsi
decq %rcx
movq %rcx, 0x8(%rdi)
jmp 0x177f0
incb %dl
movl %edx, %eax
movzbl %al, %eax
cmpb $0x14, %al
movl $0x14, %ebp
cmovbl %eax, %ebp
movzbl %bpl, %edx
movq %rbx, %rdi
callq 0x2030
movzbl %bpl, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_create
lv_obj_t * lv_canvas_create(lv_obj_t * par, const lv_obj_t * copy)
{
    LV_LOG_TRACE("canvas create started");

    /*Create the ancestor of canvas*/
    lv_obj_t * new_canvas = lv_img_create(par, copy);
    LV_ASSERT_MEM(new_canvas);
    if(new_canvas == NULL) return NULL;

    /*Allocate the canvas type specific extended data*/
    lv_canvas_ext_t * ext = lv_obj_allocate_ext_attr(new_canvas, sizeof(lv_canvas_ext_t));
    LV_ASSERT_MEM(ext);
    if(ext == NULL) return NULL;
    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(new_canvas);
    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(new_canvas);

    /*Initialize the allocated 'ext' */
    ext->dsc.header.always_zero = 0;
    ext->dsc.header.cf          = LV_IMG_CF_TRUE_COLOR;
    ext->dsc.header.h           = 0;
    ext->dsc.header.w           = 0;
    ext->dsc.data_size          = 0;
    ext->dsc.data               = NULL;

    lv_img_set_src(new_canvas, &ext->dsc);

    /*The signal and design functions are not copied so set them here*/
    lv_obj_set_signal_cb(new_canvas, lv_canvas_signal);

    /*Init the new canvas canvas*/
    if(copy == NULL) {

    }
    /*Copy an existing canvas*/
    else {
        /*Refresh the style with new signal function*/
        lv_obj_refresh_style(new_canvas);
    }

    LV_LOG_INFO("canvas created");

    return new_canvas;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x23c3c
movq %rax, %rbx
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x178e9
testq %rbx, %rbx
je 0x178fa
movq %rbx, %rdi
movl $0x28, %esi
callq 0x64db
movq %rax, %r15
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x17905
testq %r15, %r15
je 0x178fa
cmpq $0x0, 0x48b1e(%rip)     # 0x60390
jne 0x17883
movq %rbx, %rdi
callq 0x6a8b
movq %rax, 0x48b0d(%rip)     # 0x60390
cmpq $0x0, 0x48b0d(%rip)     # 0x60398
jne 0x1789c
movq %rbx, %rdi
callq 0x6aaf
movq %rax, 0x48afc(%rip)     # 0x60398
movq %r15, %rsi
addq $0x18, %rsi
movl $0x300, %eax            # imm = 0x300
andl 0x18(%r15), %eax
orl $0x4, %eax
movl %eax, 0x18(%r15)
movl $0x0, 0x1c(%r15)
movq $0x0, 0x20(%r15)
movq %rbx, %rdi
callq 0x24066
leaq 0x44(%rip), %rsi        # 0x17916
movq %rbx, %rdi
callq 0x647b
testq %r14, %r14
je 0x178fc
movq %rbx, %rdi
callq 0x5e54
jmp 0x178fc
leaq 0x277e0(%rip), %rdi     # 0x3f0d0
movq %rbx, %rsi
callq 0x8294
jmp 0x178f8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x277c4(%rip), %rdi     # 0x3f0d0
movq %r15, %rsi
callq 0x8294
jmp 0x17914
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_set_buffer
void lv_canvas_set_buffer(lv_obj_t * canvas, void * buf, lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
    LV_ASSERT_NULL(buf);

    lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);

    ext->dsc.header.cf = cf;
    ext->dsc.header.w  = w;
    ext->dsc.header.h  = h;
    ext->dsc.data      = buf;
    ext->dsc.data_size = (lv_img_color_format_get_px_size(cf) * w * h) / 8;

    lv_img_set_src(canvas, &ext->dsc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x17a14
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x17a25
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r12
addq $0x18, %rax
movq %rax, (%rsp)
movl %ebp, %eax
andb $0x1f, %al
movzbl %al, %eax
movl $0x3e0, %ecx            # imm = 0x3E0
andl 0x18(%r12), %ecx
movswl %r15w, %r15d
movl %r15d, %edx
shll $0xa, %edx
movswl %r13w, %r13d
movl %r13d, %esi
shll $0x15, %esi
andl $0x1ffc00, %edx         # imm = 0x1FFC00
orl %esi, %edx
orl %eax, %edx
orl %ecx, %edx
movl %edx, 0x18(%r12)
movq %r14, 0x20(%r12)
movzbl %bpl, %edi
callq 0x3c3ca
movzbl %al, %eax
imull %r15d, %r13d
imull %eax, %r13d
leal 0x7(%r13), %eax
testl %r13d, %r13d
cmovnsl %r13d, %eax
sarl $0x3, %eax
movl %eax, 0x1c(%r12)
movq %rbx, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24066
leaq 0x277c9(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17a23
leaq 0x277b8(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x17a34
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_set_px
void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);

    lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);

    lv_img_buf_set_px_color(&ext->dsc, x, y, c);
    lv_obj_invalidate(canvas);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x17a7e
movq %rbx, %rdi
callq 0x6af7
leaq 0x18(%rax), %rdi
movswl %r15w, %esi
movswl %r14w, %edx
movl %ebp, %ecx
callq 0x3c502
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
leaq 0x2775f(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17a8d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_set_palette
void lv_canvas_set_palette(lv_obj_t * canvas, uint8_t id, lv_color_t c)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);

    lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);

    lv_img_buf_set_palette(&ext->dsc, id, c);
    lv_obj_invalidate(canvas);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x17ac7
movq %rbx, %rdi
callq 0x6af7
leaq 0x18(%rax), %rdi
movzbl %r14b, %esi
movl %ebp, %edx
callq 0x3c7d5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c4d
leaq 0x27716(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17ad6
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_get_px
lv_color_t lv_canvas_get_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);

    lv_canvas_ext_t * ext    = lv_obj_get_ext_attr(canvas);
    const lv_style_t * style = lv_canvas_get_style(canvas, LV_CANVAS_STYLE_MAIN);

    return lv_img_buf_get_px_color(&ext->dsc, x, y, style);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x17b62
movq %r14, %rdi
callq 0x6af7
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x17b73
addq $0x18, %r15
movswl %bp, %esi
movswl %bx, %edx
movq %r15, %rdi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3c293
leaq 0x2767b(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x17b71
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_get_style
const lv_style_t * lv_canvas_get_style(const lv_obj_t * canvas, lv_canvas_style_t type)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);

    const lv_style_t * style = NULL;

    switch(type) {
        case LV_CANVAS_STYLE_MAIN: style = lv_img_get_style(canvas, LV_IMG_STYLE_MAIN); break;
        default: style = NULL;
    }

    return style;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x17b92
testb %bpl, %bpl
je 0x17ba3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2764b(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17ba1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66b6
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_copy_buf
void lv_canvas_copy_buf(lv_obj_t * canvas, const void * to_copy, lv_coord_t x, lv_coord_t y, lv_coord_t w, lv_coord_t h)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
    LV_ASSERT_NULL(to_copy);

    lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
    if(x + w >= (lv_coord_t)ext->dsc.header.w || y + h >= (lv_coord_t)ext->dsc.header.h) {
        LV_LOG_WARN("lv_canvas_copy_buf: x or y out of the canvas");
        return;
    }

    uint32_t px_size   = lv_img_color_format_get_px_size(ext->dsc.header.cf) >> 3;
    uint32_t px        = ext->dsc.header.w * y * px_size + x * px_size;
    uint8_t * to_copy8 = (uint8_t *)to_copy;
    lv_coord_t i;
    for(i = 0; i < h; i++) {
        memcpy((void *)&ext->dsc.data[px], to_copy8, w * px_size);
        px += ext->dsc.header.w * px_size;
        to_copy8 += w * px_size;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x17cc8
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x17cd9
movq %r14, %rdi
callq 0x6af7
movq %rax, %r14
movswl %r13w, %r13d
movswl %r15w, %r15d
leal (%r15,%r13), %eax
movl 0x18(%r14), %edi
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
cmpl %ecx, %eax
jge 0x17cb9
movswl %r12w, %r12d
movswl %bp, %eax
addl %r12d, %eax
movl %edi, %ecx
shrl $0x15, %ecx
cmpl %ecx, %eax
jge 0x17cb9
andl $0x1f, %edi
callq 0x3c3ca
testw %bp, %bp
jle 0x17cb9
shrb $0x3, %al
movl %r12d, %ecx
movzbl %al, %r12d
movq %r13, %rax
movl 0x18(%r14), %r13d
shrl $0xa, %r13d
andl $0x7ff, %r13d           # imm = 0x7FF
imull %ecx, %r13d
addl %eax, %r13d
imull %r12d, %r13d
imull %r12d, %r15d
movl %r13d, %edi
addq 0x20(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20f0
movl 0x18(%r14), %eax
shrl $0xa, %eax
andl $0x7ff, %eax            # imm = 0x7FF
imull %r12d, %eax
addl %eax, %r13d
addq %r15, %rbx
decw %bp
jne 0x17c8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27515(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x17cd7
leaq 0x27504(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x17ce8
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_fill_bg
void lv_canvas_fill_bg(lv_obj_t * canvas, lv_color_t color)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);

    lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);

    uint32_t x = dsc->header.w * dsc->header.h;
    uint32_t y;
    for(y = 0; y < dsc->header.h; y++) {
        for(x = 0; x < dsc->header.w; x++) {
            lv_img_buf_set_px_color(dsc, x, y, color);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x185d7
movq %r14, %rdi
callq 0x17bb1
movq %rax, %r14
movl (%rax), %eax
cmpl $0x200000, %eax         # imm = 0x200000
jb 0x185ce
xorl %r15d, %r15d
testl $0x1ffc00, %eax         # imm = 0x1FFC00
je 0x185c1
xorl %r12d, %r12d
movswl %r15w, %ebp
movswl %r12w, %esi
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x3c502
incl %r12d
movl (%r14), %eax
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
cmpl %ecx, %r12d
jb 0x1859b
incl %r15d
movl %eax, %ecx
shrl $0x15, %ecx
cmpl %ecx, %r15d
jb 0x1858d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26c06(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x185e6
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_gauge.c
// Function: lv_gauge_signal
static lv_res_t lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param)
{
    lv_res_t res;

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

    lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
    if(sign == LV_SIGNAL_CLEANUP) {
        lv_mem_free(ext->values);
        ext->values = NULL;
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq *0x471ad(%rip)          # 0x603a0
movl %eax, %ebp
cmpb $0x1, %al
jne 0x1923a
cmpb $0x7, %bl
jne 0x19217
leaq 0x2663e(%rip), %rsi     # 0x3f843
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c02
movq %r15, %rdi
callq 0x6af7
movb $0x1, %bpl
testb %bl, %bl
jne 0x1923a
movq %rax, %r14
movq 0x10(%rax), %rdi
callq 0x2a006
movq $0x0, 0x10(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_gauge.c
// Function: lv_gauge_set_scale
void lv_gauge_set_scale(lv_obj_t * gauge, uint16_t angle, uint8_t line_cnt, uint8_t label_cnt)
{
    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);

    lv_lmeter_set_scale(gauge, angle, line_cnt);

    lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
    ext->label_count     = label_cnt;
    lv_obj_invalidate(gauge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x19a12
movzwl %r15w, %esi
movzbl %r14b, %edx
movq %rbx, %rdi
callq 0x25232
movq %rbx, %rdi
callq 0x6af7
movb %bpl, 0x21(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d
leaq 0x257cb(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x19a21
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_gauge.c
// Function: lv_gauge_set_value
void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle_id, int16_t value)
{
    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);

    lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);

    if(needle_id >= ext->needle_count) return;
    if(ext->values[needle_id] == value) return;

    int16_t min = lv_gauge_get_min_value(gauge);
    int16_t max = lv_gauge_get_max_value(gauge);

    if(value > max)
        value = max;
    else if(value < min)
        value = min;

    ext->values[needle_id] = value;

    lv_obj_invalidate(gauge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x19de4
movq %rbx, %rdi
callq 0x6af7
cmpb %r15b, 0x20(%rax)
jbe 0x19ddb
movq %rax, %r14
movq 0x10(%rax), %rax
movzbl %r15b, %r12d
cmpw %bp, (%rax,%r12,2)
jne 0x19df5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x253f9(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x19df3
movq %rbx, %rdi
callq 0x252dd
movl %eax, %r15d
movq %rbx, %rdi
callq 0x25309
cmpw %bp, %r15w
cmovlel %ebp, %r15d
cmpw %bp, %ax
cmovgel %r15d, %eax
movq 0x10(%r14), %rcx
movw %ax, (%rcx,%r12,2)
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_gauge.c
// Function: lv_gauge_get_value
int16_t lv_gauge_get_value(const lv_obj_t * gauge, uint8_t needle)
{
    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);

    lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
    int16_t min          = lv_gauge_get_min_value(gauge);

    if(needle >= ext->needle_count) return min;

    return ext->values[needle];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x80e4
testb %al, %al
je 0x19e6d
movq %r14, %rdi
callq 0x6af7
movq %rax, %r15
movq %r14, %rdi
callq 0x252dd
cmpb %bl, 0x20(%r15)
jbe 0x19e67
movq 0x10(%r15), %rax
movzbl %bl, %ecx
movzwl (%rax,%rcx,2), %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x25370(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x19e7c
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_label.c
// Function: lv_label_set_long_mode
void lv_label_set_long_mode(lv_obj_t * label, lv_label_long_mode_t long_mode)
{
    LV_ASSERT_OBJ(label, LV_OBJX_NAME);

    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);

#if LV_USE_ANIMATION
    /*Delete the old animation (if exists)*/
    lv_anim_del(label, (lv_anim_exec_xcb_t)lv_obj_set_x);
    lv_anim_del(label, (lv_anim_exec_xcb_t)lv_obj_set_y);
    lv_anim_del(label, (lv_anim_exec_xcb_t)lv_label_set_offset_x);
    lv_anim_del(label, (lv_anim_exec_xcb_t)lv_label_set_offset_y);
#endif
    ext->offset.x = 0;
    ext->offset.y = 0;

    if(long_mode == LV_LABEL_LONG_SROLL || long_mode == LV_LABEL_LONG_SROLL_CIRC || long_mode == LV_LABEL_LONG_CROP)
        ext->expand = 1;
    else
        ext->expand = 0;

    /*Restore the character under the dots*/
    if(ext->long_mode == LV_LABEL_LONG_DOT && ext->dot_end != LV_LABEL_DOT_END_INV) {
        lv_label_revert_dots(label);
    }

    ext->long_mode = long_mode;
    lv_label_refr_text(label);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x1a6c9
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r15
leaq -0x15151(%rip), %rsi    # 0x54db
movq %rbx, %rdi
callq 0x29c44
leaq -0x15122(%rip), %rsi    # 0x5519
movq %rbx, %rdi
callq 0x29c44
leaq 0xc91(%rip), %rsi       # 0x1b2db
movq %rbx, %rdi
callq 0x29c44
leaq 0xca3(%rip), %rsi       # 0x1b2fc
movq %rbx, %rdi
callq 0x29c44
movl $0x0, 0x12(%r15)
leal -0x3(%r14), %ecx
xorl %eax, %eax
cmpb $0x3, %cl
setb %al
movzwl 0x18(%r15), %ecx
movl %ecx, %edx
andl $0xff7f, %edx           # imm = 0xFF7F
shll $0x7, %eax
orl %edx, %eax
movw %ax, 0x18(%r15)
andl $0x7, %ecx
cmpw $0x2, %cx
jne 0x1a6aa
cmpw $-0x1, 0x10(%r15)
je 0x1a6aa
movq %rbx, %rdi
callq 0x1b31d
movzwl 0x18(%r15), %eax
andb $0x7, %r14b
movzbl %r14b, %ecx
andl $-0x8, %eax
orl %ecx, %eax
movw %ax, 0x18(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1ab2c
leaq 0x24b14(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1a6d8
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1a788
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x6af7
testq %r14, %r14
je 0x1a7d5
movq %rax, %r15
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x1a799
movq (%r15), %r12
cmpq %r14, %r12
je 0x1a7aa
movq %r14, %rdi
callq 0x2070
movq %rax, %r13
incq %r13
testq %r12, %r12
je 0x1a753
testb $0x8, 0x18(%r15)
jne 0x1a753
movq %r12, %rdi
callq 0x2a006
movq $0x0, (%r15)
movq %r13, %rdi
callq 0x29f85
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80e4
movq (%r15), %rsi
testb %al, %al
je 0x1a7e6
testq %rsi, %rsi
je 0x1a802
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2040
andb $-0x9, 0x18(%r15)
jmp 0x1a7d5
leaq 0x24a55(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1a797
leaq 0x24a44(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1a7a8
movq %r12, %rdi
callq 0x2070
leaq 0x1(%rax), %rsi
movq %r12, %rdi
callq 0x2a06f
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80e4
movq (%r15), %rsi
testb %al, %al
je 0x1a7f4
testq %rsi, %rsi
je 0x1a802
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ab2c
leaq 0x248e3(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0x1a7f2
leaq 0x248d5(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0x1a800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1a868
movq %rbx, %rdi
callq 0x6af7
movzwl 0x18(%rax), %ecx
testb $0x40, %cl
sete %dl
xorb %bpl, %dl
je 0x1a879
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x24975(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1a877
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 0x1ab2c
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1a8f6
movq %rbx, %rdi
callq 0x6af7
movl 0x18(%rax), %ecx
btl $0x8, %ecx
setae %dl
xorb %bpl, %dl
je 0x1a907
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x248e7(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1a905
movzbl %bpl, %edx
shll $0x8, %edx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl %edx, %ecx
movw %cx, 0x18(%rax)
movq %rbx, %rdi
callq 0x6514
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_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 0x80e4
testb %al, %al
je 0x1a992
movq %rbx, %rdi
callq 0x6af7
movzwl 0x18(%rax), %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0x3, %edx
movzbl %bpl, %esi
cmpw %si, %dx
jne 0x1a9a3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2484b(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1a9a1
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 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1aa8a
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x1aa9b
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r15
testb $0x8, 0x18(%rax)
jne 0x1aa70
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1aa70
callq 0x2a006
movq $0x0, (%r15)
testq %r14, %r14
je 0x1aa7d
orb $0x8, 0x18(%r15)
movq %r14, (%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1ab2c
leaq 0x24753(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1aa99
leaq 0x24742(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1aaaa
// File: /workspace/github_c_makefile_star2_O3/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 0x6af7
movq %rax, %r14
movq %r15, %rdi
callq 0x1bf7d
movl %ebp, %r15d
cmpw $0x9, %bp
jb 0x1ab04
leaq 0x1(%r15), %rdi
callq 0x29f85
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x1ab28
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20f0
movq 0x8(%r14), %rax
movb $0x0, (%rax,%r15)
orb $0x2, 0x19(%r14)
jmp 0x1ab1b
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 0x1ab1d
// File: /workspace/github_c_makefile_star2_O3/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 0x1b0c7
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 0x80e4
testb %al, %al
je 0x1b1c0
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x1b1d1
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x6af7
testq %r14, %r14
je 0x1b1e2
movq %rax, %r15
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1b11b
testb $0x8, 0x18(%r15)
jne 0x1b11b
callq 0x2a006
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 0x2c220
movl %eax, %r13d
leal 0x1(%r13), %r12d
movq %r12, %rdi
callq 0x29f85
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80e4
movq (%r15), %rsi
testb %al, %al
je 0x1b1fa
testq %rsi, %rsi
je 0x1b1af
decl %r13d
movb $0x0, (%rsi,%r13)
movq (%r15), %rdi
movq %rsp, %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x2c220
andb $-0x9, 0x18(%r15)
movq %rbx, %rdi
callq 0x1ab2c
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2401d(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1b1cf
leaq 0x2400c(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1b1e0
movq %rbx, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ab2c
leaq 0x23ecf(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0x1b206
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1b2b3
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x6af7
movq %rax, %r15
movq (%rax), %rdi
cmpq %r14, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1b2a3
testq %rdi, %rdi
je 0x1b263
testb $0x8, 0x18(%r15)
jne 0x1b263
callq 0x2a006
movq $0x0, (%r15)
movzwl %bp, %r12d
leaq 0x1(%r12), %rdi
callq 0x29f85
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80e4
movq (%r15), %rsi
testb %al, %al
je 0x1b2c4
testq %rsi, %rsi
je 0x1b2d2
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 0x1ab2c
leaq 0x23f2a(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1b2c2
leaq 0x23e05(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0x1b2d0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6af7
movq %rax, %r14
movzwl 0x18(%rax), %eax
andl $0x7, %eax
cmpw $0x2, %ax
jne 0x1b3b9
movzwl 0x10(%r14), %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x1b3b9
addl $-0x3, %esi
leaq 0x382ef(%rip), %rax     # 0x53640
movq (%r14), %rdi
callq *(%rax)
movl %eax, %r15d
movq %rbx, %rdi
callq 0x6af7
leaq 0x8(%rax), %rcx
testb $0x2, 0x19(%rax)
je 0x1b36e
movq (%rcx), %rcx
movq (%r14), %rdx
movl %r15d, %esi
leaq (%rdx,%rsi), %rax
cmpb $0x0, (%rdx,%rsi)
je 0x1b3a3
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 0x1b380
jmp 0x1b3a5
xorl %esi, %esi
movb (%rcx,%rsi), %cl
movb %cl, (%rax)
movq %rbx, %rdi
callq 0x1bf7d
movw $0xffff, 0x10(%r14)     # imm = 0xFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1b400
movq %rbx, %rdi
callq 0x6af7
cmpw %bp, 0x16(%rax)
je 0x1b411
movw %bp, 0x16(%rax)
movzwl 0x18(%rax), %eax
andl $0x7, %eax
addl $-0x3, %eax
cmpw $0x1, %ax
ja 0x1b411
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1ab2c
leaq 0x23ddd(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1b40f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1b473
movq %rbx, %rdi
callq 0x6af7
movzwl 0x16(%rax), %eax
popq %rbx
retq
leaq 0x23d6a(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1b482
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1bedc
movq %r14, %rdi
callq 0x80e4
testb %al, %al
je 0x1beed
movq %rbx, %rdi
callq 0x6af7
testb $0x8, 0x18(%rax)
jne 0x1befe
movq %rax, %r15
movq %rbx, %rdi
callq 0x4c4d
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 0x2a06f
movq %rax, (%r15)
movq %rax, %rdi
callq 0x80e4
movq (%r15), %rsi
testb %al, %al
je 0x1bf0d
testq %rsi, %rsi
je 0x1befe
cmpl $0xffff, %ebp           # imm = 0xFFFF
jne 0x1beb9
leaq 0x377a1(%rip), %rax     # 0x53650
movq %rsi, %rdi
callq *(%rax)
movl %eax, %ebp
movq (%r15), %rsi
movq %rsi, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2b402
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ab2c
leaq 0x23301(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1beeb
leaq 0x232f0(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1befc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x231bc(%rip), %rdi     # 0x3f0d0
callq 0x8294
jmp 0x1bf19
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1bf67
movq %rbx, %rdi
callq 0x6af7
testb $0x8, 0x18(%rax)
jne 0x1bf78
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x1aa00
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x2b473
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ab2c
leaq 0x23276(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1bf76
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6af7
movq %rax, %rbx
movl 0x18(%rax), %eax
btl $0x9, %eax
jae 0x1bfa1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1bfa1
callq 0x2a006
movzwl 0x18(%rbx), %eax
andl $0xfdff, %eax           # imm = 0xFDFF
movw %ax, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1c6ca
movq %r14, %rdi
callq 0x2695e
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x654e
testq %rax, %rax
je 0x1c6bd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1cfd1
testb %al, %al
jne 0x1c6bf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x654e
movq %rax, %rbx
testq %rax, %rax
jne 0x1c69e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22b13(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1c6d9
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1c766
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51a7
testq %rax, %rax
je 0x1c755
movq %rsp, %r15
leaq 0x23218(%rip), %r12     # 0x3f928
movq %rax, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b1b
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rdi
testq %rdi, %rdi
je 0x1c73f
movq %r12, %rsi
callq 0x20e0
testl %eax, %eax
je 0x1c755
incq %r13
cmpq $0x8, %r13
jne 0x1c721
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51a7
movq %rax, %r14
testq %rax, %rax
jne 0x1c713
xorl %r14d, %r14d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x22a77(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1c775
// File: /workspace/github_c_makefile_star2_O3/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 0x80e4
testb %al, %al
je 0x1c9c4
movq %rbx, %rdi
callq 0x1cf35
testq %rax, %rax
je 0x1c9d5
movq %rax, %rdi
popq %rbx
jmp 0x1aa00
leaq 0x22819(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x1c9d3
leaq 0x26be1(%rip), %rax     # 0x435bd
popq %rbx
retq