LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/htab.c
// Function: murmurhash2
ulong
murmurhash2 (void *ptr, size_t len)
{
	uint32_t m = 0x5bd1e995;
	uint32_t r = 24;
	uint32_t h, k, n;
	uint8_t *p, *end;
	
	h = Seed ^ len;
	n = len & ~0x3ull;
	end = ptr;
	end += n;
	for (p = ptr; p != end; p += 4) {
		k = (p[0] <<  0) |
			(p[1] <<  8) |
			(p[2] << 16) |
			(p[3] << 24);

		k *= m;
		k ^= k >> r;
		k *= m;

		h *= m;
		h ^= k;
	}

	switch (len & 0x3) {
	case 3:	h ^= p[2] << 16;
	case 2:	h ^= p[1] << 8;
	case 1:	h ^= p[0] << 0;
		h *= m;
	}

	h ^= h >> 13;
	h *= m;
	h ^= h >> 15;

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5bd1e995, -0x14(%rbp) # imm = 0x5BD1E995
movl $0x18, -0x18(%rbp)
movabsq $0xae88fef5, %rax       # imm = 0xAE88FEF5
xorq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
andq $-0x4, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x4991a
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x18(%rbp), %ecx
shrl %cl, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x49896
movq -0x10(%rbp), %rax
andl $0x3, %eax
movq %rax, -0x40(%rbp)
subq $0x1, %rax
je 0x49967
jmp 0x4992d
movq -0x40(%rbp), %rax
subq $0x2, %rax
je 0x49956
jmp 0x49939
movq -0x40(%rbp), %rax
subq $0x3, %rax
jne 0x49981
jmp 0x49945
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0xd, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0xf, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/htab.c
// Function: streq
int
streq(void *a, void *b)
{
	if (a == b)
		return 1;
	if (a == NULL || b == NULL)
		return 0;
	return !strcmp(a, b);
}

// 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
jne 0x499d3
movl $0x1, -0x4(%rbp)
jmp 0x49a07
cmpq $0x0, -0x10(%rbp)
je 0x499e1
cmpq $0x0, -0x18(%rbp)
jne 0x499ea
movl $0x0, -0x4(%rbp)
jmp 0x49a07
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6220
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/htab.c
// Function: strlithash
ulong
strlithash(void *_s)
{
	Str *s;

	s = _s;
	if (!s)
		return Seed;
	return murmurhash2(s->buf, s->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x49a36
movl $0xae88fef5, %eax       # imm = 0xAE88FEF5
movq %rax, -0x8(%rbp)
jmp 0x49a4e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x49840
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/htab.c
// Function: strliteq
int
strliteq(void *_a, void *_b)
{
	Str *a, *b;

	a = _a;
	b = _b;
	if (a == b)
		return 1;
	if (a == NULL || b == NULL)
		return 0;
	if (a->len != b->len)
		return 0;
	return !memcmp(a->buf, b->buf, a->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x49a93
movl $0x1, -0x4(%rbp)
jmp 0x49aef
cmpq $0x0, -0x20(%rbp)
je 0x49aa1
cmpq $0x0, -0x28(%rbp)
jne 0x49aaa
movl $0x0, -0x4(%rbp)
jmp 0x49aef
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
je 0x49ac3
movl $0x0, -0x4(%rbp)
jmp 0x49aef
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x61f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: be64
void
be64(vlong v, byte buf[8])
{
	buf[0] = (v >> 56) & 0xff;
	buf[1] = (v >> 48) & 0xff;
	buf[2] = (v >> 40) & 0xff;
	buf[3] = (v >> 32) & 0xff;
	buf[4] = (v >> 24) & 0xff;
	buf[5] = (v >> 16) & 0xff;
	buf[6] = (v >> 8) & 0xff;
	buf[7] = (v >> 0) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x38, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
sarq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
sarq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
sarq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
sarq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: host64
vlong
host64(byte buf[8])
{
	vlong v = 0;

	v |= ((vlong)buf[0] << 56LL);
	v |= ((vlong)buf[1] << 48LL);
	v |= ((vlong)buf[2] << 40LL);
	v |= ((vlong)buf[3] << 32LL);
	v |= ((vlong)buf[4] << 24LL);
	v |= ((vlong)buf[5] << 16LL);
	v |= ((vlong)buf[6] << 8LL);
	v |= ((vlong)buf[7] << 0LL);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shlq $0x38, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
shlq $0x30, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
shlq $0x28, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
shlq $0x20, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %eax
shlq $0x18, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5(%rax), %eax
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %eax
shlq $0x0, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: be32
void
be32(long v, byte buf[4])
{
	buf[0] = (v >> 24) & 0xff;
	buf[1] = (v >> 16) & 0xff;
	buf[2] = (v >> 8) & 0xff;
	buf[3] = (v >> 0) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
sarq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: host32
long
host32(byte buf[4])
{
	int32_t v = 0;
	v |= ((long)buf[0] << 24);
	v |= ((long)buf[1] << 16);
	v |= ((long)buf[2] << 8);
	v |= ((long)buf[3] << 0);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x18, %rcx
movslq -0xc(%rbp), %rax
orq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
shlq $0x10, %rcx
movslq -0xc(%rbp), %rax
orq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, %ecx
shlq $0x8, %rcx
movslq -0xc(%rbp), %rax
orq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, %ecx
shlq $0x0, %rcx
movslq -0xc(%rbp), %rax
orq %rcx, %rax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: wrbuf
void
wrbuf(FILE *fd, void *p, size_t sz)
{
	size_t n;
	char *buf;

	n = 0;
	buf = p;
	while (n < sz) {
		n += fwrite(buf + n, 1, sz - n, fd);
		if (feof(fd))
			die("Unexpected EOF");
		if (ferror(fd))
			die("Error writing");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x49e8e
movq -0x28(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x6320
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6240
cmpl $0x0, %eax
je 0x49e70
leaq 0xb984(%rip), %rdi      # 0x557ed
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rdi
callq 0x60a0
cmpl $0x0, %eax
je 0x49e8c
leaq 0xb977(%rip), %rdi      # 0x557fc
movb $0x0, %al
callq 0x1df20
jmp 0x49e24
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: rdbuf
void
rdbuf(FILE *fd, void *buf, size_t sz)
{
	size_t n;

	n = sz;
	while (n > 0) {
		n -= fread(buf, 1, n, fd);
		if (feof(fd))
			die("Unexpected EOF");
		if (ferror(fd))
			die("Error writing");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x49f21
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x60c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6240
cmpl $0x0, %eax
je 0x49f03
leaq 0xb8f1(%rip), %rdi      # 0x557ed
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rdi
callq 0x60a0
cmpl $0x0, %eax
je 0x49f1f
leaq 0xb8e4(%rip), %rdi      # 0x557fc
movb $0x0, %al
callq 0x1df20
jmp 0x49ebc
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: rdbyte
char
rdbyte(FILE *fd)
{
	int c;
	c = fgetc(fd);
	if (c == EOF)
		die("Unexpected EOF");
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x49f9c
leaq 0xb858(%rip), %rdi      # 0x557ed
movb $0x0, %al
callq 0x1df20
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: wrstr
void
wrstr(FILE *fd, char *val)
{
	size_t len;

	if (!val) {
		wrint(fd, -1);
	} else {
		wrint(fd, strlen(val));
		len = strlen(val);
		wrbuf(fd, val, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4a049
movq -0x8(%rbp), %rdi
movq $-0x1, %rsi
callq 0x49fb0
jmp 0x4a084
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6100
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x49fb0
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49e00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: rdstr
char *
rdstr(FILE *fd)
{
	ssize_t len;
	char *s;

	len = rdint(fd);
	if (len == -1) {
		return NULL;
	} else {
		s = xalloc(len + 1);
		rdbuf(fd, s, len);
		s[len] = '\0';
		return s;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x4a0ba
movq $0x0, -0x8(%rbp)
jmp 0x4a0f0
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49ea0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: rdlenstr
void
rdlenstr(FILE *fd, Str *str)
{
	str->len = rdint(fd);
	str->buf = xalloc(str->len + 1);
	rdbuf(fd, str->buf, str->len);
	str->buf[str->len] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x481b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x49ea0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/pack.c
// Function: bprintf
size_t
bprintf(char *buf, size_t sz, char *fmt, ...)
{
	va_list ap;
	size_t n;

	va_start(ap, fmt);
	n = vsnprintf(buf, sz, fmt, ap);
	if (n >= sz)
		n = sz;
	va_end(ap);

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x4a26b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x60e0
cltq
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x4a2dd
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: strdupn
char *
strdupn(char *s, size_t len)
{
	char *ret;

	ret = xalloc(len + 1);
	memcpy(ret, s, len);
	ret[len] = '\0';
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x481b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6260
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: xstrdup
char *
xstrdup(char *s)
{
	char *p;

	p = strdup(s);
	if (!p && s)
		die("Out of memory");
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4a3c5
cmpq $0x0, -0x8(%rbp)
je 0x4a3c5
leaq 0xb373(%rip), %rdi      # 0x55731
movb $0x0, %al
callq 0x1df20
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: strjoin
char *
strjoin(char *u, char *v)
{
	size_t n;
	char *s;

	n = strlen(u) + strlen(v) + 1;
	s = xalloc(n);
	bprintf(s, n + 1, "%s%s", u, v);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x36b0(%rip), %rdx      # 0x4dae0
movb $0x0, %al
callq 0x4a230
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: swapsuffix
char *
swapsuffix(char *buf, size_t sz, char *s, char *suf, char *swap)
{
	size_t slen, suflen, swaplen;

	slen = strlen(s);
	suflen = strlen(suf);
	swaplen = strlen(swap);

	if (slen < suflen)
		return NULL;
	if (slen + swaplen >= sz)
		die("swapsuffix: buf too small");

	buf[0] = '\0';
	/* if we have matching suffixes */
	if (suflen < slen && !strcmp(suf, &s[slen - suflen])) {
		strncat(buf, s, slen - suflen);
		strncat(buf, swap, swaplen);
	} else {
		bprintf(buf, sz, "%s%s", s, swap);
	}

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6100
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6100
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6100
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4a4aa
movq $0x0, -0x8(%rbp)
jmp 0x4a542
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x4a4c6
leaq 0xb34b(%rip), %rdi      # 0x5580a
movb $0x0, %al
callq 0x1df20
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x4a51c
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
addq %rax, %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x4a51c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq -0x40(%rbp), %rdx
callq 0x61a0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x61a0
jmp 0x4a53a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0x35ad(%rip), %rdx      # 0x4dae0
movb $0x0, %al
callq 0x4a230
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: vfindentf
void
vfindentf(FILE *fd, int depth, char *fmt, va_list ap)
{
	ssize_t i;

	for (i = 0; i < depth; i++)
		fprintf(fd, "\t");
	vfprintf(fd, fmt, ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x4a6ec
movq -0x8(%rbp), %rdi
leaq 0xb14d(%rip), %rsi      # 0x55824
movb $0x0, %al
callq 0x6230
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4a6bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x62f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: optinit
void
optinit(Optctx *ctx, char *optstr, char **optargs, size_t noptargs)
{
	ctx->args = NULL;
	ctx->nargs = 0;

	ctx->optstr = optstr;
	ctx->optargs = optargs;
	ctx->noptargs = noptargs;
	ctx->optdone = 0;
	ctx->finished = 0;
	ctx->argidx = 0;
	ctx->curarg = "";
	findnextopt(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq 0xaff4(%rip), %rcx      # 0x55825
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a850
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: findnextopt
static int
findnextopt(Optctx *ctx)
{
	size_t i;

	for (i = ctx->argidx + 1; i < ctx->noptargs; i++) {
		if (ctx->optargs[i][0] == '-')
			goto foundopt;
		else
			lappend(&ctx->args, &ctx->nargs, ctx->optargs[i]);
	}
	ctx->finished = 1;
	return 0;
foundopt
:
	ctx->argidx = i;
	ctx->curarg = ctx->optargs[i] + 1; /* skip initial '-' */
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x4a8c9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4a894
jmp 0x4a8dd
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x48290
jmp 0x4a8bb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4a86c
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4a90c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: optnext
int
optnext(Optctx *ctx)
{
	int take, mand;
	int c;

	c = *ctx->curarg;
	ctx->curarg++;
	if (!optinfo(ctx, c, &take, &mand)) {
		printf("Unexpected argument %c\n", c);
		exit(1);
	}

	ctx->optarg = NULL;
	if (take) {
		if (*ctx->curarg) {
			ctx->optarg = ctx->curarg;
			ctx->curarg += strlen(ctx->optarg);
		} else if (ctx->argidx < ctx->noptargs - 1) {
			ctx->optarg = ctx->optargs[ctx->argidx + 1];
			ctx->argidx++;
		} else if (mand) {
			fprintf(stderr, "expected argument for %c\n", *ctx->curarg);
		}
		findnextopt(ctx);
	} else {
		if (*ctx->curarg == '\0')
			findnextopt(ctx);
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
leaq -0xc(%rbp), %rdx
leaq -0x10(%rbp), %rcx
movsbl %al, %esi
callq 0x4aa80
cmpl $0x0, %eax
jne 0x4a981
movl -0x14(%rbp), %esi
leaq 0xaeb6(%rip), %rdi      # 0x55826
movb $0x0, %al
callq 0x6120
movl $0x1, %edi
callq 0x6310
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0x4aa4e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
cmpb $0x0, (%rax)
je 0x4a9cf
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6100
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
jmp 0x4aa43
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x4aa16
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x4aa41
cmpl $0x0, -0x10(%rbp)
je 0x4aa3f
movq 0x145cd(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %edx
leaq 0xae06(%rip), %rsi      # 0x5583e
movb $0x0, %al
callq 0x6230
jmp 0x4aa41
jmp 0x4aa43
movq -0x8(%rbp), %rdi
callq 0x4a850
jmp 0x4aa69
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4aa67
movq -0x8(%rbp), %rdi
callq 0x4a850
jmp 0x4aa69
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/util/util.c
// Function: optinfo
static int
optinfo(Optctx *ctx, char arg, int *take, int *mand)
{
	char *s;

	for (s = ctx->optstr; *s != '\0'; s++) {
		if (*s == arg) {
			s++;
			if (*s == ':') {
				*take = 1;
				*mand = 1;
				return 1;
			} else if (*s == '?') {
				*take = 1;
				*mand = 0;
				return 1;
			} else {
				*take = 0;
				*mand = 0;
				return 1;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4ab4f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4ab3c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x4aaf6
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4ab56
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x4ab1f
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4ab56
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4ab56
jmp 0x4ab3e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4aaa2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: OpenTapeForRead
int OpenTapeForRead(
  char *name
)
{
  if ((tfile = fopen(name, "r")) != NULL) {
    int status;

    status = verifyFormat();
    rewind(tfile);
    if ((status != TIO_SUCCESS) && (status != TIO_ERROR))
      CloseTape();
    return status;
  }
  return TIO_OPENFAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x29bc(%rip), %rsi      # 0x4573
callq 0x1180
movq %rax, 0x465d(%rip)      # 0x6220
cmpq $0x0, %rax
je 0x1bf6
callq 0x1c10
movl %eax, -0x14(%rbp)
movq 0x4648(%rip), %rdi      # 0x6220
callq 0x10e0
cmpl $0x0, -0x14(%rbp)
je 0x1bee
cmpl $-0x1, -0x14(%rbp)
je 0x1bee
callq 0x1e20
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bfd
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: OpenTapeForWrite
int OpenTapeForWrite(
  char *name
)
{
  /*
   * Fail if the file exists
   */
  if (access(name, F_OK) == 0)
    return TIO_CREATEFAIL;

  if ((tfile = fopen(name, "w+")) != NULL) {
    uint32 tm = 0;
    int status = TIO_SUCCESS;

    /*
     * Write 2 tape marks
     */
    if (fwrite(&tm, sizeof(tm), 2, tfile) != 2)
      status = TIO_IOERROR;

    if (status == TIO_SUCCESS) {
      rewind(tfile);
      return TIO_SUCCESS;
    }

    /*
     * Failed to write the 2 tape marks. Try to delete the file before
     * returning an error.
     */
    CloseTape();
    unlink(name);
    return TIO_IOERROR;
  }
  return TIO_CREATEFAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x1e78
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1f03
movq -0x10(%rbp), %rdi
leaq 0x26e0(%rip), %rsi      # 0x4563
callq 0x1180
movq %rax, 0x4391(%rip)      # 0x6220
cmpq $0x0, %rax
je 0x1efc
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq 0x4376(%rip), %rcx      # 0x6220
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x11d0
cmpq $0x2, %rax
je 0x1eca
movl $0xfffffffb, -0x18(%rbp) # imm = 0xFFFFFFFB
cmpl $0x0, -0x18(%rbp)
jne 0x1ee5
movq 0x4349(%rip), %rdi      # 0x6220
callq 0x10e0
movl $0x0, -0x4(%rbp)
jmp 0x1f03
callq 0x1e20
movq -0x10(%rbp), %rdi
callq 0x1040
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x1f03
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: OpenTapeForAppend
int OpenTapeForAppend(
  char *name
)
{
  if ((tfile =fopen(name, "r+")) != NULL) {
    int status;

    status = verifyFormat();
    if ((status != TIO_SUCCESS) && (status != TIO_ERROR))
      CloseTape();
    return status;
  }
  return TIO_OPENFAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x263f(%rip), %rsi      # 0x4566
callq 0x1180
movq %rax, 0x42ed(%rip)      # 0x6220
cmpq $0x0, %rax
je 0x1f5a
callq 0x1c10
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1f52
cmpl $-0x1, -0x14(%rbp)
je 0x1f52
callq 0x1e20
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f61
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: ReadTapeRecord
uint32 ReadTapeRecord(
  void *buf,
  int len
)
{
  long pos = ftell(tfile);
  uint8 meta[4];
  uint32 bc, erflag, length;

  /*
   * Note: any I/O errors are treated as "end of medium" detection.
   */
  if (fread(meta, sizeof(meta), 1, tfile) != 1)
    return ST_EOM;

  bc = (((unsigned int)meta[3]) << 24) |
       (((unsigned int)meta[2]) << 16) |
       (((unsigned int)meta[1]) << 8) |
       (unsigned int)meta[0];

  switch (bc) {
    case ST_EOM:
    case ST_TM:
      return bc;

    default:
      erflag = bc & ST_ERROR;
      bc &= ST_LENGTH;

      length = (uint32)len;
      if (bc < length)
        length = bc;

      if (fread(buf, sizeof(uint8), length, tfile) != length)
        return ST_EOM;

      /*
       * Now position the file after this record.
       */
      pos += RECLEN(bc) + (2 * sizeof(meta));
      if (fseek(tfile, pos, SEEK_SET) != 0)
        return ST_EOM;

      return erflag | length;
  }
  return ST_EOM;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x429a(%rip), %rdi      # 0x6220
callq 0x1120
movq %rax, -0x20(%rbp)
leaq -0x24(%rbp), %rdi
movq 0x4286(%rip), %rcx      # 0x6220
movl $0x4, %esi
movl $0x1, %edx
callq 0x1090
cmpq $0x1, %rax
je 0x1fbb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x206d
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
incl %eax
subl $0x1, %eax
ja 0x1fd8
jmp 0x1fcd
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x206d
movl -0x28(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x2002
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %edx
movq 0x420e(%rip), %rcx      # 0x6220
movl $0x1, %esi
callq 0x1090
movl -0x30(%rbp), %ecx
cmpq %rcx, %rax
je 0x202d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x206d
movl -0x28(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, %eax
addq $0x8, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x41d5(%rip), %rdi      # 0x6220
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x2064
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x206d
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: ReadTapeRecordLength
uint32 ReadTapeRecordLength(void)
 {
   long pos = ftell(tfile);
   uint8 meta[4];
   uint32 bc, erflag;

   /*
    * Note: any I/O errors are treated as "end of medium" detection.
    */
   if (fread(meta, sizeof(meta), 1, tfile) != 1)
     return ST_EOM;

   bc = (((unsigned int)meta[3]) << 24) |
        (((unsigned int)meta[2]) << 16) |
        (((unsigned int)meta[1]) << 8) |
        (unsigned int)meta[0];

   switch (bc) {
     case ST_EOM:
     case ST_TM:
       return bc;

     default:
       erflag = bc & ST_ERROR;
       bc &= ST_LENGTH;

       /*
        * Now position the file after this record.
        */
       pos += RECLEN(bc) + (2 * sizeof(meta));
       if (fseek(tfile, pos, SEEK_SET) != 0)
         return ST_EOM;

       return erflag | bc;
   }
   return ST_EOM;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x4191(%rip), %rdi      # 0x6220
callq 0x1120
movq %rax, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
movq 0x417d(%rip), %rcx      # 0x6220
movl $0x4, %esi
movl $0x1, %edx
callq 0x1090
cmpq $0x1, %rax
je 0x20c1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2131
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
incl %eax
subl $0x1, %eax
ja 0x20db
jmp 0x20d3
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2131
movl -0x18(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, %eax
addq $0x8, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4111(%rip), %rdi      # 0x6220
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x2128
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2131
movl -0x1c(%rbp), %eax
orl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: WriteTapeRecord
int WriteTapeRecord(
  void *buf,
  int len
)
{
  uint8 meta[4];
  int datalen;

  meta[0] = len & 0xFF;
  meta[1] = (len >> 8) & 0xFF;
  meta[2] = (len >> 16) & 0xFF;
  meta[3] = (len >> 24) & 0xFF;

  datalen = (len + 1) & ~1;

  if (fwrite(meta, sizeof(meta), 1, tfile) != 1)
    return -1;

  if (fwrite(buf, datalen, 1, tfile) != 1)
    return -1;

  if (fwrite(meta, sizeof(meta), 1, tfile) != 1)
    return -1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x18(%rbp)
movl -0x14(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x17(%rbp)
movl -0x14(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x16(%rbp)
movl -0x14(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
movq 0x4085(%rip), %rcx      # 0x6220
movl $0x4, %esi
movl $0x1, %edx
callq 0x11d0
cmpq $0x1, %rax
je 0x21b9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2211
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq 0x4058(%rip), %rcx      # 0x6220
movl $0x1, %edx
callq 0x11d0
cmpq $0x1, %rax
je 0x21e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2211
leaq -0x18(%rbp), %rdi
movq 0x4034(%rip), %rcx      # 0x6220
movl $0x4, %esi
movl $0x1, %edx
callq 0x11d0
cmpq $0x1, %rax
je 0x220a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2211
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: WriteTapeMark
int WriteTapeMark(
  int backup
)
{
  uint32 tm = 0;

  if (fwrite(&tm, sizeof(tm), 1, tfile) != 1)
    return -1;

  if (backup)
    if (fseek(tfile, -sizeof(tm), SEEK_CUR) != 0)
      return -1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x3fe7(%rip), %rcx      # 0x6220
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x11d0
cmpq $0x1, %rax
je 0x225b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2290
cmpl $0x0, -0x8(%rbp)
je 0x2289
movq 0x3fb8(%rip), %rdi      # 0x6220
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x2287
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2290
jmp 0x2289
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: flushTapeBuffering
int flushTapeBuffering(void)
{
  uint32 count = occupied;

  occupied = 0;

  if (count != 0)
    return WriteTapeRecord(buffer, count);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x3f5e(%rip), %eax      # 0x622c
movl %eax, -0x8(%rbp)
movl $0x0, 0x3f51(%rip)      # 0x622c
cmpl $0x0, -0x8(%rbp)
je 0x22f5
movl -0x8(%rbp), %esi
leaq 0x3f45(%rip), %rdi      # 0x6230
callq 0x2140
movl %eax, -0x4(%rbp)
jmp 0x22fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/tapeio.c
// Function: writeTapeBuffering
int writeTapeBuffering(
  char ch
)
{
  buffer[occupied++] = ch;

  if (occupied == rLength) {
    occupied = 0;
    return WriteTapeRecord(buffer, rLength);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %dl
movl 0x3f05(%rip), %eax      # 0x622c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x3efa(%rip)      # 0x622c
movslq %eax, %rcx
leaq 0x3ef4(%rip), %rax      # 0x6230
movb %dl, (%rax,%rcx)
movl 0x3ee7(%rip), %eax      # 0x622c
cmpl 0x3edd(%rip), %eax      # 0x6228
jne 0x236e
movl $0x0, 0x3ed5(%rip)      # 0x622c
movl 0x3ecb(%rip), %esi      # 0x6228
leaq 0x3ecc(%rip), %rdi      # 0x6230
callq 0x2140
movl %eax, -0x4(%rbp)
jmp 0x2375
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/dos11.c
// Function: AscR50
static uint16 AscR50(
  char *inbuf
)
{
  uint16 value;
  char *ptr;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value = (ptr - rad50) * 03100;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value += (ptr - rad50) * 050;

  if ((ptr = strchr(rad50, toupper(*inbuf))) == NULL)
    ptr = strchr(rad50, '%');

  value += ptr - rad50;

  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x1070
movl %eax, %esi
leaq 0x3924(%rip), %rdi      # 0x6120
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2820
leaq 0x390e(%rip), %rdi      # 0x6120
movl $0x25, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x38f5(%rip), %rcx      # 0x6120
subq %rcx, %rax
imulq $0x640, %rax, %rax      # imm = 0x640
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x1070
movl %eax, %esi
leaq 0x38c7(%rip), %rdi      # 0x6120
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x287d
leaq 0x38b1(%rip), %rdi      # 0x6120
movl $0x25, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3898(%rip), %rcx      # 0x6120
subq %rcx, %rax
imulq $0x28, %rax, %rcx
movzwl -0xa(%rbp), %eax
addq %rcx, %rax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x1070
movl %eax, %esi
leaq 0x3871(%rip), %rdi      # 0x6120
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x28d3
leaq 0x385b(%rip), %rdi      # 0x6120
movl $0x25, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x3842(%rip), %rax      # 0x6120
subq %rax, %rcx
movzwl -0xa(%rbp), %eax
addq %rcx, %rax
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/dos11.c
// Function: r50AscNoSpace
static int r50AscNoSpace(
  uint16 value,
  char *outbuf
)
{
  int count = 0;
  int value2 = value / 050;

  /*
   * The rad50 representation of ' ' is zero.
   */
  if ((value2 / 050) != 0)
    outbuf[count++] = rad50[value2 / 050];
  if ((value2 % 050) != 0)
    outbuf[count++] = rad50[value2 % 050];
  if ((value % 050) != 0)
    outbuf[count++] = rad50[value % 050];

  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %eax
je 0x2cc2
movl -0x18(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x3476(%rip), %rax      # 0x6120
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2cff
movl -0x18(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x3439(%rip), %rax      # 0x6120
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2d3e
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x33fa(%rip), %rax      # 0x6120
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/dos11.c
// Function: xferAscii
static int xferAscii(
  char ch
)
{
  int count = 0;

  if (ch == '\r') {
    if (CRpending != 0)
      if (fwrite(&cr, sizeof(char), 1, file) != 1)
        count++;
    CRpending = 1;
    return count;
  }

  if (CRpending != 0) {
    CRpending = 0;
    if (ch != '\n')
      if (fwrite(&cr, sizeof(char), 1,  file) != 1)
        count++;
  }
  if (fwrite(&ch, sizeof(ch), 1, file) != 1)
    count++;

  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0xd, %eax
jne 0x2dc5
cmpl $0x0, 0x134b3(%rip)     # 0x16238
je 0x2db3
movq 0x134a2(%rip), %rcx     # 0x16230
leaq 0x345b(%rip), %rdi      # 0x61f0
movl $0x1, %edx
movq %rdx, %rsi
callq 0x11d0
cmpq $0x1, %rax
je 0x2db1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2db3
movl $0x1, 0x1347b(%rip)     # 0x16238
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e3c
cmpl $0x0, 0x1346c(%rip)     # 0x16238
je 0x2e0f
movl $0x0, 0x13460(%rip)     # 0x16238
movsbl -0x5(%rbp), %eax
cmpl $0xa, %eax
je 0x2e0d
movq 0x13448(%rip), %rcx     # 0x16230
leaq 0x3401(%rip), %rdi      # 0x61f0
movl $0x1, %edx
movq %rdx, %rsi
callq 0x11d0
cmpq $0x1, %rax
je 0x2e0b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e0d
jmp 0x2e0f
movq 0x1341a(%rip), %rcx     # 0x16230
leaq -0x5(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x11d0
cmpq $0x1, %rax
je 0x2e36
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/dos11.c
// Function: flushAscii
static int flushAscii(void)
{
  if (CRpending != 0)
    if (fwrite(&cr, sizeof(char), 1, file) != 1)
      return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x133d9(%rip)     # 0x16238
je 0x2e8d
movq 0x133c8(%rip), %rcx     # 0x16230
leaq 0x3381(%rip), %rdi      # 0x61f0
movl $0x1, %edx
movq %rdx, %rsi
callq 0x11d0
cmpq $0x1, %rax
je 0x2e8b
movl $0x1, -0x4(%rbp)
jmp 0x2e94
jmp 0x2e8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/dbtap/dos11.c
// Function: r50Asc
static void r50Asc(
  uint16 value,
  char *outbuf
)
{
  outbuf[2] = rad50[value % 050];
  value /= 050;
  outbuf[1] = rad50[value % 050];
  outbuf[0] = rad50[value / 050];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x301b(%rip), %rax      # 0x6120
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x2feb(%rip), %rax      # 0x6120
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x2fcb(%rip), %rax      # 0x6120
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq