LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_get_width
lv_coord_t lv_txt_get_width(const char * txt, uint16_t length, const lv_font_t * font, lv_coord_t letter_space,
                            lv_txt_flag_t flag)
{
    if(txt == NULL) return 0;
    if(font == NULL) return 0;

    uint32_t i                   = 0;
    lv_coord_t width             = 0;
    lv_txt_cmd_state_t cmd_state = LV_TXT_CMD_STATE_WAIT;
    uint32_t letter;
    uint32_t letter_next;

    if(length != 0) {
        while(i < length) {
            letter      = lv_txt_encoded_next(txt, &i);
            letter_next = lv_txt_encoded_next(&txt[i], NULL);
            if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
                if(lv_txt_is_cmd(&cmd_state, letter) != false) {
                    continue;
                }
            }

            lv_coord_t char_width = lv_font_get_glyph_width(font, letter, letter_next);
            if(char_width > 0) {
                width += char_width;
                width += letter_space;
            }
        }

        if(width > 0) {
            width -= letter_space; /*Trim the last letter space. Important if the text is center
                                      aligned */
        }
    }

    return width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movw %si, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movw %cx, -0x22(%rbp)
movb %al, -0x23(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46c00
movw $0x0, -0x2(%rbp)
jmp 0x46cf3
cmpq $0x0, -0x20(%rbp)
jne 0x46c12
movw $0x0, -0x2(%rbp)
jmp 0x46cf3
movl $0x0, -0x28(%rbp)
movw $0x0, -0x2a(%rbp)
movb $0x0, -0x2b(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
je 0x46ceb
jmp 0x46c32
movl -0x28(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jae 0x46cd2
movq 0x35a78(%rip), %rax     # 0x7c6c0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
movl %eax, -0x30(%rbp)
movq 0x35a64(%rip), %rax     # 0x7c6c0
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %ecx
addq %rcx, %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl %eax, -0x34(%rbp)
movzbl -0x23(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x46c95
movl -0x30(%rbp), %esi
leaq -0x2b(%rbp), %rdi
callq 0x46ff0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x46c93
jmp 0x46c32
jmp 0x46c95
movq -0x20(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x415e0
movw %ax, -0x36(%rbp)
movswl -0x36(%rbp), %eax
cmpl $0x0, %eax
jle 0x46ccd
movswl -0x36(%rbp), %ecx
movswl -0x2a(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x2a(%rbp)
movswl -0x22(%rbp), %ecx
movswl -0x2a(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x2a(%rbp)
jmp 0x46c32
movswl -0x2a(%rbp), %eax
cmpl $0x0, %eax
jle 0x46ce9
movswl -0x22(%rbp), %ecx
movswl -0x2a(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x2a(%rbp)
jmp 0x46ceb
movw -0x2a(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_is_cmd
bool lv_txt_is_cmd(lv_txt_cmd_state_t * state, uint32_t c)
{
    bool ret = false;

    if(c == (uint32_t)LV_TXT_COLOR_CMD[0]) {
        if(*state == LV_TXT_CMD_STATE_WAIT) { /*Start char*/
            *state = LV_TXT_CMD_STATE_PAR;
            ret    = true;
        }
        /*Other start char in parameter is escaped cmd. char */
        else if(*state == LV_TXT_CMD_STATE_PAR) {
            *state = LV_TXT_CMD_STATE_WAIT;
        }
        /*Command end */
        else if(*state == LV_TXT_CMD_STATE_IN) {
            *state = LV_TXT_CMD_STATE_WAIT;
            ret    = true;
        }
    }

    /*Skip the color parameter and wait the space after it*/
    if(*state == LV_TXT_CMD_STATE_PAR) {
        if(c == ' ') {
            *state = LV_TXT_CMD_STATE_IN; /*After the parameter the text is in the command*/
        }
        ret = true;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movl -0xc(%rbp), %eax
movsbl 0x21310(%rip), %ecx     # 0x68319
cmpl %ecx, %eax
jne 0x47058
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x47026
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0xd(%rbp)
jmp 0x47056
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x4703b
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x47054
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x47052
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0xd(%rbp)
jmp 0x47054
jmp 0x47056
jmp 0x47058
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x47075
cmpl $0x20, -0xc(%rbp)
jne 0x47071
movq -0x8(%rbp), %rax
movb $0x2, (%rax)
movb $0x1, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_ins
void lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt)
{
    size_t old_len = strlen(txt_buf);
    size_t ins_len = strlen(ins_txt);
    size_t new_len = ins_len + old_len;
    pos              = lv_txt_encoded_get_byte_id(txt_buf, pos); /*Convert to byte index instead of letter index*/

    /*Copy the second part into the end to make place to text to insert*/
    size_t i;
    for(i = new_len; i >= pos + ins_len; i--) {
        txt_buf[i] = txt_buf[i - ins_len];
    }

    /* Copy the text into the new space*/
    memcpy(txt_buf + pos, ins_txt, ins_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2060
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2060
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x35610(%rip), %rax     # 0x7c6d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
movl %eax, -0xc(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
addq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jb 0x4710c
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
subq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x470d4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x20e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: lv_txt_cut
void lv_txt_cut(char * txt, uint32_t pos, uint32_t len)
{

    size_t old_len = strlen(txt);

    pos = lv_txt_encoded_get_byte_id(txt, pos); /*Convert to byte index instead of letter index*/
    len = lv_txt_encoded_get_byte_id(&txt[pos], len);

    /*Copy the second part into the end to make place to text to insert*/
    uint32_t i;
    for(i = pos; i <= old_len - len; i++) {
        txt[i] = txt[i + len];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
movq 0x3557a(%rip), %rax     # 0x7c6d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
movl %eax, -0xc(%rbp)
movq 0x35567(%rip), %rax     # 0x7c6d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
addq %rcx, %rdi
movl -0x10(%rbp), %esi
callq *%rax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %edx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x471b7
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x47181
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_txt.c
// Function: is_break_char
static inline bool is_break_char(uint32_t letter)
{
    uint8_t i;
    bool ret = false;

    /*Compare the letter to TXT_BREAK_CHARS*/
    for(i = 0; LV_TXT_BREAK_CHARS[i] != '\0'; i++) {
        if(letter == (uint32_t)LV_TXT_BREAK_CHARS[i]) {
            ret = true; /*If match then it is break char*/
            break;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x0, -0x6(%rbp)
movb $0x0, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, %ecx
leaq 0x249e4(%rip), %rax     # 0x6bbc0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4720f
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
movl %ecx, %edx
leaq 0x249cb(%rip), %rcx     # 0x6bbc0
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x47203
movb $0x1, -0x6(%rbp)
jmp 0x4720f
jmp 0x47205
movb -0x5(%rbp), %al
addb $0x1, %al
movb %al, -0x5(%rbp)
jmp 0x471cf
movb -0x6(%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_misc/lv_math.c
// Function: lv_trigo_sin
int16_t lv_trigo_sin(int16_t angle)
{
    int16_t ret = 0;
    angle       = angle % 360;

    if(angle < 0) angle = 360 + angle;

    if(angle < 90) {
        ret = sin0_90_table[angle];
    } else if(angle >= 90 && angle < 180) {
        angle = 180 - angle;
        ret   = sin0_90_table[angle];
    } else if(angle >= 180 && angle < 270) {
        angle = angle - 180;
        ret   = -sin0_90_table[angle];
    } else { /*angle >=270*/
        angle = 360 - angle;
        ret   = -sin0_90_table[angle];
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movw $0x0, -0x4(%rbp)
movswl -0x2(%rbp), %eax
movl $0x168, %ecx            # imm = 0x168
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
cmpl $0x0, %eax
jge 0x4725a
movswl -0x2(%rbp), %eax
addl $0x168, %eax            # imm = 0x168
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
cmpl $0x5a, %eax
jge 0x4727c
movswq -0x2(%rbp), %rcx
leaq 0x24961(%rip), %rax     # 0x6bbd0
movw (%rax,%rcx,2), %ax
movw %ax, -0x4(%rbp)
jmp 0x4731d
movswl -0x2(%rbp), %eax
cmpl $0x5a, %eax
jl 0x472b5
movswl -0x2(%rbp), %eax
cmpl $0xb4, %eax
jge 0x472b5
movswl -0x2(%rbp), %ecx
movl $0xb4, %eax
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x24925(%rip), %rax     # 0x6bbd0
movw (%rax,%rcx,2), %ax
movw %ax, -0x4(%rbp)
jmp 0x4731b
movswl -0x2(%rbp), %eax
cmpl $0xb4, %eax
jl 0x472f2
movswl -0x2(%rbp), %eax
cmpl $0x10e, %eax            # imm = 0x10E
jge 0x472f2
movswl -0x2(%rbp), %eax
subl $0xb4, %eax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x248ec(%rip), %rax     # 0x6bbd0
movswl (%rax,%rcx,2), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0x4(%rbp)
jmp 0x47319
movswl -0x2(%rbp), %ecx
movl $0x168, %eax            # imm = 0x168
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x248c3(%rip), %rax     # 0x6bbd0
movswl (%rax,%rcx,2), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0x4(%rbp)
jmp 0x4731b
jmp 0x4731d
movw -0x4(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_math.c
// Function: lv_bezier3
int32_t lv_bezier3(uint32_t t, int32_t u0, int32_t u1, int32_t u2, int32_t u3)
{
    uint32_t t_rem  = 1024 - t;
    uint32_t t_rem2 = (t_rem * t_rem) >> 10;
    uint32_t t_rem3 = (t_rem2 * t_rem) >> 10;
    uint32_t t2     = (t * t) >> 10;
    uint32_t t3     = (t2 * t) >> 10;

    uint32_t v1 = ((uint32_t)t_rem3 * u0) >> 10;
    uint32_t v2 = ((uint32_t)3 * t_rem2 * t * u1) >> 20;
    uint32_t v3 = ((uint32_t)3 * t_rem * t2 * u2) >> 20;
    uint32_t v4 = ((uint32_t)t3 * u3) >> 10;

    return v1 + v2 + v3 + v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x400, %eax            # imm = 0x400
subl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
imull -0x18(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
imull -0x4(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
imull -0x4(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
imull -0x8(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x2c(%rbp)
imull $0x3, -0x1c(%rbp), %eax
imull -0x4(%rbp), %eax
imull -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, -0x30(%rbp)
imull $0x3, -0x18(%rbp), %eax
imull -0x24(%rbp), %eax
imull -0x10(%rbp), %eax
shrl $0x14, %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
imull -0x14(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
addl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_math.c
// Function: lv_sqrt
uint32_t lv_sqrt(uint32_t num)
{
    // http://www.codecodex.com/wiki/Calculate_an_integer_square_root#C
    uint32_t root  = 0;
    uint32_t place = 0x40000000;

    while(place > num) place >>= 2;
    while(place) {
        if(num >= root + place) {
            num -= root + place;
            root += (place << 1);
        }
        root >>= 1;
        place >>= 2;
    }
    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x40000000, -0xc(%rbp) # imm = 0x40000000
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jbe 0x47588
movl -0xc(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x47575
jmp 0x4758a
cmpl $0x0, -0xc(%rbp)
je 0x475c9
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jb 0x475b6
movl -0x8(%rbp), %ecx
addl -0xc(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
shll %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x4758a
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_utils.c
// Function: lv_utils_num_to_str
char * lv_utils_num_to_str(int32_t num, char * buf)
{
    if(num == 0) {
        buf[0] = '0';
        buf[1] = '\0';
        return buf;
    }
    int8_t digitCount = 0;
    int8_t i          = 0;
    if(num < 0) {
        buf[digitCount++] = '-';
        num               = LV_MATH_ABS(num);
        ++i;
    }
    while(num) {
        char digit        = num % 10;
        buf[digitCount++] = digit + 48;
        num /= 10;
    }
    buf[digitCount] = '\0';
    digitCount--;
    while(digitCount > i) {
        char temp       = buf[i];
        buf[i]          = buf[digitCount];
        buf[digitCount] = temp;
        digitCount--;
        i++;
    }
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x475fd
movq -0x18(%rbp), %rax
movb $0x30, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x47701
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x47646
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %cl
movb %cl, %dl
addb $0x1, %dl
movb %dl, -0x19(%rbp)
movsbq %cl, %rcx
movb $0x2d, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
jle 0x47630
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x47638
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xc(%rbp)
movb -0x1a(%rbp), %al
addb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x47648
cmpl $0x0, -0xc(%rbp)
je 0x47690
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0x1b(%rbp)
movsbl -0x1b(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, -0x19(%rbp)
movsbq %cl, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x47648
movq -0x18(%rbp), %rax
movsbq -0x19(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb -0x19(%rbp), %al
addb $-0x1, %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jle 0x476f9
movq -0x18(%rbp), %rax
movsbq -0x1a(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbq -0x19(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movsbq -0x1a(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x1c(%rbp), %dl
movq -0x18(%rbp), %rax
movsbq -0x19(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %al
addb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x1a(%rbp), %al
addb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x476a5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_utils.c
// Function: lv_utils_bsearch
void * lv_utils_bsearch(const void * key, const void * base, uint32_t n, uint32_t size,
                        int32_t (*cmp)(const void * pRef, const void * pElement))
{
    const char * middle;
    int32_t c;

    for(middle = base; n != 0;) {
        middle += (n / 2) * size;
        if((c = (*cmp)(key, middle)) > 0) {
            n    = (n / 2) - ((n & 1) == 0);
            base = (middle += size);
        } else if(c < 0) {
            n /= 2;
            middle = base;
        } else {
            return (char *)middle;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x477c3
movl -0x1c(%rbp), %ecx
shrl %ecx
imull -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x4779a
movl -0x1c(%rbp), %eax
shrl %eax
movl -0x1c(%rbp), %ecx
andl $0x1, %ecx
cmpl $0x0, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x18(%rbp)
jmp 0x477be
cmpl $0x0, -0x34(%rbp)
jge 0x477b2
movl -0x1c(%rbp), %eax
shrl %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x477bc
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x477cb
jmp 0x477be
jmp 0x47732
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_async.c
// Function: lv_async_call
lv_res_t lv_async_call(lv_async_cb_t async_xcb, void * user_data)
{
    /*Allocate an info structure */
    lv_async_info_t *info = lv_mem_alloc(sizeof(lv_async_info_t));
    
    if(info == NULL)
        return LV_RES_INV;
    
    /* Create a new task */
    /* Use highest priority so that it will run before a refresh */
    lv_task_t *task = lv_task_create(lv_async_task_cb, 0, LV_TASK_PRIO_HIGHEST, info);
    
    if(task == NULL) {
        lv_mem_free(info);
        return LV_RES_INV;
    }
    
    info->cb = async_xcb;
    info->user_data = user_data;

    /* Set the task's user data */
    task->user_data = info;
    lv_task_once(task);
    return LV_RES_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x44d20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4780b
movb $0x0, -0x1(%rbp)
jmp 0x4786c
movq -0x20(%rbp), %rcx
leaq 0x6a(%rip), %rdi        # 0x47880
xorl %esi, %esi
movl $0x5, %edx
callq 0x430d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4783c
movq -0x20(%rbp), %rdi
callq 0x44ec0
movb $0x0, -0x1(%rbp)
jmp 0x4786c
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x43300
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_printf.c
// Function: atoi
static unsigned int _atoi(const char** str)
{
  unsigned int i = 0U;
  while (_is_digit(**str)) {
    i = i * 10U + (unsigned int)(*((*str)++) - '0');
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x48ea0
testb $0x1, %al
jne 0x48ef8
jmp 0x48f1a
imull $0xa, -0xc(%rbp), %eax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x48ee3
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_printf.c
// Function: ntoa_long_long
static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
{
  char buf[PRINTF_NTOA_BUFFER_SIZE];
  size_t len = 0U;

  // no hash for 0 values
  if (!value) {
    flags &= ~FLAGS_HASH;
  }

  // write if precision != 0 and value is != 0
  if (!(flags & FLAGS_PRECISION) || value) {
    do {
      const char digit = (char)(value % base);
      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
      value /= base;
    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
  }

  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movb %r9b, %al
movl 0x28(%rbp), %r9d
movl 0x20(%rbp), %r9d
movl 0x18(%rbp), %r9d
movq 0x10(%rbp), %r9
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq $0x0, -0x68(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x48f82
movl 0x28(%rbp), %eax
andl $-0x11, %eax
movl %eax, 0x28(%rbp)
movl 0x28(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x48f9a
cmpq $0x0, -0x38(%rbp)
je 0x49031
jmp 0x48f9c
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x10(%rbp)
movb %dl, %al
movb %al, -0x69(%rbp)
movsbl -0x69(%rbp), %eax
cmpl $0xa, %eax
jge 0x48fc2
movsbl -0x69(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x70(%rbp)
jmp 0x48fe4
movl 0x28(%rbp), %edx
andl $0x20, %edx
movl $0x61, %eax
movl $0x41, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movsbl -0x69(%rbp), %ecx
addl %ecx, %eax
subl $0xa, %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
movb %al, %cl
movq -0x68(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %cl, -0x60(%rbp,%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x71(%rbp)
je 0x49024
cmpq $0x20, -0x68(%rbp)
setb %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x48f9c
jmp 0x49031
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %r8
movq -0x68(%rbp), %r9
movb -0x39(%rbp), %r14b
movq 0x10(%rbp), %rax
movl %eax, %ebx
movl 0x18(%rbp), %r11d
movl 0x20(%rbp), %r10d
movl 0x28(%rbp), %eax
andb $0x1, %r14b
movzbl %r14b, %r14d
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x49df0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_misc/lv_printf.c
// Function: out_rev
static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
{
  const size_t start_idx = idx;

  // pad spaces up to given width
  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
      size_t i;
      for (i = len; i < width; i++) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  // reverse string
  while (len) {
    out(buf[--len], buffer, idx++, maxlen);
  }

  // append pad spaces up to given width
  if (flags & FLAGS_LEFT) {
    while (idx - start_idx < width) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4a13a
movl 0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4a13a
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rbp), %ecx
cmpq %rcx, %rax
jae 0x4a138
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl $0x20, %edi
callq *%rax
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x4a0fc
jmp 0x4a13a
jmp 0x4a13c
cmpq $0x0, -0x30(%rbp)
je 0x4a17e
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x30(%rbp)
movb -0x1(%rcx,%rdx), %dil
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movsbl %dil, %edi
callq *%rax
jmp 0x4a13c
movl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4a1c1
jmp 0x4a18b
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl 0x10(%rbp), %ecx
cmpq %rcx, %rax
jae 0x4a1bf
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl $0x20, %edi
callq *%rax
jmp 0x4a18b
jmp 0x4a1c1
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: lv_theme_alien_init
lv_theme_t * lv_theme_alien_init(uint16_t hue, lv_font_t * font)
{
    if(font == NULL) font = LV_FONT_DEFAULT;

    _hue  = hue;
    _font = font;

    /*For backward compatibility initialize all theme elements with a default style */
    uint16_t i;
    lv_style_t ** style_p = (lv_style_t **)&theme.style;
    for(i = 0; i < LV_THEME_STYLE_COUNT; i++) {
        *style_p = &def;
        style_p++;
    }

    basic_init();
    cont_init();
    btn_init();
    label_init();
    bar_init();
    img_init();
    line_init();
    led_init();
    slider_init();
    sw_init();
    lmeter_init();
    gauge_init();
    arc_init();
    preload_init();
    chart_init();
    calendar_init();
    cb_init();
    btnm_init();
    kb_init();
    mbox_init();
    page_init();
    ta_init();
    spinbox_init();
    list_init();
    ddlist_init();
    roller_init();
    tabview_init();
    tileview_init();
    table_init();
    win_init();

#if LV_USE_GROUP
    theme.group.style_mod_xcb      = style_mod;
    theme.group.style_mod_edit_xcb = style_mod_edit;
#endif

    return &theme;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4a1f5
leaq 0x32467(%rip), %rax     # 0x7c658
movq %rax, -0x10(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x47488(%rip)      # 0x91688
movq -0x10(%rbp), %rax
movq %rax, 0x47485(%rip)     # 0x91690
leaq 0x47486(%rip), %rax     # 0x91698
movq %rax, -0x20(%rbp)
movw $0x0, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpq $0x6a, %rax
jae 0x4a24e
movq -0x20(%rbp), %rax
leaq 0x477c7(%rip), %rcx     # 0x919f8
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x4a21c
callq 0x4a310
callq 0x4a790
callq 0x4a7b0
callq 0x4abf0
callq 0x4ace0
callq 0x4af20
callq 0x4afd0
callq 0x4b030
callq 0x4b110
callq 0x4b230
callq 0x4b350
callq 0x4b400
callq 0x4b510
callq 0x4b5d0
callq 0x4b5f0
callq 0x4b610
callq 0x4b820
callq 0x4bc30
callq 0x4be50
callq 0x4beb0
callq 0x4bf10
callq 0x4bf40
callq 0x4bf80
callq 0x4bfb0
callq 0x4c200
callq 0x4c2f0
callq 0x4c400
callq 0x4c810
callq 0x4c840
callq 0x4c8b0
leaq 0x2735(%rip), %rax      # 0x4ca20
movq %rax, 0x476f6(%rip)     # 0x919e8
leaq 0x2777(%rip), %rax      # 0x4ca70
movq %rax, 0x476f0(%rip)     # 0x919f0
leaq 0x47391(%rip), %rax     # 0x91698
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: label_init
static void label_init(void)
{
#if LV_USE_LABEL != 0
    static lv_style_t label_prim, label_sec, label_hint;

    lv_style_copy(&label_prim, &def);
    label_prim.text.font  = _font;
    label_prim.text.color = lv_color_hsv_to_rgb(_hue, 80, 96);

    lv_style_copy(&label_sec, &label_prim);
    label_sec.text.color = lv_color_hsv_to_rgb(_hue, 40, 85);

    lv_style_copy(&label_hint, &label_prim);
    label_hint.text.color = lv_color_hsv_to_rgb(_hue, 20, 70);

    theme.style.label.prim = &label_prim;
    theme.style.label.sec  = &label_sec;
    theme.style.label.hint = &label_hint;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x470c9(%rip), %rdi     # 0x91cc8
leaq 0x46df2(%rip), %rsi     # 0x919f8
callq 0xc550
movq 0x46a7e(%rip), %rax     # 0x91690
movq %rax, 0x470d7(%rip)     # 0x91cf0
movl $0x50, %esi
movl $0x60, %edx
movzwl 0x46a5e(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x470aa(%rip)      # 0x91ce8
leaq 0x470cb(%rip), %rdi     # 0x91d10
leaq 0x4707c(%rip), %rsi     # 0x91cc8
callq 0xc550
movl $0x28, %esi
movl $0x55, %edx
movzwl 0x46a26(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x470ba(%rip)      # 0x91d30
leaq 0x470db(%rip), %rdi     # 0x91d58
leaq 0x47044(%rip), %rsi     # 0x91cc8
callq 0xc550
movl $0x14, %esi
movl $0x46, %edx
movzwl 0x469ee(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, 0x470ca(%rip)      # 0x91d78
leaq 0x47013(%rip), %rax     # 0x91cc8
movq %rax, 0x46a4c(%rip)     # 0x91708
leaq 0x4704d(%rip), %rax     # 0x91d10
movq %rax, 0x46a46(%rip)     # 0x91710
leaq 0x47087(%rip), %rax     # 0x91d58
movq %rax, 0x46a40(%rip)     # 0x91718
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: img_init
static void img_init(void)
{
#if LV_USE_IMG != 0
    static lv_style_t img_light, img_dark;
    lv_style_copy(&img_light, &def);
    img_light.image.color   = lv_color_hsv_to_rgb(_hue, 15, 85);
    img_light.image.intense = LV_OPA_80;

    lv_style_copy(&img_dark, &def);
    img_light.image.color   = lv_color_hsv_to_rgb(_hue, 85, 65);
    img_light.image.intense = LV_OPA_80;

    theme.style.img.light = &img_light;
    theme.style.img.dark  = &img_dark;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46f01(%rip), %rdi     # 0x91e30
leaq 0x46ac2(%rip), %rsi     # 0x919f8
callq 0xc550
movl $0xf, %esi
movl $0x55, %edx
movzwl 0x4673c(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46f08(%rip)      # 0x91e68
movb $-0x34, 0x46f03(%rip)   # 0x91e6a
leaq 0x46f0a(%rip), %rdi     # 0x91e78
leaq 0x46a83(%rip), %rsi     # 0x919f8
callq 0xc550
movl $0x55, %esi
movl $0x41, %edx
movzwl 0x466fd(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46ec9(%rip)      # 0x91e68
movb $-0x34, 0x46ec4(%rip)   # 0x91e6a
leaq 0x46e83(%rip), %rax     # 0x91e30
movq %rax, 0x4676c(%rip)     # 0x91720
leaq 0x46ebd(%rip), %rax     # 0x91e78
movq %rax, 0x46766(%rip)     # 0x91728
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: line_init
static void line_init(void)
{
#if LV_USE_LINE != 0
    static lv_style_t line_decor;
    lv_style_copy(&line_decor, &def);
    line_decor.line.color = lv_color_hsv_to_rgb(_hue, 50, 50);
    line_decor.line.width = 1;

    theme.style.line.decor = &line_decor;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46ee1(%rip), %rdi     # 0x91ec0
leaq 0x46a12(%rip), %rsi     # 0x919f8
callq 0xc550
movl $0x32, %edx
movzwl 0x46691(%rip), %edi     # 0x91688
movl %edx, %esi
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46eef(%rip)      # 0x91efc
movw $0x1, 0x46ee8(%rip)     # 0x91efe
leaq 0x46ea3(%rip), %rax     # 0x91ec0
movq %rax, 0x4670c(%rip)     # 0x91730
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: led_init
static void led_init(void)
{
#if LV_USE_LED != 0
    static lv_style_t led;
    lv_style_copy(&led, &lv_style_pretty_color);
    led.body.shadow.width = LV_DPI / 10;
    led.body.radius       = LV_RADIUS_CIRCLE;
    led.body.border.width = LV_DPI / 30;
    led.body.border.opa   = LV_OPA_30;
    led.body.main_color   = lv_color_hsv_to_rgb(_hue, 100, 100);
    led.body.grad_color   = lv_color_hsv_to_rgb(_hue, 100, 40);
    led.body.border.color = lv_color_hsv_to_rgb(_hue, 60, 60);
    led.body.shadow.color = lv_color_hsv_to_rgb(_hue, 100, 100);

    theme.style.led = &led;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46ec9(%rip), %rdi     # 0x91f08
leaq 0x3e07a(%rip), %rsi     # 0x890c0
callq 0xc550
movw $0xa, 0x46ec6(%rip)     # 0x91f1a
movw $0x7c18, 0x46eb1(%rip)  # imm = 0x7C18
movw $0x3, 0x46eae(%rip)     # 0x91f14
movb $0x4c, 0x46eaa(%rip)    # 0x91f17
movl $0x64, %edx
movzwl 0x4660f(%rip), %edi     # 0x91688
movl %edx, %esi
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46e7b(%rip)      # 0x91f0a
movl $0x64, %esi
movl $0x28, %edx
movzwl 0x465e8(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46e58(%rip)      # 0x91f0c
movl $0x3c, %edx
movzwl 0x465c8(%rip), %edi     # 0x91688
movl %edx, %esi
callq 0x45bf0
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, 0x46e3c(%rip)      # 0x91f12
movl $0x64, %edx
movzwl 0x465a6(%rip), %edi     # 0x91688
movl %edx, %esi
callq 0x45bf0
movw %ax, -0x8(%rbp)
movw -0x8(%rbp), %ax
movw %ax, 0x46e20(%rip)      # 0x91f18
leaq 0x46e09(%rip), %rax     # 0x91f08
movq %rax, 0x46632(%rip)     # 0x91738
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: slider_init
static void slider_init(void)
{
#if LV_USE_SLIDER != 0
    lv_style_copy(&slider_knob, &def);
    slider_knob.body.opa          = LV_OPA_60;
    slider_knob.body.radius       = LV_RADIUS_CIRCLE;
    slider_knob.body.main_color   = LV_COLOR_WHITE;
    slider_knob.body.grad_color   = LV_COLOR_SILVER;
    slider_knob.body.border.width = 1;
    slider_knob.body.border.color = LV_COLOR_GRAY;
    slider_knob.body.border.opa   = LV_OPA_50;

    theme.style.slider.bg    = &bar_bg;
    theme.style.slider.indic = &bar_indic;
    theme.style.slider.knob  = &slider_knob;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46e31(%rip), %rdi     # 0x91f50
leaq 0x468d2(%rip), %rsi     # 0x919f8
callq 0xc550
movb $-0x67, 0x46e26(%rip)   # 0x91f58
movw $0x7c18, 0x46e1b(%rip)  # imm = 0x7C18
movw -0x2(%rbp), %ax
andw $-0x20, %ax
orw $0x1f, %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
andw $0xf81f, %ax            # imm = 0xF81F
orw $0x7e0, %ax             # imm = 0x7E0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
andw $0x7ff, %ax             # imm = 0x7FF
orw $0xf800, %ax            # imm = 0xF800
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46ddc(%rip)      # 0x91f52
movw -0x4(%rbp), %ax
andw $-0x20, %ax
orw $0x18, %ax
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
andw $0xf81f, %ax            # imm = 0xF81F
orw $0x600, %ax             # imm = 0x600
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
andw $0x7ff, %ax             # imm = 0x7FF
orw $0xc000, %ax            # imm = 0xC000
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46da3(%rip)      # 0x91f54
movw $0x1, 0x46da2(%rip)     # 0x91f5c
movw -0x6(%rbp), %ax
andw $-0x20, %ax
orw $0x10, %ax
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
andw $0xf81f, %ax            # imm = 0xF81F
orw $0x400, %ax             # imm = 0x400
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
andw $0x7ff, %ax             # imm = 0x7FF
orw $0x8000, %ax            # imm = 0x8000
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, 0x46d65(%rip)      # 0x91f5a
movb $0x7f, 0x46d63(%rip)    # 0x91f5f
leaq 0x46b9d(%rip), %rax     # 0x91da0
movq %rax, 0x46546(%rip)     # 0x91750
leaq 0x46bd7(%rip), %rax     # 0x91de8
movq %rax, 0x46540(%rip)     # 0x91758
leaq 0x46d31(%rip), %rax     # 0x91f50
movq %rax, 0x4653a(%rip)     # 0x91760
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: sw_init
static void sw_init(void)
{
#if LV_USE_SW != 0
    static lv_style_t sw_bg, sw_indic, sw_knob;
    lv_style_copy(&sw_bg, &bar_bg);
    sw_bg.body.opa            = LV_OPA_COVER;
    sw_bg.body.padding.left   = -2;
    sw_bg.body.padding.right  = -2;
    sw_bg.body.padding.top    = -2;
    sw_bg.body.padding.bottom = -2;
    sw_bg.body.main_color     = lv_color_hex3(0x666);
    sw_bg.body.grad_color     = lv_color_hex3(0x999);
    sw_bg.body.border.width   = 2;
    sw_bg.body.border.opa     = LV_OPA_50;

    lv_style_copy(&sw_indic, &bar_indic);
    sw_indic.body.shadow.width   = LV_DPI / 20;
    sw_indic.body.padding.left   = 0;
    sw_indic.body.padding.right  = 0;
    sw_indic.body.padding.top    = 0;
    sw_indic.body.padding.bottom = 0;

    lv_style_copy(&sw_knob, &slider_knob);
    sw_knob.body.opa = LV_OPA_80;

    theme.style.sw.bg       = &sw_bg;
    theme.style.sw.indic    = &sw_indic;
    theme.style.sw.knob_off = &sw_knob;
    theme.style.sw.knob_on  = &sw_knob;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46d59(%rip), %rdi     # 0x91f98
leaq 0x46b5a(%rip), %rsi     # 0x91da0
callq 0xc550
movb $-0x1, 0x46d4e(%rip)    # 0x91fa0
movw $0xfffe, 0x46d57(%rip)  # imm = 0xFFFE
movw $0xfffe, 0x46d50(%rip)  # imm = 0xFFFE
movw $0xfffe, 0x46d41(%rip)  # imm = 0xFFFE
movw $0xfffe, 0x46d3a(%rip)  # imm = 0xFFFE
movl $0x666, %edi            # imm = 0x666
callq 0x4cca0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46d0b(%rip)      # 0x91f9a
movl $0x999, %edi            # imm = 0x999
callq 0x4cca0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46cf4(%rip)      # 0x91f9c
movw $0x2, 0x46cf3(%rip)     # 0x91fa4
movb $0x7f, 0x46cef(%rip)    # 0x91fa7
leaq 0x46d21(%rip), %rdi     # 0x91fe0
leaq 0x46b22(%rip), %rsi     # 0x91de8
callq 0xc550
movw $0x5, 0x46d1e(%rip)     # 0x91ff2
movw $0x0, 0x46d1d(%rip)     # 0x91ffa
movw $0x0, 0x46d16(%rip)     # 0x91ffc
movw $0x0, 0x46d07(%rip)     # 0x91ff6
movw $0x0, 0x46d00(%rip)     # 0x91ff8
leaq 0x46d29(%rip), %rdi     # 0x92028
leaq 0x46c4a(%rip), %rsi     # 0x91f50
callq 0xc550
movb $-0x34, 0x46d1e(%rip)   # 0x92030
leaq 0x46c7f(%rip), %rax     # 0x91f98
movq %rax, 0x46468(%rip)     # 0x91788
leaq 0x46cb9(%rip), %rax     # 0x91fe0
movq %rax, 0x46462(%rip)     # 0x91790
leaq 0x46cf3(%rip), %rax     # 0x92028
movq %rax, 0x4645c(%rip)     # 0x91798
leaq 0x46ce5(%rip), %rax     # 0x92028
movq %rax, 0x46456(%rip)     # 0x917a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: lmeter_init
static void lmeter_init(void)
{
#if LV_USE_LMETER != 0
    lv_style_copy(&lmeter_bg, &def);
    lmeter_bg.body.main_color    = lv_color_hsv_to_rgb(_hue, 10, 70);
    lmeter_bg.body.grad_color    = lv_color_hsv_to_rgb(_hue, 80, 80);
    lmeter_bg.body.padding.left  = LV_DPI / 8; /*Scale line length*/
    lmeter_bg.body.padding.right = LV_DPI / 8; /*Scale line length*/
    lmeter_bg.line.color         = lv_color_hex3(0x222);
    lmeter_bg.line.width         = 2;

    theme.style.lmeter = &lmeter_bg;

#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46d11(%rip), %rdi     # 0x92070
leaq 0x46692(%rip), %rsi     # 0x919f8
callq 0xc550
movl $0xa, %esi
movl $0x46, %edx
movzwl 0x4630c(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46ce2(%rip)      # 0x92072
movl $0x50, %edx
movzwl 0x462ec(%rip), %edi     # 0x91688
movl %edx, %esi
callq 0x45bf0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46cc2(%rip)      # 0x92074
movw $0xc, 0x46ccf(%rip)     # 0x9208a
movw $0xc, 0x46cc8(%rip)     # 0x9208c
movl $0x222, %edi            # imm = 0x222
callq 0x4cca0
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, 0x46ccf(%rip)      # 0x920ac
movw $0x2, 0x46cc8(%rip)     # 0x920ae
leaq 0x46c83(%rip), %rax     # 0x92070
movq %rax, 0x46374(%rip)     # 0x91768
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: gauge_init
static void gauge_init(void)
{
#if LV_USE_GAUGE != 0
    static lv_style_t gauge_bg;
    lv_style_copy(&gauge_bg, &def);
    gauge_bg.body.main_color     = lv_color_hsv_to_rgb(_hue, 10, 70);
    gauge_bg.body.grad_color     = gauge_bg.body.main_color;
    gauge_bg.body.padding.left   = LV_DPI / 16; /*Scale line length*/
    gauge_bg.body.padding.right  = LV_DPI / 16; /*Scale line length*/
    gauge_bg.body.padding.top    = LV_DPI / 10; /*Needle center size*/
    gauge_bg.body.padding.bottom = LV_DPI / 10; /*Needle center size*/
    gauge_bg.body.padding.inner  = LV_DPI / 12; /*Label - scale distance*/
    gauge_bg.body.border.color   = lv_color_hex3(0x777);
    gauge_bg.line.color          = lv_color_hsv_to_rgb(_hue, 80, 75);
    gauge_bg.line.width          = 2;
    gauge_bg.text.color          = lv_color_hsv_to_rgb(_hue, 10, 90);
    gauge_bg.text.font           = _font;

    theme.style.gauge = &gauge_bg;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46ca9(%rip), %rdi     # 0x920b8
leaq 0x465e2(%rip), %rsi     # 0x919f8
callq 0xc550
movl $0xa, %esi
movl $0x46, %edx
movzwl 0x4625c(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46c7a(%rip)      # 0x920ba
movw 0x46c73(%rip), %ax      # 0x920ba
movw %ax, 0x46c6e(%rip)      # 0x920bc
movw $0x6, 0x46c7b(%rip)     # 0x920d2
movw $0x6, 0x46c74(%rip)     # 0x920d4
movw $0xa, 0x46c65(%rip)     # 0x920ce
movw $0xa, 0x46c5e(%rip)     # 0x920d0
movw $0x8, 0x46c5b(%rip)     # 0x920d6
movl $0x777, %edi            # imm = 0x777
callq 0x4cca0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46c2e(%rip)      # 0x920c2
movl $0x50, %esi
movl $0x4b, %edx
movzwl 0x461e3(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, 0x46c3b(%rip)      # 0x920f4
movw $0x2, 0x46c34(%rip)     # 0x920f6
movl $0xa, %esi
movl $0x5a, %edx
movzwl 0x461b5(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x8(%rbp)
movw -0x8(%rbp), %ax
movw %ax, 0x46bf1(%rip)      # 0x920d8
movq 0x461a2(%rip), %rax     # 0x91690
movq %rax, 0x46beb(%rip)     # 0x920e0
leaq 0x46bbc(%rip), %rax     # 0x920b8
movq %rax, 0x4626d(%rip)     # 0x91770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: arc_init
static void arc_init(void)
{
#if LV_USE_ARC != 0

    static lv_style_t arc;
    lv_style_copy(&arc, &def);
    arc.line.width   = 8;
    arc.line.color   = lv_color_hsv_to_rgb(_hue, 70, 90);
    arc.line.rounded = 1;

    /*For preloader*/
    arc.body.border.width   = 2;
    arc.body.border.color   = lv_color_hex3(0x555);
    arc.body.padding.left   = 3;
    arc.body.padding.right  = 3;
    arc.body.padding.top    = 3;
    arc.body.padding.bottom = 3;

    theme.style.arc = &arc;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x46be1(%rip), %rdi     # 0x92100
leaq 0x464d2(%rip), %rsi     # 0x919f8
callq 0xc550
movw $0x8, 0x46c0a(%rip)     # 0x9213e
movl $0x46, %esi
movl $0x5a, %edx
movzwl 0x46143(%rip), %edi     # 0x91688
callq 0x45bf0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
movw %ax, 0x46be3(%rip)      # 0x9213c
movb 0x46be2(%rip), %al      # 0x92141
andb $-0x2, %al
orb $0x1, %al
movb %al, 0x46bd8(%rip)      # 0x92141
movw $0x2, 0x46b9a(%rip)     # 0x9210c
movl $0x555, %edi            # imm = 0x555
callq 0x4cca0
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, 0x46b7f(%rip)      # 0x9210a
movw $0x3, 0x46b86(%rip)     # 0x9211a
movw $0x3, 0x46b7f(%rip)     # 0x9211c
movw $0x3, 0x46b70(%rip)     # 0x92116
movw $0x3, 0x46b69(%rip)     # 0x92118
leaq 0x46b4a(%rip), %rax     # 0x92100
movq %rax, 0x461bb(%rip)     # 0x91778
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: kb_init
static void kb_init(void)
{
#if LV_USE_KB
    theme.style.kb.bg          = &btnm_bg;
    theme.style.kb.btn.rel     = &btnm_rel;
    theme.style.kb.btn.pr      = &btnm_pr;
    theme.style.kb.btn.tgl_rel = &btnm_trel;
    theme.style.kb.btn.tgl_pr  = &btnm_pr;
    theme.style.kb.btn.ina     = &btnm_ina;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x465bd(%rip), %rax     # 0x92418
movq %rax, 0x459ee(%rip)     # 0x91850
leaq 0x465f7(%rip), %rax     # 0x92460
movq %rax, 0x459e8(%rip)     # 0x91858
leaq 0x46631(%rip), %rax     # 0x924a8
movq %rax, 0x459e2(%rip)     # 0x91860
leaq 0x4666b(%rip), %rax     # 0x924f0
movq %rax, 0x459dc(%rip)     # 0x91868
leaq 0x46615(%rip), %rax     # 0x924a8
movq %rax, 0x459d6(%rip)     # 0x91870
leaq 0x46697(%rip), %rax     # 0x92538
movq %rax, 0x459d0(%rip)     # 0x91878
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: mbox_init
static void mbox_init(void)
{
#if LV_USE_MBOX
    static lv_style_t mbox_bg;
    lv_style_copy(&mbox_bg, &panel);
    mbox_bg.body.shadow.width = LV_DPI / 12;

    theme.style.mbox.bg      = &mbox_bg;
    theme.style.mbox.btn.bg  = &lv_style_transp;
    theme.style.mbox.btn.rel = &btn_trel;
    theme.style.mbox.btn.pr  = &btn_tpr;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x466c5(%rip), %rdi     # 0x92580
leaq 0x45c0e(%rip), %rsi     # 0x91ad0
callq 0xc550
movw $0x8, 0x466c2(%rip)     # 0x92592
leaq 0x466a9(%rip), %rax     # 0x92580
movq %rax, 0x459a2(%rip)     # 0x91880
leaq 0x3d223(%rip), %rax     # 0x89108
movq %rax, 0x4599c(%rip)     # 0x91888
leaq 0x45cfd(%rip), %rax     # 0x91bf0
movq %rax, 0x45996(%rip)     # 0x91890
leaq 0x45d37(%rip), %rax     # 0x91c38
movq %rax, 0x45990(%rip)     # 0x91898
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_themes/lv_theme_alien.c
// Function: ta_init
static void ta_init(void)
{
#if LV_USE_TA
    theme.style.ta.area    = &panel;
    theme.style.ta.oneline = &panel;
    theme.style.ta.cursor  = NULL;
    theme.style.ta.sb      = &sb;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x45b85(%rip), %rax     # 0x91ad0
movq %rax, 0x45966(%rip)     # 0x918b8
leaq 0x45b77(%rip), %rax     # 0x91ad0
movq %rax, 0x45960(%rip)     # 0x918c0
movq $0x0, 0x4595d(%rip) # 0x918c8
leaq 0x45ba6(%rip), %rax     # 0x91b18
movq %rax, 0x45957(%rip)     # 0x918d0
popq %rbp
retq
nopl (%rax,%rax)