LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x144b9(%rip), %rax     # 0x1fbe8
cmpq 0x144ba(%rip), %rax     # 0x1fbf0
jb 0xb7d9
movq 0x1447d(%rip), %rax     # 0x1fbc0
movq 0x28(%rax), %rdi
callq 0x4d10
movq 0x1446d(%rip), %rax     # 0x1fbc0
movq 0x28(%rax), %rdi
leaq 0x14492(%rip), %rsi     # 0x1fbf0
callq 0x4cb0
movq %rax, 0x14476(%rip)     # 0x1fbe0
cmpq $0x0, 0x1446e(%rip)     # 0x1fbe0
jne 0xb7a5
movq $0x0, 0x14471(%rip) # 0x1fbf0
movl $0x2, %edi
leaq 0xa1ed(%rip), %rsi      # 0x15978
movb $0x0, %al
callq 0xf3a0
movl $0xffffffff, 0x1442c(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb802
movq $0x0, 0x14438(%rip) # 0x1fbe8
leaq 0x144c5(%rip), %rax     # 0x1fc7c
cmpl $0x0, (%rax)
je 0xb7d4
movq 0x1441d(%rip), %rsi     # 0x1fbe0
movq 0x14426(%rip), %rdx     # 0x1fbf0
movl $0x2, %edi
callq 0x10dc0
callq 0xb810
movq 0x14400(%rip), %rax     # 0x1fbe0
movq 0x14401(%rip), %rcx     # 0x1fbe8
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x143f3(%rip)     # 0x1fbe8
movsbl (%rax,%rcx), %eax
movl %eax, 0x143c9(%rip)     # 0x1fbc8
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x14445(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0xb83a
leaq 0xa153(%rip), %rdi      # 0x1597e
callq 0x12110
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0xb83f
jmp 0xb8ef
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x1439e(%rip), %rax     # 0x1fbf0
jae 0xb8ef
movq 0x14381(%rip), %rax     # 0x1fbe0
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x23, %eax
je 0xb87b
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0xb87d
jmp 0xb8ef
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0xb8dc
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
je 0xb8dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0xd900
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xb8bc
movq -0x20(%rbp), %rdi
callq 0x11c10
jmp 0xb8da
movl -0x24(%rbp), %edi
movq 0x1431a(%rip), %rsi     # 0x1fbe0
movq 0x14323(%rip), %rdx     # 0x1fbf0
callq 0x10dc0
movl -0x24(%rbp), %edi
callq 0x3170
jmp 0xb8ef
jmp 0xb8de
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb847
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x142d9(%rip), %rax     # 0x1fbe8
cmpq 0x142da(%rip), %rax     # 0x1fbf0
jb 0xba5e
jmp 0xb91e
movq 0x1429b(%rip), %rax     # 0x1fbc0
movl 0x8(%rax), %edi
movq 0x142b1(%rip), %rsi     # 0x1fbe0
movl $0x100, %edx            # imm = 0x100
callq 0x31b0
movq %rax, -0x10(%rbp)
callq 0x104a0
cmpq $-0x1, -0x10(%rbp)
jne 0xb9c1
callq 0x3040
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x5, %eax
je 0xb991
jmp 0xb95a
movl -0x14(%rbp), %eax
subl $0xb, %eax
jne 0xb9bf
jmp 0xb964
movq 0x14255(%rip), %rax     # 0x1fbc0
movl 0x8(%rax), %edi
callq 0xd950
cmpl $0x0, %eax
jne 0xb984
leaq 0xa007(%rip), %rdi      # 0x15986
callq 0x11c80
callq 0x3040
movl $0x4, (%rax)
jmp 0xb9bf
movq 0x14228(%rip), %rax     # 0x1fbc0
movl 0x8(%rax), %edi
callq 0xd9f0
cmpl $0x0, %eax
je 0xb9b2
callq 0x3040
movl $0x4, (%rax)
jmp 0xb9bd
callq 0x3040
movl $0x5, (%rax)
jmp 0xb9bf
jmp 0xb9c1
jmp 0xb9c3
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x15(%rbp)
jge 0xb9dd
callq 0x3040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xb91e
cmpq $0x0, -0x10(%rbp)
jge 0xba02
leaq 0x9ebe(%rip), %rdi      # 0x158b4
callq 0x11c10
xorl %edi, %edi
callq 0x4ef0
movq -0x10(%rbp), %rax
movq %rax, 0x141e3(%rip)     # 0x1fbf0
cmpq $0x0, 0x141db(%rip)     # 0x1fbf0
jne 0xba2a
movl $0xffffffff, 0x141a7(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xba87
movq $0x0, 0x141b3(%rip) # 0x1fbe8
leaq 0x14240(%rip), %rax     # 0x1fc7c
cmpl $0x0, (%rax)
je 0xba59
movq 0x14198(%rip), %rsi     # 0x1fbe0
movq 0x141a1(%rip), %rdx     # 0x1fbf0
movl $0x2, %edi
callq 0x10dc0
callq 0xb810
movq 0x1417b(%rip), %rax     # 0x1fbe0
movq 0x1417c(%rip), %rcx     # 0x1fbe8
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x1416e(%rip)     # 0x1fbe8
movsbl (%rax,%rcx), %eax
movl %eax, 0x14144(%rip)     # 0x1fbc8
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/lex.c
// Function: quotep
extern bool quotep(char *s, bool dollar) {
	unsigned char c;
	const char *meta;

	meta = dollar ? dnw : q;
	while ((c = *s++))
		if (meta[c])
			return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq 0xa27b(%rip), %rax      # 0x15d80
leaq 0xa174(%rip), %rcx      # 0x15c80
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x15(%rbp)
cmpb $0x0, %al
je 0xbb48
movq -0x20(%rbp), %rax
movzbl -0x15(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0xbb46
movl $0x1, -0x4(%rbp)
jmp 0xbb4f
jmp 0xbb17
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xfffffff7, 0x135ef(%rip) # imm = 0xFFFFFFF7
movl $0xfffffff7, 0x135e1(%rip) # imm = 0xFFFFFFF7
cmpl $0x5b, -0x4(%rbp)
je 0xc662
movl -0x4(%rbp), %edi
callq 0xade0
jmp 0xc747
callq 0xae50
subl $0x30, %eax
movl %eax, -0x8(%rbp)
cmpl $0x9, %eax
jbe 0xc683
leaq 0x9893(%rip), %rdi      # 0x15f0c
callq 0xc5f0
jmp 0xc747
jmp 0xc685
callq 0xae50
subl $0x30, %eax
movl %eax, -0x4(%rbp)
cmpl $0x9, %eax
ja 0xc6a1
imull $0xa, -0x8(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xc685
movl -0x8(%rbp), %eax
movl %eax, 0x13586(%rip)     # 0x1fc30
movl -0x4(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x3d, %eax
je 0xc6da
jmp 0xc6c0
movl -0xc(%rbp), %eax
subl $0x5d, %eax
je 0xc6d8
jmp 0xc6ca
leaq 0x9854(%rip), %rdi      # 0x15f25
callq 0xc5f0
jmp 0xc747
jmp 0xc747
callq 0xae50
subl $0x30, %eax
movl %eax, -0x8(%rbp)
cmpl $0x9, %eax
jbe 0xc70a
cmpl $0x2d, -0x8(%rbp)
je 0xc6fe
leaq 0x984e(%rip), %rdi      # 0x15f45
callq 0xc5f0
jmp 0xc747
movl $0xffffffff, 0x1352c(%rip) # imm = 0xFFFFFFFF
jmp 0xc745
jmp 0xc70c
callq 0xae50
subl $0x30, %eax
movl %eax, -0x4(%rbp)
cmpl $0x9, %eax
ja 0xc728
imull $0xa, -0x8(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xc70c
cmpl $0x2d, -0x4(%rbp)
je 0xc73c
leaq 0x9830(%rip), %rdi      # 0x15f65
callq 0xc5f0
jmp 0xc747
movl -0x8(%rbp), %eax
movl %eax, 0x134ef(%rip)     # 0x1fc34
jmp 0xc747
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x134d5(%rip)     # 0x1fc38
je 0xc774
movl $0x0, 0x134c9(%rip)     # 0x1fc38
jmp 0xc86e
leaq 0x134e9(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
jne 0xc857
cmpl $0x0, 0x134a1(%rip)     # 0x1fc2c
je 0xc79d
movq 0x13484(%rip), %rax     # 0x1fc18
movq %rax, -0x10(%rbp)
jmp 0xc820
leaq 0x13424(%rip), %rax     # 0x1fbc8
cmpl $-0x1, (%rax)
jne 0xc7b6
leaq 0x9719(%rip), %rax      # 0x15ec9
movq %rax, -0x10(%rbp)
jmp 0xc81e
leaq 0x1340b(%rip), %rax     # 0x1fbc8
cmpl $0xa, (%rax)
jne 0xc7cf
leaq 0x9704(%rip), %rax      # 0x15ecd
movq %rax, -0x10(%rbp)
jmp 0xc81c
movb $0x1, %al
leaq 0x133f0(%rip), %rcx     # 0x1fbc8
cmpl $0x20, (%rcx)
movb %al, -0x11(%rbp)
jl 0xc7f0
leaq 0x133e1(%rip), %rax     # 0x1fbc8
cmpl $0x7e, (%rax)
setg %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
leaq 0x96ec(%rip), %rdi      # 0x15ee6
leaq 0x96d8(%rip), %rax      # 0x15ed9
testb $0x1, %cl
cmovneq %rax, %rdi
leaq 0x133b9(%rip), %rax     # 0x1fbc8
movl (%rax), %esi
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x10(%rbp)
jmp 0xc81e
jmp 0xc820
movl 0x13402(%rip), %edx     # 0x1fc28
leaq 0x1339b(%rip), %rax     # 0x1fbc8
cmpl $0xa, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
subl %eax, %edx
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x2, %edi
leaq 0x969d(%rip), %rsi      # 0x15eeb
movb $0x0, %al
callq 0xf3a0
jmp 0xc86e
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x969d(%rip), %rsi      # 0x15f04
movb $0x0, %al
callq 0xf3a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl $0x0, 0x13396(%rip)     # 0x1fc24
movl $0x0, 0x13394(%rip)     # 0x1fc2c
leaq 0x13311(%rip), %rax     # 0x1fbb0
movq $0x0, (%rax)
cmpq $0x1f40, 0x12aef(%rip) # imm = 0x1F40
jbe 0xc8e9
cmpq $0x0, 0x1335d(%rip)     # 0x1fc18
je 0xc8e9
movq 0x13354(%rip), %rdi     # 0x1fc18
callq 0xd7a0
movq $0x3e8, 0x12acc(%rip) # imm = 0x3E8
movq 0x12ac5(%rip), %rdi     # 0x1f3a0
callq 0xd820
movq %rax, 0x13331(%rip)     # 0x1fc18
jmp 0xc908
cmpq $0x0, 0x13327(%rip)     # 0x1fc18
jne 0xc906
movq 0x12aa6(%rip), %rdi     # 0x1f3a0
callq 0xd820
movq %rax, 0x13312(%rip)     # 0x1fc18
jmp 0xc908
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc94e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd7a0
movq -0x8(%rbp), %rdi
callq 0xd7a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc91c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xca13
cmpq $0x0, -0x18(%rbp)
jne 0xc9a4
movl $0x18, %edi
callq *-0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
jmp 0xc9b8
movl $0x18, %edi
callq *-0x10(%rbp)
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
movq %rax, %rdi
movq -0x28(%rbp), %rax
addq $0x1, %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3070
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc980
cmpq $0x0, -0x20(%rbp)
je 0xca26
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xca71
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xca44
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcaad
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xca8f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xcfc8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0xd056
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xd073
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xd0b7
movq -0x28(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8350
movq -0x100(%rbp), %rdi
movq %rax, %rsi
callq 0x83b0
movq %rax, -0x28(%rbp)
jmp 0xd01b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x11e60
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9f40
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x8050(%rip), %ecx      # 0x1512f
cmpl %ecx, %eax
jne 0xd107
movq -0x8(%rbp), %rdi
leaq 0x8041(%rip), %rsi      # 0x1512f
callq 0x31e0
cmpl $0x0, %eax
jne 0xd107
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x120b0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/match.c
// Function: rangematch
static int rangematch(char *p, char c) {
	char *orig = p;
	bool neg = (*p == '~');
	bool matched = FALSE;
	if (neg)
		p++;
	if (*p == ']') {
		p++;
		matched = (c == ']');
	}
	for (; *p != ']'; p++) {
		if (*p == '\0')
			return c == '[' ? 0 : -1;	/* no right-bracket */
		if (p[1] == '-' && p[2] != ']') { /* check for [..-..] but ignore [..-] */
			if (c >= *p)
				matched |= (c <= p[2]);
			p += 2;
		} else {
			matched |= (*p == c);
		}
	}
	if (matched ^ neg)
		return p - orig + 1; /* skip the right-bracket */
	else
		return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xd3a4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0xd3ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x5d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
jmp 0xd3d0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
je 0xd486
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd405
movsbl -0x11(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x5b, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xd4ac
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0xd458
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x5d, %eax
je 0xd458
movsbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jl 0xd44a
movsbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
orl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0xd473
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
orl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xd475
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd3d0
movl -0x28(%rbp), %eax
xorl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0xd4a5
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0xd4ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq 0x127a1(%rip), %rax     # 0x1fc88
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd52f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
addq %rcx, %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd52f
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd584
movq -0x10(%rbp), %rdi
callq 0xd590
movq 0x12749(%rip), %rax     # 0x1fc88
cmpq $0x0, (%rax)
jne 0xd547
jmp 0xd566
leaq 0x8b8c(%rip), %rdi      # 0x160da
leaq 0x8b93(%rip), %rsi      # 0x160e8
movl $0x36, %edx
leaq 0x8b90(%rip), %rcx      # 0x160f1
callq 0x3140
movq -0x10(%rbp), %rcx
movq 0x12717(%rip), %rax     # 0x1fc88
movq %rax, -0x20(%rbp)
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/nalloc.c
// Function: getblock
static void getblock(size_t n) {
	Block *r, *p;
	for (r = fl, p = NULL; r != NULL; p = r, r = r->n)
		if (n <= r->size)
			break;	/* look for a block which fits the request */
	if (r != NULL) {	/* if one is found, take it off the free list */	
		if (p != NULL)
			p->n = r->n;
		else
			fl = r->n;
	} else {		/* else allocate a new block */
		r = enew(Block);
		r->mem = ealloc(r->size = alignto(n, BLOCKSIZE));
	}
	r->used = 0;
	r->n = ul;
	ul = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x126ed(%rip), %rax     # 0x1fc90
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd5de
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0xd5c6
jmp 0xd5de
jmp 0xd5c8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd5af
cmpq $0x0, -0x10(%rbp)
je 0xd60f
cmpq $0x0, -0x18(%rbp)
je 0xd5fe
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xd60d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x12683(%rip)     # 0x1fc90
jmp 0xd64b
movl $0x20, %edi
callq 0xd820
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
subq $0x1, %rdi
andq $-0x1000, %rdi          # imm = 0xF000
movq -0x10(%rbp), %rax
movq %rdi, 0x8(%rax)
callq 0xd820
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x1262b(%rip), %rcx     # 0x1fc88
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x12618(%rip)     # 0x1fc88
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x125f8(%rip)     # 0x1fc88
jne 0xd697
jmp 0xd78d
movq 0x125ea(%rip), %rax     # 0x1fc88
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd6bd
jmp 0xd6af
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd6a2
movq 0x125cc(%rip), %rcx     # 0x1fc90
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x125b5(%rip), %rax     # 0x1fc88
movq %rax, 0x125b6(%rip)     # 0x1fc90
movq $0x0, 0x125a3(%rip) # 0x1fc88
movq 0x125a4(%rip), %rax     # 0x1fc90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd78d
cmpq $0x7a120, -0x8(%rbp)    # imm = 0x7A120
jb 0xd76a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xd768
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd7a0
movq -0x10(%rbp), %rdi
callq 0xd7a0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xd735
jmp 0xd78d
jmp 0xd76c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd6fc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd835
jmp 0xd854
leaq 0x7910(%rip), %rdi      # 0x1514c
leaq 0x88a5(%rip), %rsi      # 0x160e8
movl $0x75, %edx
leaq 0x88b7(%rip), %rcx      # 0x16106
callq 0x3140
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd87e
leaq 0x88ac(%rip), %rdi      # 0x1611b
callq 0x11c10
movl $0x1, %edi
callq 0x5c00
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd8b6
movq -0x18(%rbp), %rdi
callq 0xd820
movq %rax, -0x8(%rbp)
jmp 0xd8eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xd8e3
leaq 0x884e(%rip), %rdi      # 0x16122
callq 0x11c10
movl $0x1, %edi
callq 0x5c00
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x30b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0xd987
leaq 0x87cc(%rip), %rdi      # 0x16145
callq 0x11c10
xorl %eax, %eax
movl %eax, %edi
callq 0x50d0
movl -0xc(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xd99d
movl $0x0, -0x4(%rbp)
jmp 0xd9dc
movl -0xc(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movslq -0xc(%rbp), %rdx
movl $0x4, %esi
movb $0x0, %al
callq 0x30b0
cmpl $-0x1, %eax
jne 0xd9d5
leaq 0x877e(%rip), %rdi      # 0x16145
callq 0x11c10
xorl %eax, %eax
movl %eax, %edi
callq 0x50d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x32c0
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x3230
cmpl -0xc(%rbp), %eax
jne 0xda19
movl $0x0, -0x4(%rbp)
jmp 0xda45
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x32d0
cmpl $0x0, %eax
jge 0xda3e
leaq 0x871b(%rip), %rdi      # 0x1614b
callq 0x11c10
movl $0x0, -0x4(%rbp)
jmp 0xda45
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x10e09(%rip)     # 0x1fd20
jne 0xef1e
callq 0xef60
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x10dec(%rip), %rax     # 0x1fd20
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xef56
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x10dce(%rip), %rax     # 0x1fd20
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0xef95
movslq -0x4(%rbp), %rcx
leaq 0x10da1(%rip), %rax     # 0x1fd20
leaq 0x84a(%rip), %rdx       # 0xf7d0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xef6b
leaq 0x864(%rip), %rax       # 0xf800
movq %rax, 0x11115(%rip)     # 0x200b8
leaq 0x956(%rip), %rax       # 0xf900
movq %rax, 0x11087(%rip)     # 0x20038
leaq 0x9e8(%rip), %rax       # 0xf9a0
movq %rax, 0x11081(%rip)     # 0x20040
leaq 0xa0a(%rip), %rax       # 0xf9d0
movq %rax, 0x110cb(%rip)     # 0x20098
leaq 0xa2c(%rip), %rax       # 0xfa00
movq %rax, 0x11105(%rip)     # 0x200e0
leaq 0xa4e(%rip), %rax       # 0xfa30
movq %rax, 0x10e5f(%rip)     # 0x1fe48
leaq 0xaa0(%rip), %rax       # 0xfa90
movq %rax, 0x110d1(%rip)     # 0x200c8
leaq 0xac2(%rip), %rax       # 0xfac0
movq %rax, 0x1107b(%rip)     # 0x20080
leaq 0xae4(%rip), %rax       # 0xfaf0
movq %rax, 0x10e25(%rip)     # 0x1fe38
leaq 0xb06(%rip), %rax       # 0xfb20
movq %rax, 0x10e67(%rip)     # 0x1fe88
leaq 0xb28(%rip), %rax       # 0xfb50
movq %rax, 0x10e61(%rip)     # 0x1fe90
leaq 0xb4a(%rip), %rax       # 0xfb80
movq %rax, 0x10e63(%rip)     # 0x1fea0
movl $0x31, -0x4(%rbp)
cmpl $0x39, -0x4(%rbp)
jg 0xf06b
movslq -0x4(%rbp), %rcx
leaq 0x10ccb(%rip), %rax     # 0x1fd20
leaq 0xb84(%rip), %rdx       # 0xfbe0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xf044
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0xf108
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3220
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0xf084
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3220
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10b80(%rip)     # 0x1fd20
jne 0xf1a7
callq 0xef60
jmp 0xf1a9
movq -0x18(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0xf22b
jmp 0xf1c9
movl -0x20(%rbp), %eax
subl $0x25, %eax
jne 0xf24f
jmp 0xf1d3
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x10b09(%rip), %rax     # 0x1fd20
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq *%rax
cmpl $0x0, %eax
jne 0xf1f7
jmp 0xf28e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq 0x48(%rcx), %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0xf274
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
jmp 0xf1a9
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xf2de
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
negl %eax
movl %eax, -0x14(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf180
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x50(%rbp), %xmm0
movups %xmm0, (%rax)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x48(%rcx), %ecx
addl %ecx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
testb %al, %al
je 0xf3e7
movaps %xmm0, -0x510(%rbp)
movaps %xmm1, -0x500(%rbp)
movaps %xmm2, -0x4f0(%rbp)
movaps %xmm3, -0x4e0(%rbp)
movaps %xmm4, -0x4d0(%rbp)
movaps %xmm5, -0x4c0(%rbp)
movaps %xmm6, -0x4b0(%rbp)
movaps %xmm7, -0x4a0(%rbp)
movq %r9, -0x518(%rbp)
movq %r8, -0x520(%rbp)
movq %rcx, -0x528(%rbp)
movq %rdx, -0x530(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x440(%rbp)
movq %rax, -0x438(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x430(%rbp)
leaq 0x9f(%rip), %rax        # 0xf4d0
movq %rax, -0x420(%rbp)
movl $0x0, -0x428(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x418(%rbp)
leaq -0x540(%rbp), %rax
movq %rax, -0x480(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x488(%rbp)
movl $0x30, -0x48c(%rbp)
movl $0x10, -0x490(%rbp)
movq -0x480(%rbp), %rax
movq %rax, -0x460(%rbp)
movaps -0x490(%rbp), %xmm0
movaps %xmm0, -0x470(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdi
movq %rdi, -0x548(%rbp)
callq 0xf180
movq -0x548(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf4d0
movl -0x428(%rbp), %eax
addq $0x550, %rsp            # imm = 0x550
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x48(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10dc0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
testb %al, %al
je 0xf587
movaps %xmm0, -0x110(%rbp)
movaps %xmm1, -0x100(%rbp)
movaps %xmm2, -0xf0(%rbp)
movaps %xmm3, -0xe0(%rbp)
movaps %xmm4, -0xd0(%rbp)
movaps %xmm5, -0xc0(%rbp)
movaps %xmm6, -0xb0(%rbp)
movaps %xmm7, -0xa0(%rbp)
movq %r9, -0x118(%rbp)
movq %r8, -0x120(%rbp)
movq %rcx, -0x128(%rbp)
movq %rdx, -0x130(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, -0x18(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x30, -0x8c(%rbp)
movl $0x8, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
movaps -0x90(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x40, %edi
movq %rdi, -0x148(%rbp)
callq 0xd820
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rcx
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0xf640
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/print.c
// Function: memprint
static char *memprint(Format *format, const char *fmt, char *buf, size_t len) {
	format->buf	 = buf;
	format->bufbegin = buf;
	format->bufend	 = buf + len - 1;
	format->grow	 = memprint_grow;
	format->flushed	 = 0;
	printfmt(format, fmt);
	*format->buf = '\0';
	return format->bufbegin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x9d1(%rip), %rcx       # 0x10060
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf180
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
testb %al, %al
je 0xf717
movaps %xmm0, -0x110(%rbp)
movaps %xmm1, -0x100(%rbp)
movaps %xmm2, -0xf0(%rbp)
movaps %xmm3, -0xe0(%rbp)
movaps %xmm4, -0xd0(%rbp)
movaps %xmm5, -0xc0(%rbp)
movaps %xmm6, -0xb0(%rbp)
movaps %xmm7, -0xa0(%rbp)
movq %r9, -0x118(%rbp)
movq %r8, -0x120(%rbp)
movq %rcx, -0x128(%rbp)
movq %rdx, -0x130(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x30, -0x8c(%rbp)
movl $0x8, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
movaps -0x90(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x40, %edi
movq %rdi, -0x148(%rbp)
callq 0xd4c0
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rcx
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0xf640
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x28, %eax
ja 0xf83a
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0xf851
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
jne 0xf87f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf140
jmp 0xf8f8
movq -0x18(%rbp), %rdi
callq 0x30f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0xf8d3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf070
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x20, %edx
callq 0xfc60
jmp 0xf8f6
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x20, %edx
callq 0xfc60
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf070
jmp 0xf8f8
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x180, %rax            # imm = 0x180
cmpq $0x0, %rax
je 0xfbb6
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0xfbe0
movl %eax, -0x4(%rbp)
jmp 0xfbcd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
orq $0x10, %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/print.c
// Function: digitconv
static bool digitconv(Format *format, int c) {
	if (format->flags & FMT_f2set)
		format->f2 = 10 * format->f2 + c - '0';
	else {
		format->flags |= FMT_f1set;
		format->f1 = 10 * format->f1 + c - '0';
	}
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x100, %rax            # imm = 0x100
cmpq $0x0, %rax
je 0xfc1d
movq -0x8(%rbp), %rax
imulq $0xa, 0x28(%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
subq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0xfc4c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
orq $0x80, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
imulq $0xa, 0x20(%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
subq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jb 0x10038
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xffe0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop