LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movw $0x4, -0x10(%rbp)
movw $0x0, -0xe(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
movl $0x1388, %edx           # imm = 0x1388
callq 0x1160
cltq
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x20(%rbp)
movb %al, -0x29(%rbp)
jne 0x2b5d
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x4, (%rcx)
movb %al, -0x29(%rbp)
jne 0x2b5d
cmpl $0x0, 0x367d(%rip)      # 0x61d4
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2b19
movswl -0xe(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2bae
movq -0x8(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x2620
movzwl %ax, %eax
addl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x77, %edx
callq 0x2640
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: get_client_id
static void get_client_id(QMI_PROXY_CONNECTION *qmi_con, PQMICTL_GET_CLIENT_ID_RESP_MSG pClient) {
    if (pClient->QMIResult == 0 && pClient->QMIError == 0) {
        QMI_PROXY_CLINET *qmi_client = (QMI_PROXY_CLINET *)malloc(sizeof(QMI_PROXY_CLINET));

        qlist_init(&qmi_client->qnode);
        qmi_client->QMIType = pClient->QMIType;
        qmi_client->ClientId = pClient->ClientId;
        qmi_client->AccessTime = 0;

        dprintf("+++ ClientFd=%d QMIType=%d ClientId=%d\n", qmi_con->ClientFd, qmi_client->QMIType, qmi_client->ClientId);
        qlist_add_tail(&qmi_con->client_qnode, &qmi_client->qnode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x9(%rax), %eax
cmpl $0x0, %eax
jne 0x2c82
movq -0x10(%rbp), %rax
movzwl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x2c82
movl $0x18, %edi
callq 0x1140
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2350
movq -0x10(%rbp), %rax
movb 0x10(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rax
movb 0x11(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x11(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq 0x3399(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1340
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %r8d
movq -0x18(%rbp), %rax
movzbl 0x11(%rax), %r9d
leaq 0x1754(%rip), %rsi      # 0x43be
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x2aa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: release_client_id
static void release_client_id(QMI_PROXY_CONNECTION *qmi_con, PQMICTL_RELEASE_CLIENT_ID_RESP_MSG pClient) {
    struct qlistnode *client_node;
    
    if (pClient->QMIResult == 0 && pClient->QMIError == 0) {
        qlist_for_each (client_node, &qmi_con->client_qnode) {
            QMI_PROXY_CLINET *qmi_client = qnode_to_item(client_node, QMI_PROXY_CLINET, qnode);
            
            if (pClient->QMIType == qmi_client->QMIType && pClient->ClientId == qmi_client->ClientId) {
                dprintf("--- ClientFd=%d QMIType=%d ClientId=%d\n", qmi_con->ClientFd, qmi_client->QMIType, qmi_client->ClientId);
                qlist_remove(&qmi_client->qnode);
                free(qmi_client);
                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x9(%rax), %eax
cmpl $0x0, %eax
jne 0x2d7e
movq -0x10(%rbp), %rax
movzwl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x2d7e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x2d7c
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x2d6a
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
jne 0x2d6a
jmp 0x2d15
movq 0x32b4(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1340
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %r9d
leaq 0x169a(%rip), %rsi      # 0x43e9
movb $0x0, %al
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x2a70
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x2d7c
jmp 0x2d6c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2cce
jmp 0x2d7e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl 0x338e(%rip), %eax      # 0x6130
movl %eax, -0x10(%rbp)
movw $0x4, -0xc(%rbp)
movw $0x0, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1388, %edx           # imm = 0x1388
callq 0x1160
cltq
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x18(%rbp)
movb %al, -0x21(%rbp)
jne 0x2dfd
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x4, (%rcx)
movb %al, -0x21(%rbp)
jne 0x2dfd
cmpl $0x0, 0x33dd(%rip)      # 0x61d4
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2db9
movswl -0xa(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2e54
movq -0x8(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x2620
movzwl %ax, %eax
addl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
movl 0x3301(%rip), %edi      # 0x6130
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl 0x32e6(%rip), %esi      # 0x6130
movl $0x77, %edx
callq 0x2640
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x7a120, -0x28(%rbp)   # imm = 0x7A120
jge 0x1293
movl $0x8, %edi
callq 0x1090
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x27ce0af9, (%rax)     # imm = 0x27CE0AF9
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x19e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x1283
movl -0x1c(%rbp), %edi
negl %edi
callq 0x10e0
movq %rax, %rsi
leaq 0xda5(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
movq -0x28(%rbp), %rax
lock
addq %rax, 0x2e1e(%rip)      # 0x4090
lock
decl 0x2e2b(%rip)            # 0x40a4
movq $0x0, -0x8(%rbp)
jmp 0x12ca
jmp 0x1285
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1213
movq -0x28(%rbp), %rax
lock
addq %rax, 0x2df1(%rip)      # 0x4090
lock
decl 0x2dfe(%rip)            # 0x40a4
callq 0x10b0
movq %rax, %rsi
movl 0x2df0(%rip), %edx      # 0x40a4
leaq 0xd68(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1050
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %eax
lock
xaddl %eax, 0x2d9f(%rip)      # 0x40a0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1a60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1362
movq -0x18(%rbp), %rax
cmpq $0x27ce0af9, (%rax)     # imm = 0x27CE0AF9
je 0x134b
leaq 0xd1c(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x10c0
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1384
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x1379
movl 0x2d30(%rip), %eax      # 0x40a4
cmpl $0x0, %eax
je 0x1380
callq 0x1070
jmp 0x1382
jmp 0x1386
jmp 0x1384
jmp 0x130f
movq -0x28(%rbp), %rax
lock
addq %rax, 0x2d06(%rip)      # 0x4098
callq 0x10b0
movq %rax, %rsi
movl 0x2d04(%rip), %edx      # 0x40a4
leaq 0xcbd(%rip), %rdi       # 0x2064
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1351
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x1344
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x1342
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0x1340
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1358
jmp 0x1342
jmp 0x1344
jmp 0x1346
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/getopt-longjmp/main.c
// Function: main
int
main(int argc, char * argv[])
{
	int err = 0;

	/* Run tests; keep on going on failure. */
	if (getopt_int(argc, argv)) {
		fprintf(stderr, "Error in getopt_int\n");
		err++;
	}
	optreset = 1;
	if (getopt_int_int(argc, argv)) {
		fprintf(stderr, "Error in getopt_int_int\n");
		err++;
	}
	optreset = 1;
	if (getopt_int_int_enum(argc, argv)) {
		fprintf(stderr, "Error in getopt_int_int_enum\n");
		err++;
	}

	/* Did we fail anything? */
	if (err > 0)
		goto err0;

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12c0
cmpl $0x0, %eax
je 0x121f
movq 0x3df3(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e1d(%rip), %rsi      # 0x302c
movb $0x0, %al
callq 0x1090
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq 0x3e5a(%rip), %rax      # 0x5080
movl $0x1, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1420
cmpl $0x0, %eax
je 0x125e
movq 0x3db4(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1df3(%rip), %rsi      # 0x3041
movb $0x0, %al
callq 0x1090
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq 0x3e1b(%rip), %rax      # 0x5080
movl $0x1, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x15e0
cmpl $0x0, %eax
je 0x129d
movq 0x3d75(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1dcd(%rip), %rsi      # 0x305a
movb $0x0, %al
callq 0x1090
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x12a5
jmp 0x12ac
xorl %edi, %edi
callq 0x10c0
movl $0x1, %edi
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/getopt-longjmp/main.c
// Function: getopt_int
static int
getopt_int(int argc, char * argv[])
{
	/* Command-line arguments. */
	int a = 0;

	/* Working variable. */
	const char * ch;

	/* Parse with magic getopt. */
	while ((ch = GETOPT(argc, argv)) != NULL) {
		GETOPT_SWITCH(ch) {
		GETOPT_OPT("-a"):
			a = 1;
			break;
		GETOPT_DEFAULT:
			break;
		}
	}

	/* Check for undesired assignment. */
	if (a == 1)
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13ef
movq $0x17, -0x28(%rbp)
movq -0x28(%rbp), %rax
decq %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0x4(%rip), %rax         # 0x1315
movq %rax, -0x40(%rbp)
leaq 0x3d84(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x1337
movq -0x20(%rbp), %rdi
callq 0x1eb0
movq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
jmp 0x134a
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
subq $0x18, %rax
je 0x1366
jmp 0x135a
movq -0x50(%rbp), %rax
subq $0x1b, %rax
je 0x13a1
jmp 0x13b0
leaq 0x3d33(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x1374
jmp 0x1398
movq -0x28(%rbp), %rax
movl $0x18, %esi
subq %rax, %rsi
leaq 0x1cf1(%rip), %rdi      # 0x3078
xorl %edx, %edx
callq 0x2000
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x1410
movl $0x1, -0x14(%rbp)
jmp 0x13ea
leaq 0x3cf8(%rip), %rax      # 0x50a0
movl $0x1, (%rax)
jmp 0x13ea
leaq 0x3ce9(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x13be
jmp 0x13e8
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
jne 0x13de
movq -0x28(%rbp), %rax
movl $0x1b, %edi
subq %rax, %rdi
callq 0x2350
movl $0x1, -0x34(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x1410
jmp 0x13ea
jmp 0x12d6
cmpl $0x1, -0x14(%rbp)
jne 0x13f7
jmp 0x1400
movl $0x0, -0x4(%rbp)
jmp 0x1407
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rax
jmpq *%rax
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/getopt-longjmp/main.c
// Function: getopt_int_int
static int
getopt_int_int(int argc, char * argv[])
{
	/* Command-line arguments. */
	int a = 0;
	int b = 0;

	/* Working variable. */
	const char * ch;

	/* Parse with magic getopt. */
	while ((ch = GETOPT(argc, argv)) != NULL) {
		GETOPT_SWITCH(ch) {
		GETOPT_OPT("-a"):
			a = 1;
			break;
		GETOPT_OPT("-b"):
			b = 1;
			break;
		GETOPT_DEFAULT:
			break;
		}
	}

	/* Check for undesired assignment. */
	if ((a == 1) || (b == 1))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x15aa
movq $0x39, -0x28(%rbp)
movq -0x28(%rbp), %rax
decq %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0x4(%rip), %rax         # 0x147c
movq %rax, -0x40(%rbp)
leaq 0x3c1d(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x149e
movq -0x20(%rbp), %rdi
callq 0x1eb0
movq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
jmp 0x14b1
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
subq $0x3a, %rax
je 0x14e0
jmp 0x14c1
movq -0x50(%rbp), %rax
subq $0x3d, %rax
je 0x1521
jmp 0x14cd
movq -0x50(%rbp), %rax
subq $0x40, %rax
je 0x155c
jmp 0x156b
leaq 0x3bb9(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x14ee
jmp 0x1515
movq -0x28(%rbp), %rax
movl $0x3a, %esi
subq %rax, %rsi
leaq 0x1b77(%rip), %rdi      # 0x3078
xorl %edx, %edx
callq 0x2000
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x15d1
movl $0x1, -0x14(%rbp)
jmp 0x15a5
leaq 0x3b78(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x152f
jmp 0x1553
movq -0x28(%rbp), %rax
movl $0x3d, %esi
subq %rax, %rsi
leaq 0x1b39(%rip), %rdi      # 0x307b
xorl %edx, %edx
callq 0x2000
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x15d1
movl $0x1, -0x18(%rbp)
jmp 0x15a5
leaq 0x3b3d(%rip), %rax      # 0x50a0
movl $0x1, (%rax)
jmp 0x15a5
leaq 0x3b2e(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x1579
jmp 0x15a3
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
jne 0x1599
movq -0x28(%rbp), %rax
movl $0x40, %edi
subq %rax, %rdi
callq 0x2350
movl $0x1, -0x34(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x15d1
jmp 0x15a5
jmp 0x143d
cmpl $0x1, -0x14(%rbp)
je 0x15b6
cmpl $0x1, -0x18(%rbp)
jne 0x15b8
jmp 0x15c1
movl $0x0, -0x4(%rbp)
jmp 0x15c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rax
jmpq *%rax
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/getopt-longjmp/main.c
// Function: getopt_int_int_enum
static int
getopt_int_int_enum(int argc, char * argv[])
{
	/* Command-line arguments. */
	int a = 0;
	int b = 0;
	enum E E = ZERO;

	/* Working variable. */
	const char * ch;

	/* Parse with magic getopt. */
	while ((ch = GETOPT(argc, argv)) != NULL) {
		GETOPT_SWITCH(ch) {
		GETOPT_OPT("-a"):
			a = 1;
			break;
		GETOPT_OPT("-b"):
			b = 1;
			break;
		GETOPT_OPT("-E"):
			E = ONE;
			break;
		GETOPT_DEFAULT:
			break;
		}
	}

	/* Check for undesired assignment. */
	if ((a == 1) || (b == 1) || (E == ONE))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x17b0
movq $0x63, -0x30(%rbp)
movq -0x30(%rbp), %rax
decq %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
leaq 0x4(%rip), %rax         # 0x1643
movq %rax, -0x48(%rbp)
leaq 0x3a56(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x1665
movq -0x28(%rbp), %rdi
callq 0x1eb0
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x1678
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $-0x64, %rax
movq %rax, -0x58(%rbp)
subq $0x9, %rax
ja 0x1771
movq -0x58(%rbp), %rax
leaq 0x196b(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x39f7(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x16b0
jmp 0x16d7
movq -0x30(%rbp), %rax
movl $0x64, %esi
subq %rax, %rsi
leaq 0x19b5(%rip), %rdi      # 0x3078
xorl %edx, %edx
callq 0x2000
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x17dd
movl $0x1, -0x14(%rbp)
jmp 0x17ab
leaq 0x39b6(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x16f1
jmp 0x1718
movq -0x30(%rbp), %rax
movl $0x67, %esi
subq %rax, %rsi
leaq 0x1977(%rip), %rdi      # 0x307b
xorl %edx, %edx
callq 0x2000
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x17dd
movl $0x1, -0x18(%rbp)
jmp 0x17ab
leaq 0x3975(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x1732
jmp 0x1759
movq -0x30(%rbp), %rax
movl $0x6a, %esi
subq %rax, %rsi
leaq 0x1939(%rip), %rdi      # 0x307e
xorl %edx, %edx
callq 0x2000
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x17dd
movl $0x1, -0x1c(%rbp)
jmp 0x17ab
leaq 0x3937(%rip), %rax      # 0x50a0
movl $0x1, (%rax)
jmp 0x17ab
leaq 0x3928(%rip), %rax      # 0x50a0
cmpl $0x0, (%rax)
je 0x177f
jmp 0x17a9
movl -0x3c(%rbp), %eax
cmpl $0x0, %eax
jne 0x179f
movq -0x30(%rbp), %rax
movl $0x6d, %edi
subq %rax, %rdi
callq 0x2350
movl $0x1, -0x3c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x17dd
jmp 0x17ab
jmp 0x1604
cmpl $0x1, -0x14(%rbp)
je 0x17c2
cmpl $0x1, -0x18(%rbp)
je 0x17c2
cmpl $0x1, -0x1c(%rbp)
jne 0x17c4
jmp 0x17cd
movl $0x0, -0x4(%rbp)
jmp 0x17d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rax
jmpq *%rax
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x98b7(%rip), %rax      # 0xd940
jne 0x4097
movl $0x0, -0x4(%rbp)
jmp 0x41a2
movq 0x98a2(%rip), %rcx      # 0xd940
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x40b4
movw $0x0, -0x1e(%rbp)
movw $0x0, -0x20(%rbp)
jmp 0x40da
movq 0x9885(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x10(%rax), %ax
movw %ax, -0x1e(%rbp)
movq 0x9872(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x12(%rax), %ax
movw %ax, -0x20(%rbp)
movq 0x985f(%rip), %rax      # 0xd940
movl (%rax), %edi
callq 0x6f50
movq 0x9851(%rip), %rax      # 0xd940
movl (%rax), %edi
leaq -0x1a(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x7540
testb $0x1, %al
jne 0x410e
movl $0x0, -0x4(%rbp)
jmp 0x41a2
movw -0x1e(%rbp), %cx
movq 0x9827(%rip), %rax      # 0xd940
movw %cx, 0x6(%rax)
movw -0x20(%rbp), %cx
movq 0x9818(%rip), %rax      # 0xd940
movw %cx, 0x8(%rax)
movq 0x980d(%rip), %rax      # 0xd940
movl (%rax), %edi
movq 0x9804(%rip), %rax      # 0xd940
movw 0x6(%rax), %cx
movq 0x97f9(%rip), %rax      # 0xd940
movzwl %cx, %esi
movzwl 0x8(%rax), %edx
callq 0x7080
movq 0x981e(%rip), %rdi      # 0xd978
movq 0x97df(%rip), %rax      # 0xd940
movl (%rax), %edx
movw -0x1a(%rbp), %ax
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
cwtl
movl %eax, 0x8(%rsp)
movswl -0x1c(%rbp), %eax
movl %eax, 0x10(%rsp)
callq 0x3050
movl %eax, -0x24(%rbp)
movq 0x97e2(%rip), %rdi      # 0xd978
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x9777(%rip), %rax      # 0xd940
jne 0x41d7
movl $0x0, -0x4(%rbp)
jmp 0x4324
movq 0x9762(%rip), %rcx      # 0xd940
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x4203
movq 0x975b(%rip), %rax      # 0xd948
movw 0x14(%rax), %ax
movw %ax, -0x22(%rbp)
movw $0x0, -0x1e(%rbp)
movw $0x0, -0x20(%rbp)
jmp 0x423c
movq 0x9736(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x14(%rax), %ax
movw %ax, -0x22(%rbp)
movq 0x9723(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x10(%rax), %ax
movw %ax, -0x1e(%rbp)
movq 0x9710(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x12(%rax), %ax
movw %ax, -0x20(%rbp)
movq 0x96fd(%rip), %rax      # 0xd940
movl (%rax), %edi
callq 0x6f50
movq 0x96ef(%rip), %rax      # 0xd940
movl (%rax), %edi
leaq -0x1a(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x7540
testb $0x1, %al
jne 0x4270
movl $0x0, -0x4(%rbp)
jmp 0x4324
movswl -0x1e(%rbp), %eax
movzwl -0x22(%rbp), %ecx
addl %ecx, %eax
movq 0x96bf(%rip), %rcx      # 0xd940
movzwl 0xa(%rcx), %ecx
movl 0x96c5(%rip), %edx      # 0xd950
shll %edx
addl %edx, %ecx
subl %ecx, %eax
movw %ax, %cx
movq 0x96a5(%rip), %rax      # 0xd940
movw %cx, 0x6(%rax)
movw -0x20(%rbp), %cx
movq 0x9696(%rip), %rax      # 0xd940
movw %cx, 0x8(%rax)
movq 0x968b(%rip), %rax      # 0xd940
movl (%rax), %edi
movq 0x9682(%rip), %rax      # 0xd940
movw 0x6(%rax), %cx
movq 0x9677(%rip), %rax      # 0xd940
movzwl %cx, %esi
movzwl 0x8(%rax), %edx
callq 0x7080
movq 0x969c(%rip), %rdi      # 0xd978
movq 0x965d(%rip), %rax      # 0xd940
movl (%rax), %edx
movw -0x1a(%rbp), %ax
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
cwtl
movl %eax, 0x8(%rsp)
movswl -0x1c(%rbp), %eax
movl %eax, 0x10(%rsp)
callq 0x3050
movl %eax, -0x28(%rbp)
movq 0x9660(%rip), %rdi      # 0xd978
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x95f7(%rip), %rax      # 0xd940
jne 0x4357
movl $0x0, -0x4(%rbp)
jmp 0x44a4
movq 0x95e2(%rip), %rcx      # 0xd940
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x4383
movw $0x0, -0x1e(%rbp)
movw $0x0, -0x20(%rbp)
movq 0x95cf(%rip), %rax      # 0xd948
movw 0x16(%rax), %ax
movw %ax, -0x22(%rbp)
jmp 0x43bc
movq 0x95b6(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x10(%rax), %ax
movw %ax, -0x1e(%rbp)
movq 0x95a3(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x12(%rax), %ax
movw %ax, -0x20(%rbp)
movq 0x9590(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movw 0x16(%rax), %ax
movw %ax, -0x22(%rbp)
movq 0x957d(%rip), %rax      # 0xd940
movl (%rax), %edi
callq 0x6f50
movq 0x956f(%rip), %rax      # 0xd940
movl (%rax), %edi
leaq -0x1a(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x7540
testb $0x1, %al
jne 0x43f0
movl $0x0, -0x4(%rbp)
jmp 0x44a4
movw -0x1e(%rbp), %cx
movq 0x9545(%rip), %rax      # 0xd940
movw %cx, 0x6(%rax)
movswl -0x20(%rbp), %eax
movzwl -0x22(%rbp), %ecx
addl %ecx, %eax
movq 0x9530(%rip), %rcx      # 0xd940
movzwl 0xc(%rcx), %ecx
movl 0x9536(%rip), %edx      # 0xd950
shll %edx
addl %edx, %ecx
subl %ecx, %eax
movw %ax, %cx
movq 0x9516(%rip), %rax      # 0xd940
movw %cx, 0x8(%rax)
movq 0x950b(%rip), %rax      # 0xd940
movl (%rax), %edi
movq 0x9502(%rip), %rax      # 0xd940
movw 0x6(%rax), %cx
movq 0x94f7(%rip), %rax      # 0xd940
movzwl %cx, %esi
movzwl 0x8(%rax), %edx
callq 0x7080
movq 0x951c(%rip), %rdi      # 0xd978
movq 0x94dd(%rip), %rax      # 0xd940
movl (%rax), %edx
movw -0x1a(%rbp), %ax
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
cwtl
movl %eax, 0x8(%rsp)
movswl -0x1c(%rbp), %eax
movl %eax, 0x10(%rsp)
callq 0x3050
movl %eax, -0x28(%rbp)
movq 0x94e0(%rip), %rdi      # 0xd978
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x9167(%rip), %rax      # 0xd940
je 0x47ea
movq 0x915e(%rip), %rcx      # 0xd940
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x47f6
movl $0x0, -0x4(%rbp)
jmp 0x48a7
movq 0x9143(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x4821
movl $0x0, -0x4(%rbp)
jmp 0x48a7
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x9111(%rip), %rax      # 0xd940
movq %rcx, 0x38(%rax)
movq 0x9106(%rip), %rax      # 0xd940
movl (%rax), %edi
callq 0x6f50
movq 0x90f8(%rip), %rdi      # 0xd940
callq 0x4ac0
movq 0x90ec(%rip), %rdi      # 0xd940
callq 0x75d0
movq 0x9118(%rip), %rdi      # 0xd978
movq 0x90d9(%rip), %rax      # 0xd940
movl (%rax), %edx
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x3050
movl %eax, -0x24(%rbp)
movq 0x90dd(%rip), %rdi      # 0xd978
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x9077(%rip), %rax      # 0xd940
je 0x48da
movq 0x906e(%rip), %rcx      # 0xd940
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x48e6
movl $0x0, -0x4(%rbp)
jmp 0x4997
movq 0x9053(%rip), %rax      # 0xd940
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x4911
movl $0x0, -0x4(%rbp)
jmp 0x4997
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x9021(%rip), %rax      # 0xd940
movq %rcx, 0x38(%rax)
movq 0x9016(%rip), %rax      # 0xd940
movl (%rax), %edi
callq 0x6f50
movq 0x9008(%rip), %rdi      # 0xd940
callq 0x4ac0
movq 0x8ffc(%rip), %rdi      # 0xd940
callq 0x75d0
movq 0x9028(%rip), %rdi      # 0xd978
movq 0x8fe9(%rip), %rax      # 0xd940
movl (%rax), %edx
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x3050
movl %eax, -0x24(%rbp)
movq 0x8fed(%rip), %rdi      # 0xd978
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
testb $0x1, 0x8fbd(%rip)      # 0xd974
je 0x49cb
movq -0x18(%rbp), %rdi
callq 0x78d0
movl $0x0, -0x4(%rbp)
jmp 0x49d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: prevws
int prevws(struct client *client, const union cb_arg arg)
{
    (void) client;
    (void) arg;
    if (curws > 0)
    {
        changeworkspace(curws - 1);
    }
    else 
    {
        changeworkspace(WORKSPACES - 1);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x8ec9(%rip)      # 0xd8c0
jbe 0x4a09
movl 0x8ec1(%rip), %edi      # 0xd8c0
subl $0x1, %edi
callq 0x6be0
jmp 0x4a13
movl $0x9, %edi
callq 0x6be0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: arrbymon
void arrbymon(struct monitor *monitor)
{
    struct item *item;
    struct client *client;

    PDEBUG("arrbymon\n");
    /*
     * Go through all windows on this monitor. If they don't fit on
     * the new screen, move them around and resize them as necessary.
     *
     * FIXME: Use a per monitor workspace list instead of global
     * windows list.
     */
    for (item = winlist; item != NULL; item = item->next)
    {
        client = item->data;
        if (client->monitor == monitor)
        {
            fitonscreen(client);
        }
    } /* for */

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8e55(%rip), %rax      # 0xd8c8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ab0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x4aa0
movq -0x18(%rbp), %rdi
callq 0x4ac0
jmp 0x4aa2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4a77
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x4951(%rip), %rdi      # 0xa29c
movb $0x0, %al
callq 0x3150
leaq 0x49a6(%rip), %rdi      # 0xa2ff
movb $0x0, %al
callq 0x3150
leaq 0x49b4(%rip), %rdi      # 0xa31b
movb $0x0, %al
callq 0x3150
leaq 0x49c1(%rip), %rdi      # 0xa336
movb $0x0, %al
callq 0x3150
leaq 0x49f0(%rip), %rdi      # 0xa373
movb $0x0, %al
callq 0x3150
leaq 0x4a33(%rip), %rdi      # 0xa3c4
movb $0x0, %al
callq 0x3150
leaq 0x4a5c(%rip), %rdi      # 0xa3fb
movb $0x0, %al
callq 0x3150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7f85(%rip), %rax      # 0xd948
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x7fa8(%rip), %rax      # 0xd978
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x8(%rbp), %rcx
movzwl %ax, %edx
callq 0x3330
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq 0x7f72(%rip), %rdi      # 0xd978
movl -0x24(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x33a0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x5a50
movq 0x75d3(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x49fa(%rip), %rsi      # 0xa42d
movb $0x0, %al
callq 0x32d0
movq 0x7f37(%rip), %rdi      # 0xd978
callq 0x3430
movl $0x1, %edi
callq 0x3500
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: setuprandr
int setuprandr(void)
{
    const xcb_query_extension_reply_t *extension;
    int base;
        
    extension = xcb_get_extension_data(conn, &xcb_randr_id);
    if (!extension->present)
    {
        PDEBUG("No RANDR extension.\n");
        return -1;
    }
    else
    {
        getrandr();
    }

    base = extension->first_event;
    PDEBUG("randrbase is %d.\n", base);
        
    xcb_randr_select_input(conn, screen->root,
                           XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
                           XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
                           XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
                           XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);

    xcb_flush(conn);

    return base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x7e79(%rip), %rdi      # 0xd978
movq 0x74da(%rip), %rsi      # 0xcfe0
callq 0x3060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8(%rax)
jne 0x5b22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b61
callq 0x7960
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x7e3f(%rip), %rdi      # 0xd978
movq 0x7e08(%rip), %rax      # 0xd948
movl (%rax), %esi
movl $0xf, %edx
callq 0x3030
movl %eax, -0x18(%rbp)
movq 0x7e22(%rip), %rdi      # 0xd978
callq 0x3140
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x6dd6(%rip), %rdi      # 0xd978
xorl %ecx, %ecx
movl $0x1, %edx
movl %ecx, %esi
callq 0x34d0
movl %eax, -0x8(%rbp)
movq 0x6dbe(%rip), %rdi      # 0xd978
callq 0x3140
movq 0x6db2(%rip), %rdi      # 0xd978
callq 0x3430
movl -0x4(%rbp), %edi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: setunfocus
void setunfocus(xcb_drawable_t win)
{
    uint32_t values[1];

    if (NULL == focuswin)
    {
        return;
    }
    
    if (focuswin->id == screen->root)
    {
        return;
    }

    /* Set new border colour. */
    values[0] = conf.unfocuscol;
    xcb_change_window_attributes(conn, win, XCB_CW_BORDER_PIXEL, values);

    xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
cmpq 0x6c2c(%rip), %rax      # 0xd940
jne 0x6d18
jmp 0x6d5e
movq 0x6c21(%rip), %rax      # 0xd940
movl (%rax), %eax
movq 0x6c20(%rip), %rcx      # 0xd948
cmpl (%rcx), %eax
jne 0x6d2e
jmp 0x6d5e
movl 0x6c38(%rip), %eax      # 0xd96c
movl %eax, -0x8(%rbp)
movq 0x6c3a(%rip), %rdi      # 0xd978
movl -0x4(%rbp), %esi
leaq -0x8(%rbp), %rcx
movl $0x8, %edx
callq 0x30e0
movl %eax, -0xc(%rbp)
movq 0x6c1f(%rip), %rdi      # 0xd978
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: raisewindow
void raisewindow(xcb_drawable_t win)
{
    uint32_t values[] = { XCB_STACK_MODE_ABOVE };

    if (screen->root == win || 0 == win)
    {
        return;
    }
    
    xcb_configure_window(conn, win,
                         XCB_CONFIG_WINDOW_STACK_MODE,
                         values);
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x31c0
movq 0x69d6(%rip), %rax      # 0xd948
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x6f80
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jne 0x6f82
jmp 0x6fa9
movq 0x69ef(%rip), %rdi      # 0xd978
movl -0x4(%rbp), %esi
leaq -0x8(%rbp), %rcx
movl $0x40, %edx
callq 0x3200
movl %eax, -0xc(%rbp)
movq 0x69d4(%rip), %rdi      # 0xd978
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: addtoworkspace
void addtoworkspace(struct client *client, uint32_t ws)
{
    struct item *item;
    
    item = additem(&wslist[ws]);
    if (NULL == item)
    {
        PDEBUG("addtoworkspace: Out of memory.\n");
        return;
    }

    /* Remember our place in the workspace window list. */
    client->wsitem[ws] = item;

    /* Remember the data. */
    item->data = client;

    /*
     * Set window hint property so we can survive a crash.
     * 
     * Fixed windows have their own special WM hint. We don't want to
     * mess with that.
     */
    if (!client->fixed)
    {
        setwmdesktop(client->id, ws);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x6917(%rip), %rdi      # 0xd8e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0x9480
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6fe3
jmp 0x7016
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rdx, 0x48(%rax,%rcx,8)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x32(%rax)
jne 0x7016
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl -0xc(%rbp), %esi
callq 0x6eb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: setborders
void setborders(struct client *client, int width)
{
    uint32_t values[1];
    uint32_t mask = 0;
    
    values[0] = width;

    mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
    xcb_configure_window(conn, client->id, mask, &values[0]);
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x14(%rbp)
movq 0x692c(%rip), %rdi      # 0xd978
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0x14(%rbp), %eax
leaq -0x10(%rbp), %rcx
movzwl %ax, %edx
callq 0x3200
movl %eax, -0x18(%rbp)
movq 0x690d(%rip), %rdi      # 0xd978
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: movewindow
void movewindow(xcb_drawable_t win, uint16_t x, uint16_t y)
{
    uint32_t values[2];

    if (screen->root == win || 0 == win)
    {
        /* Can't move root. */
        return;
    }
    
    values[0] = x;
    values[1] = y;

    xcb_configure_window(conn, win, XCB_CONFIG_WINDOW_X
                         | XCB_CONFIG_WINDOW_Y, values);
    
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movq 0x68a8(%rip), %rax      # 0xd948
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x70ae
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jne 0x70b0
jmp 0x70e5
movzwl -0x6(%rbp), %eax
movl %eax, -0x10(%rbp)
movzwl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x68b3(%rip), %rdi      # 0xd978
movl -0x4(%rbp), %esi
leaq -0x10(%rbp), %rcx
movl $0x3, %edx
callq 0x3200
movl %eax, -0x14(%rbp)
movq 0x6898(%rip), %rdi      # 0xd978
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/mcwm.c
// Function: resize
void resize(xcb_drawable_t win, uint16_t width, uint16_t height)
{
    uint32_t values[2];

    if (screen->root == win || 0 == win)
    {
        /* Can't resize root. */
        return;
    }

    PDEBUG("Resizing to %d x %d.\n", width, height);
    
    values[0] = width;
    values[1] = height;
                                        
    xcb_configure_window(conn, win,
                         XCB_CONFIG_WINDOW_WIDTH
                         | XCB_CONFIG_WINDOW_HEIGHT, values);
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movq 0x6838(%rip), %rax      # 0xd948
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x711e
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jne 0x7120
jmp 0x7155
movzwl -0x6(%rbp), %eax
movl %eax, -0x10(%rbp)
movzwl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x6843(%rip), %rdi      # 0xd978
movl -0x4(%rbp), %esi
leaq -0x10(%rbp), %rcx
movl $0xc, %edx
callq 0x3200
movl %eax, -0x14(%rbp)
movq 0x6828(%rip), %rdi      # 0xd978
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)