LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: findvisclient
client*
findvisclient(client* c, int wantfloat){
	for EACHCLIENT(c)
		if (ISVISIBLE(ic))
			if ((!wantfloat && !ic->isfloat) || wantfloat)
				return ic;
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x778a(%rip)      # 0xb510
cmpq $0x0, 0x7782(%rip)      # 0xb510
je 0x3deb
movq 0x7779(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x776f(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x3dd5
cmpl $0x0, -0x14(%rbp)
jne 0x3dc0
movq 0x7756(%rip), %rax      # 0xb510
cmpl $0x0, 0x10(%rax)
je 0x3dc6
cmpl $0x0, -0x14(%rbp)
je 0x3dd3
movq 0x7743(%rip), %rax      # 0xb510
movq %rax, -0x8(%rbp)
jmp 0x3df3
jmp 0x3dd5
jmp 0x3dd7
movq 0x7732(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x7727(%rip)      # 0xb510
jmp 0x3d86
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: moveclientup
void
moveclientup(client* c){
	client* p = NULL, * target = NULL;
	client** t = NULL;

	if (!c)
		return;

	target = findprevclient(c, OnlyVis, WantTiled);
	p = findprevclient(c, AnyVis, WantDummy);
	
	/* Go up only if not highest visible */
	if (!target || !p)
		return;

 	for (t=&c->mon->head;*t && *t != target;t=&(*t)->next);

	/* if p == target, then we're still okay */
	p->next = c->next;
	c->next = target;
	*t = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3e30
jmp 0x3edb
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x3f30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3f30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e66
cmpq $0x0, -0x10(%rbp)
jne 0x3e68
jmp 0x3edb
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x3e98
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3ea1
jmp 0x3eb4
jmp 0x3ea3
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
jmp 0x3e78
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: findprevclient
client*
findprevclient(client* c, int onlyvis, int onlytiled){
	client* ret = NULL;

	for EACHCLIENT(c->mon->head){
		if (ic == c)
			break;

		if (onlyvis && ISVISIBLE(ic))
			if ((onlytiled && !ic->isfloat) || !onlytiled)
				ret = ic;

		if (ic->next == c)
			return (onlyvis) ? ret : ic;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x75b7(%rip)      # 0xb510
cmpq $0x0, 0x75af(%rip)      # 0xb510
je 0x4011
movq 0x75a2(%rip), %rax      # 0xb510
cmpq -0x10(%rbp), %rax
jne 0x3f79
jmp 0x4011
cmpl $0x0, -0x14(%rbp)
je 0x3fc2
movq 0x758a(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x7580(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x3fc2
cmpl $0x0, -0x18(%rbp)
je 0x3faf
movq 0x7567(%rip), %rax      # 0xb510
cmpl $0x0, 0x10(%rax)
je 0x3fb5
cmpl $0x0, -0x18(%rbp)
jne 0x3fc0
movq 0x7554(%rip), %rax      # 0xb510
movq %rax, -0x20(%rbp)
jmp 0x3fc2
movq 0x7547(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3ff8
cmpl $0x0, -0x14(%rbp)
je 0x3fe3
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3fee
movq 0x7526(%rip), %rax      # 0xb510
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4019
jmp 0x3ffa
movq 0x750f(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x7504(%rip)      # 0xb510
jmp 0x3f59
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: showhide
void
showhide(monitor* m){
	for EACHCLIENT(m->head){
		if (ISVISIBLE(ic)){
			XMoveWindow(dis, ic->win, ic->x, ic->y);
			if (ic->isfloat && !ic->isfull){
				resizeclient(ic, ic->x, ic->y, ic->w, ic->h);
				XRaiseWindow(dis, ic->win);
			}

		} else {
			XMoveWindow(dis, ic->win, -2*ic->w, ic->y);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x74d5(%rip)      # 0xb510
cmpq $0x0, 0x74cd(%rip)      # 0xb510
je 0x4143
movq 0x74c0(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x74b6(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x40fb
movq 0x748f(%rip), %rdi      # 0xb500
movq 0x7498(%rip), %rax      # 0xb510
movq 0x38(%rax), %rsi
movq 0x748d(%rip), %rax      # 0xb510
movl (%rax), %edx
movq 0x7484(%rip), %rax      # 0xb510
movl 0x4(%rax), %ecx
callq 0x2050
movq 0x7475(%rip), %rax      # 0xb510
cmpl $0x0, 0x10(%rax)
je 0x40f9
movq 0x7468(%rip), %rax      # 0xb510
cmpl $0x0, 0x18(%rax)
jne 0x40f9
movq 0x745b(%rip), %rdi      # 0xb510
movq 0x7454(%rip), %rax      # 0xb510
movl (%rax), %esi
movq 0x744b(%rip), %rax      # 0xb510
movl 0x4(%rax), %edx
movq 0x7441(%rip), %rax      # 0xb510
movl 0x8(%rax), %ecx
movq 0x7437(%rip), %rax      # 0xb510
movl 0xc(%rax), %r8d
callq 0x4260
movq 0x7417(%rip), %rdi      # 0xb500
movq 0x7420(%rip), %rax      # 0xb510
movq 0x38(%rax), %rsi
callq 0x2100
jmp 0x412a
movq 0x73fe(%rip), %rdi      # 0xb500
movq 0x7407(%rip), %rax      # 0xb510
movq 0x38(%rax), %rsi
movq 0x73fc(%rip), %rax      # 0xb510
imull $0xfffffffe, 0x8(%rax), %edx # imm = 0xFFFFFFFE
movq 0x73ee(%rip), %rax      # 0xb510
movl 0x4(%rax), %ecx
callq 0x2050
jmp 0x412c
movq 0x73dd(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x73d2(%rip)      # 0xb510
jmp 0x403b
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: restack
void
restack(monitor* m){
	XWindowChanges wc;

	if (!m->current)
		return;

	wc.stack_mode = Below;
	wc.sibling = m->current->win;

	for EACHCLIENT(m->head){
		//if (ic != m->current && !ic->isfloat && ISVISIBLE(ic)){
		// if not current, and visible, and both are floating or neither are floating
		if (ic != m->current && ISVISIBLE(ic) && (ic->isfloat == m->current->isfloat)){
			XConfigureWindow(dis, ic->win, CWSibling|CWStackMode, &wc);
			wc.sibling = ic->win;
		}
	}

	XSync(dis, False);
	while (XCheckMaskEvent(dis, EnterWindowMask, &dumbev));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x416c
jmp 0x425a
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x737e(%rip)      # 0xb510
cmpq $0x0, 0x7376(%rip)      # 0xb510
je 0x422d
movq 0x7369(%rip), %rax      # 0xb510
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
je 0x4214
movq 0x7358(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x734e(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x4214
movq 0x733b(%rip), %rax      # 0xb510
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jne 0x4214
movq 0x7314(%rip), %rdi      # 0xb500
movq 0x731d(%rip), %rax      # 0xb510
movq 0x38(%rax), %rsi
movl $0x60, %edx
leaq -0x30(%rbp), %rcx
callq 0x20b0
movq 0x7304(%rip), %rax      # 0xb510
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4216
movq 0x72f3(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x72e8(%rip)      # 0xb510
jmp 0x4192
movq 0x72cc(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
movq 0x72be(%rip), %rdi      # 0xb500
movl $0x10, %esi
leaq 0x72e2(%rip), %rdx      # 0xb530
callq 0x22c0
cmpl $0x0, %eax
je 0x425a
jmp 0x423b
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: resizeclient
void
resizeclient(client* c, int x, int y, int w, int h){
	XWindowChanges wc;

	c->x = wc.x = x;
	c->y = wc.y = y;
	c->w = wc.width = w;
	c->h = wc.height = h;
	XConfigureWindow(dis, c->win, CWX|CWY|CWWidth|CWHeight, &wc);
	XSync(dis, False);
#ifdef _SHAPE_H_
	roundcorners(c);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x724d(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0xf, %edx
leaq -0x40(%rbp), %rcx
callq 0x20b0
movq 0x7230(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
movq -0x8(%rbp), %rdi
callq 0x42f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: changecurrent
void
changecurrent(client* c, monitor* m, int desk, int refocused){
	client* vis;

	if (c){
		c->iscur ^= 1 << desk;
		grabbuttons(c, 1);
	}
	
	for EACHCLIENT(m->head){
		if (ic != c && (ic->iscur & 1 << desk)){
			ic->iscur ^= 1 << desk;
			grabbuttons(ic, 0);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x45e1
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
xorl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x46f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x6f20(%rip)      # 0xb510
cmpq $0x0, 0x6f18(%rip)      # 0xb510
je 0x4661
movq 0x6f0f(%rip), %rax      # 0xb510
cmpq -0x8(%rbp), %rax
je 0x464b
movq 0x6f02(%rip), %rax      # 0xb510
movl 0x20(%rax), %eax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x464b
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x6ed9(%rip), %rax      # 0xb510
xorl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq 0x6ecc(%rip), %rdi      # 0xb510
xorl %esi, %esi
callq 0x46f0
jmp 0x464d
movq 0x6ebc(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x6eb1(%rip)      # 0xb510
jmp 0x45f0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x46d3
cmpl $0x0, -0x18(%rbp)
je 0x46d3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x3d70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x46a1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x46b5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3f30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
cmpq $0x0, -0x8(%rbp)
je 0x46e3
movq -0x10(%rbp), %rdi
callq 0x4830
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: grabbuttons
void
grabbuttons(client* c, int focused){
	int i, j;
	unsigned int modifiers[] = { 0, LockMask };

	XUngrabButton(dis, AnyButton, AnyModifier, c->win);
	if (!focused)
		XGrabButton(dis, AnyButton, AnyModifier, c->win, False,
			BUTTONMASK, GrabModeSync, GrabModeSync, None, None);

	/* "all" our clicks are ClkWin */
	for (i=0;i < TABLENGTH(buttons);i++)
		for (j=0;j < TABLENGTH(modifiers);j++)
			XGrabButton(dis, buttons[i].btn,
					buttons[i].mask | modifiers[j],
					c->win, False, BUTTONMASK,
					GrabModeAsync, GrabModeSync, None, None);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x391a(%rip), %rax      # 0x8020
movq %rax, -0x1c(%rbp)
movq 0x6def(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2480
cmpl $0x0, -0xc(%rbp)
jne 0x4773
movq 0x6dce(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
xorl %r8d, %r8d
movl $0x8000, %edx           # imm = 0x8000
movl $0xc, %r9d
xorl %eax, %eax
movl %r8d, %esi
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x23e0
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
cmpq $0x2, %rax
jae 0x4828
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x2, %rax
jae 0x4818
movq 0x6d60(%rip), %rdi      # 0xb500
movslq -0x10(%rbp), %rcx
leaq 0x6d05(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
movslq -0x10(%rbp), %rcx
leaq 0x6cf0(%rip), %rax      # 0xb4b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edx
movslq -0x14(%rbp), %rax
orl -0x1c(%rbp,%rax,4), %edx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x23e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x478f
jmp 0x481a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x477a
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: updatefocus
void
updatefocus(monitor* m){
	if (!m)
		return;

	if (m->current)
		XSetInputFocus(dis, m->current->win, RevertToPointerRoot, CurrentTime);
	else
		XSetInputFocus(dis, root, RevertToPointerRoot, CurrentTime);

	XSync(dis, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4845
jmp 0x489d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4873
movq 0x6ca9(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2310
jmp 0x488f
movq 0x6c86(%rip), %rdi      # 0xb500
movq 0x6d6f(%rip), %rsi      # 0xb5f0
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2310
movq 0x6c6a(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: coordstomon
monitor*
coordstomon(int x, int y){
	for EACHMON(mhead)
		if (!ISOUTSIDE(x, y, im->mx, im->my, im->mw, im->mh))
			return im;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq 0x65df(%rip), %rax      # 0xb600
movq %rax, 0x64f0(%rip)      # 0xb518
cmpq $0x0, 0x64e8(%rip)      # 0xb518
je 0x50ac
movl -0xc(%rbp), %eax
movq 0x64dc(%rip), %rcx      # 0xb518
movl 0x8(%rcx), %ecx
movq 0x64d2(%rip), %rdx      # 0xb518
addl 0x14(%rdx), %ecx
cmpl %ecx, %eax
jg 0x5093
movl -0xc(%rbp), %eax
movq 0x64c1(%rip), %rcx      # 0xb518
cmpl 0x8(%rcx), %eax
jl 0x5093
movl -0x10(%rbp), %eax
movq 0x64b2(%rip), %rcx      # 0xb518
movl 0xc(%rcx), %ecx
movq 0x64a8(%rip), %rdx      # 0xb518
addl 0x10(%rdx), %ecx
cmpl %ecx, %eax
jg 0x5093
movl -0x10(%rbp), %eax
movq 0x6497(%rip), %rcx      # 0xb518
cmpl 0xc(%rcx), %eax
jl 0x5093
movq 0x648b(%rip), %rax      # 0xb518
movq %rax, -0x8(%rbp)
jmp 0x50b4
jmp 0x5095
movq 0x647c(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x6471(%rip)      # 0xb518
jmp 0x5028
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: sendmon
void
sendmon(client* c, monitor* m){
	if (c->mon == m || c->isfull)
		return;

	detach(c, 0);
	c->mon = m;
	c->desks = m->seldesks;

	c->next = NULL;
	attach(c, 1);
	c->iscur = 0;
	changecurrent(c, c->mon, c->mon->curdesk, 0);
	if (c->isfloat)
		adjustcoords(c);

	curmon->current = findcurrent(curmon);
	for EACHMON(mhead)
		arrange(im);
	changemon(c->mon, YesFocus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x50e8
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x50ed
jmp 0x51cc
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5240
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x52f0
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x45a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x5168
movq -0x8(%rbp), %rdi
callq 0x53e0
movq 0x63b9(%rip), %rdi      # 0xb528
callq 0x54a0
movq %rax, %rcx
movq 0x63aa(%rip), %rax      # 0xb528
movq %rcx, 0x28(%rax)
movq 0x6477(%rip), %rax      # 0xb600
movq %rax, 0x6388(%rip)      # 0xb518
cmpq $0x0, 0x6380(%rip)      # 0xb518
je 0x51ba
movq 0x6377(%rip), %rdi      # 0xb518
callq 0x3ef0
movq 0x636b(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x6360(%rip)      # 0xb518
jmp 0x5190
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0x51e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: changemon
void
changemon(monitor* m, int wantfocus){
	if (curmon && curmon->current)
		grabbuttons(curmon->current, 0);
	curmon = m;
	if (wantfocus)
		updatefocus(curmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x6331(%rip)      # 0xb528
je 0x5219
movq 0x6328(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x5219
movq 0x631a(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x46f0
movq -0x8(%rbp), %rax
movq %rax, 0x6304(%rip)      # 0xb528
cmpl $0x0, -0xc(%rbp)
je 0x5236
movq 0x62f7(%rip), %rdi      # 0xb528
callq 0x4830
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: detach
void
detach(client* c, int refocus_override){
	client** t;

	/* refocus only as necessary */
	if (c == c->mon->current && !refocus_override)
		changecurrent(c, c->mon, c->mon->curdesk, 1);

	for (t=&(c->mon->head);*t && *t != c;t=&(*t)->next);
	*t = c->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x5288
cmpl $0x0, -0xc(%rbp)
jne 0x5288
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %edx
movl $0x1, %ecx
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x52b8
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x52c1
jmp 0x52d4
jmp 0x52c3
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x5298
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: attach
void
attach(client* c, int aside){
	client* l;

	if (!aside || !c->mon->head){
		c->next = c->mon->head;
		c->mon->head = c;

	} else {
		/* If not the first on this desktop */
		if (c->mon->current){
			c->next = c->mon->current->next;
			c->mon->current->next = c;

		} else {
			for (l=c->mon->head;l && l->next;l=l->next);
			if (l)
				l->next = c;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5310
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x30(%rax)
jne 0x5339
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x53d1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x5376
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x53cf
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x53a1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x53aa
jmp 0x53ba
jmp 0x53ac
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5386
cmpq $0x0, -0x18(%rbp)
je 0x53cd
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x53cf
jmp 0x53d1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: adjustcoords
void
adjustcoords(client* c){
	monitor* m;

	if ( (m = coordstomon(c->x, c->y)) && m != c->mon ){
		c->x += (m->mx < c->mon->mx) ? c->mon->mx : -m->mx;
		c->y += (m->my < c->mon->my) ? c->mon->my : -m->my;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x5010
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5492
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x5492
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x543e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x544a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x8(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpl 0xc(%rcx), %eax
jge 0x5479
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x5485
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0xc(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: findcurrent
client*
findcurrent(monitor* m){
	for EACHCLIENT(m->head)
		if (ISVISIBLE(ic) && (ic->iscur & 1 << m->curdesk))
			return ic;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x6059(%rip)      # 0xb510
cmpq $0x0, 0x6051(%rip)      # 0xb510
je 0x5522
movq 0x6048(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x603e(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x550c
movq 0x602b(%rip), %rax      # 0xb510
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x550c
movq 0x600a(%rip), %rax      # 0xb510
movq %rax, -0x8(%rbp)
jmp 0x552a
jmp 0x550e
movq 0x5ffb(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x5ff0(%rip)      # 0xb510
jmp 0x54b7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: outputstats
void
outputstats(){
	char* isdeskocc, * isdesksel, monstate[NUMTAGS+3];
	int i;
	unsigned int occ, sel;

	/* output:
	 * "0:SONNNNNNN:Y"
	 * im->num:SEL/OCC/EMPTY:curlayout->symbol
	 */
	for EACHMON(mhead){
		occ = sel = 0;
		isdeskocc = ecalloc(NUMTAGS, sizeof(char));
		isdesksel = ecalloc(NUMTAGS, sizeof(char));
		sel = im->seldesks;

		for EACHCLIENT(im->head)
			occ |= ic->desks;

		/* uis get reordered in the dest string so they are left-to-right */
		uitos(occ, NUMTAGS, isdeskocc);
		uitos(sel, NUMTAGS, isdesksel);

		for (i=0;i<NUMTAGS;i++){
			if (isdesksel[i] == '1'){
				monstate[i] = 'S';
			} else if (isdeskocc[i] == '1'){
				monstate[i] = 'O';
			} else {
				monstate[i] = 'N';
			}
		}
		monstate[NUMTAGS] = ':';
		monstate[NUMTAGS+1] = im->curlayout->letter;
		monstate[NUMTAGS+2] = '\0';

		setrootstats(monstate, im->num);

		free(isdeskocc);
		free(isdesksel);
	}

	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x60c1(%rip), %rax      # 0xb600
movq %rax, 0x5fd2(%rip)      # 0xb518
cmpq $0x0, 0x5fca(%rip)      # 0xb518
je 0x56a8
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x9, %edi
movl $0x1, %esi
callq 0x25f0
movq %rax, -0x8(%rbp)
movl $0x9, %edi
movl $0x1, %esi
callq 0x25f0
movq %rax, -0x10(%rbp)
movq 0x5f89(%rip), %rax      # 0xb518
movl 0x24(%rax), %eax
movl %eax, -0x28(%rbp)
movq 0x5f7c(%rip), %rax      # 0xb518
movq 0x30(%rax), %rax
movq %rax, 0x5f69(%rip)      # 0xb510
cmpq $0x0, 0x5f61(%rip)      # 0xb510
je 0x55d5
movq 0x5f58(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq 0x5f48(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x5f3d(%rip)      # 0xb510
jmp 0x55a7
movl -0x24(%rbp), %edi
movq -0x8(%rbp), %rdx
movl $0x9, %esi
callq 0x2690
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x9, %esi
callq 0x2690
movl $0x0, -0x20(%rbp)
cmpl $0x9, -0x20(%rbp)
jge 0x5654
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x5620
movslq -0x20(%rbp), %rax
movb $0x53, -0x1c(%rbp,%rax)
jmp 0x5647
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x563c
movslq -0x20(%rbp), %rax
movb $0x4f, -0x1c(%rbp,%rax)
jmp 0x5645
movslq -0x20(%rbp), %rax
movb $0x4e, -0x1c(%rbp,%rax)
jmp 0x5647
jmp 0x5649
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55fe
movb $0x3a, -0x13(%rbp)
movq 0x5eb9(%rip), %rax      # 0xb518
movq 0x40(%rax), %rax
movb (%rax), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x1c(%rbp), %rdi
movq 0x5ea1(%rip), %rax      # 0xb518
movl 0x20(%rax), %esi
callq 0x56c0
movq -0x8(%rbp), %rdi
callq 0x21b0
movq -0x10(%rbp), %rdi
callq 0x21b0
movq 0x5e80(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x5e75(%rip)      # 0xb518
jmp 0x5546
movq 0x5941(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x24d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: setrootstats
void
setrootstats(char* monstate, int monnum){
	char* atom = malloc(sizeof(char) * 40);
	char* num = malloc(sizeof(char) * 12);
	sprintf(atom, "%s", "");
	sprintf(num, "%d", monnum);
	strcat(atom, "SARA_MONSTATE_");
	strcat(atom, num);
	strcat(atom, "\0");
	XChangeProperty(dis, root, XInternAtom(dis, atom, False),
			XA_STRING, 8, PropModeReplace, (unsigned char*) monstate,
			NUMTAGS+3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x28, %edi
callq 0x2140
movq %rax, -0x18(%rbp)
movl $0xc, %edi
callq 0x2140
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x29a0(%rip), %rsi      # 0x8096
leaq 0x2b21(%rip), %rdx      # 0x821e
movb $0x0, %al
callq 0x2220
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x2981(%rip), %rsi      # 0x8093
movb $0x0, %al
callq 0x2220
movq -0x18(%rbp), %rdi
leaq 0x2a34(%rip), %rsi      # 0x8158
callq 0x2290
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2290
movq -0x18(%rbp), %rdi
leaq 0x2937(%rip), %rsi      # 0x8078
callq 0x2290
movq 0x5db3(%rip), %rax      # 0xb500
movq %rax, -0x30(%rbp)
movq 0x5e98(%rip), %rax      # 0xb5f0
movq %rax, -0x28(%rbp)
movq 0x5d9d(%rip), %rdi      # 0xb500
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x23c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0xc, 0x8(%rsp)
callq 0x2400
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: unroundcorners
void
unroundcorners(client *c)
{
	Pixmap mask;
	GC shapegc;

	if (corner_radius < 0 || !c)
		return;

	if (!(mask = XCreatePixmap(dis, c->win, c->w, c->h, 1)))
		return;
	
	if (!(shapegc = XCreateGC(dis, mask, 0, NULL))){
	    XFreePixmap(dis, mask);
	    free(shapegc);
	    return;
	}

	XSetForeground(dis, shapegc, 1);
	XFillRectangle(dis, mask, shapegc, 0, 0, c->w, c->h);
	XShapeCombineMask(dis, c->win, ShapeBounding, 0, 0, mask, ShapeSet);
	XFreePixmap(dis, mask);
	XFreeGC(dis, shapegc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x57c8
jmp 0x58c7
movq 0x5d31(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movl $0x1, %r8d
callq 0x2470
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x57ff
jmp 0x58c7
movq 0x5cfa(%rip), %rdi      # 0xb500
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x22f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x583e
movq 0x5cd9(%rip), %rdi      # 0xb500
movq -0x10(%rbp), %rsi
callq 0x2420
movq -0x18(%rbp), %rdi
callq 0x21b0
jmp 0x58c7
movq 0x5cbb(%rip), %rdi      # 0xb500
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x21f0
movq 0x5ca6(%rip), %rdi      # 0xb500
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %r9d
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
xorl %r8d, %r8d
movl %r8d, %ecx
movl %eax, (%rsp)
callq 0x2200
movq 0x5c7a(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
callq 0x2380
movq 0x5c52(%rip), %rdi      # 0xb500
movq -0x10(%rbp), %rsi
callq 0x2420
movq 0x5c42(%rip), %rdi      # 0xb500
movq -0x18(%rbp), %rsi
callq 0x2230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: dirtomon
monitor*
dirtomon(int dir){
	monitor* m;

	if (dir > 0){
		if ( !(m = curmon->next) )
			m = mhead;

	} else if (curmon == mhead){
		for (m=mhead;m->next;m=m->next);

	} else {
		for (m=mhead;m->next != curmon;m=m->next);
	}

	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x58ff
movq 0x5c44(%rip), %rax      # 0xb528
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x58fd
movq 0x5d07(%rip), %rax      # 0xb600
movq %rax, -0x10(%rbp)
jmp 0x5967
movq 0x5c22(%rip), %rax      # 0xb528
cmpq 0x5cf3(%rip), %rax      # 0xb600
jne 0x5937
movq 0x5cea(%rip), %rax      # 0xb600
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x5935
jmp 0x5927
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x591a
jmp 0x5965
movq 0x5cc2(%rip), %rax      # 0xb600
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq 0x5bd7(%rip), %rax      # 0xb528
je 0x5963
jmp 0x5955
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5942
jmp 0x5965
jmp 0x5967
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: monocle
void
monocle(monitor* m){
	int x = m->mx + gappx, y = (bottombar ? (m->my + gappx) : (m->wy + barpx)), max_h = (bottombar ? (m->wh - barpx) : (m->mh - gappx));
	for EACHCLIENT(m->head)
		if (ISVISIBLE(ic) && !ic->isfloat && !ic->isfull)
			resizeclient(ic, x, y, m->mw - 2*gappx, max_h - y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0xa, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x14, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0xa, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x58fe(%rip)      # 0xb510
cmpq $0x0, 0x58f6(%rip)      # 0xb510
je 0x5c8d
movq 0x58ed(%rip), %rax      # 0xb510
movl 0x1c(%rax), %eax
movq 0x58e3(%rip), %rcx      # 0xb510
movq 0x30(%rcx), %rcx
andl 0x24(%rcx), %eax
cmpl $0x0, %eax
je 0x5c77
movq 0x58d0(%rip), %rax      # 0xb510
cmpl $0x0, 0x10(%rax)
jne 0x5c77
movq 0x58c3(%rip), %rax      # 0xb510
cmpl $0x0, 0x18(%rax)
jne 0x5c77
movq 0x58b6(%rip), %rdi      # 0xb510
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x14, %ecx
movl -0x14(%rbp), %r8d
subl -0x10(%rbp), %r8d
callq 0x4260
jmp 0x5c79
movq 0x5890(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x5885(%rip)      # 0xb510
jmp 0x5c12
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: loaddesktop
void
loaddesktop(int i){
	curmon->desks[curmon->curdesk].msize = curmon->msize;
	curmon->desks[curmon->curdesk].curlayout = curmon->curlayout;

	curmon->msize = curmon->desks[i].msize;
	curmon->curlayout = curmon->desks[i].curlayout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x587a(%rip), %rax      # 0xb528
movss (%rax), %xmm0
movq 0x586f(%rip), %rax      # 0xb528
movq 0x38(%rax), %rax
movq 0x5864(%rip), %rcx      # 0xb528
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
movq 0x584e(%rip), %rax      # 0xb528
movq 0x40(%rax), %rcx
movq 0x5843(%rip), %rax      # 0xb528
movq 0x38(%rax), %rax
movq 0x5838(%rip), %rdx      # 0xb528
movslq 0x4(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x5822(%rip), %rax      # 0xb528
movq 0x38(%rax), %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
movq 0x5808(%rip), %rax      # 0xb528
movss %xmm0, (%rax)
movq 0x57fd(%rip), %rax      # 0xb528
movq 0x38(%rax), %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x57e3(%rip), %rax      # 0xb528
movq %rcx, 0x40(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: findmon
monitor*
findmon(Window w){
	for EACHMON(mhead)
		for EACHCLIENT(im->head)
			if (ic->win == w)
				return im;

	return curmon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x58a1(%rip), %rax      # 0xb600
movq %rax, 0x57b2(%rip)      # 0xb518
cmpq $0x0, 0x57aa(%rip)      # 0xb518
je 0x5dd6
movq 0x57a1(%rip), %rax      # 0xb518
movq 0x30(%rax), %rax
movq %rax, 0x578e(%rip)      # 0xb510
cmpq $0x0, 0x5786(%rip)      # 0xb510
je 0x5dc0
movq 0x577d(%rip), %rax      # 0xb510
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5daa
movq 0x5774(%rip), %rax      # 0xb518
movq %rax, -0x8(%rbp)
jmp 0x5de1
jmp 0x5dac
movq 0x575d(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x5752(%rip)      # 0xb510
jmp 0x5d82
jmp 0x5dc2
movq 0x574f(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x5744(%rip)      # 0xb518
jmp 0x5d66
movq 0x574b(%rip), %rax      # 0xb528
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: findclient
client*
findclient(Window w){
	for EACHMON(mhead)
		for EACHCLIENT(im->head)
			if (ic->win == w)
				return ic;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x5801(%rip), %rax      # 0xb600
movq %rax, 0x5712(%rip)      # 0xb518
cmpq $0x0, 0x570a(%rip)      # 0xb518
je 0x5e76
movq 0x5701(%rip), %rax      # 0xb518
movq 0x30(%rax), %rax
movq %rax, 0x56ee(%rip)      # 0xb510
cmpq $0x0, 0x56e6(%rip)      # 0xb510
je 0x5e60
movq 0x56dd(%rip), %rax      # 0xb510
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5e4a
movq 0x56cc(%rip), %rax      # 0xb510
movq %rax, -0x8(%rbp)
jmp 0x5e7e
jmp 0x5e4c
movq 0x56bd(%rip), %rax      # 0xb510
movq 0x28(%rax), %rax
movq %rax, 0x56b2(%rip)      # 0xb510
jmp 0x5e22
jmp 0x5e62
movq 0x56af(%rip), %rax      # 0xb518
movq 0x48(%rax), %rax
movq %rax, 0x56a4(%rip)      # 0xb518
jmp 0x5e06
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: updategeom
void
updategeom(){
	int x, y;
	client* c;
	monitor* m, * oldmhead = mhead;

#ifdef XINERAMA
	if (XineramaIsActive(dis)){
		int i, j, ns;
		XineramaScreenInfo* unique;
		XineramaScreenInfo* info = XineramaQueryScreens(dis, &ns);

		// TODO: can i just use info[i] directly?
      		/* only consider unique geometries as separate screens */
		unique = ecalloc(ns, sizeof(XineramaScreenInfo));
		for (i=0, j=0;i < ns;i++)
			if (isuniquegeom(unique, j, &info[i]))
				memcpy(&unique[j++], &info[i], sizeof(XineramaScreenInfo));
		XFree(info);
		
		mhead = m = createmon(0, unique[0].x_org, unique[0].y_org,
				unique[0].width, unique[0].height);
		for (i=1;i < j;i++){
			m->next = createmon(i, unique[i].x_org, unique[i].y_org,
					unique[i].width, unique[i].height);
			m = m->next;
		}

		free(unique);

	} else
#endif
	{
		mhead = createmon(0, 0, 0, sw, sh);
	}

	/* if updating, reattach any old clients to the new mhead */
	while ( (m = oldmhead) ){
		while ( (c = m->head) ){
			m->head = c->next;
			detach(c, 0);
			c->mon = mhead;
			c->next = NULL;
			attach(c, 1);
		}
		mhead->seldesks |= m->seldesks;
		oldmhead = m->next;
		cleanupmon(m);
	}

	getptrcoords(&x, &y);
	if ( (m = coordstomon(x, y)) )
		changemon(m, YesFocus);
	if (!curmon)
		changemon(mhead, YesFocus);

	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x5761(%rip), %rax      # 0xb600
movq %rax, -0x20(%rbp)
movl 0x5763(%rip), %ecx      # 0xb60c
movl 0x5760(%rip), %r8d      # 0xb610
xorl %edx, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x5fc0
movq %rax, 0x573e(%rip)      # 0xb600
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5f5c
jmp 0x5ed6
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5f2e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5240
movq 0x56f6(%rip), %rcx      # 0xb600
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x52f0
jmp 0x5ed6
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
movq 0x56c4(%rip), %rax      # 0xb600
orl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6120
jmp 0x5ec2
leaq -0x4(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x4f20
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x5010
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5f8c
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x51e0
cmpq $0x0, 0x5594(%rip)      # 0xb528
jne 0x5fa7
movq 0x5663(%rip), %rdi      # 0xb600
movl $0x1, %esi
callq 0x51e0
callq 0x5530
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: createmon
monitor*
createmon(int num, int x, int y, int w, int h){
	int i;
	monitor* m = ecalloc(1, sizeof(monitor));

	m->num = num;
	m->mx = x;
	m->my = y;
	m->mw = w;
	m->mh = h;

	m->wy = m->my + (bottombar ? 0 : barpx );
	m->wh = m->mh - barpx;

	/* Default to first layout */
	m->curlayout = (layout*) &layouts[0];
	m->msize = m->mw * MASTER_SIZE;

	m->desks = ecalloc(NUMTAGS, sizeof(desktop));
	for (i=0;i < NUMTAGS;i++){
		m->desks[i].curlayout = m->curlayout;
		m->desks[i].msize = m->msize;
	}

	/* Default to first desktop */
	m->seldesks = 1 << 0;
	m->curdesk = 0;
	m->head = NULL;
	m->current = NULL;

	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x25f0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x14, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x14, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
leaq 0x4cd6(%rip), %rcx      # 0xad20
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
cvtsi2sdl 0x14(%rax), %xmm0
movsd 0x1fb9(%rip), %xmm1     # 0x8018
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movl $0x9, %edi
movl $0x10, %esi
callq 0x25f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x9, -0x18(%rbp)
jge 0x60df
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6090
movq -0x20(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: configure
void
configure(client* c){
	XConfigureEvent ce = {
		.type = ConfigureNotify,
		.display = dis,
		.event = c->win,
		.window = c->win,
		.x = c->x,
		.y = c->y,
		.width = c->w,
		.height = c->h,
		.above = None,
		.override_redirect = False
	};

	XSendEvent(dis, c->win, False, StructureNotifyMask, (XEvent *)&ce);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x16, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x50(%rbp)
movq 0x5387(%rip), %rax      # 0xb500
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x5327(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x60(%rbp), %r8
callq 0x2350
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: unmanage
void
unmanage(client* c, int destroyed){
	monitor* m = c->mon;

	detach(c, 0);
	if (!destroyed){
		XGrabServer(dis);
		XUngrabButton(dis, AnyButton, AnyModifier, c->win);
		XChangeProperty(dis, c->win, w_atom, w_atom, 32,
				PropModeReplace, (unsigned char*) w_data, 2);
		XSync(dis, False);
		XUngrabServer(dis);
	}
	free(c);
	arrange(m);
	outputstats();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5240
cmpl $0x0, -0xc(%rbp)
jne 0x62ab
movq 0x52cd(%rip), %rdi      # 0xb500
callq 0x20c0
movq 0x52c1(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2480
movq 0x52a6(%rip), %rdi      # 0xb500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq 0x53af(%rip), %rdx      # 0xb618
movq 0x53a8(%rip), %rcx      # 0xb618
movl $0x20, %r8d
xorl %r9d, %r9d
leaq 0x53a0(%rip), %rax      # 0xb620
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x2400
movq 0x5268(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
movq 0x525a(%rip), %rdi      # 0xb500
callq 0x2240
movq -0x8(%rbp), %rdi
callq 0x21b0
movq -0x18(%rbp), %rdi
callq 0x3ef0
callq 0x5530
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: setup
void
setup(){
	XSetWindowAttributes wa;

	screen = DefaultScreen(dis);
	root = RootWindow(dis, screen);

	sw = XDisplayWidth(dis, screen);
	sh = XDisplayHeight(dis, screen);

	cursor = XCreateFontCursor(dis, 68);

	running = 1;

	mhead = NULL;
	curmon = NULL;

	updategeom();
	loaddesktop(0);
	outputstats();

	w_atom = XInternAtom(dis, "WM_STATE", False);

	wa.cursor = cursor;
	wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask
		|ButtonPressMask|PointerMotionMask|EnterWindowMask
		|StructureNotifyMask|PropertyChangeMask;
	XChangeWindowAttributes(dis, root, CWEventMask|CWCursor, &wa);
	XSelectInput(dis, root, wa.event_mask);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x4d31(%rip), %rax      # 0xb500
movl 0xe0(%rax), %eax
movl %eax, 0x4e55(%rip)      # 0xb630
movq 0x4d1e(%rip), %rax      # 0xb500
movq 0xe8(%rax), %rax
movslq 0x4e40(%rip), %rcx      # 0xb630
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, 0x4dee(%rip)      # 0xb5f0
movq 0x4cf7(%rip), %rdi      # 0xb500
movl 0x4e21(%rip), %esi      # 0xb630
callq 0x2120
movl %eax, 0x4df2(%rip)      # 0xb60c
movq 0x4cdf(%rip), %rdi      # 0xb500
movl 0x4e09(%rip), %esi      # 0xb630
callq 0x2280
movl %eax, 0x4dde(%rip)      # 0xb610
movq 0x4cc7(%rip), %rdi      # 0xb500
movl $0x44, %esi
callq 0x2030
movq %rax, 0x4dae(%rip)      # 0xb5f8
movl $0x1, 0x4db4(%rip)      # 0xb608
movq $0x0, 0x4da1(%rip) # 0xb600
movq $0x0, 0x4cbe(%rip) # 0xb528
callq 0x5e90
xorl %edi, %edi
callq 0x5ca0
callq 0x5530
movq 0x4c7e(%rip), %rdi      # 0xb500
leaq 0x1905(%rip), %rsi      # 0x818e
xorl %edx, %edx
callq 0x23c0
movq %rax, 0x4d81(%rip)      # 0xb618
movq 0x4d5a(%rip), %rax      # 0xb5f8
movq %rax, -0x8(%rbp)
movq $0x5a0054, -0x28(%rbp)  # imm = 0x5A0054
movq 0x4c4f(%rip), %rdi      # 0xb500
movq 0x4d38(%rip), %rsi      # 0xb5f0
movl $0x4800, %edx           # imm = 0x4800
leaq -0x70(%rbp), %rcx
callq 0x24e0
movq 0x4c33(%rip), %rdi      # 0xb500
movq 0x4d1c(%rip), %rsi      # 0xb5f0
movq -0x28(%rbp), %rdx
callq 0x2300
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)