LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/heredoc.c
// Function: qdoc
extern int qdoc(Node *name, Node *n) {
	Hq *new, **prev;
	if (name->type != nWord) {
		yyerror("eof-marker not a single literal word");
		skiptonl();
		return FALSE;
	}
	for (prev = &hq; (new = *prev) != NULL; prev = &new->n)
		;
	*prev = new = nnew(Hq);
	new->name = name->u[0].s;
	new->quoted = name->u[2].i;
	new->doc = n;
	new->n = NULL;
	return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1e, (%rdi)
jne 0x828e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x118cf(%rip), %rax     # 0x19b20
movq %rax, %r15
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x8251
movl $0x20, %edi
callq 0x9f28
movq %rax, (%r15)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl 0x18(%r14), %ecx
movl %ecx, 0x18(%rax)
movq %rbx, (%rax)
movq $0x0, 0x10(%rax)
movl $0x1, %eax
jmp 0x82a1
leaq 0x7544(%rip), %rdi      # 0xf7d9
callq 0x95dd
callq 0x8532
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: gchar
extern int gchar() {
	int c;

	if (istack->ungetcount)
		return lastchar = istack->ungetbuf[--istack->ungetcount];

	while ((c = (*istack->gchar)()) == '\0')
		pr_error("warning: null character ignored", 0);

	return c;
}

// Assembly:
pushq %rbx
movq 0x11844(%rip), %rax     # 0x19b30
movslq 0x14(%rax), %rcx
testq %rcx, %rcx
je 0x8308
leaq -0x1(%rcx), %rdx
movl %edx, 0x14(%rax)
movl 0x2c(%rax,%rcx,4), %eax
movl %eax, 0x11832(%rip)     # 0x19b38
jmp 0x8335
movq 0x11821(%rip), %rax     # 0x19b30
callq *0x38(%rax)
testl %eax, %eax
jne 0x8335
leaq 0x751b(%rip), %rbx      # 0xf838
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc7a4
movq 0x11802(%rip), %rax     # 0x19b30
callq *0x38(%rax)
testl %eax, %eax
je 0x831d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: pushfd
extern void pushfd(int fd) {
	pushcommon();
	save_lineno = TRUE;
	istack->fd = fd;
	lineno = 1;
	if (editing && interactive && isatty(fd)) {
		istack->t = iEdit;
		istack->gchar = editgchar;
		istack->cookie = edit_begin(fd);
	} else {
		istack->t = iFd;
		istack->gchar = fdgchar;
		inbuf = ealloc(BUFSIZE);
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x880a
movl $0x1, %eax
movl %eax, 0x10f89(%rip)     # 0x19320
movq 0x11792(%rip), %rcx     # 0x19b30
movl %ebx, 0x8(%rcx)
leaq 0x117f0(%rip), %rcx     # 0x19b98
movl %eax, (%rcx)
leaq 0x113c3(%rip), %rax     # 0x19774
cmpl $0x0, (%rax)
je 0x83fa
leaq 0x11817(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x83fa
movl %ebx, %edi
callq 0x3090
testl %eax, %eax
je 0x83fa
movq 0x1175c(%rip), %rax     # 0x19b30
movl $0x2, 0x4(%rax)
leaq 0x4d9(%rip), %rcx       # 0x88bb
movq %rcx, 0x38(%rax)
movl %ebx, %edi
callq 0x44dc
movq 0x1173c(%rip), %rcx     # 0x19b30
movq %rax, 0x28(%rcx)
jmp 0x8424
movq 0x1172f(%rip), %rax     # 0x19b30
movl $0x0, 0x4(%rax)
leaq 0x619(%rip), %rcx       # 0x8a28
movq %rcx, 0x38(%rax)
movl $0x100, %edi            # imm = 0x100
callq 0xa0c4
movq %rax, 0x1172c(%rip)     # 0x19b50
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: pushstring
extern void pushstring(char **a, bool save) {
	pushcommon();
	istack->t = iString;
	save_lineno = save;
	inbuf = mprint("%A", a);
	istack->gchar = stringgchar;
	if (save_lineno)
		lineno = 1;
	else
		--lineno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x880a
movq 0x116f5(%rip), %rax     # 0x19b30
movl $0x1, %ebp
movl %ebp, 0x4(%rax)
movl %ebx, 0x10ed7(%rip)     # 0x19320
leaq 0x6caa(%rip), %rdi      # 0xf0fa
movq %r14, %rsi
xorl %eax, %eax
callq 0xb181
movq %rax, 0x116ef(%rip)     # 0x19b50
movq 0x116c8(%rip), %rax     # 0x19b30
leaq 0x6ff(%rip), %rcx       # 0x8b6e
movq %rcx, 0x38(%rax)
leaq 0x1171e(%rip), %rax     # 0x19b98
movl (%rax), %ecx
decl %ecx
cmpl $0x0, 0x10e9b(%rip)     # 0x19320
cmovnel %ebp, %ecx
movl %ecx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: popinput
extern void popinput() {
	if (istack->t == iEdit)
		edit_end(istack->cookie);
	if (istack->t == iFd || istack->t == iEdit)
		close(istack->fd);
	efree(inbuf);
	--istack;
	lastchar = istack->last;
	inbuf = istack->ibuf;
	chars_out = istack->index;
	chars_in = istack->read;
	if (save_lineno)
		lineno = istack->lineno;
	else
		lineno++;
	save_lineno = istack->saved;
}

// Assembly:
pushq %rax
movq 0x11699(%rip), %rax     # 0x19b30
cmpl $0x2, 0x4(%rax)
jne 0x84a6
movq 0x28(%rax), %rdi
callq 0x455c
movq 0x11683(%rip), %rax     # 0x19b30
testl $0xfffffffd, 0x4(%rax)  # imm = 0xFFFFFFFD
jne 0x84be
movl 0x8(%rax), %edi
callq 0x3170
movq 0x1168b(%rip), %rdi     # 0x19b50
callq 0xa095
movq 0x1165f(%rip), %rcx     # 0x19b30
leaq -0x40(%rcx), %rax
movq %rax, 0x11654(%rip)     # 0x19b30
movl -0x24(%rcx), %edx
movl %edx, 0x11653(%rip)     # 0x19b38
movq -0x20(%rcx), %rdx
movq %rdx, 0x11660(%rip)     # 0x19b50
movslq -0x34(%rcx), %rdx
movq %rdx, 0x1165d(%rip)     # 0x19b58
movslq -0x30(%rcx), %rdx
movq %rdx, 0x1165a(%rip)     # 0x19b60
cmpl $0x0, 0x10e13(%rip)     # 0x19320
je 0x8514
movl -0x28(%rcx), %ecx
jmp 0x851f
leaq 0x1167d(%rip), %rcx     # 0x19b98
movl (%rcx), %ecx
incl %ecx
leaq 0x11672(%rip), %rdx     # 0x19b98
movl %ecx, (%rdx)
movl (%rax), %eax
movl %eax, 0x10df0(%rip)     # 0x19320
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: skiptonl
extern void skiptonl() {
	int c;
	if (lastchar == '\n' || lastchar == EOF)
		return;
	while ((c = gchar()) != '\n' && c != EOF)
		; /* skip to newline */
	if (c == EOF)
		ugchar(c);
}

// Assembly:
pushq %rax
movl 0x115ff(%rip), %eax     # 0x19b38
cmpl $-0x1, %eax
je 0x8543
cmpl $0xa, %eax
jne 0x8545
popq %rax
retq
callq 0x82e4
cmpl $0xa, %eax
je 0x8543
cmpl $-0x1, %eax
jne 0x8545
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
popq %rax
jmp 0x82a8
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: parseline
extern Node *parseline(char *extdef) {
	bool i = interactive;
	char *in[2];
	Node *fun;
	in[0] = extdef;
	in[1] = NULL;
	interactive = FALSE;
	pushstring(in, TRUE);
	fun = doit(FALSE);
	interactive = i;
	return fun;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x11483(%rip), %rbx     # 0x19bd4
movl (%rbx), %ebp
movq %rsp, %rax
movq %rdi, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, %rdi
movl $0x1, %esi
callq 0x8426
xorl %edi, %edi
callq 0x855f
movl %ebp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: closefds
extern void closefds() {
	Input *i;
	for (i = istack; i != itop; --i)	/* close open scripts */
		if (i->t == iFd && i->fd > 2) {
			close(i->fd);
			i->fd = -1;
		}
}

// Assembly:
pushq %rbx
movq 0x113a4(%rip), %rbx     # 0x19b30
cmpq 0x113b5(%rip), %rbx     # 0x19b48
je 0x87b5
cmpl $0x0, 0x4(%rbx)
jne 0x87af
movl 0x8(%rbx), %edi
cmpl $0x3, %edi
jl 0x87af
callq 0x3170
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $-0x40, %rbx
jmp 0x878c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: nextline
extern void nextline() {
	lineno++;
	if (interactive) {
		if (istack->t == iFd)
			fprint(2, "%s", prompt2);
		else if (istack->t == iEdit)
			edit_prompt(istack->cookie, prompt2);
	}
}

// Assembly:
leaq 0x113da(%rip), %rax     # 0x19b98
incl (%rax)
leaq 0x1140d(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x87f9
movq 0x1135d(%rip), %rax     # 0x19b30
movl 0x4(%rax), %ecx
cmpl $0x2, %ecx
je 0x87fa
testl %ecx, %ecx
jne 0x87f9
movq 0x11392(%rip), %rdx     # 0x19b78
leaq 0x6d95(%rip), %rsi      # 0xf582
movl $0x2, %edi
xorl %eax, %eax
jmp 0xb06f
retq
movq 0x28(%rax), %rdi
movq 0x11373(%rip), %rsi     # 0x19b78
jmp 0x451c
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: pushcommon
static void pushcommon() {
	size_t idiff;
	istack->index = chars_out;
	istack->read = chars_in;
	istack->ibuf = inbuf;
	istack->lineno = lineno;
	istack->saved = save_lineno;
	istack->last = lastchar;
	istack++;
	idiff = istack - itop;
	if (idiff >= istacksize / sizeof (Input)) {
		itop = erealloc(itop, istacksize *= 2);
		istack = itop + idiff;
	}
	chars_out = 0;
	chars_in = 0;
	istack->ungetcount = 0;
}

// Assembly:
pushq %rbx
movl 0x11347(%rip), %eax     # 0x19b58
movq 0x11318(%rip), %rbx     # 0x19b30
movl %eax, 0xc(%rbx)
movl 0x1133f(%rip), %eax     # 0x19b60
movl %eax, 0x10(%rbx)
movq 0x11325(%rip), %rax     # 0x19b50
movq %rax, 0x20(%rbx)
leaq 0x11362(%rip), %rax     # 0x19b98
movl (%rax), %eax
movl %eax, 0x18(%rbx)
movl 0x10adf(%rip), %eax     # 0x19320
movl %eax, (%rbx)
movl 0x112ef(%rip), %eax     # 0x19b38
movl %eax, 0x1c(%rbx)
addq $0x40, %rbx
movq %rbx, 0x112d9(%rip)     # 0x19b30
movq 0x112ea(%rip), %rdi     # 0x19b48
subq %rdi, %rbx
movq %rbx, %rax
sarq $0x6, %rax
movq 0x112d1(%rip), %rsi     # 0x19b40
movq %rsi, %rcx
shrq $0x6, %rcx
cmpq %rcx, %rax
jb 0x889b
addq %rsi, %rsi
movq %rsi, 0x112bb(%rip)     # 0x19b40
callq 0xa111
movq %rax, 0x112b7(%rip)     # 0x19b48
addq %rax, %rbx
movq %rbx, 0x11295(%rip)     # 0x19b30
xorl %eax, %eax
movq %rax, 0x112b4(%rip)     # 0x19b58
movq %rax, 0x112b5(%rip)     # 0x19b60
movq 0x1127e(%rip), %rax     # 0x19b30
movl $0x0, 0x14(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: editgchar
static int editgchar() {
	if (chars_out >= chars_in) { /* replenish empty buffer */
		edit_free(istack->cookie);
		inbuf = edit_alloc(istack->cookie, &chars_in);
		if (inbuf == NULL) {
			chars_in = 0;
			fprint(2, "exit\n");
			return lastchar = EOF;
		}

		chars_out = 0;
		if (dashvee)
			writeall(2, inbuf, chars_in);
		history();
	}

	return lastchar = inbuf[chars_out++];
}

// Assembly:
pushq %rax
movq 0x11295(%rip), %rax     # 0x19b58
cmpq 0x11296(%rip), %rax     # 0x19b60
jb 0x892f
movq 0x1125d(%rip), %rax     # 0x19b30
movq 0x28(%rax), %rdi
callq 0x453c
movq 0x1124d(%rip), %rax     # 0x19b30
movq 0x28(%rax), %rdi
leaq 0x11272(%rip), %rsi     # 0x19b60
callq 0x44fc
movq %rax, 0x11256(%rip)     # 0x19b50
testq %rax, %rax
je 0x8954
movq $0x0, 0x1124e(%rip) # 0x19b58
leaq 0x112db(%rip), %rcx     # 0x19bec
cmpl $0x0, (%rcx)
je 0x892a
movq 0x11243(%rip), %rdx     # 0x19b60
movl $0x2, %edi
movq %rax, %rsi
callq 0xc0f8
callq 0x8979
movq 0x1121a(%rip), %rax     # 0x19b50
movq 0x1121b(%rip), %rcx     # 0x19b58
leaq 0x1(%rcx), %rdx
movq %rdx, 0x11210(%rip)     # 0x19b58
movsbl (%rax,%rcx), %eax
movl %eax, 0x111e6(%rip)     # 0x19b38
popq %rcx
retq
movq $0x0, 0x11201(%rip) # 0x19b60
leaq 0x6ef6(%rip), %rsi      # 0xf85c
movl $0x2, %edi
xorl %eax, %eax
callq 0xb06f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x894c
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: history
static void history() {
	List *hist;
	size_t a;

	if (!interactive || (hist = varlookup("history")) == NULL)
		return;

	for (a = 0; a < chars_in; a++) {
		char c = inbuf[a];

		/* skip empty lines and comments */
		if (c == '#' || c == '\n')
			break;

		/* line matches [ \t]*[^#\n] so it's ok to write out */
		if (c != ' ' && c != '\t') {
			char *name = hist->w;
			int fd = rc_open(name, rAppend);
			if (fd < 0)
				uerror(name);
			else {
				writeall(fd, inbuf, chars_in);
				close(fd);
			}
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x11250(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x89d3
leaq 0x6ed2(%rip), %rdi      # 0xf862
callq 0xcaf4
testq %rax, %rax
je 0x89d3
movq 0x111bf(%rip), %rcx     # 0x19b60
testq %rcx, %rcx
je 0x89d3
movq 0x111a3(%rip), %rdx     # 0x19b50
xorl %esi, %esi
movzbl (%rdx,%rsi), %edi
cmpl $0x1f, %edi
jg 0x89bf
cmpl $0x9, %edi
je 0x89c4
jmp 0x89db
cmpl $0x20, %edi
jne 0x89ce
incq %rsi
cmpq %rsi, %rcx
jne 0x89af
jmp 0x89d3
cmpl $0x23, %edi
jne 0x89e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0xa, %edi
je 0x89d3
movq (%rax), %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0xa148
testl %eax, %eax
js 0x8a19
movl %eax, %ebx
movq 0x11153(%rip), %rsi     # 0x19b50
movq 0x1115c(%rip), %rdx     # 0x19b60
movl %eax, %edi
callq 0xc0f8
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3170
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc7ed
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/input.c
// Function: fdgchar
static int fdgchar() {
	if (chars_out >= chars_in) { /* replenish empty buffer */
		ssize_t r;
		do {
			r = rc_read(istack->fd, inbuf, BUFSIZE);
			sigchk();
			if (r == -1)
				switch (errno) {
				case EAGAIN:
					if (!makeblocking(istack->fd))
						panic("not O_NONBLOCK");
					errno = EINTR;
					break;
				case EIO:
					if (makesamepgrp(istack->fd))
						errno = EINTR;
					else
						errno = EIO;
					break;
				}
		} while (r < 0 && errno == EINTR);
		if (r < 0) {
			uerror("read");
			rc_raise(eError);
		}
		chars_in = (size_t) r;
		if (chars_in == 0)
			return lastchar = EOF;
		chars_out = 0;
		if (dashvee)
			writeall(2, inbuf, chars_in);
		history();
	}

	return lastchar = inbuf[chars_out++];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x11122(%rip), %rax     # 0x19b58
cmpq 0x11123(%rip), %rax     # 0x19b60
jb 0x8b39
leaq 0x6e20(%rip), %r14      # 0xf86a
movq 0x110df(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
movq 0x110f5(%rip), %rsi     # 0x19b50
movl $0x100, %edx            # imm = 0x100
callq 0x31c0
movq %rax, %rbx
callq 0xbae1
cmpq $-0x1, %rbx
jne 0x8ac6
callq 0x3040
movq %rax, %r15
movl (%rax), %eax
cmpl $0x5, %eax
je 0x8aa9
cmpl $0xb, %eax
jne 0x8ac6
movq 0x110a2(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
callq 0xa182
movl $0x4, %ebp
testl %eax, %eax
jne 0x8ac3
movq %r14, %rdi
callq 0xc83e
jmp 0x8ac3
movq 0x11080(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
callq 0xa1f4
cmpl $0x1, %eax
movl $0x0, %ebp
adcl $0x4, %ebp
movl %ebp, (%r15)
testq %rbx, %rbx
jns 0x8aec
callq 0x3040
cmpl $0x4, (%rax)
je 0x8a4a
leaq 0x6cb8(%rip), %rdi      # 0xf798
callq 0xc7ed
xorl %edi, %edi
callq 0x4654
movq %rbx, 0x1106d(%rip)     # 0x19b60
testq %rbx, %rbx
je 0x8b2a
movq $0x0, 0x11055(%rip) # 0x19b58
leaq 0x110e2(%rip), %rax     # 0x19bec
cmpl $0x0, (%rax)
je 0x8b23
movq 0x1103a(%rip), %rsi     # 0x19b50
movl $0x2, %edi
movq %rbx, %rdx
callq 0xc0f8
callq 0x8979
jmp 0x8b34
movl $0xffffffff, 0x11004(%rip) # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x8b67
movq 0x11010(%rip), %rax     # 0x19b50
movq 0x11011(%rip), %rcx     # 0x19b58
leaq 0x1(%rcx), %rdx
movq %rdx, 0x11006(%rip)     # 0x19b58
movsbl (%rax,%rcx), %eax
movl %eax, 0x10fdc(%rip)     # 0x19b38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8b5c
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/lex.c
// Function: getpair
static void getpair(int c) {
	int n;
	fd_left = fd_right = UNSET;
	if (c != '[') {
		ugchar(c);
		return;
	}
	if ((unsigned int) (n = gchar() - '0') > 9) {
		scanerror("expected digit after '['");
		return;
	}
	while ((unsigned int) (c = gchar() - '0') <= 9)
		n = n * 10 + c;
	fd_left = n;
	c += '0';
	switch (c) {
	default:
		scanerror("expected '=' or ']' after digit");
		return;
	case ']':
		return;
	case '=':
		if ((unsigned int) (n = gchar() - '0') > 9) {
			if (n != ']' - '0') {
				scanerror("expected digit or ']' after '='");
				return;
			}
			fd_right = CLOSED;
		} else {
			while ((unsigned int) (c = gchar() - '0') <= 9)
				n = n * 10 + c;
			if (c != ']' - '0') {
				scanerror("expected ']' after digit");
				return;
			}
			fd_right = n;
		}
	}
}

// Assembly:
movl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
movl %eax, 0x106ae(%rip)     # 0x19ba4
movl %eax, 0x106a4(%rip)     # 0x19ba0
cmpl $0x5b, %edi
jne 0x82a8
pushq %rbx
callq 0x82e4
movl %eax, %ebx
addl $-0x30, %ebx
cmpl $0x9, %ebx
jbe 0x9526
callq 0x8532
leaq 0x67db(%rip), %rdi      # 0xfcfc
jmp 0x95c8
callq 0x82e4
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x9546
leal (%rbx,%rbx,4), %eax
leal (%rcx,%rax,2), %ebx
callq 0x82e4
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x9533
movl %ebx, 0x10654(%rip)     # 0x19ba0
cmpl $0x3d, %eax
je 0x9568
cmpl $0x5d, %eax
je 0x95db
callq 0x8532
leaq 0x67af(%rip), %rdi      # 0xfd15
jmp 0x95c8
callq 0x82e4
movl %eax, %ebx
addl $-0x30, %ebx
cmpl $0x9, %ebx
jbe 0x958f
cmpl $0x2d, %ebx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x95b4
callq 0x8532
leaq 0x67a8(%rip), %rdi      # 0xfd35
jmp 0x95c8
callq 0x82e4
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x95af
leal (%rbx,%rbx,4), %ecx
leal (%rax,%rcx,2), %ebx
callq 0x82e4
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x959c
cmpl $0x2d, %eax
jne 0x95bc
movl %ebx, 0x105ea(%rip)     # 0x19ba4
jmp 0x95db
callq 0x8532
leaq 0x678d(%rip), %rdi      # 0xfd55
callq 0x95dd
movb $0x1, %al
movb %al, 0x105d3(%rip)      # 0x19ba8
movb %al, 0x105b5(%rip)      # 0x19b90
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/lex.c
// Function: yyerror
extern void yyerror(const char *s) {
	char *tok;
	if (prerror) { /* don't print "syntax error" if there's a more informative scanerror */
		prerror = FALSE;
		return;
	}
	if (!interactive) {
		if (w != NW)
			tok = realbuf;
		else if (lastchar == EOF)
			tok = "eof";
		else if (lastchar == '\n')
			tok = "end of line";
		else
			tok = nprint((lastchar < 32 || lastchar > 126) ? "(decimal %d)" : "'%c'", lastchar);
		fprint(2, "rc: line %d: %s near %s\n", lineno - (lastchar == '\n'), s, tok);
	} else
		fprint(2, "rc: %s\n", s);
}

// Assembly:
pushq %rbx
cmpb $0x1, 0x105c3(%rip)     # 0x19ba8
jne 0x95f0
movb $0x0, 0x105ba(%rip)     # 0x19ba8
popq %rbx
retq
movq %rdi, %rbx
leaq 0x105da(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x9616
leaq 0x66ee(%rip), %rsi      # 0xfcf4
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0xb06f
cmpl $0x0, 0x1057f(%rip)     # 0x19b9c
je 0x9654
movq 0x10562(%rip), %r8      # 0x19b88
movl 0x1056c(%rip), %edx     # 0x19b98
leaq 0x10505(%rip), %rax     # 0x19b38
xorl %ecx, %ecx
cmpl $0xa, (%rax)
sete %cl
subl %ecx, %edx
leaq 0x6697(%rip), %rsi      # 0xfcdb
movl $0x2, %edi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
jmp 0xb06f
leaq 0x104dd(%rip), %rax     # 0x19b38
movl (%rax), %esi
cmpl $-0x1, %esi
je 0x9670
cmpl $0xa, %esi
jne 0x9679
leaq 0x664f(%rip), %r8       # 0xfcbd
jmp 0x9626
leaq 0x6642(%rip), %r8       # 0xfcb9
jmp 0x9626
leal -0x7f(%rsi), %eax
cmpl $-0x5f, %eax
leaq 0x6643(%rip), %rax      # 0xfcc9
leaq 0x6649(%rip), %rdi      # 0xfcd6
cmovbq %rax, %rdi
xorl %eax, %eax
callq 0xb274
movq %rax, %r8
jmp 0x9626
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/lex.c
// Function: inityy
extern void inityy() {
	newline = FALSE;
	w = NW;
	hq = NULL;
	/* return memory to the system if the buffer got too large */
	if (bufsize > BUFMAX && realbuf != NULL) {
		efree(realbuf);
		bufsize = BUFSIZE;
		realbuf = ealloc(bufsize);
	} else if (realbuf == NULL)
		realbuf = ealloc(bufsize);
}

// Assembly:
pushq %rax
movb $0x0, 0x104ef(%rip)     # 0x19b94
movl $0x0, 0x104ed(%rip)     # 0x19b9c
leaq 0x1046a(%rip), %rax     # 0x19b20
movq $0x0, (%rax)
movq 0xfc7c(%rip), %rdi      # 0x19340
cmpq $0x1f41, %rdi           # imm = 0x1F41
setae %cl
movq 0x104b3(%rip), %rax     # 0x19b88
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x96fc
movq %rax, %rdi
callq 0xa095
movq $0x3e8, 0xfc4b(%rip) # imm = 0x3E8
movl $0x3e8, %edi            # imm = 0x3E8
jmp 0x9701
testq %rax, %rax
jne 0x970d
callq 0xa0c4
movq %rax, 0x1047b(%rip)     # 0x19b88
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/list.c
// Function: listfree
extern void listfree(List *p) {
	while (p != NULL) {
		List *n = p->n;
		efree(p->w);
		efree(p);
		p = n;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x973f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0xa095
movq %rbx, %rdi
callq 0xa095
movq %r14, %rbx
testq %r14, %r14
jne 0x971c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/list.c
// Function: listcpy
extern List *listcpy(List *s, void *(*alloc)(size_t)) {
	List *top, *r;
	for (top = r = NULL; s != NULL; s = s->n) {
		if (top == NULL)
			r = top = (*alloc)(sizeof (List));
		else
			r = r->n = (*alloc)(sizeof (List));
		r->w = (*alloc)(strlen(s->w) + 1);
		strcpy(r->w, s->w);
		r->m = NULL;
	}
	if (r != NULL)
		r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x97a9
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
movl $0x18, %edi
callq *%rbx
movq %rax, %r15
movq %rax, %r12
testq %rbp, %rbp
je 0x9774
movq %r15, 0x10(%r13)
movq %rbp, %r12
movq (%r14), %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq *%rbx
movq %rax, (%r15)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3070
movq $0x0, 0x8(%r15)
movq 0x10(%r14), %r14
movq %r15, %r13
movq %r12, %rbp
testq %r14, %r14
jne 0x975b
jmp 0x97af
xorl %r12d, %r12d
xorl %r15d, %r15d
testq %r15, %r15
je 0x97bc
movq $0x0, 0x10(%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/list.c
// Function: listlen
extern size_t listlen(List *s) {
	size_t size;
	for (size = 0; s != NULL; s = s->n)
		size += strlen(s->w) + 1;
	return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x97f5
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x30f0
addq %rax, %rbx
incq %rbx
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x97dc
jmp 0x97f7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/list.c
// Function: listnel
extern int listnel(List *s) {
	int nel;
	for (nel = 0; s != NULL; s = s->n)
		nel++;
	return nel;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x9811
incl %eax
movq 0x10(%rdi), %rdi
jmp 0x9804
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/main.c
// Function: assigndefault
static void assigndefault(char *name,...) {
	va_list ap;
	List *l;
	char *v;
	va_start(ap, name);
	for (l = NULL; (v = va_arg(ap, char *)) != NULL;)
		l = append(l, word(v, NULL));
	varassign(name, l, FALSE);
	set_exportable(name, FALSE);
	if (streq(name, "path"))
		alias(name, l, FALSE);
	va_end(ap);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x9cb9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
xorl %r14d, %r14d
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x9cf5
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x9d03
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9d22
xorl %esi, %esi
callq 0x6714
movq %r14, %rdi
movq %rax, %rsi
callq 0x6747
movq %rax, %r14
jmp 0x9cdc
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc918
movq %rbx, %rdi
xorl %esi, %esi
callq 0x79f2
cmpb $0x70, (%rbx)
jne 0x9d5e
leaq 0x5396(%rip), %rsi      # 0xf0db
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
jne 0x9d5e
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xcaaf
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/match.c
// Function: match
extern bool match(char *p, char *m, char *s) {
	struct { char *p, *m, *s; } next;
	if (m == NULL)
		return streq(p, s);
	next.s = NULL;
	while (*p || *s) {
		if (*p) {
			if (!*m) {
				/* ordinary character */
				if (*s == *p) {
					p++, m++, s++;
					continue;
				}
			} else switch (*p) {
			case '?':
				if (*s) {
					p++, m++, s++;
					continue;
				}
				break;
			case '[': {
				int r = 1 + rangematch(p+1, *s);
				if (r > 0) {
					p += r, m += r, s++;
					continue;
				}
				break;
			}
			case '*':
				next.p = p++;
				next.m = m++;
				next.s = *s ? s+1 : NULL;
				continue;
			default:
				panic("bad metacharacter in match");
				/* NOTREACHED */
				return FALSE; /* hush up gcc -Wall */
			}
		}
		if (next.s != NULL) {
			p = next.p;
			m = next.m;
			s = next.s;
			continue;
		}
		return FALSE;
	}
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9ef7
xorl %eax, %eax
xorl %r8d, %r8d
leaq 0x1(%rdx), %r11
xorl %r10d, %r10d
movzbl (%rdi,%r10), %ebx
testl %ebx, %ebx
jne 0x9da6
cmpb $0x0, (%rdx)
je 0x9f14
testl %ebx, %ebx
je 0x9ed5
leaq (%rsi,%r10), %r14
cmpb $0x0, (%r14)
je 0x9de3
cmpl $0x2a, %ebx
jne 0x9dcb
leaq (%rdi,%r10), %rcx
cmpb $0x0, (%rdx)
movq %r11, %r8
cmoveq %rax, %r8
incq %r10
movq %r14, %r9
jmp 0x9d8c
cmpl $0x5b, %ebx
je 0x9dfc
cmpl $0x3f, %ebx
jne 0x9ee9
cmpb $0x0, (%rdx)
jne 0x9deb
jmp 0x9ed5
cmpb %bl, (%rdx)
jne 0x9ed5
addq %r10, %rdi
incq %rdi
addq %r10, %rsi
incq %rsi
movq %r11, %rdx
jmp 0x9d85
leaq (%rdi,%r10), %r11
leaq (%rdi,%r10), %rbx
incq %rbx
xorl %r14d, %r14d
cmpb $0x7e, (%rbx)
sete %r14b
xorl %r15d, %r15d
movq %r11, (%rsp)
cmpb $0x5d, 0x1(%r14,%r11)
movb (%rdx), %bpl
sete %r15b
cmpb $0x5d, %bpl
sete %r12b
addq %r14, %rbx
addq %r15, %rbx
andb %r12b, %r15b
movzbl %r15b, %r15d
movzbl (%rbx), %r12d
cmpl $0x5d, %r12d
je 0x9e93
testl %r12d, %r12d
je 0x9e83
cmpb $0x2d, 0x1(%rbx)
jne 0x9e59
movb 0x2(%rbx), %r13b
cmpb $0x5d, %r13b
jne 0x9e62
cmpb %bpl, %r12b
sete %r12b
jmp 0x9e77
addq $0x2, %rbx
cmpb %bpl, %r12b
setle %r11b
cmpb %bpl, %r13b
setge %r12b
andb %r11b, %r12b
movzbl %r12b, %r11d
orl %r11d, %r15d
incq %rbx
jmp 0x9e3a
xorl %r12d, %r12d
cmpb $0x5b, %bpl
setne %r12b
negl %r12d
jmp 0x9ea6
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %r14d, %r15d
je 0x9ea6
subl %edi, %ebx
subl %r10d, %ebx
movl %ebx, %r12d
leal 0x1(%r12), %edi
xorl %r11d, %r11d
testl %r12d, %r12d
setns %r11b
cmovsq %rax, %rdi
movq (%rsp), %rbx
addq %rdi, %rbx
addq %r10, %rsi
addq %rdi, %rsi
addq %r11, %rdx
movq %rbx, %rdi
testl %r12d, %r12d
jns 0x9d85
movq %rcx, %rdi
movq %r9, %rsi
movq %r8, %rdx
testq %r8, %r8
jne 0x9d85
jmp 0x9f10
leaq 0x5f2f(%rip), %rdi      # 0xfe1f
callq 0xc83e
jmp 0x9f10
movb (%rdi), %al
cmpb (%rdx), %al
jne 0x9f10
movq %rdx, %rsi
callq 0x31f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x9f19
xorl %eax, %eax
jmp 0x9f19
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/nalloc.c
// Function: nalloc
extern void *nalloc(size_t n) {
	size_t base;
	Block *ulp;
	n = alignto(n, sizeof(align_t));
	ulp = ul;
	if (ulp != NULL && n + (base = ulp->used) < ulp->size) {
		ulp->used = base + n;
		return &ulp->mem[base];
	} else {
		getblock(n);
		assert(ul->used == 0);
		(ulp = ul)->used = n;
		return &ulp->mem[0];
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0xfcba(%rip), %rcx      # 0x19bf8
testq %rcx, %rcx
je 0x9f5c
movq (%rcx), %rax
leaq (%rax,%rbx), %rdx
cmpq 0x8(%rcx), %rdx
jae 0x9f5c
movq %rdx, (%rcx)
addq 0x10(%rcx), %rax
jmp 0x9fe4
movq 0xfc9d(%rip), %r14      # 0x19c00
testq %r14, %r14
je 0x9f82
cmpq %rbx, 0x8(%r14)
jae 0x9fac
movq %r14, %rax
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x9f82
cmpq %rbx, 0x8(%r14)
jb 0x9f6e
jmp 0x9fae
movl $0x20, %edi
callq 0xa0c4
movq %rax, %r14
leaq 0xfff(%rbx), %rdi
andq $-0x1000, %rdi          # imm = 0xF000
movq %rdi, 0x8(%rax)
callq 0xa0c4
movq %rax, 0x10(%r14)
jmp 0x9fc4
xorl %eax, %eax
movq 0x18(%r14), %rcx
testq %rax, %rax
je 0x9fbd
movq %rcx, 0x18(%rax)
jmp 0x9fc4
movq %rcx, 0xfc3c(%rip)      # 0x19c00
movq $0x0, (%r14)
movq 0xfc26(%rip), %rax      # 0x19bf8
movq %rax, 0x18(%r14)
movq %r14, 0xfc1b(%rip)      # 0x19bf8
movq %rbx, (%r14)
movq 0x10(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/nalloc.c
// Function: nfree
extern void nfree() {
	size_t count;
	Block *r;
	if (ul == NULL)
		return;
	for (r = ul; r->n != NULL; r = r->n)
		;	/* get to end of used list */
	r->n = fl;	/* tack free list onto it */
	fl = ul;	/* and make it the free list */
	ul = NULL;	/* finally, zero out the used list */
	for (r = fl, count = r->size; r->n != NULL; r = r->n, count += r->size) {
		if (count >= MAXMEM) {
			Block *tmp = r;
			r = r->n;
			tmp->n = NULL;		/* terminate the free list */
			while (r != NULL) {	/* free memory off the tail of the free list */
				tmp = r->n;
				efree(r->mem);
				efree(r);
				r = tmp;
			}
		return;
		}
	}
}

// Assembly:
movq 0xfc05(%rip), %rax      # 0x19bf8
testq %rax, %rax
je 0xa094
pushq %r14
pushq %rbx
pushq %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0xa003
movq 0xfbea(%rip), %rdx      # 0x19c00
movq %rdx, 0x18(%rcx)
movq %rax, 0xfbdf(%rip)      # 0x19c00
movq $0x0, 0xfbcc(%rip) # 0x19bf8
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0xa08d
movq 0x8(%rax), %rdx
cmpq $0x7a11f, %rdx          # imm = 0x7A11F
jbe 0xa047
movq %rcx, %rbx
jmp 0xa063
movq 0x18(%rcx), %rbx
testq %rbx, %rbx
je 0xa08d
addq 0x8(%rcx), %rdx
movq %rcx, %rax
movq %rbx, %rcx
cmpq $0x7a120, %rdx          # imm = 0x7A120
jb 0xa047
movq $0x0, 0x18(%rax)
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
testq %rdi, %rdi
je 0xa07d
callq 0x3030
movq %rbx, %rdi
callq 0x3030
movq %r14, %rbx
testq %r14, %r14
jne 0xa06b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/nalloc.c
// Function: ealloc
extern void *ealloc(size_t n) {
	void *p;

	assert(n);
	p = malloc(n);
	if (p == NULL) {
		uerror("malloc");
		rc_exit(1);
	}
	return p;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa0f2
callq 0x3270
movq %rax, %rbx
testq %rax, %rax
jne 0xa0ed
leaq 0x5d7a(%rip), %rdi      # 0xfe58
callq 0xc7ed
movl $0x1, %edi
callq 0x4fb5
movq %rbx, %rax
popq %rbx
retq
leaq 0x4fff(%rip), %rdi      # 0xf0f8
leaq 0x5d3a(%rip), %rsi      # 0xfe3a
leaq 0x5d3c(%rip), %rcx      # 0xfe43
movl $0x75, %edx
callq 0x3140
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/nalloc.c
// Function: erealloc
extern void *erealloc(void *p, size_t n) {
	if (p == NULL)		/* erealloc() has POSIX realloc() semantics */
		return ealloc(n);
	if ((p = realloc(p, n)) == NULL) {
		uerror("realloc");
		rc_exit(1);
	}
	return p;
}

// Assembly:
testq %rdi, %rdi
je 0xa13f
pushq %rbx
callq 0x32a0
movq %rax, %rbx
testq %rax, %rax
jne 0xa13a
leaq 0x5d34(%rip), %rdi      # 0xfe5f
callq 0xc7ed
movl $0x1, %edi
callq 0x4fb5
movq %rbx, %rax
popq %rbx
retq
movq %rsi, %rdi
jmp 0xa0c4
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/open.c
// Function: makeblocking
extern bool makeblocking(int fd) {
	int flags;

	if ((flags = fcntl(fd, F_GETFL)) == -1) {
		uerror("fcntl");
		rc_error(NULL);
	}
	if (! (flags & O_NONBLOCK))
		return FALSE;
	flags &= ~O_NONBLOCK;
	if (fcntl(fd, F_SETFL, (long) flags) == -1) {
		uerror("fcntl");
		rc_error(NULL);
	}
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
xorl %ebx, %ebx
movl $0x3, %esi
xorl %eax, %eax
callq 0x30b0
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa1b1
leaq 0x5cdd(%rip), %rdi      # 0xfe82
callq 0xc7ed
xorl %edi, %edi
callq 0x47be
btl $0xb, %r14d
jae 0xa1ed
andl $0xfffff7ff, %r14d      # imm = 0xFFFFF7FF
movslq %r14d, %rdx
movl %ebp, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x30b0
movl $0x1, %ebx
cmpl $-0x1, %eax
jne 0xa1ed
leaq 0x5ca1(%rip), %rdi      # 0xfe82
callq 0xc7ed
xorl %edi, %edi
callq 0x47be
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/open.c
// Function: makesamepgrp
extern bool makesamepgrp(int fd) {
	pid_t grp;

	grp = getpgrp();

	if (tcgetpgrp(fd) == grp)
		return FALSE;

	if (tcsetpgrp(fd, grp) < 0) {
		uerror("tcsetgrp");
		return FALSE;
	}
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x32d0
movl %eax, %ebp
movl %ebx, %edi
callq 0x3240
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
je 0xa231
movl %ebx, %edi
movl %ebp, %esi
callq 0x32e0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jns 0xa231
leaq 0x5c5e(%rip), %rdi      # 0xfe88
callq 0xc7ed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: fmtinstall
extern bool (*fmtinstall(int c, bool (*f)(Format *, int)))(Format *, int) {
/*Conv fmtinstall(int c, Conv f) {*/
	Conv oldf;
	if (fmttab[0] == NULL)
		inittab();
	c &= MAXCONV - 1;
	oldf = fmttab[c];
	if (f != NULL)
		fmttab[c] = f;
	return oldf;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0xef3c(%rip)      # 0x19c90
jne 0xad5b
callq 0xad7a
movzbl %bpl, %ecx
leaq 0xef2a(%rip), %rdx      # 0x19c90
movq (%rdx,%rcx,8), %rax
testq %rbx, %rbx
je 0xad73
movq %rbx, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: inittab
static void inittab(void) {
	int i;
	for (i = 0; i < MAXCONV; i++)
		fmttab[i] = badconv;

	fmttab['s'] = sconv;
	fmttab['c'] = cconv;
	fmttab['d'] = dconv;
	fmttab['o'] = oconv;
	fmttab['x'] = xconv;
	fmttab['%'] = pctconv;

	fmttab['u'] = uconv;
	fmttab['l'] = rc_lconv;
	fmttab['#'] = altconv;
	fmttab['-'] = leftconv;
	fmttab['.'] = dotconv;

#if HAVE_QUAD_T
	fmttab['q'] = qconv;
#endif

	fmttab['0'] = zeroconv;
	for (i = '1'; i <= '9'; i++)
		fmttab[i] = digitconv;
}

// Assembly:
xorl %ecx, %ecx
leaq 0xef0d(%rip), %rax      # 0x19c90
leaq 0x5d9(%rip), %rdx       # 0xb363
movq %rdx, (%rcx,%rax)
addq $0x8, %rcx
cmpq $0x800, %rcx            # imm = 0x800
jne 0xad8a
leaq 0x5d2(%rip), %rcx       # 0xb374
movq %rcx, 0xf27f(%rip)      # 0x1a028
leaq 0x6bf(%rip), %rcx       # 0xb46f
movq %rcx, 0xf1f1(%rip)      # 0x19fa8
leaq 0x700(%rip), %rcx       # 0xb4be
movq %rcx, 0xf1eb(%rip)      # 0x19fb0
leaq 0x708(%rip), %rcx       # 0xb4d4
movq %rcx, 0xf235(%rip)      # 0x1a008
leaq 0x710(%rip), %rcx       # 0xb4ea
movq %rcx, 0xf26f(%rip)      # 0x1a050
leaq 0x718(%rip), %rcx       # 0xb500
movq %rcx, 0xefc9(%rip)      # 0x19db8
leaq 0x736(%rip), %rcx       # 0xb52c
movq %rcx, 0xf23b(%rip)      # 0x1a038
leaq 0x732(%rip), %rcx       # 0xb536
movq %rcx, 0xf1e5(%rip)      # 0x19ff0
leaq 0x72e(%rip), %rcx       # 0xb540
movq %rcx, 0xef8f(%rip)      # 0x19da8
leaq 0x72a(%rip), %rcx       # 0xb54a
movq %rcx, 0xefd1(%rip)      # 0x19df8
leaq 0x726(%rip), %rcx       # 0xb554
movq %rcx, 0xefcb(%rip)      # 0x19e00
leaq 0x722(%rip), %rcx       # 0xb55e
movq %rcx, 0xefcd(%rip)      # 0x19e10
xorl %ecx, %ecx
leaq 0x75d(%rip), %rdx       # 0xb5a9
movq %rdx, 0x188(%rax,%rcx,8)
incq %rcx
cmpq $0x9, %rcx
jne 0xae4c
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: fmtappend
extern void fmtappend(Format *format, const char *s, size_t len) {
	while (format->buf + len > format->bufend) {
		size_t split = format->bufend - format->buf;
		memcpy(format->buf, s, split);
		format->buf += split;
		s += split;
		len -= split;
		(*format->grow)(format, len);
	}
	memcpy(format->buf, s, len);
	format->buf += len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq 0x40(%r14), %r12
leaq (%rdi,%rdx), %rax
cmpq %r12, %rax
jbe 0xaeb0
subq %rdi, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x3230
addq %r12, 0x30(%r14)
addq %r12, %r15
subq %r12, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x50(%r14)
movq 0x30(%r14), %rdi
movq 0x40(%r14), %r12
leaq (%rdi,%rbx), %rax
jmp 0xae7b
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3230
addq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: printfmt
extern int printfmt(Format *format, const char *fmt) {
	unsigned const char *s = (unsigned const char *) fmt;

	if (fmttab[0] == NULL)
		inittab();

	for (;;) {
		int c = *s++;
		switch (c) {
		case '%':
			format->flags = format->f1 = format->f2 = 0;
			do
				c = *s++;
			while ((*fmttab[c])(format, c));
			break;
		case '\0':
			return format->buf - format->bufbegin + format->flushed;
		default:
			fmtputc(format, c);
			break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xed85(%rip)      # 0x19c90
jne 0xaf12
callq 0xad7a
leaq 0x18(%r14), %r15
leaq 0xed73(%rip), %r12      # 0x19c90
movzbl (%rbx), %r13d
incq %rbx
testl %r13d, %r13d
je 0xaf51
cmpl $0x25, %r13d
jne 0xaf61
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movzbl (%rbx), %esi
incq %rbx
movq %r14, %rdi
callq *(%r12,%rsi,8)
testl %eax, %eax
jne 0xaf3e
jmp 0xaf86
movl 0x30(%r14), %ebp
subl 0x38(%r14), %ebp
addl 0x48(%r14), %ebp
xorl %eax, %eax
jmp 0xaf88
movq 0x30(%r14), %rax
cmpq 0x40(%r14), %rax
jb 0xaf77
movl $0x1, %esi
movq %r14, %rdi
callq *0x50(%r14)
movq 0x30(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%r14)
movb %r13b, (%rax)
movb $0x1, %al
testb %al, %al
jne 0xaf1d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: fmtprint
extern int fmtprint(Format *format, const char *fmt,...) {
	int n = -format->flushed;
	va_list ap, saveargs;

	va_start(ap, fmt);
	va_copy(saveargs, format->args);
	va_copy(format->args, ap);
	n += printfmt(format, fmt);
	va_end(format->args);
	va_copy(format->args, saveargs);

	return n + format->flushed;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xafff
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movl 0x48(%rbx), %ebp
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x30(%rsp)
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdi, 0x10(%rbx)
movq %rbx, %rdi
callq 0xaef2
subl %ebp, %eax
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rbx)
addl 0x48(%rbx), %eax
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: fprint
extern int fprint(int fd, const char *fmt,...) {
	char buf[1024];
	Format format;
	va_list ap;

	format.buf	= buf;
	format.bufbegin	= buf;
	format.bufend	= buf + sizeof buf;
	format.grow	= fprint_flush;
	format.flushed	= 0;
	format.u.n	= fd;

	va_start(ap, fmt);
	va_copy(format.args, ap);
	printfmt(&format, fmt);
	va_end(format.args);

	fprint_flush(&format, 0);
	return format.flushed;
}

// Assembly:
pushq %rbx
subq $0x530, %rsp            # imm = 0x530
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xb0c7
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x130(%rsp), %rax
leaq 0xd0(%rsp), %rbx
movq %rax, 0x30(%rbx)
movq %rax, 0x38(%rbx)
leaq 0x530(%rsp), %rax
movq %rax, 0x40(%rbx)
leaq 0x75(%rip), %rax        # 0xb167
movq %rax, 0x50(%rbx)
movl $0x0, 0x48(%rbx)
movl %edi, 0x58(%rbx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x540(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0xaef2
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
subq %rsi, %rdx
addl %edx, 0x48(%rbx)
movq %rsi, 0x30(%rbx)
movl 0x58(%rbx), %edi
callq 0xc0f8
movl 0x48(%rbx), %eax
addq $0x530, %rsp            # imm = 0x530
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: fprint_flush
static void fprint_flush(Format *format, size_t ignore) {
	size_t n = format->buf - format->bufbegin;
	char *buf = format->bufbegin;

	format->flushed += n;
	format->buf = format->bufbegin;
	writeall(format->u.n, buf, n);
}

// Assembly:
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rsi
subq %rsi, %rdx
addl %edx, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
movl 0x58(%rdi), %edi
jmp 0xc0f8
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: mprint
extern char *mprint(const char *fmt,...) {
	Format format;
	char *result;
	va_list ap;

	format.u.n = 1;
	va_start(ap, fmt);
	va_copy(format.args, ap);
	result = memprint(&format, fmt, ealloc(PRINT_ALLOCSIZE), PRINT_ALLOCSIZE);
	va_end(format.args);
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xb1e2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0xd0(%rsp), %r14
movl $0x1, 0x58(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, 0x10(%r14)
movq (%rsp), %rax
movq %rax, (%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movl $0x40, %edi
callq 0xa0c4
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
addq $0x3f, %rax
movq %rax, 0x40(%r14)
leaq 0x5d5(%rip), %rax       # 0xb81c
movq %rax, 0x50(%r14)
movl $0x0, 0x48(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaef2
movq 0x30(%r14), %rax
movb $0x0, (%rax)
movq 0x38(%r14), %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: nprint
extern char *nprint(const char *fmt,...) {
	Format format;
	char *result;
	va_list ap;

	format.u.n = 0;
	va_start(ap, fmt);
	va_copy(format.args, ap);
	result = memprint(&format, fmt, nalloc(PRINT_ALLOCSIZE), PRINT_ALLOCSIZE);
	va_end(format.args);
	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xb2d6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
xorl %ebp, %ebp
leaq 0xd0(%rsp), %r14
movl %ebp, 0x58(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, 0x10(%r14)
movq (%rsp), %rax
movq %rax, (%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movl $0x40, %edi
callq 0x9f28
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
addq $0x3f, %rax
movq %rax, 0x40(%r14)
leaq 0x4e3(%rip), %rax       # 0xb81c
movq %rax, 0x50(%r14)
movl %ebp, 0x48(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaef2
movq 0x30(%r14), %rax
movb $0x0, (%rax)
movq 0x38(%r14), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: sconv
static bool sconv(Format *format, int ignore) {
	char *s = va_arg(format->args, char *);
	if ((format->flags & FMT_f1set) == 0)
		fmtcat(format, s);
	else {
		size_t len = strlen(s), width = format->f1 - len;
		if (format->flags & FMT_leftside) {
			fmtappend(format, s, len);
			pad(format, width, ' ');
		} else {
			pad(format, width, ' ');
			fmtappend(format, s, len);
		}
	}
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0xb398
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0xb3a4
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r15
movq 0x18(%rbx), %r12
movq %r15, %rdi
testb %r12b, %r12b
js 0xb3c3
callq 0x30f0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
jmp 0xb418
callq 0x30f0
movq %rax, %r14
movq 0x20(%rbx), %r13
movq %r13, %rbp
subq %rax, %rbp
testb $0x20, %r12b
jne 0xb42e
testq %rbp, %rbp
je 0xb40f
movq %r14, %r12
subq %r13, %r12
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0xb3fb
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x20, (%rax)
incq %r12
jne 0xb3e6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xae5e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xae5e
testq %rbp, %rbp
je 0xb41d
subq %r13, %r14
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0xb459
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x20, (%rax)
incq %r14
jne 0xb444
jmp 0xb41d
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: zeroconv
static bool zeroconv(Format *format, int ignore) {
	if (format->flags & (FMT_f1set | FMT_f2set))
		return digitconv(format, '0');
	format->flags |= FMT_zeropad;
	return TRUE;
}

// Assembly:
movq 0x18(%rdi), %rax
testl $0x180, %eax            # imm = 0x180
je 0xb58a
btl $0x8, %eax
jb 0xb594
orq $0x80, %rax
movq %rax, 0x18(%rdi)
movq 0x20(%rdi), %rax
addq %rax, %rax
leaq (%rax,%rax,4), %rax
movq %rax, 0x20(%rdi)
jmp 0xb5a3
orq $0x10, %rax
movq %rax, 0x18(%rdi)
jmp 0xb5a3
movq 0x28(%rdi), %rax
addq %rax, %rax
leaq (%rax,%rax,4), %rax
movq %rax, 0x28(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: rc_utoa
static char *rc_utoa(unsigned long u, char *t, unsigned int radix, const char *digit) {
	if (u >= radix) {
		t = rc_utoa(u / radix, t, radix, digit);
		u %= radix;
	}
	*t++ = digit[u];
	return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %edx, %edi
cmpq %rbx, %rdi
ja 0xb808
movl %edx, %ecx
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %rbx
movq %rax, %rdi
movl %ecx, %edx
callq 0xb7e3
movq %rax, %rsi
leaq 0x83c3(%rip), %rax      # 0x13bd2
movb (%rbx,%rax), %al
movb %al, (%rsi)
incq %rsi
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/print.c
// Function: memprint_grow
static void memprint_grow(Format *format, size_t more) {
	char *buf;
	size_t len = format->bufend - format->bufbegin + 1;
	size_t used = format->buf - format->bufbegin;

	len = (len >= more)
		? len * 2
		: ((len + more) + PRINT_ALLOCSIZE) &~ (PRINT_ALLOCSIZE - 1);
	if (format->u.n)
		buf = erealloc(format->bufbegin, len);
	else {
		buf = nalloc(len);
		memcpy(buf, format->bufbegin, used);
	}
	format->buf = buf + used;
	format->bufbegin = buf;
	format->bufend = buf + len - 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %rdi
subq %rdi, %rax
leaq 0x1(%rax), %rcx
subq %rdi, %r14
leaq (%rax,%rsi), %rdx
incq %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
cmpq %rsi, %rcx
leaq 0x2(%rax,%rax), %r15
cmovbq %rdx, %r15
cmpl $0x0, 0x58(%rbx)
je 0xb86b
movq %r15, %rsi
callq 0xa111
movq %rax, %r12
jmp 0xb885
movq %r15, %rdi
callq 0x9f28
movq %rax, %r12
movq 0x38(%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x3230
addq %r12, %r14
movq %r14, 0x30(%rbx)
movq %r12, 0x38(%rbx)
leaq (%r12,%r15), %rax
decq %rax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/signal.c
// Function: sys_signal
void (*sys_signal(int signum, void (*handler)(int)))(int) {
	struct sigaction new, old;

	new.sa_handler = handler;
	new.sa_flags = 0; /* clear SA_RESTART */
	sigfillset(&new.sa_mask);
	if (sigaction(signum, &new, &old) == 0)
		return old.sa_handler;
	return SIG_DFL;
}

// Assembly:
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movl %edi, %ebx
leaq 0xa0(%rsp), %rdi
movq %rsi, -0x8(%rdi)
movl $0x0, 0x80(%rdi)
callq 0x3220
leaq 0x98(%rsp), %rsi
movq %rsp, %rdx
movl %ebx, %edi
callq 0x30a0
testl %eax, %eax
jne 0xbaad
movq (%rsp), %rax
jmp 0xbaaf
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
retq