LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/neovim[P]libvterm/src/vterm.c
// Function: default_malloc
static void *default_malloc(size_t size, void *allocdata)
{
  void *ptr = malloc(size);
  if(ptr)
    memset(ptr, 0, size);
  return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2180
testq %rax, %rax
je 0xac14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x2100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: save_file
void save_file(char *file, void *buf, size_t len) {
  FILE *fhandle;
  if (file != NULL) {
    fhandle = fopen(file, "w");
    if (fhandle == NULL) {
      fprintf(stderr, "Unable to open %s\n", file);
      exit(1);
    }
    for (size_t i = 0; i < len; ++i)
      fprintf(fhandle, "%02hhx", ((uint8_t *)buf)[i]);
    fprintf(fhandle, "\n");
    fclose(fhandle);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1558
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x3b1a(%rip), %rsi      # 0x501e
callq 0x10c0
testq %rax, %rax
je 0x1562
movq %rax, %r15
testq %rbx, %rbx
je 0x153a
leaq 0x3af3(%rip), %r12      # 0x5010
xorl %r13d, %r13d
movzbl (%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x10a0
incq %r13
cmpq %r13, %rbx
jne 0x1520
movl $0xa, %edi
movq %r15, %rsi
callq 0x1080
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1050
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: read_file
uint64_t read_file(const char *file, uint8_t *buf, size_t len) {
  size_t c = 0;
  FILE *fhandle;
  fhandle = fopen(file, "r");
  if (fhandle == NULL) {
    fprintf(stderr, "Unable to open %s\n", file);
    exit(3);
  }
  for (uint64_t i = 0; i < len; ++i) {
    c += fscanf(fhandle, "%02hhx", &buf[i]);
  }
  fclose(fhandle);
  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3e27(%rip), %rsi      # 0x53d0
callq 0x10c0
testq %rax, %rax
je 0x15fc
movq %rax, %r14
testq %rbx, %rbx
je 0x15e4
leaq 0x3a4e(%rip), %r13      # 0x5010
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1040
cltq
addq %rax, %r12
incq %r15
decq %rbx
jne 0x15c5
jmp 0x15e7
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1050
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x1144
// File: /workspace/github_c_makefile_star2_O1/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: read_stdin
uint64_t read_stdin(uint8_t *buf, uint64_t len) {
  uint64_t c = 0;
  for (uint64_t i = 0; i < len; ++i) {
    c += fscanf(stdin, "%02hhx", &buf[i]);
  }
  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x1649
movq %rsi, %rbx
movq %rdi, %r14
movq 0x69b1(%rip), %r13      # 0x7fd0
leaq 0x39ea(%rip), %r12      # 0x5010
xorl %r15d, %r15d
movq (%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1040
cltq
addq %rax, %r15
incq %r14
decq %rbx
jne 0x1629
jmp 0x164c
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/osh.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 > DUPFD0; fd--)
		(void)close(fd);
	for (fd--; fd > FD2; fd--)
		(void)close(fd);
}

// Assembly:
pushq %rbx
movl $0x4, %edi
callq 0x2340
leaq -0x1001(%rax), %rcx
decl %eax
cmpq $-0xfed, %rcx           # imm = 0xF013
movl $0x13, %ebx
cmovael %eax, %ebx
cmpl $0xb, %ebx
jl 0x2b81
movl %ebx, %edi
callq 0x21d0
leal -0x1(%rbx), %eax
cmpl $0xb, %ebx
movl %eax, %ebx
jg 0x2b6b
movl $0xa, %ebx
cmpl $0x4, %ebx
jl 0x2b97
incl %ebx
leal -0x2(%rbx), %edi
callq 0x21d0
decl %ebx
cmpl $0x4, %ebx
jg 0x2b88
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/osh.c
// Function: rc_init
static void
rc_init(int *rcflag)
{
	char path[PATHMAX];
	const char *file;

	while (*rcflag <= DO_INIT_DONE) {
		file = NULL;
		switch (*rcflag) {
		case DO_SYSTEM_LOGIN:
			file = PATH_SYSTEM_LOGIN;
			break;
		case DO_SYSTEM_OSHRC:
			if (!is_login)
				(*rcflag)++;
			file = PATH_SYSTEM_OSHRC;
			break;
		case DO_DOT_LOGIN:
			file = pn_build(path, FILE_DOT_LOGIN, sizeof(path));
			break;
		case DO_DOT_OSHRC:
			file = pn_build(path, FILE_DOT_OSHRC, sizeof(path));
			break;
		case DO_INIT_DONE:
			if (dup2(dupfd0, FD0) == -1)
				err(SH_ERR,FMT2S,getmyname(),strerror(errno));
			shtype &= ~ST_RCFILE;
			(*rcflag)++;
			return;
		default:
			shtype &= ~ST_RCFILE;
			return;
		}
		(*rcflag)++;
		if (rc_open(file))
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
leaq 0x69f0(%rip), %r13      # 0x95af
leaq 0x6542(%rip), %rbp      # 0x9108
leaq 0x69fb(%rip), %r14      # 0x95c8
movq %rsp, %r15
leaq 0x6a03(%rip), %r12      # 0x95da
movl (%rbx), %eax
cmpl $0x5, %eax
jg 0x2c84
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
ja 0x2c33
movslq (%rbp,%rcx,4), %rcx
addq %rbp, %rcx
movq %r13, %rdi
jmpq *%rcx
cmpb $0x0, 0x964a(%rip)      # 0xc248
movq %r14, %rdi
jne 0x2c26
incl %eax
movl %eax, (%rbx)
movq %r14, %rdi
jmp 0x2c26
movq %r15, %rdi
leaq 0x69cb(%rip), %rsi      # 0x95e1
jmp 0x2c1e
movq %r15, %rdi
movq %r12, %rsi
callq 0x672f
movq %r15, %rdi
incl (%rbx)
callq 0x67bf
testb %al, %al
je 0x2bd7
jmp 0x2c84
andb $-0x9, 0x9602(%rip)     # 0xc23c
jmp 0x2c84
movl 0xe73a(%rip), %edi      # 0x1137c
xorl %esi, %esi
callq 0x2160
cmpl $-0x1, %eax
jne 0x2c7b
callq 0x6b0f
movq %rax, %r14
callq 0x2070
movl (%rax), %edi
callq 0x2380
leaq 0x66d4(%rip), %rsi      # 0x933d
movl $0x2, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68c8
andb $-0x9, 0x95ba(%rip)     # 0xc23c
incl (%rbx)
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq %rsp, %rsi
xorl %edi, %edi
callq 0x2390
testl %eax, %eax
js 0x303c
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x303c
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21a0
testq %rax, %rax
jne 0x303c
callq 0x3296
cmpl $0x23, %eax
jne 0x3031
callq 0x3296
cmpl $0x21, %eax
jne 0x3031
movl $0x7fe, %r14d           # imm = 0x7FE
callq 0x3296
cmpl $-0x1, %eax
je 0x303c
cmpl $0xa, %eax
je 0x303c
decq %r14
jne 0x2ff9
callq 0x6b0f
leaq 0x6324(%rip), %rsi      # 0x933d
leaq 0x6231(%rip), %rcx      # 0x9251
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rdx
xorl %eax, %eax
callq 0x68c8
jmp 0x303c
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
movb $0x0, 0x922d(%rip)      # 0xc270
xorl %ebp, %ebp
leaq 0x6202(%rip), %r15      # 0x924e
leaq 0x61f8(%rip), %r12      # 0x924b
leaq 0x6595(%rip), %r14      # 0x95ef
movl 0x91dc(%rip), %eax      # 0xc23c
andl $0x1f, %eax
cmpl $0x4, %eax
jne 0x3086
cmpl $0x0, 0x91fd(%rip)      # 0xc26c
movq %r15, %rdx
je 0x3077
movq %r12, %rdx
movl $0x2, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x6a82
callq 0x2c96
cmpl $-0x1, %eax
je 0x30b4
testb %bl, %bl
je 0x309d
cmpb $0x0, 0x91d5(%rip)      # 0xc270
jne 0x30c4
movb $0x1, %bpl
cmpb $0x1, 0x91a1(%rip)      # 0xc248
jne 0x305a
cmpl $0x0, 0x91a0(%rip)      # 0xc250
je 0x305a
jmp 0x30c4
testb $0x1, %bpl
jne 0x30c4
movl $0x0, 0x91a4(%rip)      # 0xc268
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x1, 0x916d(%rip)      # 0xc248
jne 0x312e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
leaq 0x650c(%rip), %r12      # 0x9601
leaq 0x651f(%rip), %r14      # 0x961b
movq %rsp, %r15
movl (%rbx), %eax
cmpl $0x3, %eax
jg 0x314f
movq %r12, %rdi
cmpl $0x1, %eax
je 0x3121
cmpl $0x2, %eax
jne 0x3136
movq %r15, %rdi
movq %r14, %rsi
callq 0x672f
movq %r15, %rdi
incl (%rbx)
callq 0x67bf
testb %al, %al
je 0x30ff
jmp 0x314f
andb $-0x9, 0x9107(%rip)     # 0xc23c
retq
cmpl $0x3, %eax
jne 0x3148
andb $-0x9, 0x90fa(%rip)     # 0xc23c
incl %eax
movl %eax, (%rbx)
jmp 0x314f
andb $-0x9, 0x90ed(%rip)     # 0xc23c
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xb99b(%rip), %rbx      # 0xeb08
testq %rdi, %rdi
je 0x31a8
testq %rbx, %rbx
je 0x31dc
movq %rdi, %r15
movb (%rdi), %bpl
movq %rbx, %r12
movq %rbx, %r14
movq 0x8(%r14), %rsi
cmpb (%rsi), %bpl
jne 0x3198
movq %r15, %rdi
callq 0x2230
testl %eax, %eax
je 0x31e5
movq %r14, %r12
movq (%r14), %rax
movq %rax, %r14
testq %rax, %rax
jne 0x3183
jmp 0x31dc
testq %rbx, %rbx
je 0x31dc
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31bb
callq 0x2050
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x31c9
callq 0x2050
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2050
movq %r14, %rbx
testq %r14, %r14
jne 0x31ad
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r14
leaq 0xb919(%rip), %rax      # 0xeb08
cmoveq %rax, %r12
movq (%r14), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3208
callq 0x2050
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x3216
callq 0x2050
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x89c8(%rip), %r14      # 0xbc00
leaq 0x8b01(%rip), %r15      # 0xbd40
movq %r15, %rax
subq %r14, %rax
movq %rax, %rcx
sarq $0x4, %rcx
shrq $0x3f, %rax
addq %rcx, %rax
andq $-0x2, %rax
leaq (%r14,%rax,8), %r12
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
je 0x3285
jg 0x3272
movq %r12, %r15
jmp 0x3279
addq $0x10, %r12
movq %r12, %r14
cmpq %r15, %r14
jb 0x323f
movl $0x14, %eax
jmp 0x328a
movl 0x8(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq 0x8fd6(%rip), %rax      # 0xc278
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
je 0x332b
testq %rax, %rax
jne 0x32dd
movq 0x8f87(%rip), %rax      # 0xc240
cmpq $-0x1, %rax
je 0x332b
testq %rax, %rax
jne 0x32ff
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2200
cmpq $0x1, %rax
je 0x3326
jmp 0x332b
leaq 0x1(%rax), %rcx
movq %rcx, 0x8f90(%rip)      # 0xc278
movb (%rax), %al
movb %al, 0xf(%rsp)
testb %al, %al
jne 0x3326
movq $-0x1, 0x8f7b(%rip) # 0xc278
jmp 0x3321
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8f34(%rip)      # 0xc240
movb (%rax), %al
movb %al, 0xf(%rsp)
testb %al, %al
jne 0x3326
movq $-0x1, 0x8f1f(%rip) # 0xc240
movb $0xa, 0xf(%rsp)
movzbl 0xf(%rsp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x3da7
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3da8
cmpl $0x3, %eax
je 0x3dbb
cmpl $0x4, %eax
jne 0x3de0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3d93
callq 0x2050
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3da1
callq 0x2050
movq 0x10(%rbx), %rdi
jmp 0x3db4
retq
movq (%rbx), %rdi
callq 0x3d67
movq 0x8(%rbx), %rdi
callq 0x3d67
jmp 0x3de0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3dc9
callq 0x2050
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3dd7
callq 0x2050
movq 0x28(%rbx), %rdi
callq 0x4a9f
movq %rbx, %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xa202(%rip), %r15      # 0xeb08
testq %r15, %r15
je 0x4932
movq %rdi, %r14
movb (%rdi), %bpl
xorl %ebx, %ebx
movq 0x8(%r15), %rsi
cmpb (%rsi), %bpl
jne 0x4928
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x4936
movq (%r15), %r15
testq %r15, %r15
jne 0x4913
jmp 0x493a
xorl %ebx, %ebx
jmp 0x493a
movq 0x10(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/osh.c
// Function: rp_alias
static const char **
rp_alias(const char *string)
{
	struct tnode *t;
	sigset_t nmask, omask;
	char *wp;

	asp = string;
	linep  = aline;
	elinep = &aline[LINEMAX - 5];
	wordp  = aword;
	ewordp = &aword[WORDMAX - 5];
	error  = false;
	error_message = NULL;
	nul_count = 0;
	do {
		wp = linep;
		if (get_word() == EOF) {
			error_message = ERR_SYNTAX;/* same as: ([...] \) */
			asp = NULL;
			return NULL;
		}
	} while (*wp != EOL);
	*wordp = NULL;

	if (error) {
		asp = NULL;
		return NULL;
	}

	if (wordp - aword > 1) {
		if (any(**aword, ";&")) {
			error_message = ERR_SYNTAX;/* same as: (;) or (&) */
			asp = NULL;
			return NULL;
		}
		(void)sigfillset(&nmask);
		(void)sigprocmask(SIG_SETMASK, &nmask, &omask);
		t = NULL;
		t = syntax(aword, wordp);
		(void)sigprocmask(SIG_SETMASK, &omask, NULL);
		if (error) {
			tfree(t);
			t = NULL;
			asp = NULL;
			return NULL;
		}
		tfree(t);
		t = NULL;
		asp = NULL;
		return (const char **)aword;
	}
	error_message = ERR_SYNTAX;/* same as: () */
	asp = NULL;
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x791b(%rip)      # 0xc278
leaq 0xa1ac(%rip), %rax      # 0xeb10
movq %rax, 0x8115(%rip)      # 0xca80
leaq 0xa999(%rip), %rax      # 0xf30b
movq %rax, 0x810f(%rip)      # 0xca88
leaq 0xa990(%rip), %rbx      # 0xf310
movq %rbx, 0xa109(%rip)      # 0xea90
leaq 0xc95a(%rip), %rax      # 0x112e8
movq %rax, 0xa103(%rip)      # 0xea98
movb $0x0, 0xa104(%rip)      # 0xeaa0
movq $0x0, 0xa101(%rip) # 0xeaa8
movl $0x0, 0xa0ff(%rip)      # 0xeab0
movq 0x80c8(%rip), %r14      # 0xca80
callq 0x3333
cmpl $-0x1, %eax
je 0x4a09
cmpb $0xa, (%r14)
jne 0x49b1
movq 0xa0c1(%rip), %rax      # 0xea90
movq $0x0, (%rax)
cmpb $0x1, 0xa0c3(%rip)      # 0xeaa0
je 0x4a17
subq %rbx, %rax
cmpq $0x9, %rax
jl 0x4a09
movq 0xa921(%rip), %rax      # 0xf310
movb (%rax), %al
leaq 0x48ff(%rip), %rcx      # 0x92f7
movb (%rcx), %dl
testb %dl, %dl
je 0x4a05
incq %rcx
cmpb %al, %dl
jne 0x49f8
testb %dl, %dl
je 0x4a36
leaq 0x4855(%rip), %rax      # 0x9265
movq %rax, 0xa091(%rip)      # 0xeaa8
movq $0x0, 0x7856(%rip) # 0xc278
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x2290
leaq 0x8(%rsp), %r15
movl $0x2, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2040
movq 0xa02e(%rip), %rsi      # 0xea90
movq %rbx, %rdi
callq 0x35ec
movq %rax, %r14
xorl %r12d, %r12d
movl $0x2, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2040
cmpb $0x0, 0xa01a(%rip)      # 0xeaa0
cmovneq %r12, %rbx
movq %r14, %rdi
callq 0x3d67
movq $0x0, 0x77db(%rip) # 0xc278
jmp 0x4a24
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x4adf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4ad0
leaq 0x8(%rbx), %r14
callq 0x2050
movq $0x0, -0x8(%r14)
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x4ab7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movl $0x21, %ecx
movabsq $0x200000020000100, %rdx # imm = 0x200000020000100
movb (%rax), %sil
movzbl %sil, %edi
leal -0x22(%rdi), %r8d
cmpl $0x3a, %r8d
ja 0x5cd1
btq %r8, %rcx
jae 0x5cba
incq %rax
movb (%rax), %dil
cmpb %sil, %dil
je 0x5cd5
incq %rax
testb %dil, %dil
jne 0x5ca8
jmp 0x5cda
cmpq $0x3a, %r8
jne 0x5ccb
cmpb $0x0, 0x1(%rax)
je 0x5cda
incq %rax
jmp 0x5cd5
btq %r8, %rdx
jb 0x5cdc
testl %edi, %edi
je 0x5cda
incq %rax
jmp 0x5c8e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb62d(%rip), %r14      # 0x11318
cmpq 0xb62e(%rip), %r14      # 0x11320
jne 0x5d81
movl 0x64fe(%rip), %eax      # 0xc1fc
leal (%rax,%rax), %ecx
movl %ecx, 0x64f5(%rip)      # 0xc1fc
subq %rbx, %r14
shll $0x8, %eax
leaq (%r14,%rax,8), %rsi
andq $-0x8, %rsi
movq %rbx, %rdi
callq 0x2310
movq %rax, %rbx
testq %rax, %rax
jne 0x5d5f
callq 0x2100
movl %eax, %ebp
callq 0x6b25
cmpl %eax, %ebp
movl $0x2, %eax
movl $0x7c, %ebp
cmovel %eax, %ebp
callq 0x6b0f
leaq 0x35f1(%rip), %rsi      # 0x933d
leaq 0x3581(%rip), %rcx      # 0x92d4
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x68c8
addq %rbx, %r14
movq %r14, 0xb5af(%rip)      # 0x11318
movl 0x648d(%rip), %eax      # 0xc1fc
shll $0x7, %eax
leaq (%r14,%rax,8), %rax
addq $-0x8, %rax
movq %rax, 0xb59f(%rip)      # 0x11320
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/osh.c
// Function: atrim
static char *
atrim(UChar *ap)
{
	size_t siz;
	UChar buf[LINEMAX], c;
	UChar *a, *b;

	*buf = UCHAR(EOS);
	for (a = ap, b = buf; b < &buf[LINEMAX]; a++, b++) {
		switch (*a) {
		case EOS:
			*b = UCHAR(EOS);
			siz = (b - buf) + 1;
			(void)memcpy(ap, buf, siz);
			return (char *)ap;
		case DQUOT:
		case SQUOT:
			c = *a++;
			while (*a != c && b < &buf[LINEMAX]) {
				if (*a == EOS)
					goto aterr;
				*b++ = *a++;
			}
			b--;
			continue;
		case BQUOT:
			if (*++a == EOS) {
				a--, b--;
				continue;
			}
			break;
		}
		*b = *a;
	}

aterr:
	err(ESTATUS, "%s: %s %s\n", getmyname(), ERR_TRIM, (const char *)ap);
	/*NOTREACHED*/
	return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
movb $0x0, (%rsp)
xorl %edx, %edx
movq %rdi, %rax
movb (%rax), %cl
movzbl %cl, %esi
cmpl $0x26, %esi
jle 0x5dbd
cmpl $0x27, %esi
je 0x5dc2
cmpl $0x5c, %esi
jne 0x5e0b
cmpb $0x0, 0x1(%rax)
je 0x5e13
incq %rax
jmp 0x5e0b
cmpl $0x22, %esi
jne 0x5e07
movb 0x1(%rax), %sil
incq %rax
cmpb %cl, %sil
sete %dil
cmpq $0x800, %rdx            # imm = 0x800
setge %r8b
orb %dil, %r8b
jne 0x5e13
testb %sil, %sil
je 0x5e29
leaq 0x1(%rdx), %rdi
movb %sil, (%rsp,%rdx)
movb 0x1(%rax), %sil
incq %rax
cmpb %cl, %sil
je 0x5e16
cmpq $0x7ff, %rdx            # imm = 0x7FF
movq %rdi, %rdx
jl 0x5de0
jmp 0x5e16
testl %esi, %esi
je 0x5e75
movb (%rax), %cl
movb %cl, (%rsp,%rdx)
incq %rdx
movq %rdx, %rdi
incq %rax
movq %rdi, %rdx
cmpq $0x800, %rdi            # imm = 0x800
jl 0x5d9e
callq 0x2100
movl %eax, %ebp
callq 0x6b25
cmpl %eax, %ebp
movl $0x2, %eax
movl $0x7c, %ebp
cmovel %eax, %ebp
callq 0x6b0f
leaq 0x3549(%rip), %rsi      # 0x9399
leaq 0x354d(%rip), %rcx      # 0x93a4
movl %ebp, %edi
movq %rax, %rdx
movq %rbx, %r8
xorl %eax, %eax
callq 0x68c8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %rbp
retq
movb $0x0, (%rsp,%rdx)
incq %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x22a0
jmp 0x5e68
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/osh.c
// Function: gcat
static char *
gcat(const char *src1, const char *src2, bool slash)
{
	size_t siz;
	char *b, buf[PATHMAX], c, *dst;
	const char *s;

	if (src1 == NULL || src2 == NULL) {
		/* never true, but appease splint(1) */
		err(-2, FMT2S, getmyname(), "gcat: Invalid argument");
		return NULL;
	}

	*buf = EOS, b = buf, s = src1;
	while ((c = *s++) != EOS) {
		if (b >= &buf[PATHMAX - 1]) {
			err(-2, FMT2S, getmyname(), strerror(ENAMETOOLONG));
			return NULL;
		}
		*b++ = c;
	}
	if (slash)
		*b++ = SLASH;
	s = src2;
	do {
		if (b >= &buf[PATHMAX]) {
			err(-2, FMT2S, getmyname(), strerror(ENAMETOOLONG));
			return NULL;
		}
		*b++ = c = *s++;
	} while (c != EOS);

	siz = b - buf;
	gavtot += siz;
	if (gavtot > GAVMAX) {
		err(-2, FMT2S, getmyname(), ERR_E2BIG);
		return NULL;
	}
	dst = xmalloc(siz);

	(void)memcpy(dst, buf, siz);
	return dst;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x5ec6
callq 0x6b0f
leaq 0x348e(%rip), %rsi      # 0x933d
leaq 0x34fa(%rip), %rcx      # 0x93b0
xorl %r14d, %r14d
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movq %rax, %rdx
jmp 0x5f72
movb $0x0, (%rsp)
movb (%rdi), %al
testb %al, %al
je 0x5ef3
xorl %ecx, %ecx
cmpq $0xfff, %rcx            # imm = 0xFFF
je 0x5f4b
leaq 0x1(%rcx), %rbx
movb %al, (%rsp,%rcx)
movb 0x1(%rdi,%rcx), %al
movq %rbx, %rcx
testb %al, %al
jne 0x5ed2
leaq (%rsp,%rbx), %rax
jmp 0x5ef8
movq %rsp, %rax
xorl %ebx, %ebx
testb %dl, %dl
je 0x5f02
incq %rbx
movb $0x2f, (%rax)
cmpq $0x1000, %rbx           # imm = 0x1000
jae 0x5f4b
movb (%rsi), %al
incq %rsi
movb %al, (%rsp,%rbx)
incq %rbx
testb %al, %al
jne 0x5f02
movq 0xb3ef(%rip), %rax      # 0x11310
addq %rbx, %rax
movq %rax, 0xb3e5(%rip)      # 0x11310
cmpq $0x100001, %rax         # imm = 0x100001
jb 0x5f87
callq 0x6b0f
leaq 0x33fe(%rip), %rsi      # 0x933d
leaq 0x3481(%rip), %rcx      # 0x93c7
jmp 0x5eb6
callq 0x6b0f
movq %rax, %rbx
movl $0x24, %edi
callq 0x2380
leaq 0x33d9(%rip), %rsi      # 0x933d
xorl %r14d, %r14d
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68c8
movq %r14, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x42ee
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x22a0
jmp 0x5f79
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x6261
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6253
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x6253
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x6253
movq 0x896e(%rip), %r15      # 0xeb08
testq %r15, %r15
je 0x61d7
movq %r15, %rax
movq %r15, %r13
movq %rax, %r12
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x61eb
js 0x6238
movq (%r12), %rax
movq %r12, %r13
testq %rax, %rax
jne 0x61a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6593
movq %rax, (%r12)
jmp 0x6253
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6593
movq %rax, 0x891f(%rip)      # 0xeb08
jmp 0x6253
movq 0x10(%r12), %r14
cmpb (%r14), %bpl
jne 0x6204
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
je 0x6253
movq %r14, %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2130
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x42ee
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22a0
movq %r15, 0x10(%r12)
jmp 0x6253
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6593
cmpq %r15, %r12
je 0x6262
movq (%r13), %rcx
movq %rcx, (%rax)
movq %rax, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x889f(%rip), %rcx      # 0xeb08
movq %rcx, (%rax)
jmp 0x61e2
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x18, %edi
callq 0x42ee
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x2130
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x42ee
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22a0
movq %r13, 0x8(%r14)
movq %rbx, %rdi
callq 0x2130
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x42ee
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x22a0
movq %r12, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x663a
cmpq $0x1, %rsi
jne 0x6684
cmpl $0xf, %edi
je 0x666a
cmpl $0x3, %edi
je 0x6654
cmpl $0x2, %edi
jne 0x6684
movl 0xad3f(%rip), %eax      # 0x11374
orl $0x1, %eax
jmp 0x667e
cmpl $0xf, %edi
je 0x6675
cmpl $0x3, %edi
je 0x665f
cmpl $0x2, %edi
jne 0x6684
movl 0xad25(%rip), %eax      # 0x11374
andl $-0x2, %eax
jmp 0x667e
movl 0xad1a(%rip), %eax      # 0x11374
orl $0x2, %eax
jmp 0x667e
movl 0xad0f(%rip), %eax      # 0x11374
andl $-0x3, %eax
jmp 0x667e
movl 0xad04(%rip), %eax      # 0x11374
orl $0x4, %eax
jmp 0x667e
movl 0xacf9(%rip), %eax      # 0x11374
andl $-0x5, %eax
movl %eax, 0xacf0(%rip)      # 0x11374
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testl %edi, %edi
je 0x66aa
cmpl $-0x1, %edi
je 0x66a0
cmpl $-0x2, %edi
jne 0x66f5
movl $0x2, 0x5bca(%rip)      # 0xc268
jmp 0x66f3
movl $0x2, 0x5bbe(%rip)      # 0xc268
movl 0x5b8c(%rip), %eax      # 0xc23c
testb $0x10, %al
jne 0x66d8
testb $0x8, %al
je 0x66ef
movl 0x5baa(%rip), %ecx      # 0xc268
andl $-0x2, %ecx
cmpl $0x82, %ecx
jne 0x66ef
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
popq %rbx
jmp 0x21a0
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movb $0x1, 0x5b83(%rip)      # 0xc270
jmp 0x66f3
testb $0x4, %al
je 0x66fd
popq %rbx
retq
movl %edi, 0x5b6d(%rip)      # 0xc268
jmp 0x670f
testb $0x1, %al
jne 0x670f
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
callq 0x2100
movl %eax, %ebx
callq 0x6b25
movl 0x5b47(%rip), %edi      # 0xc268
cmpl %eax, %ebx
jne 0x672a
callq 0x2370
callq 0x2080
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
leaq 0x2b6b(%rip), %rdi      # 0x92b2
callq 0x2030
testq %rax, %rax
je 0x67b0
movq %rax, %r15
cmpb $0x0, (%rax)
je 0x67b0
leaq 0x2e8c(%rip), %rdx      # 0x95ec
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x2170
cmpl $0x1000, %eax           # imm = 0x1000
jb 0x67b0
callq 0x6b0f
movq %rax, %r12
movl $0x24, %edi
callq 0x2380
leaq 0x2e5d(%rip), %rsi      # 0x95f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x68c8
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x90, %rsp
testq %rdi, %rdi
je 0x6884
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x6884
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
callq 0x2320
cmpl $-0x1, %eax
je 0x6887
movl %eax, %ebp
movq %rsp, %rsi
movl %eax, %edi
callq 0x2390
testl %eax, %eax
js 0x6896
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x6896
movl %ebp, %edi
xorl %esi, %esi
callq 0x2160
cmpl $-0x1, %eax
je 0x6841
xorl %edi, %edi
movl $0x4, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x20d0
cmpl $-0x1, %eax
jne 0x6871
callq 0x6b0f
movq %rax, %r14
callq 0x2070
movl (%rax), %edi
callq 0x2380
leaq 0x2add(%rip), %rsi      # 0x9339
movl $0x2, %edi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x68c8
movl %ebp, %edi
callq 0x21d0
orb $0x8, 0x59bd(%rip)      # 0xc23c
movb $0x1, %r14b
jmp 0x6887
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x6b0f
leaq 0x2a97(%rip), %rsi      # 0x9339
leaq 0x2a9c(%rip), %r8       # 0x9345
xorl %r14d, %r14d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x68c8
movl %ebp, %edi
callq 0x21d0
jmp 0x6887
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
cmpl $0x0, 0xa7b1(%rip)      # 0x11390
jne 0x6bed
leaq -0x42(%rip), %rdi       # 0x6ba6
callq 0x6b34
addl $-0x4, %r14d
cmpl $0x6, %r14d
jae 0x6c4e
movl $0x39, %eax
btl %r14d, %eax
jae 0x6c4e
movl %r14d, %eax
leaq 0x51a4(%rip), %rcx      # 0xbdb0
movl 0xa77e(%rip), %edx      # 0x11390
leal 0x1(%rdx), %esi
movl %esi, 0xa775(%rip)      # 0x11390
movl %edx, 0xa773(%rip)      # 0x11394
movl %ebp, %edi
movq %rbx, %rsi
callq *(%rcx,%rax,8)
movl 0xa761(%rip), %ecx      # 0x11390
leal -0x1(%rcx), %edx
movl %edx, 0xa758(%rip)      # 0x11390
cmpl 0xa756(%rip), %ecx      # 0x11394
jle 0x6c46
movl %eax, 0xa752(%rip)      # 0x11398
movl 0xa74c(%rip), %ebx      # 0x11398
jmp 0x6c75
callq 0x6b0f
leaq 0x26e3(%rip), %rsi      # 0x933d
leaq 0x2a17(%rip), %rcx      # 0x9678
movl $0x7c, %ebx
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x68c8
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %r12d
leaq 0x8(%rsi), %r15
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x6cb2
cmpb $0x2d, (%rdi)
jne 0x6cb2
movq %rsi, %r14
leaq 0x29e6(%rip), %rsi      # 0x968f
callq 0x2230
testl %eax, %eax
je 0x6d2a
xorl %ebp, %ebp
testl %r12d, %r12d
jle 0x6cfa
movslq %r12d, %rax
leaq (%r15,%rax,8), %r14
leaq 0x260c(%rip), %r12      # 0x92d3
leaq 0x2581(%rip), %r13      # 0x924f
leaq 0x25f6(%rip), %rbx      # 0x92cb
movq (%r15), %rdx
addq $0x8, %r15
cmpq %r14, %r15
movq %r12, %rcx
cmovbq %r13, %rcx
movl $0x1, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6a82
cmpq %r14, %r15
jb 0x6cd5
testb %bpl, %bpl
jne 0x6d19
leaq 0x263b(%rip), %rsi      # 0x9341
leaq 0x25c6(%rip), %rdx      # 0x92d3
movl $0x1, %edi
xorl %eax, %eax
callq 0x6a82
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0x2, %ebx
addq $0x10, %r14
movb $0x1, %bpl
movq %r14, %r15
movl %ebx, %r12d
jmp 0x6cb4
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
callq 0x6b41
cmpl $0x2, %ebp
jl 0x71f7
movl %ebp, 0xa1e4(%rip)      # 0x113a8
movq %rbx, 0xa1e5(%rip)      # 0x113b0
movl $0x1, 0xa1e3(%rip)      # 0x113b8
callq 0x7206
movl %eax, %ebx
testb %al, %al
je 0x71f9
movl 0xa1d2(%rip), %eax      # 0x113b8
cmpl 0xa1bc(%rip), %eax      # 0x113a8
jge 0x71f9
xorl %edi, %edi
callq 0x7257
jmp 0x71f9
xorl %ebx, %ebx
xorb $0x1, %bl
movzbl %bl, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0x24df(%rip), %rbx      # 0x96f3
callq 0x7476
movl %eax, %ebp
movl $0x1, %edi
callq 0x7509
testq %rax, %rax
je 0x7243
cmpb $0x2d, (%rax)
jne 0x7243
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
testl %eax, %eax
jne 0x7243
orb %bpl, %r14b
jmp 0x7214
decl 0xa16f(%rip)            # 0x113b8
orb %r14b, %bpl
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %r15b
leaq 0x226f(%rip), %rbx      # 0x96f6
leaq 0x1d5b(%rip), %r14      # 0x91e9
movl $0x1, %edi
callq 0x7509
testq %rax, %rax
je 0x74b1
cmpb $0x21, (%rax)
jne 0x74b1
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
je 0x74e6
decl 0x9f01(%rip)            # 0x113b8
callq 0x75a7
movl %eax, %ebp
movl $0x1, %edi
callq 0x7509
testq %rax, %rax
je 0x74f3
cmpb $0x2d, (%rax)
jne 0x74f3
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
testl %eax, %eax
jne 0x74f3
andb %bpl, %r15b
jmp 0x748e
callq 0x75a7
movl %eax, %ebp
xorb $0x1, %bpl
jmp 0x74be
decl 0x9ebf(%rip)            # 0x113b8
andb %r15b, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/util.c
// Function: nxtarg
static char *
nxtarg(bool reterr)
{
	char *nap;

	if (iap < 1 || iap > iac)	/* should never (but can) be true */
		err(FC_ERR, FMT2S, getmyname(), ERR_AVIINVAL);

	if (iap == iac) {
		if (reterr) {
			iap++;
			return NULL;
		}
		err(FC_ERR, FMT3S, getmyname(), iav[iap - 1], ERR_ARGUMENT);
	}
	nap = iav[iap];
	iap++;
	return nap;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x9ea6(%rip), %eax      # 0x113b8
testl %eax, %eax
jle 0x751e
cmpl 0x9e8c(%rip), %eax      # 0x113a8
jle 0x7540
callq 0x6b0f
leaq 0x1e13(%rip), %rsi      # 0x933d
leaq 0x2255(%rip), %rcx      # 0x9786
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x68c8
movl 0x9e72(%rip), %ecx      # 0x113b8
cmpl 0x9e5c(%rip), %ecx      # 0x113a8
jne 0x758b
testb %bl, %bl
je 0x7556
xorl %eax, %eax
jmp 0x759d
callq 0x6b0f
movq 0x9e4e(%rip), %rcx      # 0x113b0
movslq 0x9e4f(%rip), %rdx      # 0x113b8
movq -0x8(%rcx,%rdx,8), %rcx
leaq 0x1dc4(%rip), %rsi      # 0x9339
leaq 0x221d(%rip), %r8       # 0x9799
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x68c8
movq 0x9e1e(%rip), %rax      # 0x113b0
movslq 0x9e1f(%rip), %rcx      # 0x113b8
movq (%rax,%rcx,8), %rax
incl %ecx
movl %ecx, 0x9e13(%rip)      # 0x113b8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/util.c
// Function: ifstat1
static bool
ifstat1(const char *file, mode_t type)
{
	struct stat sb;
	bool rs;

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

	if (type == S_IFLNK) {
		if (lstat(file, &sb) < 0)
			rs = false;
		else
			rs = (sb.st_mode & S_IFMT) == type;
	} else if (stat(file, &sb) < 0)
		rs = false;
	else if (type == S_IFDIR || type == S_IFREG)
		rs = (sb.st_mode & S_IFMT) == type;
	else if (type == F_GZ)
		rs = sb.st_size > (off_t)0;
	else
		rs = false;

	return rs;
}

// Assembly:
testq %rdi, %rdi
je 0x7c32
cmpb $0x0, (%rdi)
je 0x7c32
pushq %rbx
subq $0x90, %rsp
movl %esi, %ebx
movq %rsp, %rsi
cmpl $0xa000, %ebx           # imm = 0xA000
jne 0x7c35
callq 0x2210
testl %eax, %eax
js 0x7c63
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0xa000, %eax           # imm = 0xA000
jmp 0x7c5e
xorl %eax, %eax
retq
callq 0x2270
testl %eax, %eax
js 0x7c63
cmpl $0x1, %ebx
je 0x7c6e
cmpl $0x8000, %ebx           # imm = 0x8000
je 0x7c53
cmpl $0x4000, %ebx           # imm = 0x4000
jne 0x7c63
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl %ebx, %eax
sete %al
jmp 0x7c65
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
cmpq $0x0, 0x30(%rsp)
setg %al
jmp 0x7c65
// File: /workspace/github_c_makefile_star2_O1/s3lase[P]v6shell/util.c
// Function: ifstat2
static bool
ifstat2(const char *file1, const char *file2, int act)
{
	struct stat sb1, sb2;
	bool rs;

	if (file1 == NULL || *file1 == EOS)
		return false;
	if (file2 == NULL || *file2 == EOS)
		return false;

	if (stat(file1, &sb1) < 0)
		return false;
	if (stat(file2, &sb2) < 0)
		return false;

	if (act == F_OT)
		rs = sb1.st_mtime < sb2.st_mtime;
	else if (act == F_NT)
		rs = sb1.st_mtime > sb2.st_mtime;
	else if (act == F_EF)
		rs = sb1.st_dev == sb2.st_dev && sb1.st_ino == sb2.st_ino;
	else
		rs = false;

	return rs;
}

// Assembly:
testq %rdi, %rdi
je 0x7cdd
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r14
xorl %eax, %eax
testq %rsi, %rsi
je 0x7ce2
cmpb $0x0, (%rdi)
je 0x7ce2
cmpb $0x0, (%r14)
je 0x7ce0
movl %edx, %ebx
leaq 0x98(%rsp), %rsi
callq 0x2270
testl %eax, %eax
js 0x7ce0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2270
testl %eax, %eax
js 0x7ce0
cmpl $0x3, %ebx
je 0x7ced
cmpl $0x2, %ebx
jne 0x7cff
movq 0xf0(%rsp), %rax
cmpq 0x60(%rsp), %rax
setl %al
jmp 0x7ce2
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq 0xf0(%rsp), %rax
cmpq 0x60(%rsp), %rax
setg %al
jmp 0x7ce2
movq 0x98(%rsp), %rax
xorq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorq 0xa0(%rsp), %rcx
orq %rax, %rcx
sete %al
jmp 0x7ce2
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: smalloc
void* smalloc(size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return NULL;

    void*   buf = NULL;

    va_list args;

    if ((buf = malloc(size)) == NULL) {
        if (fmt != NULL) {
            va_start(args, fmt);
            vfprintf(stderr, fmt, args);
            va_end(args);
        } else {
            fprintf(stderr, "%s: %d: neo_malloc(): %s\n",
                    __FILE__, __LINE__, strerror(errno));
        }

        return NULL;
    }
    memset(buf, '\0', size);

    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1247
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x12b1
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1070
testq %rax, %rax
je 0x126e
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1050
jmp 0x12b4
testq %rbx, %rbx
jne 0x127a
callq 0x10c0
jmp 0x12b1
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x2d52(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1090
xorl %r14d, %r14d
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: srealloc
void* srealloc(void* ptr, size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return ptr;

    void*   buf = NULL;

    va_list args;

    if ((buf = realloc(ptr, size)) == NULL) {
        if (fmt != NULL) {
            va_start(args, fmt);
            vfprintf(stderr, fmt, args);
            va_end(args);
        } else {
            fprintf(stderr, "%s: %d: neo_realloc(): %s\n",
                    __FILE__, __LINE__, strerror(errno));
        }
        if (ptr != NULL)
            free(ptr);

        return NULL;
    }

    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x131b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x1333
movq %rdx, %r14
movq %rbx, %rdi
callq 0x1080
testq %rax, %rax
je 0x1341
movq %rax, %rbx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
testq %r14, %r14
jne 0x134d
callq 0x10f6
jmp 0x1384
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq 0x2c7f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1090
testq %rbx, %rbx
je 0x1391
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x1330
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: free2d
void free2d(char** buf, int y)
{
    int     i   = 0,
            j   = y - 1;

    while (i <= j) {
        if (*(buf + i) != NULL) {
            free(*(buf + i));
            *(buf + i) = NULL;
        }
        if (*(buf + j) != NULL) {
            free(*(buf + j));
            *(buf + j) = NULL;
        }
        i++;
        j--;
    }
    free(buf);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x13e5
movl %esi, %r14d
decq %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x13c0
callq 0x1030
movq $0x0, (%rbx,%r15,8)
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x13d6
callq 0x1030
movq $0x0, (%rbx,%r14,8)
incq %r15
leaq -0x1(%r14), %rax
cmpq %r14, %r15
movq %rax, %r14
jl 0x13aa
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030