LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x8/bisect_test.c
// Function: test_max_subtree_logn
int test_max_subtree_logn(int *i)
{
	const struct test {
		const char	*name;
		const int	array[10];
		int		want;
	} tests[] = {
		{
			.name	= "31,-41,59,26,-53,58,97,-93,-23,84",
			.array	= {31, -41, 59, 26, -53, 58, 97, -93, -23, 84},
			.want	= 187,
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
		int got;

		printf("%3d) %-25s: %-45s", ++(*i), "test_max_subtree_logn", t->name);
		got = max_subtree_logn(t->array, 10);
		if (got != t->want) {
			printf("FAIL, got(%d)!=want(%d)\n", got, t->want);
			fail++;
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x2a78(%rip), %rsi      # 0x3d80
movq %rsp, %rax
movl $0xe, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1390
leaq 0x38(%rsp), %r12
leaq 0xcfc(%rip), %r14       # 0x2026
leaq 0xd38(%rip), %r15       # 0x2069
leaq 0xd13(%rip), %r13       # 0x204b
xorl %ebp, %ebp
movl (%rbx), %esi
incl %esi
movl %esi, (%rbx)
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1040
leaq -0x30(%r12), %rdi
movl $0xa, %esi
callq 0x1230
movl -0x8(%r12), %edx
cmpl %edx, %eax
jne 0x1373
leaq 0xcf8(%rip), %rdi       # 0x2064
callq 0x1030
jmp 0x1381
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
incl %ebp
movq (%r12), %rcx
addq $0x38, %r12
testq %rcx, %rcx
jne 0x133a
jmp 0x1392
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x8/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls, Chapter 0x8\n");
	printf("===============================\n");

	if (test_max_subtree_n(&i))
		fail++;
	if (test_max_subtree_logn(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xce5(%rip), %r14       # 0x209f
movq %r14, %rdi
callq 0x1030
leaq 0xcb6(%rip), %rdi       # 0x207f
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x117c
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movq %rbx, %rdi
callq 0x12f0
leal 0x1(%r14), %ecx
testl %eax, %eax
cmovel %r14d, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: createStack
Stack createStack(int size)
{
    Stack s;
    s=(Stack)malloc(sizeof(StackNode));
    if(s==NULL)
    {
        fatal("stack malloc failed.");
    }
    s->next=NULL;
    return s;

}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x1080
testq %rax, %rax
je 0x11c6
movq $0x0, 0x8(%rax)
popq %rcx
retq
leaq 0xed0(%rip), %rdi       # 0x209d
leaq 0xe30(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: popStack
void popStack(Stack s)
{
    assert(s!=NULL);
    PStackNode node=s->next;
    s->next=s->next->next;
    free(node);
}

// Assembly:
testq %rdi, %rdi
je 0x1264
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rdi
jmp 0x1030
pushq %rax
leaq 0xdad(%rip), %rdi       # 0x2019
leaq 0xdae(%rip), %rsi       # 0x2021
leaq 0xddf(%rip), %rcx       # 0x2059
movl $0x41, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: pushStack
void pushStack(int value, Stack s)
{
	PStackNode newNode;
    newNode=(PStackNode)malloc(sizeof(StackNode));
    if(newNode==NULL)
    {
        fatal("new node malloc failed");
    }
    newNode->value=value;
    newNode->next=s->next;
    s->next=newNode;

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x1080
testq %rax, %rax
je 0x12b0
movl %ebp, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xde6(%rip), %rdi       # 0x209d
leaq 0xd84(%rip), %rsi       # 0x2042
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: printStack
void printStack(Stack s){
    assert(s!=NULL);
    if(isEmptyStack(s)){
        printf("stack is empty.\n");
        return;
    }
    
    printf("stack: ");
    PStackNode node=s->next;
    while(node!=NULL){
        printf("%d ", node->value);
        node=node->next;
    }
    printf("\n");
    
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1360
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x134d
leaq 0xd82(%rip), %rdi       # 0x2091
xorl %eax, %eax
callq 0x1060
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x133c
leaq 0xd73(%rip), %rbx       # 0x2099
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1326
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
leaq 0xd59(%rip), %rdi       # 0x20ad
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1050
leaq 0xcb2(%rip), %rdi       # 0x2019
leaq 0xcb3(%rip), %rsi       # 0x2021
leaq 0xd05(%rip), %rcx       # 0x207a
movl $0x53, %edx
callq 0x1070
nop
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_list/main.c
// Function: main
int main(int argc, char** argv)
{
    
    Stack s;
    s=createStack(0);
    int i;
    for(i=0;i<10;i++){
        pushStack(rand()%100,s);
    }
    
    printStack(s);
    printf("Top: %d\n",topStack(s));
    popStack(s);
    popStack(s);
    printStack(s);
    printf("Top: %d\n",topStack(s));
    clearStack(s);
    printStack(s);
    exit(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %edi, %edi
callq 0x11ac
movq %rax, %rbx
movl $0xa, %ebp
callq 0x10a0
movslq %eax, %rdi
imulq $0x51eb851f, %rdi, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %edi
movq %rbx, %rsi
callq 0x1284
decl %ebp
jne 0x1393
movq %rbx, %rdi
callq 0x12f5
movq %rbx, %rdi
callq 0x12cc
leaq 0xce6(%rip), %r14       # 0x20bd
movq %r14, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x124b
movq %rbx, %rdi
callq 0x124b
movq %rbx, %rdi
callq 0x12f5
movq %rbx, %rdi
callq 0x12cc
movq %r14, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1224
movq %rbx, %rdi
callq 0x12f5
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/ggets.c
// Function: fggets
int fggets(char* *ln, FILE *f)
{
   int     cursize, ch, ix;
   char   *buffer, *temp;

   *ln = NULL; /* default */
   if (NULL == (buffer = malloc(INITSIZE))) return NOMEM;
   cursize = INITSIZE;

   ix = 0;
   while ((EOF != (ch = getc(f))) && ('\n' != ch)) {
      if (ix >= (cursize - 1)) { /* extend buffer */
         cursize += DELTASIZE;
         if (NULL == (temp = realloc(buffer, (size_t)cursize))) {
            /* ran out of memory, return partial line */
            buffer[ix] = '\0';
            *ln = buffer;
            return NOMEM;
         }
         buffer = temp;
      }
      buffer[ix++] = ch;
   }
   if ((EOF == ch) && (0 == ix)) {
      free(buffer);
      return EOF;
   }

   buffer[ix] = '\0';
   if (NULL == (temp = realloc(buffer, (size_t)ix + 1))) {
      *ln = buffer;  /* without reducing it */
   }
   else *ln = temp;
   return OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x70, %edi
callq 0x1130
movl $0x1, %ebp
testq %rax, %rax
je 0x14a6
movq %rax, %r14
movq %rbx, (%rsp)
movl $0x70, %ebx
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x11a0
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x144f
cmpl $0xa, %r12d
je 0x144f
leal -0x1(%rbx), %eax
cltq
cmpq %rax, %r13
jge 0x1430
movq %r14, %rax
jmp 0x1443
subl $-0x80, %ebx
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x1140
testq %rax, %rax
je 0x1497
movb %r12b, (%rax,%r13)
incq %r13
movq %rax, %r14
jmp 0x140b
cmpl $-0x1, %r12d
sete %al
testq %r13, %r13
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1472
movq %r14, %rdi
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x14a6
movl %r13d, %esi
movb $0x0, (%r14,%rsi)
incq %rsi
movq %r14, %rdi
callq 0x1140
testq %rax, %rax
cmoveq %r14, %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
xorl %ebp, %ebp
jmp 0x14a6
movl %r13d, %eax
movb $0x0, (%r14,%rax)
movq (%rsp), %rax
movq %r14, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: insert
static struct node *insert(struct node *t, void *data, ftype dup,
                           ftype comp, jmp_buf env)
{
    if (t == NULL) {
        if ((t = malloc(sizeof(struct node))) == NULL) {
            longjmp(env, 2);
        }

        t->data = data;
        t->level = 1;
        t->left = NULL;
        t->right = NULL;
        return t;
    } else if (comp(data, t->data) == -1) {
        t->left = insert(t->left, data, dup, comp, env);
    } else if (comp(data, t->data) == 1) {
        t->right = insert(t->right, data, dup, comp, env);
    } else if (dup == NULL) {
        longjmp(env, 3);
    } else {
        if (dup(t->data, data) == 0) {
            return t;
        } else {
            longjmp(env, 4);
        }
    }

    t = skew(t);
    t = split(t);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %r15
testq %rdi, %rdi
je 0x159c
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %r15, %rdi
callq *%rcx
cmpl $-0x1, %eax
je 0x15d1
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq *%r13
movl $0x18, %ebp
cmpl $0x1, %eax
je 0x15d6
testq %r12, %r12
je 0x162f
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq *%r12
testl %eax, %eax
je 0x15bf
movq %r14, %rdi
movl $0x4, %esi
callq 0x1150
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0x1622
movq %rax, %rbx
movq %r15, 0x8(%rax)
movl $0x1, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %ebp
movq (%rbx,%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1537
movq %rax, (%rbx,%rbp)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x160c
movl (%rdi), %eax
cmpl (%rbx), %eax
jne 0x160c
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0x18(%rdi)
jmp 0x160f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ce2
movq %r14, %rdi
movl $0x2, %esi
callq 0x1150
movq %r14, %rdi
movl $0x3, %esi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: find
static void *find(struct node *t, void *data, ftype comp)
{
    if (t == NULL) {
        return NULL;
    }

    if (t->data == NULL) {
        return NULL;
    }

    if (comp(data, t->data) == -1) {
        return find(t->left, data, comp);
    } else if (comp(data, t->data) == 1) {
        return find(t->right, data, comp);
    } else {
        return t->data;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x1905
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x1905
movq %r12, %rdi
callq *%r14
cmpl $-0x1, %eax
je 0x18fb
movq 0x8(%r15), %rsi
movq %r12, %rdi
callq *%r14
cmpl $0x1, %eax
jne 0x1901
movq 0x18(%r15), %r15
jmp 0x18cd
movq 0x10(%r15), %r15
jmp 0x18cd
movq 0x8(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: aa_traverse
int aa_traverse(aa * tree, void *(*func) (void *data), trav t)
{
    if (tree == NULL) {
        return 1;
    }

    switch (t) {
    case TRAV_IN:
        inorder(tree->root, func);
        break;
    case TRAV_POST:
        postorder(tree->root, func);
        break;
    case TRAV_PRE:
        preorder(tree->root, func);
        break;
    default:
        return 2;
        break;
    }

    return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1937
cmpl $0x2, %edx
je 0x1948
cmpl $0x1, %edx
je 0x193e
movl $0x2, %eax
testl %edx, %edx
jne 0x1952
movq (%rdi), %rdi
callq 0x1954
jmp 0x1950
movl $0x1, %eax
jmp 0x1952
movq (%rdi), %rdi
callq 0x198f
jmp 0x1950
movq (%rdi), %rdi
callq 0x19d3
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: inorder
static void inorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    if (node->left)
        inorder(node->left, func);

    node->data = func(node->data);

    if (node->right)
        inorder(node->right, func);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x1987
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1974
movq %rbx, %rsi
callq 0x1954
movq 0x8(%r14), %rdi
callq *%rbx
movq %rax, 0x8(%r14)
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x195e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: postorder
static void postorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    if (node->left)
        postorder(node->left, func);

    if (node->right)
        postorder(node->right, func);

    node->data = func(node->data);
}

// Assembly:
testq %rdi, %rdi
je 0x19d2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x19af
movq %r14, %rsi
callq 0x198f
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x19c0
movq %r14, %rsi
callq 0x198f
movq 0x8(%rbx), %rdi
callq *%r14
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: preorder
static void preorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    node->data = func(node->data);

    if (node->left)
        preorder(node->left, func);

    if (node->right)
        preorder(node->right, func);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x1a06
movq 0x8(%r14), %rdi
callq *%rbx
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x19fd
movq %rbx, %rsi
callq 0x19d3
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x19dd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: freetree
static void freetree(struct node *node)
{
    if (node == NULL)
        return;

    if (node->left)
        freetree(node->left);

    if (node->right)
        freetree(node->right);

    free(node);
}

// Assembly:
testq %rdi, %rdi
je 0x1a73
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1a5c
callq 0x1a45
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a6a
callq 0x1a45
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: aa_set_here
int aa_set_here(aa * tree, void *data, int (*dup) (void *orig, void *data))
{
    if (tree == NULL) {
        return 1;
    }

    if (tree->cursor == NULL) {
        return 2;
    }

    if (tree->comp(data, tree->cursor->data) == 0) {
        if (dup != NULL) {
            if (dup(tree->cursor->data, data) == 0) {
                return 0;
            } else {
                return 4;
            }

        } else {
            return 3;
        }

    } else {
        tree->cursor->data = data;
        return 0;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1ac1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1ac7
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x10(%r15)
testl %eax, %eax
je 0x1ace
movq 0x8(%r15), %rax
movq %rbx, 0x8(%rax)
xorl %eax, %eax
jmp 0x1af4
movl $0x1, %eax
retq
movl $0x2, %eax
jmp 0x1af4
testq %r14, %r14
je 0x1aef
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq *%r14
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
shll $0x2, %eax
jmp 0x1af4
movl $0x3, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: aa_print
int aa_print(aa * tree, FILE * fp, void (*printer) (FILE *, void *))
{
    if (!tree)
        return -1;

    if (tree->root == NULL)
        return -2;

    fprintf(fp, "digraph aa_tree {\n");
    fprintf(fp, "node [shape = record];\n");
    tree_print(tree->root, 1, printer, fp);
    fprintf(fp, "}\n");

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1c0e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x1c14
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x1461(%rip), %rdi      # 0x3014
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
leaq 0x145b(%rip), %rdi      # 0x3027
movl $0x17, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c1f
leaq 0x1447(%rip), %rdi      # 0x303f
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
xorl %eax, %eax
jmp 0x1c19
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: tree_print
static void tree_print(struct node *node, unsigned long long int n,
                       void (*printer) (FILE *, void *), FILE * fp)
{
    unsigned long long int pn = n / 2;

    fprintf(fp, "node%llu [label = \"<f0> | <f1> ", n);
    printer(fp, node->data);
    fprintf(fp, "|<f2> \"];\n");

    if (pn != 0) {
        if (n % 2 == 0) {
            fprintf(fp, "\"node%llu\":f0 -> \"node%llu\":f1;\n", pn, n);
        } else {
            fprintf(fp, "\"node%llu\":f2 -> \"node%llu\":f1;\n", pn, n);
        }
    }

    if (node->left)
        tree_print(node->left, 2 * n, printer, fp);

    if (node->right)
        tree_print(node->right, 2 * n + 1, printer, fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1405(%rip), %r13      # 0x3042
leaq 0x141e(%rip), %rbp      # 0x3062
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1110
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *%r14
movl $0xa, %esi
movl $0x1, %edx
movq %rbp, %rdi
movq %rbx, %rcx
callq 0x1190
cmpq $0x2, %r15
jb 0x1ca3
movq %r15, %rdx
shrq %rdx
testb $0x1, %r15b
leaq 0x1403(%rip), %rsi      # 0x308e
leaq 0x13db(%rip), %rax      # 0x306d
cmoveq %rax, %rsi
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1110
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1cbc
leaq (%r15,%r15), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c1f
movq 0x18(%r12), %r12
testq %r12, %r12
je 0x1cd3
leaq 0x1(,%r15,2), %r15
jmp 0x1c44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/aa-tree.c
// Function: split
static struct node *split(struct node *t)
{
    struct node *r;

    if (t == NULL)
        return NULL;

    if ((t->right == NULL) || (t->right->right == NULL))
        return t;

    if (t->level == t->right->right->level) {
        r = t->right;
        t->right = r->left;
        r->left = t;
        r->level++;
        return r;
    } else {
        return t;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1d12
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1d0e
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x1d0e
movl (%rdi), %edx
cmpl (%rcx), %edx
jne 0x1d0e
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rdi)
movq %rdi, 0x10(%rax)
incl (%rax)
retq
movq %rdi, %rax
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/asprintf.c
// Function: vasprintf
int vasprintf(char **ret, const char *fmt, va_list ap)
{
    int n;
    va_list ap2;

    va_copy(ap2, ap);

    if ((n = vsnprintf(NULL, 0, fmt, ap2)) < 0)
        goto error;

    va_end(ap2);

    if ((*ret = malloc(n + 1)) == NULL)
        goto error;

    if ((n = vsnprintf(*ret, n + 1, fmt, ap)) < 0) {
        free(*ret);
        goto error;
    }

    return n;

  error:
    *ret = NULL;
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
testl %eax, %eax
js 0x1d80
movl %eax, %r12d
incl %r12d
movq %r12, %rdi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
je 0x1d80
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1070
testl %eax, %eax
jns 0x1d8c
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/ll3.c
// Function: get_end
ll *get_end(ll * node)
{
    if (!node)
        return NULL;

    if (!(node->nxt))
        return node;

    while (node->nxt)
        node = get_next(node);

    return node;
}

// Assembly:
testq %rdi, %rdi
je 0x1e93
movq %rdi, %rax
cmpq $0x0, 0x10(%rdi)
je 0x1e95
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1e95
movq %rcx, %rax
movq 0x10(%rcx), %rcx
jmp 0x1e85
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/ll3.c
// Function: new_node
ll *new_node(int tag, void *data, ll * next)
{
    ll *new;

    if (!(new = malloc(sizeof(ll))))
        return NULL;

    new->tag = tag;
    new->data = data;
    new->nxt = next;

    return new;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0x1f05
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
jmp 0x1f07
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/ll3.c
// Function: map
ll *map(ll * beg, void *(proc) (int, void *))
{
    ll *tmp = beg;

    if (!beg)
        return NULL;

    while (beg) {
        beg->data = proc(beg->tag, beg->data);
        beg = beg->nxt;
    }

    return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f38
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movl (%r15), %edi
movq 0x8(%r15), %rsi
callq *%r14
movq %rax, 0x8(%r15)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1f1f
jmp 0x1f3a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/ll3.c
// Function: free_all_data
ll *free_all_data(ll * beg)
{
    ll *tmp = beg;

    if (!beg)
        return NULL;

    while (beg) {
        free(beg->data);
        beg->data = NULL;
        beg = beg->nxt;
    }

    return tmp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f9f
movq %rdi, %rbx
movq %rdi, %r14
movq 0x8(%r14), %rdi
callq 0x1030
movq $0x0, 0x8(%r14)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1f83
jmp 0x1fa1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chbarts[P]aa-tree/sort2.c
// Function: comparator
static int comparator(void *left, void *right)
{
    char *cl, *cr;
    int r;

    cl = (char *) get_data((ll *) left);
    cr = (char *) get_data((ll *) right);

    r = strcmp(cl, cr);

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

    return (rev * r);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x1e55
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e55
movq %r14, %rdi
movq %rax, %rsi
callq 0x10f0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
negl %ecx
testl %eax, %eax
movl $0x1, %eax
cmovlel %ecx, %eax
imull 0x3e07(%rip), %eax      # 0x60ec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x38c(%rip), %r13       # 0x269e
movq %r12, %rdi
movq %r15, %rsi
callq 0x13cc
testl %eax, %eax
jne 0x23ab
testb %bpl, %bpl
je 0x236a
movq (%rsp), %r14
movq %r14, %rdi
callq 0x1090
leaq 0x10(%rsp), %rdi
leaq 0xe02(%rip), %rsi       # 0x3144
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1d98
movl %eax, %r14d
movq (%rsp), %rdi
callq 0x1030
cmpl $-0x1, %r14d
je 0x23e0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
movl $0x1, %edi
xorl %edx, %edx
callq 0x1ede
testq %rax, %rax
je 0x23d7
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x14e0
testl %eax, %eax
je 0x2312
cmpl $0x2, %eax
jne 0x23e8
movq (%rsp), %rdi
callq 0x1030
movq %r14, %rdi
jmp 0x23db
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
je 0x23c8
leaq 0xd80(%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 0x2668
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x128c
// File: /workspace/github_c_makefile_star2_O1/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 0x1e39
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1e55
testl %ebp, %ebp
jle 0x2424
movq %rax, %r14
incl %ebp
movq %r14, %rdi
callq 0x1050
decl %ebp
cmpl $0x1, %ebp
jg 0x2415
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd16(%rip), %rdi       # 0x3168
xorl %eax, %eax
callq 0x10c0
leaq 0xd26(%rip), %rdi       # 0x3186
callq 0x1050
leaq 0xd56(%rip), %rdi       # 0x31c2
callq 0x1050
leaq 0xd75(%rip), %rdi       # 0x31ed
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xd8a(%rip), %rdi       # 0x3218
callq 0x1050
leaq 0xdb2(%rip), %rdi       # 0x324c
callq 0x1050
leaq 0xdde(%rip), %rdi       # 0x3284
callq 0x1050
leaq 0xe0d(%rip), %rdi       # 0x32bf
callq 0x1050
leaq 0xe41(%rip), %rdi       # 0x32ff
callq 0x1050
leaq 0xe59(%rip), %rdi       # 0x3323
callq 0x1050
movl $0xa, %edi
callq 0x1040
leaq 0xe71(%rip), %rdi       # 0x3351
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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 0xe87(%rip), %rdi       # 0x3375
callq 0x1050
leaq 0xe8f(%rip), %rdi       # 0x3389
callq 0x1050
leaq 0xe9f(%rip), %rdi       # 0x33a5
callq 0x1050
leaq 0xed0(%rip), %rdi       # 0x33e2
callq 0x1050
leaq 0xef7(%rip), %rdi       # 0x3415
callq 0x1050
leaq 0xf0e(%rip), %rdi       # 0x3438
callq 0x1050
leaq 0xf33(%rip), %rdi       # 0x3469
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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 0x1e55
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e55
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 0x2594
movl $0x1, %eax
jbe 0x25a3
imull 0x3b51(%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 0x26f7
// File: /workspace/github_c_makefile_star2_O1/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 0x1e55
movq %rax, %rdi
movl $0x3a, %esi
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e39
testl %eax, %eax
jle 0x264a
movl %eax, %ebp
incq %r14
incl %ebp
movq %r14, %rdi
callq 0x1050
decl %ebp
cmpl $0x1, %ebp
jg 0x263b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e39
leal 0x1(%rax), %esi
movq %r14, %rdi
callq 0x1e47
movq %rbx, %rdi
callq 0x1e55
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_O1/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 0x1e55
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2759
movl $0x1, %eax
jg 0x2759
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10f0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x2759
setne %al
movzbl %al, %eax
imull 0x398c(%rip), %eax      # 0x60ec
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x44f0
callq 0x3e5a4
leaq 0x5dc20(%rip), %rbx     # 0x5fe70
leaq 0x51419(%rip), %rsi     # 0x53670
movq %rbx, %rdi
xorl %edx, %edx
movl $0x6400, %ecx           # imm = 0x6400
callq 0x8350
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x831c
movq %rbx, 0x8(%r14)
leaq 0x3c43f(%rip), %rax     # 0x3e6bd
movq %rax, 0x18(%r14)
movq %r14, %rdi
callq 0x8371
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x86e4
movb $0x1, (%rbx)
leaq 0x3c81c(%rip), %rax     # 0x3eabd
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x8700
callq 0x860d
movq %rax, %rdi
callq 0x43d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x196f4
movq %rax, %rbx
leaq 0x3cd36(%rip), %rsi     # 0x3f004
movq %rax, %rdi
callq 0x19f13
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x576d
callq 0x860d
movq %rax, %rdi
callq 0x43d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x130d4
movq %rax, %rbx
leaq 0x59(%rip), %rsi        # 0x2364
movq %rax, %rdi
callq 0x6344
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x576d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x196f4
leaq 0x3ccdc(%rip), %rsi     # 0x3f011
movq %rax, %rdi
callq 0x19f13
leaq 0x3ccde(%rip), %rdi     # 0x3f022
callq 0x2050
movl $0x5, %edi
callq 0x8830
callq 0x287af
movl $0x1388, %edi           # imm = 0x1388
callq 0x2120
jmp 0x2349
// File: /workspace/github_c_makefile_star2_O1/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 0x29c08
movq %rax, %rbx
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x2425
testq %rbx, %rbx
je 0x2436
movq %rbx, %rdi
movl $0x8, %esi
callq 0x29bf8
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 0x2e244
leaq 0x83f(%rip), %rcx       # 0x2c2e
movq %rcx, 0x20(%rbx)
leaq 0x9aa(%rip), %rcx       # 0x2da4
movq %rcx, 0x28(%rbx)
testq %rax, %rax
je 0x2438
movq 0x350(%rax), %rcx
testq %rcx, %rcx
je 0x2413
movq %rcx, 0x20(%rbx)
movq 0x358(%rax), %rax
testq %rax, %rax
je 0x2438
movq %rax, 0x28(%rbx)
jmp 0x2438
leaq 0x3cc14(%rip), %rdi     # 0x3f040
movq %rbx, %rsi
callq 0x829e
jmp 0x2434
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2463
movq (%rax), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c36
movq %rbx, %rdi
callq 0x29cce
testq %rax, %rax
je 0x2488
movq (%rax), %rcx
movq $0x0, 0x50(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29dfb
jmp 0x246b
movq %rbx, %rdi
callq 0x29e18
leaq 0x660d9(%rip), %rdi     # 0x68570
movq %rbx, %rsi
callq 0x29d38
movq %rbx, %rdi
popq %rbx
jmp 0x29984
// File: /workspace/github_c_makefile_star2_O1/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 0x2520
movq %rsi, %r14
movq %rdi, %rbx
callq 0x29cce
testq %rax, %rax
je 0x24d4
cmpq %r14, (%rax)
je 0x2520
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29dfb
jmp 0x24bd
cmpq $0x0, 0x50(%r14)
je 0x24f0
movq %r14, %rdi
callq 0x6bbc
testb %al, %al
je 0x24f0
movq 0x50(%r14), %rdi
callq 0x2541
movq %rbx, 0x50(%r14)
movq %rbx, %rdi
callq 0x29cea
movq %rax, %r15
movq %rax, %rdi
callq 0x80d4
testb %al, %al
je 0x2526
testq %r15, %r15
je 0x2520
movq %r14, (%r15)
movq %rbx, %rdi
callq 0x29cce
cmpq %r15, %rax
je 0x2537
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3cb13(%rip), %rdi     # 0x3f040
movq %r15, %rsi
callq 0x829e
jmp 0x2535
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2541
// File: /workspace/github_c_makefile_star2_O1/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 0x256e
leaq 0x27769(%rip), %rsi     # 0x29cce
leaq 0x2788f(%rip), %rdx     # 0x29dfb
jmp 0x257c
leaq 0x27896(%rip), %rsi     # 0x29e0b
leaq 0x2775f(%rip), %rdx     # 0x29cdb
movq %rbx, %rdi
callq 0x2870
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_O1/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 0x2644
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x2644
movq %rdi, %rbx
cmpq %rdi, (%rax)
jne 0x25ee
movq %r14, %rdi
callq 0x29cce
cmpq 0x18(%r14), %rax
jne 0x25e6
movq %r14, %rdi
callq 0x29e0b
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
je 0x264a
movq %r14, %rdi
callq 0x2541
movq 0x18(%r14), %rax
cmpq %rbx, (%rax)
jne 0x25ff
movq $0x0, 0x18(%r14)
movq %r14, %rdi
callq 0x29cce
testq %rax, %rax
je 0x2644
movq %rax, %r15
cmpq %rbx, (%r15)
je 0x2629
movq %r14, %rdi
movq %r15, %rsi
callq 0x29dfb
movq %rax, %r15
testq %rax, %rax
jne 0x260f
jmp 0x2644
movq %r14, %rdi
movq %r15, %rsi
callq 0x29d38
movq %r15, %rdi
callq 0x29984
movq $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq (%rcx), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
jmp 0x25ee
// File: /workspace/github_c_makefile_star2_O1/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 0x2687
movq (%rax), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c36
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x29cce
testq %rax, %rax
je 0x26ac
movq (%rax), %rcx
movq $0x0, 0x50(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29dfb
jmp 0x268f
movq %rbx, %rdi
popq %rbx
jmp 0x29e18
// File: /workspace/github_c_makefile_star2_O1/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 0x27a7
movq %rdi, %r15
movq 0x50(%rdi), %rbx
testq %rbx, %rbx
je 0x27a7
testb $0x1, 0x80(%rbx)
jne 0x27a7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x27ad
movq %rbx, %rdi
callq 0x29cce
testq %rax, %rax
je 0x27a7
movq %rax, %r14
cmpq %r15, (%r14)
je 0x271b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29dfb
movq %rax, %r14
testq %rax, %rax
jne 0x26fe
jmp 0x27a7
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x2754
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 0x4fea
cmpb $0x1, %al
jne 0x27a7
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c36
movq %r14, 0x18(%rbx)
movq (%r14), %rdi
movl $0x10, %esi
xorl %edx, %edx
callq *0x30(%rdi)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2773
movq %rbx, %rdi
callq *%rax
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl $0xc, %esi
xorl %edx, %edx
callq 0x4fea
cmpb $0x1, %al
jne 0x27a7
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x4c36
movq 0x18(%rbx), %rax
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2829
popq %rbx
popq %r14
popq %r15
retq