LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_verify_bytes.c
// Function: crypto_verify_bytes
uint8_t
crypto_verify_bytes(const uint8_t * buf0, const uint8_t * buf1, size_t len)
{
	uint8_t rc = 0;
	size_t i;

	for (i = 0; i < len; i++)
		rc = rc | (buf0[i] ^ buf1[i]);

	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x11517
movzbl -0x19(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
xorl %edx, %ecx
orl %ecx, %eax
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x114dc
movb -0x19(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/util/fork_func.c
// Function: fork_func
pid_t
fork_func(int (* func)(void *), void * cookie)
{
	pid_t pid;

	/* Fork */
	switch (pid = fork()) {
	case -1:
		/* Error in fork system call. */
		warnp("fork");
		goto err0;
	case 0:
		/* In child process: Run the provided function, then exit. */
		_exit(func(cookie));
	default:
		/* In parent process: do nothing else. */
		break;
	}

	/* Success! */
	return (pid);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x23f0
movl %eax, -0x1c(%rbp)
movl %eax, %ecx
movl %ecx, -0x20(%rbp)
subl $-0x1, %eax
je 0x1378d
jmp 0x13784
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x137c6
jmp 0x137d7
jmp 0x1378f
callq 0x2340
cmpl $0x0, (%rax)
je 0x137b4
leaq 0x5a4d(%rip), %rdi      # 0x191ed
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x137c2
leaq 0x5a32(%rip), %rdi      # 0x191ed
movb $0x0, %al
callq 0x145e0
jmp 0x137c4
jmp 0x137e1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, %edi
callq 0x2180
jmp 0x137d9
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x137e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/util/fork_func.c
// Function: fork_func_wait
int
fork_func_wait(pid_t pid)
{
	int status;
	int rc = -1;

	/* Wait for the process to finish. */
	if (waitpid(pid, &status, 0) == -1) {
		warnp("waitpid");
		goto err0;
	}

	/* Print the error status, if applicable. */
	if (WIFEXITED(status)) {
		/* Child ${pid} exited cleanly. */
		rc = WEXITSTATUS(status);
	} else {
		/*
		 * Child ${pid} did not exit cleanly; warn about the reason
		 * for the unclean exit.
		 */
		if (WIFSIGNALED(status))
			warn0("pid %jd: terminated with signal %d",
			    (intmax_t)pid, WTERMSIG(status));
		else
			warn0("pid %jd: exited for an unknown reason",
			    (intmax_t)pid);
	}

err0:
	/* Done! */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x2310
cmpl $-0x1, %eax
jne 0x1385e
jmp 0x13827
callq 0x2340
cmpl $0x0, (%rax)
je 0x1384c
leaq 0x59ba(%rip), %rdi      # 0x191f2
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x1385a
leaq 0x599f(%rip), %rdi      # 0x191f2
movb $0x0, %al
callq 0x145e0
jmp 0x1385c
jmp 0x138d8
movl -0x8(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x13879
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x138d6
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x138b3
jmp 0x1388e
movslq -0x4(%rbp), %rsi
movl -0x8(%rbp), %edx
andl $0x7f, %edx
leaq 0x595b(%rip), %rdi      # 0x191fa
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x138d4
jmp 0x138b5
movslq -0x4(%rbp), %rsi
leaq 0x595d(%rip), %rdi      # 0x1921d
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x138d4
jmp 0x138d6
jmp 0x138d8
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/proto/proto_pipe.c
// Function: proto_pipe
void *
proto_pipe(int s_in, int s_out, int decr, struct proto_keys * k,
    int * status, int (* callback)(void *), void * cookie)
{
	struct pipe_cookie * P;

	/* Bake a cookie. */
	if ((P = malloc(sizeof(struct pipe_cookie))) == NULL)
		goto err0;
	P->callback = callback;
	P->cookie = cookie;
	P->status = status;
	P->s_in = s_in;
	P->s_out = s_out;
	P->decr = decr;
	P->k = k;
	P->write_cookie = NULL;

	/* Initialize reader. */
	if ((P->R = netbuf_read_init(P->s_in)) == NULL)
		goto err1;

	/* Set the minimum number of bytes to read. */
	P->minread = P->decr ? PCRYPT_ESZ : 1;

	/* Set the number of bytes in a full buffer. */
	P->full_buflen = P->decr ? PCRYPT_ESZ : PCRYPT_MAXDSZ;

	/* Start reading. */
	if (netbuf_read_wait(P->R, P->minread, callback_pipe_read, P))
		goto err2;

	/* Success! */
	return (P);

err2:
	netbuf_read_free(P->R);
err1:
	free(P);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x2178, %edi           # imm = 0x2178
callq 0x2150
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x1485a
jmp 0x14972
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x2158(%rax)
movq -0x38(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x15b60
movq -0x38(%rbp), %rcx
movq %rax, 0x2150(%rcx)
cmpq $0x0, %rax
jne 0x148d8
jmp 0x14969
movq -0x38(%rbp), %rax
movl 0x20(%rax), %edx
movl $0x1, %eax
movl $0x424, %ecx            # imm = 0x424
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x2168(%rax)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %edx
movl $0x400, %eax            # imm = 0x400
movl $0x424, %ecx            # imm = 0x424
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x2170(%rax)
movq -0x38(%rbp), %rax
movq 0x2150(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x2168(%rax), %rsi
movq -0x38(%rbp), %rcx
leaq 0x4d(%rip), %rdx        # 0x14990
callq 0x15c80
cmpl $0x0, %eax
je 0x1494f
jmp 0x14959
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1497a
movq -0x38(%rbp), %rax
movq 0x2150(%rax), %rdi
callq 0x161b0
movq -0x38(%rbp), %rdi
callq 0x2200
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/proto/proto_pipe.c
// Function: proto_pipe_cancel
void
proto_pipe_cancel(void * cookie)
{
	struct pipe_cookie * P = cookie;

	/* If a read or write is in progress, cancel it. */
	netbuf_read_wait_cancel(P->R);
	if (P->write_cookie)
		network_write_cancel(P->write_cookie);

	/* Clean up the buffered reader. */
	netbuf_read_free(P->R);

	/* Free the cookie. */
	free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2150(%rax), %rdi
callq 0x160d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2158(%rax)
je 0x14c62
movq -0x10(%rbp), %rax
movq 0x2158(%rax), %rdi
callq 0x16b00
movq -0x10(%rbp), %rax
movq 0x2150(%rax), %rdi
callq 0x161b0
movq -0x10(%rbp), %rdi
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/proto/proto_pipe.c
// Function: callback_pipe_write
static int
callback_pipe_write(void * cookie, ssize_t len)
{
	struct pipe_cookie * P = cookie;

	/* This write is no longer in progress. */
	P->write_cookie = NULL;

	/* Did we fail to write everything? */
	if (len < P->wlen)
		goto fail;

	/* Launch another read. */
	if (netbuf_read_wait(P->R, P->minread, callback_pipe_read, P))
		goto err0;

	/* Success! */
	return (0);

fail:
	/* Record that this connection is broken. */
	*(P->status) = -1;

	/* Inform the upstream that our status has changed. */
	return ((P->callback)(P->cookie));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x2158(%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x2160(%rcx), %rax
jge 0x14cca
jmp 0x14d00
movq -0x20(%rbp), %rax
movq 0x2150(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x2168(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq -0x35b(%rip), %rdx      # 0x14990
callq 0x15c80
cmpl $0x0, %eax
je 0x14cf7
jmp 0x14d24
movl $0x0, -0x4(%rbp)
jmp 0x14d2b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x14d2b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_09/getch.c
// Function: main
int main(void)
{
  int c;

  c = getch();
  putchar(c);

  ungetch(EOF);

  c = getch();
  putchar(c);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x11b0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1200
callq 0x11b0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: ecalloc
void*
ecalloc(size_t nmemb, size_t size){
	void* p;

	if ( !(p = calloc(nmemb, size)) )
		die("ecalloc failed");

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2625
leaq 0x5a66(%rip), %rdi      # 0x8084
movb $0x0, %al
callq 0x70a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: uitos
void
uitos(unsigned int ui, int len, char* dest){
	int i, j, res;
	int bytearray[len];
	char bytestr[len + 1];

	/* reverse the array, as tags are printed left to right, not right to left */
	for (i=0;i < len;i++)
		bytearray[i] = ui >> i & 1;

	for (i=0, j=0;
	(i < (len + 1)) && (res = snprintf(bytestr + j, (len + 1) - j, "%d", bytearray[i])) > 0;
	i++)
		j += res;

	snprintf(dest, len + 1, "%s", bytestr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x271a
movq -0x48(%rbp), %rax
movl -0x4(%rbp), %edx
movl -0x14(%rbp), %ecx
shrl %cl, %edx
andl $0x1, %edx
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26f1
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movl -0x8(%rbp), %edx
addl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x49(%rbp)
jge 0x2776
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rcx
addq %rcx, %rdi
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rsi
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x5930(%rip), %rdx      # 0x8093
movb $0x0, %al
callq 0x2080
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x277f
jmp 0x2793
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2728
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq 0x58eb(%rip), %rdx      # 0x8096
movb $0x0, %al
callq 0x2080
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: buttonpress
void
buttonpress(XEvent* e){
	int i;
	client* c;
	monitor* m;
	XButtonPressedEvent* ev = &e->xbutton;

	if ( (m = findmon(ev->window)) && m != curmon )
		changemon(m, NoFocus);

	if ( (c = findclient(ev->window)) ){
		if (c != c->mon->current)
			changecurrent(c, c->mon, c->mon->curdesk, 0);

		restack(c->mon);
		XAllowEvents(dis, ReplayPointer, CurrentTime);

		/* "all" our button functions are performed on a client */
		for (i=0;i < TABLENGTH(buttons);i++)
			if (buttons[i].func && buttons[i].btn == ev->button
			&& buttons[i].mask == ev->state)
				buttons[i].func(buttons[i].arg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5d50
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2803
movq -0x20(%rbp), %rax
cmpq 0x8d32(%rip), %rax      # 0xb528
je 0x2803
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x51e0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5df0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2919
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpq 0x28(%rcx), %rax
je 0x284e
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4150
movq 0x8c9e(%rip), %rdi      # 0xb500
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x22b0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x2, %rax
jae 0x2917
movslq -0xc(%rbp), %rcx
leaq 0x8c20(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x2907
movslq -0xc(%rbp), %rcx
leaq 0x8c07(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x2907
movslq -0xc(%rbp), %rcx
leaq 0x8be9(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jne 0x2907
movslq -0xc(%rbp), %rcx
leaq 0x8bcc(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rdx
leaq 0x8bb6(%rip), %rcx      # 0xb4b0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rdi
callq *%rax
jmp 0x2909
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2877
jmp 0x2919
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: motionnotify
void
motionnotify(XEvent* e){
	monitor* m;
	XMotionEvent* ev = &e->xmotion;

	if (ev->window != root)
		return;

	if ( (m = coordstomon(ev->x_root, ev->y_root)) && m != curmon)
		changemon(im, YesFocus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x8cad(%rip), %rax      # 0xb5f0
je 0x2947
jmp 0x2982
movq -0x18(%rbp), %rax
movl 0x48(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x5010
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2982
movq -0x10(%rbp), %rax
cmpq 0x8bb9(%rip), %rax      # 0xb528
je 0x2982
movq 0x8ba0(%rip), %rdi      # 0xb518
movl $0x1, %esi
callq 0x51e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: enternotify
void
enternotify(XEvent* e){
	client* c;
	monitor* m;
	XCrossingEvent* ev = &e->xcrossing;

	if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
		return;

	if ( !(c = findclient(ev->window)) || c == curmon->current )
		return;

	if ( (m = c->mon) && m != curmon )
		changemon(m, YesFocus);

	changecurrent(c, c->mon, c->mon->curdesk, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x29b8
movq -0x20(%rbp), %rax
cmpl $0x2, 0x54(%rax)
jne 0x29cb
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x8c29(%rip), %rax      # 0xb5f0
je 0x29cb
jmp 0x2a40
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5df0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x29f3
movq -0x10(%rbp), %rax
movq 0x8b3b(%rip), %rcx      # 0xb528
cmpq 0x28(%rcx), %rax
jne 0x29f5
jmp 0x2a40
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2a22
movq -0x18(%rbp), %rax
cmpq 0x8b16(%rip), %rax      # 0xb528
je 0x2a22
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x51e0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: destroynotify
void
destroynotify(XEvent* e){
	client* c;
	XDestroyWindowEvent* ev = &e->xdestroywindow;

	if ( (c = findclient(ev->window)) )
		unmanage(c, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5df0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2ad9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6200
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: unmapnotify
void
unmapnotify(XEvent* e){
	client* c;
	XUnmapEvent* ev = &e->xunmap;

	if ( (c = findclient(ev->window)) )
		unmanage(c, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5df0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2b16
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: maprequest
void
maprequest(XEvent* e){
	XWindowAttributes wa;
	XMapRequestEvent* ev = &e->xmaprequest;

	if (!XGetWindowAttributes(dis, ev->window, &wa) || wa.override_redirect)
		return;

	if (!findclient(ev->window))
		manage(ev->window, &wa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x89bf(%rip), %rdi      # 0xb500
movq -0x98(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x90(%rbp), %rdx
callq 0x23f0
cmpl $0x0, %eax
je 0x2b63
cmpl $0x0, -0x18(%rbp)
je 0x2b65
jmp 0x2b92
movq -0x98(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5df0
cmpq $0x0, %rax
jne 0x2b92
movq -0x98(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x90(%rbp), %rsi
callq 0x62d0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: configurenotify
void
configurenotify(XEvent* e){
	XConfigureEvent* ev = &e->xconfigure;

	if (ev->window == root){
		sw = ev->width; sh = ev->height;
		updategeom();

		for EACHMON(mhead){
			for EACHCLIENT(im->head)
				if (ic->isfull)
					resizeclient(ic, im->mx, im->my, im->mw, im->mh);

			arrange(im);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x8a2d(%rip), %rax      # 0xb5f0
jne 0x2c9d
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x8a36(%rip)      # 0xb60c
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x8a2d(%rip)      # 0xb610
callq 0x5e90
movq 0x8a11(%rip), %rax      # 0xb600
movq %rax, 0x8922(%rip)      # 0xb518
cmpq $0x0, 0x891a(%rip)      # 0xb518
je 0x2c9b
movq 0x890d(%rip), %rax      # 0xb518
movq 0x30(%rax), %rax
movq %rax, 0x88fa(%rip)      # 0xb510
cmpq $0x0, 0x88f2(%rip)      # 0xb510
je 0x2c78
movq 0x88e9(%rip), %rax      # 0xb510
cmpl $0x0, 0x18(%rax)
je 0x2c62
movq 0x88dc(%rip), %rdi      # 0xb510
movq 0x88dd(%rip), %rax      # 0xb518
movl 0x8(%rax), %esi
movq 0x88d3(%rip), %rax      # 0xb518
movl 0xc(%rax), %edx
movq 0x88c9(%rip), %rax      # 0xb518
movl 0x14(%rax), %ecx
movq 0x88bf(%rip), %rax      # 0xb518
movl 0x10(%rax), %r8d
callq 0x4260
jmp 0x2c64
movq 0x88a5(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x889a(%rip)      # 0xb510
jmp 0x2c16
movq 0x8899(%rip), %rdi      # 0xb518
callq 0x3ef0
movq 0x888d(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x8882(%rip)      # 0xb518
jmp 0x2bf6
jmp 0x2c9d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: changemsize
void
changemsize(const Arg arg){
	parser[WantFloat](arg.s, &parg);
	curmon->msize += ( ((curmon->msize < 0.95 * curmon->mw) && (parg.f > 0))
			|| ((curmon->msize > 0.05 * curmon->mw) && (parg.f < 0)) )
		? parg.f * curmon->mw : 0;

	arrange(curmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8465(%rip), %rax      # 0xb3b8
movq -0x8(%rbp), %rdi
leaq 0x85c2(%rip), %rsi      # 0xb520
callq *%rax
movq 0x85c1(%rip), %rax      # 0xb528
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movq 0x85b2(%rip), %rax      # 0xb528
cvtsi2sdl 0x14(%rax), %xmm2
movsd 0x5085(%rip), %xmm0     # 0x8008
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2f9d
movss 0x858b(%rip), %xmm0     # 0xb520
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
ja 0x2fd6
movq 0x8584(%rip), %rax      # 0xb528
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x8575(%rip), %rax      # 0xb528
cvtsi2sdl 0x14(%rax), %xmm2
movsd 0x5050(%rip), %xmm1     # 0x8010
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2ff5
xorps %xmm0, %xmm0
ucomiss 0x854c(%rip), %xmm0     # 0xb520
jbe 0x2ff5
movss 0x8542(%rip), %xmm0     # 0xb520
movq 0x8543(%rip), %rax      # 0xb528
cvtsi2ssl 0x14(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x2fff
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x2fff
movss -0xc(%rbp), %xmm0
movq 0x851d(%rip), %rax      # 0xb528
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq 0x850e(%rip), %rdi      # 0xb528
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: focusmon
void
focusmon(const Arg arg){
	monitor* m;

	if (!mhead->next)
		return;

	parser[WantInt](arg.s, &parg);

	if ( (m = dirtomon(parg.i)) && m == curmon )
		return;
	changemon(m, YesFocus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x85bd(%rip), %rax      # 0xb600
cmpq $0x0, 0x48(%rax)
jne 0x304c
jmp 0x3092
movq 0x835d(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x84c2(%rip), %rsi      # 0xb520
callq *%rax
movl 0x84ba(%rip), %edi      # 0xb520
callq 0x58d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3084
movq -0x10(%rbp), %rax
cmpq 0x84a8(%rip), %rax      # 0xb528
jne 0x3084
jmp 0x3092
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x51e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: killclient
void
killclient(const Arg arg){
	if (!curmon->current)
		return;

	if (!xsendkill(curmon->current->win)){
		XGrabServer(dis);
		XSetCloseDownMode(dis, DestroyAll);
		XKillClient(dis, curmon->current->win);
		XSync(dis, False);
		XUngrabServer(dis);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8475(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
jne 0x30bc
jmp 0x3124
movq 0x8465(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x3c30
cmpl $0x0, %eax
jne 0x3124
movq 0x8424(%rip), %rdi      # 0xb500
callq 0x20c0
movq 0x8418(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x20f0
movq 0x840a(%rip), %rdi      # 0xb500
movq 0x842b(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x24c0
movq 0x83ef(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
movq 0x83e1(%rip), %rdi      # 0xb500
callq 0x2240
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: moveclient
void
moveclient(const Arg arg){
	client* c;

	if (!curmon->current || curmon->current->isfull)
		return;
	
	parser[WantInt](arg.s, &parg);

	if (!(SAFEPARG(-1,1)))
		return;

	/* move current up, or move next visible up (i.e. move current down) */
	c = (parg.i > 0) ? curmon->current : findvisclient(curmon->current->next, WantTiled);

	if (c){
		moveclientup(c);
		arrange(c->mon);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x83e5(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x315b
movq 0x83d7(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x3160
jmp 0x31e8
movq 0x8249(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x83ae(%rip), %rsi      # 0xb520
callq *%rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x83a1(%rip), %eax      # 0xb520
jg 0x318a
cmpl $0x1, 0x8398(%rip)      # 0xb520
jle 0x318c
jmp 0x31e8
cmpl $0x0, 0x838d(%rip)      # 0xb520
jle 0x31a6
movq 0x838c(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x31c3
movq 0x837b(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq 0x28(%rax), %rdi
movl $0x1, %esi
callq 0x3d70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x31e8
movq -0x10(%rbp), %rdi
callq 0x3e00
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3ef0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: movefocus
void
movefocus(const Arg arg){
	client* j, * c = NULL;

	if (!curmon->current || curmon->current->isfull)
		return;

	parser[WantInt](arg.s, &parg);

	/* up stack */
	if (parg.i > 0){
		for (j=curmon->head;j && j != curmon->current;j=j->next)
			if (ISVISIBLE(j))
				c = j;

		/* if curmon->current was highest, go to the bottom */
		if (!c)
			for (;j;j=j->next)
				if (ISVISIBLE(j))
					c = j;

	/* down stack, wrap around */
	} else if (parg.i < 0) {
		if ( !(c = findvisclient(curmon->current->next, WantFloating)) )
			c = findvisclient(curmon->head, WantFloating);
	}

	if (c && c != curmon->current){
		changecurrent(c, curmon, curmon->curdesk, 0);
		restack(curmon);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x831d(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x3223
movq 0x830f(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x3228
jmp 0x3377
movq 0x8181(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x82e6(%rip), %rsi      # 0xb520
callq *%rax
cmpl $0x0, 0x82dd(%rip)      # 0xb520
jle 0x32f4
movq 0x82d8(%rip), %rax      # 0xb528
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x3279
movq -0x10(%rbp), %rax
movq 0x82b9(%rip), %rcx      # 0xb528
cmpq 0x28(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3282
jmp 0x32b1
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x32a1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x32a3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3258
cmpq $0x0, -0x18(%rbp)
jne 0x32f2
jmp 0x32ba
cmpq $0x0, -0x10(%rbp)
je 0x32f0
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x32e0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x32e2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x32ba
jmp 0x32f2
jmp 0x3337
cmpl $0x0, 0x8225(%rip)      # 0xb520
jge 0x3335
movq 0x8224(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x3d70
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3333
movq 0x8204(%rip), %rax      # 0xb528
movq 0x30(%rax), %rdi
xorl %esi, %esi
callq 0x3d70
movq %rax, -0x18(%rbp)
jmp 0x3335
jmp 0x3337
cmpq $0x0, -0x18(%rbp)
je 0x3377
movq -0x18(%rbp), %rax
movq 0x81df(%rip), %rcx      # 0xb528
cmpq 0x28(%rcx), %rax
je 0x3377
movq -0x18(%rbp), %rdi
movq 0x81ce(%rip), %rsi      # 0xb528
movq 0x81c7(%rip), %rax      # 0xb528
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
movq 0x81b6(%rip), %rdi      # 0xb528
callq 0x4150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: quit
void
quit(const Arg arg){

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(0,1))
		return;

	if (parg.i > 0)
		restart = 1;

	running = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x801d(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x8182(%rip), %rsi      # 0xb520
callq *%rax
xorl %eax, %eax
cmpl 0x8178(%rip), %eax      # 0xb520
jg 0x33b3
cmpl $0x1, 0x816f(%rip)      # 0xb520
jle 0x33b5
jmp 0x33d2
cmpl $0x0, 0x8164(%rip)      # 0xb520
jle 0x33c8
movl $0x1, 0x8140(%rip)      # 0xb508
movl $0x0, 0x8236(%rip)      # 0xb608
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: todesktop
void
todesktop(const Arg arg){
	if (!curmon->current)
		return;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(0,NUMTAGS))
		return;

	if (curmon->current->desks == (1 << parg.i))
		return;

	curmon->current->desks = 1 << parg.i;
	curmon->current->iscur = 0;
	changecurrent(curmon->current, curmon, 1 << parg.i, 1);

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8135(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
jne 0x33ff
jmp 0x34b7
movq 0x7faa(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x810f(%rip), %rsi      # 0xb520
callq *%rax
xorl %eax, %eax
cmpl 0x8105(%rip), %eax      # 0xb520
jg 0x3426
cmpl $0x9, 0x80fc(%rip)      # 0xb520
jle 0x342b
jmp 0x34b7
movq 0x80f6(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
movl 0x80e1(%rip), %ecx      # 0xb520
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jne 0x344e
jmp 0x34b7
movl 0x80cc(%rip), %ecx      # 0xb520
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x80c4(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x80b6(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl $0x0, 0x20(%rax)
movq 0x80a4(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
movq 0x8099(%rip), %rsi      # 0xb528
movl 0x808b(%rip), %ecx      # 0xb520
movl $0x1, %edx
shll %cl, %edx
movl $0x1, %ecx
callq 0x45a0
movq 0x807b(%rip), %rdi      # 0xb528
callq 0x3ef0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: toggledesktop
void
toggledesktop(const Arg arg){
	unsigned int newdesks;

	if (!curmon->current)
		return;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(-1,NUMTAGS))
		return;

	if (parg.i < 0)
		newdesks = curmon->current->desks | ~(curmon->current->desks);
	else
		newdesks = curmon->current->desks ^ (1 << parg.i);

	if (newdesks){
		curmon->current->desks = newdesks;
		/* set current to be current on new desktop
		 * if it will no longer be visible, adjust current
		 */
		changecurrent(curmon->current, curmon, 1 << parg.i,
			(curmon->current->desks & curmon->seldesks) ? 0 : 1);

		arrange(curmon);
		outputstats();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8055(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
jne 0x34df
jmp 0x35d3
movq 0x7eca(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x802f(%rip), %rsi      # 0xb520
callq *%rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x8022(%rip), %eax      # 0xb520
jg 0x3509
cmpl $0x9, 0x8019(%rip)      # 0xb520
jle 0x350e
jmp 0x35d3
cmpl $0x0, 0x800b(%rip)      # 0xb520
jge 0x353d
movq 0x800a(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
movq 0x7ffc(%rip), %rcx      # 0xb528
movq 0x28(%rcx), %rcx
movl 0x1c(%rcx), %ecx
xorl $-0x1, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x355f
movq 0x7fe4(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
movl 0x7fcf(%rip), %ecx      # 0xb520
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x35d3
movl -0xc(%rbp), %ecx
movq 0x7fb9(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x7fab(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
movq 0x7fa0(%rip), %rsi      # 0xb528
movl 0x7f92(%rip), %ecx      # 0xb520
movl $0x1, %edx
shll %cl, %edx
movq 0x7f8c(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x1c(%rax), %r8d
movq 0x7f7d(%rip), %rax      # 0xb528
andl 0x24(%rax), %r8d
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %r8d
cmovnel %eax, %ecx
callq 0x45a0
movq 0x7f5f(%rip), %rdi      # 0xb528
callq 0x3ef0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: togglefloat
void
togglefloat(const Arg arg){
	if (!curmon->current || curmon->current->isfull)
		return;

	if (curmon->curlayout->arrange == &floaty)
		return;

	curmon->current->isfloat = !curmon->current->isfloat;
	arrange(curmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7f35(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x360b
movq 0x7f27(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x360d
jmp 0x365a
movq 0x7f14(%rip), %rax      # 0xb528
movq 0x40(%rax), %rax
leaq 0x1951(%rip), %rcx      # 0x4f70
cmpq %rcx, 0x8(%rax)
jne 0x3627
jmp 0x365a
movq 0x7efa(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x7ee1(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl %ecx, 0x10(%rax)
movq 0x7ed3(%rip), %rdi      # 0xb528
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: togglefs
void
togglefs(const Arg arg){
	if (!curmon->current)
		return;

	if ( (curmon->current->isfull = !curmon->current->isfull) ){
		curmon->current->oldfloat = curmon->current->isfloat;
		curmon->current->isfloat = 0;

		resizeclient(curmon->current, curmon->mx, curmon->my,
				curmon->mw, curmon->mh);
#ifdef _SHAPE_H_
		unroundcorners(curmon->current);
#endif
		XRaiseWindow(dis, curmon->current->win);

	} else {
		curmon->current->isfloat = curmon->current->oldfloat;
		arrange(curmon);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7eb5(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
jne 0x367f
jmp 0x376e
movq 0x7ea2(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %edx
movq 0x7e86(%rip), %rcx      # 0xb528
movq 0x28(%rcx), %rcx
movl %edx, 0x18(%rcx)
testb $0x1, %al
jne 0x36b2
jmp 0x3746
movq 0x7e6f(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x10(%rax), %ecx
movq 0x7e61(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl %ecx, 0x14(%rax)
movq 0x7e53(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl $0x0, 0x10(%rax)
movq 0x7e41(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
movq 0x7e36(%rip), %rax      # 0xb528
movl 0x8(%rax), %esi
movq 0x7e2c(%rip), %rax      # 0xb528
movl 0xc(%rax), %edx
movq 0x7e22(%rip), %rax      # 0xb528
movl 0x14(%rax), %ecx
movq 0x7e18(%rip), %rax      # 0xb528
movl 0x10(%rax), %r8d
callq 0x4260
movq 0x7e08(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
callq 0x57b0
movq 0x7dd0(%rip), %rdi      # 0xb500
movq 0x7df1(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x2100
jmp 0x376e
movq 0x7ddb(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x14(%rax), %ecx
movq 0x7dcd(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl %ecx, 0x10(%rax)
movq 0x7dbf(%rip), %rdi      # 0xb528
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: toggleview
void
toggleview(const Arg arg){
	int i;
	unsigned int tagmask;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(-1,NUMTAGS))
		return;

	if (parg.i < 0)
		tagmask = ~(curmon->seldesks);
	else
		tagmask = 1 << parg.i;

	/* if this would leave nothing visible */
	if ((curmon->seldesks ^ tagmask) == 0)
		return;

	if (curmon->current && curmon->current->isfull)
		togglefs(dumbarg);

	curmon->seldesks ^= tagmask;

	if (!(curmon->seldesks & 1 << curmon->curdesk)){
		for (i=0;i < NUMTAGS;i++){
			if (curmon->seldesks & 1 << i){
				loaddesktop(i);
				curmon->curdesk = i;
				break;
			}
		}
	}

	/* refocuses, toggles off curmon->current's currentness */
	if (curmon->current && !ISVISIBLE(curmon->current))
		changecurrent(curmon->current, curmon, curmon->curdesk, 1);

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7c1d(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x7d82(%rip), %rsi      # 0xb520
callq *%rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x7d75(%rip), %eax      # 0xb520
jg 0x37b6
cmpl $0x9, 0x7d6c(%rip)      # 0xb520
jle 0x37bb
jmp 0x3916
cmpl $0x0, 0x7d5e(%rip)      # 0xb520
jge 0x37d6
movq 0x7d5d(%rip), %rax      # 0xb528
movl 0x24(%rax), %eax
xorl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x37e6
movl 0x7d44(%rip), %ecx      # 0xb520
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movq 0x7d3b(%rip), %rax      # 0xb528
movl 0x24(%rax), %eax
xorl -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x37fd
jmp 0x3916
movq 0x7d24(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x3828
movq 0x7d16(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x3828
movq 0x484d(%rip), %rdi      # 0x8070
callq 0x3660
movl -0x10(%rbp), %ecx
movq 0x7cf6(%rip), %rax      # 0xb528
xorl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movq 0x7ce9(%rip), %rax      # 0xb528
movl 0x24(%rax), %eax
movq 0x7cdf(%rip), %rcx      # 0xb528
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x38ac
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x38aa
movq 0x7cb8(%rip), %rax      # 0xb528
movl 0x24(%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x389d
movl -0xc(%rbp), %edi
callq 0x5ca0
movl -0xc(%rbp), %ecx
movq 0x7c90(%rip), %rax      # 0xb528
movl %ecx, 0x4(%rax)
jmp 0x38aa
jmp 0x389f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3863
jmp 0x38ac
movq 0x7c75(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x3905
movq 0x7c67(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
movq 0x7c59(%rip), %rcx      # 0xb528
movq 0x28(%rcx), %rcx
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
jne 0x3905
movq 0x7c42(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
movq 0x7c37(%rip), %rsi      # 0xb528
movq 0x7c30(%rip), %rax      # 0xb528
movl 0x4(%rax), %edx
movl $0x1, %ecx
callq 0x45a0
movq 0x7c1c(%rip), %rdi      # 0xb528
callq 0x3ef0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: tomon
void
tomon(const Arg arg){
	if (!curmon->current || !mhead->next)
		return;
	
	parser[WantInt](arg.s, &parg);

	sendmon(curmon->current, dirtomon(parg.i));
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7bf5(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x3948
movq 0x7cbf(%rip), %rax      # 0xb600
cmpq $0x0, 0x48(%rax)
jne 0x394a
jmp 0x3989
movq 0x7a5f(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x7bc4(%rip), %rsi      # 0xb520
callq *%rax
movq 0x7bc3(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x7bad(%rip), %edi      # 0xb520
callq 0x58d0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x50c0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: setlayout
void
setlayout(const Arg arg){
	int i;
	for (i=0;i < TABLENGTH(layouts);i++)
		if (STREQ(arg.s, layouts[i].name))
			curmon->curlayout = (layout*) &layouts[i];

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x3, %rax
jae 0x39fb
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x7364(%rip), %rax      # 0xad20
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x2370
cmpl $0x0, %eax
jne 0x39ee
movslq -0xc(%rbp), %rax
leaq 0x7344(%rip), %rcx      # 0xad20
imulq $0x18, %rax, %rax
addq %rax, %rcx
movq 0x7b3e(%rip), %rax      # 0xb528
movq %rcx, 0x40(%rax)
jmp 0x39f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39a3
movq 0x7b26(%rip), %rdi      # 0xb528
callq 0x3ef0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: view
void
view(const Arg arg){
	client* c;

	parser[WantInt](arg.s, &parg);

	if (!SAFEPARG(0,NUMTAGS))
		return;

	if (curmon->current && curmon->current->isfull)
		togglefs(dumbarg);

	loaddesktop(parg.i);
	curmon->seldesks = 1 << parg.i;
	curmon->curdesk = parg.i;

	if ( (c = findcurrent(curmon)) )
		/* rezero, so it can be set and everyone else unset */
		c->iscur ^= 1 << curmon->curdesk;
	else
		c = findvisclient(curmon->head, WantFloating);
		
	changecurrent(c, curmon, curmon->curdesk, 0);

	arrange(curmon);
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x797d(%rip), %rax      # 0xb3b0
movq -0x8(%rbp), %rdi
leaq 0x7ae2(%rip), %rsi      # 0xb520
callq *%rax
xorl %eax, %eax
cmpl 0x7ad8(%rip), %eax      # 0xb520
jg 0x3a53
cmpl $0x9, 0x7acf(%rip)      # 0xb520
jle 0x3a58
jmp 0x3b2f
movq 0x7ac9(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x3a83
movq 0x7abb(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x3a83
movq 0x45f2(%rip), %rdi      # 0x8070
callq 0x3660
movl 0x7a97(%rip), %edi      # 0xb520
callq 0x5ca0
movl 0x7a8c(%rip), %ecx      # 0xb520
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x7a84(%rip), %rax      # 0xb528
movl %ecx, 0x24(%rax)
movl 0x7a73(%rip), %ecx      # 0xb520
movq 0x7a74(%rip), %rax      # 0xb528
movl %ecx, 0x4(%rax)
movq 0x7a6a(%rip), %rdi      # 0xb528
callq 0x54a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3aec
movq 0x7a54(%rip), %rax      # 0xb528
movl 0x4(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
xorl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0x3b02
movq 0x7a35(%rip), %rax      # 0xb528
movq 0x30(%rax), %rdi
xorl %esi, %esi
callq 0x3d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x7a1b(%rip), %rsi      # 0xb528
movq 0x7a14(%rip), %rax      # 0xb528
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
movq 0x7a03(%rip), %rdi      # 0xb528
callq 0x3ef0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: zoom
void
zoom(const Arg arg){
	client* c;

	if (!(c = curmon->current))
		return;

	detach(c, 1);
	attach(c, 0);
	arrange(c->mon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x79d5(%rip), %rax      # 0xb528
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3b63
jmp 0x3b89
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5240
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x52f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: main
int
main(){
	if ( !(dis = XOpenDisplay(NULL)) )
		die("Cannot open display!");
	XSetErrorHandler(xerror);
	setup();

	adopt();
	start();

	if (restart)
		execlp("sara", "sara");

	cleanup();
        XCloseDisplay(dis);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21a0
movq %rax, 0x7951(%rip)      # 0xb500
cmpq $0x0, %rax
jne 0x3bc3
leaq 0x4564(%rip), %rdi      # 0x8120
movb $0x0, %al
callq 0x70a0
leaq 0x56(%rip), %rdi        # 0x3c20
callq 0x2410
callq 0x67c0
callq 0x68f0
callq 0x6a50
cmpl $0x0, 0x7923(%rip)      # 0xb508
je 0x3bf8
leaq 0x4547(%rip), %rsi      # 0x8135
movq %rsi, %rdi
movb $0x0, %al
callq 0x2160
callq 0x6fa0
movq 0x78fc(%rip), %rdi      # 0xb500
callq 0x21c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: xsendkill
int
xsendkill(Window w){
	int n;
	Atom* protocols;
	XEvent ev;
	int exists = 0;
	Atom destproto = XInternAtom(dis, "WM_DELETE_WINDOW", False);

	if (XGetWMProtocols(dis, w, &protocols, &n)){
		while (!exists && n--)
			exists = (protocols[n] == destproto);
		XFree(protocols);
	}

	if (exists){
		ev.type = ClientMessage;
		ev.xclient.window = w;
		ev.xclient.message_type = XInternAtom(dis, "WM_PROTOCOLS", True);
		ev.xclient.format = 32;
		ev.xclient.data.l[0] = destproto;
		ev.xclient.data.l[1] = CurrentTime;
		XSendEvent(dis, w, False, NoEventMask, &ev);
	}

	return exists;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xdc(%rbp)
movq 0x78b0(%rip), %rdi      # 0xb500
leaq 0x44e3(%rip), %rsi      # 0x813a
xorl %edx, %edx
callq 0x23c0
movq %rax, -0xe8(%rbp)
movq 0x7894(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x2450
cmpl $0x0, %eax
je 0x3ce4
jmp 0x3c84
xorl %eax, %eax
cmpl $0x0, -0xdc(%rbp)
movb %al, -0xe9(%rbp)
jne 0x3cac
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x3cb8
jmp 0x3cdb
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0xe8(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xdc(%rbp)
jmp 0x3c84
movq -0x18(%rbp), %rdi
callq 0x2040
cmpl $0x0, -0xdc(%rbp)
je 0x3d61
movl $0x21, -0xd8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq 0x77f7(%rip), %rdi      # 0xb500
leaq 0x443b(%rip), %rsi      # 0x814b
movl $0x1, %edx
callq 0x23c0
movq %rax, -0xb0(%rbp)
movl $0x20, -0xa8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq 0x77b5(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
callq 0x2350
movl -0xdc(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq