LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/stdedit.c
// Function: self_destruct
void self_destruct(){
    while(!isEmptyq(&data)){
        while(!isEmptys(&(data.front->element)))
                ipops(&(data.front->element));
        dequeue(&data);
    }
    printf("\nThe Program terminated Successfully :)\nThanks For Using Vasu's Text Editor\n\n");
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x5195(%rip), %rbx      # 0xa1d8
movq %rbx, %rdi
callq 0x2704
testl %eax, %eax
je 0x505d
jmp 0x5077
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x24e8
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x2577
testl %eax, %eax
je 0x5051
movq %rbx, %rdi
callq 0x2696
jmp 0x5043
leaq 0x23ff(%rip), %rdi      # 0x747d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2060
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: add_event
void add_event(undo *s,char *state,int a,int b,char *c, char *d){
    event e;
    e.state = state;
    e.p1 = a;
    e.p2 = b;
    e.p3 = (char *)calloc(sizeof(c)+1,1);
    strcpy(e.p3,c);
    e.p4 = (char *)calloc(sizeof(d)+1,1);
    strcpy(e.p4,d);
    epush(s,e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdi, %rbx
movq %rsi, -0x40(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x34(%rbp)
movl $0x9, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x30(%rbp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
movl $0x9, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x28(%rbp)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5800
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: backtrack
void backtrack(undo *s){
    if(isEmptye(s) || (s->num == 0)){
       return; 
    }
    event e = epop(s);
    
    if(strstr(e.state,"replace")){
        undo_replace(e);        
        char *temp = e.p3;
        e.p3 = e.p4;
        e.p4 = temp;
        epush(&redo,e);
    }
    else if(strstr(e.state,"add")){
        undo_insert(e);
        
    }
    else if(strstr(e.state,"back")){
        undo_back(e);
    }
    else if(strstr(e.state,"next")){
        undo_next(e);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x589a
testl %eax, %eax
je 0x5135
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x8(%rbx)
je 0x512c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5848
movq (%r14), %rbx
leaq 0x22a3(%rip), %rsi      # 0x73f7
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
je 0x51bb
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5267
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x5017(%rip), %rdi      # 0xa1c8
callq 0x5800
jmp 0x512c
leaq 0x1e5a(%rip), %rsi      # 0x701c
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
je 0x51f3
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x54d5
jmp 0x512c
leaq 0x1e26(%rip), %rsi      # 0x7020
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
je 0x522b
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x55bc
jmp 0x512c
leaq 0x1de5(%rip), %rsi      # 0x7017
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
je 0x512c
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x568c
jmp 0x512c
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: undo_insert
void undo_insert(event e){
    int x,y;
    getyx(stdscr,y,x);
    if(strstr(e.p3,"\n")){
        backspace(e.p2,1);
        epop(&states);
        display(stline);
        refresh();
        move(y,x);
    }
    else{
        backspace(e.p2,e.p1+1);
        epop(&states);
        display(stline);
        refresh();
    }
    if(x == e.p1)
        move(y,++x);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq 0x4af5(%rip), %r15      # 0x9fe0
movq (%r15), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x5502
movswl (%rax), %r14d
leaq 0x10(%rbp), %r12
testq %rax, %rax
je 0x550f
movswl 0x2(%rax), %ebx
movq 0x10(%r12), %rdi
movl $0xa, %esi
callq 0x20e0
movl 0xc(%r12), %edi
testq %rax, %rax
je 0x5567
movl $0x1, %esi
callq 0x30fa
leaq 0x4c7f(%rip), %rsi      # 0xa1b8
leaq -0x48(%rbp), %rdi
callq 0x5848
leaq 0x4c53(%rip), %rax      # 0xa19c
movl (%rax), %edi
callq 0x2866
movq (%r15), %rdi
callq 0x2100
movq (%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x2230
jmp 0x5599
movl 0x8(%r12), %esi
incl %esi
callq 0x30fa
leaq 0x4c3e(%rip), %rsi      # 0xa1b8
leaq -0x48(%rbp), %rdi
callq 0x5848
leaq 0x4c12(%rip), %rax      # 0xa19c
movl (%rax), %edi
callq 0x2866
movq (%r15), %rdi
callq 0x2100
cmpl 0x8(%r12), %ebx
jne 0x55af
movq (%r15), %rdi
incl %ebx
movl %r14d, %esi
movl %ebx, %edx
callq 0x2230
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: undo_back
void undo_back(event e){
    int y,x;
    getyx(stdscr,y,x);
    if(strstr(e.p3,"\n")){
        add_char('\n',e.p2,e.p1);
        add_line(e.p2);
        display(stline);
        move(y,x+1);
    }
    else{
        add_char(e.p3[0],e.p2,e.p1-1);
        display(stline);
        move(y,x+1);
    }   
    display(stline);
    move(y,x+1);
    refresh();
    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4a0f(%rip), %r12      # 0x9fe0
movq (%r12), %rax
testq %rax, %rax
je 0x55df
movswl (%rax), %ebx
jmp 0x55e4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x10(%rbp), %r13
testq %rax, %rax
je 0x55f7
movswl 0x2(%rax), %r14d
incl %r14d
jmp 0x55fa
xorl %r14d, %r14d
movq 0x10(%r13), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x20e0
testq %rax, %rax
je 0x562f
movl 0x8(%r13), %edx
movl 0xc(%r13), %r15d
movl $0xa, %edi
movl %r15d, %esi
callq 0x2b61
movl %r15d, %edi
callq 0x29cc
jmp 0x5642
movsbl (%r15), %edi
movl 0x8(%r13), %edx
movl 0xc(%r13), %esi
decl %edx
callq 0x2b61
leaq 0x4b53(%rip), %r15      # 0xa19c
movl (%r15), %edi
callq 0x2866
movq (%r12), %rdi
movl %ebx, %esi
movl %r14d, %edx
callq 0x2230
movl (%r15), %edi
callq 0x2866
movq (%r12), %rdi
movl %ebx, %esi
movl %r14d, %edx
callq 0x2230
movq (%r12), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: undo_next
void undo_next(event e){
    int x = 0,y = 0;
    getyx(stdscr,y,x);
    backspace(e.p2,0);
    epop(&states);
    clear();
    if((y == 0 ) && (stline != 0)){
        stline--;
    }
    display(stline);
    if(stline >  0){
        move(e.p2 - stline,getwidth(e.p2));
    }
    else{
        x += 2;
        move(e.p2,getwidth(e.p2 -stline));
    }
    refresh();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq 0x493a(%rip), %r12      # 0x9fe0
movq (%r12), %rcx
testq %rcx, %rcx
je 0x56b9
cmpw $0x0, (%rcx)
sete %r14b
jmp 0x56bc
xorl %r14d, %r14d
movl 0xc(%rax), %ebx
movl %ebx, %edi
xorl %esi, %esi
callq 0x30fa
leaq 0x4ae9(%rip), %rsi      # 0xa1b8
leaq -0x48(%rbp), %rdi
callq 0x5848
movq (%r12), %rdi
callq 0x20a0
leaq 0x4ab4(%rip), %r15      # 0xa19c
movl (%r15), %eax
testl %eax, %eax
setne %cl
andb %r14b, %cl
cmpb $0x1, %cl
jne 0x56fd
decl %eax
movl %eax, (%r15)
movl (%r15), %edi
callq 0x2866
movl (%r15), %eax
movl %ebx, %r14d
subl %eax, %r14d
testl %eax, %eax
movq (%r12), %r15
movl %r14d, %edi
cmovgl %ebx, %edi
cmovlel %ebx, %r14d
callq 0x30b2
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x2230
movq (%r12), %rdi
callq 0x2100
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/undo.c
// Function: retrack
void retrack(undo *s){
     if(isEmptye(s) || s->num == 0){
       return; 
    }
    event e = epop(s);
    if(strstr(e.state,"replace")){
        undo_replace(e);        
        char *temp = e.p3;
        e.p3 = e.p4;
        e.p4 = temp;
        epush(&states,e);       
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x589a
testl %eax, %eax
je 0x5766
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x8(%rbx)
je 0x575d
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5848
movq (%r14), %rdi
leaq 0x1c72(%rip), %rsi      # 0x73f7
callq 0x22d0
testq %rax, %rax
je 0x575d
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5267
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x49d9(%rip), %rdi      # 0xa1b8
callq 0x5800
jmp 0x575d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/events.c
// Function: epush
void epush(undo *s, event a){
    event *new = (event *)calloc(1,sizeof(event));
    *new  = a;
    if(!(s->e)){
        s->e = new;
        s->num++;
        return;
    }
    else
    {
        event *temp = s->e;
        s->e = new;
        s->e->ptr = temp;
        s->num++;
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq (%rbx), %rcx
movq %rax, (%rbx)
testq %rcx, %rcx
je 0x583e
movq %rcx, 0x20(%rax)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/events.c
// Function: epop
event epop(undo *s){
    event e = {NULL,0,0,NULL,NULL,NULL};

    if(!s->e){
        return e;
    }
    else
    {
        event *temp = s->e;
        s->e = s->e->ptr;
        e = *temp;
        s->num--;
        free(temp);
        return e;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5890
movq 0x20(%rdi), %rax
movq %rax, (%rsi)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rbx)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
decl 0x8(%rsi)
callq 0x2030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: get_time
const char * get_time(void) {
    static char time_buf[128];
    struct timeval  tv;
    time_t time;
    suseconds_t millitm;
    struct tm *ti;

    gettimeofday (&tv, NULL);

    time= tv.tv_sec;
    millitm = (tv.tv_usec + 500) / 1000;

    if (millitm == 1000) {
        ++time;
        millitm = 0;
    }

    ti = localtime(&time);
    sprintf(time_buf, "[%02d-%02d_%02d:%02d:%02d:%03d]", ti->tm_mon+1, ti->tm_mday, ti->tm_hour, ti->tm_min, ti->tm_sec, (int)millitm);
    return time_buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10d0
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
leaq 0x1f4(%rsi), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
movq %rcx, (%rsp)
addq $-0xf404c, %rsi         # imm = 0xFFF0BFB4
cmpq $0x3e7, %rsi            # imm = 0x3E7
ja 0x138c
incq %rcx
movq %rcx, (%rsp)
xorl %ebx, %ebx
jmp 0x139d
movq %rdx, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rbx
addq %rax, %rbx
movq %rsp, %rdi
callq 0x1050
movl 0x10(%rax), %edx
incl %edx
movl 0xc(%rax), %ecx
movl 0x8(%rax), %r8d
movl (%rax), %r10d
movl 0x4(%rax), %r9d
leaq 0x3d91(%rip), %r14      # 0x5150
leaq 0x1c3e(%rip), %rsi      # 0x3004
movq %r14, %rdi
xorl %eax, %eax
pushq %rbx
pushq %r10
callq 0x11e0
addq $0x10, %rsp
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: cleanup_qmi_connection
static void cleanup_qmi_connection(int clientfd) {
    struct qlistnode *con_node, *qmi_node;
    
    qlist_for_each(con_node, &qmi_proxy_connection) {
        QMI_PROXY_CONNECTION *qmi_con = qnode_to_item(con_node, QMI_PROXY_CONNECTION, qnode);

        if (qmi_con->ClientFd == clientfd) {
            while (!qlist_empty(&qmi_con->client_qnode)) {
                QMI_PROXY_CLINET *qmi_client = qnode_to_item(qlist_head(&qmi_con->client_qnode), QMI_PROXY_CLINET, qnode);

                dprintf("xxx ClientFd=%d QMIType=%d ClientId=%d\n", qmi_con->ClientFd, qmi_client->QMIType, qmi_client->ClientId);

                qlist_remove(&qmi_client->qnode);
                free(qmi_client);
            }
           
            qlist_for_each(qmi_node, &qmi_proxy_ctl_msg) {
                QMI_PROXY_MSG *qmi_msg = qnode_to_item(qmi_node, QMI_PROXY_MSG, qnode);

                if (qmi_msg->ClientFd == qmi_con->ClientFd) {
                    qlist_remove(&qmi_msg->qnode);
                    free(qmi_msg);
                    break;
                 }
            }

            dprintf("--- ClientFd=%d\n", qmi_con->ClientFd);    
            close(qmi_con->ClientFd);
            qlist_remove(&qmi_con->qnode);
            free(qmi_con);
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3ed1(%rip), %r14      # 0x61f0
leaq 0x3eca(%rip), %rax      # 0x61f0
cmpq %rax, %r14
je 0x2435
movq 0x2c9a(%rip), %rbx      # 0x4fd0
leaq 0x2e13(%rip), %r12      # 0x5150
movl %edi, (%rsp)
movl 0x20(%r14), %ecx
cmpl %edi, %ecx
jne 0x2429
movl %ecx, 0x4(%rsp)
leaq 0x10(%r14), %r13
movq 0x10(%r14), %rbp
cmpq %rbp, %r13
je 0x23a4
movq (%rbx), %r15
callq 0x133c
movl 0x20(%r14), %ecx
movzbl 0x10(%rbp), %r8d
movzbl 0x11(%rbp), %r9d
movq %r15, %rdi
leaq 0xfdd(%rip), %rsi       # 0x335a
movq %r12, %rdx
xorl %eax, %eax
callq 0x1120
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %rbp, %rdi
callq 0x1030
jmp 0x2354
leaq 0x3e55(%rip), %rcx      # 0x6200
movq %rcx, %rdi
movq (%rdi), %rdi
cmpq %rcx, %rdi
je 0x23d6
movl 0x10(%rdi), %eax
cmpl 0x20(%r14), %eax
jne 0x23ae
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x1030
movq (%rbx), %r15
callq 0x133c
movl 0x20(%r14), %ecx
movq %r15, %rdi
leaq 0xf99(%rip), %rsi       # 0x3385
movq %r12, %rdx
xorl %eax, %eax
callq 0x1120
movl 0x20(%r14), %edi
callq 0x10e0
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq %r14, %rdi
callq 0x1030
movl (%rsp), %edi
cmpl %edi, 0x4(%rsp)
leaq 0x3dc9(%rip), %rax      # 0x61f0
je 0x2435
movq (%r14), %r14
cmpq %rax, %r14
jne 0x2340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: dump_qmi
static void dump_qmi(PQCQMIMSG pQMI, int fd, const char flag)
{
    if (verbose_debug)
    {
        unsigned i;
        unsigned size = le16toh(pQMI->QMIHdr.Length) + 1;
        printf("%c %d %u: ", flag, fd, size);
        if (size > 16)
            size = 16;
        for (i = 0; i < size; i++)
            printf("%02x ", ((uint8_t *)pQMI)[i]);
        printf("\n");
    }
}

// Assembly:
cmpb $0x1, 0x2d85(%rip)      # 0x51d0
jne 0x24b5
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movzwl 0x1(%rdi), %ebp
incl %ebp
movzbl %dl, %esi
leaq 0xf43(%rip), %rdi       # 0x33ad
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10c0
cmpl $0x10, %ebp
movl $0x10, %r15d
cmovbl %ebp, %r15d
leaq 0xf2f(%rip), %r14       # 0x33b8
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10c0
incq %r12
cmpq %r12, %r15
jne 0x248c
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: send_qmi_to_client
static int send_qmi_to_client(PQCQMIMSG pQMI, int clientFd) {
    struct pollfd pollfds[]= {{clientFd, POLLOUT, 0}};
    ssize_t ret = 0;

    do {
        ret = poll(pollfds, sizeof(pollfds)/sizeof(pollfds[0]), 5000);
    } while (ret == -1 && errno == EINTR && qmi_proxy_quit == 0);

    if (pollfds[0].revents & POLLOUT) {
        ssize_t size = le16toh(pQMI->QMIHdr.Length) + 1;
        ret = write(clientFd, pQMI, size);
        dump_qmi(pQMI, clientFd, 'w');
    }

    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq %rsp, %r14
movl %edi, (%r14)
movl $0x4, 0x4(%r14)
movl $0x1, %esi
movq %r14, %rdi
movl $0x1388, %edx           # imm = 0x1388
callq 0x1160
cmpl $-0x1, %eax
jne 0x24f4
callq 0x1060
cmpl $0x4, (%rax)
jne 0x24f4
testb $0x1, 0x2ce2(%rip)      # 0x51d4
je 0x24ca
testb $0x4, 0x6(%rsp)
je 0x2525
movzwl 0x2cef(%rip), %edx      # 0x51f1
leaq 0x2ce7(%rip), %r14      # 0x51f0
incq %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x10a0
movq %r14, %rdi
movl %ebx, %esi
movl $0x77, %edx
callq 0x2444
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: send_qmi_to_cdc_wdm
static int send_qmi_to_cdc_wdm(PQCQMIMSG pQMI) {
    struct pollfd pollfds[]= {{cdc_wdm_fd, POLLOUT, 0}};
    ssize_t ret = 0;

    do {
        ret = poll(pollfds, sizeof(pollfds)/sizeof(pollfds[0]), 5000);
    } while (ret == -1 && errno == EINTR && qmi_proxy_quit == 0);

    if (pollfds[0].revents & POLLOUT) {
        ssize_t size = le16toh(pQMI->QMIHdr.Length) + 1;
        ret = write(cdc_wdm_fd, pQMI, size);
        dump_qmi(pQMI, cdc_wdm_fd, 'w');
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x2bf1(%rip), %eax      # 0x5130
leaq 0x8(%rsp), %r15
movl %eax, (%r15)
movl $0x4, 0x4(%r15)
movl $0x1, %esi
movq %r15, %rdi
movl $0x1388, %edx           # imm = 0x1388
callq 0x1160
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x257c
callq 0x1060
cmpl $0x4, (%rax)
jne 0x257c
testb $0x1, 0x2c5a(%rip)      # 0x51d4
je 0x254f
testb $0x4, 0xe(%rsp)
je 0x25ae
movzwl 0x1(%rbx), %edx
incq %rdx
movl 0x2ba0(%rip), %edi      # 0x5130
movq %rbx, %rsi
callq 0x10a0
movq %rax, %r14
movl 0x2b8f(%rip), %esi      # 0x5130
movq %rbx, %rdi
movl $0x77, %edx
callq 0x2444
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/darkautism[P]lfqueue/test_multithread.c
// Function: addq
THREAD_FN addq( void * data ) {
	struct lfq_ctx * ctx = data;
	int ret = 0;
	long added;
	for (added = 0 ; added < 500000 ; added++) {
		struct user_data * p = malloc(sizeof(struct user_data));
		p->data=SOMEID;
		if ( ( ret = lfq_enqueue(ctx,p) ) != 0 ) {
			printf("lfq_enqueue failed, reason:%s\n", strerror(-ret));
			ATOMIC_ADD64(&cn_added, added);
			ATOMIC_SUB(&cn_producer, 1);
			return 0;
		}
	}
	ATOMIC_ADD64(&cn_added, added);
	ATOMIC_SUB(&cn_producer, 1);
	printf("Producer thread [%lu] exited! Still %d running...\n",THREAD_ID(), cn_producer);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x8, %edi
callq 0x1090
movq $0x27ce0af9, (%rax)     # imm = 0x27CE0AF9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x171c
testl %eax, %eax
jne 0x1253
incq %r14
cmpq $0x7a120, %r14          # imm = 0x7A120
jne 0x11f6
lock
addq $0x7a120, 0x2e62(%rip) # imm = 0x7A120
lock
decl 0x2e6f(%rip)            # 0x40a4
callq 0x10b0
movl 0x2e64(%rip), %edx      # 0x40a4
leaq 0xddc(%rip), %rdi       # 0x2023
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x127c
negl %eax
movl %eax, %edi
callq 0x10e0
leaq 0xda1(%rip), %rdi       # 0x2004
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
lock
addq %r14, 0x2e1b(%rip)      # 0x4090
lock
decl 0x2e28(%rip)            # 0x40a4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/darkautism[P]lfqueue/test_multithread.c
// Function: delq
THREAD_FN delq(void * data) {
	struct lfq_ctx * ctx = data;
	struct user_data * p;
	int tid = ATOMIC_ADD(&cn_t, 1);

	long deleted = 0;
	while(1) {
		p = lfq_dequeue_tid(ctx, tid);
		if (p) {
			if (p->data!=SOMEID){
				printf("data wrong!!\n");
				exit(1);
			}

			free(p);
			deleted++;
		} else {
			if (ctx->count || cn_producer)
				THREAD_YIELD(); // queue is empty, release CPU slice
			else
				break; // queue is empty and no more producers
		}
	}

	ATOMIC_ADD64(&cn_deled, deleted);

	// p = lfq_dequeue_tid(ctx, tid);
	printf("Consumer thread [%lu] exited %d\n",THREAD_ID(),cn_producer);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %ebx
lock
xaddl %ebx, 0x2e08(%rip)      # 0x40a0
movq %rdi, %r14
incl %ebx
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebx, %esi
callq 0x1760
testq %rax, %rax
jne 0x12c6
cmpl $0x0, 0x8(%r14)
jne 0x12bf
cmpl $0x0, 0x2de7(%rip)      # 0x40a4
je 0x12dc
callq 0x1070
jmp 0x12a0
cmpq $0x27ce0af9, (%rax)     # imm = 0x27CE0AF9
jne 0x1308
movq %rax, %rdi
callq 0x1030
incq %r15
jmp 0x12a0
lock
addq %r15, 0x2db4(%rip)      # 0x4098
callq 0x10b0
movl 0x2db5(%rip), %edx      # 0x40a4
leaq 0xd60(%rip), %rdi       # 0x2056
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdad(%rip), %rdi       # 0x20bc
callq 0x1050
movl $0x1, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/darkautism[P]lfqueue/test_multithread.c
// Function: main
int main() {
	struct lfq_ctx ctx;
	int i = 0;
	lfq_init(&ctx, MAX_CONSUMER);
	THREAD_TOKEN thread_d[MAX_CONSUMER];
	THREAD_TOKEN thread_a[MAX_PRODUCER];
	
	ATOMIC_ADD(&cn_producer, 1);
	for ( i = 0 ; i < MAX_CONSUMER ; i++ ) {
#if defined __GNUC__ || defined __CYGWIN__ || defined __MINGW32__
		pthread_create(&thread_d[i], NULL, delq, (void*)&ctx);
#else
#pragma warning(disable:4133)
		thread_d[i] = CreateThread(NULL, 0, delq, &ctx, 0, 0);
#endif
	}
	
	for ( i = 0 ; i < MAX_PRODUCER ; i++ ){
		ATOMIC_ADD(&cn_producer, 1);
#if defined __GNUC__ || defined __CYGWIN__ || defined __MINGW32__
		pthread_create(&thread_a[i], NULL, addq, (void*)&ctx);
#else
#pragma warning(disable:4133)
		thread_a[i] = CreateThread(NULL, 0, addq, &ctx, 0, 0);
#endif
		
	}
	
	ATOMIC_SUB(&cn_producer, 1);
	
	for (i = 0; i < MAX_PRODUCER; i++)
		THREAD_WAIT(thread_a[i]);
	
	for ( i = 0 ; i < MAX_CONSUMER ; i++ )
		THREAD_WAIT(thread_d[i]);

	long freecount = lfg_count_freelist(&ctx);
	int clean = lfq_clean(&ctx);

	printf("Total push %"PRId64" elements, pop %"PRId64" elements. freelist=%ld, clean = %d\n", cn_added, cn_deled, freecount, clean);
	if ( cn_added == cn_deled )
		printf("Test PASS!!\n");
	else
		printf("Test Failed!!\n");

	return (cn_added != cn_deled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
andq $-0x40, %rsp
subq $0x480, %rsp            # imm = 0x480
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl $0x64, %esi
callq 0x1470
lock
incl 0x2d56(%rip)            # 0x40a4
xorl %r15d, %r15d
leaq -0xd2(%rip), %r14       # 0x1286
leaq (%rsp,%r15), %rdi
addq $0x130, %rdi            # imm = 0x130
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10a0
addq $0x8, %r15
cmpq $0x320, %r15            # imm = 0x320
jne 0x1358
xorl %r15d, %r15d
leaq -0x19b(%rip), %rbx      # 0x11ec
leaq 0x80(%rsp), %r14
lock
incl 0x2d0e(%rip)            # 0x40a4
leaq (%rsp,%r15), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x10a0
addq $0x8, %r15
cmpq $0x50, %r15
jne 0x138f
lock
decl 0x2ce8(%rip)            # 0x40a4
xorl %ebx, %ebx
movq 0x30(%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x10d0
incq %rbx
cmpq $0xa, %rbx
jne 0x13be
xorl %ebx, %ebx
movq 0x130(%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x10d0
incq %rbx
cmpq $0x64, %rbx
jne 0x13d5
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0x152e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1543
movq 0x2c81(%rip), %rsi      # 0x4090
movq 0x2c82(%rip), %rdx      # 0x4098
leaq 0xc5a(%rip), %rdi       # 0x2077
movq %r14, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x1060
movq 0x2c5f(%rip), %rax      # 0x4090
cmpq 0x2c60(%rip), %rax      # 0x4098
leaq 0xc98(%rip), %rax       # 0x20d7
leaq 0xc83(%rip), %rdi       # 0x20c9
cmoveq %rax, %rdi
callq 0x1050
movq 0x2c3a(%rip), %rcx      # 0x4090
xorl %eax, %eax
cmpq 0x2c39(%rip), %rcx      # 0x4098
setne %al
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/minkcv[P]vm/convertsprite.c
// Function: getColorIndex
int getColorIndex(int rgba[4], int colors[4][3])
{
    int i;
    for (i = 0; i < 4; i++)
    {
        // Screw &&
        if (rgba[0] == colors[i][0])
        if (rgba[1] == colors[i][1])
        if (rgba[2] == colors[i][2])
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
addq $0x8, %rsi
xorl %eax, %eax
cmpl -0x8(%rsi), %ecx
jne 0x12cc
movl 0x4(%rdi), %edx
cmpl -0x4(%rsi), %edx
jne 0x12cc
movl 0x8(%rdi), %edx
cmpl (%rsi), %edx
je 0x12de
incq %rax
addq $0xc, %rsi
cmpq $0x4, %rax
jne 0x12b8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: movestep
int movestep(struct client *client, const union cb_arg arg)
{
    int16_t start_x;
    int16_t start_y;
    
    if (NULL == client)
    {
        return 0;
    }

    if (client->maxed)
    {
        /* We can't move a fully maximized window. */
        return 0;
    }

    /* Save pointer position so we can warp pointer here later. */
    if (!getpointer(client->id, &start_x, &start_y))
    {
        return 0;
    }

    raisewindow(client->id);
    switch (arg.c)
    {
    case 'h':
        client->x = client->x - MOVE_STEP;
        break;

    case 'j':
        client->y = client->y + MOVE_STEP;
        break;

    case 'k':
        client->y = client->y - MOVE_STEP;
        break;

    case 'l':
        client->x = client->x + MOVE_STEP;
        break;

    default:
        PDEBUG("movestep: Moving in unknown direction.\n");
        break;
    } /* switch direction */
    
    movelim(client);
    
    /*
     * If the pointer was inside the window to begin with, move
     * pointer back to where it was, relative to the window.
     */
    if (start_x > 0 - conf.borderwidth && start_x < client->width
        + conf.borderwidth && start_y > 0 - conf.borderwidth && start_y
        < client->height + conf.borderwidth)
    {
        xcb_warp_pointer(conn, XCB_NONE, client->id, 0, 0, 0, 0,
                         start_x, start_y);
        xcb_flush(conn);        
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x38ff
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
jne 0x38f8
movq %rsi, %r14
movl (%rbx), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x64dd
testb %al, %al
je 0x38f8
movl (%rbx), %edi
callq 0x618f
movsbl %r14b, %eax
addl $-0x68, %eax
cmpl $0x4, %eax
ja 0x388c
leaq 0x379b(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addw $-0x20, 0x6(%rbx)
jmp 0x388c
addw $-0x20, 0x8(%rbx)
jmp 0x388c
addw $0x20, 0x8(%rbx)
jmp 0x388c
addw $0x20, 0x6(%rbx)
movq %rbx, %rdi
callq 0x6532
movswl 0x6(%rsp), %eax
movl 0x70b1(%rip), %ecx      # 0xa950
movl %ecx, %edx
negl %edx
cmpl %edx, %eax
jle 0x38f8
movzwl 0xa(%rbx), %esi
addl %ecx, %esi
cmpl %eax, %esi
jle 0x38f8
movswl 0x4(%rsp), %r10d
cmpl %edx, %r10d
jle 0x38f8
movzwl 0xc(%rbx), %edx
addl %edx, %ecx
cmpl %r10d, %ecx
jle 0x38f8
movq 0x70aa(%rip), %rdi      # 0xa978
movl (%rbx), %edx
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3050
addq $0x20, %rsp
movq 0x7085(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: topleft
int topleft(struct client *client, const union cb_arg arg)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;
    int16_t mon_y;
    (void) client;
    (void) arg;
    
    if (NULL == focuswin)
    {
        return 0;
    }

    if (NULL == focuswin->monitor)
    {
        mon_x = 0;
        mon_y = 0;
    }
    else
    {
        mon_x = focuswin->monitor->x;
        mon_y = focuswin->monitor->y;        
    }
        
    raisewindow(focuswin->id);
    
    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return 0;
    }

    focuswin->x = mon_x;
    focuswin->y = mon_y;
    movewindow(focuswin->id, focuswin->x, focuswin->y);
    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
    return 0;
}

// Assembly:
movq 0x6cb2(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x3d39
pushq %rbp
pushq %rbx
pushq %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x3cad
movzwl 0x10(%rcx), %ebx
movzwl 0x12(%rcx), %ebp
jmp 0x3cb1
xorl %ebx, %ebx
xorl %ebp, %ebp
movl (%rax), %edi
callq 0x618f
movq 0x6c81(%rip), %rax      # 0xa940
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x64dd
testb %al, %al
je 0x3d33
movq 0x6c65(%rip), %rax      # 0xa940
movw %bx, 0x6(%rax)
movw %bp, 0x8(%rax)
movl (%rax), %edi
movzwl %bx, %esi
movzwl %bp, %edx
callq 0x623d
movq 0x6c81(%rip), %rdi      # 0xa978
movq 0x6c42(%rip), %rax      # 0xa940
movl (%rax), %edx
movswl 0x6(%rsp), %eax
movswl 0x4(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3050
addq $0x20, %rsp
movq 0x6c4a(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: topright
static int topright(struct client *client, const union cb_arg arg)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;    
    uint16_t mon_y;    
    uint16_t mon_width;
    (void) client;
    (void) arg;
    
    if (NULL == focuswin)
    {
        return 0;
    }

    if (NULL == focuswin->monitor)
    {
        mon_width = screen->width_in_pixels;
        mon_x = 0;
        mon_y = 0;
    }
    else
    {
        mon_width = focuswin->monitor->width;
        mon_x = focuswin->monitor->x;        
        mon_y = focuswin->monitor->y;
    }

    raisewindow(focuswin->id);
    
    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return 0;
    }

    focuswin->x = mon_x + mon_width -
        (focuswin->width + conf.borderwidth * 2);    

    focuswin->y = mon_y;
    
    movewindow(focuswin->id, focuswin->x, focuswin->y);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
    return 0;
}

// Assembly:
movq 0x6bfd(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x3e13
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x3d67
movzwl 0x10(%rcx), %ebx
movzwl 0x12(%rcx), %ebp
jmp 0x3d72
xorl %ebx, %ebx
movq 0x6bd8(%rip), %rcx      # 0xa948
xorl %ebp, %ebp
movzwl 0x14(%rcx), %r14d
movl (%rax), %edi
callq 0x618f
movq 0x6bbb(%rip), %rax      # 0xa940
movl (%rax), %edi
leaq 0xe(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x64dd
testb %al, %al
je 0x3e0b
movq 0x6b9f(%rip), %rax      # 0xa940
movzwl 0xa(%rax), %ecx
movl 0x6ba5(%rip), %edx      # 0xa950
addl %r14d, %ebx
leal (%rcx,%rdx,2), %ecx
subl %ecx, %ebx
movw %bx, 0x6(%rax)
movw %bp, 0x8(%rax)
movl (%rax), %edi
movzwl %bx, %esi
movzwl %bp, %edx
callq 0x623d
movq 0x6ba9(%rip), %rdi      # 0xa978
movq 0x6b6a(%rip), %rax      # 0xa940
movl (%rax), %edx
movswl 0xe(%rsp), %eax
movswl 0xc(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3050
addq $0x20, %rsp
movq 0x6b72(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: botleft
static int botleft(struct client *client, const union cb_arg arg)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;
    int16_t mon_y;
    uint16_t mon_height;
    (void) client;
    (void) arg;
    
    if (NULL == focuswin)
    {
        return 0;
    }

    if (NULL == focuswin->monitor)
    {
        mon_x = 0;
        mon_y = 0;
        mon_height = screen->height_in_pixels;
    }
    else
    {
        mon_x = focuswin->monitor->x;
        mon_y = focuswin->monitor->y;
        mon_height = focuswin->monitor->height;
    }
    
    raisewindow(focuswin->id);
    
    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return 0;
    }

    focuswin->x = mon_x;
    focuswin->y = mon_y + mon_height - (focuswin->height + conf.borderwidth
                                        * 2);
    movewindow(focuswin->id, focuswin->x, focuswin->y);
    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
    return 0;
}

// Assembly:
movq 0x6b23(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x3eed
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x3e41
movzwl 0x10(%rcx), %ebx
movzwl 0x12(%rcx), %ebp
jmp 0x3e4c
xorl %ebx, %ebx
movq 0x6afe(%rip), %rcx      # 0xa948
xorl %ebp, %ebp
movzwl 0x16(%rcx), %r14d
movl (%rax), %edi
callq 0x618f
movq 0x6ae1(%rip), %rax      # 0xa940
movl (%rax), %edi
leaq 0xe(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x64dd
testb %al, %al
je 0x3ee5
movq 0x6ac5(%rip), %rax      # 0xa940
movw %bx, 0x6(%rax)
movzwl 0xc(%rax), %ecx
movl 0x6ac7(%rip), %edx      # 0xa950
addl %r14d, %ebp
leal (%rcx,%rdx,2), %ecx
subl %ecx, %ebp
movw %bp, 0x8(%rax)
movl (%rax), %edi
movzwl %bp, %edx
movzwl %bx, %esi
callq 0x623d
movq 0x6acf(%rip), %rdi      # 0xa978
movq 0x6a90(%rip), %rax      # 0xa940
movl (%rax), %edx
movswl 0xe(%rsp), %eax
movswl 0xc(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3050
addq $0x20, %rsp
movq 0x6a98(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: botright
static int botright(struct client *client, const union cb_arg arg)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;
    int16_t mon_y;
    uint16_t mon_width;
    uint16_t mon_height;
    (void) client;
    (void) arg;

    if (NULL == focuswin)
    {
        return 0;
    }

    if (NULL == focuswin->monitor)
    {
        mon_x = 0;
        mon_y = 0;
        mon_width = screen->width_in_pixels;;        
        mon_height = screen->height_in_pixels;
    }
    else
    {
        mon_x = focuswin->monitor->x;
        mon_y = focuswin->monitor->y;
        mon_width = focuswin->monitor->width;
        mon_height = focuswin->monitor->height;
    }

    raisewindow(focuswin->id);
    
    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return 0;
    }

    focuswin->x = mon_x + mon_width - (focuswin->width + conf.borderwidth * 2);
    focuswin->y =  mon_y + mon_height - (focuswin->height + conf.borderwidth
                                         * 2);
    movewindow(focuswin->id, focuswin->x, focuswin->y);
    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
    return 0;
}

// Assembly:
movq 0x6a49(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x3fd7
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x3f1a
movzwl 0x10(%rcx), %ebx
movzwl 0x12(%rcx), %ebp
jmp 0x3f25
xorl %ebx, %ebx
movq 0x6a25(%rip), %rcx      # 0xa948
xorl %ebp, %ebp
movzwl 0x16(%rcx), %r14d
movzwl 0x14(%rcx), %r15d
movl (%rax), %edi
callq 0x618f
movq 0x6a03(%rip), %rax      # 0xa940
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x64dd
testb %al, %al
je 0x3fcd
movq 0x69e7(%rip), %rax      # 0xa940
movzwl 0xa(%rax), %ecx
movl 0x69ed(%rip), %edx      # 0xa950
addl %edx, %edx
addl %r15d, %ebx
subl %ecx, %ebx
subl %edx, %ebx
movw %bx, 0x6(%rax)
addl %r14d, %ebp
subl %edx, %ebp
subw 0xc(%rax), %bp
movw %bp, 0x8(%rax)
movl (%rax), %edi
movzwl %bx, %esi
movzwl %bp, %edx
callq 0x623d
movq 0x69e7(%rip), %rdi      # 0xa978
movq 0x69a8(%rip), %rax      # 0xa940
movl (%rax), %edx
movswl 0x6(%rsp), %eax
movswl 0x4(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3050
addq $0x20, %rsp
movq 0x69b0(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: deletewin
int deletewin(struct client *client, const union cb_arg arg)
{
    xcb_get_property_cookie_t cookie;
    xcb_icccm_get_wm_protocols_reply_t protocols;
    bool use_delete = false;
    uint32_t i;
    (void) client;
    (void) arg;

    if (NULL == focuswin)
    {
        return 0;
    }

    /* Check if WM_DELETE is supported.  */
    cookie = xcb_icccm_get_wm_protocols_unchecked(conn, focuswin->id,
                                                  wm_protocols);
    if (xcb_icccm_get_wm_protocols_reply(conn, cookie, &protocols, NULL) == 1)
    {
        for (i = 0; i < protocols.atoms_len; i++)
        {
            if (protocols.atoms[i] == wm_delete_window)
            {
                 use_delete = true;
            }
        }
    }

    xcb_icccm_get_wm_protocols_reply_wipe(&protocols);

    if (use_delete)
    {
        xcb_client_message_event_t ev = {
          .response_type = XCB_CLIENT_MESSAGE,
          .format = 32,
          .sequence = 0,
          .window = focuswin->id,
          .type = wm_protocols,
          .data.data32 = { wm_delete_window, XCB_CURRENT_TIME }
        };

        xcb_send_event(conn, false, focuswin->id,
                       XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
    }
    else
    {
        xcb_kill_client(conn, focuswin->id);
    }

    xcb_flush(conn);    
    return 0;
}

// Assembly:
movq 0x695f(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x40e2
pushq %rbx
subq $0x40, %rsp
movq 0x6982(%rip), %rdi      # 0xa978
movl (%rax), %esi
movl 0x6992(%rip), %edx      # 0xa990
callq 0x3460
movq 0x696e(%rip), %rdi      # 0xa978
leaq 0x8(%rsp), %rdx
movl %eax, %esi
xorl %ecx, %ecx
callq 0x3110
cmpb $0x1, %al
jne 0x40b2
movl 0x8(%rsp), %eax
testq %rax, %rax
je 0x40b2
movq 0x10(%rsp), %rcx
movl 0x694c(%rip), %edx      # 0xa984
xorl %esi, %esi
movl $0x1, %edi
xorl %ebx, %ebx
cmpl %edx, (%rcx,%rsi,4)
movzbl %bl, %ebx
cmovel %edi, %ebx
incq %rsi
cmpq %rsi, %rax
jne 0x4041
leaq 0x8(%rsp), %rdi
callq 0x30a0
testb $0x1, %bl
je 0x40bc
leaq 0x20(%rsp), %r8
movl $0x2021, (%r8)          # imm = 0x2021
movq 0x68cc(%rip), %rax      # 0xa940
movl (%rax), %ecx
movl %ecx, 0x4(%r8)
movl 0x6910(%rip), %ecx      # 0xa990
movl %ecx, 0x8(%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r8)
movl $0x0, 0x1c(%r8)
movl 0x68ea(%rip), %ecx      # 0xa984
movl %ecx, 0xc(%r8)
movq 0x68d3(%rip), %rdi      # 0xa978
movl (%rax), %edx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x3450
jmp 0x40d1
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq 0x68b5(%rip), %rdi      # 0xa978
movq 0x6876(%rip), %rax      # 0xa940
movl (%rax), %esi
callq 0x3530
movq 0x68a0(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x40, %rsp
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: prevscreen
int prevscreen(struct client *client, const union cb_arg arg)
{
    struct item *item;
    (void) client;
    (void) arg;
    
    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return 0;
    }

    item = focuswin->monitor->item->prev;

    if (NULL == item)
    {
        return 0;
    }
    
    focuswin->monitor = item->data;

    raisewindow(focuswin->id);    
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);    
    return 0;
}

// Assembly:
movq 0x6854(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x416a
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x416a
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x416a
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x618f
movq 0x6823(%rip), %rdi      # 0xa940
callq 0x42e8
movq 0x6817(%rip), %rdi      # 0xa940
callq 0x6532
movq 0x6843(%rip), %rdi      # 0xa978
movq 0x6804(%rip), %rax      # 0xa940
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x3050
addq $0x20, %rsp
movq 0x6817(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: nextscreen
int nextscreen(struct client *client, const union cb_arg arg)
{
    struct item *item;
    (void) client;
    (void) arg;
    
    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return 0;
    }

    item = focuswin->monitor->item->next;

    if (NULL == item)
    {
        return 0;
    }
    
    focuswin->monitor = item->data;

    raisewindow(focuswin->id);    
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);    
    return 0;
}

// Assembly:
movq 0x67cc(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x41f2
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x41f2
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x41f2
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x618f
movq 0x679b(%rip), %rdi      # 0xa940
callq 0x42e8
movq 0x678f(%rip), %rdi      # 0xa940
callq 0x6532
movq 0x67bb(%rip), %rdi      # 0xa978
movq 0x677c(%rip), %rax      # 0xa940
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x3050
addq $0x20, %rsp
movq 0x678f(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: iconify
int iconify(struct client *client, const union cb_arg arg)
{
    (void) arg;
    if (conf.allowicons)
    {
        hide(client);
        return 0;
    }
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x676a(%rip)      # 0xa974
jne 0x4262
movq %rdi, %r14
movaps 0x335a(%rip), %xmm0     # 0x7570
movq %rsp, %r15
movaps %xmm0, (%r15)
movq 0x6754(%rip), %rdi      # 0xa978
movl (%r14), %esi
callq 0x30d0
movq 0x6745(%rip), %rdi      # 0xa978
movl (%r14), %edx
movl 0x6750(%rip), %ecx      # 0xa98c
xorl %ebx, %ebx
xorl %esi, %esi
movl %ecx, %r8d
movl $0x20, %r9d
pushq %r15
pushq $0x2
callq 0x3520
addq $0x10, %rsp
movq 0x671b(%rip), %rdi      # 0xa978
callq 0x3150
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: printhelp
void printhelp(void)
{
    printf("mcwm: Usage: mcwm [-b] [-s snapmargin] [-t terminal-program] "
           "[-f colour] [-u colour] [-x colour] \n");
    printf("  -b means draw no borders\n");
    printf("  -s snapmargin in pixels\n");
    printf("  -t urxvt will start urxvt when MODKEY + Return is pressed\n");
    printf("  -f colour sets colour for focused window borders of focused "
           "to a named color.\n");
    printf("  -u colour sets colour for unfocused window borders.\n");
    printf("  -x color sets colour for fixed window borders.\n");    
}

// Assembly:
pushq %rax
leaq 0x27a0(%rip), %rdi      # 0x73bb
callq 0x30c0
leaq 0x27f6(%rip), %rdi      # 0x741d
callq 0x30c0
leaq 0x2805(%rip), %rdi      # 0x7438
callq 0x30c0
leaq 0x2813(%rip), %rdi      # 0x7452
callq 0x30c0
leaq 0x2843(%rip), %rdi      # 0x748e
callq 0x30c0
leaq 0x2887(%rip), %rdi      # 0x74de
callq 0x30c0
leaq 0x28b1(%rip), %rdi      # 0x7514
popq %rax
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: getcolor
uint32_t getcolor(const char *colstr)
{
    xcb_alloc_named_color_reply_t *col_reply;    
    xcb_colormap_t colormap; 
    xcb_generic_error_t *error;
    xcb_alloc_named_color_cookie_t colcookie;

    colormap = screen->default_colormap;
    colcookie = xcb_alloc_named_color(conn, colormap, strlen(colstr), colstr);
    col_reply = xcb_alloc_named_color_reply(conn, colcookie, &error);
    if (NULL != error)
    {
        fprintf(stderr, "mcwm: Couldn't get pixel value for colour %s. "
                "Exiting.\n", colstr);

        xcb_disconnect(conn);
        exit(1);
    }

    return col_reply->pixel;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x5ccd(%rip), %rax      # 0xa948
movl 0x4(%rax), %ebp
movq 0x5cf3(%rip), %r14      # 0xa978
callq 0x3140
movzwl %ax, %edx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x3330
movq 0x5cd7(%rip), %rdi      # 0xa978
leaq 0x8(%rsp), %r14
movl %eax, %esi
movq %r14, %rdx
callq 0x33a0
cmpq $0x0, (%r14)
jne 0x4cc2
movl 0x8(%rax), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: getatom
xcb_atom_t getatom(char *atom_name)
{
    xcb_intern_atom_cookie_t atom_cookie;
    xcb_atom_t atom;
    xcb_intern_atom_reply_t *rep;
    
    atom_cookie = xcb_intern_atom(conn, 0, strlen(atom_name), atom_name);
    rep = xcb_intern_atom_reply(conn, atom_cookie, NULL);
    if (NULL != rep)
    {
        atom = rep->atom;
        free(rep);
        return atom;
    }

    /*
     * XXX Note that we return 0 as an atom if anything goes wrong.
     * Might become interesting.
     */
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x5c9f(%rip), %r15      # 0xa978
callq 0x3140
movzwl %ax, %edx
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x31c0
movq 0x5c81(%rip), %rdi      # 0xa978
movl %eax, %esi
xorl %edx, %edx
callq 0x33f0
testq %rax, %rax
je 0x4d10
movl 0x8(%rax), %ebx
movq %rax, %rdi
callq 0x3040
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: cleanup
void cleanup(int code)
{
    xcb_set_input_focus(conn, XCB_NONE,
                        XCB_INPUT_FOCUS_POINTER_ROOT,
                        XCB_CURRENT_TIME);
    xcb_flush(conn);
    xcb_disconnect(conn);    
    exit(code);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x4a66(%rip), %rdi      # 0xa978
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x34d0
movq 0x4a51(%rip), %rdi      # 0xa978
callq 0x3150
movq 0x4a45(%rip), %rdi      # 0xa978
callq 0x3430
movl %ebx, %edi
callq 0x3500