LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: dofile
static void dofile(char *fname, FILE * fin, aa * tree, bool bylen)
{
    char *ln, *lnl;
    ll *lln;

    while (fggets(&ln, fin) == 0) {
#ifdef DEBUG
        printf("read: %s\n", ln);
#endif

        if (bylen) {
            if (asprintf
                (&lnl, "%llu:%s", (unsigned long long int) strlen(ln),
                 ln) == -1) {
                free(ln);
                error(tree);
            }

            free(ln);
            ln = lnl;
#ifdef DEBUG
            printf("%s\n", ln);
#endif
        }

        if ((lln = new_node(1, ln, NULL)) == NULL) {
            free(ln);
            error(tree);
        }

        switch (aa_add(tree, (void *) lln, duplicate)) {
        case 0:                /* no error */
            break;
        case 2:                /* memory error */
            free(ln);
            free(lln);
            error(tree);
            break;
        default:               /* can't happen */
            fprintf(stderr, "can't happen\n");
            free(ln);
            free(lln);
            cleanup(tree);
            exit(EXIT_FAILURE);
            break;
        }
    }

    if (ferror(fin) != 0)
        handle_ferr(fname, "sort2");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rsp, %r12
leaq 0x38b(%rip), %r13       # 0x2679
movq %r12, %rdi
movq %r15, %rsi
callq 0x13cc
testl %eax, %eax
jne 0x2386
movq (%rsp), %r14
testb %bpl, %bpl
je 0x2346
movq %r14, %rdi
callq 0x1090
leaq 0x10(%rsp), %rdi
leaq 0xe26(%rip), %rsi       # 0x3144
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1d90
movl %eax, %r14d
movq (%rsp), %rdi
callq 0x1030
cmpl $-0x1, %r14d
je 0x23bb
movq 0x10(%rsp), %r14
movq %r14, (%rsp)
movl $0x1, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1ecc
testq %rax, %rax
je 0x23b2
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x14e0
testl %eax, %eax
je 0x22ee
cmpl $0x2, %eax
jne 0x23c3
movq (%rsp), %rdi
callq 0x1030
movq %r14, %rdi
jmp 0x23b6
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
je 0x23a3
leaq 0xda5(%rip), %rsi       # 0x313e
movq 0x8(%rsp), %rdi
callq 0x11c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x2643
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x128c
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: printall
static void *printall(void *data)
{
    ll *node = (ll *) data;
    char *ln;
    int n;

    n = get_tag(node);
    ln = get_data(node);
    while (n-- > 0)
        puts(ln);

    return data;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1e2e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1e47
testl %ebp, %ebp
jle 0x23ff
movq %rax, %r14
incl %ebp
movq %r14, %rdi
callq 0x1050
decl %ebp
cmpl $0x1, %ebp
ja 0x23f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: usage
static void usage(char *pname)
{
    printf("Usage: %s [OPTION] [FILE...]\n", pname);
    puts("Sort files or, if no files on the command line, sort stdin.");
    puts("Multiple sorting criteria can be combined.");
    puts("All files sorted together into one output.");
    puts("");
    puts("  -u, --uniqify     Only print identical lines once");
    puts("  -r, --reverse     Reverse the sense of the comparison");
    puts("  -n, --numer       Sort numerically, then non-numerically");
    puts("  -b, --bylen       Sort by length first, then by other critera");
    puts("  -h, --help        Print this help");
    puts("  -v, --version     Print version information");
    puts("");
    puts("Report bugs to <chbarts@gmail.com>.");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0xd3b(%rip), %rdi       # 0x3168
xorl %eax, %eax
callq 0x10c0
leaq 0xd4b(%rip), %rdi       # 0x3186
callq 0x1050
leaq 0xd7b(%rip), %rdi       # 0x31c2
callq 0x1050
leaq 0xd9a(%rip), %rdi       # 0x31ed
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xdaf(%rip), %rdi       # 0x3218
callq 0x1050
leaq 0xdd7(%rip), %rdi       # 0x324c
callq 0x1050
leaq 0xe03(%rip), %rdi       # 0x3284
callq 0x1050
leaq 0xe32(%rip), %rdi       # 0x32bf
callq 0x1050
leaq 0xe66(%rip), %rdi       # 0x32ff
callq 0x1050
leaq 0xe7e(%rip), %rdi       # 0x3323
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xe96(%rip), %rdi       # 0x3351
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: version
static void version(void)
{
    puts("sort2 version 0.1.0");
    puts("Copyright 2014 Chris Barts.");
    puts("sort2 comes with NO WARRANTY to the extent permitted by law.");
    puts("You may redistribute this software under the terms");
    puts("of the GNU General Public License.");
    puts("For more information, see the file named COPYING");
    puts("in this program's distribution file.");
}

// Assembly:
pushq %rax
leaq 0xeac(%rip), %rdi       # 0x3375
callq 0x1050
leaq 0xeb4(%rip), %rdi       # 0x3389
callq 0x1050
leaq 0xec4(%rip), %rdi       # 0x33a5
callq 0x1050
leaq 0xef5(%rip), %rdi       # 0x33e2
callq 0x1050
leaq 0xf1c(%rip), %rdi       # 0x3415
callq 0x1050
leaq 0xf33(%rip), %rdi       # 0x3438
callq 0x1050
leaq 0xf58(%rip), %rdi       # 0x3469
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: lncomparator
static int lncomparator(void *left, void *right)
{
    ll *l = (ll *) left, *r = (ll *) right;
    unsigned long long int ln, rn;
    char *ls, *rs, *cro, *clo;
    int res = 0;

    ls = (char *) get_data(l);
    rs = (char *) get_data(r);

    ln = strtoll(ls, &clo, 10);
    rn = strtoll(rs, &cro, 10);

    if (ln < rn) {
        res = -1;
    } else if (ln > rn) {
        res = 1;
    } else {
        return sncomp(clo + 1, cro + 1);
    }

    return (rev * res);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x1e47
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e47
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0x1100
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x1100
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
jb 0x256f
movl $0x1, %eax
jbe 0x257e
imull 0x3b76(%rip), %eax      # 0x60ec
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rsp), %rdi
incq %rdi
movq 0x10(%rsp), %rsi
incq %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x26d2
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: lprintall
static void *lprintall(void *data)
{
    ll *node = (ll *) data;
    char *ln, *lno;
    int n;

    ln = get_data(node);
    lno = strchr(ln, ':') + 1;
    n = get_tag(data);
    while (n-- > 0)
        puts(lno);

    return data;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1e47
movq %rax, %rdi
movl $0x3a, %esi
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e2e
testl %eax, %eax
jle 0x2625
movl %eax, %ebp
incq %r14
incl %ebp
movq %r14, %rdi
callq 0x1050
decl %ebp
cmpl $0x1, %ebp
ja 0x2616
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: duplicate
static int duplicate(void *orig, void *new)
{
    int n;
    ll *node = (ll *) orig, *node2 = (ll *) new;
    char *ln;

    n = get_tag(node);
    set_tag(node, n + 1);
    ln = get_data(node2);
    free(ln);
    free(node2);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e2e
leal 0x1(%rax), %esi
movq %r14, %rdi
callq 0x1e3c
movq %rbx, %rdi
callq 0x1e47
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: freedata
static void *freedata(void *data)
{
    ll *node = (ll *) data;
    char *ln;

    ln = get_data(node);
    free(ln);
    free(node);
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1e47
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/chbarts[P]aa-tree/sort2.c
// Function: sncomp
static int sncomp(char *left, char *right)
{
    long long int nl, nr;
    char *clo, *cro;
    int r = 0;

    nl = strtoll(left, &clo, 10);
    nr = strtoll(right, &cro, 10);

    if (nl < nr) {
        r = -1;
    } else if (nl > nr) {
        r = 1;
    } else {
        r = strcmp(clo, cro);

        if (r < 0) {
            r = -1;
        } else if (r > 0) {
            r = 1;
        }
    }

    return (rev * r);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %rsi
movl $0xa, %edx
callq 0x1100
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x1100
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
jl 0x2734
movl $0x1, %eax
jg 0x2734
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10f0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x2734
setne %al
movzbl %al, %eax
imull 0x39b1(%rip), %eax      # 0x60ec
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/main.c
// Function: main
int main(int argc, char *argv[]) {
  
  printf("lv_init\n");
  /*LittlevGL init*/
  lv_init();
  
  /*Linux frame buffer device init*/
  fbdev_init();

  /*A small buffer for LittlevGL to draw the screen's content*/
  static lv_color_t buf[DISP_BUF_SIZE];

  /*Initialize a descriptor for the buffer*/
  static lv_disp_buf_t disp_buf;
  lv_disp_buf_init(&disp_buf, buf, NULL, DISP_BUF_SIZE);

  /*Initialize and register a display driver*/
  lv_disp_drv_t disp_drv;
  lv_disp_drv_init(&disp_drv);
  disp_drv.buffer = &disp_buf;
  disp_drv.flush_cb = fbdev_flush;
  lv_disp_drv_register(&disp_drv);
  
  /*Initialize and register an input device*/
  lv_indev_drv_t indev_drv;
  lv_indev_drv_init(&indev_drv);             /*Descriptor of a input device driver*/
  indev_drv.type = LV_INDEV_TYPE_POINTER;    /*Touch pad is a pointer-like device*/
  indev_drv.read_cb = xpt7603_read;      /*Set your driver function*/
  lv_indev_drv_register(&indev_drv);         /*Finally register the driver*/
  
  /* Demo Code - replace this with yours */
  /*Create a "Hello world!" label*/
  lv_obj_t * label = lv_label_create(lv_scr_act(), NULL);
  lv_label_set_text(label, "Hello world!");
  lv_obj_align(label, NULL, LV_ALIGN_IN_TOP_MID, 0, 0);
  
  /*Create a button*/
  lv_obj_t * btnLabel;

  lv_obj_t * btn1 = lv_btn_create(lv_scr_act(), NULL);
  lv_obj_set_event_cb(btn1, event_handler);
  lv_obj_align(btn1, NULL, LV_ALIGN_CENTER, 0, 0);

  btnLabel = lv_label_create(btn1, NULL);
  lv_label_set_text(btnLabel, "Press Me");
  
  printf("starting loop\n");
  while(1) {
    lv_tick_inc(5);
    lv_task_handler();
    usleep(5000);
  }
  
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x3cde0(%rip), %rdi     # 0x3f01a
callq 0x2050
callq 0x44e0
callq 0x3e924
leaq 0x5dc20(%rip), %rbx     # 0x5fe70
leaq 0x51419(%rip), %rsi     # 0x53670
movq %rbx, %rdi
xorl %edx, %edx
movl $0x6400, %ecx           # imm = 0x6400
callq 0x830f
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x82ec
movq %rbx, 0x8(%r14)
leaq 0x3c7bf(%rip), %rax     # 0x3ea3d
movq %rax, 0x18(%r14)
movq %r14, %rdi
callq 0x8325
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x865c
movb $0x1, (%rbx)
leaq 0x3cb96(%rip), %rax     # 0x3ee37
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x8678
callq 0x8585
movq %rax, %rdi
callq 0x43c0
movq %rax, %rdi
xorl %esi, %esi
callq 0x19ed4
movq %rax, %rbx
leaq 0x3cd36(%rip), %rsi     # 0x3f004
movq %rax, %rdi
callq 0x1a6da
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5789
callq 0x8585
movq %rax, %rdi
callq 0x43c0
movq %rax, %rdi
xorl %esi, %esi
callq 0x13104
movq %rax, %rbx
leaq 0x59(%rip), %rsi        # 0x2364
movq %rax, %rdi
callq 0x6363
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5789
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19ed4
leaq 0x3ccdc(%rip), %rsi     # 0x3f011
movq %rax, %rdi
callq 0x1a6da
leaq 0x3ccde(%rip), %rdi     # 0x3f022
callq 0x2050
movl $0x5, %edi
callq 0x87a8
callq 0x28e4b
movl $0x1388, %edi           # imm = 0x1388
callq 0x2120
jmp 0x2349
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_create
lv_group_t * lv_group_create(void)
{
    lv_group_t * group = lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
    LV_ASSERT_MEM(group);
    if(group == NULL) return NULL;
    lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));

    group->obj_focus      = NULL;
    group->frozen         = 0;
    group->focus_cb       = NULL;
    group->click_focus    = 1;
    group->editing        = 0;
    group->refocus_policy = LV_GROUP_REFOCUS_POLICY_PREV;
    group->wrap           = 1;

#if LV_USE_USER_DATA
    memset(&group->user_data, 0, sizeof(lv_group_user_data_t));
#endif

    /*Initialize style modification callbacks from current theme*/
    refresh_theme(group, lv_theme_get_current());

    return group;
}

// Assembly:
pushq %rbx
leaq 0x661cf(%rip), %rdi     # 0x68570
callq 0x2a2a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x2428
testq %rbx, %rbx
je 0x2423
movq %rbx, %rdi
movl $0x8, %esi
callq 0x2a290
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movb 0x80(%rbx), %cl
movq %rax, 0x30(%rbx)
andb $-0x20, %cl
orb $0x1c, %cl
movb %cl, 0x80(%rbx)
callq 0x2e91c
leaq 0x81f(%rip), %rcx       # 0x2c0e
movq %rcx, 0x20(%rbx)
leaq 0x94e(%rip), %rcx       # 0x2d48
movq %rcx, 0x28(%rbx)
testq %rax, %rax
je 0x2423
movq 0x350(%rax), %rcx
testq %rcx, %rcx
je 0x2413
movq %rcx, 0x20(%rbx)
movq 0x358(%rax), %rax
testq %rax, %rax
je 0x2423
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x3cca1(%rip), %rdi     # 0x3f0d0
movq %rbx, %rsi
callq 0x8294
jmp 0x2437
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_del
void lv_group_del(lv_group_t * group)
{
    /*Defocus the the currently focused object*/
    if(group->obj_focus != NULL) {
        (*group->obj_focus)->signal_cb(*group->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        lv_obj_invalidate(*group->obj_focus);
    }

    /*Remove the objects from the group*/
    lv_obj_t ** obj;
    LV_LL_READ(group->obj_ll, obj)
    {
        (*obj)->group_p = NULL;
    }

    lv_ll_clear(&(group->obj_ll));
    lv_ll_rem(&LV_GC_ROOT(_lv_group_ll), group);
    lv_mem_free(group);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x245f
movq (%rax), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x2484
movq (%rax), %rcx
movq $0x0, 0x50(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a448
jmp 0x2467
movq %rbx, %rdi
callq 0x2a465
leaq 0x660dd(%rip), %rdi     # 0x68570
movq %rbx, %rsi
callq 0x2a3c2
movq %rbx, %rdi
popq %rbx
jmp 0x2a006
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_add_obj
void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
{
    if(group == NULL) return;

    /*Do not add the object twice*/
    lv_obj_t ** obj_i;
    LV_LL_READ(group->obj_ll, obj_i)
    {
        if((*obj_i) == obj) {
            LV_LOG_INFO("lv_group_add_obj: the object is already added to this group");
            return;
        }
    }

    /*If the object is already in a group and focused then defocus it*/
    if(obj->group_p) {
        if(lv_obj_is_focused(obj)) {
            lv_group_refocus(obj->group_p);

            LV_LOG_INFO("lv_group_add_obj: assign object to an other group");
        }
    }

    obj->group_p     = group;
    lv_obj_t ** next = lv_ll_ins_tail(&group->obj_ll);
    LV_ASSERT_MEM(next);
    if(next == NULL) return;
    *next = obj;

    /* If the head and the tail is equal then there is only one object in the linked list.
     * In this case automatically activate it*/
    if(lv_ll_get_head(&group->obj_ll) == next) {
        lv_group_refocus(group);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x251c
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2a35c
testq %rax, %rax
je 0x24d0
cmpq %r14, (%rax)
je 0x251c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a448
jmp 0x24b9
cmpq $0x0, 0x50(%r14)
je 0x24ec
movq %r14, %rdi
callq 0x6bc9
testb %al, %al
je 0x24ec
movq 0x50(%r14), %rdi
callq 0x253d
movq %rbx, 0x50(%r14)
movq %rbx, %rdi
callq 0x2a378
movq %rax, %r15
movq %rax, %rdi
callq 0x80e4
testb %al, %al
je 0x2522
testq %r15, %r15
je 0x251c
movq %r14, (%r15)
movq %rbx, %rdi
callq 0x2a35c
cmpq %r15, %rax
je 0x2533
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3cba7(%rip), %rdi     # 0x3f0d0
movq %r15, %rsi
callq 0x8294
jmp 0x2531
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x253d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_refocus
static void lv_group_refocus(lv_group_t * g)
{
    /*Refocus must temporarily allow wrapping to work correctly*/
    uint8_t temp_wrap = g->wrap;
    g->wrap           = 1;

    if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_NEXT)
        lv_group_focus_next(g);
    else if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_PREV)
        lv_group_focus_prev(g);
    /*Restore wrap property*/
    g->wrap = temp_wrap;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x80(%rdi), %bpl
movl %ebp, %eax
orb $0x10, %al
movb %al, 0x80(%rdi)
testb $0x8, %bpl
jne 0x256a
leaq 0x27dfb(%rip), %rsi     # 0x2a35c
leaq 0x27ee0(%rip), %rdx     # 0x2a448
jmp 0x2578
leaq 0x27ee7(%rip), %rsi     # 0x2a458
leaq 0x27df1(%rip), %rdx     # 0x2a369
movq %rbx, %rdi
callq 0x285e
andb $0x10, %bpl
movb 0x80(%rbx), %al
andb $-0x11, %al
orb %bpl, %al
movb %al, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_remove_obj
void lv_group_remove_obj(lv_obj_t * obj)
{
    lv_group_t * g = obj->group_p;
    if(g == NULL) return;
    if(g->obj_focus == NULL) return; /*Just to be sure (Not possible if there is at least one object in the group)*/

    /*Focus on the next object*/
    if(*g->obj_focus == obj) {
        /*If this is the only object in the group then focus to nothing.*/
        if(lv_ll_get_head(&g->obj_ll) == g->obj_focus && lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
            (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        }
        /*If there more objects in the group then focus to the next/prev object*/
        else {
            lv_group_refocus(g);
        }
    }

    /* If the focuses object is still the same then it was the only object in the group but it will
     * be deleted. Set the `obj_focus` to NULL to get back to the initial state of the group with
     * zero objects*/
    if(*g->obj_focus == obj) {
        g->obj_focus = NULL;
    }

    /*Search the object and remove it from its group */
    lv_obj_t ** i;
    LV_LL_READ(g->obj_ll, i)
    {
        if(*i == obj) {
            lv_ll_rem(&g->obj_ll, i);
            lv_mem_free(i);
            obj->group_p = NULL;
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x2640
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x2640
movq %rdi, %rbx
cmpq %rdi, (%rax)
jne 0x25ea
movq %r14, %rdi
callq 0x2a35c
cmpq 0x18(%r14), %rax
jne 0x25e2
movq %r14, %rdi
callq 0x2a458
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
je 0x2646
movq %r14, %rdi
callq 0x253d
movq 0x18(%r14), %rax
cmpq %rbx, (%rax)
jne 0x25fb
movq $0x0, 0x18(%r14)
movq %r14, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x2640
movq %rax, %r15
cmpq %rbx, (%r15)
je 0x2625
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a448
movq %rax, %r15
testq %rax, %rax
jne 0x260b
jmp 0x2640
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a3c2
movq %r15, %rdi
callq 0x2a006
movq $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq (%rcx), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
jmp 0x25ea
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_remove_all_objs
void lv_group_remove_all_objs(lv_group_t * group)
{
    /*Defocus the the currently focused object*/
    if(group->obj_focus != NULL) {
        (*group->obj_focus)->signal_cb(*group->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
        lv_obj_invalidate(*group->obj_focus);
        group->obj_focus = NULL;
    }

    /*Remove the objects from the group*/
    lv_obj_t ** obj;
    LV_LL_READ(group->obj_ll, obj)
    {
        (*obj)->group_p = NULL;
    }

    lv_ll_clear(&(group->obj_ll));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2683
movq (%rax), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c4d
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x26a8
movq (%rax), %rcx
movq $0x0, 0x50(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a448
jmp 0x268b
movq %rbx, %rdi
popq %rbx
jmp 0x2a465
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_focus_obj
void lv_group_focus_obj(lv_obj_t * obj)
{
    if(obj == NULL) return;
    lv_group_t * g = obj->group_p;
    if(g == NULL) return;

    if(g->frozen != 0) return;

    /*On defocus edit mode must be leaved*/
    lv_group_set_editing(g, false);

    lv_obj_t ** i;
    LV_LL_READ(g->obj_ll, i)
    {
        if(*i == obj) {
            if(g->obj_focus != NULL) {
                (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
                lv_res_t res = lv_event_send(*g->obj_focus, LV_EVENT_DEFOCUSED, NULL);
                if(res != LV_RES_OK) return;
                lv_obj_invalidate(*g->obj_focus);
            }

            g->obj_focus = i;

            if(g->obj_focus != NULL) {
                (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_FOCUS, NULL);
                if(g->focus_cb) g->focus_cb(g);
                lv_res_t res = lv_event_send(*g->obj_focus, LV_EVENT_FOCUSED, NULL);
                if(res != LV_RES_OK) return;
                lv_obj_invalidate(*g->obj_focus);

                /*If the object or its parent has `top == true` bring it to the foregorund*/
                obj_to_foreground(*g->obj_focus);
            }
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x27a0
movq %rdi, %r15
movq 0x50(%rdi), %rbx
testq %rbx, %rbx
je 0x27a0
testb $0x1, 0x80(%rbx)
jne 0x27a0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x27a6
movq %rbx, %rdi
callq 0x2a35c
testq %rax, %rax
je 0x27a0
movq %rax, %r14
cmpq %r15, (%r14)
je 0x2717
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a448
movq %rax, %r14
testq %rax, %rax
jne 0x26fa
jmp 0x27a0
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x2750
movq (%rax), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x5018
cmpb $0x1, %al
jne 0x27a0
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c4d
movq %r14, 0x18(%rbx)
movq (%r14), %rdi
movl $0x10, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x276f
movq %rbx, %rdi
callq *%rax
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl $0xc, %esi
xorl %edx, %edx
callq 0x5018
cmpb $0x1, %al
jne 0x27a0
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c4d
movq 0x18(%rbx), %rax
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x281b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_set_editing
void lv_group_set_editing(lv_group_t * group, bool edit)
{
    uint8_t en_val = edit ? 1 : 0;

    if(en_val == group->editing) return; /*Do not set the same mode again*/

    group->editing     = en_val;
    lv_obj_t * focused = lv_group_get_focused(group);

    if(focused) {
        focused->signal_cb(focused, LV_SIGNAL_FOCUS, NULL); /*Focus again to properly leave/open edit/navigate mode*/
        lv_res_t res = lv_event_send(*group->obj_focus, LV_EVENT_FOCUSED, NULL);
        if(res != LV_RES_OK) return;
    }

    lv_obj_invalidate(focused);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb 0x80(%rdi), %al
testb $0x2, %al
sete %cl
xorb %sil, %cl
je 0x27c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
addb %sil, %sil
andb $-0x3, %al
orb %sil, %al
movb %al, 0x80(%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x280a
movq (%rax), %rbx
testq %rbx, %rbx
je 0x280a
movq %rbx, %rdi
movl $0x10, %esi
xorl %edx, %edx
callq *0x30(%rbx)
movq 0x18(%r14), %rax
movq (%rax), %rdi
movl $0xc, %esi
xorl %edx, %edx
callq 0x5018
cmpb $0x1, %al
jne 0x27ba
jmp 0x280c
xorl %ebx, %ebx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4c4d
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: obj_to_foreground
static void obj_to_foreground(lv_obj_t * obj)
{
    /*Search for 'top' attribute*/
    lv_obj_t * i        = obj;
    lv_obj_t * last_top = NULL;
    while(i != NULL) {
        if(i->top != 0) last_top = i;
        i = lv_obj_get_parent(i);
    }

    if(last_top != NULL) {
        /*Move the last_top object to the foreground*/
        lv_obj_move_foreground(last_top);
    }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x284c
movq %rdi, %rax
xorl %ebx, %ebx
movzwl 0x58(%rax), %ecx
testb $0x20, %cl
cmovneq %rax, %rbx
movq %rax, %rdi
callq 0x4ab5
testq %rax, %rax
jne 0x2826
testq %rbx, %rbx
je 0x284c
movq %rbx, %rdi
popq %rbx
jmp 0x5338
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_send_data
lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c)
{
    lv_obj_t * act = lv_group_get_focused(group);
    if(act == NULL) return LV_RES_OK;

    lv_res_t res;

    res = act->signal_cb(act, LV_SIGNAL_CONTROL, &c);
    if(res != LV_RES_OK) return res;

    res = lv_event_send(act, LV_EVENT_KEY, &c);
    if(res != LV_RES_OK) return res;

    return res;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movb $0x1, %al
testq %rdi, %rdi
je 0x2a13
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x2a13
movq (%rcx), %rbx
testq %rbx, %rbx
je 0x2a13
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x12, %esi
callq *0x30(%rbx)
cmpb $0x1, %al
jne 0x2a13
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0xb, %esi
callq 0x5018
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_mod_style
lv_style_t * lv_group_mod_style(lv_group_t * group, const lv_style_t * style)
{
    /*Load the current style. It will be modified by the callback*/
    lv_style_copy(&group->style_tmp, style);

    if(group->editing) {
        if(group->style_mod_edit_cb) group->style_mod_edit_cb(group, &group->style_tmp);
    } else {
        if(group->style_mod_cb) group->style_mod_cb(group, &group->style_tmp);
    }
    return &group->style_tmp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x799d
testb $0x2, 0x80(%r14)
jne 0x2ac8
movq 0x20(%r14), %rax
jmp 0x2acc
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x2ad9
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: lv_group_report_style_mod
void lv_group_report_style_mod(lv_group_t * group)
{
    lv_theme_t * th = lv_theme_get_current();

    if(group != NULL) {
        refresh_theme(group, th);
        return;
    }

    lv_group_t * i;
    LV_LL_READ(LV_GC_ROOT(_lv_group_ll), i)
    {
        refresh_theme(i, th);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2e91c
movq %rax, %rbx
testq %r14, %r14
je 0x2b9f
leaq 0xa9(%rip), %rax        # 0x2c0e
movq %rax, 0x20(%r14)
leaq 0x1d8(%rip), %rax       # 0x2d48
movq %rax, 0x28(%r14)
testq %rbx, %rbx
je 0x2c02
movq 0x350(%rbx), %rax
testq %rax, %rax
je 0x2b8d
movq %rax, 0x20(%r14)
movq 0x358(%rbx), %rax
testq %rax, %rax
je 0x2c02
movq %rax, 0x28(%r14)
jmp 0x2c02
leaq 0x659ca(%rip), %rdi     # 0x68570
callq 0x2a35c
testq %rax, %rax
je 0x2c02
leaq 0x57(%rip), %r15        # 0x2c0e
leaq 0x18a(%rip), %r12       # 0x2d48
leaq 0x659ab(%rip), %r14     # 0x68570
movq %r15, 0x20(%rax)
movq %r12, 0x28(%rax)
testq %rbx, %rbx
je 0x2bf2
movq 0x350(%rbx), %rcx
testq %rcx, %rcx
je 0x2be2
movq %rcx, 0x20(%rax)
movq 0x358(%rbx), %rcx
testq %rcx, %rcx
je 0x2bf2
movq %rcx, 0x28(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a448
testq %rax, %rax
jne 0x2bc5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: style_mod_def
static void style_mod_def(lv_group_t * group, lv_style_t * style)
{
    (void)group; /*Unused*/
#if LV_COLOR_DEPTH != 1

    /*Make the style to be a little bit orange*/
    style->body.border.opa   = LV_OPA_COVER;
    style->body.border.color = LV_COLOR_ORANGE;

    /*If not transparent or has border then emphasis the border*/
    if(style->body.opa != LV_OPA_TRANSP || style->body.border.width != 0) style->body.border.width = LV_DPI / 20;

    style->body.main_color   = lv_color_mix(style->body.main_color, LV_COLOR_ORANGE, LV_OPA_70);
    style->body.grad_color   = lv_color_mix(style->body.grad_color, LV_COLOR_ORANGE, LV_OPA_70);
    style->body.shadow.color = lv_color_mix(style->body.shadow.color, LV_COLOR_ORANGE, LV_OPA_60);

    style->text.color = lv_color_mix(style->text.color, LV_COLOR_ORANGE, LV_OPA_70);

    /*Add some recolor to the images*/
    if(style->image.intense < LV_OPA_MIN) {
        style->image.color   = LV_COLOR_ORANGE;
        style->image.intense = LV_OPA_40;
    }
#else
    style->body.border.opa   = LV_OPA_COVER;
    style->body.border.color = LV_COLOR_BLACK;
    style->body.border.width = 2;

#endif
}

// Assembly:
movb $-0x1, 0xf(%rsi)
movw $0xfd20, 0xa(%rsi)      # imm = 0xFD20
cmpb $0x0, 0x8(%rsi)
jne 0x2c25
cmpw $0x0, 0xc(%rsi)
je 0x2c2b
movw $0x5, 0xc(%rsi)
movd 0x2(%rsi), %xmm0
movdqa %xmm0, %xmm1
psrlw $0xb, %xmm1
pmullw 0x3c3ff(%rip), %xmm1    # 0x3f040
paddw 0x3c407(%rip), %xmm1    # 0x3f050
pand 0x3c40f(%rip), %xmm1    # 0x3f060
movdqa %xmm0, %xmm2
psrlw $0x5, %xmm2
pand 0x3c40e(%rip), %xmm2    # 0x3f070
movdqa 0x3c416(%rip), %xmm3    # 0x3f080
pmullw %xmm3, %xmm2
paddw 0x3c41a(%rip), %xmm2    # 0x3f090
psrlw $0x3, %xmm2
pand 0x3c41d(%rip), %xmm2    # 0x3f0a0
pand 0x3c425(%rip), %xmm0    # 0x3f0b0
pmullw %xmm3, %xmm0
psrlw $0x8, %xmm0
por %xmm1, %xmm0
por %xmm2, %xmm0
movd %xmm0, 0x2(%rsi)
movzwl 0x10(%rsi), %edx
movl %edx, %eax
shrl $0xb, %eax
imull $0x4c8, %eax, %edi      # imm = 0x4C8
addl $0x62d0, %edi           # imm = 0x62D0
movl $0xf800, %eax           # imm = 0xF800
andl %eax, %edi
movl %edx, %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
imull $0x99, %ecx, %r8d
addl $0x1056, %r8d           # imm = 0x1056
shrl $0x3, %r8d
movl $0x7e0, %ecx            # imm = 0x7E0
andl %ecx, %r8d
andl $0x1f, %edx
imull $0x99, %edx, %edx
shrl $0x8, %edx
orl %edi, %edx
orl %r8d, %edx
movw %dx, 0x10(%rsi)
movzwl 0x20(%rsi), %edx
movl %edx, %edi
shrl $0xb, %edi
imull $0x590, %edi, %edi      # imm = 0x590
addl $0x4a98, %edi           # imm = 0x4A98
andl %eax, %edi
movl %edx, %eax
shrl $0x5, %eax
andl $0x3f, %eax
imull $0xb2, %eax, %eax
addl $0xc55, %eax            # imm = 0xC55
shrl $0x3, %eax
andl %ecx, %eax
andl $0x1f, %edx
imull $0xb2, %edx, %ecx
shrl $0x8, %ecx
orl %edi, %ecx
orl %eax, %ecx
movw %cx, 0x20(%rsi)
cmpb $0xf, 0x3a(%rsi)
ja 0x2d47
movw $0xfd20, 0x38(%rsi)     # imm = 0xFD20
movb $0x66, 0x3a(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_group.c
// Function: style_mod_edit_def
static void style_mod_edit_def(lv_group_t * group, lv_style_t * style)
{
    (void)group; /*Unused*/
#if LV_COLOR_DEPTH != 1

    /*Make the style to be a little bit orange*/
    style->body.border.opa   = LV_OPA_COVER;
    style->body.border.color = LV_COLOR_GREEN;

    /*If not empty or has border then emphasis the border*/
    if(style->body.opa != LV_OPA_TRANSP || style->body.border.width != 0) style->body.border.width = LV_DPI / 20;

    style->body.main_color   = lv_color_mix(style->body.main_color, LV_COLOR_GREEN, LV_OPA_70);
    style->body.grad_color   = lv_color_mix(style->body.grad_color, LV_COLOR_GREEN, LV_OPA_70);
    style->body.shadow.color = lv_color_mix(style->body.shadow.color, LV_COLOR_GREEN, LV_OPA_60);

    style->text.color = lv_color_mix(style->text.color, LV_COLOR_GREEN, LV_OPA_70);

    /*Add some recolor to the images*/
    if(style->image.intense < LV_OPA_MIN) {
        style->image.color   = LV_COLOR_GREEN;
        style->image.intense = LV_OPA_40;
    }

#else
    style->body.border.opa   = LV_OPA_COVER;
    style->body.border.color = LV_COLOR_BLACK;
    style->body.border.width = 3;

#endif
}

// Assembly:
movb $-0x1, 0xf(%rsi)
movw $0x400, 0xa(%rsi)       # imm = 0x400
cmpb $0x0, 0x8(%rsi)
jne 0x2d5f
cmpw $0x0, 0xc(%rsi)
je 0x2d65
movw $0x5, 0xc(%rsi)
movd 0x2(%rsi), %xmm0
movdqa %xmm0, %xmm1
psrlw $0xb, %xmm1
pmullw 0x3c2c5(%rip), %xmm1    # 0x3f040
pand 0x3c2dd(%rip), %xmm1    # 0x3f060
movdqa %xmm0, %xmm2
psrlw $0x5, %xmm2
pand 0x3c2dc(%rip), %xmm2    # 0x3f070
movdqa 0x3c2e4(%rip), %xmm3    # 0x3f080
pmullw %xmm3, %xmm2
paddw 0x3c318(%rip), %xmm2    # 0x3f0c0
psrlw $0x3, %xmm2
pand 0x3c2eb(%rip), %xmm2    # 0x3f0a0
pand 0x3c2f3(%rip), %xmm0    # 0x3f0b0
pmullw %xmm3, %xmm0
psrlw $0x8, %xmm0
por %xmm1, %xmm0
por %xmm2, %xmm0
movd %xmm0, 0x2(%rsi)
movzwl 0x10(%rsi), %ecx
movl %ecx, %eax
shrl $0xb, %eax
imull $0x4c8, %eax, %edx      # imm = 0x4C8
movl $0xf800, %eax           # imm = 0xF800
andl %eax, %edx
movl %ecx, %edi
shrl $0x5, %edi
andl $0x3f, %edi
imull $0x99, %edi, %edi
addl $0xcc0, %edi            # imm = 0xCC0
shrl $0x3, %edi
movl $0x7e0, %r8d            # imm = 0x7E0
andl %r8d, %edi
andl $0x1f, %ecx
imull $0x99, %ecx, %ecx
shrl $0x8, %ecx
orl %edx, %ecx
orl %edi, %ecx
movw %cx, 0x10(%rsi)
movzwl 0x20(%rsi), %ecx
movl %ecx, %edx
shrl $0xb, %edx
imull $0x590, %edx, %edx      # imm = 0x590
andl %eax, %edx
movl %ecx, %eax
shrl $0x5, %eax
andl $0x3f, %eax
imull $0xb2, %eax, %eax
addl $0x9a0, %eax            # imm = 0x9A0
shrl $0x3, %eax
andl %r8d, %eax
andl $0x1f, %ecx
imull $0xb2, %ecx, %ecx
shrl $0x8, %ecx
orl %edx, %ecx
orl %eax, %ecx
movw %cx, 0x20(%rsi)
cmpb $0xf, 0x3a(%rsi)
ja 0x2e6b
movw $0x400, 0x38(%rsi)      # imm = 0x400
movb $0x66, 0x3a(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_indev.c
// Function: lv_indev_reset
void lv_indev_reset(lv_indev_t * indev)
{
    if(indev)
        indev->proc.reset_query = 1;
    else {
        lv_indev_t * i = lv_indev_get_next(NULL);
        while(i) {
            i->proc.reset_query = 1;

            i = lv_indev_get_next(i);
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2e7d
orb $0x2, 0x78(%rdi)
retq
pushq %rax
xorl %edi, %edi
callq 0x874d
testq %rax, %rax
je 0x2e93
orb $0x2, 0x78(%rax)
movq %rax, %rdi
jmp 0x2e80
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_indev.c
// Function: lv_indev_set_cursor
void lv_indev_set_cursor(lv_indev_t * indev, lv_obj_t * cur_obj)
{
    if(indev->driver.type != LV_INDEV_TYPE_POINTER) return;

    indev->cursor = cur_obj;
    lv_obj_set_parent(indev->cursor, lv_disp_get_layer_sys(indev->driver.disp));
    lv_obj_set_pos(indev->cursor, indev->proc.types.pointer.act_point.x, indev->proc.types.pointer.act_point.y);
}

// Assembly:
cmpb $0x1, (%rdi)
jne 0x3815
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x80(%rdi)
movq 0x18(%rdi), %rdi
callq 0x4410
movq %r14, %rdi
movq %rax, %rsi
callq 0x5259
movq 0x80(%rbx), %rdi
movswl 0x38(%rbx), %esi
movswl 0x3a(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ad8
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_indev.c
// Function: lv_indev_get_point
void lv_indev_get_point(const lv_indev_t * indev, lv_point_t * point)
{
    if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) {
        point->x = -1;
        point->y = -1;
    } else {
        point->x = indev->proc.types.pointer.act_point.x;
        point->y = indev->proc.types.pointer.act_point.y;
    }
}

// Assembly:
movzbl (%rdi), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x3850
movzwl 0x38(%rdi), %eax
movw %ax, (%rsi)
movzwl 0x3a(%rdi), %eax
jmp 0x3859
movw $0xffff, (%rsi)         # imm = 0xFFFF
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_disp.c
// Function: lv_disp_get_scr_act
lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) {
        LV_LOG_WARN("lv_scr_act: no display registered to get its top layer");
        return NULL;
    }

    return disp->act_scr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x43d3
callq 0x8585
movq %rax, %rdi
testq %rax, %rax
je 0x43d9
movq 0x60(%rdi), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x43d7
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_disp.c
// Function: lv_disp_get_layer_top
lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) {
        LV_LOG_WARN("lv_layer_top: no display registered to get its top layer");
        return NULL;
    }

    return disp->top_layer;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x4406
callq 0x8585
movq %rax, %rdi
testq %rax, %rax
je 0x440c
movq 0x68(%rdi), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x440a
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_disp.c
// Function: lv_disp_get_layer_sys
lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) {
        LV_LOG_WARN("lv_layer_sys: no display registered to get its top layer");
        return NULL;
    }

    return disp->sys_layer;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x4423
callq 0x8585
movq %rax, %rdi
testq %rax, %rax
je 0x4429
movq 0x70(%rdi), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x4427
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_disp.c
// Function: lv_disp_assign_screen
void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr)
{
    if(lv_obj_get_parent(scr) != NULL) {
        LV_LOG_WARN("lv_disp_assign_screen: try to assign a non-screen object");
        return;
    }

    lv_disp_t * old_disp = lv_obj_get_disp(scr);

    if(old_disp == disp) return;

    lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4ab5
testq %rax, %rax
je 0x444c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x5061
cmpq %r14, %rax
je 0x4444
addq $0x48, %rax
addq $0x48, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a4ad
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_disp.c
// Function: lv_disp_get_refr_task
lv_task_t * lv_disp_get_refr_task(lv_disp_t * disp)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) {
        LV_LOG_WARN("lv_disp_get_refr_task: no display registered");
        return NULL;
    }

    return disp->refr_task;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x448e
callq 0x8585
movq %rax, %rdi
testq %rax, %rax
je 0x4494
movq 0x40(%rdi), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x4492
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_signal
static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
{
    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);

    lv_res_t res = LV_RES_OK;

    if(sign == LV_SIGNAL_CHILD_CHG) {
        /*Return 'invalid' if the child change signal is not enabled*/
        if(lv_obj_is_protected(obj, LV_PROTECT_CHILD_CHG) != false) res = LV_RES_INV;
    } else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
        const lv_style_t * style = lv_obj_get_style(obj);
        if(style->body.shadow.width > obj->ext_draw_pad) obj->ext_draw_pad = style->body.shadow.width;
    } else if(sign == LV_SIGNAL_STYLE_CHG) {
        lv_obj_refresh_ext_draw_pad(obj);
    }
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bl
decl %esi
cmpl $0x6, %esi
ja 0x4983
movq %rdi, %r14
leaq 0x3a803(%rip), %rax     # 0x3f120
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movl $0x1, %esi
callq 0x6a5b
movl %eax, %ebx
xorb $0x1, %bl
jmp 0x4983
movq %r14, %rdi
callq 0x66b6
movzwl 0x12(%rax), %eax
cmpw 0x5c(%r14), %ax
jle 0x4983
movw %ax, 0x5c(%r14)
jmp 0x4983
movq %r14, %rdi
callq 0x6514
jmp 0x4983
xorl %eax, %eax
cmpq $0x0, (%rdx,%rax,8)
je 0x4975
incq %rax
cmpq $0x7, %rax
jne 0x4960
movl $0x7, %eax
movzbl %al, %eax
leaq 0x3a880(%rip), %rcx     # 0x3f1ff
movq %rcx, (%rdx,%rax,8)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_design
static bool lv_obj_design(lv_obj_t * obj, const lv_area_t * mask_p, lv_design_mode_t mode)
{
    if(mode == LV_DESIGN_COVER_CHK) {

        /*Most trivial test. Is the mask fully IN the object? If no it surely doesn't cover it*/
        if(lv_area_is_in(mask_p, &obj->coords) == false) return false;

        /*Can cover the area only if fully solid (no opacity)*/
        const lv_style_t * style = lv_obj_get_style(obj);
        if(style->body.opa < LV_OPA_MAX) return false;

        /* Because of the radius it is not sure the area is covered
         * Check the areas where there is no radius*/
        lv_coord_t r = style->body.radius;

        if(r == LV_RADIUS_CIRCLE) return false;

        lv_area_t area_tmp;

        /*Check horizontally without radius*/
        lv_obj_get_coords(obj, &area_tmp);
        area_tmp.x1 += r;
        area_tmp.x2 -= r;
        if(lv_area_is_in(mask_p, &area_tmp) == false) return false;

        /*Check vertically without radius*/
        lv_obj_get_coords(obj, &area_tmp);
        area_tmp.y1 += r;
        area_tmp.y2 -= r;
        if(lv_area_is_in(mask_p, &area_tmp) == false) return false;

    } else if(mode == LV_DESIGN_DRAW_MAIN) {
        const lv_style_t * style = lv_obj_get_style(obj);
        lv_draw_rect(&obj->coords, mask_p, style, lv_obj_get_opa_scale(obj));
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movb $0x1, %bl
testl %edx, %edx
je 0x49de
cmpl $0x2, %edx
jne 0x4a06
leaq 0x20(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x28dd5
testb %al, %al
je 0x49da
movq %r15, %rdi
callq 0x66b6
cmpb $-0x5, 0x8(%rax)
jb 0x49da
movzwl 0x6(%rax), %r13d
cmpl $0x7c18, %r13d          # imm = 0x7C18
jne 0x4a16
xorl %ebx, %ebx
jmp 0x4a06
movq %r15, %rdi
callq 0x66b6
movq %rax, %r12
leaq 0x20(%r15), %r13
movq %r15, %rdi
callq 0x69eb
movzbl %al, %ecx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x36968
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x80e4
testb %al, %al
je 0x4a90
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leal (%rax,%r13), %ecx
movw %cx, (%rsi)
shrq $0x20, %rax
subl %r13d, %eax
movw %ax, 0x4(%rsi)
movq %r14, %rdi
callq 0x28dd5
testb %al, %al
je 0x49da
movq %r15, %rdi
callq 0x80e4
testb %al, %al
je 0x4aa1
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
addl %r13d, %ecx
movw %cx, 0x2(%rsi)
shrq $0x30, %rax
subl %r13d, %eax
movw %ax, 0x6(%rsi)
movq %r14, %rdi
callq 0x28dd5
testb %al, %al
je 0x49da
jmp 0x4a06
leaq 0x3a74d(%rip), %rdi     # 0x3f1e4
movq %r15, %rsi
callq 0x8294
jmp 0x4a9f
leaq 0x3a73c(%rip), %rdi     # 0x3f1e4
movq %r15, %rsi
callq 0x8294
jmp 0x4ab0
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_set_pos
void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    /*Convert x and y to absolute coordinates*/
    lv_obj_t * par = obj->par;

    x = x + par->coords.x1;
    y = y + par->coords.y1;

    /*Calculate and set the movement*/
    lv_point_t diff;
    diff.x = x - obj->coords.x1;
    diff.y = y - obj->coords.y1;

    /* Do nothing if the position is not changed */
    /* It is very important else recursive positioning can
     * occur without position change*/
    if(diff.x == 0 && diff.y == 0) return;

    /*Invalidate the original area*/
    lv_obj_invalidate(obj);

    /*Save the original coordinates*/
    lv_area_t ori;
    lv_obj_get_coords(obj, &ori);

    obj->coords.x1 += diff.x;
    obj->coords.y1 += diff.y;
    obj->coords.x2 += diff.x;
    obj->coords.y2 += diff.y;

    refresh_children_position(obj, diff.x, diff.y);

    /*Inform the object about its new coordinates*/
    obj->signal_cb(obj, LV_SIGNAL_CORD_CHG, &ori);

    /*Send a signal to the parent too*/
    par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);

    /*Invalidate the new area*/
    lv_obj_invalidate(obj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x4bbb
movq (%rbx), %r14
addw 0x20(%r14), %r15w
movzwl 0x22(%r14), %eax
addl %eax, %ebp
movl 0x20(%rbx), %r13d
movzwl 0x22(%rbx), %r12d
movl %r15d, %eax
xorl %r13d, %eax
movl %r12d, %ecx
xorl %ebp, %ecx
orw %ax, %cx
je 0x4bac
movq %rbx, %rdi
callq 0x4c4d
movq %rbx, %rdi
callq 0x80e4
testb %al, %al
je 0x4bcc
subl %r13d, %r15d
subl %r12d, %ebp
movq 0x20(%rbx), %rax
movq %rsp, %r12
movq %rax, (%r12)
leal (%r15,%rax), %ecx
movw %cx, 0x20(%rbx)
movl %eax, %ecx
shrl $0x10, %ecx
addl %ebp, %ecx
movw %cx, 0x22(%rbx)
movq %rax, %rcx
shrq $0x20, %rcx
addl %r15d, %ecx
movw %cx, 0x24(%rbx)
shrq $0x30, %rax
addl %ebp, %eax
movw %ax, 0x26(%rbx)
movswl %r15w, %esi
movswl %bp, %edx
movq %rbx, %rdi
callq 0x545e
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq *0x30(%rbx)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *0x30(%r14)
movq %rbx, %rdi
callq 0x4c4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a622(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x4bca
leaq 0x3a611(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x4bdb
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_x
lv_coord_t lv_obj_get_x(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_coord_t rel_x;
    lv_obj_t * parent = lv_obj_get_parent(obj);
    if(parent) {
        rel_x             = obj->coords.x1 - parent->coords.x1;
    } else {
        rel_x = obj->coords.x1;
    }
    return rel_x;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x4c04
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %rcx
movzwl 0x20(%rbx), %eax
testq %rcx, %rcx
je 0x4c02
subw 0x20(%rcx), %ax
popq %rbx
retq
leaq 0x3a5d9(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x4c13
// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_core/lv_obj.c
// Function: lv_obj_get_y
lv_coord_t lv_obj_get_y(const lv_obj_t * obj)
{
    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);

    lv_coord_t rel_y;
    lv_obj_t * parent = lv_obj_get_parent(obj);
   if(parent) {
       rel_y             = obj->coords.y1 - parent->coords.y1;
   } else {
       rel_y = obj->coords.y1;
   }
    return rel_y;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x80e4
testb %al, %al
je 0x4c3c
movq %rbx, %rdi
callq 0x4ab5
movq %rax, %rcx
movzwl 0x22(%rbx), %eax
testq %rcx, %rcx
je 0x4c3a
subw 0x22(%rcx), %ax
popq %rbx
retq
leaq 0x3a5a1(%rip), %rdi     # 0x3f1e4
movq %rbx, %rsi
callq 0x8294
jmp 0x4c4b