LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: cmd_loop
static void
cmd_loop(bool halt)
{
	bool gz;

	sh_magic();

	for (error_source = gz = false; ; ) {
		if (PROMPT)
			fd_print(FD2, "%s", (sheuid != 0) ? "% " : "# ");
		if (rpx_line() == EOF) {
			if (!gz)
				status = SH_TRUE;
			break;
		}
		if (halt && error_source)
			break;
		if (is_login && logout_now != 0)
			break;
		gz = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
callq 0x3600
movb $0x0, -0x2(%rbp)
movb $0x0, 0xb010(%rip)      # 0xe270
movl 0xafd6(%rip), %eax      # 0xe23c
andl $0x1f, %eax
cmpl $0x4, %eax
jne 0x329c
movl 0xaff8(%rip), %ecx      # 0xe26c
leaq 0x8437(%rip), %rdx      # 0xb6b2
leaq 0x842d(%rip), %rax      # 0xb6af
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl $0x2, %edi
leaq 0x87be(%rip), %rsi      # 0xba53
movb $0x0, %al
callq 0x8d40
callq 0x3010
cmpl $-0x1, %eax
jne 0x32b8
testb $0x1, -0x2(%rbp)
jne 0x32b6
movl $0x0, 0xafb2(%rip)      # 0xe268
jmp 0x32e8
testb $0x1, -0x1(%rbp)
je 0x32c9
testb $0x1, 0xafab(%rip)      # 0xe270
je 0x32c9
jmp 0x32e8
testb $0x1, 0xaf78(%rip)      # 0xe248
je 0x32df
movl 0xaf78(%rip), %eax      # 0xe250
cmpl $0x0, %eax
je 0x32df
jmp 0x32e8
movb $0x1, -0x2(%rbp)
jmp 0x3260
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: rc_logout
static void
rc_logout(int *rcflag)
{
	char path[PATHMAX];
	const char *file;

	if (!is_login) {
		shtype &= ~ST_RCFILE;
		return;
	}

	while (*rcflag <= DO_LOGOUT_DONE) {
		file = NULL;
		switch (*rcflag) {
		case DO_SYSTEM_LOGOUT:
			file = PATH_SYSTEM_LOGOUT;
			break;
		case DO_DOT_LOGOUT:
			file = pn_build(path, FILE_DOT_LOGOUT, sizeof(path));
			break;
		case DO_LOGOUT_DONE:
			shtype &= ~ST_RCFILE;
			(*rcflag)++;
			return;
		default:
			shtype &= ~ST_RCFILE;
			return;
		}
		(*rcflag)++;
		if (rc_open(file))
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
testb $0x1, 0xaf42(%rip)      # 0xe248
jne 0x331c
movl 0xaf2e(%rip), %eax      # 0xe23c
andl $-0x9, %eax
movl %eax, 0xaf25(%rip)      # 0xe23c
jmp 0x33e5
jmp 0x331e
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jg 0x33e5
movq $0x0, -0x1018(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x101c(%rbp)
subl $0x1, %eax
je 0x3363
jmp 0x3349
movl -0x101c(%rbp), %eax
subl $0x2, %eax
je 0x3373
jmp 0x3356
movl -0x101c(%rbp), %eax
subl $0x3, %eax
je 0x3394
jmp 0x33b0
leaq 0x86fb(%rip), %rax      # 0xba65
movq %rax, -0x1018(%rbp)
jmp 0x33c1
leaq -0x1010(%rbp), %rdi
leaq 0x86fe(%rip), %rsi      # 0xba7f
movl $0x1000, %edx           # imm = 0x1000
callq 0x8900
movq %rax, -0x1018(%rbp)
jmp 0x33c1
movl 0xaea2(%rip), %eax      # 0xe23c
andl $-0x9, %eax
movl %eax, 0xae99(%rip)      # 0xe23c
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x33e5
movl 0xae86(%rip), %eax      # 0xe23c
andl $-0x9, %eax
movl %eax, 0xae7d(%rip)      # 0xe23c
jmp 0x33e5
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x1018(%rbp), %rdi
callq 0x89d0
testb $0x1, %al
jne 0x33de
jmp 0x33e0
jmp 0x33e5
jmp 0x331e
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: afree
static void
afree(const char *name)
{
	struct anode *a, *p;

	if (name != NULL) {
		a = anp;
		p = a;
		while (a != NULL) {
			if (EQUAL(name, a->name)) {
				if (a == anp)
					anp = a->next;
				else
					p->next = a->next;
				xfree(a->name);
				xfree(a->string);
				xfree(a);
				break;
			}
			p = a;
			a = a->next;
		}
	} else {
		a = anp;
		while (a != NULL) {
			p = a;
			xfree(a->name);
			xfree(a->string);
			a = a->next;
			xfree(p);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34eb
movq 0xd6ca(%rip), %rax      # 0x10b08
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34e9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x34d1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2230
cmpl $0x0, %eax
jne 0x34d1
movq -0x10(%rbp), %rax
cmpq 0xd67c(%rip), %rax      # 0x10b08
jne 0x349e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xd66c(%rip)      # 0x10b08
jmp 0x34ac
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x33f0
movq -0x10(%rbp), %rdi
callq 0x33f0
jmp 0x34e9
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x344a
jmp 0x3537
movq 0xd616(%rip), %rax      # 0x10b08
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3535
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x33f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33f0
jmp 0x34f6
jmp 0x3537
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: cmd_lookup
enum sbikey
cmd_lookup(const char *cmd)
{
	const struct sbicmd *lp, *mp, *rp;
	int d;

	for (lp = sbi, rp = &sbi[NSBICMD]; lp < rp; /* nothing */) {
		mp = lp + (rp - lp) / 2;
		if ((d = strcmp(cmd, mp->sbi_command)) == 0)
			return mp->sbi_key;
		if (d > 0)
			lp = mp + 1;
		else
			rp = mp;
	}

	return SBI_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xa6dd(%rip), %rax      # 0xdc30
movq %rax, -0x18(%rbp)
leaq 0xa6d2(%rip), %rax      # 0xdc30
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x35e7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x2230
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x35c9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x35ee
cmpl $0x0, -0x2c(%rbp)
jle 0x35dd
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x35e5
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3568
movl $0x14, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: sh_magic
static void
sh_magic(void)
{
	size_t len;
	int c;

	if (fd_type(FD0, FD_ISREG) && lseek(FD0, (off_t)0, SEEK_CUR) == 0) {
		if (readc() == HASH && readc() == BANG) {
			for (len = 2; len < LINEMAX; len++)
				if ((c = readc()) == EOL || c == EOF)
					return;
			err(-1, FMT2S, getmyname(), ERR_TMCHARS);
		} else
			(void)lseek(FD0, (off_t)0, SEEK_SET);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movl $0x8000, %esi           # imm = 0x8000
callq 0x2b90
testb $0x1, %al
jne 0x361d
jmp 0x36b1
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x21a0
cmpq $0x0, %rax
jne 0x36b1
callq 0x36c0
cmpl $0x23, %eax
jne 0x36a2
callq 0x36c0
cmpl $0x21, %eax
jne 0x36a2
movq $0x2, -0x8(%rbp)
cmpq $0x800, -0x8(%rbp)      # imm = 0x800
jae 0x367e
callq 0x36c0
movl %eax, -0xc(%rbp)
cmpl $0xa, %eax
je 0x366c
cmpl $-0x1, -0xc(%rbp)
jne 0x366e
jmp 0x36b1
jmp 0x3670
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x364f
callq 0x8df0
movq %rax, %rdx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x810f(%rip), %rsi      # 0xb7a1
leaq 0x801c(%rip), %rcx      # 0xb6b5
movb $0x0, %al
callq 0x8af0
jmp 0x36af
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %edi
callq 0x21a0
jmp 0x36b1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: readc
static int
readc(void)
{
	UChar c;

	if (asp != NULL) {
		if (asp == (char *)-1)
			return EOF;
		if ((c = UCHAR(*asp++)) == EOS) {
			asp = (char *)-1;
			c = UCHAR(EOL);
		}
		return c;
	}
	if (argv2p != NULL) {
		if (argv2p == (char *)-1)
			return EOF;
		if ((c = UCHAR(*argv2p++)) == EOS) {
			argv2p = (char *)-1;
			c = UCHAR(EOL);
		}
		return c;
	}
	if (read(FD0, &c, (size_t)1) != 1)
		return EOF;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xaba8(%rip)      # 0xe278
je 0x372e
movq $-0x1, %rax
cmpq %rax, 0xab98(%rip)      # 0xe278
jne 0x36ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b4
movq 0xab83(%rip), %rax      # 0xe278
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xab75(%rip)      # 0xe278
movb (%rax), %al
movb %al, -0x5(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3722
movq $-0x1, %rax
movq %rax, 0xab5a(%rip)      # 0xe278
movb $0xa, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37b4
cmpq $0x0, 0xab0a(%rip)      # 0xe240
je 0x378e
movq $-0x1, %rax
cmpq %rax, 0xaafa(%rip)      # 0xe240
jne 0x3751
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b4
movq 0xaae8(%rip), %rax      # 0xe240
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xaada(%rip)      # 0xe240
movb (%rax), %al
movb %al, -0x5(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3785
movq $-0x1, %rax
movq %rax, 0xaabf(%rip)      # 0xe240
movb $0xa, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37b4
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x2200
cmpq $0x1, %rax
je 0x37ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b4
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: cmd_verbose
static void
cmd_verbose(void)
{
	char **vp;

	if (!verbose_flag)
		return;
	for (vp = word; **vp != EOL; vp++)
		fd_print(FD2, "%s%s", *vp, (**(vp + 1) != EOL) ? " " : "");
	fd_print(FD2, FMT1S, "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0xa711(%rip)      # 0xe220
jne 0x3b13
jmp 0x3b8f
leaq 0xaf76(%rip), %rax      # 0xea90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x3b75
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %esi
leaq 0x7bf1(%rip), %rcx      # 0xb737
leaq 0x7b66(%rip), %rax      # 0xb6b3
cmpl $0xa, %esi
cmovneq %rax, %rcx
movl $0x2, %edi
leaq 0x7bcf(%rip), %rsi      # 0xb72f
movb $0x0, %al
callq 0x8d40
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3b1e
movl $0x2, %edi
leaq 0x7c24(%rip), %rsi      # 0xb7a5
leaq 0x7baf(%rip), %rdx      # 0xb737
movb $0x0, %al
callq 0x8d40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: hist_write
static void
hist_write(bool hwflag)
{
	char **vp;

	if (hwfd == -1 || !hwflag)
		return;
	if (!fd_type(hwfd, FD_ISREGOK)) {
		if (close(hwfd) != -1)
			hwfd = -1;
		return;
	}
	for (vp = word; **vp != EOL; vp++)
		fd_print(hwfd, "%s%s", *vp, (**(vp + 1) != EOL) ? " " : "");
	fd_print(hwfd, FMT1S, "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
cmpl $-0x1, 0xa641(%rip)     # 0xe1f8
je 0x3bbf
testb $0x1, -0x1(%rbp)
jne 0x3bc4
jmp 0x3c72
movl 0xa62e(%rip), %edi      # 0xe1f8
movl $0x4, %esi
callq 0x2b90
testb $0x1, %al
jne 0x3bf4
movl 0xa61a(%rip), %edi      # 0xe1f8
callq 0x21d0
cmpl $-0x1, %eax
je 0x3bf2
movl $0xffffffff, 0xa606(%rip) # imm = 0xFFFFFFFF
jmp 0x3c72
leaq 0xae95(%rip), %rax      # 0xea90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x3c57
movl 0xa5e4(%rip), %edi      # 0xe1f8
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %esi
leaq 0x7b0a(%rip), %rcx      # 0xb737
leaq 0x7a7f(%rip), %rax      # 0xb6b3
cmpl $0xa, %esi
cmovneq %rax, %rcx
leaq 0x7aed(%rip), %rsi      # 0xb72f
movb $0x0, %al
callq 0x8d40
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x3bff
movl 0xa59b(%rip), %edi      # 0xe1f8
leaq 0x7b41(%rip), %rsi      # 0xb7a5
leaq 0x7acc(%rip), %rdx      # 0xb737
movb $0x0, %al
callq 0x8d40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: tfree
static void
tfree(struct tnode *t)
{

	if (t == NULL)
		return;
	switch (t->ntype) {
	case TLIST:
	case TPIPE:
		tfree(t->nleft);
		tfree(t->nright);
		break;
	case TCOMMAND:
		xfree(t->nfin);
		xfree(t->nfout);
		vfree(t->nav);
		break;
	case TSUBSHELL:
		xfree(t->nfin);
		xfree(t->nfout);
		tfree(t->nsub);
		break;
	}
	xfree(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4138
jmp 0x41d3
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
decl %eax
subl $0x2, %eax
jb 0x415f
jmp 0x414b
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x417a
jmp 0x4155
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x41a3
jmp 0x41ca
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4120
jmp 0x41ca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5400
jmp 0x41ca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4120
movq -0x8(%rbp), %rdi
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: xstrdup
static char *
xstrdup(const char *src)
{
	size_t siz;
	char *dst;

	siz = strlen(src) + 1;
	dst = xmalloc(siz);
	(void)memcpy(dst, src, siz);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ae0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: asget
static const char *
asget(const char *name)
{
	struct anode *a;
	const char *as;

	as = NULL;
	a  = anp;
	while (a != NULL) {
		if (EQUAL(name, a->name)) {
			as = a->string;
			break;
		}
		a = a->next;
	}
	return as;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq 0xb9ed(%rip), %rax      # 0x10b08
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x516d
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5160
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2230
cmpl $0x0, %eax
jne 0x5160
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x516d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x511f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: vfree
static void
vfree(char **vp)
{
	char **p;

	if (vp != NULL) {
		for (p = vp; *p != NULL; p++) {
			free(*p);
			*p = NULL;
		}
		free(vp);
		vp = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x545b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x544a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2050
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x541b
movq -0x8(%rbp), %rdi
callq 0x2050
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: vtglob
static bool
vtglob(char **vp)
{
	char **p;

	for (p = vp; *p != NULL; p++)
		if (gchar(*p) != NULL)
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54b6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6600
cmpq $0x0, %rax
je 0x54a6
movb $0x1, -0x1(%rbp)
jmp 0x54ba
jmp 0x54a8
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x5484
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: glob
static const char **
glob(enum sbikey key, char **av)
{
	char *gp, **sav;
	const char **gav;	/* points to generated argument vector */
	int pmc = 0;		/* pattern-match count                 */
	bool gerr = false;	/* glob error flag                     */

	gavtot = 0;

	sav  = av;
	gav  = xmalloc(GAVNEW * sizeof(char *));
	*gav = NULL, gavp = gav;
	gave = &gav[GAVNEW - 1];
	while (*av != NULL) {
		if ((gp = gtrim(UCPTR(*av))) == NULL) {
			gerr = true;
			break;
		}
		gav = glob1(key, gav, gp, &pmc, &gerr);
		if (gerr)
			break;
		av++;
	}
	gavp = NULL;

	if (pmc == 0 && !gerr) {
		err(-2, FMT2S, getmyname(), ERR_NOMATCH);
		gerr = true;
	}
	if (gerr)
		vfree((char **)gav);
	vfree(sav);

	return gerr ? NULL : gav;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movb $0x0, -0x2d(%rbp)
movq $0x0, 0xde1b(%rip) # 0x13310
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x4ae0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, 0xddf7(%rip)      # 0x13318
movq -0x28(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movq %rax, 0xddee(%rip)      # 0x13320
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x558a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6710
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5558
movb $0x1, -0x2d(%rbp)
jmp 0x558a
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x2d(%rbp), %r8
callq 0x6b20
movq %rax, -0x28(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x557c
jmp 0x558a
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x5532
movq $0x0, 0xdd83(%rip) # 0x13318
cmpl $0x0, -0x2c(%rbp)
jne 0x55c7
testb $0x1, -0x2d(%rbp)
jne 0x55c7
callq 0x8df0
movq %rax, %rdx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
leaq 0x61ec(%rip), %rsi      # 0xb7a1
leaq 0x6218(%rip), %rcx      # 0xb7d4
movb $0x0, %al
callq 0x8af0
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x55d6
movq -0x28(%rbp), %rdi
callq 0x5400
movq -0x20(%rbp), %rdi
callq 0x5400
testb $0x1, -0x2d(%rbp)
je 0x55ed
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x55f5
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: gchar
static char *
gchar(const char *ap)
{
	char c;
	const char *a;

	for (a = ap; *a != EOS; a++)
		switch (*a) {
		case DQUOT:
		case SQUOT:
			for (c = *a++; *a != c; a++)
				if (*a == EOS)
					return NULL;
			continue;
		case BQUOT:
			if (*++a == EOS)
				return NULL;
			continue;
		case ASTERISK:
		case QUESTION:
		case LBRACKET:
			return (char *)a;
		}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x66f7
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x22, %eax
je 0x666b
jmp 0x6631
movl -0x24(%rbp), %eax
subl $0x27, %eax
je 0x666b
jmp 0x663b
movl -0x24(%rbp), %eax
subl $0x2a, %eax
je 0x66da
jmp 0x6649
movl -0x24(%rbp), %eax
subl $0x3f, %eax
je 0x66da
jmp 0x6657
movl -0x24(%rbp), %eax
subl $0x5b, %eax
je 0x66da
jmp 0x6661
movl -0x24(%rbp), %eax
subl $0x5c, %eax
je 0x66b6
jmp 0x66e4
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x66b4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x66a4
movq $0x0, -0x8(%rbp)
jmp 0x66ff
jmp 0x66a6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x667f
jmp 0x66e6
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x66d8
movq $0x0, -0x8(%rbp)
jmp 0x66ff
jmp 0x66e6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66ff
jmp 0x66e6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6610
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: gnew
static const char **
gnew(const char **gav)
{
	size_t siz;
	ptrdiff_t gidx;
	static unsigned mult = 1;

	if (gavp == gave) {
		mult *= GAVMULT;
		gidx  = (ptrdiff_t)(gavp - gav);
		siz   = (size_t)((gidx + (GAVNEW * mult)) * sizeof(char *));
		gav   = xrealloc(gav, siz);
		gavp  = gav + gidx;
		gave  = &gav[gidx + (GAVNEW * mult) - 1];
	}
	return gav;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc4a5(%rip), %rax      # 0x13318
cmpq 0xc4a6(%rip), %rax      # 0x13320
jne 0x6f0d
movl 0x7376(%rip), %eax      # 0xe1fc
shll %eax
movl %eax, 0x736e(%rip)      # 0xe1fc
movq 0xc483(%rip), %rax      # 0x13318
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x734e(%rip), %ecx      # 0xe1fc
shll $0x7, %ecx
movl %ecx, %ecx
addq %rcx, %rax
shlq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7890
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0xc433(%rip)      # 0x13318
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x7309(%rip), %edx      # 0xe1fc
shll $0x7, %edx
movl %edx, %edx
addq %rdx, %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0xc413(%rip)      # 0x13320
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: gopendir
static DIR *
gopendir(char *buf, const char *dname)
{
	char *b;
	const char *d;

	for (*buf = EOS, b = buf, d = dname; b < &buf[PATHMAX]; b++, d++)
		if ((*b = *d) == EOS) {
			(void)atrim(UCPTR(buf));
			break;
		}
	return (b >= &buf[PATHMAX]) ? NULL : opendir(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jae 0x7486
movq -0x20(%rbp), %rax
movb (%rax), %al
movq -0x18(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x746a
movq -0x8(%rbp), %rdi
callq 0x6f20
jmp 0x7486
jmp 0x746c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7437
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x74a2
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x74af
movq -0x8(%rbp), %rdi
callq 0x2110
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: aalloc
static void
aalloc(const char *name, const char *string)
{
	struct anode *a, *n, *p;
	int d;

	if (name == NULL || *name == EOS || string == NULL || *string == EOS)
		return;

	a = anp;
	if (a == NULL) { /* First */
		anp = aalloc1(name, string);
		return;
	}
	p = a;
	/* ascending ASCII sort */
	while (a != NULL) {
		if ((d = strcmp(name, a->name)) == 0) {
			if (!EQUAL(string, a->string)) {
				/* Replace old string w/ new string. */
				xfree(a->string);
				a->string = xstrdup(string);
			}
			return;
		}
		if (d < 0)
			break;
		p = a;
		a = a->next;
	}
	if (a == NULL) { /* Last */
		p->next = aalloc1(name, string);
		return;
	}

	/* Insert new alias between p and a (ascending ASCII insert). */
	if (a == anp) { /* New Head */
		n = aalloc1(name, string);
		n->next = anp;
		anp = n;
		return;
	}
	n = aalloc1(name, string);
	n->next = p->next;
	p->next = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7946
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7946
cmpq $0x0, -0x10(%rbp)
je 0x7946
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x794b
jmp 0x7a97
movq 0x91b6(%rip), %rax      # 0x10b08
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7976
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8580
movq %rax, 0x9197(%rip)      # 0x10b08
jmp 0x7a97
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7a14
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2230
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x79f4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x79ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2230
cmpl $0x0, %eax
je 0x79ef
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x33f0
movq -0x10(%rbp), %rdi
callq 0x50b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7a97
cmpl $0x0, -0x2c(%rbp)
jge 0x79fc
jmp 0x7a14
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x797e
cmpq $0x0, -0x18(%rbp)
jne 0x7a34
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8580
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7a97
movq -0x18(%rbp), %rax
cmpq 0x90c9(%rip), %rax      # 0x10b08
jne 0x7a6d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8580
movq %rax, -0x20(%rbp)
movq 0x90af(%rip), %rcx      # 0x10b08
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x909d(%rip)      # 0x10b08
jmp 0x7a97
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8580
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: aalloc1
static struct anode *
aalloc1(const char *name, const char *string)
{
	struct anode *a;

	a = xmalloc(sizeof(struct anode));
	a->next   = NULL;
	a->name   = xstrdup(name);
	a->string = xstrdup(string);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x4ae0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x50b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x50b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: set_ss_flags
static void
set_ss_flags(int sig, action_type act)
{

	if (act == SIG_IGN) {
		if (sig == SIGINT)
			sig_state |= S_SIGINT;
		else if (sig == SIGQUIT)
			sig_state |= S_SIGQUIT;
		else if (sig == SIGTERM)
			sig_state |= S_SIGTERM;
	} else if (act == SIG_DFL) {
		if (sig == SIGINT)
			sig_state &= ~S_SIGINT;
		else if (sig == SIGQUIT)
			sig_state &= ~S_SIGQUIT;
		else if (sig == SIGTERM)
			sig_state &= ~S_SIGTERM;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %eax
cmpq %rax, -0x10(%rbp)
jne 0x863f
cmpl $0x2, -0x4(%rbp)
jne 0x860d
movl 0xad72(%rip), %eax      # 0x13374
orl $0x1, %eax
movl %eax, 0xad69(%rip)      # 0x13374
jmp 0x863d
cmpl $0x3, -0x4(%rbp)
jne 0x8624
movl 0xad5b(%rip), %eax      # 0x13374
orl $0x2, %eax
movl %eax, 0xad52(%rip)      # 0x13374
jmp 0x863b
cmpl $0xf, -0x4(%rbp)
jne 0x8639
movl 0xad44(%rip), %eax      # 0x13374
orl $0x4, %eax
movl %eax, 0xad3b(%rip)      # 0x13374
jmp 0x863b
jmp 0x863d
jmp 0x8691
cmpq $0x0, -0x10(%rbp)
jne 0x868f
cmpl $0x2, -0x4(%rbp)
jne 0x865d
movl 0xad22(%rip), %eax      # 0x13374
andl $-0x2, %eax
movl %eax, 0xad19(%rip)      # 0x13374
jmp 0x868d
cmpl $0x3, -0x4(%rbp)
jne 0x8674
movl 0xad0b(%rip), %eax      # 0x13374
andl $-0x3, %eax
movl %eax, 0xad02(%rip)      # 0x13374
jmp 0x868b
cmpl $0xf, -0x4(%rbp)
jne 0x8689
movl 0xacf4(%rip), %eax      # 0x13374
andl $-0x5, %eax
movl %eax, 0xaceb(%rip)      # 0x13374
jmp 0x868b
jmp 0x868d
jmp 0x868f
jmp 0x8691
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: sh_errexit
static void
sh_errexit(int es)
{

#ifdef	DEBUG
	fd_print(FD2, "sh_errexit: es == %d;\n", es);
#endif

	switch (es) {
	case -2:
		/* For compatibility, glob() errors are not fatal. */
		status = SH_ERR;
		return;
	case -1:
		status = SH_ERR;
		/*FALLTHROUGH*/
	case 0:
		if (SHTYPE(ST_SOURCE)) {
			(void)lseek(FD0, (off_t)0, SEEK_END);
			error_source = true;
			return;
		}
		if (SHTYPE(ST_RCFILE) && (status == 130 || status == 131)) {
			(void)lseek(FD0, (off_t)0, SEEK_END);
			return;
		}
		if (!SHTYPE(ST_INTERACTIVE)) {
			if (!SHTYPE(ST_ONELINE))
				(void)lseek(FD0, (off_t)0, SEEK_END);
			break;
		}
		return;
	default:
		status = es;
	}
	EXIT(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $-0x2, %eax
je 0x880e
jmp 0x87f8
movl -0x8(%rbp), %eax
subl $-0x1, %eax
je 0x881d
jmp 0x8802
movl -0x8(%rbp), %eax
testl %eax, %eax
je 0x8827
jmp 0x88b9
movl $0x2, 0x5a50(%rip)      # 0xe268
jmp 0x88ee
movl $0x2, 0x5a41(%rip)      # 0xe268
movl 0x5a0f(%rip), %eax      # 0xe23c
andl $0x10, %eax
cmpl $0x0, %eax
je 0x8851
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
movb $0x1, 0x5a24(%rip)      # 0xe270
jmp 0x88ee
movl 0x59e5(%rip), %eax      # 0xe23c
andl $0x8, %eax
cmpl $0x0, %eax
je 0x8889
cmpl $0x82, 0x59ff(%rip)     # 0xe268
je 0x8877
cmpl $0x83, 0x59f3(%rip)     # 0xe268
jne 0x8889
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
jmp 0x88ee
movl 0x59ad(%rip), %eax      # 0xe23c
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x88b7
movl 0x599f(%rip), %eax      # 0xe23c
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x88b5
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
jmp 0x88c2
jmp 0x88ee
movl -0x4(%rbp), %eax
movl %eax, 0x59a6(%rip)      # 0xe268
callq 0x2100
movl %eax, -0xc(%rbp)
callq 0x8e20
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jne 0x88e3
movl 0x598a(%rip), %edi      # 0xe268
callq 0x2370
movl 0x597f(%rip), %edi      # 0xe268
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: pn_build
static char *
pn_build(char *path, const char *file, size_t size)
{
	int len;
	const char *home;

	*path = EOS;
	home  = getenv("HOME");

	if (home != NULL && *home != EOS) {
		len = snprintf(path, size, "%s/%s", home, file);
		if (len < 0 || len >= (int)size) {
			err(-1, "%s: %s/%s: %s\n",
			    getmyname(), home, file, strerror(ENAMETOOLONG));
			*path = EOS;
		}
	}

	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq 0x2df4(%rip), %rdi      # 0xb716
callq 0x2030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x89c6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x89c6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x30f3(%rip), %rdx      # 0xba50
movb $0x0, %al
callq 0x2170
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x8978
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl %ecx, %eax
jl 0x89c4
callq 0x8df0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x24, %edi
callq 0x2380
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq %rax, %r9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x30a0(%rip), %rsi      # 0xba56
movb $0x0, %al
callq 0x8af0
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x89c6
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: rc_open
static bool
rc_open(const char *file)
{
	int fd;

	if (file == NULL || *file == EOS)
		return false;

	if ((fd = open(file, O_RDONLY | O_NONBLOCK)) == -1)
		return false;

	if (!fd_type(fd, FD_ISREG)) {
		err(-1, FMT3S, getmyname(), file, ERR_EXEC);
		(void)close(fd);
		return false;
	}

	/* NOTE: A dup2(2) or fcntl(2) error here is fatal. */
	if (dup2(fd, FD0) == -1 ||
	    fcntl(FD0, F_SETFL, O_RDONLY & ~O_NONBLOCK) == -1)
		err(SH_ERR, FMT3S, getmyname(), file, strerror(errno));

	(void)close(fd);
	shtype |= ST_RCFILE;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x89ef
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x89f8
movb $0x0, -0x1(%rbp)
jmp 0x8ad8
movq -0x10(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
movb $0x0, %al
callq 0x2320
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x8a19
movb $0x0, -0x1(%rbp)
jmp 0x8ad8
movl -0x14(%rbp), %edi
movl $0x8000, %esi           # imm = 0x8000
callq 0x2b90
testb $0x1, %al
jne 0x8a5e
callq 0x8df0
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x2d5b(%rip), %rsi      # 0xb79d
leaq 0x2d60(%rip), %r8       # 0xb7a9
movb $0x0, %al
callq 0x8af0
movl -0x14(%rbp), %edi
callq 0x21d0
movb $0x0, -0x1(%rbp)
jmp 0x8ad8
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x2160
cmpl $-0x1, %eax
je 0x8a82
xorl %edx, %edx
movl $0x4, %esi
movl %edx, %edi
movb $0x0, %al
callq 0x20d0
cmpl $-0x1, %eax
jne 0x8abd
callq 0x8df0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2070
movl (%rax), %edi
callq 0x2380
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rax, %r8
movl $0x2, %edi
leaq 0x2ce7(%rip), %rsi      # 0xb79d
movb $0x0, %al
callq 0x8af0
movl -0x14(%rbp), %edi
callq 0x21d0
movl 0x5771(%rip), %eax      # 0xe23c
orl $0x8, %eax
movl %eax, 0x5768(%rip)      # 0xe23c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: uexec
int
uexec(enum sbikey key, int ac, char **av)
{
	int (*util)(int, char **);
	int r;
	static int cnt, cnt1, s;

	if (cnt == 0) setmyerrexit(&ut_errexit);

	switch (key) {
	case SBI_ECHO:	util = &sbi_echo;	break;
	case SBI_FD2:	util = &sbi_fd2;	break;
	case SBI_GOTO:	util = &sbi_goto;	break;
	case SBI_IF:	util = &sbi_if;		break;
	default:
		err(FC_ERR, FMT2S, getmyname(), "uexec: Invalid utility");
		/*NOTREACHED*/
		return FC_ERR;
	}

	cnt1 = cnt++;

	r = (*util)(ac, av);

	if (cnt-- > cnt1)
		s = r;

#ifdef	DEBUG
	if (cnt == 0) fd_print(FD2, "uexec: return %d;\n", s);
#endif

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, 0xa3f7(%rip)      # 0x13390
jne 0x8fa7
leaq -0x62(%rip), %rdi       # 0x8f40
callq 0x8e50
movl -0x8(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x5, %eax
ja 0x9000
movq -0x30(%rbp), %rax
leaq 0x2b19(%rip), %rcx      # 0xbadc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xbd(%rip), %rax        # 0x9090
movq %rax, -0x20(%rbp)
jmp 0x902b
leaq 0x1c0(%rip), %rax       # 0x91a0
movq %rax, -0x20(%rbp)
jmp 0x902b
leaq 0x403(%rip), %rax       # 0x93f0
movq %rax, -0x20(%rbp)
jmp 0x902b
leaq 0x566(%rip), %rax       # 0x9560
movq %rax, -0x20(%rbp)
jmp 0x902b
callq 0x8df0
movq %rax, %rdx
movl $0x7c, %edi
leaq 0x278d(%rip), %rsi      # 0xb7a1
leaq 0x2ad9(%rip), %rcx      # 0xbaf4
movb $0x0, %al
callq 0x8af0
movl $0x7c, -0x4(%rbp)
jmp 0x907d
movl 0xa35f(%rip), %eax      # 0x13390
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xa354(%rip)      # 0x13390
movl %eax, 0xa352(%rip)      # 0x13394
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
movl 0xa338(%rip), %eax      # 0x13390
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xa32d(%rip)      # 0x13390
cmpl 0xa32b(%rip), %eax      # 0x13394
jle 0x9074
movl -0x24(%rbp), %eax
movl %eax, 0xa324(%rip)      # 0x13398
movl 0xa31e(%rip), %eax      # 0x13398
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: sbi_echo
static int
sbi_echo(int argc, char **argv)
{
	bool nopt;
	char **avp, **ave;

	argc--, argv++;
	if (*argv != NULL && EQUAL(*argv, "-n")) {
		argc--, argv++;
		nopt = true;
	} else
		nopt = false;

	for (avp = argv, ave = &argv[argc]; avp < ave; avp++)
		fd_print(FD1, "%s%s", *avp, (avp + 1 < ave) ? " " : "");
	if (!nopt)
		fd_print(FD1, FMT1S, "");

	return SH_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9106
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl 0x2a3c(%rip), %ecx      # 0xbb0b
cmpl %ecx, %eax
jne 0x9106
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x2a2a(%rip), %rsi      # 0xbb0b
callq 0x2230
cmpl $0x0, %eax
jne 0x9106
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0x910a
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9178
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdi
leaq 0x25ee(%rip), %rcx      # 0xb737
leaq 0x2563(%rip), %rax      # 0xb6b3
cmpq %rdi, %rsi
cmovbq %rax, %rcx
movl $0x1, %edi
leaq 0x25cc(%rip), %rsi      # 0xb72f
movb $0x0, %al
callq 0x8d40
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x9125
testb $0x1, -0x11(%rbp)
jne 0x9198
movl $0x1, %edi
leaq 0x261b(%rip), %rsi      # 0xb7a5
leaq 0x25a6(%rip), %rdx      # 0xb737
movb $0x0, %al
callq 0x8d40
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: sbi_goto
static int
sbi_goto(int argc, char **argv)
{
	size_t siz;
	char label[LABELMAX];

	setmyname(argv[0]);

	if (argc < 2 || *argv[1] == EOS || isatty(FD0) != 0)
		err(FC_ERR, FMT2S, getmyname(), ERR_GENERIC);
	if ((siz = strlen(argv[1]) + 1) > sizeof(label))
		err(FC_ERR, FMT3S, getmyname(), argv[1], ERR_LABTOOLONG);
	if (lseek(FD0, (off_t)0, SEEK_SET) == -1)
		err(FC_ERR, FMT2S, getmyname(), ERR_SEEK);

	while (getlabel(label, *argv[1] & 0377, siz))
		if (strcmp(label, argv[1]) == 0) {
			(void)lseek(FD0, offset, SEEK_SET);
			return SH_TRUE;
		}

	fd_print(FD2, FMT3S, getmyname(), argv[1], ERR_LABNOTFOUND);
	return SH_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8e70
cmpl $0x2, -0x8(%rbp)
jl 0x942d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x942d
xorl %edi, %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x944f
callq 0x8df0
movq %rax, %rdx
movl $0x7c, %edi
leaq 0x2360(%rip), %rsi      # 0xb7a1
leaq 0x24c7(%rip), %rcx      # 0xb90f
movb $0x0, %al
callq 0x8af0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2130
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x41, %rax
jbe 0x9494
callq 0x8df0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x7c, %edi
leaq 0x2317(%rip), %rsi      # 0xb79d
leaq 0x26b7(%rip), %r8       # 0xbb44
movb $0x0, %al
callq 0x8af0
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %edi
callq 0x21a0
cmpq $-0x1, %rax
jne 0x94c9
callq 0x8df0
movq %rax, %rdx
movl $0x7c, %edi
leaq 0x22e6(%rip), %rsi      # 0xb7a1
leaq 0x2691(%rip), %rcx      # 0xbb53
movb $0x0, %al
callq 0x8af0
jmp 0x94cb
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %esi
andl $0xff, %esi
movq -0x18(%rbp), %rdx
callq 0x9610
testb $0x1, %al
jne 0x94ef
jmp 0x9520
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2230
cmpl $0x0, %eax
jne 0x951e
movq 0x9e94(%rip), %rsi      # 0x133a0
xorl %edx, %edx
movl %edx, %edi
callq 0x21a0
movl $0x0, -0x4(%rbp)
jmp 0x9551
jmp 0x94cb
callq 0x8df0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x2, %edi
leaq 0x2261(%rip), %rsi      # 0xb79d
leaq 0x261c(%rip), %r8       # 0xbb5f
movb $0x0, %al
callq 0x8d40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: sbi_if
static int
sbi_if(int argc, char **argv)
{
	bool re;		/* return value of expr() */

	setmyname(argv[0]);

	if (argc > 1) {
		iac = argc;
		iav = argv;
		iap = 1;
		re  = expr();
		if (re && iap < iac)
			doex(!FORKED);
	} else
		re = false;

	return re ? SH_TRUE : SH_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8e70
cmpl $0x1, -0x4(%rbp)
jle 0x95c6
movl -0x4(%rbp), %eax
movl %eax, 0x9e1e(%rip)      # 0x133a8
movq -0x10(%rbp), %rax
movq %rax, 0x9e1b(%rip)      # 0x133b0
movl $0x1, 0x9e19(%rip)      # 0x133b8
callq 0x97e0
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x95c4
movl 0x9e03(%rip), %eax      # 0x133b8
cmpl 0x9ded(%rip), %eax      # 0x133a8
jge 0x95c4
xorl %edi, %edi
callq 0x9860
jmp 0x95ca
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: getlabel
static bool
getlabel(char *buf, int fc, size_t siz)
{
	int c;
	char *b;

	while ((c = xgetc()) != EOF) {
		/* `:' may be preceded by blanks. */
		while (c == SPACE || c == TAB)
			c = xgetc();
		if (c != COLON) {
			while (c != EOL && c != EOF)
				c = xgetc();
			continue;
		}

		/* Prepare for possible label. */
		while ((c = xgetc()) == SPACE || c == TAB)
			;	/* nothing   */
		if (c != fc)	/* not label */
			continue;

		/*
		 * Try to copy possible label (first word only)
		 * to buf, ignoring it if it becomes too long.
		 */
		b = buf;
		do {
			if (c == EOL || c == SPACE || c == TAB || c == EOF) {
				*b = EOS;
				break;
			}
			*b = c;
			c = xgetc();
		} while (++b < &buf[siz]);

		/* Ignore any remaining characters on labelled line. */
		while (c != EOL && c != EOF)
			c = xgetc();
		if (c == EOF)
			break;

		if ((size_t)(b - buf) != siz - 1)	/* not label */
			continue;
		return true;
	}

	*buf = EOS;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x9790
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x9772
jmp 0x9636
movb $0x1, %al
cmpl $0x20, -0x24(%rbp)
movb %al, -0x31(%rbp)
je 0x964b
cmpl $0x9, -0x24(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9654
jmp 0x965e
callq 0x9790
movl %eax, -0x24(%rbp)
jmp 0x9636
cmpl $0x3a, -0x24(%rbp)
je 0x9690
jmp 0x9666
xorl %eax, %eax
cmpl $0xa, -0x24(%rbp)
movb %al, -0x32(%rbp)
je 0x967b
cmpl $-0x1, -0x24(%rbp)
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x9684
jmp 0x968e
callq 0x9790
movl %eax, -0x24(%rbp)
jmp 0x9666
jmp 0x9623
jmp 0x9692
callq 0x9790
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x33(%rbp)
je 0x96b0
cmpl $0x9, -0x24(%rbp)
sete %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
testb $0x1, %al
jne 0x96b9
jmp 0x96bb
jmp 0x9692
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x96c8
jmp 0x9623
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0xa, -0x24(%rbp)
je 0x96e8
cmpl $0x20, -0x24(%rbp)
je 0x96e8
cmpl $0x9, -0x24(%rbp)
je 0x96e8
cmpl $-0x1, -0x24(%rbp)
jne 0x96f1
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x971d
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
callq 0x9790
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jb 0x96d0
jmp 0x971f
xorl %eax, %eax
cmpl $0xa, -0x24(%rbp)
movb %al, -0x34(%rbp)
je 0x9734
cmpl $-0x1, -0x24(%rbp)
setne %al
movb %al, -0x34(%rbp)
movb -0x34(%rbp), %al
testb $0x1, %al
jne 0x973d
jmp 0x9747
callq 0x9790
movl %eax, -0x24(%rbp)
jmp 0x971f
cmpl $-0x1, -0x24(%rbp)
jne 0x974f
jmp 0x9772
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x976c
jmp 0x9623
movb $0x1, -0x1(%rbp)
jmp 0x977d
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: xgetc
static int
xgetc(void)
{
	int nc;

	offset++;
	nc = getchar();
	return (nc != EOF) ? nc & 0377 : EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9c01(%rip), %rax      # 0x133a0
addq $0x1, %rax
movq %rax, 0x9bf6(%rip)      # 0x133a0
callq 0x2240
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x97c5
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
jmp 0x97cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x8(%rbp)
jmp 0x97cf
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: expr
static bool
expr(void)
{
	bool re;

	re = e1();
	if (equal(nxtarg(RETERR), "-o"))
		return re | expr();
	iap--;
	return re;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x9ac0
andb $0x1, %al
movb %al, -0x2(%rbp)
movl $0x1, %edi
callq 0x9bb0
movq %rax, %rdi
leaq 0x2369(%rip), %rsi      # 0xbb6f
callq 0x9b40
testb $0x1, %al
jne 0x9811
jmp 0x983b
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x97e0
movb %al, %cl
movl -0x8(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9852
movl 0x9b77(%rip), %eax      # 0x133b8
addl $-0x1, %eax
movl %eax, 0x9b6e(%rip)      # 0x133b8
movb -0x2(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: e1
static bool
e1(void)
{
	bool re;

	re = e2();
	if (equal(nxtarg(RETERR), "-a"))
		return re & e1();
	iap--;
	return re;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x9ca0
andb $0x1, %al
movb %al, -0x2(%rbp)
movl $0x1, %edi
callq 0x9bb0
movq %rax, %rdi
leaq 0x208c(%rip), %rsi      # 0xbb72
callq 0x9b40
testb $0x1, %al
jne 0x9af1
jmp 0x9b1b
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x9ac0
movb %al, %cl
movl -0x8(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9b32
movl 0x9897(%rip), %eax      # 0x133b8
addl $-0x1, %eax
movl %eax, 0x988e(%rip)      # 0x133b8
movb -0x2(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)