LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: parse_var
extern List *parse_var(char *extdef) {
	char *begin, *end, *from, *to;
	int len;
	List *first, *last, *new;

	first = last = NULL;
	begin = strchr(extdef, '=');
	assert(begin); /* guaranteed by initenv() */
	while (*begin) {
		++begin;
		end = begin;
		len = 0;
		while (*end != ENV_SEP && *end != '\0') {
			if (*end == ENV_ESC) {
				++end;
				if (*end != ENV_SEP && *end != ENV_ESC) --end;
			}
			++end; ++len;
		}
		new = enew(List);
		if (last)
			last->n = new;
		else
			first = new;
		last = new;
		new->w = ealloc(len + 1);
		new->m = NULL;
		new->n = NULL;
		to = new->w;
		for (from = begin; from < end; ++from) {
			if (*from == ENV_ESC) {
				++from;
				if (*from != ENV_SEP && *from != ENV_ESC)
					--from;
			}
			*to = *from;
			++to;
		}
		*to = '\0';
		begin = end;
	}
	return first;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x3d
popq %rsi
callq 0x3120
testq %rax, %rax
je 0x51b6
movq %rax, %rbx
xorl %r15d, %r15d
pushq $0x2
popq %rbp
xorl %r12d, %r12d
cmpb $0x0, (%rbx)
je 0x51a4
movq %r15, (%rsp)
incq %rbx
pushq $0x1
popq %r13
movq %rbx, %r14
movzbl (%r14), %eax
cmpl $0x2, %eax
je 0x5125
jae 0x5132
jmp 0x513a
movb 0x1(%r14), %al
decb %al
cmpb $0x2, %al
jae 0x5132
incq %r14
incq %r14
incq %r13
jmp 0x5118
pushq $0x18
popq %rdi
callq 0x9a83
movq %r12, %rcx
movq %rax, %r12
movq %rax, %r15
testq %rcx, %rcx
je 0x5158
movq %r12, 0x10(%rcx)
movq (%rsp), %r15
movq %r13, %rdi
callq 0x9a83
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
cmpq %r14, %rbx
jae 0x5199
movb (%rbx), %cl
cmpb $0x2, %cl
jne 0x518f
leaq 0x1(%rbx), %rdx
movzbl 0x1(%rbx), %ecx
leal -0x1(%rcx), %esi
cmpb $0x2, %sil
cmovael %ebp, %ecx
cmovbq %rdx, %rbx
movb %cl, (%rax)
incq %rax
incq %rbx
jmp 0x516d
movb $0x0, (%rax)
movq %r14, %rbx
jmp 0x5101
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x938b(%rip), %rdi      # 0xe548
leaq 0x938a(%rip), %rsi      # 0xe54e
leaq 0x938e(%rip), %rcx      # 0xe559
movl $0xf2, %edx
callq 0x3140
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: parse_fn
extern Node *parse_fn(char *extdef) {
	Node *def;
	char *s, old[PRELEN];
	if ((s = strchr(extdef, '=')) == NULL)
		return NULL;
	memcpy(old, s -= (PRELEN-1), PRELEN);
	memcpy(s, PREFIX, PRELEN);
	def = parseline(s);
	memcpy(s, old, PRELEN);
	return (def == NULL || def->type != nNewfn) ? NULL : def->u[1].p;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
pushq $0x3d
popq %rsi
callq 0x3120
testq %rax, %rax
je 0x5211
movq %rax, %rbx
movq %rax, %rdi
addq $-0x3, %rdi
movl -0x3(%rax), %ebp
movl $0x78206e66, -0x3(%rax) # imm = 0x78206E66
callq 0x829a
movl %ebp, -0x3(%rbx)
testq %rax, %rax
je 0x5211
cmpl $0xe, (%rax)
jne 0x5211
movq 0x10(%rax), %rax
jmp 0x5213
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: initprint
void initprint(void) {
	fmtinstall('A', Aconv);
	fmtinstall('L', Lconv);
	fmtinstall('S', Sconv);
	fmtinstall('T', Tconv);
	fmtinstall('D', Dconv);
	fmtinstall('W', Wconv);
#if PROTECT_ENV
	fmtinstall('F', Fconv);
#else
	fmtinstall('F', fmtinstall('s', NULL));
#endif
}

// Assembly:
pushq %rax
leaq 0x63(%rip), %rsi        # 0x5285
pushq $0x41
popq %rdi
callq 0xa5e0
leaq 0xbf(%rip), %rsi        # 0x52f0
pushq $0x4c
popq %rdi
callq 0xa5e0
leaq 0x18d(%rip), %rsi       # 0x53cd
pushq $0x53
popq %rdi
callq 0xa5e0
leaq 0x2d6(%rip), %rsi       # 0x5525
pushq $0x54
popq %rdi
callq 0xa5e0
leaq 0x7cc(%rip), %rsi       # 0x5a2a
pushq $0x44
popq %rdi
callq 0xa5e0
leaq 0x808(%rip), %rsi       # 0x5a75
pushq $0x57
popq %rdi
callq 0xa5e0
leaq 0x8cc(%rip), %rsi       # 0x5b48
pushq $0x46
popq %rdi
popq %rax
jmp 0xa5e0
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Aconv
static bool Aconv(Format *f, int ignore) {
	char **a = va_arg(f->args, char **);
	if (*a != NULL) {
		fmtcat(f, *a);
		while (*++a != NULL)
			fmtprint(f, " %s", *a);
	}
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x52a3
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x52af
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x52e8
movq %rbx, %rdi
callq 0xa75f
addq $0x8, %r15
leaq 0x92a4(%rip), %r14      # 0xe571
movq (%r15), %rdx
testq %rdx, %rdx
je 0x52e8
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa824
addq $0x8, %r15
jmp 0x52cd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Lconv
static bool Lconv(Format *f, int ignore) {
	bool plain;
	char *sep;
	List *l, *n;

	plain = f->flags & FMT_leftside;
	l = va_arg(f->args, List *);
	sep = va_arg(f->args, char *);
	if (l == NULL && (f->flags & FMT_leftside) == 0)
		fmtprint(f, "()");
	else {
		for (; l != NULL; l = n) {
			n = l->n;
			fmtprint(f, plain ? "%s" : "%-S", l->w);
			if (n != NULL) fmtputc(f, *sep);
		}
	}
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movl (%rdi), %edx
cmpq $0x29, %rdx
jae 0x5329
movq 0x10(%rbx), %rsi
movq %rdx, %rcx
addq $0x8, %rcx
movl %ecx, (%rbx)
movq (%rsi,%rdx), %r12
cmpl $0x20, %edx
ja 0x5338
addq 0x10(%rbx), %rcx
addl $0x10, %edx
movl %edx, (%rbx)
jmp 0x5344
movq 0x8(%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq (%rcx), %r12
movq 0x8(%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movl %eax, %edx
andl $0x20, %edx
orq %r12, %rdx
jne 0x536b
leaq 0x9220(%rip), %rsi      # 0xe575
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa824
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rcx), %r13
testb $0x20, %al
leaq 0x9201(%rip), %rax      # 0xe578
leaq 0x91f4(%rip), %r14      # 0xe572
cmoveq %rax, %r14
pushq $0x1
popq %r15
testq %r12, %r12
je 0x535f
movq (%r12), %rdx
movq 0x10(%r12), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa824
testq %r12, %r12
je 0x5386
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x53bd
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
movb (%r13), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0x30(%rbx)
movb %cl, (%rax)
jmp 0x5386
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Sconv
static bool Sconv(Format *f, int ignore) {
	int c;
	unsigned char *s = va_arg(f->args, unsigned char *), *t = s;
	bool quoted    = (f->flags & FMT_altform)  != 0;	/* '#' */
	bool metaquote = (f->flags & FMT_leftside) != 0;	/* '-' */
	if (*s == '\0') {
		fmtprint(f, "''");
		return FALSE;
	}
	if (!quoted) {
		while ((c = *t++) != '\0')
			if (nw[c] == 1 || (metaquote && ISMETA(c)))
				goto quoteit;
		fmtprint(f, "%s", s);
		return FALSE;
	}
quoteit:
	fmtputc(f, '\'');
	while ((c = *s++) != '\0') {
		fmtputc(f, c);
		if (c == '\'')
			fmtputc(f, '\'');

	}
	fmtputc(f, '\'');
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x53ed
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x53f9
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r14
movb (%r14), %dil
testb %dil, %dil
je 0x54f1
movq 0x18(%rbx), %rax
testb $0x40, %al
jne 0x5452
leaq 0x1(%r14), %rcx
leaq 0x95a5(%rip), %rdx      # 0xe9c0
movabsq $0x2000000200001, %rsi  # imm = 0x2000000200001
testb %dil, %dil
je 0x5504
movzbl %dil, %edi
cmpb $0x1, (%rdx,%rdi)
je 0x5452
testb $0x20, %al
je 0x544a
addl $-0x2a, %edi
cmpl $0x31, %edi
ja 0x544a
btq %rdi, %rsi
jb 0x5452
movb (%rcx), %dil
incq %rcx
jmp 0x5425
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5469
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
pushq $0x1
popq %r15
movb (%r14), %bpl
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
testb %bpl, %bpl
je 0x54d2
cmpq %rcx, %rax
jb 0x549a
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
incq %r14
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %bpl, (%rax)
cmpb $0x27, %bpl
jne 0x5478
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x54c5
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
jmp 0x5478
cmpq %rcx, %rax
jb 0x54e4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
jmp 0x5518
leaq 0x9084(%rip), %rsi      # 0xe57c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa824
jmp 0x5518
leaq 0x9067(%rip), %rsi      # 0xe572
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa824
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Dconv
static bool Dconv(Format *f, int ignore) {
	const char *name = "?";
	int n = va_arg(f->args, int);
	switch (n) {
	case rCreate:		name = ">";	break;
	case rAppend:		name = ">>";	break;
	case rFrom:		name = "<";	break;
	case rHeredoc:		name = "<<";	break;
	case rHerestring:	name = "<<<";	break;
	}
	fmtcat(f, name);
	return FALSE;
}

// Assembly:
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5a40
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x5a4c
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movl (%rax), %eax
cmpq $0x4, %rax
ja 0x5a64
leaq 0x8ad9(%rip), %rcx      # 0xe534
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x5a6b
leaq 0x8c0f(%rip), %rsi      # 0xe67a
pushq %rax
callq 0xa75f
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Wconv
static bool Wconv(Format *f, int ignore) {
	List *l, *n;

	l = va_arg(f->args, List *);
	for (; l != NULL; l = n) {
		char c, *s;

		for (s = l->w; (c = *s) != '\0'; ++s) {
			if (c == ENV_SEP || c == ENV_ESC)
				fmtputc(f, ENV_ESC);
			fmtputc(f, c);
		}
		n = l->n;
		if (n != NULL) fmtputc(f, ENV_SEP);
	}
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5a96
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5aa2
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r15
pushq $0x1
popq %r14
testq %r15, %r15
je 0x5b3d
movq (%r15), %r12
movb (%r12), %bpl
testb %bpl, %bpl
je 0x5b0d
cmpb $0x2, %bpl
ja 0x5ae6
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5adb
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x2, (%rax)
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5afd
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %bpl, (%rax)
incq %r12
jmp 0x5ab5
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x5aa9
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5b2d
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x1, (%rax)
jmp 0x5aa9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/footobar.c
// Function: Fconv
static bool Fconv(Format *f, int ignore) {
	unsigned const char *s = va_arg(f->args, unsigned const char *);
	int c;

	while ((c = *s++) != '\0')
		if (dnw[c] || c == '*' || (c == '_' && *s == '_'))
			fmtprint(f, "__%02x", c);
		else
			fmtputc(f, c);
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5b6c
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5b78
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r13
incq %r13
leaq 0x8f3b(%rip), %rbp      # 0xeac0
leaq 0x8af7(%rip), %r14      # 0xe683
pushq $0x1
popq %r15
movzbl -0x1(%r13), %r12d
testl %r12d, %r12d
je 0x5bee
cmpb $0x2a, %r12b
je 0x5bb5
cmpb $0x0, (%rbp,%r12)
jne 0x5bb5
cmpb $0x5f, %r12b
jne 0x5bc7
cmpb $0x5f, (%r13)
jne 0x5bc7
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0xa824
jmp 0x5be9
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5bde
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %r12b, (%rax)
incq %r13
jmp 0x5b90
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glob.c
// Function: lmatch
extern bool lmatch(List *s, List *p) {
	List *q;
	if (s == NULL) {
		if (p == NULL) /* null matches null */
			return TRUE;
		for (; p != NULL; p = p->n) /* one or more stars match null */
			if (strspn(p->w, "*") == strlen(p->w) &&
			    p->m != NULL && strlen(p->m) == strlen(p->w))
				return TRUE;
		return FALSE;
	}
	for (; s != NULL; s = s->n)
		for (q = p; q != NULL; q = q->n)
			if (match(q->w, q->m, s->w))
				return TRUE;
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x5e06
movq %rdi, %r15
pushq $0x1
popq %rbx
testq %r15, %r15
je 0x5e51
movq %r14, %r12
testq %r12, %r12
je 0x5e00
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq (%r15), %rdx
callq 0x978c
testl %eax, %eax
jne 0x5e53
movq 0x10(%r12), %r12
jmp 0x5ddf
movq 0x10(%r15), %r15
jmp 0x5dd7
pushq $0x1
popq %rbx
testq %r14, %r14
je 0x5e53
leaq 0x8247(%rip), %r15      # 0xe05c
testq %r14, %r14
je 0x5e51
movq (%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3190
movq %rax, %r12
movq %r13, %rdi
callq 0x30f0
cmpq %rax, %r12
jne 0x5e4b
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5e4b
callq 0x30f0
cmpq %r12, %rax
je 0x5e53
movq 0x10(%r14), %r14
jmp 0x5e15
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glob.c
// Function: glob
extern List *glob(List *s) {
	List *top, *r;
	bool meta;
	for (r = s, meta = FALSE; r != NULL; r = r->n)
		if (r->m != NULL)
			meta = TRUE;
	if (!meta)
		return s; /* don't copy lists with no metacharacters in them */
	for (top = r = NULL; s != NULL; s = s->n) {
		if (s->m == NULL) { /* no metacharacters; just tack on to the return list */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = s->w;
		} else {
			if (top == NULL)
				top = r = sort(doglob(s->w, s->m));
			else
				r->n = sort(doglob(s->w, s->m));
			while (r->n != NULL)
				r = r->n;
		}
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
pushq $0x1
popq %rcx
movq %rdi, %rdx
testq %rdx, %rdx
je 0x5e86
cmpq $0x0, 0x8(%rdx)
cmovnel %ecx, %eax
movq 0x10(%rdx), %rdx
jmp 0x5e73
testl %eax, %eax
je 0x5f04
xorl %r14d, %r14d
pushq $0x18
popq %r15
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x5efd
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x5ec0
movq (%rbx), %rdi
callq 0x5f6c
movq %rax, %r12
movq %rax, %rdi
callq 0x5f14
testq %r14, %r14
je 0x5ee2
movq %r12, 0x10(%r13)
jmp 0x5ee8
movq %r15, %rdi
callq 0x9928
movq %rax, %rcx
testq %r14, %r14
je 0x5ed7
movq %rax, 0x10(%r13)
movq %r14, %rcx
movq (%rbx), %rdx
movq %rdx, (%rax)
movq %rcx, %r14
jmp 0x5ef4
movq %r12, %r14
movq %r12, %r13
movq %r13, %rax
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x5ee8
movq 0x10(%rbx), %rbx
movq %rax, %r13
jmp 0x5e94
andq $0x0, 0x10(%r13)
jmp 0x5f07
movq %rbx, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glob.c
// Function: sort
static List *sort(List *s) {
	size_t nel = listnel(s);
	if (nel > 1) {
		char **a;
		List *t;
		qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
		for (t = s; t != NULL; t = t->n)
			t->w = *a++;
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x922f
cmpl $0x2, %eax
jb 0x5f63
movslq %eax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4fac
movq %rax, %r14
leaq 0x6015(%rip), %rcx      # 0xbf52
pushq $0x8
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3080
movq %rbx, %rax
testq %rax, %rax
je 0x5f63
movq (%r14), %rcx
addq $0x8, %r14
movq %rcx, (%rax)
movq 0x10(%rax), %rax
jmp 0x5f4e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glom.c
// Function: word
extern List *word(char *w, char *m) {
	List *s = NULL;
	if (w != NULL) {
		s = nnew(List);
		s->w = w;
		s->m = m;
		s->n = NULL;
	}
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x642b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x9928
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
andq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glom.c
// Function: append
extern List *append(List *s1, List *s2) {
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		r->w = s1->w;
		r->m = s1->m;
		if ((s1 = s1->n) == NULL)
			break;
	}
	r->n = s2;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x647d
movq %rdi, %r14
testq %rbx, %rbx
je 0x6482
pushq $0x18
popq %r12
movq %r12, %rdi
callq 0x9928
movq %rax, %r15
movq %rax, %r13
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x6477
movq %r12, %rdi
callq 0x9928
movq %rax, 0x10(%r13)
jmp 0x6456
movq %rbx, 0x10(%r13)
jmp 0x6485
movq %rbx, %r15
jmp 0x6485
movq %r14, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glom.c
// Function: concat
extern List *concat(List *s1, List *s2) {
	int n1, n2;
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	if ((n1 = listnel(s1)) != (n2 = listnel(s2)) && n1 != 1 && n2 != 1)
		rc_error("bad concatenation");
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		size_t x = strlen(s1->w);
		size_t y = strlen(s2->w);
		size_t z = x + y + 1;
		r->w = nalloc(z);
		strcpy(r->w, s1->w);
		strcat(r->w, s2->w);
		if (s1->m == NULL && s2->m == NULL) {
			r->m = NULL;
		} else {
			r->m = nalloc(z);
			if (s1->m == NULL)
				memzero(r->m, x);
			else
				memcpy(r->m, s1->m, x);
			if (s2->m == NULL)
				memzero(&r->m[x], y);
			else
				memcpy(&r->m[x], s2->m, y);
			r->m[z] = 0;
		}
		if (n1 > 1)
			s1 = s1->n;
		if (n2 > 1)
			s2 = s2->n;
		if (s1 == NULL || s2 == NULL || (n1 == 1 && n2 == 1))
			break;
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x660f
movq %rdi, %r14
testq %rbx, %rbx
je 0x6614
movq %r14, %rdi
callq 0x922f
movl %eax, %r15d
movq %rbx, %rdi
callq 0x922f
movl %eax, 0x8(%rsp)
cmpl $0x1, %eax
je 0x64ed
cmpl $0x1, %r15d
je 0x64ed
cmpl 0x8(%rsp), %r15d
je 0x64ed
leaq 0x81e4(%rip), %rdi      # 0xe6cc
callq 0x45b7
movl 0x8(%rsp), %ebp
xorl $0x1, %ebp
movl %r15d, 0xc(%rsp)
xorl $0x1, %r15d
pushq $0x18
popq %rdi
callq 0x9928
orl %ebp, %r15d
setne 0x7(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, %r15
movq (%r14), %rdi
callq 0x30f0
movq %rax, %r13
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %rbp
leaq (%rax,%r13), %r12
incq %r12
movq %r12, %rdi
callq 0x9928
movq %rax, (%r15)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3070
movq (%r15), %rdi
movq (%rbx), %rsi
callq 0x3310
cmpq $0x0, 0x8(%r14)
jne 0x6565
cmpq $0x0, 0x8(%rbx)
je 0x65fc
movq %r12, %rdi
callq 0x9928
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %rax, %rdi
testq %rsi, %rsi
je 0x6587
movq %r13, %rdx
callq 0x3230
jmp 0x6591
xorl %esi, %esi
movq %r13, %rdx
callq 0x3150
movq 0x8(%rbx), %rsi
addq 0x8(%r15), %r13
movq %r13, %rdi
testq %rsi, %rsi
je 0x65ab
movq %rbp, %rdx
callq 0x3230
jmp 0x65b5
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3150
movq 0x8(%r15), %rax
movb $0x0, (%rax,%r12)
cmpl $0x2, 0xc(%rsp)
jl 0x65c9
movq 0x10(%r14), %r14
cmpl $0x2, 0x8(%rsp)
jl 0x65d4
movq 0x10(%rbx), %rbx
testq %r14, %r14
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
andb 0x7(%rsp), %cl
cmpb $0x1, %cl
jne 0x6603
pushq $0x18
popq %rdi
callq 0x9928
movq %rax, 0x10(%r15)
jmp 0x6512
andq $0x0, 0x8(%r15)
jmp 0x65be
andq $0x0, 0x10(%r15)
movq 0x10(%rsp), %rax
jmp 0x6617
movq %rbx, %rax
jmp 0x6617
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glom.c
// Function: varsub
extern List *varsub(List *var, List *subs) {
	List *r, *top;
	int n = listnel(var);
	for (top = r = NULL; subs != NULL; subs = subs->n) {
		int i = a2u(subs->w);
		if (i < 1)
			rc_error("bad subscript");
		if (i <= n) {
			List *sub = var;
			while (--i)
				sub = sub->n; /* loop until sub == var(i) */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = sub->w;
			r->m = sub->m;
		}
	}
	if (top != NULL)
		r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
callq 0x922f
movl %eax, %ebp
movq $0x0, 0x8(%rsp)
pushq $0xa
popq %r15
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x66c0
movq (%rbx), %rdi
movl %r15d, %esi
callq 0xbf32
movl %eax, %r13d
testl %eax, %eax
jg 0x6676
leaq 0x806d(%rip), %rdi      # 0xe6de
callq 0x45b7
cmpl %ebp, %r13d
jg 0x66ba
decl %r13d
movq 0x10(%rsp), %r14
subl $0x1, %r13d
jb 0x668f
movq 0x10(%r14), %r14
jmp 0x6683
pushq $0x18
popq %rdi
callq 0x9928
movq %rax, %rcx
testq %r12, %r12
je 0x66ab
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %r12, %rcx
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq %rcx, %r12
movq %rax, 0x8(%rsp)
movq 0x10(%rbx), %rbx
jmp 0x6653
testq %r12, %r12
je 0x66cf
movq 0x8(%rsp), %rax
andq $0x0, 0x10(%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/glom.c
// Function: flatten
extern List *flatten(List *s) {
	List *r;
	size_t step;
	char *f;
	if (s == NULL || s->n == NULL)
		return s;
	r = nnew(List);
	f = r->w = nalloc(listlen(s) + 1);
	r->m = NULL; /* flattened lists come from variables, so no meta */
	r->n = NULL;
	strcpy(f, s->w);
	f += strlen(s->w);
	do {
		*f++ = ' ';
		s = s->n;
		step = strlen(s->w);
		memcpy(f, s->w, step);
		f += step;
	} while (s->n != NULL);
	*f = '\0';
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6781
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x6786
pushq $0x18
popq %rdi
callq 0x9928
movq %rax, %r14
movq %rbx, %rdi
callq 0x9202
leaq 0x1(%rax), %rdi
callq 0x9928
movq %rax, %r12
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x3070
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %r15
addq %r12, %r15
leaq 0x1(%r15), %r12
movb $0x20, (%r15)
movq 0x10(%rbx), %rbx
movq (%rbx), %r13
movq %r13, %rdi
callq 0x30f0
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3230
addq %rbp, %r15
incq %r15
cmpq $0x0, 0x10(%rbx)
jne 0x6746
movb $0x0, (%r15)
jmp 0x6789
xorl %r14d, %r14d
jmp 0x6789
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x67bc
leaq 0x7f35(%rip), %rdi      # 0xe6ec
callq 0x45b7
cmpq $0x0, 0x10(%rbx)
je 0x67cf
leaq 0x7f35(%rip), %rdi      # 0xe6ff
callq 0x45b7
movq (%rbx), %rdi
cmpb $0x0, (%rdi)
jne 0x67e6
leaq 0x7f3a(%rip), %rdi      # 0xe718
callq 0x45b7
movq (%rbx), %rdi
pushq $0xa
popq %rsi
callq 0xbf32
cmpl $-0x1, %eax
je 0x67ff
leaq 0x7f38(%rip), %rdi      # 0xe732
callq 0x45b7
movq (%rbx), %r12
pushq $0x3d
popq %rsi
movq %r12, %rdi
callq 0x3120
testq %rax, %rax
je 0x6821
leaq 0x7f2f(%rip), %rdi      # 0xe748
callq 0x45b7
movq (%rbx), %r12
cmpb $0x2a, (%r12)
movq %r14, %r15
jne 0x6850
cmpb $0x0, 0x1(%r12)
movq %r14, %r15
jne 0x6850
leaq 0xc784(%rip), %rdi      # 0x12fc1
callq 0xc16d
movq %rax, %rdi
movq %r14, %rsi
callq 0x642e
movq %rax, %r15
testq %r14, %r14
sete %cl
testl %ebp, %ebp
sete %dl
leaq 0x1338e(%rip), %rax     # 0x19bf0
movl (%rax), %eax
movq (%rbx), %rsi
testb %dl, %cl
jne 0x68aa
testl %eax, %eax
je 0x687d
pushq $0x2
popq %rdi
movq %r15, %rdx
callq 0xc4c9
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xbfac
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0xc16d
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc128
testl %eax, %eax
je 0x68bb
pushq $0x2
popq %rdi
xorl %edx, %edx
callq 0xc4c9
movq (%rbx), %rsi
movq %rsi, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc2ae
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x131ed(%rip), %rax     # 0x19ac8
testq %rax, %rax
je 0x68f2
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x68e0
addq $0x8, %r14
jmp 0x68f9
leaq 0x131cf(%rip), %r14     # 0x19ac8
pushq $0x10
popq %rdi
callq 0x9928
movq %rax, (%r14)
movq %rbx, (%rax)
andq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movl $0x400, %edi            # imm = 0x400
callq 0x9a83
movq %rax, 0x12b5a(%rip)     # 0x19ad0
movl $0x400, %edi            # imm = 0x400
callq 0x9a83
movq %rax, 0x12b51(%rip)     # 0x19ad8
andl $0x0, 0x12b52(%rip)     # 0x19ae0
andl $0x0, 0x12b4f(%rip)     # 0x19ae4
pushq $0x40
popq %rcx
movl %ecx, 0x12b4a(%rip)     # 0x19ae8
movl %ecx, 0x12b48(%rip)     # 0x19aec
xorl %ecx, %ecx
movq 0x12b23(%rip), %rdx     # 0x19ad0
cmpl $0x400, %ecx            # imm = 0x400
je 0x6fc5
andq $0x0, (%rdx,%rcx)
andq $0x0, (%rax,%rcx)
addq $0x10, %rcx
jmp 0x6fad
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x7a48
movl %eax, %ebp
decl %ebx
movl %ebp, %eax
shlq $0x4, %rax
movq (%r14,%rax), %rdi
testq %rdi, %rdi
je 0x7047
movb (%rdi), %al
cmpb (%r15), %al
jne 0x7041
movq %r15, %rsi
callq 0x31f0
testl %eax, %eax
je 0x7047
incl %ebp
andl %ebx, %ebp
jmp 0x701f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x12a6d(%rip), %r14     # 0x19ad0
movl 0x12a83(%rip), %edx     # 0x19aec
movq %r14, %rsi
callq 0x7005
movb $0x0, 0x12a78(%rip)     # 0x19af0
movl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
cmpq $0x0, (%r14,%rax)
je 0x7097
addq %rax, %r14
movq 0x8(%r14), %rdi
callq 0x7286
jmp 0x7106
movq %r14, %rdi
callq 0x711c
testl %eax, %eax
je 0x70bb
movq 0x12a26(%rip), %rsi     # 0x19ad0
movl 0x12a3c(%rip), %edx     # 0x19aec
movq %rbx, %rdi
callq 0x7005
movl %eax, %r15d
incl 0x12a23(%rip)           # 0x19ae4
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0x9a83
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq 0x129e9(%rip), %rax     # 0x19ad0
movq %r15, %rbx
shlq $0x4, %rbx
movq %r14, (%rax,%rbx)
pushq $0x10
popq %rdi
callq 0x9a83
movq 0x129cf(%rip), %rcx     # 0x19ad0
movq %rax, 0x8(%rcx,%rbx)
movq 0x129c3(%rip), %rax     # 0x19ad0
shlq $0x4, %r15
movq 0x8(%rax,%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/hash.c
// Function: rehash
static bool rehash(Htab *ht) {
	int i, j, size;
	int newsize, newused;
	Htab *newhtab;
	if (ht == fp) {
		if (fsize > 2 * fused)
			return FALSE;
		size = fsize;
	} else {
		if (vsize > 2 * vused)
			return FALSE;
		size = vsize;
	}
	newsize = 2 * size;
	newhtab = ealloc(newsize * sizeof(Htab));
	for (i = 0; i < newsize; i++)
		newhtab[i].name = NULL;
	for (i = newused = 0; i < size; i++)
		if (ht[i].name != NULL && ht[i].name != dead) {
			newused++;
			j = hash(ht[i].name, newsize);
			while (newhtab[j].name != NULL) {
				j++;
				j &= (newsize - 1);
			}
			newhtab[j].name = ht[i].name;
			newhtab[j].p = ht[i].p;
		}
	if (ht == fp) {
		fused = newused;
		fp = newhtab;
		fsize = newsize;
	} else {
		vused = newused;
		vp = newhtab;
		vsize = newsize;
	}
	efree(ht);
	return TRUE;
}

// Assembly:
cmpq %rdi, 0x129ad(%rip)     # 0x19ad0
je 0x7133
movl 0x129bd(%rip), %ecx     # 0x19ae8
movl 0x129af(%rip), %eax     # 0x19ae0
jmp 0x713f
movl 0x129b3(%rip), %ecx     # 0x19aec
movl 0x129a5(%rip), %eax     # 0x19ae4
addl %eax, %eax
cmpl %eax, %ecx
jle 0x7148
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rcx, %r12
leal (%rcx,%rcx), %r14d
movslq %r14d, %rbx
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x9a83
movq %rax, %r15
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
movq %r14, (%rsp)
cmovgl %r14d, %ecx
shlq $0x4, %rcx
cmpq %rax, %rcx
je 0x7199
andq $0x0, (%r15,%rax)
addq $0x10, %rax
jmp 0x7189
movq (%rsp), %rax
leal -0x1(%rax), %r14d
xorl %ebx, %ebx
movq %r12, %rdx
testl %edx, %edx
cmovlel %ebx, %edx
leaq 0x7c75(%rip), %rsi      # 0xee27
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rbx
je 0x7227
movq %rbx, %r13
shlq $0x4, %r13
movq (%rdi,%r13), %r12
testq %r12, %r12
sete %al
cmpq %rsi, %r12
sete %cl
orb %al, %cl
jne 0x7222
addq %rdi, %r13
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x7a48
movl %eax, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%r15,%rcx)
je 0x7201
incl %eax
andl %r14d, %eax
jmp 0x71ed
addq %r15, %rcx
incl %ebp
movq %r12, (%rcx)
movq 0x8(%r13), %rax
movq %rax, 0x8(%rcx)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x7c05(%rip), %rsi      # 0xee27
incq %rbx
jmp 0x71be
cmpq %rdi, 0x128a2(%rip)     # 0x19ad0
leaq 0x128af(%rip), %rax     # 0x19ae4
leaq 0x128a4(%rip), %rcx     # 0x19ae0
cmoveq %rax, %rcx
leaq 0x12889(%rip), %rax     # 0x19ad0
leaq 0x1288a(%rip), %rdx     # 0x19ad8
cmoveq %rax, %rdx
leaq 0x12893(%rip), %rax     # 0x19aec
leaq 0x12888(%rip), %rsi     # 0x19ae8
cmoveq %rax, %rsi
movl %ebp, (%rcx)
movq %r15, (%rdx)
movq (%rsp), %rax
movl %eax, (%rsi)
callq 0x9a5c
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x12828(%rip), %r14     # 0x19ad8
movl 0x12832(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x7005
movb $0x0, 0x1282b(%rip)     # 0x19af0
movl %eax, %r15d
movq %r15, %r12
shlq $0x4, %r12
cmpq $0x0, (%r14,%r12)
je 0x7303
testl %ebp, %ebp
je 0x7382
pushq $0x18
popq %rdi
callq 0x9a83
movq %rax, %rbx
movq 0x127e8(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%r12), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, 0x8(%rax,%r12)
jmp 0x739a
movq %r14, %rdi
callq 0x711c
testl %eax, %eax
je 0x7327
movq 0x127c2(%rip), %rsi     # 0x19ad8
movl 0x127cc(%rip), %edx     # 0x19ae8
movq %rbx, %rdi
callq 0x7005
movl %eax, %r15d
incl 0x127b3(%rip)           # 0x19ae0
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0x9a83
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq 0x12785(%rip), %rax     # 0x19ad8
shlq $0x4, %r15
movq %r14, (%rax,%r15)
pushq $0x18
popq %rdi
callq 0x9a83
movq 0x1276e(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%r15)
movq 0x12762(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%r15), %rbx
andq $0x0, 0x10(%rbx)
jmp 0x739a
addq %r12, %r14
movq 0x8(%r14), %rbx
movq 0x8(%rbx), %rdi
callq 0x9a5c
movq (%rbx), %rdi
callq 0x9158
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x1271e(%rip), %rbx     # 0x19ad0
movl 0x12734(%rip), %edx     # 0x19aec
movq %rbx, %rsi
callq 0x7005
movl %eax, %r15d
movq %r15, %r14
shlq $0x4, %r14
cmpq $0x0, (%rbx,%r14)
je 0x743b
movb $0x0, 0x12718(%rip)     # 0x19af0
movq 0x8(%rbx,%r14), %rdi
callq 0x7286
movq 0x126e7(%rip), %rax     # 0x19ad0
movq 0x8(%rax,%r14), %rdi
callq 0x9a5c
movq 0x126d6(%rip), %rax     # 0x19ad0
movq (%rax,%r14), %rdi
callq 0x9a5c
movq 0x126c6(%rip), %rax     # 0x19ad0
incl %r15d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x126d4(%rip), %ecx     # 0x19aec
andl %r15d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x742f
leaq 0x79fa(%rip), %rcx      # 0xee27
jmp 0x7437
decl 0x126af(%rip)           # 0x19ae4
xorl %ecx, %ecx
movq %rcx, (%rax,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x12686(%rip), %r14     # 0x19ad8
movl 0x12690(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x7005
movl %eax, %r12d
movq %r12, %r15
shlq $0x4, %r15
cmpq $0x0, (%r14,%r15)
je 0x7527
movb $0x0, 0x12674(%rip)     # 0x19af0
movq 0x8(%r14,%r15), %r14
movq 0x8(%r14), %rdi
callq 0x9a5c
movq (%r14), %rdi
callq 0x9158
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x74be
testl %ebx, %ebx
je 0x7513
movq 0x12632(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%r15)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9a5c
movq %r14, %rdi
callq 0x9a5c
movq 0x1260b(%rip), %rax     # 0x19ad8
andq $0x0, 0x8(%rax,%r15)
movq 0x125fe(%rip), %rax     # 0x19ad8
movq (%rax,%r15), %rdi
callq 0x9a5c
movq 0x125ee(%rip), %rax     # 0x19ad8
incl %r12d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x125f0(%rip), %ecx     # 0x19ae8
andl %r12d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x751c
leaq 0x791a(%rip), %rcx      # 0xee27
movq %rcx, (%rax,%r15)
jmp 0x7527
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x7527
decl 0x125be(%rip)           # 0x19ae0
andq $0x0, (%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %rax
movq %rdi, %rcx
incl %eax
cmpq $0x0, (%rcx)
leaq 0x8(%rcx), %rcx
jne 0x7540
cmpl $0x40, %eax
pushq $0x3f
popq %rcx
cmovael %eax, %ecx
leal 0x2(,%rcx,2), %eax
movl %eax, 0x12592(%rip)     # 0x19af4
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x9a83
movq %rax, 0x12583(%rip)     # 0x19af8
leaq 0x12668(%rip), %r14     # 0x19be4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x75cf
cmpb $0x66, (%rdi)
jne 0x75a2
cmpb $0x6e, 0x1(%rdi)
jne 0x75a2
cmpb $0x5f, 0x2(%rdi)
jne 0x75a2
cmpl $0x0, (%r14)
jne 0x75c9
callq 0x4df2
jmp 0x75c9
callq 0xc020
testl %eax, %eax
jne 0x75c9
movq (%rbx), %rax
movq 0x12543(%rip), %rcx     # 0x19af8
movslq 0x12544(%rip), %rdx     # 0x19b00
leal 0x1(%rdx), %esi
movl %esi, 0x1253b(%rip)     # 0x19b00
movq %rax, (%rcx,%rdx,8)
addq $0x8, %rbx
jmp 0x757c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x11d12(%rip), %r12     # 0x19300
cmpq $0x20, %r15
je 0x761d
cmpl %ebx, 0x8(%r15,%r12)
je 0x7617
movb (%r14), %al
movq (%r15,%r12), %rsi
cmpb (%rsi), %al
jne 0x7617
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
jne 0x7617
movl %ebx, 0x8(%r15,%r12)
addq $0x10, %r15
jmp 0x75ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
je 0x78e8
xorl %r14d, %r14d
pushq $0x1
popq %rbp
xorl %r15d, %r15d
movslq 0x1223d(%rip), %rax     # 0x19ae8
cmpq %rax, %r15
jge 0x78e8
movq 0x12221(%rip), %rax     # 0x19ad8
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x78df
callq 0xc16d
testq %rax, %rax
je 0x78df
movq 0x12207(%rip), %rcx     # 0x19ad8
movq (%rcx,%r14), %rsi
movl %ebp, %edi
movq %rax, %rdx
callq 0xc4c9
incq %r15
addq $0x10, %r14
jmp 0x78a4
testl %ebx, %ebx
je 0x7949
movl 0x121fa(%rip), %eax     # 0x19aec
xorl %r15d, %r15d
leaq 0x752b(%rip), %r12      # 0xee27
pushq $0x1
popq %rbx
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x7949
movq 0x121bf(%rip), %rcx     # 0x19ad0
movq (%rcx,%r15), %r14
testq %r14, %r14
sete %cl
cmpq %r12, %r14
sete %dl
orb %cl, %dl
jne 0x7940
movq %r14, %rdi
callq 0x4e40
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4f96
movl 0x121ac(%rip), %eax     # 0x19aec
incq %r13
addq $0x10, %r15
jmp 0x7902
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %rcx
testl %esi, %esi
movq %rdi, (%rsp)
je 0x798b
movq 0x12195(%rip), %r15     # 0x19b10
movq 0x12186(%rip), %r12     # 0x19b08
movq 0x1218f(%rip), %r13     # 0x19b18
jmp 0x79b6
movq %rdx, %r12
movq %rdx, 0x12173(%rip)     # 0x19b08
andq $0x0, 0x12173(%rip)     # 0x19b10
movq %rcx, %rdi
callq 0x30f0
movq (%rsp), %rcx
movq %rax, %r13
movq %rax, 0x12165(%rip)     # 0x19b18
xorl %r15d, %r15d
shlq $0x3, %rbx
xorl %eax, %eax
testq %rax, %rax
jne 0x7a0b
cmpq %r14, %r15
jae 0x7a0b
movq (%r12), %rbp
testq %rbp, %rbp
je 0x79e5
movq %rbp, %rdi
movq %rcx, %rsi
movq %r13, %rdx
callq 0x3060
testl %eax, %eax
je 0x79e9
xorl %eax, %eax
jmp 0x79f1
xorl %eax, %eax
jmp 0x79f5
movq %rbp, %rdi
callq 0x3350
movq (%rsp), %rcx
incq %r15
movq %r15, 0x12111(%rip)     # 0x19b10
addq %rbx, %r12
movq %r12, 0x120ff(%rip)     # 0x19b08
jmp 0x79bc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
xorl %ecx, %ecx
movsbl (%rdi), %edx
testl %edx, %edx
je 0x7adb
movl %edx, %esi
shll $0x11, %esi
movl %edx, %r8d
shll $0xb, %r8d
xorl %esi, %r8d
movl %edx, %esi
shll $0x5, %esi
sarl %edx
xorl %esi, %edx
xorl %r8d, %edx
addl %ecx, %edx
movsbl 0x1(%rdi), %ecx
testl %ecx, %ecx
je 0x7ad5
imull $0x4091, %ecx, %esi     # imm = 0x4091
xorl %edx, %esi
movsbl 0x2(%rdi), %ecx
testl %ecx, %ecx
je 0x7ad9
movl %ecx, %edx
notl %edx
shll $0xb, %edx
leal (,%rcx,8), %r8d
sarl %ecx
xorl %r8d, %ecx
orl %edx, %ecx
xorl %esi, %ecx
movsbl 0x3(%rdi), %edx
testl %edx, %edx
je 0x7adb
movl %edx, %esi
shll $0x10, %esi
movl %edx, %r8d
shll $0x9, %r8d
orl %esi, %r8d
leal (,%rdx,4), %esi
orl %r8d, %esi
andl $0x3, %edx
orl %esi, %edx
subl %edx, %ecx
addq $0x4, %rdi
jmp 0x7a4c
movl %edx, %ecx
jmp 0x7adb
movl %esi, %ecx
movl %ecx, %edx
sarl $0x1f, %edx
xorl %ecx, %edx
decl %eax
andl %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/heredoc.c
// Function: qdoc
extern int qdoc(Node *name, Node *n) {
	Hq *new, **prev;
	if (name->type != nWord) {
		yyerror("eof-marker not a single literal word");
		skiptonl();
		return FALSE;
	}
	for (prev = &hq; (new = *prev) != NULL; prev = &new->n)
		;
	*prev = new = nnew(Hq);
	new->name = name->u[0].s;
	new->quoted = name->u[2].i;
	new->doc = n;
	new->n = NULL;
	return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1e, (%rdi)
jne 0x7e0c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x11d4a(%rip), %rax     # 0x19b20
movq %rax, %r15
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x7dd6
pushq $0x20
popq %rdi
callq 0x9928
movq %rax, (%r15)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl 0x18(%r14), %ecx
movl %ecx, 0x18(%rax)
movq %rbx, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x1
popq %rax
jmp 0x7e1f
leaq 0x69b2(%rip), %rdi      # 0xe7c5
callq 0x902d
callq 0x8094
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x11cc7(%rip), %rax     # 0x19b30
movslq 0x14(%rax), %rcx
testq %rcx, %rcx
je 0x7e84
leaq -0x1(%rcx), %rdx
movl %edx, 0x14(%rax)
movl 0x2c(%rax,%rcx,4), %eax
movl %eax, 0x11cb5(%rip)     # 0x19b38
retq
pushq %rbx
leaq 0x6998(%rip), %rbx      # 0xe824
callq *0x38(%rax)
testl %eax, %eax
jne 0x7ea6
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbe58
movq 0x11c8c(%rip), %rax     # 0x19b30
jmp 0x7e8c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/input.c
// Function: pushfd
extern void pushfd(int fd) {
	pushcommon();
	save_lineno = TRUE;
	istack->fd = fd;
	lineno = 1;
	if (editing && interactive && isatty(fd)) {
		istack->t = iEdit;
		istack->gchar = editgchar;
		istack->cookie = edit_begin(fd);
	} else {
		istack->t = iFd;
		istack->gchar = fdgchar;
		inbuf = ealloc(BUFSIZE);
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x835d
pushq $0x1
popq %rax
movl %eax, 0x1141f(%rip)     # 0x19320
movq 0x11c28(%rip), %rcx     # 0x19b30
movl %ebx, 0x8(%rcx)
leaq 0x11c86(%rip), %rdx     # 0x19b98
movl %eax, (%rdx)
leaq 0x11859(%rip), %rax     # 0x19774
cmpl $0x0, (%rax)
je 0x7f64
leaq 0x11cad(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x7f64
movl %ebx, %edi
callq 0x3090
movq 0x11bf6(%rip), %rcx     # 0x19b30
testl %eax, %eax
je 0x7f64
movl $0x2, 0x4(%rcx)
leaq 0x4be(%rip), %rax       # 0x840a
movq %rax, 0x38(%rcx)
movl %ebx, %edi
callq 0x4308
movq 0x11bd2(%rip), %rcx     # 0x19b30
movq %rax, 0x28(%rcx)
jmp 0x7f84
andl $0x0, 0x4(%rcx)
leaq 0x5ee(%rip), %rax       # 0x855d
movq %rax, 0x38(%rcx)
movl $0x100, %edi            # imm = 0x100
callq 0x9a83
movq %rax, 0x11bcc(%rip)     # 0x19b50
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/input.c
// Function: pushstring
extern void pushstring(char **a, bool save) {
	pushcommon();
	istack->t = iString;
	save_lineno = save;
	inbuf = mprint("%A", a);
	istack->gchar = stringgchar;
	if (save_lineno)
		lineno = 1;
	else
		--lineno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x835d
movq 0x11b95(%rip), %rax     # 0x19b30
pushq $0x1
popq %rbp
movl %ebp, 0x4(%rax)
movl %ebx, 0x11379(%rip)     # 0x19320
leaq 0x6145(%rip), %rdi      # 0xe0f3
movq %r14, %rsi
xorl %eax, %eax
callq 0xa9f3
movq %rax, 0x11b91(%rip)     # 0x19b50
movq 0x11b6a(%rip), %rax     # 0x19b30
leaq 0x6d5(%rip), %rcx       # 0x86a2
movq %rcx, 0x38(%rax)
leaq 0x11bc0(%rip), %rax     # 0x19b98
movl (%rax), %ecx
decl %ecx
cmpl $0x0, 0x1133d(%rip)     # 0x19320
cmovnel %ebp, %ecx
movl %ecx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq