LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x6300(%rip), %rdi      # 0x94e8
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x320a
xorl %ecx, %ecx
cmpl $0x0, 0x18(%rax)
sete %cl
movl %ecx, 0x18(%rax)
je 0x320b
movl 0x14(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x3d4c
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 0x3eb9
movq 0x62ab(%rip), %rax      # 0x94e8
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x330e
movq 0x626f(%rip), %rdi      # 0x94c0
movq 0x38(%r15), %rsi
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
movl $0x1, %r8d
callq 0x2480
testq %rax, %rax
je 0x330e
movq %rax, %rbx
movq 0x6245(%rip), %rdi      # 0x94c0
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f0
movq 0x6232(%rip), %rdi      # 0x94c0
testq %rax, %rax
je 0x3306
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rsi
callq 0x21f0
movq 0x6216(%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 0x61f4(%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 0x61d3(%rip), %rdi      # 0x94c0
movq %rbx, %rsi
callq 0x2420
movq 0x61c4(%rip), %rdi      # 0x94c0
movq %r14, %rsi
callq 0x2230
jmp 0x330e
movq %rbx, %rsi
callq 0x2420
movq 0x61ab(%rip), %rdi      # 0x94c0
movq 0x61cc(%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_O1/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 0x61a6(%rip), %rsi      # 0x94e0
callq *0x6070(%rip)           # 0x93b0
movl 0x619a(%rip), %ecx      # 0x94e0
leal 0x1(%rcx), %eax
cmpl $0xa, %eax
ja 0x3373
testl %ecx, %ecx
js 0x335b
movl $0x1, %ebx
shll %cl, %ebx
jmp 0x3367
movq 0x6186(%rip), %rax      # 0x94e8
movl 0x24(%rax), %ebx
notl %ebx
movq 0x617a(%rip), %rax      # 0x94e8
cmpl %ebx, 0x24(%rax)
jne 0x3375
popq %rbx
retq
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x3389
cmpl $0x0, 0x18(%rax)
je 0x3389
callq 0x31e1
movq 0x6158(%rip), %rax      # 0x94e8
xorl 0x24(%rax), %ebx
movl %ebx, 0x24(%rax)
movslq 0x4(%rax), %rdx
btl %edx, %ebx
jb 0x33f2
xorl %ecx, %ecx
movl $0x8, %esi
btl %ecx, %ebx
jb 0x33b8
incl %ecx
addq $0x10, %rsi
cmpl $0x9, %ecx
jne 0x33a6
jmp 0x33f2
movss (%rax), %xmm0
movq 0x38(%rax), %rdi
shlq $0x4, %rdx
movss %xmm0, (%rdi,%rdx)
movq 0x40(%rax), %rax
movq %rax, 0x8(%rdi,%rdx)
movq 0x610f(%rip), %rax      # 0x94e8
movq 0x38(%rax), %rdx
movss -0x8(%rdx,%rsi), %xmm0
movss %xmm0, (%rax)
movq (%rdx,%rsi), %rdx
movq %rdx, 0x40(%rax)
movl %ecx, 0x4(%rax)
movq 0x60ef(%rip), %rsi      # 0x94e8
movq 0x28(%rsi), %rdi
testq %rdi, %rdi
je 0x341b
movq 0x30(%rdi), %rax
movl 0x24(%rax), %eax
testl %eax, 0x1c(%rdi)
jne 0x341b
movl 0x4(%rsi), %edx
movl $0x1, %ecx
callq 0x4162
movq 0x60c6(%rip), %rdi      # 0x94e8
callq 0x3d4c
popq %rbx
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/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 0x60b4(%rip), %rax      # 0x94e8
cmpq $0x0, 0x28(%rax)
je 0x347d
movq 0x617e(%rip), %rax      # 0x95c0
cmpq $0x0, 0x48(%rax)
je 0x347d
pushq %rax
leaq 0x608f(%rip), %rsi      # 0x94e0
callq *0x5f59(%rip)           # 0x93b0
movq 0x608a(%rip), %rcx      # 0x94e8
movq 0x28(%rcx), %rdi
cmpl $0x0, 0x6077(%rip)      # 0x94e0
jle 0x347e
movq 0x48(%rcx), %rsi
testq %rsi, %rsi
jne 0x34a4
movq 0x6145(%rip), %rsi      # 0x95c0
jmp 0x34a4
retq
movq 0x613b(%rip), %rax      # 0x95c0
cmpq %rax, %rcx
je 0x3498
movq %rax, %rsi
movq 0x48(%rax), %rax
cmpq %rcx, %rax
jne 0x348a
jmp 0x34a4
movq %rax, %rsi
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x3498
callq 0x4843
popq %rax
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq 0x6027(%rip), %r14      # 0x94e8
xorl %r15d, %r15d
leaq 0x5895(%rip), %r12      # 0x8d60
movq 0x10(%r15,%r12), %rsi
movq %rbx, %rdi
callq 0x2370
testl %eax, %eax
jne 0x34e4
leaq (%r12,%r15), %rax
movq %rax, 0x40(%r14)
addq $0x18, %r15
cmpq $0x48, %r15
jne 0x34cb
movq 0x5ff3(%rip), %rdi      # 0x94e8
callq 0x3d4c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/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 0x5fce(%rip), %rsi      # 0x94e0
callq *0x5e98(%rip)           # 0x93b0
cmpl $0x9, 0x5fc1(%rip)      # 0x94e0
ja 0x35c0
movq 0x5fbc(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x3540
cmpl $0x0, 0x18(%rax)
je 0x3540
callq 0x31e1
movslq 0x5f99(%rip), %rax      # 0x94e0
movq 0x5f9a(%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 0x5f75(%rip), %rdi      # 0x94e8
movq 0x38(%rdi), %rcx
shlq $0x4, %rax
movss (%rcx,%rax), %xmm0
movss %xmm0, (%rdi)
movq 0x8(%rcx,%rax), %rax
movq %rax, 0x40(%rdi)
movl 0x5f4d(%rip), %ecx      # 0x94e0
movl $0x1, %eax
shll %cl, %eax
movl $0x1, %ebx
movl %eax, 0x24(%rdi)
movl %ecx, 0x4(%rdi)
callq 0x4a15
movq 0x5f37(%rip), %rcx      # 0x94e8
testq %rax, %rax
je 0x35c2
movb 0x4(%rcx), %cl
shll %cl, %ebx
xorl %ebx, 0x20(%rax)
jmp 0x35ef
popq %rbx
retq
movq 0x30(%rcx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x35e8
movq 0x30(%rcx), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rcx)
je 0x35df
cmpl $0x0, 0x10(%rcx)
je 0x35e5
movq 0x28(%rcx), %rcx
jmp 0x35c8
movq %rcx, %rax
movq %rcx, 0x5ee1(%rip)      # 0x94d0
movq 0x5ef2(%rip), %rsi      # 0x94e8
movl 0x4(%rsi), %edx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x4162
movq 0x5ede(%rip), %rdi      # 0x94e8
callq 0x3d4c
popq %rbx
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/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 0x5ecc(%rip), %rax      # 0x94e8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x365d
movq 0x30(%rax), %rdx
addq $0x30, %rdx
movq %rdx, %rcx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x3641
leaq 0x28(%rsi), %rdx
cmpq %rax, %rsi
jne 0x362d
movq 0x28(%rax), %rdx
movq %rdx, (%rcx)
movq 0x30(%rax), %rdi
movq 0x30(%rdi), %rcx
movq %rcx, 0x28(%rax)
movq %rax, 0x30(%rdi)
jmp 0x3d4c
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3eb8
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, 0x56b0(%rip)      # 0x94d0
testq %rax, %rax
je 0x3e84
movq %rsp, %r14
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x3e6d
movq 0x30(%rax), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rax)
je 0x3e6d
movl 0x10(%rax), %edx
cmpl 0x10(%rcx), %edx
jne 0x3e6d
movq 0x5674(%rip), %rdi      # 0x94c0
movq 0x38(%rax), %rsi
movl $0x60, %edx
movq %r14, %rcx
callq 0x20a0
movq 0x566c(%rip), %rax      # 0x94d0
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x565c(%rip), %rax      # 0x94d0
movq 0x28(%rax), %rax
movq %rax, 0x5651(%rip)      # 0x94d0
testq %rax, %rax
jne 0x3e28
movq 0x5635(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
leaq 0x5657(%rip), %rbx      # 0x94f0
movq 0x5620(%rip), %rdi      # 0x94c0
movl $0x10, %esi
movq %rbx, %rdx
callq 0x22c0
testl %eax, %eax
jne 0x3e99
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x55db(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rsi
movl $0xf, %edx
movq %rax, %rcx
callq 0x20a0
movq 0x55c3(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq %rbx, %rdi
callq 0x3f12
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4195
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
xorl %eax, 0x20(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x429d
movq 0x30(%rbx), %rdi
movq %rdi, 0x5330(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x41e2
movl $0x1, %r12d
movl %r15d, %ecx
shll %cl, %r12d
cmpq %r14, %rdi
je 0x41cb
movl 0x20(%rdi), %eax
testl %r12d, %eax
je 0x41cb
xorl %r12d, %eax
movl %eax, 0x20(%rdi)
xorl %esi, %esi
callq 0x429d
movq 0x52fe(%rip), %rax      # 0x94d0
movq 0x28(%rax), %rdi
movq %rdi, 0x52f3(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x41b1
testq %r14, %r14
sete %al
movq %r14, 0x28(%rbx)
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x427f
movq 0x28(%r14), %rax
xorl %edi, %edi
testq %rax, %rax
je 0x421f
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x4216
cmpl $0x0, 0x10(%rax)
je 0x421c
movq 0x28(%rax), %rax
jmp 0x41ff
movq %rax, %rdi
movq %rax, 0x52aa(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x4272
movq 0x30(%r14), %rax
movq 0x30(%rax), %rdx
xorl %edi, %edi
xorl %r8d, %r8d
movq %rdx, %rax
testq %rdx, %rdx
je 0x426b
cmpq %r14, %rax
je 0x426b
movq %r8, %rcx
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rsi
movl 0x24(%rsi), %esi
andl 0x1c(%rax), %esi
movq %rax, %r8
cmoveq %rcx, %r8
cmpq %r14, %rdx
jne 0x4238
testl %esi, %esi
cmovneq %rax, %rcx
movq %rcx, %rdi
movq %rax, 0x525e(%rip)      # 0x94d0
movl 0x4(%rbx), %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x4162
testq %r14, %r14
je 0x4294
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4380
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5209(%rip), %rdi      # 0x94c0
movq 0x38(%rbx), %rcx
xorl %r14d, %r14d
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
testl %ebp, %ebp
jne 0x42ff
movq 0x51eb(%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
xorl %r14d, %r14d
leaq 0x1d17(%rip), %r12      # 0x6020
xorps %xmm0, %xmm0
leaq (%r14,%r14,2), %rax
leaq 0x4a19(%rip), %rcx      # 0x8d30
movl (%rcx,%rax,8), %r13d
movl 0x4(%rcx,%rax,8), %ebp
xorl %r15d, %r15d
movq 0x5197(%rip), %rdi      # 0x94c0
movl (%r15,%r12), %edx
orl %r13d, %edx
movq 0x38(%rbx), %rcx
movups %xmm0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
movl %ebp, %esi
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x23e0
xorps %xmm0, %xmm0
addq $0x4, %r15
cmpq $0x4, %r15
je 0x4322
leaq 0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
je 0x430c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x43c1
pushq %rax
movq 0x28(%rdi), %rax
leaq 0x38(%rax), %rcx
testq %rax, %rax
movq 0x5128(%rip), %rdi      # 0x94c0
leaq 0x5211(%rip), %rax      # 0x95b0
cmovneq %rcx, %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2310
movq 0x5107(%rip), %rdi      # 0x94c0
xorl %esi, %esi
popq %rax
jmp 0x2330
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4db1(%rip), %rcx      # 0x95c0
xorl %eax, %eax
testq %rcx, %rcx
je 0x483b
movl 0x8(%rcx), %edx
cmpl %edi, %edx
jg 0x4832
addl 0x14(%rcx), %edx
cmpl %edi, %edx
jl 0x4832
movl 0xc(%rcx), %edx
cmpl %esi, %edx
jg 0x4832
addl 0x10(%rcx), %edx
cmpl %esi, %edx
jge 0x4838
movq 0x48(%rcx), %rcx
jmp 0x4811
movq %rcx, %rax
movq %rcx, 0x4c96(%rip)      # 0x94d8
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4856
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x485e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4943
movq %r14, 0x30(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x1c(%rbx)
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x498a
movl $0x0, 0x20(%rbx)
movq 0x30(%rbx), %rsi
movl 0x4(%rsi), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4162
cmpl $0x0, 0x10(%rbx)
je 0x48b1
movq %rbx, %rdi
callq 0x49d4
movq 0x4c30(%rip), %rdi      # 0x94e8
callq 0x4a15
movq 0x4c24(%rip), %rcx      # 0x94e8
movq %rax, 0x28(%rcx)
movq 0x4cf1(%rip), %rdi      # 0x95c0
movq %rdi, 0x4c02(%rip)      # 0x94d8
testq %rdi, %rdi
je 0x48ed
callq 0x3d4c
movq 0x4bf1(%rip), %rax      # 0x94d8
movq 0x48(%rax), %rdi
jmp 0x48cf
movq 0x30(%rbx), %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x48ff
// File: /workspace/github_c_makefile_star2_O1/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 0x4bda(%rip), %rax      # 0x94e8
testq %rax, %rax
je 0x4923
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4923
xorl %esi, %esi
callq 0x429d
movq %rbx, 0x4bbe(%rip)      # 0x94e8
testl %ebp, %ebp
je 0x493c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4380
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
testl %esi, %esi
jne 0x4965
movq 0x30(%rbx), %rsi
cmpq %rbx, 0x28(%rsi)
jne 0x4965
movl 0x4(%rsi), %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x4162
movq 0x30(%rbx), %rcx
addq $0x30, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x4981
leaq 0x28(%rdx), %rcx
cmpq %rbx, %rdx
jne 0x496d
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
je 0x49c0
movq 0x30(%rdi), %rax
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x49c0
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x49ae
movq 0x28(%rax), %rcx
addq $0x28, %rax
jmp 0x49cc
movq %rcx, %rax
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x49ae
addq $0x28, %rax
jmp 0x49d0
movq 0x30(%rdi), %rax
movq 0x30(%rax), %rcx
addq $0x30, %rax
movq %rcx, 0x28(%rdi)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/gitluin[P]sara/src/sara.c
// Function: adjustcoords
void
adjustcoords(client* c){
	monitor* m;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq 0x4808
testq %rax, %rax
je 0x4a13
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x4a13
movl 0x8(%rax), %edx
movl 0x8(%rcx), %esi
movl %edx, %edi
negl %edi
cmpl %esi, %edx
cmovll %esi, %edi
addl %edi, (%rbx)
movl 0xc(%rax), %eax
movl 0xc(%rcx), %ecx
movl %eax, %edx
negl %edx
cmpl %ecx, %eax
cmovll %ecx, %edx
addl %edx, 0x4(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4a40
movq 0x30(%rcx), %rdx
movl 0x24(%rdx), %edx
testl %edx, 0x1c(%rcx)
je 0x4a37
movl 0x20(%rcx), %edx
movl 0x4(%rdi), %esi
btl %esi, %edx
jb 0x4a3d
movq 0x28(%rcx), %rcx
jmp 0x4a1b
movq %rcx, %rax
movq %rcx, 0x4a89(%rip)      # 0x94d0
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4c81
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl $0x0, 0x10(%rax)
jne 0x4c76
movq 0x30(%rax), %rcx
movl 0x24(%rcx), %ecx
testl %ecx, 0x1c(%rax)
je 0x4c76
testq %r12, %r12
cmoveq %rax, %r12
incl %r13d
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x4c5a
jmp 0x4c87
xorl %r13d, %r13d
xorl %r12d, %r12d
addl $0xa, %ebp
addl $0x14, %r15d
addl $-0xa, %ebx
movq %rax, 0x4838(%rip)      # 0x94d0
testq %r12, %r12
setne %al
cmpl $0x1, %r13d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4ce0
cmpl $0x0, 0x18(%r12)
jne 0x4dcc
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 0x3eb9
testq %r12, %r12
je 0x4dcc
cmpl $0x0, 0x18(%r12)
jne 0x4d15
movss (%r14), %xmm0
addss 0x132a(%rip), %xmm0     # 0x6028
cvttss2si %xmm0, %ecx
movl %ebx, %r8d
subl %r15d, %r8d
movq %r12, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x3eb9
movq 0x28(%r12), %rdi
movq %rdi, 0x47af(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x4dcc
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 0x4db1
cmpl $0x0, 0x10(%rdi)
jne 0x4db1
cmpl $0x0, 0x18(%rdi)
jne 0x4db1
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 0x12a5(%rip), %xmm1     # 0x602c
cvttss2si %xmm1, %ecx
movl %r15d, %edx
movl %eax, %r8d
callq 0x3eb9
leal (%r12,%r15), %eax
addl $0xa, %r12d
cmpl %ebx, %eax
movl $0x0, %eax
cmovgel %eax, %r12d
addl %r15d, %r12d
incl %ebp
movl %r12d, %r15d
movq 0x4718(%rip), %rax      # 0x94d0
movq 0x28(%rax), %rdi
movq %rdi, 0x470d(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x4d39
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x46d5(%rip)      # 0x94d0
testq %rdi, %rdi
je 0x4e50
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 0x4e39
cmpl $0x0, 0x10(%rdi)
jne 0x4e39
cmpl $0x0, 0x18(%rdi)
jne 0x4e39
movl 0x14(%rbx), %ecx
addl $-0x14, %ecx
movl %ebp, %esi
movl %r15d, %edx
movl %r14d, %r8d
callq 0x3eb9
movq 0x4690(%rip), %rax      # 0x94d0
movq 0x28(%rax), %rdi
movq %rdi, 0x4685(%rip)      # 0x94d0
testq %rdi, %rdi
jne 0x4e0e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x475e(%rip), %rcx      # 0x95c0
testq %rcx, %rcx
je 0x4e98
movq 0x30(%rcx), %rax
testq %rax, %rax
je 0x4e7c
cmpq %rdi, 0x38(%rax)
je 0x4e89
movq 0x28(%rax), %rax
jmp 0x4e6b
movq %rax, 0x464d(%rip)      # 0x94d0
movq 0x48(%rcx), %rcx
jmp 0x4e62
movq %rcx, 0x4648(%rip)      # 0x94d8
movq %rax, 0x4639(%rip)      # 0x94d0
retq
movq %rcx, 0x4639(%rip)      # 0x94d8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x440b(%rip), %rax      # 0x94c0
movq %rax, 0x18(%r8)
movq 0x38(%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movl (%rdi), %edx
movl %edx, 0x30(%r8)
movl 0x4(%rdi), %edx
movl %edx, 0x34(%r8)
movl 0x8(%rdi), %edx
movl %edx, 0x38(%r8)
movl 0xc(%rdi), %edx
movl %edx, 0x3c(%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_O1/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 0x4943
testl %ebp, %ebp
jne 0x5186
movq 0x43a1(%rip), %rdi      # 0x94c0
callq 0x20b0
movq 0x4395(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2490
movq 0x437e(%rip), %rdi      # 0x94c0
movq 0x38(%r14), %rsi
movq 0x448b(%rip), %rcx      # 0x95d8
leaq 0x448c(%rip), %rax      # 0x95e0
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x2400
addq $0x10, %rsp
movq 0x434d(%rip), %rdi      # 0x94c0
xorl %esi, %esi
callq 0x2330
movq 0x433f(%rip), %rdi      # 0x94c0
callq 0x2240
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x3d4c
popq %rbx
popq %r14
popq %rbp
jmp 0x4a48
// File: /workspace/github_c_makefile_star2_O1/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 0xe36(%rip), %r13       # 0x407b
leaq 0x8(%rsp), %r14
xorl %r15d, %r15d
movl %r12d, %ecx
movl %ecx, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2200
movb $0x1, %cl
cmpl $0x67, %eax
je 0x3250
cmpl $-0x1, %eax
je 0x32ac
cmpl $0x72, %eax
jne 0x3352
movq 0x2d64(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0xdfb(%rip), %rsi       # 0x4081
movq %r14, %rdx
leaq 0xc(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x14(%rsp), %r9
xorl %eax, %eax
callq 0x2180
movb $0x1, %r15b
cmpl $0x4, %eax
je 0x324d
jmp 0x3360
movq 0x2d15(%rip), %rax      # 0x5fc8
movslq (%rax), %rax
subl %eax, %ebp
cmpl $0x2, %ebp
jne 0x3360
movl %r12d, %ecx
notb %cl
movl %r15d, %edx
notb %dl
orb %cl, %dl
testb $0x1, %dl
je 0x3360
movq (%rbx,%rax,8), %r14
movq 0x8(%rbx,%rax,8), %rbx
testb $0x1, %r15b
je 0x32f2
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x333e
testb $0x1, %r12b
je 0x3336
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23dc
testl %eax, %eax
jne 0x3343
leaq 0x8(%rsp), %r15
movl (%r15), %esi
movl 0x4(%r15), %edx
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
leaq 0xd69(%rip), %rdi       # 0x408d
xorl %eax, %eax
callq 0x20f0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
jmp 0x333e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2a28
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x56, %eax
jne 0x3360
leaq 0xefc(%rip), %rdi       # 0x425a
jmp 0x3367
leaq 0xd41(%rip), %rdi       # 0x40a8
callq 0x2150
xorl %edi, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xb, %edi
callq 0x1050
xorl %edi, %edi
callq 0x1040
movq %rax, 0x2eaa(%rip)      # 0x4058
movq %rax, 0x2e9b(%rip)      # 0x4050
movl $0x1, %edi
callq 0x1040
jmp 0x11bf
// File: /workspace/github_c_makefile_star2_O1/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 0xad61
movq %rax, 0x8(%rsp)
movq 0x30(%rbx), %rdi
callq 0xacc2
movq %rax, %rdi
callq 0x2e2d
movq %rax, %r15
leaq 0xa938(%rip), %rdi      # 0xd09e
callq 0x8198
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb196
movq %rax, %r12
leaq 0xa882(%rip), %rdi      # 0xd004
callq 0x8198
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb196
movq %rax, %r15
leaq 0xa868(%rip), %rax      # 0xd006
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xfb4b(%rip), %rbp      # 0x122f8
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2e, 0xc(%rdi)
leaq 0xc4ab(%rip), %r13      # 0xec74
movq %r13, 0x10(%rdi)
leaq 0xf94c(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca2e
leaq 0x100a8(%rip), %r14     # 0x12890
cmpl $0x0, (%r14)
je 0x282f
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xc1a0
testl %eax, %eax
je 0x282f
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x2f, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0xacc2
leaq 0xa7f0(%rip), %rdi      # 0xd015
movq %rax, %rsi
xorl %eax, %eax
callq 0xca9f
cmpl $0x0, (%r14)
movq 0x8(%rsp), %r14
je 0x2880
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0xc1a0
testl %eax, %eax
je 0x2880
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x30, 0xc(%rax)
movq %r14, %rsi
shrq $0x2, %rsi
movq %r12, %rdx
shrq $0x2, %rdx
leaq 0xa7a7(%rip), %rdi      # 0xd01d
movq %r15, %rcx
xorl %eax, %eax
callq 0xca9f
movq %r14, %rax
shrq $0x2, %rax
testl %eax, %eax
js 0x28b7
shrq $0x2, %r12
testl %r12d, %r12d
jg 0x28ac
testl %eax, %eax
je 0x28c5
movabsq $0x3fffffffc, %rax      # imm = 0x3FFFFFFFC
addq %rax, %r14
andq %rax, %r14
orq $0x3, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
jmp 0x28c0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3a33
leaq 0x10(%rsp), %rdi
movl $0x38, 0xc(%rdi)
callq 0xcbb3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa4d6(%rip), %rax      # 0xd03d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xf784(%rip), %rax      # 0x122f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x6e, 0xc(%rdi)
leaq 0xc0e5(%rip), %rcx      # 0xec74
movq %rcx, 0x10(%rdi)
leaq 0xf586(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca2e
movl $0xa, %edi
callq 0x327b
movq %rax, %rbx
leaq 0xa4e3(%rip), %rdi      # 0xd09e
callq 0x8198
movslq %ebp, %rcx
leaq 0x3(,%rcx,4), %rdx
leaq 0xf696(%rip), %rdi      # 0x12268
movq %rax, %rsi
callq 0xb208
leaq -0x2fc(%rip), %rsi      # 0x28e5
movq %rbx, %rdi
movq %rax, %rdx
callq 0x3956
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x3a33
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x407b
cmpl $0x0, 0x28(%rbx)
jle 0x2c21
incl %ebp
cmpl $0xf4240, %ebp          # imm = 0xF4240
jne 0x2bff
movl $0xf4240, %ebp          # imm = 0xF4240
leaq 0xa42b(%rip), %rdi      # 0xd053
movl %ebp, %esi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x4bf7
movq %rsp, %rdi
movl $0x7b, 0xc(%rdi)
callq 0xcbb3
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa3d5(%rip), %rax      # 0xd09b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xf625(%rip), %r12      # 0x122f8
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0xbf85(%rip), %rcx      # 0xec74
movq %rcx, 0x10(%rdi)
leaq 0xf426(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca2e
movq (%r12), %rax
movq 0x18(%rax), %rcx
movq 0xf2e2(%rip), %rdx      # 0x11ff8
testq %rcx, %rcx
jne 0x2d1e
movq (%rdx), %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 0xa35e(%rip), %r15      # 0xd0a0
movq 0xf28f(%rip), %r13      # 0x11fd8
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21b0
cmpl $0x23, %eax
jne 0x2d75
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9f, 0xc(%rax)
movq (%r13), %rdi
callq 0xc2fd
jmp 0x2d49
cmpl $0x6d, %eax
jle 0x2d8d
cmpl $0x6e, %eax
jne 0x2da3
movq (%r13), %rdi
callq 0x21d0
movl %eax, %r14d
jmp 0x2d49
cmpl $-0x1, %eax
je 0x2dcc
cmpl $0x3f, %eax
je 0x2da3
cmpl $0x56, %eax
jne 0x2da3
callq 0x2c89
jmp 0x2ded
movq 0xf24e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xa2b9(%rip), %rsi      # 0xd06d
leaq 0xf375(%rip), %rdx      # 0x12130
xorl %eax, %eax
callq 0x2160
movl $0x1, %edi
callq 0x21f0
callq 0x2c89
movl %r14d, %edi
callq 0x2b58
callq 0x2c4f
movq %rsp, %rdi
movl $0xaa, 0xc(%rdi)
callq 0xcbb3
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/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, %r12
addq %rdi, %r12
testl %edx, %edx
je 0x3e28
decq %r12
cmpq %r15, %r12
jb 0x3e5d
incl %r14d
leaq 0x225e(%rip), %r13      # 0x6050
movsbq (%r12), %rax
movsbl (%rax,%r13), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3e1b
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2190
decq %r12
incl %r14d
cmpq %r15, %r12
jae 0x3df2
jmp 0x3e5d
testl %esi, %esi
jle 0x3e5d
incl %r14d
movsbl (%r15), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3e52
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2190
incq %r15
incl %r14d
cmpq %r12, %r15
jb 0x3e2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x72f(%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 0x2ca5
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2cc4
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
xorl %ecx, %ecx
callq 0x2250
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2c86
leaq 0x20(%rsp), %r14
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2250
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2c6a
leaq 0x664(%rip), %rdi       # 0x32f1
leaq 0x5f0(%rip), %rsi       # 0x3284
leaq 0x5f8(%rip), %rcx       # 0x3293
movl $0x17, %edx
callq 0x2120
leaq 0x5d0(%rip), %rdi       # 0x327c
leaq 0x5d1(%rip), %rsi       # 0x3284
leaq 0x5d9(%rip), %rcx       # 0x3293
movl $0x12, %edx
callq 0x2120
leaq 0x5fb(%rip), %rdi       # 0x32c6
leaq 0x5b2(%rip), %rsi       # 0x3284
leaq 0x5ba(%rip), %rcx       # 0x3293
movl $0x13, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
callq 0x4300
movq %rax, %rbx
leaq 0xaa196(%rip), %rsi     # 0xb0296
movq %r14, %rdi
callq 0x288f3
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x29f39
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6127
movq %rax, %rdi
callq 0x22290
movq %r14, %rdi
callq 0xa3b7
movq %rax, 0x8(%rbx)
movl $0x1, 0x2c(%rbx)
movl $0x1, %edi
movl $0xd0, %esi
callq 0x4300
movq %rax, 0x20(%rbx)
movabsq $0x30000000000000, %rax # imm = 0x30000000000000
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x2c(%rdi)
jle 0x6199
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
addq %r14, %rdi
callq 0xb4d3
incq %r15
movslq 0x2c(%rbx), %rax
addq $0xd0, %r14
cmpq %rax, %r15
jl 0x617a
movq 0x50(%rbx), %rdi
callq 0x45d0
movq 0x20(%rbx), %rdi
callq 0x45d0
movq 0x48(%rbx), %rdi
callq 0x45d0
movq 0x8(%rbx), %rdi
callq 0xa21e
movq (%rbx), %rdi
callq 0x29b5d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O1/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 0x61fc
movl $0x0, 0x18(%rbx)
movq (%rbx), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x2a109
movq (%rbx), %rdi
callq 0x2a124
movq %rax, %r15
movq 0x20(%rbx), %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xb996
testl %eax, %eax
je 0x624e
movl $0x1, 0x64(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x6235
movl $0x0, 0x58(%rax)
movl $0x1, 0x18(%rbx)
movl 0x5c(%rbx), %eax
movl %eax, 0x58(%rbx)
movl $0x0, 0x28(%rbx)
xorl %r14d, %r14d
jmp 0x62bb
cmpl $0x0, 0x64(%rbx)
jne 0x62bb
movslq 0x5c(%rbx), %rax
testq %rax, %rax
je 0x6272
movq 0x50(%rbx), %rcx
movq %r15, %rdx
subq -0x8(%rcx,%rax,8), %rdx
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %rdx
jbe 0x62bb
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rbx)
movslq 0x60(%rbx), %rsi
cmpl %esi, %eax
jl 0x62ae
testl %eax, %eax
movl $0x1, %edi
cmovnsl %ecx, %edi
leaq 0x50(%rbx), %r9
leaq 0xa3df5(%rip), %rax     # 0xaa08a
movq %rax, (%rsp)
movl $0x4, %edx
movl $0x8, %ecx
xorl %r8d, %r8d
callq 0x308b8
movl %eax, 0x60(%rbx)
movq 0x50(%rbx), %rax
movslq 0x5c(%rbx), %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_O1/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 0x18ae8
callq 0x18928
movq %rax, %rbx
decl %ebp
movq %r14, 0x10(%rsp)
leaq 0x8(%r14), %rsi
movl %ebp, %edi
callq 0x225cb
movq %rax, %r15
movq %rax, %rdi
callq 0x29fa7
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0x22f50
movq %rax, %r13
leaq 0x8(%rsp), %rbp
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x29158
testl %eax, %eax
sete %r14b
movq (%rbp), %rdi
testq %rdi, %rdi
setne %al
andb %r14b, %al
cmpb $0x1, %al
jne 0x188dd
leaq 0x8(%rsp), %rbp
callq 0x220ee
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x29158
testl %eax, %eax
sete %r14b
jne 0x188dd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x188b8
testb %r14b, %r14b
je 0x18919
movq %r13, %rdi
callq 0x290de
movq %r12, %rdi
callq 0x290de
movq %r15, %rdi
callq 0x290de
movq %rbx, %rdi
callq 0x18aa9
xorb $0x1, %r14b
movzbl %r14b, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x7a20
jmp 0x188e2
// File: /workspace/github_c_makefile_star2_O1/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 0x438bf
cmpq $0x0, 0x8ca6e(%rip)     # 0xb6768
jne 0x29d1b
leaq 0x26(%rip), %rsi        # 0x29d29
leaq 0x81(%rip), %rdx        # 0x29d8b
movl $0x30, %edi
callq 0x29024
movq %rax, 0x8ca4d(%rip)     # 0xb6768
callq 0x438d5
movq 0x8ca41(%rip), %rax     # 0xb6768
popq %rcx
retq