LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x61d9(%rip), %rsi      # 0x94e0
callq *0x60a3(%rip)           # 0x93b0
movl 0x61cd(%rip), %edi      # 0x94e0
cmpl $0x9, %edi
ja 0x3375
movq 0x61c9(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x3339
cmpl $0x0, 0x18(%rax)
je 0x3339
callq 0x3046
movl 0x61a7(%rip), %edi      # 0x94e0
callq 0x4b22
movl 0x619c(%rip), %ecx      # 0x94e0
pushq $0x1
popq %rbx
movl %ebx, %eax
shll %cl, %eax
movq 0x6196(%rip), %rdi      # 0x94e8
movl %eax, 0x24(%rdi)
movl %ecx, 0x4(%rdi)
callq 0x46d0
movq 0x6184(%rip), %rsi      # 0x94e8
testq %rax, %rax
je 0x3377
movl 0x4(%rsi), %edx
movl %edx, %ecx
shll %cl, %ebx
xorl %ebx, 0x20(%rax)
jmp 0x338c
popq %rbx
retq
movq 0x30(%rsi), %rdi
xorl %esi, %esi
callq 0x3a34
movq 0x615f(%rip), %rsi      # 0x94e8
movl 0x4(%rsi), %edx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x3eb5
movq 0x614b(%rip), %rdi      # 0x94e8
callq 0x3a60
popq %rbx
jmp 0x4701
// File: /workspace/github_c_makefile_star2_O2/gitluin[P]sara/src/sara.c
// Function: zoom
void
zoom(const Arg arg){
	client* c;

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

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

// Assembly:
pushq %rbx
movq 0x6138(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rbx
testq %rbx, %rbx
je 0x33d8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x45f5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x463c
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x3a60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
testq %rax, %rax
je 0x3a58
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x3a52
testl %esi, %esi
jne 0x3a58
cmpl $0x0, 0x10(%rax)
je 0x3a58
movq 0x28(%rax), %rax
jmp 0x3a37
movq %rax, 0x5a71(%rip)      # 0x94d0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x30(%rdi), %rax
movq 0x30(%rax), %r9
xorl %r8d, %r8d
movq %r9, %rcx
testq %r9, %r9
je 0x3b59
movl $0x0, %eax
cmpq %rdi, %rcx
je 0x3b5b
testl %esi, %esi
je 0x3b46
movq 0x30(%rcx), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rcx)
je 0x3b4b
testl %edx, %edx
je 0x3b3e
cmpl $0x0, 0x10(%rcx)
movq %r8, %rax
jne 0x3b4e
movq %rcx, %rax
movq %rcx, %r8
jmp 0x3b4e
movq %rcx, %rax
jmp 0x3b4e
movq %r8, %rax
movq 0x28(%rcx), %r9
cmpq %rdi, %r9
jne 0x3b0f
jmp 0x3b5b
xorl %eax, %eax
movq %rcx, 0x596e(%rip)      # 0x94d0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c25
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, 0x20(%r14)
movq 0x38(%rax), %rax
movq %rax, 0x18(%r14)
leaq 0x30(%rdi), %rax
pushq $0x60
popq %rbp
movq (%rax), %rax
movq %rax, 0x592f(%rip)      # 0x94d0
testq %rax, %rax
je 0x3bee
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x3be8
movq 0x30(%rax), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rax)
je 0x3be8
movl 0x10(%rax), %edx
cmpl 0x10(%rcx), %edx
jne 0x3be8
movq 0x58f6(%rip), %rdi      # 0x94c0
movq 0x38(%rax), %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x20a0
movq 0x58f1(%rip), %rax      # 0x94d0
movq 0x38(%rax), %rcx
movq %rcx, 0x20(%rsp)
addq $0x28, %rax
jmp 0x3b97
movq 0x58cb(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
leaq 0x58ed(%rip), %rbx      # 0x94f0
pushq $0x10
popq %r14
movq 0x58b2(%rip), %rdi      # 0x94c0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22c0
testl %eax, %eax
jne 0x3c07
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x586e(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rsi
pushq $0xf
popq %rdx
movq %rax, %rcx
callq 0x20a0
movq 0x5858(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq %rbx, %rdi
callq 0x3c7d
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
shll %cl, %r15d
testq %rdi, %rdi
je 0x3ee1
xorl %r15d, 0x20(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3f7f
leaq 0x30(%rbx), %rdi
movq (%rdi), %rdi
movq %rdi, 0x55e1(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x3f1b
cmpq %r14, %rdi
je 0x3f15
movl 0x20(%rdi), %eax
testl %r15d, %eax
je 0x3f15
xorl %r15d, %eax
movl %eax, 0x20(%rdi)
xorl %esi, %esi
callq 0x3f7f
movq 0x55bb(%rip), %rdi      # 0x94d0
addq $0x28, %rdi
jmp 0x3ee5
testq %r14, %r14
sete %al
movq %r14, 0x28(%rbx)
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x3f5d
movq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x3a34
testq %rax, %rax
jne 0x3f4b
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3b04
movl 0x4(%rbx), %edx
movq %rax, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x3eb5
jmp 0x3f62
testq %r14, %r14
je 0x3f74
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4056
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x5527(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
testl %ebp, %ebp
jne 0x3fdc
movq 0x550c(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0xc
popq %r9
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
callq 0x23e0
xorl %r15d, %r15d
leaq 0x203a(%rip), %r13      # 0x6020
pushq $0xc
popq %rbp
cmpq $0x2, %r15
je 0x4047
imulq $0x18, %r15, %rax
leaq 0x4d36(%rip), %rcx      # 0x8d30
movl 0x4(%rax,%rcx), %r14d
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x4042
movq 0x54b1(%rip), %rdi      # 0x94c0
movl (%r12,%r13), %edx
orl $0x40, %edx
movq 0x38(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
movl %r14d, %esi
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x23e0
addq $0x4, %r12
jmp 0x4002
incq %r15
jmp 0x3fe9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4095
pushq %rax
movq 0x28(%rdi), %rax
leaq 0x38(%rax), %rcx
testq %rax, %rax
movq 0x5452(%rip), %rdi      # 0x94c0
leaq 0x553b(%rip), %rax      # 0x95b0
cmovneq %rcx, %rax
movq (%rax), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x2310
movq 0x5433(%rip), %rdi      # 0x94c0
xorl %esi, %esi
popq %rax
jmp 0x2330
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x50f6(%rip), %rax      # 0x95c0
movq (%rax), %rax
testq %rax, %rax
je 0x44f4
movl 0x8(%rax), %ecx
cmpl %edi, %ecx
jg 0x44ee
addl 0x14(%rax), %ecx
cmpl %edi, %ecx
jl 0x44ee
movl 0xc(%rax), %ecx
cmpl %esi, %ecx
jg 0x44ee
addl 0x10(%rax), %ecx
cmpl %esi, %ecx
jge 0x44f4
addq $0x48, %rax
jmp 0x44ca
movq %rax, 0x4fdd(%rip)      # 0x94d8
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x450f
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x4517
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45f5
movq %r14, 0x30(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x1c(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x463c
andl $0x0, 0x20(%rbx)
movq 0x30(%rbx), %rsi
movl 0x4(%rsi), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3eb5
cmpl $0x0, 0x10(%rbx)
je 0x4562
movq %rbx, %rdi
callq 0x4680
movq 0x4f7f(%rip), %rdi      # 0x94e8
callq 0x46d0
movq 0x4f73(%rip), %rcx      # 0x94e8
movq %rax, 0x28(%rcx)
leaq 0x5040(%rip), %rax      # 0x95c0
movq (%rax), %rdi
movq %rdi, 0x4f4e(%rip)      # 0x94d8
testq %rdi, %rdi
je 0x45a1
callq 0x3a60
movq 0x4f3d(%rip), %rax      # 0x94d8
addq $0x48, %rax
jmp 0x4580
movq 0x30(%rbx), %rdi
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45b1
// File: /workspace/github_c_makefile_star2_O2/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 0x4f28(%rip), %rax      # 0x94e8
testq %rax, %rax
je 0x45d5
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x45d5
xorl %esi, %esi
callq 0x3f7f
movq %rbx, 0x4f0c(%rip)      # 0x94e8
testl %ebp, %ebp
je 0x45ee
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4056
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x461b
cmpq %rbx, 0x28(%rsi)
jne 0x461b
movl 0x4(%rsi), %edx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x3eb5
movq 0x30(%rbx), %rsi
addq $0x30, %rsi
movq %rsi, %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x4633
leaq 0x28(%rcx), %rsi
cmpq %rbx, %rcx
jne 0x461f
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x30(%rdi), %rax
movq 0x30(%rax), %rcx
testl %esi, %esi
je 0x4674
testq %rcx, %rcx
je 0x4672
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x4660
movq 0x28(%rax), %rcx
addq $0x28, %rax
jmp 0x4678
movq %rcx, %rax
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x4660
addq $0x28, %rax
jmp 0x467c
xorl %ecx, %ecx
addq $0x30, %rax
movq %rcx, 0x28(%rdi)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x4c29(%rip), %rdx      # 0x94e8
testl %edi, %edi
jle 0x48d4
movq 0x48(%rdx), %rax
testq %rax, %rax
jne 0x48fa
movq 0x4ced(%rip), %rax      # 0x95c0
retq
movq 0x4ce5(%rip), %rcx      # 0x95c0
cmpq %rcx, %rdx
je 0x48ee
movq %rcx, %rax
movq 0x48(%rcx), %rcx
cmpq %rdx, %rcx
jne 0x48e0
jmp 0x48fa
movq %rcx, %rax
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
jne 0x48ee
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r14
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %ebx
movl 0x18(%rdi), %r15d
leaq 0x30(%rdi), %rax
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%rax), %rax
testq %rax, %rax
je 0x4947
cmpl $0x0, 0x10(%rax)
jne 0x4941
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x4941
testq %r12, %r12
cmoveq %rax, %r12
incl %r13d
addq $0x28, %rax
jmp 0x491d
addl $0xa, %ebp
andq $0x0, 0x4b7e(%rip)      # 0x94d0
addl $0x14, %r15d
addl $-0xa, %ebx
testq %r12, %r12
setne %al
cmpl $0x1, %r13d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x49a1
cmpl $0x0, 0x18(%r12)
jne 0x4a9a
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 0x3c26
testq %r12, %r12
je 0x4a9a
cmpl $0x0, 0x18(%r12)
jne 0x49d6
movss (%r14), %xmm0
addss 0x1691(%rip), %xmm0     # 0x6050
cvttss2si %xmm0, %ecx
movl %ebx, %r8d
subl %r15d, %r8d
movq %r12, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x3c26
cvtsi2ss %ebp, %xmm2
movss 0x1672(%rip), %xmm3     # 0x6054
xorl %ecx, %ecx
movq 0x28(%r12), %r12
testq %r12, %r12
je 0x4a93
movq 0x30(%r12), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%r12)
je 0x49e4
cmpl $0x0, 0x10(%r12)
jne 0x49e4
cmpl $0x0, 0x18(%r12)
jne 0x49e4
movq %r12, 0x4ab8(%rip)      # 0x94d0
movl %ebx, %eax
subl %r15d, %eax
movl %ecx, (%rsp)
movl (%rsp), %ecx
notl %ecx
addl %r13d, %ecx
cltd
idivl %ecx
movl %eax, %ebp
movss (%r14), %xmm0
cvtsi2ssl 0x14(%r14), %xmm1
subss %xmm0, %xmm1
addss %xmm2, %xmm0
cvttss2si %xmm0, %esi
addss %xmm3, %xmm1
cvttss2si %xmm1, %ecx
movq %r12, %rdi
movl %r15d, %edx
movl %eax, %r8d
movss %xmm2, 0x4(%rsp)
callq 0x3c26
movss 0x15ec(%rip), %xmm3     # 0x6054
xorl %ecx, %ecx
movss 0x4(%rsp), %xmm2
leal (%r15,%rbp), %eax
addl $0xa, %ebp
cmpl %ebx, %eax
cmovgel %ecx, %ebp
movl (%rsp), %ecx
addl %r15d, %ebp
incl %ecx
movq 0x4a45(%rip), %r12      # 0x94d0
movl %ebp, %r15d
jmp 0x49e4
movq %r12, 0x4a36(%rip)      # 0x94d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
addl $0xa, %ebp
movl 0x18(%rdi), %r15d
addq $0x30, %rdi
subl %r15d, %r14d
addl $0x14, %r15d
addl $-0x1e, %r14d
movq (%rdi), %rdi
movq %rdi, 0x49f6(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x4b17
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
je 0x4b11
cmpl $0x0, 0x10(%rdi)
jne 0x4b11
cmpl $0x0, 0x18(%rdi)
jne 0x4b11
movl 0x14(%rbx), %ecx
addl $-0x14, %ecx
movl %ebp, %esi
movl %r15d, %edx
movl %r14d, %r8d
callq 0x3c26
movq 0x49bf(%rip), %rdi      # 0x94d0
addq $0x28, %rdi
jmp 0x4ad0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x49bf(%rip), %rax      # 0x94e8
movss (%rax), %xmm0
movq 0x38(%rax), %rcx
movslq 0x4(%rax), %rdx
shlq $0x4, %rdx
movss %xmm0, (%rcx,%rdx)
movq 0x40(%rax), %rax
movq %rax, 0x8(%rcx,%rdx)
movq 0x499a(%rip), %rax      # 0x94e8
movq 0x38(%rax), %rcx
movslq %edi, %rdx
shlq $0x4, %rdx
movss (%rcx,%rdx), %xmm0
movss %xmm0, (%rax)
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, 0x40(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x4a4d(%rip), %rcx      # 0x95c0
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x4bb0
leaq 0x30(%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x4b93
cmpq %rdi, 0x38(%rax)
je 0x4ba1
addq $0x28, %rax
jmp 0x4b7f
andq $0x0, 0x4935(%rip)      # 0x94d0
addq $0x48, %rcx
jmp 0x4b73
movq %rcx, 0x4930(%rip)      # 0x94d8
movq %rax, 0x4921(%rip)      # 0x94d0
retq
andq $0x0, 0x4920(%rip)      # 0x94d8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x8(%r8)
andl $0x0, 0x10(%r8)
movq 0x475e(%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)
andl $0x0, 0x40(%r8)
andq $0x0, 0x48(%r8)
andl $0x0, 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_O2/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 0x45f5
testl %ebp, %ebp
jne 0x4e1f
movq 0x4704(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x46f8(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
movq 0x46e1(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rsi
movq 0x47ee(%rip), %rcx      # 0x95d8
leaq 0x47ef(%rip), %rax      # 0x95e0
pushq $0x20
popq %r8
movq %rcx, %rdx
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x2400
popq %rcx
popq %rdx
movq 0x46b4(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x46a6(%rip), %rdi      # 0x94c0
callq 0x2240
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x3a60
popq %rbx
popq %r14
popq %rbp
jmp 0x4701
// File: /workspace/github_c_makefile_star2_O2/szanni[P]slideextract/slideextract.cpp
// Function: se_mouseHandler(int, int, int, int, void*)
static void
_se_mouseHandler(int event, int x, int y, int flags, void *param)
{
	Mat clone;
	Mat frame = *(Mat*)param;

	if (event == EVENT_LBUTTONDOWN && (flags & EVENT_FLAG_LBUTTON)) {
		point1 = Point (x, y);
		point2 = Point (x, y);
	}

	if (!(flags & EVENT_FLAG_LBUTTON))
		return;

	if (event != EVENT_MOUSEMOVE && event != EVENT_LBUTTONUP)
		return;

	point2 = Point(x, y);
	selected_roi = (point1.x != point2.x && point1.y != point2.y);

	clone = frame.clone();
	rectangle(clone, point1, point2, CV_RGB(0, 255, 0), 1, 8, 0);
	imshow("frame", clone);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r8, %r12
movl %ecx, %r14d
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
leaq 0xf8(%rsp), %rdi
callq 0x2060
leaq 0x98(%rsp), %rdi
movq %r12, %rsi
callq 0x2160
cmpl $0x1, %r15d
setne %al
testb $0x1, %r14b
sete %cl
orb %al, %cl
jne 0x27c7
movl %ebp, 0x39df(%rip)      # 0x6194
movl %ebx, 0x39dd(%rip)      # 0x6198
movl %ebp, 0x39db(%rip)      # 0x619c
movl %ebx, 0x39d9(%rip)      # 0x61a0
testb $0x1, %r14b
sete %al
testl $0xfffffffb, %r15d      # imm = 0xFFFFFFFB
setne %cl
orb %al, %cl
jne 0x2903
cmpl %ebp, 0x39ae(%rip)      # 0x6194
movl %ebp, 0x39b0(%rip)      # 0x619c
setne %al
cmpl %ebx, 0x39a3(%rip)      # 0x6198
movl %ebx, 0x39a5(%rip)      # 0x61a0
setne %cl
andb %al, %cl
movb %cl, 0x399e(%rip)       # 0x61a4
leaq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x20d0
leaq 0xf8(%rsp), %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2070
leaq 0x20(%rsp), %rdi
callq 0x2080
leaq 0x80(%rsp), %r14
andq $0x0, 0x10(%r14)
movl $0x3010000, (%r14)      # imm = 0x3010000
movq %rbx, 0x8(%r14)
movl 0x393f(%rip), %eax      # 0x6194
leaq 0x18(%rsp), %r15
movl %eax, (%r15)
movl 0x3935(%rip), %eax      # 0x6198
movl %eax, 0x4(%r15)
movl 0x392f(%rip), %eax      # 0x619c
leaq 0x10(%rsp), %r12
movl %eax, (%r12)
movl 0x3924(%rip), %eax      # 0x61a0
movl %eax, 0x4(%r12)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x2f5a
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x176d(%rip), %xmm1     # xmm1 = xmm1[0,1],mem[0,1]
movaps %xmm1, (%r13)
movaps %xmm0, 0x10(%r13)
andl $0x0, (%rsp)
pushq $0x1
popq %r8
pushq $0x8
popq %r9
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2050
leaq 0x1767(%rip), %rsi      # 0x4030
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2e7e
leaq 0x80(%rsp), %rsi
andq $0x0, 0x10(%rsi)
movl $0x1010000, (%rsi)      # imm = 0x1010000
movq %rbx, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
callq 0x2030
leaq 0x20(%rsp), %rdi
callq 0x2280
leaq 0x98(%rsp), %rdi
callq 0x2080
leaq 0xf8(%rsp), %rdi
callq 0x2080
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2280
jmp 0x2954
jmp 0x2951
jmp 0x2951
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2080
jmp 0x2954
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2080
jmp 0x2966
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/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 %r12d, %r12d
leaq 0xf4e(%rip), %r13       # 0x4083
leaq 0x8(%rsp), %r15
xorl %r14d, %r14d
movl %r12d, %ecx
movl %ecx, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2210
movb $0x1, %cl
cmpl $0x67, %eax
je 0x3140
cmpl $-0x1, %eax
je 0x319c
cmpl $0x72, %eax
jne 0x3234
movq 0x2e74(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0xf13(%rip), %rsi       # 0x4089
movq %r15, %rdx
leaq 0xc(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x14(%rsp), %r9
xorl %eax, %eax
callq 0x2190
movb $0x1, %r14b
cmpl $0x4, %eax
je 0x313d
jmp 0x324c
movq 0x2e25(%rip), %rax      # 0x5fc8
movslq (%rax), %rax
subl %eax, %ebp
cmpl $0x2, %ebp
jne 0x324c
testb $0x1, %r12b
je 0x3208
testb $0x1, %r14b
jne 0x324c
movq (%rbx,%rax,8), %r14
movq 0x8(%rbx,%rax,8), %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23ec
testl %eax, %eax
jne 0x3225
leaq 0x8(%rsp), %r15
movl (%r15), %esi
movl 0x4(%r15), %edx
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
leaq 0xe9f(%rip), %rdi       # 0x4095
xorl %eax, %eax
callq 0x20f0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
jmp 0x3220
movq (%rbx,%rax,8), %rdi
movq 0x8(%rbx,%rax,8), %rsi
testb $0x1, %r14b
je 0x321e
leaq 0x8(%rsp), %rdx
jmp 0x3220
xorl %edx, %edx
callq 0x297b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x56, %eax
jne 0x324c
leaq 0x1022(%rip), %rdi      # 0x4262
callq 0x2150
xorl %edi, %edi
callq 0x2290
callq 0x3251
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/12-VirtualMemory/test_page_size.c
// Function: main
int main(int argc, char **argv) {
	char c;

	signal(SIGSEGV, handler);
	prev_ptr = ptr = sbrk(0);	// current value of program break.
	sbrk(1);			// force 1-page allocation.
	while(1)
		c = *(++ptr);
	return 0;
}

// Assembly:
pushq %rax
leaq -0x2a(%rip), %rsi       # 0x116c
pushq $0xb
popq %rdi
callq 0x1050
xorl %edi, %edi
callq 0x1040
movq %rax, 0x2eac(%rip)      # 0x4058
movq %rax, 0x2e9d(%rip)      # 0x4050
pushq $0x1
popq %rdi
callq 0x1040
jmp 0x11bb
// File: /workspace/github_c_makefile_star2_O2/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 0xa5ae
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0xa4a3
movq %rax, %rdi
callq 0x2a03
movq %rax, %r15
leaq 0xad3a(%rip), %rdi      # 0xd09e
callq 0x7bc7
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xaa2f
movq %rax, %r12
leaq 0xac84(%rip), %rdi      # 0xd004
callq 0x7bc7
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xaa2f
movq %rax, 0x8(%rsp)
leaq 0xac68(%rip), %rax      # 0xd006
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xff5b(%rip), %rbp      # 0x12308
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2e, 0xc(%rdi)
leaq 0xc883(%rip), %r13      # 0xec4c
movq %r13, 0x10(%rdi)
leaq 0xfd5c(%rip), %rcx      # 0x12130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xc321
leaq 0x104b8(%rip), %r15     # 0x128a0
cmpl $0x0, (%r15)
je 0x2481
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xba9c
testl %eax, %eax
je 0x2433
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x2f, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0xa4a3
leaq 0xabec(%rip), %rdi      # 0xd015
movq %rax, %rsi
xorl %eax, %eax
callq 0xc398
cmpl $0x0, (%r15)
je 0x2481
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xba9c
testl %eax, %eax
je 0x2481
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x30, 0xc(%rax)
movq %r14, %rsi
shrq $0x2, %rsi
movq %r12, %rdx
shrq $0x2, %rdx
leaq 0xaba8(%rip), %rdi      # 0xd01d
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0xc398
movq %r14, %rax
shrq $0x2, %rax
testl %eax, %eax
js 0x24ba
shrq $0x2, %r12
testl %r12d, %r12d
jg 0x24ad
testl %eax, %eax
je 0x24ca
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 0x24c5
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x373c
leaq 0x10(%rsp), %rdi
movl $0x38, 0xc(%rdi)
callq 0xc49a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa8cd(%rip), %rax      # 0xd03d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xfb8b(%rip), %rax      # 0x12308
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x6e, 0xc(%rdi)
leaq 0xc4b4(%rip), %rcx      # 0xec4c
movq %rcx, 0x10(%rdi)
leaq 0xf98d(%rip), %rcx      # 0x12130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xc321
pushq $0xa
popq %rdi
callq 0x2fb8
movq %rax, %rbx
leaq 0xa8dc(%rip), %rdi      # 0xd09e
callq 0x7bc7
movslq %ebp, %rcx
leaq 0x3(,%rcx,4), %rdx
leaq 0xfa9f(%rip), %rdi      # 0x12278
movq %rax, %rsi
callq 0xaaa1
leaq -0x2fe(%rip), %rsi      # 0x24ea
movq %rbx, %rdi
movq %rax, %rdx
callq 0x365f
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x373c
pushq $0x1
popq %rbp
cmpl $0xf4240, %ebp          # imm = 0xF4240
je 0x2823
movq %rbx, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x3d8f
cmpl $0x0, 0x28(%rbx)
jle 0x2823
incl %ebp
jmp 0x2804
leaq 0xa829(%rip), %rdi      # 0xd053
movl %ebp, %esi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x48ee
movq %rsp, %rdi
movl $0x7b, 0xc(%rdi)
callq 0xc49a
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/challenge.c
// Function: main
int
main(int argc, char** argv)
{
	int c;
	int counter = 1000;

	DBUG_ENTER("main");
	DBUG_PROCESS(argv[0]);
	while ((c = getopt(argc, argv, "n:#:V")) != EOF) {
		switch(c) {
		case 'n':	counter = atoi(optarg);	break;
		case '#':	DBUG_PUSH(optarg);		break;
		case 'V':	banner();				exit(EXIT_SUCCESS);
		case '?':							usage();
		default:							usage();
		}
	}
	banner();

	test_erlang_challenge(counter);	/* this test involves running the dispatch loop */

	report_cons_stats();
	DBUG_RETURN (exit(EXIT_SUCCESS), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xa7d5(%rip), %rax      # 0xd09b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xfa35(%rip), %r12      # 0x12308
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0xc35d(%rip), %rcx      # 0xec4c
movq %rcx, 0x10(%rdi)
leaq 0xf836(%rip), %rcx      # 0x12130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xc321
movq (%r12), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
jne 0x291e
movq 0xf6dd(%rip), %rcx      # 0x11ff8
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
callq 0x20b0
movq (%r12), %rcx
movl %eax, 0x10(%rcx)
movq (%rbx), %rax
movq %rax, 0x8(%rcx)
movl $0x3e8, %r14d           # imm = 0x3E8
leaq 0xa75e(%rip), %r15      # 0xd0a0
movq 0xf68f(%rip), %r13      # 0x11fd8
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21c0
cmpl $0x23, %eax
jne 0x2975
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9f, 0xc(%rax)
movq (%r13), %rdi
callq 0xbbf5
jmp 0x2949
cmpl $0x6e, %eax
jne 0x2988
movq (%r13), %rdi
callq 0x21e0
movl %eax, %r14d
jmp 0x2949
cmpl $-0x1, %eax
je 0x29a3
cmpl $0x3f, %eax
je 0x299e
cmpl $0x56, %eax
jne 0x299e
callq 0x2889
jmp 0x29c4
callq 0x2861
callq 0x2889
movl %r14d, %edi
callq 0x2761
callq 0x2851
movq %rsp, %rdi
movl $0xaa, 0xc(%rdi)
callq 0xc49a
xorl %edi, %edi
callq 0x2200
nop
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]oatk/rotate.c
// Function: print_seq
static void print_seq(char *seq, int len, int rv, int pos, int line_wd, FILE *fo)
{
    char *s;
    if (!rv) {
        // forward
        for (s = seq, seq += len; s < seq; s++) {
            fputc(*s, fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    } else {
         // reverse
        for (s = seq + len - 1; s >= seq; s--) {
            fputc(comp_table[(int) (*s)], fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %r15
movslq %esi, %r13
testl %edx, %edx
je 0x3aaf
incl %r14d
addq %r15, %r13
decq %r13
leaq 0x25d5(%rip), %r12      # 0x6050
cmpq %r15, %r13
jb 0x3ae7
movsbq (%r13), %rax
movsbl (%rax,%r12), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3aa7
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2190
incl %r14d
decq %r13
jmp 0x3a7b
addq %r15, %r13
incl %r14d
pushq $0xa
popq %r12
cmpq %r13, %r15
jae 0x3ae7
movsbl (%r15), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3adf
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2190
incq %r15
incl %r14d
jmp 0x3ab9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/pread1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	unlink(tmpfile);

	while (1) {
		assert(pread(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, %rbx
movaps 0x7db(%rip), %xmm0      # 0x3320
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21c0
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x2130
testl %ebp, %ebp
js 0x2bb9
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2bd2
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %r14
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2250
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2beb
incq (%rbx)
jmp 0x2b9b
leaq 0x6bc(%rip), %rdi       # 0x327c
leaq 0x6bd(%rip), %rsi       # 0x3284
leaq 0x6c5(%rip), %rcx       # 0x3293
pushq $0x12
jmp 0x2c02
leaq 0x6ed(%rip), %rdi       # 0x32c6
leaq 0x6a4(%rip), %rsi       # 0x3284
leaq 0x6ac(%rip), %rcx       # 0x3293
pushq $0x13
jmp 0x2c02
leaq 0x6ff(%rip), %rdi       # 0x32f1
leaq 0x68b(%rip), %rsi       # 0x3284
leaq 0x693(%rip), %rcx       # 0x3293
pushq $0x17
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_init
bcf_sweep_t *bcf_sweep_init(const char *fname)
{
    bcf_sweep_t *sw = (bcf_sweep_t*) calloc(1,sizeof(bcf_sweep_t));
    sw->file = hts_open(fname, "r");
    sw->fp   = hts_get_bgzfp(sw->file);
    if (sw->fp) bgzf_index_build_init(sw->fp);
    sw->hdr  = bcf_hdr_read(sw->file);
    sw->mrec = 1;
    sw->rec  = (bcf1_t*) calloc(sw->mrec,(sizeof(bcf1_t)));
    sw->block_size = 1024*1024*3;
    sw->direction = SW_FWD;
    return sw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x4300
movq %rax, %rbx
leaq 0x82278(%rip), %rsi     # 0x87f7c
movq %r14, %rdi
callq 0x1ddaf
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x1f33c
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x5d2b
movq %rax, %rdi
callq 0x19063
movq %r14, %rdi
callq 0x92ca
movq %rax, 0x8(%rbx)
movl $0x1, 0x2c(%rbx)
pushq $0x1
popq %rdi
movl $0xd0, %esi
callq 0x4300
movq %rax, 0x20(%rbx)
movl $0x300000, 0x1c(%rbx)   # imm = 0x300000
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_destroy
void bcf_sweep_destroy(bcf_sweep_t *sw)
{
    int i;
    for (i=0; i<sw->mrec; i++) bcf_empty1(&sw->rec[i]);
    free(sw->idx);
    free(sw->rec);
    free(sw->lals);
    bcf_hdr_destroy(sw->hdr);
    hts_close(sw->file);
    free(sw);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x2c(%rbx), %rax
cmpq %rax, %r15
jge 0x5d90
movq 0x20(%rbx), %rdi
addq %r14, %rdi
callq 0x9cce
incq %r15
addq $0xd0, %r14
jmp 0x5d6f
movq 0x50(%rbx), %rdi
callq 0x45d0
movq 0x20(%rbx), %rdi
callq 0x45d0
movq 0x48(%rbx), %rdi
callq 0x45d0
movq 0x8(%rbx), %rdi
callq 0x9158
movq (%rbx), %rdi
callq 0x1ef85
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_fwd
bcf1_t *bcf_sweep_fwd(bcf_sweep_t *sw)
{
    if ( sw->direction==SW_BWD ) sw_seek(sw, SW_FWD);

    off_t pos = hts_utell(sw->file);

    bcf1_t *rec = &sw->rec[0];
    int ret = bcf_read1(sw->file, sw->hdr, rec);

    if ( ret!=0 )   // last record, get ready for sweeping backwards
    {
        sw->idx_done = 1;
        if (sw->fp) sw->fp->idx_build_otf = 0;
        sw_seek(sw, SW_BWD);
        return NULL;
    }

    if ( !sw->idx_done )
    {
        if ( !sw->nidx || pos - sw->idx[sw->nidx-1] > sw->block_size )
        {
            sw->nidx++;
            hts_expand(uint64_t, sw->nidx, sw->midx, sw->idx);
            sw->idx[sw->nidx-1] = pos;
        }
    }
    return rec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x18(%rdi)
jne 0x5de5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5ea7
movq (%rbx), %rdi
callq 0x1f507
movq %rax, %r15
movq 0x20(%rbx), %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x9fd2
testl %eax, %eax
je 0x5e31
movl $0x1, 0x64(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5e1b
andl $0x0, 0x58(%rax)
movl $0x1, 0x18(%rbx)
movl 0x5c(%rbx), %eax
movl %eax, 0x58(%rbx)
andl $0x0, 0x28(%rbx)
xorl %r14d, %r14d
jmp 0x5e9a
cmpl $0x0, 0x64(%rbx)
jne 0x5e9a
movslq 0x5c(%rbx), %rax
testq %rax, %rax
je 0x5e55
movq 0x50(%rbx), %rcx
movq %r15, %rdx
subq -0x8(%rcx,%rax,8), %rdx
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %rdx
jbe 0x5e9a
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rbx)
movslq 0x60(%rbx), %rsi
cmpl %esi, %eax
jl 0x5e8e
testl %eax, %eax
pushq $0x1
popq %rdi
cmovnsl %ecx, %edi
leaq 0x50(%rbx), %r9
leaq 0x7c214(%rip), %rax     # 0x8208a
movq %rax, (%rsp)
pushq $0x4
popq %rdx
pushq $0x8
popq %rcx
xorl %r8d, %r8d
callq 0x24acb
movl %eax, 0x60(%rbx)
movl 0x5c(%rbx), %ecx
movq 0x50(%rbx), %rax
movslq %ecx, %rcx
movq %r15, -0x8(%rax,%rcx,8)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/vcf_sweep.c
// Function: sw_seek
static void sw_seek(bcf_sweep_t *sw, int direction)
{
    sw->direction = direction;
    if ( direction==SW_FWD )
        hts_useek(sw->file, sw->idx[0], 0);
    else
    {
        sw->iidx = sw->nidx;
        sw->nrec = 0;
    }
}

// Assembly:
movl %esi, 0x18(%rdi)
testl %esi, %esi
je 0x5eb9
movl 0x5c(%rdi), %eax
movl %eax, 0x58(%rdi)
andl $0x0, 0x28(%rdi)
retq
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
xorl %edx, %edx
jmp 0x1f4ec
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/examples/gff3sort.c
// Function: main
int main(int argc, const char *argv[])
{
  GtNodeStream *gff3_in_stream, *sort_stream, *gff3_out_stream;
  GtGenomeNode *gn;
  GtError *err;
  int had_err;

  gt_lib_init();
  err = gt_error_new();

  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
  sort_stream = gt_sort_stream_new(gff3_in_stream);
  gff3_out_stream = gt_gff3_out_stream_new(sort_stream, NULL);

  while (!(had_err = gt_node_stream_next(gff3_out_stream, &gn, err)) && gn)
    gt_genome_node_delete(gn);

  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));

  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(sort_stream);
  gt_node_stream_delete(gff3_in_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x7ec8
callq 0x7bec
movq %rax, %rbx
decl %ebp
movq %r14, 0x8(%rsp)
leaq 0x8(%r14), %rsi
movl %ebp, %edi
callq 0x13e75
movq %rax, %r14
movq %rax, %rdi
callq 0x1d90c
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x14bc3
movq %rax, %r13
leaq 0x10(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1c386
movl %eax, %ebp
testl %eax, %eax
jne 0x7b73
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7b73
callq 0x1370f
jmp 0x7b4e
testl %ebp, %ebp
jne 0x7bb2
xorl %r12d, %r12d
testl %ebp, %ebp
setne %r12b
movq %r13, %rdi
callq 0x1c2df
movq %r15, %rdi
callq 0x1c2df
movq %r14, %rdi
callq 0x1c2df
movq %rbx, %rdi
callq 0x7e8d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9d417(%rip), %rax     # 0xa4fd0
movq (%rax), %r12
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x7d89
leaq 0x6642c(%rip), %rsi     # 0x6e004
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x7710
jmp 0x7b77
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_class
const GtNodeStreamClass* gt_sort_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSortStream),
                                   gt_sort_stream_free,
                                   gt_sort_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x346fb
cmpq $0x0, 0x890fe(%rip)     # 0xa6758
jne 0x1d679
leaq 0x24(%rip), %rsi        # 0x1d687
leaq 0x77(%rip), %rdx        # 0x1d6e1
pushq $0x30
popq %rdi
callq 0x1c19c
movq %rax, 0x890df(%rip)     # 0xa6758
callq 0x34742
movq 0x890d3(%rip), %rax     # 0xa6758
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_free
static void gt_sort_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  for (i = sort_stream->idx; i < gt_array_size(sort_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(sort_stream->nodes, i));
  }
  gt_array_delete(sort_stream->nodes);
  gt_node_stream_delete(sort_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1d64c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c5e5
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rbx), %rdi
callq 0x32dec
movq 0x20(%rbx), %rdi
cmpq %rax, %r14
jae 0x1d6cc
movq %r14, %rsi
callq 0x328f2
movq (%rax), %rdi
callq 0x1370f
incq %r14
jmp 0x1d6a5
callq 0x33601
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c2df
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_new
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true);
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  gt_assert(in_stream);
  sort_stream->in_stream = gt_node_stream_ref(in_stream);
  sort_stream->sorted = false;
  sort_stream->idx = 0;
  sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x1d64c
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x1c203
movq %rax, %rbx
callq 0x1d64c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c5e5
testq %r14, %r14
je 0x1d96a
movq %rax, %r15
movq %r14, %rdi
callq 0x1c298
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
andq $0x0, 0x18(%r15)
pushq $0x8
popq %rdi
callq 0x327e4
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8765f(%rip), %rax     # 0xa4fd0
movq (%rax), %rdi
leaq 0x506a9(%rip), %rsi     # 0x6e024
leaq 0x573ae(%rip), %rdx     # 0x74d30
leaq 0x573b1(%rip), %rcx     # 0x74d3a
leaq 0x573bd(%rip), %r8      # 0x74d4d
movl $0x80, %r9d
xorl %eax, %eax
callq 0x7710
callq 0x7270
nop