LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gitluin[P]sara/src/sara.c
// Function: configurerequest
void
configurerequest(XEvent* e){
	client* c;
	monitor* m;
	XWindowChanges wc;
	XConfigureRequestEvent* ev = &e->xconfigurerequest;

	if ( (c = findclient(ev->window)) ){
		if (c->isfloat){
			m = c->mon;
			if (ev->value_mask & CWX)
				c->x = m->mx + ev->x;
			if (ev->value_mask & CWY)
				c->y = (ev->y < barpx) ? barpx : ev->y;
			if (ev->value_mask & CWWidth)
				c->w = ev->width;
			if (ev->value_mask & CWHeight)
				c->h = ev->height;
			if ((c->x + c->w) > m->mx + m->mw)
				c->x = m->mx + (m->mw / 2 - c->w / 2);
			if ((c->y + c->h) > m->wy + m->wh)
				c->y = m->wy + (m->wh / 2 - c->h / 2);
			if ((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight)))
				configure(c);
			if (ISVISIBLE(c))
				XMoveResizeWindow(dis, c->win, c->x, c->y, c->w, c->h);

		} else {
			configure(c);
		}

	} else {
		wc.x = ev->x;
		wc.y = ev->y;
		wc.width = ev->width;
		wc.height = ev->height;
		wc.sibling = ev->above;
		wc.stack_mode = ev->detail;
		XConfigureWindow(dis, ev->window, ev->value_mask, &wc);
	}

	XSync(dis, False);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x4e87
testq %rax, %rax
je 0x2c20
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x2c50
movq 0x30(%rbx), %rax
movq 0x58(%r14), %rcx
testb $0x1, %cl
je 0x2b42
movl 0x30(%r14), %edx
addl 0x8(%rax), %edx
movl %edx, (%rbx)
testb $0x2, %cl
je 0x2b59
movl 0x34(%r14), %edx
cmpl $0x15, %edx
movl $0x14, %esi
cmovgel %edx, %esi
movl %esi, 0x4(%rbx)
testb $0x4, %cl
je 0x2b65
movl 0x38(%r14), %edx
movl %edx, 0x8(%rbx)
testb $0x8, %cl
je 0x2b71
movl 0x3c(%r14), %edx
movl %edx, 0xc(%rbx)
movl 0x8(%rbx), %esi
movl (%rbx), %r8d
addl %esi, %r8d
movl 0x8(%rax), %edx
movl 0x14(%rax), %edi
leal (%rdi,%rdx), %r9d
cmpl %r9d, %r8d
jle 0x2ba6
movl %edi, %r8d
shrl $0x1f, %r8d
addl %edi, %r8d
sarl %r8d
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
subl %edi, %edx
addl %r8d, %edx
movl %edx, (%rbx)
movl 0xc(%rbx), %esi
movl 0x4(%rbx), %r8d
addl %esi, %r8d
movl 0x18(%rax), %edx
movl 0x1c(%rax), %edi
leal (%rdi,%rdx), %r9d
cmpl %r9d, %r8d
jle 0x2bdd
movl %edi, %r8d
shrl $0x1f, %r8d
addl %edi, %r8d
sarl %r8d
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
subl %edi, %edx
addl %r8d, %edx
movl %edx, 0x4(%rbx)
testb $0x3, %cl
sete %dl
testb $0xc, %cl
setne %cl
orb %dl, %cl
jne 0x2bf9
movq %rbx, %rdi
callq 0x50e7
movq 0x30(%rbx), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rbx)
je 0x2c58
movq 0x68b8(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rsi
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
callq 0x2250
jmp 0x2c58
movups 0x30(%r14), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x48(%r14), %rax
movq %rax, 0x18(%rcx)
movl 0x50(%r14), %eax
movl %eax, 0x20(%rcx)
movq 0x687f(%rip), %rdi      # 0x94c0
movq 0x28(%r14), %rsi
movl 0x58(%r14), %edx
callq 0x20a0
jmp 0x2c58
movq %rbx, %rdi
callq 0x50e7
movq 0x6861(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x686a(%rip), %rsi      # 0x94e0
callq *0x673c(%rip)           # 0x93b8
movq 0x6865(%rip), %rdi      # 0x94e8
movss (%rdi), %xmm0
cvtss2sd %xmm0, %xmm2
movl 0x14(%rdi), %eax
cvtsi2sd %eax, %xmm3
movsd 0x33c6(%rip), %xmm1     # 0x6060
mulsd %xmm3, %xmm1
ucomisd %xmm2, %xmm1
movss 0x6836(%rip), %xmm1     # 0x94e0
jbe 0x2cb4
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
ja 0x2cce
mulsd 0x33ac(%rip), %xmm3     # 0x6068
ucomisd %xmm3, %xmm2
xorps %xmm2, %xmm2
jbe 0x2cdc
xorpd %xmm3, %xmm3
ucomiss %xmm1, %xmm3
jbe 0x2cdc
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm2, %xmm1
movaps %xmm1, %xmm2
addss %xmm2, %xmm0
movss %xmm0, (%rdi)
popq %rax
jmp 0x3d5e
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x68ce(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x2d65
leaq 0x67e0(%rip), %rsi      # 0x94e0
callq *0x66aa(%rip)           # 0x93b0
cmpl $0x0, 0x67d3(%rip)      # 0x94e0
movq 0x67d4(%rip), %rax      # 0x94e8
jle 0x2d2f
movq 0x48(%rax), %rdi
testq %rdi, %rdi
jne 0x2d26
movq 0x689a(%rip), %rdi      # 0x95c0
testq %rdi, %rdi
jne 0x2d55
xorl %edi, %edi
jmp 0x2d5a
movq 0x688a(%rip), %rcx      # 0x95c0
cmpq %rcx, %rax
je 0x2d49
movq %rcx, %rdi
movq 0x48(%rcx), %rcx
cmpq %rax, %rcx
jne 0x2d3b
jmp 0x2d55
movq %rcx, %rdi
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
jne 0x2d49
cmpq %rax, %rdi
je 0x2d65
movl $0x1, %esi
popq %rax
jmp 0x4953
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq 0x676e(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2e97
movq 0x38(%rax), %rbx
movq 0x672e(%rip), %rdi      # 0x94c0
leaq 0x339d(%rip), %rsi      # 0x6136
xorl %edx, %edx
callq 0x23c0
movq %rax, %r14
movq 0x6716(%rip), %rdi      # 0x94c0
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rsi
callq 0x2450
testl %eax, %eax
je 0x2e48
movslq 0x4(%rsp), %rax
movq 0x8(%rsp), %rdi
subq $0x1, %rax
jb 0x2e3b
cmpq %r14, (%rdi,%rax,8)
jne 0x2dce
movl %eax, 0x4(%rsp)
callq 0x2040
leaq 0x10(%rsp), %r15
movl $0x21, (%r15)
movq %rbx, 0x20(%r15)
movq 0x66c6(%rip), %rdi      # 0x94c0
leaq 0x3346(%rip), %rsi      # 0x6147
movl $0x1, %edx
callq 0x23c0
movq %rax, 0x28(%r15)
movl $0x20, 0x30(%r15)
movq %r14, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq 0x6696(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2350
jmp 0x2e97
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
callq 0x2040
movq 0x6671(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x6665(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x20e0
movq 0x6657(%rip), %rdi      # 0x94c0
movq 0x6678(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x24d0
movq 0x663c(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x662e(%rip), %rdi      # 0x94c0
callq 0x2240
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x663c(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2f57
cmpl $0x0, 0x18(%rax)
jne 0x2f57
leaq 0x6616(%rip), %rsi      # 0x94e0
callq *0x64e0(%rip)           # 0x93b0
movl 0x660a(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0x2, %eax
ja 0x2f57
movq 0x6603(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testl %ecx, %ecx
jg 0x2f0d
jmp 0x2efb
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
jne 0x2f06
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x2eef
xorl %eax, %eax
movq %rax, 0x65c3(%rip)      # 0x94d0
testq %rax, %rax
je 0x2f57
movq 0x30(%rax), %rdi
leaq 0x30(%rdi), %rcx
movq 0x30(%rdi), %rdx
xorl %r8d, %r8d
movq %rdx, %r9
testq %r9, %r9
je 0x2f59
movl $0x0, %esi
cmpq %rax, %r9
je 0x2f5b
movq 0x30(%r9), %rsi
movl 0x24(%rsi), %esi
testl %esi, 0x1c(%r9)
je 0x2f49
cmpl $0x0, 0x10(%r9)
cmoveq %r9, %r8
movq 0x28(%r9), %r9
movq %r8, %rsi
cmpq %rax, %r9
jne 0x2f24
jmp 0x2f5b
popq %rax
retq
xorl %esi, %esi
movq %rdx, %r8
testq %rdx, %rdx
je 0x2fa6
cmpq %rax, %r8
je 0x2fa6
movq 0x28(%r8), %rdx
cmpq %rax, %rdx
jne 0x2f5b
movq %r8, 0x6558(%rip)       # 0x94d0
testq %rsi, %rsi
je 0x2fad
movq %rcx, %rdx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x2f91
leaq 0x28(%rdi), %rcx
cmpq %rsi, %rdi
jne 0x2f7d
movq 0x28(%rax), %rcx
movq %rcx, 0x28(%r8)
movq %rsi, 0x28(%rax)
movq %rax, (%rdx)
movq 0x30(%rax), %rdi
jmp 0x2fad
movq %r8, 0x6523(%rip)       # 0x94d0
popq %rax
jmp 0x3d5e
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x652d(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2fca
cmpl $0x0, 0x18(%rax)
je 0x2fcc
popq %rax
retq
leaq 0x650d(%rip), %rsi      # 0x94e0
callq *0x63d7(%rip)           # 0x93b0
cmpl $0x0, 0x6500(%rip)      # 0x94e0
jle 0x3019
movq 0x64ff(%rip), %rsi      # 0x94e8
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x2fca
movq 0x28(%rsi), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
je 0x304b
movq 0x30(%rax), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rax)
cmovneq %rax, %rdi
movq 0x28(%rax), %rdx
movq %rdx, %rax
testq %rdx, %rdx
jne 0x2ff8
jmp 0x3098
jns 0x2fca
movq 0x64c6(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x306e
movq 0x30(%rdi), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rdi)
je 0x3045
cmpl $0x0, 0x10(%rdi)
je 0x30c5
movq 0x28(%rdi), %rdi
jmp 0x302a
testq %rdi, %rdi
jne 0x30a1
xorl %edi, %edi
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
cmovneq %rax, %rdi
movq 0x28(%rax), %rcx
movq %rcx, %rax
testq %rcx, %rcx
jne 0x3052
jmp 0x3098
movq 0x30(%rsi), %rdi
testq %rdi, %rdi
je 0x308f
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
je 0x3089
cmpl $0x0, 0x10(%rdi)
je 0x3091
movq 0x28(%rdi), %rdi
jmp 0x3072
xorl %edi, %edi
movq %rdi, 0x6438(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x2fca
movq 0x28(%rsi), %rax
cmpq %rax, %rdi
je 0x2fca
movl 0x4(%rsi), %edx
xorl %ecx, %ecx
callq 0x416d
movq 0x6429(%rip), %rdi      # 0x94e8
popq %rax
jmp 0x3dff
movq %rdi, 0x6404(%rip)      # 0x94d0
jmp 0x30a5
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x63e9(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x3135
leaq 0x63d3(%rip), %rsi      # 0x94e0
callq *0x629d(%rip)           # 0x93b0
movl 0x63c7(%rip), %ecx      # 0x94e0
cmpl $0x9, %ecx
ja 0x3135
movl $0x1, %edx
shll %cl, %edx
movq 0x63bc(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
cmpl %edx, 0x1c(%rdi)
jne 0x3137
popq %rax
retq
movl %edx, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x1, %ecx
callq 0x416d
movq 0x6396(%rip), %rdi      # 0x94e8
callq 0x3d5e
popq %rax
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x6383(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x31a0
leaq 0x636d(%rip), %rsi      # 0x94e0
callq *0x6237(%rip)           # 0x93b0
movl 0x6361(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x31a0
movq 0x635a(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
movl 0x1c(%rdi), %eax
movl $0x1, %edx
shll %cl, %edx
cmpl %edx, %eax
jne 0x31a2
popq %rax
retq
xorl %edx, %eax
movl %eax, 0x1c(%rdi)
xorl %ecx, %ecx
testl %eax, 0x24(%rsi)
sete %cl
callq 0x416d
movq 0x632d(%rip), %rdi      # 0x94e8
callq 0x3d5e
popq %rax
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x631b(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x31dc
cmpl $0x0, 0x18(%rax)
je 0x31dd
retq
movq 0x40(%rdi), %rcx
leaq 0x1601(%rip), %rdx      # 0x47e9
cmpq %rdx, 0x8(%rcx)
je 0x31dc
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rax)
sete %cl
movl %ecx, 0x10(%rax)
jmp 0x3d5e
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x62e2(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3228
xorl %ecx, %ecx
cmpl $0x0, 0x18(%rax)
sete %cl
movl %ecx, 0x18(%rax)
je 0x3229
movl 0x14(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x3d5e
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x10(%rax), %ecx
movl %ecx, 0x14(%rax)
movl $0x0, 0x10(%rax)
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edx
movl 0x14(%rdi), %ecx
movl 0x10(%rdi), %r8d
movq %rax, %rdi
callq 0x3ec4
movq 0x628d(%rip), %rax      # 0x94e8
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x332c
movq 0x6251(%rip), %rdi      # 0x94c0
movq 0x38(%r15), %rsi
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
movl $0x1, %r8d
callq 0x2480
testq %rax, %rax
je 0x332c
movq %rax, %rbx
movq 0x6227(%rip), %rdi      # 0x94c0
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f0
movq 0x6214(%rip), %rdi      # 0x94c0
testq %rax, %rax
je 0x3324
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rsi
callq 0x21f0
movq 0x61f8(%rip), %rdi      # 0x94c0
movl 0x8(%r15), %r9d
movl 0xc(%r15), %eax
movl %eax, (%rsp)
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2200
movq 0x61d6(%rip), %rdi      # 0x94c0
movq 0x38(%r15), %rsi
movl $0x0, (%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x2380
movq 0x61b5(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
callq 0x2420
movq 0x61a6(%rip), %rdi      # 0x94c0
movq %r14, %rsi
callq 0x2230
jmp 0x332c
movq %rbx, %rsi
callq 0x2420
movq 0x618d(%rip), %rdi      # 0x94c0
movq 0x61ae(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
movq 0x38(%rax), %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x6188(%rip), %rsi      # 0x94e0
callq *0x6052(%rip)           # 0x93b0
movl 0x617c(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x3385
testl %ecx, %ecx
js 0x3387
movl $0x1, %ebx
shll %cl, %ebx
movq 0x616a(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
cmpl %ebx, %eax
jne 0x3395
popq %rbx
retq
movq 0x615a(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
movl %eax, %ebx
notl %ebx
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x33b3
cmpl $0x0, 0x18(%rcx)
je 0x33b3
callq 0x31ff
movq 0x6138(%rip), %rsi      # 0x94e8
movl 0x24(%rsi), %eax
xorl %ebx, %eax
movl %eax, 0x24(%rsi)
movl 0x4(%rsi), %r8d
btl %r8d, %eax
jb 0x33dc
movslq %r8d, %rdi
xorl %edx, %edx
movl $0x8, %ecx
btl %edx, %eax
jb 0x3413
incl %edx
addq $0x10, %rcx
cmpl $0x9, %edx
jne 0x33cc
movl %r8d, %edx
movq 0x28(%rsi), %rdi
testq %rdi, %rdi
je 0x3405
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
jne 0x3405
movl $0x1, %ecx
callq 0x416d
movq 0x60e3(%rip), %rsi      # 0x94e8
movq %rsi, %rdi
callq 0x3d5e
popq %rbx
jmp 0x4a60
movss (%rsi), %xmm0
movq 0x38(%rsi), %rax
shlq $0x4, %rdi
movss %xmm0, (%rax,%rdi)
movq 0x40(%rsi), %rsi
movq %rsi, 0x8(%rax,%rdi)
movq 0x60b4(%rip), %rsi      # 0x94e8
movq 0x38(%rsi), %rax
movss -0x8(%rax,%rcx), %xmm0
movss %xmm0, (%rsi)
movq (%rax,%rcx), %rax
movq %rax, 0x40(%rsi)
movl %edx, 0x4(%rsi)
jmp 0x33df
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x6092(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x349f
movq 0x615c(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x349f
pushq %rax
leaq 0x606d(%rip), %rsi      # 0x94e0
callq *0x5f37(%rip)           # 0x93b0
movq 0x6068(%rip), %rcx      # 0x94e8
movq 0x28(%rcx), %rdi
cmpl $0x0, 0x6055(%rip)      # 0x94e0
jle 0x34a0
movq 0x48(%rcx), %rsi
testq %rsi, %rsi
jne 0x34c6
movq 0x6123(%rip), %rsi      # 0x95c0
jmp 0x34c6
retq
movq 0x6119(%rip), %rax      # 0x95c0
cmpq %rax, %rcx
je 0x34ba
movq %rax, %rsi
movq 0x48(%rax), %rax
cmpq %rcx, %rax
jne 0x34ac
jmp 0x34c6
movq %rax, %rsi
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x34ba
callq 0x486b
popq %rax
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6005(%rip), %rbx      # 0x94e8
xorl %r15d, %r15d
leaq 0x5873(%rip), %r12      # 0x8d60
movq 0x10(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2370
testl %eax, %eax
jne 0x3506
leaq (%r12,%r15), %rax
movq %rax, 0x40(%rbx)
addq $0x18, %r15
cmpq $0x48, %r15
jne 0x34ed
movq %rbx, %rdi
callq 0x3d5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x5fb0(%rip), %rsi      # 0x94e0
callq *0x5e7a(%rip)           # 0x93b0
movl 0x5fa4(%rip), %eax      # 0x94e0
cmpl $0x9, %eax
ja 0x35e3
movq 0x5f9c(%rip), %rcx      # 0x94e8
movq 0x28(%rcx), %rdx
testq %rdx, %rdx
je 0x356d
cmpl $0x0, 0x18(%rdx)
je 0x356d
callq 0x31ff
movl 0x5f7a(%rip), %eax      # 0x94e0
movq 0x5f7b(%rip), %rcx      # 0x94e8
movss (%rcx), %xmm0
movq 0x38(%rcx), %rdx
movslq 0x4(%rcx), %rsi
shlq $0x4, %rsi
movss %xmm0, (%rdx,%rsi)
movq 0x40(%rcx), %rcx
movq %rcx, 0x8(%rdx,%rsi)
movq 0x5f56(%rip), %rdi      # 0x94e8
movq 0x38(%rdi), %rcx
cltq
shlq $0x4, %rax
movss (%rcx,%rax), %xmm0
movss %xmm0, (%rdi)
movq 0x8(%rcx,%rax), %rax
movq %rax, 0x40(%rdi)
movl 0x5f2c(%rip), %ecx      # 0x94e0
movl $0x1, %eax
shll %cl, %eax
movl $0x1, %ebx
movl %eax, 0x24(%rdi)
movl %ecx, 0x4(%rdi)
callq 0x4a30
movq 0x5f16(%rip), %rsi      # 0x94e8
testq %rax, %rax
je 0x35e5
movl 0x4(%rsi), %edx
movl %edx, %ecx
shll %cl, %ebx
xorl %ebx, 0x20(%rax)
jmp 0x3612
popq %rbx
retq
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x3606
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x3600
cmpl $0x0, 0x10(%rax)
je 0x3608
movq 0x28(%rax), %rax
jmp 0x35e9
xorl %eax, %eax
movq %rax, 0x5ec1(%rip)      # 0x94d0
movl 0x4(%rsi), %edx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x416d
movq 0x5ec5(%rip), %rdi      # 0x94e8
callq 0x3d5e
popq %rbx
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x5eb3(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x367a
movq 0x30(%rax), %rdx
addq $0x30, %rdx
movq %rdx, %rcx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x365a
leaq 0x28(%rsi), %rdx
cmpq %rax, %rsi
jne 0x3646
movq 0x28(%rax), %rdx
movq %rdx, (%rcx)
movq 0x30(%rax), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq %rax, 0x30(%rcx)
movq 0x30(%rax), %rdi
jmp 0x3d5e
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3ec3
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x1, 0x20(%rsp)
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0x569e(%rip)      # 0x94d0
testq %rax, %rax
je 0x3e8f
movq %rsp, %r14
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x3e7f
movq 0x30(%rax), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rax)
je 0x3e7f
movl 0x10(%rax), %edx
cmpl 0x10(%rcx), %edx
jne 0x3e7f
movq 0x5662(%rip), %rdi      # 0x94c0
movq 0x38(%rax), %rsi
movl $0x60, %edx
movq %r14, %rcx
callq 0x20a0
movq 0x565a(%rip), %rax      # 0x94d0
movq 0x38(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x5646(%rip)      # 0x94d0
testq %rax, %rax
jne 0x3e3a
movq 0x562a(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
leaq 0x564c(%rip), %rbx      # 0x94f0
movq 0x5615(%rip), %rdi      # 0x94c0
movl $0x10, %esi
movq %rbx, %rdx
callq 0x22c0
testl %eax, %eax
jne 0x3ea4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movl %esi, (%rdi)
movl %edx, 0x4(%rax)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rax)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rax)
movl %r8d, 0xc(%rdi)
movq 0x55d0(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rsi
movl $0xf, %edx
movq %rax, %rcx
callq 0x20a0
movq 0x55b8(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq %rbx, %rdi
callq 0x3f1d
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x41a0
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
xorl %eax, 0x20(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x428a
movq 0x30(%rbx), %rdi
movq %rdi, 0x5325(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x41ed
movl $0x1, %r12d
movl %r15d, %ecx
shll %cl, %r12d
cmpq %r14, %rdi
je 0x41dd
movl 0x20(%rdi), %eax
testl %r12d, %eax
je 0x41dd
xorl %r12d, %eax
movl %eax, 0x20(%rdi)
xorl %esi, %esi
callq 0x428a
movq 0x52f3(%rip), %rdi      # 0x94d0
movq 0x28(%rdi), %rdi
movq %rdi, 0x52e8(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x41bc
testq %r14, %r14
sete %al
movq %r14, 0x28(%rbx)
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x426c
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x4221
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x421b
cmpl $0x0, 0x10(%rax)
je 0x4255
movq 0x28(%rax), %rax
jmp 0x4204
movq 0x30(%r14), %rax
movq 0x30(%rax), %rcx
xorl %edi, %edi
movq %rcx, %rax
testq %rcx, %rcx
je 0x4251
cmpq %r14, %rax
je 0x4251
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
movq 0x28(%rax), %rcx
cmovneq %rax, %rdi
cmpq %r14, %rcx
jne 0x422b
jmp 0x4258
xorl %edi, %edi
jmp 0x4258
movq %rax, %rdi
movq %rax, 0x5271(%rip)      # 0x94d0
movl 0x4(%rbx), %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x416d
testq %r14, %r14
je 0x4281
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x43c9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x5220(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorl %r14d, %r14d
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
testl %ebp, %ebp
jne 0x42e8
movq 0x5202(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %r14d, 0x8(%rsp)
movl %r14d, (%rsp)
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
movl 0x4a46(%rip), %ebp      # 0x8d34
movq 0x51cb(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %r14d, 0x8(%rsp)
movl $0x1, %r15d
movl %r15d, (%rsp)
movl %ebp, %esi
movl $0x40, %edx
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
movq 0x5194(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %r14d, 0x8(%rsp)
movl %r15d, (%rsp)
movl %ebp, %esi
movl $0x42, %edx
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
movq 0x5163(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %r14d, 0x8(%rsp)
movl %r15d, (%rsp)
movl $0x3, %esi
movl $0x40, %edx
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
movq 0x512f(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %r14d, 0x8(%rsp)
movl %r15d, (%rsp)
movl $0x3, %esi
movl $0x42, %edx
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x440a
pushq %rax
movq 0x28(%rdi), %rax
leaq 0x38(%rax), %rcx
testq %rax, %rax
movq 0x50df(%rip), %rdi      # 0x94c0
leaq 0x51c8(%rip), %rax      # 0x95b0
cmovneq %rcx, %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2310
movq 0x50be(%rip), %rdi      # 0x94c0
xorl %esi, %esi
popq %rax
jmp 0x2330
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x4d86(%rip), %rax      # 0x95c0
testq %rax, %rax
je 0x4861
movl 0x8(%rax), %ecx
cmpl %edi, %ecx
jg 0x485b
addl 0x14(%rax), %ecx
cmpl %edi, %ecx
jl 0x485b
movl 0xc(%rax), %ecx
cmpl %esi, %ecx
jg 0x485b
addl 0x10(%rax), %ecx
cmpl %esi, %ecx
jge 0x4863
movq 0x48(%rax), %rax
jmp 0x483a
xorl %eax, %eax
movq %rax, 0x4c6e(%rip)      # 0x94d8
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x30(%rdi)
je 0x487e
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x4886
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4997
movq %r14, 0x30(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x1c(%rbx)
movq $0x0, 0x28(%rbx)
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x48d8
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x48c6
movq 0x28(%r14), %rax
addq $0x28, %r14
movq %rax, 0x28(%rbx)
jmp 0x48dc
movq %rax, %r14
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x48c6
addq $0x28, %r14
jmp 0x48dc
addq $0x30, %r14
movq %rbx, (%r14)
movl $0x0, 0x20(%rbx)
movq 0x30(%rbx), %rsi
movl 0x4(%rsi), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x416d
cmpl $0x0, 0x10(%rbx)
je 0x4905
movq %rbx, %rdi
callq 0x49e0
movq 0x4bdc(%rip), %rdi      # 0x94e8
callq 0x4a30
movq 0x4bd0(%rip), %rcx      # 0x94e8
movq %rax, 0x28(%rcx)
movq 0x4c9d(%rip), %rdi      # 0x95c0
movq %rdi, 0x4bae(%rip)      # 0x94d8
testq %rdi, %rdi
je 0x4941
callq 0x3d5e
movq 0x4b9d(%rip), %rax      # 0x94d8
movq 0x48(%rax), %rdi
jmp 0x4923
movq 0x30(%rbx), %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4953
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x4b86(%rip), %rax      # 0x94e8
testq %rax, %rax
je 0x4977
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4977
xorl %esi, %esi
callq 0x428a
movq %rbx, 0x4b6a(%rip)      # 0x94e8
testl %ebp, %ebp
je 0x4990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43c9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %esi, %eax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
testl %eax, %eax
jne 0x49bf
cmpq %rbx, 0x28(%rsi)
jne 0x49bf
movl 0x4(%rsi), %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x416d
movq 0x30(%rbx), %rsi
addq $0x30, %rsi
movq %rsi, %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x49d7
leaq 0x28(%rcx), %rsi
cmpq %rbx, %rcx
jne 0x49c3
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4a56
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x4a50
movl 0x20(%rax), %ecx
movl 0x4(%rdi), %edx
btl %edx, %ecx
jb 0x4a58
movq 0x28(%rax), %rax
jmp 0x4a34
xorl %eax, %eax
movq %rax, 0x4a71(%rip)      # 0x94d0
retq
// File: /workspace/github_c_makefile_star2_O3/gitluin[P]sara/src/sara.c
// Function: tile
void
tile(monitor* m){
	int n = 0, i = 0, h = 0, x = m->mx + gappx, y = (bottombar ? (m->my + gappx) : (m->wy + barpx)), max_h = (bottombar ? (m->wh - barpx) : (m->mh - gappx));
	client* nf = NULL;

	/* Find the first non-floating, visible window and tally non-floating, visible windows */
	for EACHCLIENT(m->head){
		if (!ic->isfloat && ISVISIBLE(ic)){
			nf = (!nf) ? ic : nf;
			n++;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4cfc
movq %rdi, %r14
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %ebx
addl $0xa, %ebp
movl 0x18(%rdi), %r15d
addl $0x14, %r15d
addl $-0xa, %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl $0x0, 0x10(%rax)
jne 0x4ca0
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x4ca0
testq %r12, %r12
cmoveq %rax, %r12
incl %r13d
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x4c84
movq $0x0, 0x481c(%rip) # 0x94d0
testq %r12, %r12
setne %al
cmpl $0x1, %r13d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4d0c
cmpl $0x0, 0x18(%r12)
jne 0x4df8
movl 0x14(%r14), %ecx
addl $-0x14, %ecx
subl %r15d, %ebx
movq %r12, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ec4
movq $0x0, 0x47c9(%rip) # 0x94d0
jmp 0x4df8
testq %r12, %r12
je 0x4df8
cmpl $0x0, 0x18(%r12)
jne 0x4d41
movss (%r14), %xmm0
addss 0x134e(%rip), %xmm0     # 0x6078
cvttss2si %xmm0, %ecx
movl %ebx, %r8d
subl %r15d, %r8d
movq %r12, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x3ec4
movq 0x28(%r12), %rdi
movq %rdi, 0x4783(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x4df8
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm0, 0x4(%rsp)
xorl %ebp, %ebp
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
je 0x4de4
cmpl $0x0, 0x10(%rdi)
jne 0x4de4
cmpl $0x0, 0x18(%rdi)
jne 0x4de4
movl %ebx, %eax
subl %r15d, %eax
movl %ebp, %ecx
notl %ecx
addl %r13d, %ecx
cltd
idivl %ecx
movl %eax, %r12d
movss (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x14(%r14), %xmm1
subss %xmm0, %xmm1
addss 0x4(%rsp), %xmm0
cvttss2si %xmm0, %esi
addss 0x12c9(%rip), %xmm1     # 0x607c
cvttss2si %xmm1, %ecx
movl %r15d, %edx
movl %eax, %r8d
callq 0x3ec4
leal (%r12,%r15), %eax
addl $0xa, %r12d
cmpl %ebx, %eax
movl $0x0, %eax
cmovgel %eax, %r12d
addl %r15d, %r12d
incl %ebp
movq 0x46ef(%rip), %rdi      # 0x94d0
movl %r12d, %r15d
movq 0x28(%rdi), %rdi
movq %rdi, 0x46e1(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x4d65
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
movl 0x18(%rdi), %r15d
movq 0x30(%rdi), %rdi
movq %rdi, 0x46a9(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x4e7c
addl $0xa, %ebp
subl %r15d, %r14d
addl $0x14, %r15d
addl $-0x1e, %r14d
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
je 0x4e6c
cmpl $0x0, 0x10(%rdi)
jne 0x4e6c
cmpl $0x0, 0x18(%rdi)
jne 0x4e6c
movl 0x14(%rbx), %ecx
addl $-0x14, %ecx
movl %ebp, %esi
movl %r15d, %edx
movl %r14d, %r8d
callq 0x3ec4
movq 0x4664(%rip), %rdi      # 0x94d0
movq 0x28(%rdi), %rdi
movq %rdi, 0x4659(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x4e3a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x4732(%rip), %rcx      # 0x95c0
testq %rcx, %rcx
je 0x4ec8
movq 0x30(%rcx), %rax
testq %rax, %rax
je 0x4ea8
cmpq %rdi, 0x38(%rax)
je 0x4eb9
movq 0x28(%rax), %rax
jmp 0x4e97
movq $0x0, 0x461d(%rip) # 0x94d0
movq 0x48(%rcx), %rcx
jmp 0x4e8e
movq %rcx, 0x4618(%rip)      # 0x94d8
movq %rax, 0x4609(%rip)      # 0x94d0
retq
movq $0x0, 0x4605(%rip) # 0x94d8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x58, %rsp
movq %rsp, %r8
movl $0x16, (%r8)
xorl %ecx, %ecx
movq %rcx, 0x8(%r8)
movl %ecx, 0x10(%r8)
movq 0x43ba(%rip), %rax      # 0x94c0
movq %rax, 0x18(%r8)
movq 0x38(%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movups (%rdi), %xmm0
movups %xmm0, 0x30(%r8)
movl %ecx, 0x40(%r8)
movq %rcx, 0x48(%r8)
movl %ecx, 0x50(%r8)
movl $0x20000, %ecx          # imm = 0x20000
movq %rax, %rdi
xorl %edx, %edx
callq 0x2350
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x30(%rdi), %rbx
xorl %esi, %esi
callq 0x4997
testl %ebp, %ebp
jne 0x51c4
movq 0x4363(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x4357(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
movq 0x4340(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rsi
movq 0x444d(%rip), %rcx      # 0x95d8
leaq 0x444e(%rip), %rax      # 0x95e0
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x2400
addq $0x10, %rsp
movq 0x430f(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x4301(%rip), %rdi      # 0x94c0
callq 0x2240
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x3d5e
popq %rbx
popq %r14
popq %rbp
jmp 0x4a60
// File: /workspace/github_c_makefile_star2_O3/szanni[P]slideextract/main.c
// Function: main
int
main (int argc, char **argv)
{
	struct roi roi;
	bool gflag = 0;
	bool rflag = 0;
	int c;
	int ret;

	while ((c = getopt(argc, argv, "gr:Vh")) != -1) {
		switch (c) {
			case 'g':
				gflag = 1;
				break;

			case 'r':
				rflag = 1;
				if (sscanf(optarg, "%d.%d:%dx%d", &roi.x, &roi.y, &roi.width, &roi.height) != 4)
					help();
				break;

			case 'V':
				version();
				break;

			case 'h':
			case '?':
			default:
				help();
		}
	}
	argc -= optind;
	argv += optind;

	if (argc != 2 || (gflag && rflag))
		help();

	const char *file = *argv++;
	const char *outprefix = *argv;

	if (rflag)
		return se_extract_slides(file, outprefix, &roi);

	if (gflag)
	{
		if ((ret = se_select_roi(file, &roi)))
			return ret;

		printf("Selected ROI: %d.%d:%dx%d\n", roi.x, roi.y, roi.width, roi.height);
		return se_extract_slides(file, outprefix, &roi);
	}

	return se_extract_slides(file, outprefix, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
leaq 0xe56(%rip), %r13       # 0x4083
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movl %r12d, %ecx
movl %ecx, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2200
movb $0x1, %cl
cmpl $0x67, %eax
je 0x3238
cmpl $-0x1, %eax
je 0x3294
cmpl $0x72, %eax
jne 0x332c
movq 0x2d7c(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0xe1b(%rip), %rsi       # 0x4089
movq %r15, %rdx
leaq 0xc(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x14(%rsp), %r9
xorl %eax, %eax
callq 0x2180
movb $0x1, %r14b
cmpl $0x4, %eax
je 0x3235
jmp 0x333a
movq 0x2d2d(%rip), %rax      # 0x5fc8
movslq (%rax), %rax
subl %eax, %ebp
cmpl $0x2, %ebp
jne 0x333a
testb $0x1, %r12b
je 0x3300
testb $0x1, %r14b
jne 0x333a
movq (%rbx,%rax,8), %r14
movq 0x8(%rbx,%rax,8), %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23dc
testl %eax, %eax
jne 0x331d
leaq 0x8(%rsp), %r15
movl (%r15), %esi
movl 0x4(%r15), %edx
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
leaq 0xda7(%rip), %rdi       # 0x4095
xorl %eax, %eax
callq 0x20f0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
jmp 0x3318
movq (%rbx,%rax,8), %rdi
movq 0x8(%rbx,%rax,8), %rsi
testb $0x1, %r14b
je 0x3316
leaq 0x8(%rsp), %rdx
jmp 0x3318
xorl %edx, %edx
callq 0x2a33
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x56, %eax
jne 0x333a
leaq 0xf2a(%rip), %rdi       # 0x4262
jmp 0x3341
leaq 0xd6f(%rip), %rdi       # 0x40b0
callq 0x2150
xorl %edi, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/challenge.c
// Function: countdown_ring
BEH_DECL(countdown_ring)
{
	CONS* m = WHAT;
	CONS* state = MINE;
	CONS* n = map_get(state, ATOM("n"));
	CONS* a = map_get(state, ATOM("a"));

	DBUG_ENTER("countdown_ring");
	DBUG_PRINT("", ("self=%p", SELF));
	DBUG_PRINT("", ("m=%d n=%d a=%p", MK_INT(m), MK_INT(n), a));
	if (MK_INT(m) < 0) {
		SEND(a, n);
	} else if (0 < MK_INT(n)) {
		SEND(a, m);
	} else if (0 < MK_INT(m)) {
		SEND(a, NUMBER(MK_INT(m) - 1));
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xad85
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0xace6
movq %rax, %rdi
callq 0x2dd9
movq %rax, %r15
leaq 0xa99a(%rip), %rdi      # 0xd09e
callq 0x8173
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb1ba
movq %rax, %r12
leaq 0xa8e4(%rip), %rdi      # 0xd004
callq 0x8173
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb1ba
movq %rax, 0x8(%rsp)
leaq 0xa8c8(%rip), %rax      # 0xd006
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xfbab(%rip), %rbp      # 0x122f8
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2e, 0xc(%rdi)
leaq 0xc50b(%rip), %r13      # 0xec74
movq %r13, 0x10(%rdi)
leaq 0xf9ac(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca9a
leaq 0x10108(%rip), %r15     # 0x12890
cmpl $0x0, (%r15)
je 0x2821
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xc1fc
testl %eax, %eax
je 0x27d3
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x2f, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0xace6
leaq 0xa84c(%rip), %rdi      # 0xd015
movq %rax, %rsi
xorl %eax, %eax
callq 0xcb0b
cmpl $0x0, (%r15)
je 0x2821
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xc1fc
testl %eax, %eax
je 0x2821
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x30, 0xc(%rax)
movq %r14, %rsi
shrq $0x2, %rsi
movq %r12, %rdx
shrq $0x2, %rdx
leaq 0xa808(%rip), %rdi      # 0xd01d
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0xcb0b
movq %r14, %rax
shrq $0x2, %rax
testl %eax, %eax
js 0x285a
shrq $0x2, %r12
testl %r12d, %r12d
jg 0x284d
testl %eax, %eax
je 0x286a
movabsq $0x3fffffffc, %rax      # imm = 0x3FFFFFFFC
addq %rax, %r14
andq %rax, %r14
orq $0x3, %r14
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
jmp 0x2865
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x3a0f
leaq 0x10(%rsp), %rdi
movl $0x38, 0xc(%rdi)
callq 0xcc1f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/challenge.c
// Function: test_erlang_challenge
void
test_erlang_challenge(int counter)
{
	CONFIG* cfg;
	CONS* actor;
	int n;
	int m;

	DBUG_ENTER("test_erlang_challenge");
	cfg = new_configuration(10);
	actor = CFG_ACTOR(cfg, challenge, map_put(NIL, ATOM("n"), NUMBER(counter)));
	CFG_SEND(cfg, actor, actor);
	for (m = 1; m < 1000000; ++m) {
		n = run_configuration(cfg, 1000000);
		if (cfg->q_count <= 0) {
			/* queue empty */
			break;
		}
	}
	TRACE(printf("~%dM messages delivered.\n", m));
	report_actor_usage(cfg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebp
leaq 0xa52d(%rip), %rax      # 0xd03d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xf7db(%rip), %rax      # 0x122f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x6e, 0xc(%rdi)
leaq 0xc13c(%rip), %rcx      # 0xec74
movq %rcx, 0x10(%rdi)
leaq 0xf5dd(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca9a
movl $0xa, %edi
callq 0x326d
movq %rax, %rbx
leaq 0xa53a(%rip), %rdi      # 0xd09e
callq 0x8173
movslq %ebp, %rcx
leaq 0x3(,%rcx,4), %rdx
leaq 0xf6ed(%rip), %rdi      # 0x12268
movq %rax, %rsi
callq 0xb22c
leaq -0x300(%rip), %rsi      # 0x288a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x3932
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x3a0f
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x4083
cmpl $0x0, 0x28(%rbx)
jle 0x2bca
incl %ebp
cmpl $0xf4240, %ebp          # imm = 0xF4240
jne 0x2ba8
movl $0xf4240, %ebp          # imm = 0xF4240
leaq 0xa482(%rip), %rdi      # 0xd053
movl %ebp, %esi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x4bf4
movq %rsp, %rdi
movl $0x7b, 0xc(%rdi)
callq 0xcc1f
addq $0x28, %rsp
popq %rbx
popq %rbp
retq