LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: assign
extern void assign(List *s1, List *s2, bool stack) {
	List *val = s2;
	if (s1 == NULL)
		rc_error("null variable name");
	if (s1->n != NULL)
		rc_error("multi-word variable name");
	if (*s1->w == '\0')
		rc_error("zero-length variable name");
	if (a2u(s1->w) != -1)
		rc_error("numeric variable name");
	if (strchr(s1->w, '=') != NULL)
		rc_error("'=' in variable name");
	if (*s1->w == '*' && s1->w[1] == '\0')
		val = append(varlookup("0"), s2); /* preserve $0 when * is assigned explicitly */
	if (s2 != NULL || stack) {
		if (dashex)
			prettyprint_var(2, s1->w, val);
		varassign(s1->w, val, stack);
		alias(s1->w, varlookup(s1->w), stack);
	} else {
		if (dashex)
			prettyprint_var(2, s1->w, NULL);
		varrm(s1->w, stack);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x88fe
leaq 0xcf1f(%rip), %rdi      # 0x15818
callq 0x50d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8915
leaq 0xcf1b(%rip), %rdi      # 0x1582b
callq 0x50d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8930
leaq 0xcf19(%rip), %rdi      # 0x15844
callq 0x50d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x11cf0
cmpl $-0x1, %eax
je 0x8952
leaq 0xcf11(%rip), %rdi      # 0x1585e
callq 0x50d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x3120
cmpq $0x0, %rax
je 0x8975
leaq 0xcf04(%rip), %rdi      # 0x15874
callq 0x50d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x89b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x89b0
leaq 0xd74b(%rip), %rdi      # 0x160e6
callq 0x12110
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x83b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x89bd
cmpl $0x0, -0x14(%rbp)
je 0x8a19
leaq 0x172bc(%rip), %rax     # 0x1fc80
cmpl $0x0, (%rax)
je 0x89de
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x12680
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x11e60
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12110
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x120b0
jmp 0x8a49
leaq 0x17260(%rip), %rax     # 0x1fc80
cmpl $0x0, (%rax)
je 0x8a3a
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x12680
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x12380
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: qredir
extern void qredir(Node *n) {
	Rq *next;
	if (redirq == NULL) {
		next = redirq = nnew(Rq);
	} else {
		for (next = redirq; next->n != NULL; next = next->n)
			;
		next->n = nnew(Rq);
		next = next->n;
	}
	next->r = n;
	next->n = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x170f4(%rip)     # 0x1fb58
jne 0x8a7d
movl $0x10, %edi
callq 0xd4c0
movq %rax, 0x170e1(%rip)     # 0x1fb58
movq %rax, -0x10(%rbp)
jmp 0x8ac4
movq 0x170d4(%rip), %rax     # 0x1fb58
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8aa3
jmp 0x8a95
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8a88
movl $0x10, %edi
callq 0xd4c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: backq
static List *backq(Node *ifs, Node *n) {
	int p[2], sp;
	pid_t pid;
	List *bq;
	struct termios t;
	if (n == NULL)
		return NULL;
	if (pipe(p) < 0) {
		uerror("pipe");
		rc_error(NULL);
	}
	if (interactive)
		tcgetattr(0, &t);
	if ((pid = rc_fork()) == 0) {
		mvfd(p[1], 1);
		close(p[0]);
		redirq = NULL;
		walk(n, FALSE);
		exit(getstatus());
	}
	close(p[1]);
	bq = bqinput(glom(ifs), p[0]);
	close(p[0]);
	rc_wait4(pid, &sp, TRUE);
	if (interactive && WIFSIGNALED(sp))
		tcsetattr(0, TCSANOW, &t);
	setstatus(-1, sp);
	varassign("bqstatus", word(strstatus(sp), NULL), FALSE);
	sigchk();
	return bq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8e24
movq $0x0, -0x8(%rbp)
jmp 0x8f46
leaq -0x20(%rbp), %rdi
callq 0x3180
cmpl $0x0, %eax
jge 0x8e47
leaq 0x11201(%rip), %rdi     # 0x1a03a
callq 0x11c10
xorl %eax, %eax
movl %eax, %edi
callq 0x50d0
leaq 0x16e16(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0x8e5e
xorl %edi, %edi
leaq -0x6c(%rbp), %rsi
callq 0x32b0
callq 0x127b0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jne 0x8ea2
movl -0x1c(%rbp), %edi
movl $0x1, %esi
callq 0x11e10
movl -0x20(%rbp), %edi
callq 0x3170
movq $0x0, 0x16ccd(%rip) # 0x1fb58
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x12d80
callq 0x10730
movl %eax, %edi
callq 0x3320
movl -0x1c(%rbp), %edi
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x8af0
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x9140
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %edi
callq 0x3170
movl -0x28(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x1, %edx
callq 0x128c0
leaq 0x16d82(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0x8f07
movl -0x24(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x8f07
xorl %esi, %esi
leaq -0x6c(%rbp), %rdx
movl %esi, %edi
callq 0x32e0
movl -0x24(%rbp), %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x107d0
movl -0x24(%rbp), %edi
callq 0x10aa0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8350
movq %rax, %rsi
leaq 0xc96f(%rip), %rdi      # 0x158a1
xorl %edx, %edx
callq 0x11e60
callq 0x104a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: mkcmdarg
static List *mkcmdarg(Node *n) {
	char *name;
	List *ret = nnew(List);
	Estack *e = nnew(Estack);
	Edata efd;
	int p[2];
	if (pipe(p) < 0) {
		uerror("pipe");
		return NULL;
	}
	if (rc_fork() == 0) {
		setsigdefaults(FALSE);
		if (mvfd(p[n->u[0].i == rFrom], n->u[0].i == rFrom) < 0) /* stupid hack */
			exit(1);
		close(p[n->u[0].i != rFrom]);
		redirq = NULL;
		walk(n->u[2].p, FALSE);
		exit(getstatus());
	}

#if HAVE_DEV_FD
	name = nprint("/dev/fd/%d", p[n->u[0].i != rFrom]);
#else
	name = nprint("/proc/self/fd/%d", p[n->u[0].i != rFrom]);
#endif

	efd.fd = p[n->u[0].i != rFrom];
	except(eFd, efd, e);
	close(p[n->u[0].i == rFrom]);
	ret->w = name;
	ret->m = NULL;
	ret->n = NULL;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x20(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
cmpl $0x0, %eax
jge 0x8f9f
leaq 0x110ad(%rip), %rdi     # 0x1a03a
callq 0x11c10
movq $0x0, -0x8(%rbp)
jmp 0x90c8
callq 0x127b0
cmpl $0x0, %eax
jne 0x902f
xorl %edi, %edi
callq 0x5ab0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movl -0x38(%rbp,%rax,4), %edi
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x11e10
cmpl $0x0, %eax
jge 0x8fee
movl $0x1, %edi
callq 0x3320
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movl -0x38(%rbp,%rax,4), %edi
callq 0x3170
movq $0x0, 0x16b44(%rip) # 0x1fb58
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x12d80
callq 0x10730
movl %eax, %edi
callq 0x3320
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movl -0x38(%rbp,%rax,4), %esi
leaq 0xc86d(%rip), %rdi      # 0x158b9
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movl -0x38(%rbp,%rax,4), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rsi
movl $0x6, %edi
callq 0x4da0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movl -0x38(%rbp,%rax,4), %edi
callq 0x3170
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: count
static List *count(List *l) {
	List *s = nnew(List);
	s->w = nprint("%d", listnel(l));
	s->n = NULL;
	s->m = NULL;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca80
movl %eax, %esi
leaq 0xc7b5(%rip), %rdi      # 0x158c1
movb $0x0, %al
callq 0xf6d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: inithash
extern void inithash() {
	Htab *fpp, *vpp;
	int i;
	fp = ealloc(sizeof(Htab) * HASHSIZE);
	vp = ealloc(sizeof(Htab) * HASHSIZE);
	fused = vused = 0;
	fsize = vsize = HASHSIZE;
	for (vpp = vp, fpp = fp, i = 0; i < HASHSIZE; i++, vpp++, fpp++)
		vpp->name = fpp->name = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x400, %edi            # imm = 0x400
callq 0xd820
movq %rax, 0x166f7(%rip)     # 0x1fb60
movl $0x400, %edi            # imm = 0x400
callq 0xd820
movq %rax, 0x166ee(%rip)     # 0x1fb68
movl $0x0, 0x166ec(%rip)     # 0x1fb70
movl $0x0, 0x166e6(%rip)     # 0x1fb74
movl $0x40, 0x166e0(%rip)    # 0x1fb78
movl $0x40, 0x166da(%rip)    # 0x1fb7c
movq 0x166bf(%rip), %rax     # 0x1fb68
movq %rax, -0x10(%rbp)
movq 0x166ac(%rip), %rax     # 0x1fb60
movq %rax, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x94fe
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x94bf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: find
static int find(char *s, Htab *ht, int size) {
	int h = hash(s, size);
	while (ht[h].name != NULL && !streq(ht[h].name, s)) {
		h++;
		h &= size - 1;
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa6f0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x963d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x1a(%rbp)
jne 0x9635
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x31e0
cmpl $0x0, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9646
jmp 0x9660
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
andl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x95d2
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: get_fn_place
extern rc_Function *get_fn_place(char *s) {
	int h = fnfind(s);
	env_dirty = TRUE;
	if (fp[h].name == NULL) {
		if (rehash(fp))
			h = fnfind(s);
		fused++;
		fp[h].name = ecpy(s);
		fp[h].p = enew(rc_Function);
	} else
		free_fn(fp[h].p);
	return fp[h].p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x164d9(%rip), %rsi     # 0x1fb60
movl 0x164ef(%rip), %edx     # 0x1fb7c
callq 0x95b0
movl %eax, -0xc(%rbp)
movl $0x1, 0x15c61(%rip)     # 0x1f300
movq 0x164ba(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9752
movq 0x1649e(%rip), %rdi     # 0x1fb60
callq 0x9790
cmpl $0x0, %eax
je 0x96e5
movq -0x8(%rbp), %rdi
movq 0x16489(%rip), %rsi     # 0x1fb60
movl 0x1649f(%rip), %edx     # 0x1fb7c
callq 0x95b0
movl %eax, -0xc(%rbp)
movl 0x16489(%rip), %eax     # 0x1fb74
addl $0x1, %eax
movl %eax, 0x16480(%rip)     # 0x1fb74
movq -0x8(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd820
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
movq %rax, %rcx
movq 0x16441(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl $0x10, %edi
callq 0xd820
movq %rax, %rcx
movq 0x1641f(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x976d
movq 0x16407(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x99b0
movq 0x163ec(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: get_var_place
extern Variable *get_var_place(char *s, bool stack) {
	Variable *new;
	int h = varfind(s);

	env_dirty = TRUE;

	if (vp[h].name == NULL) {
		if (rehash(vp))
			h = varfind(s);
		vused++;
		vp[h].name = ecpy(s);
		vp[h].p = enew(Variable);
		((Variable *)vp[h].p)->n = NULL;
		return vp[h].p;
	} else {
		if (stack) {	/* increase the stack by 1 */
			new = enew(Variable);
			new->n = vp[h].p;
			return vp[h].p = new;
		} else {	/* trample the top of the stack */
			new = vp[h].p;
			efree(new->extdef);
			listfree(new->def);
			return new;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1616e(%rip), %rsi     # 0x1fb68
movl 0x16178(%rip), %edx     # 0x1fb78
callq 0x95b0
movl %eax, -0x24(%rbp)
movl $0x1, 0x158ee(%rip)     # 0x1f300
movq 0x1614f(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9b00
movq 0x16133(%rip), %rdi     # 0x1fb68
callq 0x9790
cmpl $0x0, %eax
je 0x9a58
movq -0x10(%rbp), %rdi
movq 0x1611e(%rip), %rsi     # 0x1fb68
movl 0x16128(%rip), %edx     # 0x1fb78
callq 0x95b0
movl %eax, -0x24(%rbp)
movl 0x16112(%rip), %eax     # 0x1fb70
addl $0x1, %eax
movl %eax, 0x16109(%rip)     # 0x1fb70
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd820
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3070
movq %rax, %rcx
movq 0x160d6(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl $0x18, %edi
callq 0xd820
movq %rax, %rcx
movq 0x160b4(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x1609e(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x16080(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b8d
cmpl $0x0, -0x14(%rbp)
je 0x9b52
movl $0x18, %edi
callq 0xd820
movq %rax, -0x20(%rbp)
movq 0x1604d(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x1602b(%rip), %rcx     # 0x1fb68
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x9b8d
movq 0x1600f(%rip), %rax     # 0x1fb68
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd7a0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xc910
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: delete_fn
extern void delete_fn(char *s) {
	int h = fnfind(s);
	if (fp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	free_fn(fp[h].p);
	efree(fp[h].p);
	efree(fp[h].name);
	if (fp[(h+1)&(fsize-1)].name == NULL) {
		--fused;
		fp[h].name = NULL;
	} else {
		fp[h].name = dead;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x15fa9(%rip), %rsi     # 0x1fb60
movl 0x15fbf(%rip), %edx     # 0x1fb7c
callq 0x95b0
movl %eax, -0xc(%rbp)
movq 0x15f94(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9be2
jmp 0x9caa
movl $0x1, 0x15714(%rip)     # 0x1f300
movq 0x15f6d(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x99b0
movq 0x15f52(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0xd7a0
movq 0x15f37(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xd7a0
movq 0x15f1d(%rip), %rax     # 0x1fb60
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl 0x15f2d(%rip), %edx     # 0x1fb7c
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9c8e
movl 0x15f0a(%rip), %eax     # 0x1fb74
addl $-0x1, %eax
movl %eax, 0x15f01(%rip)     # 0x1fb74
movq 0x15ee6(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x9caa
movq 0x15673(%rip), %rcx     # 0x1f308
movq 0x15ec4(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: delete_var
extern void delete_var(char *s, bool stack) {
	int h = varfind(s);
	Variable *v;
	if (vp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	v = vp[h].p;
	efree(v->extdef);
	listfree(v->def);
	if (v->n != NULL) { /* This is the top of a stack */
		if (stack) { /* pop */
			vp[h].p = v->n;
			efree(v);
		} else { /* else just empty */
			v->extdef = NULL;
			v->def = NULL;
		}
	} else { /* needs to be removed from the hash table */
		efree(v);
		vp[h].p = NULL;
		efree(vp[h].name);
		if (vp[(h+1)&(vsize-1)].name == NULL) {
			--vused;
			vp[h].name = NULL;
		} else {
			vp[h].name = dead;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq 0x15e9e(%rip), %rsi     # 0x1fb68
movl 0x15ea8(%rip), %edx     # 0x1fb78
callq 0x95b0
movl %eax, -0x10(%rbp)
movq 0x15e89(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9cf5
jmp 0x9e35
movl $0x1, 0x15601(%rip)     # 0x1f300
movq 0x15e62(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd7a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xc910
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9d88
cmpl $0x0, -0xc(%rbp)
je 0x9d6c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x15e16(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0xd7a0
jmp 0x9d83
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x9e35
movq -0x18(%rbp), %rdi
callq 0xd7a0
movq 0x15dd0(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x15db6(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xd7a0
movq 0x15d9c(%rip), %rax     # 0x1fb68
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl 0x15da0(%rip), %edx     # 0x1fb78
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x9e17
movl 0x15d7d(%rip), %eax     # 0x1fb70
addl $-0x1, %eax
movl %eax, 0x15d74(%rip)     # 0x1fb70
movq 0x15d65(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x9e33
movq 0x154ea(%rip), %rcx     # 0x1f308
movq 0x15d43(%rip), %rax     # 0x1fb68
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x9e35
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: initenv
extern void initenv(char **envp) {
	int n;
	for (n = 0; envp[n] != NULL; n++)
		;
	n++; /* one for the null terminator */
	if (n < HASHSIZE)
		n = HASHSIZE;
	env = ealloc((envsize = 2 * n) * sizeof (char *));
	for (; *envp != NULL; envp++)
		if (strncmp(*envp, "fn_", conststrlen("fn_")) == 0) {
			if (!dashpee)
				fnassign_string(*envp);
		} else {
			if (!varassign_string(*envp)) /* add to bozo env */
				env[bozosize++] = *envp;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9e6f
jmp 0x9e64
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9e53
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x9e85
movl $0x40, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, 0x15cf0(%rip)     # 0x1fb80
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xd820
movq %rax, 0x15ce5(%rip)     # 0x1fb88
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9f34
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xba05(%rip), %rsi      # 0x158c4
movl $0x3, %edx
callq 0x3060
cmpl $0x0, %eax
jne 0x9ee8
leaq 0x15d9f(%rip), %rax     # 0x1fc74
cmpl $0x0, (%rax)
jne 0x9ee6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5cc0
jmp 0x9f21
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x11f20
cmpl $0x0, %eax
jne 0x9f1f
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq 0x15c81(%rip), %rax     # 0x1fb88
movl 0x15c83(%rip), %ecx     # 0x1fb90
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x15c78(%rip)     # 0x1fb90
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x9f21
jmp 0x9f23
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x9ea3
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: set_exportable
void set_exportable(char *s, bool b) {
	int i;
	for (i = 0; i < arraysize(maybeexport); ++i)
		if (maybeexport[i].flag != b && streq(s, maybeexport[i].name))
			maybeexport[i].flag = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x9fe8
movslq -0x10(%rbp), %rcx
leaq 0x153a5(%rip), %rax     # 0x1f310
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x9fd8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq -0x10(%rbp), %rdx
leaq 0x15384(%rip), %rcx     # 0x1f310
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x9fd8
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rcx
leaq 0x15364(%rip), %rax     # 0x1f310
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x9fd8
movl -0xc(%rbp), %ecx
movslq -0x10(%rbp), %rdx
leaq 0x15342(%rip), %rax     # 0x1f310
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x9fda
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9f56
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: var_exportable
static bool var_exportable(char *s) {
	int i;
	for (i = 0; i < arraysize(neverexport); i++)
		if (streq(s, neverexport[i]))
			return FALSE;
	for (i = 0; i < arraysize(maybeexport); i++)
		if (maybeexport[i].flag == FALSE && streq(s, maybeexport[i].name))
			return FALSE;
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0xa29c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x14(%rbp), %rdx
leaq 0x150d5(%rip), %rcx     # 0x1f330
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xa28f
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x150bb(%rip), %rax     # 0x1f330
movq (%rax,%rcx,8), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0xa28f
movl $0x0, -0x4(%rbp)
jmp 0xa324
jmp 0xa291
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa243
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xa31d
movslq -0x14(%rbp), %rcx
leaq 0x1505c(%rip), %rax     # 0x1f310
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xa310
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x14(%rbp), %rdx
leaq 0x1503d(%rip), %rcx     # 0x1f310
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xa310
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x1501d(%rip), %rax     # 0x1f310
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0xa310
movl $0x0, -0x4(%rbp)
jmp 0xa324
jmp 0xa312
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa2a3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: fn_exportable
static bool fn_exportable(char *s) {
	int i;
	if (strncmp(s, "sig", conststrlen("sig")) == 0) { /* small speed hack */
		for (i = 0; i < NUMOFSIGNALS; i++)
			if (streq(s, signals[i].name))
				return FALSE;
		if (streq(s, "sigexit"))
			return FALSE;
	}
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb13f(%rip), %rsi      # 0x15486
movl $0x3, %edx
callq 0x3060
cmpl $0x0, %eax
jne 0xa3f5
movl $0x0, -0x14(%rbp)
cmpl $0x41, -0x14(%rbp)
jge 0xa3c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x14(%rbp), %rdx
leaq 0x15037(%rip), %rcx     # 0x1f3b0
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xa3b6
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x15017(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0xa3b6
movl $0x0, -0x4(%rbp)
jmp 0xa3fc
jmp 0xa3b8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa361
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xb0ad(%rip), %ecx      # 0x1547e
cmpl %ecx, %eax
jne 0xa3f3
movq -0x10(%rbp), %rdi
leaq 0xb09e(%rip), %rsi      # 0x1547e
callq 0x31e0
cmpl $0x0, %eax
jne 0xa3f3
movl $0x0, -0x4(%rbp)
jmp 0xa3fc
jmp 0xa3f5
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/hash.c
// Function: whatare_all_vars
extern void whatare_all_vars(bool showfn, bool showvar) {
	int i;
	List *s;
	if (showvar)
		for (i = 0; i < vsize; i++)
			if (vp[i].name != NULL && (s = varlookup(vp[i].name)) != NULL)
				prettyprint_var(1, vp[i].name, s);
	if (showfn)
		for (i = 0; i < fsize; i++)
			if (fp[i].name != NULL && fp[i].name != dead)
				prettyprint_fn(1, fp[i].name, fnlookup(fp[i].name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xa4a8
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x15740(%rip), %eax     # 0x1fb78
jge 0xa4a6
movq 0x15727(%rip), %rax     # 0x1fb68
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xa499
movq 0x1570f(%rip), %rax     # 0x1fb68
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x12110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa499
movq 0x156eb(%rip), %rax     # 0x1fb68
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %edi
callq 0x12680
jmp 0xa49b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa42f
jmp 0xa4a8
cmpl $0x0, -0x4(%rbp)
je 0xa554
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x156ba(%rip), %eax     # 0x1fb7c
jge 0xa552
movq 0x15691(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xa542
movq 0x15679(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x14e0c(%rip), %rax     # 0x1f308
je 0xa542
movq 0x1565b(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x15642(%rip), %rax     # 0x1fb60
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x5d30
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x1, %edi
callq 0x5f90
jmp 0xa544
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa4b9
jmp 0xa554
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: compl_name
extern char *compl_name(const char *text, int state, char **p, size_t count, ssize_t inc) {
	static char **n;
	static size_t i, len;
	char *name;

	if (!state) {
		n = p;
		i = 0;
		len = strlen(text);
	}
	for (name = NULL; name == NULL && i < count; i++, n += inc)
		if (*n != NULL && strncmp(*n, text, len) == 0)
			name = strdup(*n);
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa5a7
movq -0x18(%rbp), %rax
movq %rax, 0x1560c(%rip)     # 0x1fb98
movq $0x0, 0x15609(%rip) # 0x1fba0
movq -0x8(%rbp), %rdi
callq 0x30f0
movq %rax, 0x15601(%rip)     # 0x1fba8
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
jne 0xa5cc
movq 0x155de(%rip), %rax     # 0x1fba0
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xa5d5
jmp 0xa643
movq 0x155bc(%rip), %rax     # 0x1fb98
cmpq $0x0, (%rax)
je 0xa614
movq 0x155af(%rip), %rax     # 0x1fb98
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq 0x155b1(%rip), %rdx     # 0x1fba8
callq 0x3060
cmpl $0x0, %eax
jne 0xa614
movq 0x15590(%rip), %rax     # 0x1fb98
movq (%rax), %rdi
callq 0x3340
movq %rax, -0x30(%rbp)
jmp 0xa616
movq 0x15583(%rip), %rax     # 0x1fba0
addq $0x1, %rax
movq %rax, 0x15578(%rip)     # 0x1fba0
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq 0x15561(%rip), %rax     # 0x1fb98
movq %rax, 0x1555a(%rip)     # 0x1fb98
jmp 0xa5af
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/hash.c
// Function: hash
static int hash(char *s, int size) {
	int c, n = 0;
	while (1) {
		ADV();
		n += (c << 17) ^ (c << 11) ^ (c << 5) ^ (c >> 1);
		ADV();
		n ^= (c << 14) + (c << 7) + (c << 4) + c;
		ADV();
		n ^= (~c << 11) | ((c << 3) ^ (c >> 1));
		ADV();
		n -= (c << 16) | (c << 9) | (c << 2) | (c & 3);
	}
	if (n < 0)
		n = ~n;
	return n & (size - 1); /* need power of 2 size */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0xa721
jmp 0xa803
movl -0x10(%rbp), %eax
shll $0x11, %eax
movl -0x10(%rbp), %ecx
shll $0xb, %ecx
xorl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
xorl %ecx, %eax
movl -0x10(%rbp), %ecx
sarl %ecx
xorl %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0xa763
jmp 0xa803
movl -0x10(%rbp), %eax
shll $0xe, %eax
movl -0x10(%rbp), %ecx
shll $0x7, %ecx
addl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
addl -0x10(%rbp), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0xa79e
jmp 0xa803
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
shll $0xb, %eax
movl -0x10(%rbp), %ecx
shll $0x3, %ecx
movl -0x10(%rbp), %edx
sarl %edx
xorl %edx, %ecx
orl %ecx, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0xa7d8
jmp 0xa803
movl -0x10(%rbp), %ecx
shll $0x10, %ecx
movl -0x10(%rbp), %eax
shll $0x9, %eax
orl %eax, %ecx
movl -0x10(%rbp), %eax
shll $0x2, %eax
orl %eax, %ecx
movl -0x10(%rbp), %eax
andl $0x3, %eax
orl %eax, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xa702
cmpl $0x0, -0x14(%rbp)
jge 0xa812
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/heredoc.c
// Function: heredoc
extern int heredoc(int end) {
	Hq *here;
	if ((here = hq) != NULL) {
		hq = NULL;
		if (end) {
			yyerror("heredoc incomplete");
			return FALSE;
		}
		do {
			Node *n = here->doc;
			char *s = readheredoc(here->name);
			if (dead)
				return FALSE;
			n->u[2].p = here->quoted ? mk(nWord, s, NULL, FALSE) : parseheredoc(s);
			n->u[0].i = rHerestring;
		} while ((here = here->n) != NULL);
	}
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq 0x1537e(%rip), %rax     # 0x1fbb0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xa8fb
movq $0x0, 0x15365(%rip) # 0x1fbb0
cmpl $0x0, -0x8(%rbp)
je 0xa869
leaq 0xb08a(%rip), %rdi      # 0x158e2
callq 0xc750
movl $0x0, -0x4(%rbp)
jmp 0xa902
jmp 0xa86b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa910
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x1532a(%rip)     # 0x1fbb8
je 0xa899
movl $0x0, -0x4(%rbp)
jmp 0xa902
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xa8bf
movq -0x20(%rbp), %rsi
movl $0x1e, %edi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x10e30
movq %rax, -0x28(%rbp)
jmp 0xa8cc
movq -0x20(%rbp), %rdi
callq 0xab30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa86b
jmp 0xa8fb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1e, (%rax)
je 0xad56
leaq 0xabb5(%rip), %rdi      # 0x158f5
callq 0xc750
callq 0xb1b0
movl $0x0, -0x4(%rbp)
jmp 0xadd6
leaq 0x14e53(%rip), %rax     # 0x1fbb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xad82
jmp 0xad74
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0xad61
movl $0x20, %edi
callq 0xd4c0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x14d61(%rip), %rax     # 0x1fbc0
cmpl $0x0, 0x14(%rax)
je 0xae8e
movq 0x14d54(%rip), %rax     # 0x1fbc0
movq 0x14d4d(%rip), %rdx     # 0x1fbc0
movl 0x14(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rdx)
movslq %ecx, %rcx
movl 0x30(%rax,%rcx,4), %eax
movl %eax, 0x14d3f(%rip)     # 0x1fbc8
movl %eax, -0x4(%rbp)
jmp 0xaeb8
jmp 0xae90
movq 0x14d29(%rip), %rax     # 0x1fbc0
callq *0x38(%rax)
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jne 0xaeb2
leaq 0xaaab(%rip), %rdi      # 0x15954
xorl %esi, %esi
callq 0x11ba0
jmp 0xae90
movl -0x8(%rbp), %eax
movl %eax, -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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0xb600
movl $0x1, 0x14416(%rip)     # 0x1f380
movl -0x4(%rbp), %ecx
movq 0x14c4c(%rip), %rax     # 0x1fbc0
movl %ecx, 0x8(%rax)
leaq 0x14caa(%rip), %rax     # 0x1fc28
movl $0x1, (%rax)
leaq 0x14879(%rip), %rax     # 0x1f804
cmpl $0x0, (%rax)
je 0xafe1
leaq 0x14ccd(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0xafe1
movl -0x4(%rbp), %edi
callq 0x3090
cmpl $0x0, %eax
je 0xafe1
movq 0x14c10(%rip), %rax     # 0x1fbc0
movl $0x2, 0x4(%rax)
movq 0x14c02(%rip), %rax     # 0x1fbc0
leaq 0x75b(%rip), %rcx       # 0xb720
movq %rcx, 0x38(%rax)
movl -0x4(%rbp), %edi
callq 0x4c80
movq %rax, %rcx
movq 0x14be5(%rip), %rax     # 0x1fbc0
movq %rcx, 0x28(%rax)
jmp 0xb012
movq 0x14bd8(%rip), %rax     # 0x1fbc0
movl $0x0, 0x4(%rax)
movq 0x14bca(%rip), %rax     # 0x1fbc0
leaq 0x903(%rip), %rcx       # 0xb900
movq %rcx, 0x38(%rax)
movl $0x100, %edi            # imm = 0x100
callq 0xd820
movq %rax, 0x14bce(%rip)     # 0x1fbe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xb600
movq 0x14b85(%rip), %rax     # 0x1fbc0
movl $0x1, 0x4(%rax)
movl -0xc(%rbp), %eax
movl %eax, 0x14335(%rip)     # 0x1f380
movq -0x8(%rbp), %rsi
leaq 0xa0f8(%rip), %rdi      # 0x1514e
movb $0x0, %al
callq 0xf540
movq %rax, 0x14b7c(%rip)     # 0x1fbe0
movq 0x14b55(%rip), %rax     # 0x1fbc0
leaq 0xa1e(%rip), %rcx       # 0xba90
movq %rcx, 0x38(%rax)
cmpl $0x0, 0x14303(%rip)     # 0x1f380
je 0xb08e
leaq 0x14ba2(%rip), %rax     # 0x1fc28
movl $0x1, (%rax)
jmp 0xb0a3
leaq 0x14b93(%rip), %rax     # 0x1fc28
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x14b87(%rip), %rax     # 0x1fc28
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x14b05(%rip), %rax     # 0x1fbc0
cmpl $0x2, 0x4(%rax)
jne 0xb0d1
movq 0x14af8(%rip), %rax     # 0x1fbc0
movq 0x28(%rax), %rdi
callq 0x4d40
movq 0x14ae8(%rip), %rax     # 0x1fbc0
cmpl $0x0, 0x4(%rax)
je 0xb0eb
movq 0x14adb(%rip), %rax     # 0x1fbc0
cmpl $0x2, 0x4(%rax)
jne 0xb0fa
movq 0x14ace(%rip), %rax     # 0x1fbc0
movl 0x8(%rax), %edi
callq 0x3170
movq 0x14adf(%rip), %rdi     # 0x1fbe0
callq 0xd7a0
movq 0x14ab3(%rip), %rax     # 0x1fbc0
addq $-0x40, %rax
movq %rax, 0x14aa8(%rip)     # 0x1fbc0
movq 0x14aa1(%rip), %rax     # 0x1fbc0
movl 0x1c(%rax), %eax
movl %eax, 0x14aa0(%rip)     # 0x1fbc8
movq 0x14a91(%rip), %rax     # 0x1fbc0
movq 0x20(%rax), %rax
movq %rax, 0x14aa6(%rip)     # 0x1fbe0
movq 0x14a7f(%rip), %rax     # 0x1fbc0
movslq 0xc(%rax), %rax
movq %rax, 0x14a9c(%rip)     # 0x1fbe8
movq 0x14a6d(%rip), %rax     # 0x1fbc0
movslq 0x10(%rax), %rax
movq %rax, 0x14a92(%rip)     # 0x1fbf0
cmpl $0x0, 0x1421b(%rip)     # 0x1f380
je 0xb17c
movq 0x14a52(%rip), %rax     # 0x1fbc0
movl 0x18(%rax), %ecx
leaq 0x14ab0(%rip), %rax     # 0x1fc28
movl %ecx, (%rax)
jmp 0xb191
leaq 0x14aa5(%rip), %rax     # 0x1fc28
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x14a99(%rip), %rax     # 0x1fc28
movl %ecx, (%rax)
movq 0x14a28(%rip), %rax     # 0x1fbc0
movl (%rax), %eax
movl %eax, 0x141e0(%rip)     # 0x1f380
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0xa, 0x14a09(%rip)     # 0x1fbc8
je 0xb1ca
cmpl $-0x1, 0x14a00(%rip)    # 0x1fbc8
jne 0xb1cc
jmp 0xb205
jmp 0xb1ce
callq 0xae50
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x5(%rbp)
je 0xb1ec
cmpl $-0x1, -0x4(%rbp)
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0xb1f5
jmp 0xb1f7
jmp 0xb1ce
cmpl $-0x1, -0x4(%rbp)
jne 0xb205
movl -0x4(%rbp), %edi
callq 0xade0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x147b1(%rip), %rax     # 0x1fc64
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x14795(%rip), %rax     # 0x1fc64
movl $0x0, (%rax)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xb020
xorl %edi, %edi
callq 0xb210
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
leaq 0x1476c(%rip), %rax     # 0x1fc64
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x146a1(%rip), %rax     # 0x1fbc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x146aa(%rip), %rax     # 0x1fbd8
je 0xb56b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xb55b
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jle 0xb55b
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3170
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0xb55d
movq -0x8(%rbp), %rax
addq $-0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0xb523
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x1469d(%rip), %rax     # 0x1fc28
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x14691(%rip), %rax     # 0x1fc28
movl %ecx, (%rax)
leaq 0x146c4(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0xb5f6
movq 0x14614(%rip), %rax     # 0x1fbc0
cmpl $0x0, 0x4(%rax)
jne 0xb5ce
movq 0x1464f(%rip), %rdx     # 0x1fc08
movl $0x2, %edi
leaq 0xa00b(%rip), %rsi      # 0x155d0
movb $0x0, %al
callq 0xf3a0
jmp 0xb5f4
movq 0x145eb(%rip), %rax     # 0x1fbc0
cmpl $0x2, 0x4(%rax)
jne 0xb5f2
movq 0x145de(%rip), %rax     # 0x1fbc0
movq 0x28(%rax), %rdi
movq 0x1461b(%rip), %rsi     # 0x1fc08
callq 0x4ce0
jmp 0xb5f4
jmp 0xb5f6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x145d9(%rip), %rax     # 0x1fbe8
movl %eax, %ecx
movq 0x145a8(%rip), %rax     # 0x1fbc0
movl %ecx, 0xc(%rax)
movq 0x145ce(%rip), %rax     # 0x1fbf0
movl %eax, %ecx
movq 0x14595(%rip), %rax     # 0x1fbc0
movl %ecx, 0x10(%rax)
movq 0x145ab(%rip), %rcx     # 0x1fbe0
movq 0x14584(%rip), %rax     # 0x1fbc0
movq %rcx, 0x20(%rax)
leaq 0x145e1(%rip), %rax     # 0x1fc28
movl (%rax), %ecx
movq 0x14570(%rip), %rax     # 0x1fbc0
movl %ecx, 0x18(%rax)
movl 0x13d27(%rip), %ecx     # 0x1f380
movq 0x14560(%rip), %rax     # 0x1fbc0
movl %ecx, (%rax)
movl 0x14560(%rip), %ecx     # 0x1fbc8
movq 0x14551(%rip), %rax     # 0x1fbc0
movl %ecx, 0x1c(%rax)
movq 0x14547(%rip), %rax     # 0x1fbc0
addq $0x40, %rax
movq %rax, 0x1453c(%rip)     # 0x1fbc0
movq 0x14535(%rip), %rax     # 0x1fbc0
movq 0x14546(%rip), %rcx     # 0x1fbd8
subq %rcx, %rax
sarq $0x6, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x14528(%rip), %rcx     # 0x1fbd0
shrq $0x6, %rcx
cmpq %rcx, %rax
jb 0xb6ee
movq 0x14520(%rip), %rdi     # 0x1fbd8
movq 0x14511(%rip), %rsi     # 0x1fbd0
shlq %rsi
movq %rsi, 0x14507(%rip)     # 0x1fbd0
callq 0xd890
movq %rax, 0x14503(%rip)     # 0x1fbd8
movq 0x144fc(%rip), %rax     # 0x1fbd8
movq -0x8(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, 0x144d2(%rip)     # 0x1fbc0
movq $0x0, 0x144ef(%rip) # 0x1fbe8
movq $0x0, 0x144ec(%rip) # 0x1fbf0
movq 0x144b5(%rip), %rax     # 0x1fbc0
movl $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)