LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/synd.c
// Function: synd
void synd(gf *out, gf *f, gf *L, unsigned char *r)
{
	int i, j;
	gf e, e_inv, c;

	for (j = 0; j < 2*SYS_T; j++)
		out[j] = 0;

	for (i = 0; i < SYS_N; i++)
	{
		c = (r[i/8] >> (i%8)) & 1;

		e = eval(f, L[i]);
		e_inv = gf_inv(gf_mul(e,e));

		for (j = 0; j < 2*SYS_T; j++)
		{
			out[j] = gf_add(out[j], gf_mul(e_inv, c));
			e_inv = gf_mul(e_inv, L[i]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x100, -0x28(%rbp)     # imm = 0x100
jge 0xdad1
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movw $0x0, (%rax,%rcx,2)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xdaaf
movl $0x0, -0x24(%rbp)
cmpl $0x2000, -0x24(%rbp)    # imm = 0x2000
jge 0xdbdb
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x34(%rbp), %eax
movl %edx, %ecx
sarl %cl, %eax
andl $0x1, %eax
movw %ax, -0x2e(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0xd570
movw %ax, -0x2a(%rbp)
movw -0x2a(%rbp), %ax
movzwl %ax, %edi
movzwl -0x2a(%rbp), %esi
callq 0xb230
movzwl %ax, %edi
callq 0xb9a0
movw %ax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x100, -0x28(%rbp)     # imm = 0x100
jge 0xdbcb
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x42(%rbp)
movw -0x2c(%rbp), %ax
movzwl %ax, %edi
movzwl -0x2e(%rbp), %esi
callq 0xb230
movw -0x42(%rbp), %cx
movzwl %cx, %edi
movzwl %ax, %esi
callq 0xb210
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x2c(%rbp), %dx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzwl %dx, %edi
movzwl (%rax,%rcx,2), %esi
callq 0xb230
movw %ax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xdb5d
jmp 0xdbcd
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdad8
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/util.c
// Function: load2
uint16_t load2(const unsigned char *src)
{
	uint16_t a;

	a = src[1];
	a <<= 8;
	a |= src[0];

	return a & GFMASK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
movzwl -0xa(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x1fff, %eax           # imm = 0x1FFF
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/util.c
// Function: store8
void store8(unsigned char *out, uint64_t in)
{
	out[0] = (in >> 0x00) & 0xFF;
	out[1] = (in >> 0x08) & 0xFF;
	out[2] = (in >> 0x10) & 0xFF;
	out[3] = (in >> 0x18) & 0xFF;
	out[4] = (in >> 0x20) & 0xFF;
	out[5] = (in >> 0x28) & 0xFF;
	out[6] = (in >> 0x30) & 0xFF;
	out[7] = (in >> 0x38) & 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
shrq $0x38, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/util.c
// Function: load8
uint64_t load8(const unsigned char * in)
{
	int i;
	uint64_t ret = in[7];

	for (i = 6; i >= 0; i--)
	{
		ret <<= 8;
		ret |= in[i];
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %eax
movq %rax, -0x18(%rbp)
movl $0x6, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xdf4c
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdf1b
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/util.c
// Function: bitrev
gf bitrev(gf a)
{
	a = ((a & 0x00FF) << 8) | ((a & 0xFF00) >> 8);
	a = ((a & 0x0F0F) << 4) | ((a & 0xF0F0) >> 4);
	a = ((a & 0x3333) << 2) | ((a & 0xCCCC) >> 2);
	a = ((a & 0x5555) << 1) | ((a & 0xAAAA) >> 1);
	
	return a >> 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0xff, %eax
shll $0x8, %eax
movzwl -0x2(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0xf0f, %eax            # imm = 0xF0F
shll $0x4, %eax
movzwl -0x2(%rbp), %ecx
andl $0xf0f0, %ecx           # imm = 0xF0F0
sarl $0x4, %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0x3333, %eax           # imm = 0x3333
shll $0x2, %eax
movzwl -0x2(%rbp), %ecx
andl $0xcccc, %ecx           # imm = 0xCCCC
sarl $0x2, %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0x5555, %eax           # imm = 0x5555
shll %eax
movzwl -0x2(%rbp), %ecx
andl $0xaaaa, %ecx           # imm = 0xAAAA
sarl %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x3, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/writeall.c
// Function: writeall
int writeall(int fd, const void *xv, long long xlen) {

    const unsigned char *x = xv;
    long long w;
    while (xlen > 0) {
        w = xlen;
        if (w > 1048576) w = 1048576;
        w = write(fd, x, w);
        if (w < 0) {
            if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) {
                struct pollfd p;
                p.fd = fd;
                p.events = POLLOUT | POLLERR;
                poll(&p, 1, -1);
                continue;
            }
            return -1;
        }
        x += w;
        xlen -= w;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0xe0b3
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x100000, -0x28(%rbp)  # imm = 0x100000
jle 0xe030
movq $0x100000, -0x28(%rbp)  # imm = 0x100000
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xe093
callq 0x1040
cmpl $0x4, (%rax)
je 0xe069
callq 0x1040
cmpl $0xb, (%rax)
je 0xe069
callq 0x1040
cmpl $0xb, (%rax)
jne 0xe08a
movl -0x8(%rbp), %eax
movl %eax, -0x30(%rbp)
movw $0xc, -0x2c(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x10d0
jmp 0xe00b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe0ba
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xe00b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: sh_init
static void
sh_init(const char *av0p)
{
	struct stat sb;
	int i;

	setmyerrexit(&sh_errexit);
	setmyname(av0p);
	setmypid(getpid());

	/*
	 * Set-ID execution is not supported.
	 */
	if (geteuid() != getuid() || getegid() != getgid())
		err(SH_ERR, FMT1S, ERR_SETID);

	/*
	 * Save the process ID of the shell as a 5-digit ASCII
	 * string (apid).  Each occurrence of `$$' in a command
	 * line is substituted w/ the value of apid.
	 */
	i = snprintf(apid, sizeof(apid), "%05u", (unsigned)getmypid());
	if (i < 0 || i >= (int)sizeof(apid))
		*apid = EOS;

	/*
	 * Fail if any of the descriptors 0, 1, or 2 is not open.
	 */
	for (i = 0; i < 3; i++)
		if (fstat(i, &sb) == -1)
			err(SH_ERR, "%u: %s\n", (unsigned)i, strerror(errno));

	/*
	 * Set the SIGCHLD signal to its default action.
	 * Correct operation of the shell requires that zombies
	 * be created for its children when they terminate.
	 */
	(void)sasignal(SIGCHLD, SIG_DFL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1eba(%rip), %rdi      # 0x4500
callq 0x48f0
movq -0x8(%rbp), %rdi
callq 0x4910
callq 0x20e0
movl %eax, %edi
callq 0x49c0
callq 0x2170
movl %eax, -0xa0(%rbp)
callq 0x2110
movl %eax, %ecx
movl -0xa0(%rbp), %eax
cmpl %ecx, %eax
jne 0x2698
callq 0x2220
movl %eax, -0xa4(%rbp)
callq 0x2200
movl %eax, %ecx
movl -0xa4(%rbp), %eax
cmpl %ecx, %eax
je 0x26b2
movl $0x2, %edi
leaq 0x4062(%rip), %rsi      # 0x6706
leaq 0x3f85(%rip), %rdx      # 0x6630
movb $0x0, %al
callq 0x4590
callq 0x48c0
movl %eax, %ecx
leaq 0x8340(%rip), %rdi      # 0xaa00
movl $0x21, %esi
leaq 0x3f7c(%rip), %rdx      # 0x6648
movb $0x0, %al
callq 0x2130
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
jl 0x26eb
cmpl $0x21, -0x9c(%rbp)
jl 0x26f2
movb $0x0, 0x830e(%rip)      # 0xaa00
movl $0x0, -0x9c(%rbp)
cmpl $0x3, -0x9c(%rbp)
jge 0x2763
movl -0x9c(%rbp), %edi
leaq -0x98(%rbp), %rsi
callq 0x2270
cmpl $-0x1, %eax
jne 0x2750
movl -0x9c(%rbp), %eax
movl %eax, -0xa8(%rbp)
callq 0x2070
movl (%rax), %edi
callq 0x2260
movl -0xa8(%rbp), %edx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x3f04(%rip), %rsi      # 0x664d
movb $0x0, %al
callq 0x4590
jmp 0x2752
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x26fc
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x5090
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: fd_free
static void
fd_free(void)
{
	long fd_max;
	int fd;

	fd_max = sysconf(_SC_OPEN_MAX);
	if (fd_max < FDFREEMIN || fd_max > FDFREEMAX)
		fd_max = FDFREEMIN;
	for (fd = (int)fd_max - 1; fd > FD2; fd--)
		(void)close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
callq 0x2240
movq %rax, -0x8(%rbp)
cmpq $0x14, -0x8(%rbp)
jl 0x2807
cmpq $0x1000, -0x8(%rbp)     # imm = 0x1000
jle 0x280f
movq $0x14, -0x8(%rbp)
movq -0x8(%rbp), %rax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jle 0x2832
movl -0xc(%rbp), %edi
callq 0x2180
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2819
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: sh_magic
static void
sh_magic(void)
{
	struct stat sb;
	size_t len;

	if (fstat(FD0, &sb) == -1 || !S_ISREG(sb.st_mode))
		return;
	if (lseek(FD0, (off_t)0, SEEK_CUR) == 0) {
		if (readc() == HASH && readc() == BANG) {
			for (len = 2; len < LINEMAX; len++)
				if (readc() == EOL)
					return;
			err(SH_ERR, FMT1S, ERR_TMCHARS);
		}
		(void)lseek(FD0, (off_t)0, SEEK_SET);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
xorl %edi, %edi
leaq -0x90(%rbp), %rsi
callq 0x2270
cmpl $-0x1, %eax
je 0x286d
movl -0x78(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x2872
jmp 0x2906
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2150
cmpq $0x0, %rax
jne 0x2906
callq 0x3a80
movsbl %al, %eax
cmpl $0x23, %eax
jne 0x28f9
callq 0x3a80
movsbl %al, %eax
cmpl $0x21, %eax
jne 0x28f9
movq $0x2, -0x98(%rbp)
cmpq $0x800, -0x98(%rbp) # imm = 0x800
jae 0x28df
callq 0x3a80
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x28c9
jmp 0x2906
jmp 0x28cb
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x28ad
movl $0x2, %edi
leaq 0x3e1b(%rip), %rsi      # 0x6706
leaq 0x3b71(%rip), %rdx      # 0x6463
movb $0x0, %al
callq 0x4590
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %edi
callq 0x2150
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: rpx_line
static void
rpx_line(void)
{
	struct tnode *t;
	sigset_t nmask, omask;
	char *wp;

	linep = line;
	wordp = word;
	error = false;
	nul_count = 0;
	do {
		wp = linep;
		get_word();
	} while (*wp != EOL);

	if (error) {
		err(SH_ERR, FMT1S, error_message);
		return;
	}

	if (wordp - word > 1) {
		(void)sigfillset(&nmask);
		(void)sigprocmask(SIG_SETMASK, &nmask, &omask);
		t = NULL;
		t = syntax(word, wordp);
		(void)sigprocmask(SIG_SETMASK, &omask, NULL);
		if (error)
			err(SH_ERR, FMT1S, ERR_SYNTAX);
		else
			execute(t, NULL, NULL);
		tfree(t);
		t = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq 0x589e(%rip), %rax      # 0x81c0
movq %rax, 0x6097(%rip)      # 0x89c0
leaq 0x60a0(%rip), %rax      # 0x89d0
movq %rax, 0x8099(%rip)      # 0xa9d0
movb $0x0, 0x809a(%rip)      # 0xa9d8
movl $0x0, 0x8094(%rip)      # 0xa9dc
movq 0x6071(%rip), %rax      # 0x89c0
movq %rax, -0x110(%rbp)
callq 0x2a60
movq -0x110(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2948
testb $0x1, 0x8067(%rip)      # 0xa9d8
je 0x2992
movq 0x8066(%rip), %rdx      # 0xa9e0
movl $0x2, %edi
leaq 0x3d80(%rip), %rsi      # 0x6706
movb $0x0, %al
callq 0x4590
jmp 0x2a4f
movq 0x8037(%rip), %rax      # 0xa9d0
leaq 0x6030(%rip), %rcx      # 0x89d0
subq %rcx, %rax
sarq $0x3, %rax
cmpq $0x1, %rax
jle 0x2a4f
leaq -0x88(%rbp), %rdi
callq 0x21e0
movl $0x2, %edi
leaq -0x88(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x2040
movq $0x0, -0x8(%rbp)
movq 0x7fec(%rip), %rsi      # 0xa9d0
leaq 0x5fe5(%rip), %rdi      # 0x89d0
callq 0x2cb0
movq %rax, -0x8(%rbp)
movl $0x2, %edi
leaq -0x108(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2040
testb $0x1, 0x7fc8(%rip)      # 0xa9d8
je 0x2a2e
movl $0x2, %edi
leaq 0x3ce8(%rip), %rsi      # 0x6706
leaq 0x3a12(%rip), %rdx      # 0x6437
movb $0x0, %al
callq 0x4590
jmp 0x2a3e
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2d20
movq -0x8(%rbp), %rdi
callq 0x3730
movq $0x0, -0x8(%rbp)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: syntax
static struct tnode *
syntax(char **p1, char **p2)
{

	while (p1 < p2)
		if (any(**p1, EOC))
			p1++;
		else
			return syn1(p1, p2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2d09
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
leaq 0x37a7(%rip), %rsi      # 0x6482
callq 0x3a30
testb $0x1, %al
jne 0x2ce6
jmp 0x2cf4
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d07
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b60
movq %rax, -0x8(%rbp)
jmp 0x2d11
jmp 0x2cc0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.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:
		free(t->nav);
		break;
	case TSUBSHELL:
		tfree(t->nsub);
		break;
	}
	free(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3745
jmp 0x37ac
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0xc(%rbp)
decl %eax
subl $0x2, %eax
jb 0x376c
jmp 0x3758
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x3787
jmp 0x3762
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x3796
jmp 0x37a3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3730
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3730
jmp 0x37a3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2050
jmp 0x37a3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3730
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: any
static bool
any(int c, const char *as)
{
	const char *s;

	s = as;
	while (*s != EOS)
		if (*s++ == c)
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3a6e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x3a6c
movb $0x1, -0x1(%rbp)
jmp 0x3a72
jmp 0x3a43
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: readc
static char
readc(void)
{
	char c;

	if (argv2p != NULL) {
		if (argv2p == (char *)-1)
			exit(status);
		if ((c = (*argv2p++ & ASCII)) == EOS) {
			argv2p = (char *)-1;
			c = EOL;
		}
		return c;
	}
	if (one_line_flag == 1)
		exit(status);
	if (read(FD0, &c, (size_t)1) != 1)
		exit(status);
	if ((c &= ASCII) == EOL && one_line_flag == 2)
		one_line_flag = 1;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x4708(%rip)      # 0x8198
je 0x3aed
movq $-0x1, %rax
cmpq %rax, 0x46f8(%rip)      # 0x8198
jne 0x3aad
movl 0x470c(%rip), %edi      # 0x81b4
callq 0x2250
movq 0x46e4(%rip), %rax      # 0x8198
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x46d6(%rip)      # 0x8198
movsbl (%rax), %eax
andl $0x7f, %eax
movb %al, -0x2(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x3ae5
movq $-0x1, %rax
movq %rax, 0x46b7(%rip)      # 0x8198
movb $0xa, -0x2(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3b4d
cmpl $0x1, 0x46ac(%rip)      # 0x81a0
jne 0x3b01
movl 0x46b8(%rip), %edi      # 0x81b4
callq 0x2250
xorl %edi, %edi
leaq -0x2(%rbp), %rsi
movl $0x1, %edx
callq 0x21a0
cmpq $0x1, %rax
je 0x3b22
movl 0x4697(%rip), %edi      # 0x81b4
callq 0x2250
movsbl -0x2(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x2(%rbp)
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x3b47
cmpl $0x2, 0x4665(%rip)      # 0x81a0
jne 0x3b47
movl $0x1, 0x4659(%rip)      # 0x81a0
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: syn1
static struct tnode *
syn1(char **p1, char **p2)
{
	struct tnode *t;
	int c, subcnt;
	char **p;

	subcnt = 0;
	for (p = p1; p < p2; p++)
		switch (**p) {
		case LPARENTHESIS:
			subcnt++;
			continue;

		case RPARENTHESIS:
			subcnt--;
			if (subcnt < 0)
				goto synerr;
			continue;

		case SEMICOLON:
		case AMPERSAND:
		case EOL:
			if (subcnt == 0) {
				c = **p;
				t = talloc();
				t->ntype  = TLIST;
				t->nleft  = syn2(p1, p);
				if (c == AMPERSAND && t->nleft != NULL)
					t->nleft->nflags |= FAND | FINTR | FPRS;
				t->nright = syntax(p + 1, p2);
				t->nflags = 0;
				return t;
			}
			break;
		}

	if (subcnt == 0)
		return syn2(p1, p2);

synerr:
	error = true;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3c8f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x31, %eax
ja 0x3c7c
movq -0x38(%rbp), %rax
leaq 0x2734(%rip), %rcx      # 0x62e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3c7e
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x3bdf
jmp 0x3caa
jmp 0x3c7e
cmpl $0x0, -0x28(%rbp)
jne 0x3c7a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x3cd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3d50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x26, -0x24(%rbp)
jne 0x3c49
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c49
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %ecx
orl $0xc1, %ecx
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x2cb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3cb9
jmp 0x3c7c
jmp 0x3c7e
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x3b7f
cmpl $0x0, -0x28(%rbp)
jne 0x3ca8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d50
movq %rax, -0x8(%rbp)
jmp 0x3cb9
jmp 0x3caa
movb $0x1, 0x6d27(%rip)      # 0xa9d8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: talloc
static struct tnode *
talloc(void)
{
	struct tnode *t;

	t = xmalloc(sizeof(struct tnode));
	t->nleft  = NULL;
	t->nright = NULL;
	t->nsub   = NULL;
	t->nfin   = NULL;
	t->nfout  = NULL;
	t->nav    = NULL;
	t->nflags = 0;
	t->ntype  = 0;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x3e60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: syn2
static struct tnode *
syn2(char **p1, char **p2)
{
	struct tnode *t;
	int subcnt;
	char **p;

	subcnt = 0;
	for (p = p1; p < p2; p++)
		switch (**p) {
		case LPARENTHESIS:
			subcnt++;
			continue;

		case RPARENTHESIS:
			subcnt--;
			continue;

		case VERTICALBAR:
		case CARET:
			if (subcnt == 0) {
				t = talloc();
				t->ntype  = TPIPE;
				t->nleft  = syn3(p1, p);
				t->nright = syn2(p + 1, p2);
				t->nflags = 0;
				return t;
			}
			break;
		}

	return syn3(p1, p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3e3c
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x28, %eax
je 0x3daf
jmp 0x3d91
movl -0x34(%rbp), %eax
subl $0x29, %eax
je 0x3dba
jmp 0x3d9b
movl -0x34(%rbp), %eax
subl $0x5e, %eax
je 0x3dc5
jmp 0x3da5
movl -0x34(%rbp), %eax
subl $0x7c, %eax
je 0x3dc5
jmp 0x3e29
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e2b
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e2b
cmpl $0x0, -0x24(%rbp)
jne 0x3e27
callq 0x3cd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x34(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3ec0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e4d
jmp 0x3e29
jmp 0x3e2b
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ec0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: ascan
static void
ascan(char *ap, int (*func)(int))
{
	char c;

	if (ap == NULL)
		return;
	while ((c = *ap) != EOS)
		*ap++ = (*func)(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x41c9
jmp 0x41fb
jmp 0x41cb
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x41fb
movq -0x10(%rbp), %rax
movsbl -0x11(%rbp), %edi
callq *%rax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x41cb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: vscan
static void
vscan(char **vp, int (*func)(int))
{
	char *ap, c;

	if (vp == NULL)
		return;
	while ((ap = *vp++) != NULL)
		while ((c = *ap) != EOS)
			*ap++ = (*func)(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4239
jmp 0x428b
jmp 0x423b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x428b
jmp 0x4259
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x4289
movq -0x10(%rbp), %rax
movsbl -0x19(%rbp), %edi
callq *%rax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x4259
jmp 0x423b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: pwait
static void
pwait(pid_t cp)
{
	pid_t tp;
	int s;

	if (cp == 0)
		return;
	for (;;) {
		tp = wait(&s);
		if (tp == -1)
			break;
		if (s != 0) {
			if (WIFSIGNALED(s) != 0)
				status = prsig(s, tp, cp);
			else if (WIFEXITED(s) != 0)
				status = WEXITSTATUS(s);
			if (status >= FC_ERR) {
				if (status == FC_ERR)
					status = SH_ERR;
				err(status, NULL);
			}
		} else
			status = SH_TRUE;
		if (tp == cp)
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x42b6
jmp 0x437e
jmp 0x42b8
leaq -0xc(%rbp), %rdi
callq 0x2280
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x42cf
jmp 0x437e
cmpl $0x0, -0xc(%rbp)
je 0x4365
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x430d
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x43c0
movl %eax, 0x3ea9(%rip)      # 0x81b4
jmp 0x4336
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4334
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, 0x3e80(%rip)      # 0x81b4
jmp 0x4336
cmpl $0x7c, 0x3e77(%rip)     # 0x81b4
jl 0x4363
cmpl $0x7c, 0x3e6e(%rip)     # 0x81b4
jne 0x4352
movl $0x2, 0x3e62(%rip)      # 0x81b4
movl 0x3e5c(%rip), %edi      # 0x81b4
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x4590
jmp 0x436f
movl $0x0, 0x3e45(%rip)      # 0x81b4
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x4379
jmp 0x437e
jmp 0x42b8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: prsig
static int
prsig(int s, pid_t tp, pid_t cp)
{
	int e, r;
	char buf[SBUFMM(1)];
	const char *c, *m;

	e = WTERMSIG(s);
	if (e >= NSIGMSG || (e >= 0 && *sigmsg[e] != EOS)) {
		if (e < NSIGMSG)
			m = sigmsg[e];
		else {
			r = snprintf(buf, sizeof(buf), "Sig %u", (unsigned)e);
			m = (r < 0 || r >= (int)sizeof(buf))  ?
			    "prsig: snprintf: Internal error" :
			    buf;
		}
		c = "";
#ifdef	WCOREDUMP
		if (WCOREDUMP(s) != 0)
			c = sigmsg[0];
#endif
		if (tp != cp)
			fd_print(FD2, "%u: %s%s\n", (unsigned)tp, m, c);
		else
			fd_print(FD2, "%s%s\n", m, c);
	} else
		fd_print(FD2, FMT1S, "");

	return 128 + e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
cmpl $0xe, -0x10(%rbp)
jge 0x4405
cmpl $0x0, -0x10(%rbp)
jl 0x44ce
movslq -0x10(%rbp), %rcx
leaq 0x398b(%rip), %rax      # 0x7d80
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x44ce
cmpl $0xe, -0x10(%rbp)
jge 0x4420
movslq -0x10(%rbp), %rcx
leaq 0x396a(%rip), %rax      # 0x7d80
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
jmp 0x4466
leaq -0x40(%rbp), %rdi
movl -0x10(%rbp), %ecx
movl $0x21, %esi
leaq 0x2136(%rip), %rdx      # 0x6569
movb $0x0, %al
callq 0x2130
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4449
cmpl $0x21, -0x14(%rbp)
jl 0x4456
leaq 0x2120(%rip), %rax      # 0x6570
movq %rax, -0x58(%rbp)
jmp 0x445e
leaq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x2018(%rip), %rax      # 0x6485
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4489
movq 0x38fb(%rip), %rax      # 0x7d80
movq %rax, -0x48(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x44b1
movl -0x8(%rbp), %edx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
movl $0x2, %edi
leaq 0x20e8(%rip), %rsi      # 0x6590
movb $0x0, %al
callq 0x47e0
jmp 0x44cc
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x2, %edi
leaq 0x20cf(%rip), %rsi      # 0x6594
movb $0x0, %al
callq 0x47e0
jmp 0x44e8
movl $0x2, %edi
leaq 0x222c(%rip), %rsi      # 0x6706
leaq 0x1fa4(%rip), %rdx      # 0x6485
movb $0x0, %al
callq 0x47e0
movl -0x10(%rbp), %eax
addl $0x80, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sh6.c
// Function: sh_errexit
static void
sh_errexit(int es)
{

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

	status = es;
	if (prompt == NULL) {
		(void)lseek(FD0, (off_t)0, SEEK_END);
		EXIT(status);
	}
	if (getpid() != getmypid())
		_exit(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x3ca0(%rip)      # 0x81b4
cmpq $0x0, 0x3c8c(%rip)      # 0x81a8
jne 0x455a
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2150
callq 0x20e0
movl %eax, -0x8(%rbp)
callq 0x48c0
movl %eax, %ecx
movl -0x8(%rbp), %eax
cmpl %ecx, %eax
jne 0x454f
movl 0x3c6a(%rip), %edi      # 0x81b4
callq 0x2250
movl 0x3c5f(%rip), %edi      # 0x81b4
callq 0x2080
callq 0x20e0
movl %eax, -0xc(%rbp)
callq 0x48c0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
je 0x457b
movl 0x3c3e(%rip), %edi      # 0x81b4
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/sasignal.c
// Function: sasignal
action_type
sasignal(int sig, action_type act)
{
	struct sigaction a, oa;

	(void)memset(&a, 0, sizeof(a));
	(void)sigemptyset(&a.sa_mask);
	(void)sigaddset(&a.sa_mask, sig);

	a.sa_handler = act;
	a.sa_flags   = SA_RESTART;

	if (sigaction(sig, &a, &oa) < 0)
		return SIG_ERR;

	return oa.sa_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2160
leaq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x21d0
leaq -0xb0(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0x2290
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x10000000, -0x28(%rbp) # imm = 0x10000000
movl -0xc(%rbp), %edi
leaq -0xb0(%rbp), %rsi
leaq -0x148(%rbp), %rdx
callq 0x20b0
cmpl $0x0, %eax
jge 0x5112
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x511d
movq -0x148(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/client.c
// Function: clientSend
void clientSend(int fd, char *filename)
{
  char buf[MAXLINE];
  char hostname[MAXLINE];

  Gethostname(hostname, MAXLINE);

  /* Form and send the HTTP request */
  sprintf(buf, "GET %s HTTP/1.1\n", filename);
  sprintf(buf, "%shost: %s\n\r\n", buf, hostname);
  Rio_writen(fd, buf, strlen(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x4010(%rbp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x1770
leaq -0x2010(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1c1f(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1230
leaq -0x2010(%rbp), %rdi
leaq -0x2010(%rbp), %rdx
leaq -0x4010(%rbp), %rcx
leaq 0x1c0d(%rip), %rsi      # 0x3015
movb $0x0, %al
callq 0x1230
movl -0x4(%rbp), %eax
movl %eax, -0x401c(%rbp)
leaq -0x2010(%rbp), %rax
movq %rax, -0x4018(%rbp)
leaq -0x2010(%rbp), %rdi
callq 0x1080
movl -0x401c(%rbp), %edi
movq -0x4018(%rbp), %rsi
movq %rax, %rdx
callq 0x2210
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/client.c
// Function: clientPrint
void clientPrint(int fd)
{
  rio_t rio;
  char buf[MAXBUF];  
  int length = 0;
  int n;
  
  Rio_readinitb(&rio, fd);

  /* Read and display the HTTP Header */
  n = Rio_readlineb(&rio, buf, MAXBUF);
  while (strcmp(buf, "\r\n") && (n > 0)) {
    printf("Header: %s", buf);
    n = Rio_readlineb(&rio, buf, MAXBUF);

    /* If you want to look for certain HTTP tags... */
    if (sscanf(buf, "Content-Length: %d ", &length) == 1) {
      printf("Length = %d\n", length);
    }
  }

  /* Read and display the HTTP Body */
  n = Rio_readlineb(&rio, buf, MAXBUF);
  while (n > 0) {
    printf("%s", buf);
    n = Rio_readlineb(&rio, buf, MAXBUF);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4030, %rsp           # imm = 0x4030
movl %edi, -0x4(%rbp)
movl $0x0, -0x4024(%rbp)
movl -0x4(%rbp), %esi
leaq -0x2018(%rbp), %rdi
callq 0x2250
leaq -0x4020(%rbp), %rsi
leaq -0x2018(%rbp), %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x22d0
movl %eax, -0x4028(%rbp)
leaq -0x4020(%rbp), %rdi
leaq 0x1b7d(%rip), %rsi      # 0x3020
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x4029(%rbp)
je 0x14c7
cmpl $0x0, -0x4028(%rbp)
setg %al
movb %al, -0x4029(%rbp)
movb -0x4029(%rbp), %al
testb $0x1, %al
jne 0x14d3
jmp 0x1540
leaq -0x4020(%rbp), %rsi
leaq 0x1b42(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x10c0
leaq -0x4020(%rbp), %rsi
leaq -0x2018(%rbp), %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x22d0
movl %eax, -0x4028(%rbp)
leaq -0x4020(%rbp), %rdi
leaq 0x1b1a(%rip), %rsi      # 0x302e
leaq -0x4024(%rbp), %rdx
movb $0x0, %al
callq 0x1190
cmpl $0x1, %eax
jne 0x153b
movl -0x4024(%rbp), %esi
leaq 0x1b0e(%rip), %rdi      # 0x3042
movb $0x0, %al
callq 0x10c0
jmp 0x1495
leaq -0x4020(%rbp), %rsi
leaq -0x2018(%rbp), %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x22d0
movl %eax, -0x4028(%rbp)
cmpl $0x0, -0x4028(%rbp)
jle 0x159c
leaq -0x4020(%rbp), %rsi
leaq 0x1ab6(%rip), %rdi      # 0x302b
movb $0x0, %al
callq 0x10c0
leaq -0x4020(%rbp), %rsi
leaq -0x2018(%rbp), %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x22d0
movl %eax, -0x4028(%rbp)
jmp 0x155e
addq $0x4030, %rsp           # imm = 0x4030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/client.c
// Function: main
int main(int argc, char *argv[])
{
  char *host, *filename;
  int port;
  int clientfd;

  if (argc != 4) {
    fprintf(stderr, "Usage: %s <host> <port> <filename>\n", argv[0]);
    exit(1);
  }

  host = argv[1];
  port = atoi(argv[2]);
  filename = argv[3];

  /* Open a single connection to the specified host and port */
  clientfd = Open_clientfd(host, port);
  
  clientSend(clientfd, filename);
  clientPrint(clientfd);
    
  Close(clientfd);

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x15f5
movq 0x3a25(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1a6b(%rip), %rsi      # 0x304f
movb $0x0, %al
callq 0x1150
movl $0x1, %edi
callq 0x1240
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1200
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2530
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x13b0
movl -0x28(%rbp), %edi
callq 0x1450
movl -0x28(%rbp), %edi
callq 0x19d0
xorl %edi, %edi
callq 0x1240
nop
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: rio_readn
ssize_t rio_readn(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nread = read(fd, bufp, nleft)) < 0) {
            if (errno == EINTR) /* interrupted by sig handler return */
                nread = 0;      /* and call read() again */
            else
                return -1;      /* errno set by read() */ 
        } 
        else if (nread == 0)
            break;              /* EOF */
        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);         /* return >= 0 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x1e5c
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1110
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x1e34
callq 0x1030
cmpl $0x4, (%rax)
jne 0x1e28
movq $0x0, -0x30(%rbp)
jmp 0x1e32
movq $-0x1, -0x8(%rbp)
jmp 0x1e68
jmp 0x1e3f
cmpq $0x0, -0x30(%rbp)
jne 0x1e3d
jmp 0x1e5c
jmp 0x1e3f
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1df3
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: rio_writen
ssize_t rio_writen(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nwritten;
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nwritten = write(fd, bufp, nleft)) <= 0) {
            if (errno == EINTR)  /* interrupted by sig handler return */
                nwritten = 0;    /* and call write() again */
            else
                return -1;       /* errorno set by write() */
        }
        nleft -= nwritten;
        bufp += nwritten;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x1f01
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jg 0x1ee4
callq 0x1030
cmpl $0x4, (%rax)
jne 0x1ed8
movq $0x0, -0x30(%rbp)
jmp 0x1ee2
movq $-0x1, -0x8(%rbp)
jmp 0x1f09
jmp 0x1ee4
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1ea3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: rio_readnb
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;
    
    while (nleft > 0) {
        if ((nread = rio_read(rp, bufp, nleft)) < 0) {
            if (errno == EINTR) /* interrupted by sig handler return */
                nread = 0;      /* call read() again */
            else
                return -1;      /* errno set by read() */ 
        } 
        else if (nread == 0)
            break;              /* EOF */
        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);         /* return >= 0 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x1fee
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2010
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x1fc6
callq 0x1030
cmpl $0x4, (%rax)
jne 0x1fba
movq $0x0, -0x30(%rbp)
jmp 0x1fc4
movq $-0x1, -0x8(%rbp)
jmp 0x1ffa
jmp 0x1fd1
cmpq $0x0, -0x30(%rbp)
jne 0x1fcf
jmp 0x1fee
jmp 0x1fd1
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1f84
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: rio_read
static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0) {  /* refill if buf is empty */
        rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, 
                           sizeof(rp->rio_buf));
        if (rp->rio_cnt < 0) {
            if (errno != EINTR) /* interrupted by sig handler return */
                return -1;
        }
        else if (rp->rio_cnt == 0)  /* EOF */
            return 0;
        else 
            rp->rio_bufptr = rp->rio_buf; /* reset buffer ptr */
    }

    /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
    cnt = n;          
    if (rp->rio_cnt < n)   
        cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt;
    rp->rio_cnt -= cnt;
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x209a
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x1110
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x2072
callq 0x1030
cmpl $0x4, (%rax)
je 0x2070
movq $-0x1, -0x8(%rbp)
jmp 0x20fa
jmp 0x2098
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2086
movq $0x0, -0x8(%rbp)
jmp 0x20fa
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2098
jmp 0x2024
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x20b9
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x1170
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: rio_readlineb
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
{
    int n, rc;
    char c, *bufp = usrbuf;

    for (n = 1; n < maxlen; n++) { 
        if ((rc = rio_read(rp, &c, 1)) == 1) {
            *bufp++ = c;
            if (c == '\n')
                break;
        } else if (rc == 0) {
            if (n == 1)
                return 0; /* EOF, no data read */
            else
                break;    /* EOF, some data was read */
        } else
            return -1;    /* error */
    }
    *bufp = 0;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x21a7
movq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
movl $0x1, %edx
callq 0x2010
movl %eax, -0x28(%rbp)
cmpl $0x1, %eax
jne 0x2178
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movsbl -0x29(%rbp), %eax
cmpl $0xa, %eax
jne 0x2176
jmp 0x21a7
jmp 0x219a
cmpl $0x0, -0x28(%rbp)
jne 0x2190
cmpl $0x1, -0x24(%rbp)
jne 0x218e
movq $0x0, -0x8(%rbp)
jmp 0x21b6
jmp 0x21a7
movq $-0x1, -0x8(%rbp)
jmp 0x21b6
jmp 0x219c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2133
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/cs537.c
// Function: open_clientfd
int open_clientfd(char *hostname, int port) 
{
    int clientfd;
    struct hostent *hp;
    struct sockaddr_in serveraddr;

    if ((clientfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return -1; /* check errno for cause of error */

    /* Fill in the server's IP address and port */
    if ((hp = gethostbyname(hostname)) == NULL)
        return -2; /* check h_errno for cause of error */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    bcopy((char *)hp->h_addr, 
          (char *)&serveraddr.sin_addr.s_addr, hp->h_length);
    serveraddr.sin_port = htons(port);

    /* Establish a connection with the server */
    if (connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr)) < 0)
        return -1;
    return clientfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x12a0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0x2354
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23da
movq -0x10(%rbp), %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2370
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x23da
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movw $0x2, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x11d0
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x10a0
movw %ax, -0x2e(%rbp)
movl -0x18(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x1250
cmpl $0x0, %eax
jge 0x23d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23da
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)