LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_rect.c
// Function: lv_draw_rect
void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale)
{
    if(lv_area_get_height(coords) < 1 || lv_area_get_width(coords) < 1) return;

#if LV_USE_SHADOW
    if(style->body.shadow.width != 0) {
        lv_draw_shadow(coords, mask, style, opa_scale);
    }
#endif

    /* If the object is out of the mask there is nothing to draw.
     * Draw shadow before it because the shadow is out of `coords`*/
    if(lv_area_is_on(coords, mask) == false) return;

    if(style->body.opa > LV_OPA_MIN) {
        lv_draw_rect_main_mid(coords, mask, style, opa_scale);

        if(style->body.radius != 0) {
            lv_draw_rect_main_corner(coords, mask, style, opa_scale);
        }
    }

    if(style->body.border.width != 0 && style->body.border.part != LV_BORDER_NONE &&
       style->body.border.opa >= LV_OPA_MIN) {
        lv_draw_rect_border_straight(coords, mask, style, opa_scale);

        if(style->body.radius != 0) {
            lv_draw_rect_border_corner(coords, mask, style, opa_scale);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ab10
cwtl
cmpl $0x1, %eax
jl 0x5aa17
movq -0x8(%rbp), %rdi
callq 0x5ab30
cwtl
cmpl $0x1, %eax
jge 0x5aa1c
jmp 0x5ab00
movq -0x18(%rbp), %rax
movswl 0x12(%rax), %eax
cmpl $0x0, %eax
je 0x5aa3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5ab50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42a70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5aa5a
jmp 0x5ab00
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x10, %eax
jle 0x5aaa0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5ac80
movq -0x18(%rbp), %rax
movswl 0x6(%rax), %eax
cmpl $0x0, %eax
je 0x5aa9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5af20
jmp 0x5aaa0
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %eax
cmpl $0x0, %eax
je 0x5ab00
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
cmpl $0x0, %eax
je 0x5ab00
movq -0x18(%rbp), %rax
movzbl 0xf(%rax), %eax
cmpl $0x10, %eax
jl 0x5ab00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5c210
movq -0x18(%rbp), %rax
movswl 0x6(%rax), %eax
cmpl $0x0, %eax
je 0x5aafe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5cae0
jmp 0x5ab00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_rect.c
// Function: lv_draw_shadow
static void lv_draw_shadow(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style,
                           lv_opa_t opa_scale)
{
    /* If mask is in the middle of cords do not draw shadow*/
    lv_coord_t radius = style->body.radius;
    lv_coord_t width  = lv_area_get_width(coords);
    lv_coord_t height = lv_area_get_height(coords);
    radius            = lv_draw_cont_radius_corr(radius, width, height);
    lv_area_t area_tmp;

    /*Check horizontally without radius*/
    lv_area_copy(&area_tmp, coords);
    area_tmp.x1 += radius;
    area_tmp.x2 -= radius;
    if(lv_area_is_in(mask, &area_tmp) != false) return;

    /*Check vertically without radius*/
    lv_area_copy(&area_tmp, coords);
    area_tmp.y1 += radius;
    area_tmp.y2 -= radius;
    if(lv_area_is_in(mask, &area_tmp) != false) return;

    if(style->body.shadow.type == LV_SHADOW_FULL) {
        lv_draw_shadow_full(coords, mask, style, opa_scale);
    } else if(style->body.shadow.type == LV_SHADOW_BOTTOM) {
        lv_draw_shadow_bottom(coords, mask, style, opa_scale);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movw 0x6(%rax), %ax
movw %ax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ab30
movw %ax, -0x1e(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ab10
movw %ax, -0x20(%rbp)
movw -0x1c(%rbp), %cx
movw -0x1e(%rbp), %ax
movzwl %cx, %edi
movswl %ax, %esi
movswl -0x20(%rbp), %edx
callq 0x5e0e0
movw %ax, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5e390
movswl -0x1c(%rbp), %ecx
movswl -0x28(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x28(%rbp)
movswl -0x1c(%rbp), %ecx
movswl -0x24(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42ae0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x5abef
jmp 0x5ac79
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5e390
movswl -0x1c(%rbp), %ecx
movswl -0x26(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x26(%rbp)
movswl -0x1c(%rbp), %ecx
movswl -0x22(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42ae0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x5ac31
jmp 0x5ac79
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x1, %eax
jne 0x5ac55
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5e3b0
jmp 0x5ac79
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x0, %eax
jne 0x5ac77
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x5eac0
jmp 0x5ac79
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_rect.c
// Function: lv_draw_cont_radius_corr
static uint16_t lv_draw_cont_radius_corr(uint16_t r, lv_coord_t w, lv_coord_t h)
{
    bool aa = lv_disp_get_antialiasing(lv_refr_get_disp_refreshing());

    if(r >= (w >> 1)) {
        r = (w >> 1);
        if(r != 0) r--;
    }
    if(r >= (h >> 1)) {
        r = (h >> 1);
        if(r != 0) r--;
    }

    if(r > 0) r -= aa;

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movw %di, %dx
movw %dx, -0x2(%rbp)
movw %cx, -0x4(%rbp)
movw %ax, -0x6(%rbp)
callq 0xafe0
movq %rax, %rdi
callq 0xdb00
andb $0x1, %al
movb %al, -0x7(%rbp)
movzwl -0x2(%rbp), %eax
movswl -0x4(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jl 0x5e13e
movswl -0x4(%rbp), %eax
sarl %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x5e13c
movw -0x2(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0x5e13e
movzwl -0x2(%rbp), %eax
movswl -0x6(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jl 0x5e16d
movswl -0x6(%rbp), %eax
sarl %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x5e16b
movw -0x2(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0x5e16d
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
jle 0x5e188
movb -0x7(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movzwl -0x2(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_rect.c
// Function: antialias_get_opa_circ
static lv_opa_t antialias_get_opa_circ(lv_coord_t seg, lv_coord_t px_id, lv_opa_t opa)
{
    /*Empirical non-linear values anti-aliasing values*/
    static const lv_opa_t opa_map2[2] = {210, 80};
    static const lv_opa_t opa_map3[3] = {230, 150, 60};
    static const lv_opa_t opa_map4[4] = {235, 185, 125, 50};
    static const lv_opa_t opa_map8[8] = {250, 242, 219, 191, 158, 117, 76, 40};

#if CIRCLE_AA_NON_LINEAR_OPA_THRESHOLD < 1
    if(seg == 1) return 170;
#endif

#if CIRCLE_AA_NON_LINEAR_OPA_THRESHOLD < 2
    if(seg == 2) return (opa_map2[px_id] * opa) >> 8;
#endif

#if CIRCLE_AA_NON_LINEAR_OPA_THRESHOLD < 3
    if(seg == 3) return (opa_map3[px_id] * opa) >> 8;
#endif

#if CIRCLE_AA_NON_LINEAR_OPA_THRESHOLD < 4
    if(seg == 4) return (opa_map4[px_id] * opa) >> 8;
#endif

    uint8_t id = (uint32_t)((uint32_t)px_id * (sizeof(opa_map8) - 1)) / (seg - 1);
    return (uint32_t)((uint32_t)opa_map8[id] * opa) >> 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movb %al, -0x7(%rbp)
movswl -0x4(%rbp), %eax
cmpl $0x2, %eax
jne 0x5e302
movswq -0x6(%rbp), %rcx
leaq 0xdd08(%rip), %rax      # 0x6bff4
movzbl (%rax,%rcx), %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
sarl $0x8, %eax
movb %al, -0x1(%rbp)
jmp 0x5e388
movswl -0x4(%rbp), %eax
cmpl $0x3, %eax
jne 0x5e32a
movswq -0x6(%rbp), %rcx
leaq 0xdcdf(%rip), %rax      # 0x6bff6
movzbl (%rax,%rcx), %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
sarl $0x8, %eax
movb %al, -0x1(%rbp)
jmp 0x5e388
movswl -0x4(%rbp), %eax
cmpl $0x4, %eax
jne 0x5e352
movswq -0x6(%rbp), %rcx
leaq 0xdcba(%rip), %rax      # 0x6bff9
movzbl (%rax,%rcx), %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
sarl $0x8, %eax
movb %al, -0x1(%rbp)
jmp 0x5e388
movswl -0x6(%rbp), %eax
movl %eax, %eax
imulq $0x7, %rax, %rax
movswl -0x4(%rbp), %ecx
subl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movb %al, -0x8(%rbp)
movzbl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xdc86(%rip), %rax      # 0x6bffd
movzbl (%rax,%rcx), %eax
movzbl -0x7(%rbp), %ecx
imull %ecx, %eax
shrl $0x8, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_label.c
// Function: hex_char_to_num
static uint8_t hex_char_to_num(char hex)
{
    uint8_t result = 0;

    if(hex >= '0' && hex <= '9') {
        result = hex - '0';
    } else {
        if(hex >= 'a') hex -= 'a' - 'A'; /*Convert to upper case*/

        switch(hex) {
        case 'A': result = 10; break;
        case 'B': result = 11; break;
        case 'C': result = 12; break;
        case 'D': result = 13; break;
        case 'E': result = 14; break;
        case 'F': result = 15; break;
        default: result = 0; break;
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x30, %eax
jl 0x5fbdc
movsbl -0x1(%rbp), %eax
cmpl $0x39, %eax
jg 0x5fbdc
movsbl -0x1(%rbp), %eax
subl $0x30, %eax
movb %al, -0x2(%rbp)
jmp 0x5fc3f
movsbl -0x1(%rbp), %eax
cmpl $0x61, %eax
jl 0x5fbef
movsbl -0x1(%rbp), %eax
subl $0x20, %eax
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x5fc39
movq -0x10(%rbp), %rax
leaq 0xc3fc(%rip), %rcx      # 0x6c008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0xa, -0x2(%rbp)
jmp 0x5fc3d
movb $0xb, -0x2(%rbp)
jmp 0x5fc3d
movb $0xc, -0x2(%rbp)
jmp 0x5fc3d
movb $0xd, -0x2(%rbp)
jmp 0x5fc3d
movb $0xe, -0x2(%rbp)
jmp 0x5fc3d
movb $0xf, -0x2(%rbp)
jmp 0x5fc3d
movb $0x0, -0x2(%rbp)
jmp 0x5fc3f
movb -0x2(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_line.c
// Function: line_next
static bool line_next(line_draw_t * line)
{
    if(line->p_act.x == line->p2.x && line->p_act.y == line->p2.y) return false;
    line->e2 = line->err;
    if(line->e2 > -line->dx) {
        line->err -= line->dy;
        line->p_act.x += line->sx;
    }
    if(line->e2 < line->dy) {
        line->err += line->dx;
        line->p_act.y += line->sy;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x61c09
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jne 0x61c09
movb $0x0, -0x1(%rbp)
jmp 0x61ca1
movq -0x10(%rbp), %rax
movw 0x14(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x10(%rbp), %rax
movswl 0x16(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0xc(%rcx), %edx
xorl %ecx, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x61c5d
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x14(%rax), %ecx
subl %edx, %ecx
movw %cx, 0x14(%rax)
movq -0x10(%rbp), %rax
movswl 0xe(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movswl 0x16(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x61c9d
movq -0x10(%rbp), %rax
movswl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x14(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x14(%rax)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %edx
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %ecx
addl %edx, %ecx
movw %cx, 0xa(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_line.c
// Function: line_next_y
static bool line_next_y(line_draw_t * line)
{
    lv_coord_t last_y = line->p_act.y;

    do {
        if(!line_next(line)) return false;
    } while(last_y == line->p_act.y);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw 0xa(%rax), %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61bd0
testb $0x1, %al
jne 0x61cdb
movb $0x0, -0x1(%rbp)
jmp 0x61cf1
jmp 0x61cdd
movswl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movswl 0xa(%rcx), %ecx
cmpl %ecx, %eax
je 0x61cc8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_line.c
// Function: line_next_x
static bool line_next_x(line_draw_t * line)
{
    lv_coord_t last_x = line->p_act.x;

    do {
        if(!line_next(line)) return false;
    } while(last_x == line->p_act.x);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw 0x8(%rax), %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61bd0
testb $0x1, %al
jne 0x61d2b
movb $0x0, -0x1(%rbp)
jmp 0x61d41
jmp 0x61d2d
movswl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
je 0x61d18
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_draw_img
void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style,
                 lv_opa_t opa_scale)
{
    if(src == NULL) {
        LV_LOG_WARN("Image draw: src is NULL");
        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL, NULL, NULL, LV_BIDI_DIR_LTR);
        return;
    }

    lv_res_t res;
    res = lv_img_draw_core(coords, mask, src, style, opa_scale);

    if(res == LV_RES_INV) {
        LV_LOG_WARN("Image draw error");
        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL,  NULL, NULL, LV_BIDI_DIR_LTR);
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x61dda
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x27264(%rip), %rdx     # 0x88fe8
movl $0xff, %ecx
callq 0x5a9e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x2724b(%rip), %rdx     # 0x88fe8
movl $0xff, %ecx
leaq 0xa2df(%rip), %r8       # 0x6c088
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x5f210
jmp 0x61e60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzbl -0x21(%rbp), %r8d
callq 0x61e70
movb %al, -0x22(%rbp)
movzbl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0x61e60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x271d9(%rip), %rdx     # 0x88fe8
movl $0xff, %ecx
callq 0x5a9e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x271c0(%rip), %rdx     # 0x88fe8
movl $0xff, %ecx
leaq 0xa254(%rip), %r8       # 0x6c088
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x5f210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_color_format_get_px_size
uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf)
{
    uint8_t px_size = 0;

    switch(cf) {
        case LV_IMG_CF_UNKNOWN:
        case LV_IMG_CF_RAW: px_size = 0; break;
        case LV_IMG_CF_TRUE_COLOR:
        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED: px_size = LV_COLOR_SIZE; break;
        case LV_IMG_CF_TRUE_COLOR_ALPHA: px_size = LV_IMG_PX_SIZE_ALPHA_BYTE << 3; break;
        case LV_IMG_CF_INDEXED_1BIT:
        case LV_IMG_CF_ALPHA_1BIT: px_size = 1; break;
        case LV_IMG_CF_INDEXED_2BIT:
        case LV_IMG_CF_ALPHA_2BIT: px_size = 2; break;
        case LV_IMG_CF_INDEXED_4BIT:
        case LV_IMG_CF_ALPHA_4BIT: px_size = 4; break;
        case LV_IMG_CF_INDEXED_8BIT:
        case LV_IMG_CF_ALPHA_8BIT: px_size = 8; break;
        default: px_size = 0; break;
    }

    return px_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xe, %rax
ja 0x6258a
movq -0x10(%rbp), %rax
leaq 0x9ac9(%rip), %rcx      # 0x6c020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x2(%rbp)
jmp 0x6258e
movb $0x10, -0x2(%rbp)
jmp 0x6258e
movb $0x18, -0x2(%rbp)
jmp 0x6258e
movb $0x1, -0x2(%rbp)
jmp 0x6258e
movb $0x2, -0x2(%rbp)
jmp 0x6258e
movb $0x4, -0x2(%rbp)
jmp 0x6258e
movb $0x8, -0x2(%rbp)
jmp 0x6258e
movb $0x0, -0x2(%rbp)
movb -0x2(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_buf_set_palette
void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c)
{
    if((dsc->header.cf == LV_IMG_CF_ALPHA_1BIT && id > 1) || (dsc->header.cf == LV_IMG_CF_ALPHA_2BIT && id > 3) ||
       (dsc->header.cf == LV_IMG_CF_ALPHA_4BIT && id > 15) || (dsc->header.cf == LV_IMG_CF_ALPHA_8BIT)) {
        LV_LOG_WARN("lv_img_buf_set_px_alpha: invalid 'id'");
        return;
    }

    lv_color32_t c32;
    c32.full      = lv_color_to32(c);
    uint8_t * buf = (uint8_t *)dsc->data;
    memcpy(&buf[id * sizeof(c32)], &c32, sizeof(c32));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %cx
movb %sil, %al
movw %cx, -0x2(%rbp)
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x62f90
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jg 0x62fcc
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1f, %eax
cmpl $0xc, %eax
jne 0x62fa7
movzbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jg 0x62fcc
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1f, %eax
cmpl $0xd, %eax
jne 0x62fbe
movzbl -0x11(%rbp), %eax
cmpl $0xf, %eax
jg 0x62fcc
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1f, %eax
cmpl $0xe, %eax
jne 0x62fce
jmp 0x62ff8
movzwl -0x2(%rbp), %edi
callq 0x63000
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl -0x11(%rbp), %ecx
shlq $0x2, %rcx
movl -0x18(%rbp), %edx
movl %edx, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_color_format_is_chroma_keyed
bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf)
{
    bool is_chroma_keyed = false;

    switch(cf) {
        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED:
        case LV_IMG_CF_RAW_CHROMA_KEYED:
#if LV_INDEXED_CHROMA
        case LV_IMG_CF_INDEXED_1BIT:
        case LV_IMG_CF_INDEXED_2BIT:
        case LV_IMG_CF_INDEXED_4BIT:
        case LV_IMG_CF_INDEXED_8BIT:
#endif
            is_chroma_keyed = true; break;

        default: is_chroma_keyed = false; break;
    }

    return is_chroma_keyed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x3, %eax
je 0x630a9
jmp 0x6309c
movl -0x8(%rbp), %eax
addl $-0x6, %eax
subl $0x4, %eax
ja 0x630af
jmp 0x630a9
movb $0x1, -0x2(%rbp)
jmp 0x630b3
movb $0x0, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_color_format_has_alpha
bool lv_img_color_format_has_alpha(lv_img_cf_t cf)
{
    bool has_alpha = false;

    switch(cf) {
        case LV_IMG_CF_TRUE_COLOR_ALPHA:
        case LV_IMG_CF_RAW_ALPHA:
        case LV_IMG_CF_INDEXED_1BIT:
        case LV_IMG_CF_INDEXED_2BIT:
        case LV_IMG_CF_INDEXED_4BIT:
        case LV_IMG_CF_INDEXED_8BIT:
        case LV_IMG_CF_ALPHA_1BIT:
        case LV_IMG_CF_ALPHA_2BIT:
        case LV_IMG_CF_ALPHA_4BIT:
        case LV_IMG_CF_ALPHA_8BIT: has_alpha = true; break;
        default: has_alpha = false; break;
    }

    return has_alpha;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0x630f3
jmp 0x630dc
movl -0x8(%rbp), %eax
subl $0x5, %eax
je 0x630f3
jmp 0x630e6
movl -0x8(%rbp), %eax
addl $-0x7, %eax
subl $0x7, %eax
ja 0x630f9
jmp 0x630f3
movb $0x1, -0x2(%rbp)
jmp 0x630fd
movb $0x0, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_src_get_type
lv_img_src_t lv_img_src_get_type(const void * src)
{
    lv_img_src_t img_src_type = LV_IMG_SRC_UNKNOWN;

    if(src == NULL) return img_src_type;
    const uint8_t * u8_p = src;

    /*The first byte shows the type of the image source*/
    if(u8_p[0] >= 0x20 && u8_p[0] <= 0x7F) {
        img_src_type = LV_IMG_SRC_FILE; /*If it's an ASCII character then it's file name*/
    } else if(u8_p[0] >= 0x80) {
        img_src_type = LV_IMG_SRC_SYMBOL; /*Symbols begins after 0x7F*/
    } else {
        img_src_type = LV_IMG_SRC_VARIABLE; /*`lv_img_dsc_t` is design to the first byte < 0x20*/
    }

    if(LV_IMG_SRC_UNKNOWN == img_src_type) {
        LV_LOG_WARN("lv_img_src_get_type: unknown image type");
    }

    return img_src_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x3, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6312b
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x63180
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jl 0x63151
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jg 0x63151
movb $0x1, -0x11(%rbp)
jmp 0x6316b
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jl 0x63165
movb $0x2, -0x11(%rbp)
jmp 0x63169
movb $0x0, -0x11(%rbp)
jmp 0x6316b
movzbl -0x11(%rbp), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jne 0x6317a
jmp 0x6317a
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_buf_alloc
lv_img_dsc_t *lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
{
    /* Allocate image descriptor */
    lv_img_dsc_t *dsc = lv_mem_alloc(sizeof(lv_img_dsc_t));
    if(dsc == NULL)
        return NULL;
    
    memset(dsc, 0, sizeof(lv_img_dsc_t));
    
    /* Get image data size */
    dsc->data_size = lv_img_buf_get_img_size(w, h, cf);
    if(dsc->data_size == 0) {
        lv_mem_free(dsc);
        return NULL;
    }
    
    /* Allocate raw buffer */
    dsc->data = lv_mem_alloc(dsc->data_size);
    if(dsc->data == NULL) {
        lv_mem_free(dsc);
        return NULL;
    }
    memset((uint8_t *)dsc->data, 0, dsc->data_size);
    
    /* Fill in header */
    dsc->header.always_zero = 0;
    dsc->header.w = w;
    dsc->header.h = h;
    dsc->header.cf = cf;
    return dsc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0xa(%rbp)
movw %cx, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl $0x10, %edi
callq 0x44d20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x631cd
movq $0x0, -0x8(%rbp)
jmp 0x632d3
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2090
movw -0xa(%rbp), %cx
movw -0xc(%rbp), %ax
movswl %cx, %edi
movswl %ax, %esi
movzbl -0xd(%rbp), %edx
callq 0x632e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6321d
movq -0x18(%rbp), %rdi
callq 0x44ec0
movq $0x0, -0x8(%rbp)
jmp 0x632d3
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
callq 0x44d20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x63254
movq -0x18(%rbp), %rdi
callq 0x44ec0
movq $0x0, -0x8(%rbp)
jmp 0x632d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2090
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff1f, %ecx       # imm = 0xFFFFFF1F
orl $0x0, %ecx
movl %ecx, (%rax)
movswl -0xa(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x7ff, %edx            # imm = 0x7FF
shll $0xa, %edx
andl $0xffe003ff, %ecx       # imm = 0xFFE003FF
orl %edx, %ecx
movl %ecx, (%rax)
movswl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x7ff, %edx            # imm = 0x7FF
shll $0x15, %edx
andl $0x1fffff, %ecx         # imm = 0x1FFFFF
orl %edx, %ecx
movl %ecx, (%rax)
movzbl -0xd(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x1f, %edx
andl $-0x20, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_buf_get_img_size
uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
{
    switch(cf) {
        case LV_IMG_CF_TRUE_COLOR: return LV_IMG_BUF_SIZE_TRUE_COLOR(w, h);
        case LV_IMG_CF_TRUE_COLOR_ALPHA: return LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h);
        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED: return LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h);
        case LV_IMG_CF_ALPHA_1BIT: return LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h);
        case LV_IMG_CF_ALPHA_2BIT: return LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h);
        case LV_IMG_CF_ALPHA_4BIT: return LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h);
        case LV_IMG_CF_ALPHA_8BIT: return LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h);
        case LV_IMG_CF_INDEXED_1BIT: return LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h);
        case LV_IMG_CF_INDEXED_2BIT: return LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h);
        case LV_IMG_CF_INDEXED_4BIT: return LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h);
        case LV_IMG_CF_INDEXED_8BIT: return LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h);
        default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x6(%rbp)
movw %cx, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xa, %eax
ja 0x6343a
movq -0x18(%rbp), %rax
leaq 0x8d44(%rip), %rcx      # 0x6c05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movswl -0x6(%rbp), %eax
shll %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
imull $0x3, %eax, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
shll %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
addl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
addl $0x10, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
addl $0x40, %eax
movl %eax, -0x4(%rbp)
jmp 0x63441
movswl -0x6(%rbp), %eax
movswl -0x8(%rbp), %ecx
imull %ecx, %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x4(%rbp)
jmp 0x63441
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_img.c
// Function: lv_img_buf_free
void lv_img_buf_free(lv_img_dsc_t *dsc)
{
    if(dsc != NULL) {
        if(dsc->data != NULL)
            lv_mem_free(dsc->data);
        
        lv_mem_free(dsc);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x63484
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6347b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44ec0
movq -0x8(%rbp), %rdi
callq 0x44ec0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_triangle.c
// Function: lv_draw_polygon
void lv_draw_polygon(const lv_point_t * points, uint32_t point_cnt, const lv_area_t * mask, const lv_style_t * style,
                     lv_opa_t opa_scale)
{
    if(point_cnt < 3) return;
    if(points == NULL) return;

    uint32_t i;
    lv_point_t tri[3];
    tri[0].x = points[0].x;
    tri[0].y = points[0].y;
    for(i = 0; i < point_cnt - 1; i++) {
        tri[1].x = points[i].x;
        tri[1].y = points[i].y;
        tri[2].x = points[i + 1].x;
        tri[2].y = points[i + 1].y;
        lv_draw_triangle(tri, mask, style, opa_scale);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
cmpl $0x3, -0xc(%rbp)
jae 0x64f48
jmp 0x64fe7
cmpq $0x0, -0x8(%rbp)
jne 0x64f54
jmp 0x64fe7
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x32(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x64fe7
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movw (%rax,%rcx,4), %ax
movw %ax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movw 0x2(%rax,%rcx,4), %ax
movw %ax, -0x2e(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw (%rax,%rcx,4), %ax
movw %ax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw 0x2(%rax,%rcx,4), %ax
movw %ax, -0x2a(%rbp)
leaq -0x34(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movzbl -0x21(%rbp), %ecx
callq 0x63fd0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x64f72
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_triangle.c
// Function: point_swap
static void point_swap(lv_point_t * p1, lv_point_t * p2)
{
    lv_point_t tmp;
    tmp.x = p1->x;
    tmp.y = p1->y;

    p1->x = p2->x;
    p1->y = p2->y;

    p2->x = tmp.x;
    p2->y = tmp.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movw -0x14(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_init
void lv_img_decoder_init(void)
{
    lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));

    lv_img_decoder_t * decoder;

    /*Create a decoder for the built in color format*/
    decoder = lv_img_decoder_create();
    if(decoder == NULL) {
        LV_LOG_WARN("lv_img_decoder_init: out of memory");
        LV_ASSERT_MEM(decoder);
        return;
    }

    lv_img_decoder_set_info_cb(decoder, lv_img_decoder_built_in_info);
    lv_img_decoder_set_open_cb(decoder, lv_img_decoder_built_in_open);
    lv_img_decoder_set_read_line_cb(decoder, lv_img_decoder_built_in_read_line);
    lv_img_decoder_set_close_cb(decoder, lv_img_decoder_built_in_close);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2c5f9(%rip), %rdi     # 0x91658
movl $0x20, %esi
callq 0x453a0
callq 0x650e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6509a
movq -0x8(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x65098
movq -0x8(%rbp), %rsi
leaq 0x2fb3(%rip), %rdi      # 0x68044
callq 0xd410
jmp 0x65096
jmp 0x650da
movq -0x8(%rbp), %rdi
leaq 0xcb(%rip), %rsi        # 0x65170
callq 0x65150
movq -0x8(%rbp), %rdi
leaq 0x26b(%rip), %rsi       # 0x65320
callq 0x65300
movq -0x8(%rbp), %rdi
leaq 0x70b(%rip), %rsi       # 0x657d0
callq 0x657b0
movq -0x8(%rbp), %rdi
leaq 0x88b(%rip), %rsi       # 0x65960
callq 0x65940
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_create
lv_img_decoder_t * lv_img_decoder_create(void)
{
    lv_img_decoder_t * decoder;
    decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
    LV_ASSERT_MEM(decoder);
    if(decoder == NULL) return NULL;

    memset(decoder, 0, sizeof(lv_img_decoder_t));

    return decoder;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2c569(%rip), %rdi     # 0x91658
callq 0x453f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd120
testb $0x1, %al
jne 0x65117
movq -0x10(%rbp), %rsi
leaq 0x2f34(%rip), %rdi      # 0x68044
callq 0xd410
jmp 0x65115
cmpq $0x0, -0x10(%rbp)
jne 0x65128
movq $0x0, -0x8(%rbp)
jmp 0x65140
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2090
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_built_in_close
void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
{
    (void)decoder; /*Unused*/

    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
    if(user_data) {
#if LV_USE_FILESYSTEM
        if(user_data->f) {
            lv_fs_close(user_data->f);
            lv_mem_free(user_data->f);
        }
#endif
        if(user_data->palette) lv_mem_free(user_data->palette);

        lv_mem_free(user_data);

        dsc->user_data = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x659d2
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x659a5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x43650
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44ec0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x659bd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44ec0
movq -0x18(%rbp), %rdi
callq 0x44ec0
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_get_info
lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
{
    header->always_zero = 0;

    lv_res_t res = LV_RES_INV;
    lv_img_decoder_t * d;
    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
    {
        res = LV_RES_INV;
        if(d->info_cb) {
            res = d->info_cb(d, src, header);
            if(res == LV_RES_OK) break;
        }
    }

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff1f, %ecx       # imm = 0xFFFFFF1F
orl $0x0, %ecx
movl %ecx, (%rax)
movb $0x0, -0x11(%rbp)
leaq 0x2bc4c(%rip), %rdi     # 0x91658
callq 0x45660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x65a67
movb $0x0, -0x11(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x65a4f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq *%rax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jne 0x65a4d
jmp 0x65a67
jmp 0x65a4f
jmp 0x65a51
movq -0x20(%rbp), %rsi
leaq 0x2bbfc(%rip), %rdi     # 0x91658
callq 0x458a0
movq %rax, -0x20(%rbp)
jmp 0x65a15
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_open
lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style)
{
    dsc->style     = style;
    dsc->src_type  = lv_img_src_get_type(src);
    dsc->user_data = NULL;

    if(dsc->src_type == LV_IMG_SRC_FILE) {
        size_t fnlen = strlen(src);
        dsc->src = lv_mem_alloc(fnlen + 1);
        strcpy((char *)dsc->src, src);
    } else {
        dsc->src       = src;
    }

    lv_res_t res = LV_RES_INV;

    lv_img_decoder_t * d;
    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
    {
        /*Info an Open callbacks are required*/
        if(d->info_cb == NULL || d->open_cb == NULL) continue;

        res = d->info_cb(d, src, &dsc->header);
        if(res != LV_RES_OK) continue;

        dsc->error_msg = NULL;
        dsc->img_data  = NULL;
        dsc->decoder   = d;

        res = d->open_cb(d, dsc);

        /*Opened successfully. It is a good decoder to for this image source*/
        if(res == LV_RES_OK) break;
    }

    if(res == LV_RES_INV) {
        memset(dsc, 0, sizeof(lv_img_decoder_dsc_t));
    }

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x63110
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x1, %eax
jne 0x65af3
movq -0x10(%rbp), %rdi
callq 0x2060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x44d20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2040
jmp 0x65aff
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, -0x21(%rbp)
leaq 0x2bb4e(%rip), %rdi     # 0x91658
callq 0x45660
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x65bba
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x65b33
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x65b35
jmp 0x65ba1
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x1c, %rdx
callq *%rax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0x65b5c
jmp 0x65ba1
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x1, %eax
jne 0x65b9f
jmp 0x65bba
jmp 0x65ba1
movq -0x30(%rbp), %rsi
leaq 0x2baac(%rip), %rdi     # 0x91658
callq 0x458a0
movq %rax, -0x30(%rbp)
jmp 0x65b13
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x65bd3
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
movb -0x21(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_close
void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc)
{
    if(dsc->decoder) {
        if(dsc->decoder->close_cb) dsc->decoder->close_cb(dsc->decoder, dsc);

        if(dsc->src_type == LV_IMG_SRC_FILE) {
            lv_mem_free(dsc->src);
            dsc->src = NULL;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x65cc4
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x65c9c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x1, %eax
jne 0x65cc2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44ec0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x65cc4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_decoder.c
// Function: lv_img_decoder_built_in_line_true_color
static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
                                                        lv_coord_t len, uint8_t * buf)
{
#if LV_USE_FILESYSTEM
    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
    lv_fs_res_t res;
    uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf);

    uint32_t pos = ((y * dsc->header.w + x) * px_size) >> 3;
    pos += 4; /*Skip the header*/
    res = lv_fs_seek(user_data->f, pos);
    if(res != LV_FS_RES_OK) {
        LV_LOG_WARN("Built-in image decoder seek failed");
        return LV_RES_INV;
    }
    uint32_t btr = len * (px_size >> 3);
    uint32_t br  = 0;
    lv_fs_read(user_data->f, buf, btr, &br);
    if(res != LV_FS_RES_OK || btr != br) {
        LV_LOG_WARN("Built-in image decoder read failed");
        return LV_RES_INV;
    }

    return LV_RES_OK;
#else
    LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
    return LV_RES_INV;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
movq %rdi, -0x10(%rbp)
movw %dx, -0x12(%rbp)
movw %cx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x1f, %eax
movzbl %al, %edi
callq 0x62530
movb %al, -0x2a(%rbp)
movswl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shrl $0xa, %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
imull %ecx, %eax
movswl -0x12(%rbp), %ecx
addl %ecx, %eax
movzbl -0x2a(%rbp), %ecx
imull %ecx, %eax
sarl $0x3, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x30(%rbp), %esi
callq 0x438e0
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x65e1a
movb $0x0, -0x1(%rbp)
jmp 0x65e64
movswl -0x16(%rbp), %eax
movzbl -0x2a(%rbp), %ecx
sarl $0x3, %ecx
imull %ecx, %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
leaq -0x38(%rbp), %rcx
callq 0x437a0
movzbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jne 0x65e5a
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x65e60
movb $0x0, -0x1(%rbp)
jmp 0x65e64
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_cache.c
// Function: lv_img_cache_set_size
void lv_img_cache_set_size(uint16_t new_entry_cnt)
{
    if(LV_GC_ROOT(_lv_img_cache_array) != NULL) {
        /*Clean the cache before free it*/
        lv_img_cache_invalidate_src(NULL);
        lv_mem_free(LV_GC_ROOT(_lv_img_cache_array));
    }

    /*Reallocate the cache*/
    LV_GC_ROOT(_lv_img_cache_array) = lv_mem_alloc(sizeof(lv_img_cache_entry_t) * new_entry_cnt);
    LV_ASSERT_MEM(LV_GC_ROOT(_lv_img_cache_array));
    if(LV_GC_ROOT(_lv_img_cache_array) == NULL) {
        entry_cnt = 0;
        return;
    }
    entry_cnt = new_entry_cnt;

    /*Clean the cache*/
    uint16_t i;
    for(i = 0; i < entry_cnt; i++) {
        memset(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
        memset(&LV_GC_ROOT(_lv_img_cache_array)[i], 0, sizeof(lv_img_cache_entry_t));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq 0x2ad1a(%rip), %rax     # 0x91670
cmpq $0x0, (%rax)
je 0x66974
xorl %eax, %eax
movl %eax, %edi
callq 0x66a50
leaq 0x2ad04(%rip), %rax     # 0x91670
movq (%rax), %rdi
callq 0x44ec0
movzwl -0x2(%rbp), %eax
imulq $0x48, %rax, %rdi
callq 0x44d20
movq %rax, %rcx
leaq 0x2ace5(%rip), %rax     # 0x91670
movq %rcx, (%rax)
leaq 0x2acdb(%rip), %rax     # 0x91670
movq (%rax), %rdi
callq 0xd120
testb $0x1, %al
jne 0x669b9
leaq 0x2acc8(%rip), %rax     # 0x91670
movq (%rax), %rsi
leaq 0x1692(%rip), %rdi      # 0x68044
callq 0xd410
jmp 0x669b7
leaq 0x2acb0(%rip), %rax     # 0x91670
cmpq $0x0, (%rax)
jne 0x669d1
movw $0x0, 0x341fd(%rip)     # 0x9abcc
jmp 0x66a41
movw -0x2(%rbp), %ax
movw %ax, 0x341f0(%rip)      # 0x9abcc
movw $0x0, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
movzwl 0x341df(%rip), %ecx     # 0x9abcc
cmpl %ecx, %eax
jge 0x66a41
leaq 0x2ac78(%rip), %rax     # 0x91670
movq (%rax), %rdi
movzwl -0x4(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
leaq 0x2ac57(%rip), %rax     # 0x91670
movq (%rax), %rdi
movzwl -0x4(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x2090
movw -0x4(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x4(%rbp)
jmp 0x669e2
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_img_cache.c
// Function: lv_img_cache_invalidate_src
void lv_img_cache_invalidate_src(const void * src)
{

    lv_img_cache_entry_t * cache = LV_GC_ROOT(_lv_img_cache_array);

    uint16_t i;
    for(i = 0; i < entry_cnt; i++) {
        if(cache[i].dec_dsc.src == src || src == NULL) {
            if(cache[i].dec_dsc.src != NULL) {
                lv_img_decoder_close(&cache[i].dec_dsc);
            }

            memset(&cache[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
            memset(&cache[i], 0, sizeof(lv_img_cache_entry_t));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2ac0d(%rip), %rax     # 0x91670
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movw $0x0, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movzwl 0x34151(%rip), %ecx     # 0x9abcc
cmpl %ecx, %eax
jge 0x66b16
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x66aa3
cmpq $0x0, -0x8(%rbp)
jne 0x66b03
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x66acd
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
callq 0x65c60
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x2090
jmp 0x66b05
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x66a70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)