LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsiter
int
bsiter(Bitset *bs, size_t *elt)
{
	size_t b, t, i;

	i = *elt;
	t = i/Sizetbits;
	if (t >= bs->nchunks)
		return 0;
	b = bs->chunks[t];
	b &= ~((1ull << (i%Sizetbits)) - 1);
	while (!b) {
		++t;
		if (t >= bs->nchunks)
			return 0;
		b = bs->chunks[t];
	}
	*elt = Sizetbits*t + firstbit(b);
	return 1;
}

// Assembly:
movq (%rsi), %rcx
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rdi), %r8
xorl %eax, %eax
cmpq %r8, %rdx
jae 0x29ecc
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %rdi
shrq %cl, %rdi
shlq %cl, %rdi
movq %rdx, %rcx
shlq $0x6, %rcx
incq %rdx
testq %rdi, %rdi
jne 0x29e5e
cmpq %r8, %rdx
jae 0x29ecc
movq (%r9,%rdx,8), %rdi
addq $0x40, %rcx
jmp 0x29e47
movq %rdi, %rax
shrq $0x20, %rax
xorl %edx, %edx
testl %edi, %edi
sete %dl
cmovneq %rdi, %rax
shll $0x5, %edx
leal 0x10(%rdx), %edi
movq %rax, %r8
shrq $0x10, %r8
testw %ax, %ax
cmovneq %rax, %r8
cmovnel %edx, %edi
leal 0x8(%rdi), %eax
movq %r8, %rdx
shrq $0x8, %rdx
testb %r8b, %r8b
cmovneq %r8, %rdx
cmovnel %edi, %eax
leal 0x4(%rax), %edi
movl %edx, %r8d
shrl $0x4, %r8d
testb $0xf, %dl
cmovneq %rdx, %r8
cmovnel %eax, %edi
andl $0xf, %r8d
leaq 0xb276(%rip), %rax      # 0x35130
movsbl (%r8,%rax), %eax
addl %edi, %eax
cltq
addq %rcx, %rax
movq %rax, (%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsput
void
bsput(Bitset *bs, size_t elt)
{
	size_t sz;
	if (elt >= bs->nchunks * Sizetbits) {
		sz = (elt / Sizetbits) + 1;
		bs->chunks = zrealloc(bs->chunks, bs->nchunks * sizeof(size_t), sz * sizeof(size_t));
		bs->nchunks = sz;
	}
	bs->chunks[elt / Sizetbits] |= 1ULL << (elt % Sizetbits);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
movq %rsi, %rax
shlq $0x6, %rax
cmpq %rbx, %rax
jbe 0x29eff
movq 0x8(%r14), %rax
movq %rbx, %r15
shrq $0x6, %r15
jmp 0x29f26
movq %rbx, %r15
shrq $0x6, %r15
leaq 0x1(%r15), %r12
movq 0x8(%r14), %rdi
shlq $0x3, %rsi
leaq 0x8(,%r15,8), %rdx
callq 0x29ad0
movq %rax, 0x8(%r14)
movq %r12, (%r14)
pushq $0x1
popq %rdx
movl %ebx, %ecx
shlq %cl, %rdx
orq %rdx, (%rax,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsunion
void
bsunion(Bitset *a, Bitset *b)
{
	size_t i;

	eqsz(a, b);
	for (i = 0; i < a->nchunks; i++)
		a->chunks[i] |= b->chunks[i];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29f92
xorl %eax, %eax
cmpq (%r14), %rax
jae 0x29f8a
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%r14), %rdx
orq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x29f70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: eqsz
static void
eqsz(Bitset *a, Bitset *b)
{
	size_t sz;
	size_t i;
	size_t *p;

	if (a->nchunks > b->nchunks)
		sz = a->nchunks;
	else
		sz = b->nchunks;

	if (a->nchunks != sz) {
		p = zalloc(sz * sizeof(size_t));
		for (i = 0; i < a->nchunks; i++)
			p[i] = a->chunks[i];
		free(a->chunks);
		a->chunks = p;
		a->nchunks = sz;
	}

	if (b->nchunks != sz) {
		p = zalloc(sz * sizeof(size_t));
		for (i = 0; i < b->nchunks; i++)
			p[i] = b->chunks[i];
		free(b->chunks);
		b->chunks = p;
		b->nchunks = sz;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r12
movq (%rsi), %rax
cmpq %rax, %r12
cmovbeq %rax, %r12
jae 0x29fe6
movq %rdi, %r14
leaq (,%r12,8), %rdi
callq 0x29a78
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %eax, %eax
cmpq (%r14), %rax
jae 0x29fd7
movq (%rdi,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x29fc5
callq 0x4040
movq %r15, 0x8(%r14)
movq %r12, (%r14)
movq (%rbx), %rax
cmpq %r12, %rax
je 0x2a01f
leaq (,%r12,8), %rdi
callq 0x29a78
movq %rax, %r14
movq 0x8(%rbx), %rdi
xorl %eax, %eax
cmpq (%rbx), %rax
jae 0x2a013
movq (%rdi,%rax,8), %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x2a001
callq 0x4040
movq %r14, 0x8(%rbx)
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bseq
int
bseq(Bitset *a, Bitset *b)
{
	size_t i;

	if (!a || !b)
		return bsisempty(a) && bsisempty(b);
	eqsz(a, b);
	for (i = 0; i < a->nchunks; i++) {
		if (a->chunks[i] != b->chunks[i])
			return 0;
	}
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x2a0fc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29f92
movq (%r14), %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
cmpq %rdx, %rcx
je 0x2a119
movq 0x8(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x8(%rbx), %rdi
leaq 0x1(%rdx), %r8
cmpq (%rdi,%rdx,8), %rsi
movq %r8, %rdx
je 0x2a0dc
jmp 0x2a117
movq %r14, %rdi
callq 0x2a121
testl %eax, %eax
je 0x2a117
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a121
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsisempty
int
bsisempty(Bitset *set)
{
	size_t i;

	if (!set)
		return 1;
	for (i = 0; i < set->nchunks; i++)
		if (set->chunks[i])
			return 0;
	return 1;
}

// Assembly:
pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x2a144
movq (%rdi), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2a144
movq 0x8(%rdi), %rsi
cmpq $0x0, (%rsi,%rdx,8)
leaq 0x1(%rdx), %rdx
je 0x2a12e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsissubset
int
bsissubset(Bitset *set, Bitset *sub)
{
	size_t i;

	eqsz(set, sub);
	for (i = 0; i < set->nchunks; i++)
		if ((sub->chunks[i] & set->chunks[i]) != set->chunks[i])
			return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29f92
movq (%r14), %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
cmpq %rdx, %rcx
je 0x2a17f
movq 0x8(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x8(%r14), %rdi
notq %rsi
leaq 0x1(%rdx), %r8
testq %rsi, (%rdi,%rdx,8)
movq %r8, %rdx
je 0x2a15c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: mkht
Htab *
mkht(ulong (*hash)(void *key), int (*cmp)(void *k1, void *k2))
{
	Htab *ht;

	ht = xalloc(sizeof(Htab));
	ht->nelt = 0;
	ht->ndead = 0;
	ht->sz = Initsz;
	ht->hash = hash;
	ht->cmp = cmp;
	ht->keys = zalloc(Initsz * sizeof(void *));
	ht->vals = zalloc(Initsz * sizeof(void *));
	ht->hashes = zalloc(Initsz * sizeof(void *));
	ht->dead = zalloc(Initsz * sizeof(char));

	return ht;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x48
popq %rdi
callq 0x29aa7
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x10, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movl $0x80, %edi
callq 0x29a78
movq %rax, 0x28(%rbx)
movl $0x80, %edi
callq 0x29a78
movq %rax, 0x30(%rbx)
movl $0x80, %edi
callq 0x29a78
movq %rax, 0x38(%rbx)
pushq $0x10
popq %rdi
callq 0x29a78
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: htfree
void
htfree(Htab *ht)
{
	if (!ht)
		return;
	free(ht->keys);
	free(ht->vals);
	free(ht->hashes);
	free(ht->dead);
	free(ht);
}

// Assembly:
testq %rdi, %rdi
je 0x2a229
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x4040
movq 0x30(%rbx), %rdi
callq 0x4040
movq 0x38(%rbx), %rdi
callq 0x4040
movq 0x40(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
popq %rbx
jmp 0x4040
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: htput
int
htput(Htab *ht, void *k, void *v)
{
	int i;
	ulong h;
	int di;

	di = 0;
	h = hash(ht, k);
	i = h & (ht->sz - 1);
	while (ht->hashes[i] && !ht->dead[i]) {
		/* second insertion overwrites first. nb, we shouldn't touch the
		 * keys for dead values */
		if (ht->hashes[i] == h) {
			if (ht->dead[i])
				break;
			else if (ht->cmp(ht->keys[i], k))
				goto conflicted;
		}
		di++;
		i = (h + di) & (ht->sz - 1);
	}
	ht->nelt++;
conflicted:
	if (ht->dead[i])
		ht->ndead--;
	ht->hashes[i] = h;
	ht->keys[i] = k;
	ht->vals[i] = v;
	ht->dead[i] = 0;

	if (ht->sz < ht->nelt * 2)
		grow(ht, ht->sz * 2);
	if (ht->sz < ht->ndead * 4)
		grow(ht, ht->sz);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x18(%rbx)
movq %rax, %r12
cmpq $0x1, %rax
adcq $0x0, %r12
movq 0x10(%rbx), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
addq %rax, %rcx
andq %r12, %rcx
leaq 0x1(%r12), %r13
movq 0x38(%rbx), %rdx
movslq %ecx, %rbp
movq (%rdx,%rbp,8), %rcx
testq %rcx, %rcx
je 0x2a2a4
movq 0x40(%rbx), %rdx
cmpb $0x0, (%rdx,%rbp)
jne 0x2a2a4
cmpq %r12, %rcx
jne 0x2a298
movq 0x28(%rbx), %rax
movq (%rax,%rbp,8), %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testl %eax, %eax
jne 0x2a2a7
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
andq %r13, %rcx
incq %r13
jmp 0x2a263
incq (%rbx)
movq 0x40(%rbx), %rax
cmpb $0x0, (%rax,%rbp)
je 0x2a2b5
decq 0x8(%rbx)
movq 0x38(%rbx), %rax
movq %r12, (%rax,%rbp,8)
movq 0x28(%rbx), %rax
movq %r15, (%rax,%rbp,8)
movq 0x30(%rbx), %rax
movq %r14, (%rax,%rbp,8)
movq 0x40(%rbx), %rax
movb $0x0, (%rax,%rbp)
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
addq %rax, %rax
cmpq %rax, %rsi
jae 0x2a2f2
addl %esi, %esi
movq %rbx, %rdi
callq 0x2a319
movq 0x10(%rbx), %rsi
movq 0x8(%rbx), %rax
shlq $0x2, %rax
cmpq %rax, %rsi
jae 0x2a307
movq %rbx, %rdi
callq 0x2a319
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: grow
static void
grow(Htab *ht, int sz)
{
	void **oldk;
	void **oldv;
	ulong *oldh;
	char *oldd;
	int oldsz;
	int i;

	oldk = ht->keys;
	oldv = ht->vals;
	oldh = ht->hashes;
	oldd = ht->dead;
	oldsz = ht->sz;

	ht->nelt = 0;
	ht->ndead = 0;
	ht->sz = sz;
	ht->keys = zalloc(sz * sizeof(void *));
	ht->vals = zalloc(sz * sizeof(void *));
	ht->hashes = zalloc(sz * sizeof(void *));
	ht->dead = zalloc(sz * sizeof(void *));

	for (i = 0; i < oldsz; i++)
		if (oldh[i] && !oldd[i])
			htput(ht, oldk[i], oldv[i]);

	free(oldh);
	free(oldk);
	free(oldv);
	free(oldd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %rax
movq %rax, (%rsp)
movq 0x38(%rdi), %r13
movq 0x40(%rdi), %rbx
movl 0x10(%rdi), %r14d
movslq %esi, %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbp, 0x10(%rdi)
shlq $0x3, %rbp
movq %rbp, %rdi
callq 0x29a78
movq %rax, 0x28(%r12)
movq %rbp, %rdi
callq 0x29a78
movq %rax, 0x30(%r12)
movq %rbp, %rdi
callq 0x29a78
movq %rax, 0x38(%r12)
movq %rbp, %rdi
callq 0x29a78
movq %rax, 0x40(%r12)
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
cmpq %rbp, %r14
je 0x2a3b9
cmpq $0x0, (%r13,%rbp,8)
je 0x2a3b4
cmpb $0x0, (%rbx,%rbp)
jne 0x2a3b4
movq (%r15,%rbp,8), %rsi
movq (%rsp), %rax
movq (%rax,%rbp,8), %rdx
movq %r12, %rdi
callq 0x2a22a
incq %rbp
jmp 0x2a38d
movq %r13, %rdi
callq 0x4040
movq %r15, %rdi
callq 0x4040
movq (%rsp), %rdi
callq 0x4040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: htidx
static ssize_t
htidx(Htab *ht, void *k)
{
	ssize_t i;
	ulong h;
	int di;

	di = 0;
	h = hash(ht, k);
	i = h & (ht->sz - 1);
	while (ht->hashes[i] && !ht->dead[i] && ht->hashes[i] != h) {
searchmore:
		di++;
		i = (h + di) & (ht->sz - 1);
	}
	if (!ht->hashes[i])
		return -1;
	if ((ht->hashes[i] == h && ht->dead[i]) || !ht->cmp(ht->keys[i], k))
		goto searchmore; /* collision */
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq *0x18(%r14)
movq %rax, %r15
cmpq $0x1, %rax
adcq $0x0, %r15
movq 0x10(%r14), %rax
leaq -0x1(%rax), %r12
andq %r15, %r12
leaq 0x1(%r15), %rbp
pushq $-0x1
popq %r13
movq 0x38(%r14), %rcx
movq (%rcx,%r12,8), %rdx
testq %rdx, %rdx
je 0x2a48b
movq 0x40(%r14), %rcx
cmpb $0x0, (%rcx,%r12)
setne %cl
cmpq %r15, %rdx
sete %dl
movl %ecx, %esi
orb %dl, %sil
cmpb $0x1, %sil
jne 0x2a47f
andb %dl, %cl
jne 0x2a47f
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq *0x20(%r14)
testl %eax, %eax
jne 0x2a48e
movq 0x10(%r14), %rax
leaq -0x1(%rax), %r12
andq %rbp, %r12
incq %rbp
jmp 0x2a43a
movq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: htdel
void
htdel(Htab *ht, void *k)
{
	ssize_t i;

	i = htidx(ht, k);
	if (i < 0)
		return;
	assert(!ht->dead[i]);
	assert(ht->hashes[i]);
	ht->dead[i] = 1;
	ht->nelt--;
	ht->ndead++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2a404
testq %rax, %rax
js 0x2a4d7
movq 0x40(%rbx), %rcx
cmpb $0x0, (%rcx,%rax)
jne 0x2a4d9
movq 0x38(%rbx), %rdx
cmpq $0x0, (%rdx,%rax,8)
je 0x2a4f8
movb $0x1, (%rcx,%rax)
movdqu (%rbx), %xmm0
paddq 0xac6d(%rip), %xmm0     # 0x35140
movdqu %xmm0, (%rbx)
popq %rbx
retq
leaq 0xac80(%rip), %rdi      # 0x35160
leaq 0xac86(%rip), %rsi      # 0x3516d
leaq 0xac86(%rip), %rcx      # 0x35174
movl $0xbe, %edx
callq 0x4180
leaq 0xac90(%rip), %rdi      # 0x3518f
leaq 0xac67(%rip), %rsi      # 0x3516d
leaq 0xac67(%rip), %rcx      # 0x35174
movl $0xbf, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/htab.c
// Function: htkeys
void **
htkeys(Htab *ht, size_t *nkeys)
{
	void **k;
	size_t i, j;

	j = 0;
	k = xalloc(sizeof(void *) * ht->nelt);
	for (i = 0; i < ht->sz; i++)
		if (ht->hashes[i] && !ht->dead[i])
			k[j++] = ht->keys[i];
	*nkeys = ht->nelt;
	return k;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
shlq $0x3, %rdi
callq 0x29aa7
movq 0x10(%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %rdx
jae 0x2a575
movq 0x38(%r14), %rdi
cmpq $0x0, (%rdi,%rdx,8)
je 0x2a570
movq 0x40(%r14), %rdi
cmpb $0x0, (%rdi,%rdx)
jne 0x2a570
movq 0x28(%r14), %rdi
movq (%rdi,%rdx,8), %rdi
movq %rdi, (%rax,%rsi,8)
incq %rsi
incq %rdx
jmp 0x2a547
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
xorl $0xae88fef5, %eax       # imm = 0xAE88FEF5
movl %esi, %ecx
andl $-0x4, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2a5de
imull $0x5bd1e995, (%rdi,%rdx), %r8d # imm = 0x5BD1E995
movl %r8d, %r9d
shrl $0x18, %r9d
xorl %r8d, %r9d
imull $0x5bd1e995, %r9d, %r8d # imm = 0x5BD1E995
imull $0x5bd1e995, %eax, %eax # imm = 0x5BD1E995
xorl %r8d, %eax
addq $0x4, %rdx
jmp 0x2a5b1
andl $0x3, %esi
leaq 0xab68(%rip), %rdx      # 0x35150
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movzbl 0x2(%rdi,%rcx), %edx
shll $0x10, %edx
xorl %edx, %eax
movzbl 0x1(%rdi,%rcx), %edx
shll $0x8, %edx
xorl %edx, %eax
movzbl (%rdi,%rcx), %ecx
xorl %eax, %ecx
imull $0x5bd1e995, %ecx, %eax # imm = 0x5BD1E995
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0x5bd1e995, %ecx, %ecx # imm = 0x5BD1E995
movl %ecx, %eax
shrl $0xf, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq %rsi, %rdi
je 0x2a6a7
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x2a6a6
movq (%rdi), %rdx
cmpq (%rsi), %rdx
jne 0x2a6a6
pushq %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x4290
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
pushq $0x1
popq %r12
movq %rbx, %rdx
subq %rbp, %rdx
jbe 0x2a767
leaq (%r14,%rbp), %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x4330
movq %rax, %r13
movq %r15, %rdi
callq 0x4250
testl %eax, %eax
jne 0x2a776
addq %r13, %rbp
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x2a729
leaq 0xaa47(%rip), %rdi      # 0x351ac
jmp 0x2a77d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaa20(%rip), %rdi      # 0x3519d
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %r12
testq %rbx, %rbx
je 0x2a7d7
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x40e0
movq %rax, %r13
movq %r15, %rdi
callq 0x4250
testl %eax, %eax
jne 0x2a7e1
subq %r13, %rbx
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x2a79a
leaq 0xa9d7(%rip), %rdi      # 0x351ac
jmp 0x2a7e8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xa9b5(%rip), %rdi      # 0x3519d
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x41d0
cmpl $-0x1, %eax
je 0x2a81f
popq %rcx
retq
leaq 0xa977(%rip), %rdi      # 0x3519d
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2a8c1
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4120
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a82d
movq %r14, %rdi
callq 0x4120
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a70f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a82d
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a844
cmpq $-0x1, %rax
je 0x2a90c
movq %rax, %r14
movq %rax, %rdi
incq %rdi
callq 0x29aa7
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a784
movb $0x0, (%r15,%r14)
jmp 0x2a90f
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2a844
movq %rax, (%rbx)
leaq 0x1(%rax), %rdi
callq 0x29aa7
movq %rax, 0x8(%rbx)
movq (%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a784
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x4340
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x2aab6
popq %rbx
retq
leaq 0xa5fd(%rip), %rdi      # 0x350ba
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4120
movq %rax, %r15
movq %rbx, %rdi
callq 0x4120
movq %rax, %r12
leaq (%rax,%r15), %rdi
incq %rdi
callq 0x29aa7
movq %rax, %r13
leaq (%r12,%r15), %rsi
addq $0x2, %rsi
leaq 0x303f(%rip), %rdx      # 0x2db43
movq %rax, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x2a9bf
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi
callq 0x4120
movq %rax, %r13
movq %rbp, %rdi
callq 0x4120
movq %rax, %r12
movq %r15, (%rsp)
movq %r15, %rdi
callq 0x4120
cmpq %r12, %r13
jae 0x2ab6b
xorl %ebx, %ebx
jmp 0x2abb0
movq %rax, 0x8(%rsp)
addq %r13, %rax
cmpq %r14, %rax
jae 0x2abef
movb $0x0, (%rbx)
subq %r12, %r13
movq 0x10(%rsp), %r15
jbe 0x2ab95
leaq (%r15,%r13), %rsi
movq %rbp, %rdi
callq 0x4230
testl %eax, %eax
je 0x2abc2
leaq 0x2fa7(%rip), %rdx      # 0x2db43
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x2a9bf
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x41c0
movq %rbx, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41c0
leaq 0xa5c4(%rip), %rdi      # 0x351ba
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
pushq $0x9
popq %rbp
subq $0x1, %r12
jb 0x2acf0
movl %ebp, %edi
movq %r15, %rsi
callq 0x41f0
jmp 0x2acde
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r12
leaq 0x8(%rdi), %r14
leaq 0x10(%rdi), %r15
incq %r12
cmpq 0x28(%rbx), %r12
jae 0x2ade4
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rdx
cmpb $0x2d, (%rdx)
je 0x2aded
movq %r14, %rdi
movq %r15, %rsi
callq 0x29b2d
jmp 0x2adc1
movl $0x1, 0x3c(%rbx)
jmp 0x2adf8
movq %r12, 0x30(%rbx)
incq %rdx
movq %rdx, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x40(%rdi), %r15
movsbl (%r15), %ebx
incq %r15
movq %r15, 0x40(%rdi)
movb (%rax), %cl
testb %cl, %cl
je 0x2aec2
incq %rax
cmpb %bl, %cl
jne 0x2ae1f
movzbl (%rax), %eax
cmpl $0x3a, %eax
je 0x2ae41
cmpl $0x3f, %eax
jne 0x2ae61
movb $0x1, %al
jmp 0x2ae43
xorl %eax, %eax
andq $0x0, (%r14)
cmpb $0x0, (%r15)
je 0x2ae6d
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4120
addq %r15, %rax
movq %rax, 0x40(%r14)
jmp 0x2ae96
andq $0x0, (%r14)
cmpb $0x0, (%r15)
jne 0x2ae9e
jmp 0x2ae96
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rcx
decq %rdx
cmpq %rdx, %rcx
jae 0x2ae92
movq 0x20(%r14), %rax
movq 0x8(%rax,%rcx,8), %rax
movq %rax, (%r14)
incq %rcx
movq %rcx, 0x30(%r14)
jmp 0x2ae96
testb %al, %al
je 0x2aea6
movq %r14, %rdi
callq 0x2adaa
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x16143(%rip), %rax     # 0x40ff0
movq (%rax), %rdi
leaq 0xa335(%rip), %rsi      # 0x351ec
xorl %edx, %edx
xorl %eax, %eax
callq 0x4240
jmp 0x2ae96
leaq 0xa30b(%rip), %rdi      # 0x351d4
movl %ebx, %esi
xorl %eax, %eax
callq 0x4140
pushq $0x1
popq %rdi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0x1b7a(%rip), %rsi      # 0x34ba
callq 0x1190
movq %rax, 0x38d4(%rip)      # 0x5220
testq %rax, %rax
je 0x1974
callq 0x197b
movl %eax, %ebx
movq 0x38c1(%rip), %rdi      # 0x5220
callq 0x10f0
movl %ebx, %eax
decl %eax
cmpl $-0x3, %eax
ja 0x1977
callq 0x1add
jmp 0x1977
pushq $-0x3
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1180
pushq $-0x4
popq %rbp
testl %eax, %eax
je 0x1b67
leaq 0x197c(%rip), %rsi      # 0x3493
movq %rbx, %rdi
callq 0x1190
movq %rax, 0x36fa(%rip)      # 0x5220
testq %rax, %rax
je 0x1b67
leaq 0x4(%rsp), %rdi
andl $0x0, (%rdi)
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
movq %rax, %rcx
callq 0x11e0
cmpq $0x2, %rax
jne 0x1b57
movq 0x36d2(%rip), %rdi      # 0x5220
callq 0x10f0
xorl %ebp, %ebp
jmp 0x1b67
callq 0x1add
movq %rbx, %rdi
callq 0x1060
pushq $-0x5
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0x191e(%rip), %rsi      # 0x3496
callq 0x1190
movq %rax, 0x369c(%rip)      # 0x5220
testq %rax, %rax
je 0x1b9e
callq 0x197b
movl %eax, %ebx
decl %eax
cmpl $-0x3, %eax
ja 0x1ba1
callq 0x1add
jmp 0x1ba1
pushq $-0x3
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movq 0x3664(%rip), %rdi      # 0x5220
callq 0x1130
movq %rax, %r14
movq 0x3655(%rip), %rcx      # 0x5220
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbp
cmpq $0x1, %rax
jne 0x1c10
movzbl 0x7(%rsp), %r12d
shll $0x18, %r12d
movzbl 0x6(%rsp), %eax
shll $0x10, %eax
movzwl 0x4(%rsp), %r13d
orl %eax, %r13d
leal (%r12,%r13), %eax
incl %eax
cmpl $0x2, %eax
jae 0x1c21
orl %r12d, %r13d
movl %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebx, %r13d
cmovbl %r13d, %ebx
movq 0x35f1(%rip), %rcx      # 0x5220
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x10a0
cmpq %rbx, %rax
jne 0x1c10
andl $0x80000000, %r12d      # imm = 0x80000000
incl %r13d
andl $-0x2, %r13d
leaq (%r14,%r13), %rsi
addq $0x8, %rsi
movq 0x35c1(%rip), %rdi      # 0x5220
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1170
orl %r12d, %ebx
negl %eax
sbbl %ebp, %ebp
orl %ebx, %ebp
jmp 0x1c10
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x359e(%rip), %rdi      # 0x5220
callq 0x1130
movq %rax, %r14
movq 0x358f(%rip), %rcx      # 0x5220
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x1cfa
movzbl 0x7(%rsp), %r15d
shll $0x18, %r15d
movzwl 0x5(%rsp), %eax
shll $0x8, %eax
movzbl 0x4(%rsp), %r12d
orl %eax, %r12d
leal (%r15,%r12), %eax
incl %eax
cmpl $0x2, %eax
jae 0x1cd8
orl %r15d, %r12d
movl %r12d, %ebx
jmp 0x1cfa
leal 0x1(%r12), %eax
andl $-0x2, %eax
leaq (%rax,%r14), %rsi
addq $0x8, %rsi
movq 0x3531(%rip), %rdi      # 0x5220
xorl %edx, %edx
callq 0x1170
testl %eax, %eax
je 0x1d08
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
andl $0x80000000, %r15d      # imm = 0x80000000
jmp 0x1cd0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
movq 0x34f4(%rip), %rcx      # 0x5220
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x1d82
incl %ebp
andl $-0x2, %ebp
movslq %ebp, %rsi
movq 0x34d1(%rip), %rcx      # 0x5220
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x11e0
cmpq $0x1, %rax
jne 0x1d82
movq 0x34b9(%rip), %rcx      # 0x5220
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
xorl %ebx, %ebx
cmpq $0x1, %rax
setne %bl
negl %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x4(%rsp), %rdi
andl $0x0, (%rdi)
movq 0x347f(%rip), %rcx      # 0x5220
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x1dd1
testl %ebp, %ebp
je 0x1dcf
movq 0x3460(%rip), %rdi      # 0x5220
pushq $-0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x1170
testl %eax, %eax
jne 0x1dd1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq 0x341d(%rip), %rax      # 0x522c
leal 0x1(%rax), %esi
movl %esi, 0x3414(%rip)      # 0x522c
leaq 0x3411(%rip), %rcx      # 0x5230
movb %dil, (%rax,%rcx)
cmpl 0x33ff(%rip), %esi      # 0x5228
jne 0x1e3e
andl $0x0, 0x33fa(%rip)      # 0x522c
leaq 0x33f7(%rip), %rdi      # 0x5230
jmp 0x1d11
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1030
movq (%rax), %r12
movsbq (%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x2fef(%rip), %rdi      # 0x5130
callq 0x10d0
movq %rax, %rbx
testq %rax, %rax
jne 0x2160
leaq 0x2fdb(%rip), %rdi      # 0x5130
pushq $0x25
popq %rsi
callq 0x10d0
movq %rax, %rbx
movsbq 0x1(%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x2fc0(%rip), %rdi      # 0x5130
callq 0x10d0
movq %rax, %r15
testq %rax, %rax
jne 0x218f
leaq 0x2fac(%rip), %rdi      # 0x5130
pushq $0x25
popq %rsi
callq 0x10d0
movq %rax, %r15
movsbq 0x2(%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x2f91(%rip), %rdi      # 0x5130
callq 0x10d0
testq %rax, %rax
jne 0x21b8
leaq 0x2f80(%rip), %rdi      # 0x5130
pushq $0x25
popq %rsi
callq 0x10d0
leaq 0x2f71(%rip), %rcx      # 0x5130
subl %ecx, %ebx
imull $0x640, %ebx, %edx      # imm = 0x640
subl %ecx, %r15d
imull $0x28, %r15d, %esi
subl %ecx, %edx
addl %esi, %eax
addl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %r9d
movw $0x28, %r10w
movl %r9d, %eax
xorl %edx, %edx
divw %r10w
movl %eax, %r8d
movl %edx, %ecx
xorl %edi, %edi
cmpw $0x640, %r9w            # imm = 0x640
jb 0x2504
movw $0x640, %di             # imm = 0x640
movl %r9d, %eax
xorl %edx, %edx
divw %di
movzwl %ax, %eax
leaq 0x2c34(%rip), %rdx      # 0x5130
movb (%rax,%rdx), %al
movb %al, (%rsi)
pushq $0x1
popq %rdi
movl %r8d, %eax
xorl %edx, %edx
divw %r10w
testw %dx, %dx
je 0x2526
movzwl %dx, %eax
leaq 0x2c14(%rip), %rdx      # 0x5130
movb (%rax,%rdx), %al
movl %edi, %edx
incl %edi
movb %al, (%rsi,%rdx)
testw %cx, %cx
je 0x253f
movzwl %cx, %eax
leaq 0x2bfb(%rip), %rcx      # 0x5130
movb (%rax,%rcx), %al
movl %edi, %ecx
incl %edi
movb %al, (%rsi,%rcx)
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movw $0x28, %cx
movl %edi, %eax
xorl %edx, %edx
divw %cx
movzwl %dx, %edx
leaq 0x29a7(%rip), %r8       # 0x5130
movb (%rdx,%r8), %dl
movb %dl, 0x2(%rsi)
xorl %edx, %edx
divw %cx
movzwl %dx, %eax
movb (%rax,%r8), %al
movb %al, 0x1(%rsi)
movw $0x640, %cx             # imm = 0x640
movl %edi, %eax
xorl %edx, %edx
divw %cx
movzwl %ax, %eax
movb (%rax,%r8), %al
movb %al, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_8_rxs_m_xs_8_boundedrand_r
inline uint8_t pcg_oneseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_8* rng,
                                                     uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_oneseq_8_rxs_m_xs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x1609
cmpb %bpl, %al
jb 0x1648
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_8_rxs_m_xs_8_boundedrand_r
inline uint8_t
pcg_setseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_setseq_8* rng,
                                      uint8_t bound)
{
    uint8_t threshold = ((uint8_t)(-bound)) % bound;
    for (;;) {
        uint8_t r = pcg_setseq_8_rxs_m_xs_8_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, %eax
negb %al
movzbl %al, %eax
divb %bl
movzbl %ah, %ebp
movq %r14, %rdi
callq 0x1662
cmpb %bpl, %al
jb 0x16a1
movzbl %al, %eax
divb %bl
movzbl %ah, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/pcg-advance-8.c
// Function: pcg_advance_lcg_8
uint8_t pcg_advance_lcg_8(uint8_t state, uint8_t delta, uint8_t cur_mult,
                          uint8_t cur_plus)
{
    uint8_t acc_mult = 1u;
    uint8_t acc_plus = 0u;
    while (delta > 0) {
        if (delta & 1) {
            acc_mult *= cur_mult;
            acc_plus = acc_plus * cur_mult + cur_plus;
        }
        cur_plus = (cur_mult + 1) * cur_plus;
        cur_mult *= cur_mult;
        delta /= 2;
    }
    return acc_mult * state + acc_plus;
}

// Assembly:
movl %edx, %r9d
movb $0x1, %r8b
xorl %edx, %edx
pushq $0x1
popq %r11
testb %sil, %sil
je 0x1f62
movl %edx, %eax
mulb %r9b
addb %cl, %al
testb $0x1, %sil
movzbl %r9b, %r9d
movl %r9d, %r10d
cmovel %r11d, %r10d
movzbl %al, %eax
movzbl %dl, %edx
cmovnel %eax, %edx
movl %r8d, %eax
mulb %r10b
leal 0x1(%r9), %r10d
movl %eax, %r8d
movl %r10d, %eax
mulb %cl
movl %eax, %ecx
movl %r9d, %eax
mulb %r9b
shrb %sil
movl %eax, %r9d
jmp 0x1f1c
movl %r8d, %eax
mulb %dil
addb %dl, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/common/tree.c
// Function: make_tree
static struct node *make_tree(int depth)
{
  if (depth == 0)
    return NULL;
  else {
    if (create_garbage) {
      /* create and destroy a junk branch */
      struct node *n = NULL;
      PUSH_STACK_POINTER(n);
      SET_NODE(n, make_tree(depth-1));
      destroy_tree(n);
      UNSET_NODE(n);
      POP_STACK_POINTER(n);
    }
    
    /* Left subtree */
    struct node *l = NULL;
    PUSH_STACK_POINTER(l);
    SET_NODE(l, make_tree(depth-1));
    
    /* Right subtree */
    struct node *r = NULL;
    PUSH_STACK_POINTER(r);
    SET_NODE(r, make_tree(depth-1));
    
    /* New node */
    struct node *t = NULL;
    PUSH_STACK_POINTER(t);
    SET_NODE(t, allocate());
    SET_NODE(t->left, l);
    UNSET_NODE(l);
    SET_NODE(t->right, r);
    UNSET_NODE(r);

    UNSET_RETURN_NODE(t);

    POP_STACK_POINTER(t);
    POP_STACK_POINTER(r);
    POP_STACK_POINTER(l);

    return t;
  }
}

// Assembly:
testl %edi, %edi
je 0x124c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x2e6c(%rip), %r14      # 0x4080
movl (%r14), %eax
cmpb $0x0, 0x2e36(%rip)      # 0x4054
je 0x124f
cltq
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leal 0x1(%rax), %edx
movl %edx, (%r14)
leaq 0x2e58(%rip), %rdx      # 0x4090
movq %rcx, (%rdx,%rax,8)
decl %ebx
movl %ebx, %edi
callq 0x11fa
movl (%r14), %eax
decl %eax
jmp 0x1251
xorl %eax, %eax
retq
decl %ebx
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
cltq
leaq 0x2e27(%rip), %r13      # 0x4090
movq %r15, (%r13,%rax,8)
movl %ebx, %edi
callq 0x11fa
movq %rax, (%r15)
leaq 0x18(%rsp), %r12
andq $0x0, (%r12)
movslq (%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq %r12, (%r13,%rax,8)
movl %ebx, %edi
callq 0x11fa
movq %rax, (%r12)
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movslq (%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq %rbx, (%r13,%rax,8)
xorl %eax, %eax
callq 0x13f0
movq %rax, (%rbx)
movq (%r15), %rcx
movq %rcx, (%rax)
movq (%r12), %rcx
movq (%rbx), %rax
movq %rcx, 0x8(%rax)
addl $-0x3, (%r14)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/2space/2space.c
// Function: collect_garbage
void collect_garbage()
{
  /* Set up new space */
  size_t new_size = (space_end - space_start + sizeof(struct gc_node));
  if (new_size < (prev_size * 2))
    new_size = prev_size * 2;
  
  void *new_space = raw_malloc(new_size);
  struct gc_node *alloc_pos = new_space;

  /* Copy into new space */
  copy_from_roots(&alloc_pos);

  /* Clean up old space */
  if (space_start != 0)
    raw_free((void *)space_start, space_end - space_start);

  /* Continue allocating into new space */
  space_start = (uintptr_t)new_space;
  space_end = space_start + new_size;
  space_next = (uintptr_t)alloc_pos;

  /* Remember size after collection to be used as a guide for the next
     space's size: */
  prev_size = space_next - space_start;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2d25(%rip), %r15      # 0x4078
movq (%r15), %rax
leaq 0x3133(%rip), %r12      # 0x4490
subq (%r12), %rax
addq $0x18, %rax
movq 0x2cd4(%rip), %rbx      # 0x4040
addq %rbx, %rbx
cmpq %rbx, %rax
cmovaq %rax, %rbx
movq %rbx, %rdi
callq 0x130c
movq %rax, %r14
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x1427
movq (%r12), %rdi
testq %rdi, %rdi
je 0x13a0
movq (%r15), %rsi
subq %rdi, %rsi
callq 0x1336
movq %r14, (%r12)
addq %r14, %rbx
movq %rbx, (%r15)
movq (%rsp), %rax
leaq 0x2cbb(%rip), %rcx      # 0x4070
movq %rax, (%rcx)
subq %r14, %rax
movq %rax, 0x2c7e(%rip)      # 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/2space/copy.c
// Function: allocate
struct node *allocate()
{
  if (space_next + sizeof(struct gc_node) > space_end)
    collect_garbage();

  struct gc_node *p = (struct gc_node *)space_next;
  space_next += sizeof(struct gc_node);

  p->forwarded = 0;

  return &p->n;
}

// Assembly:
pushq %rax
movq 0x2c78(%rip), %rax      # 0x4070
leaq 0x18(%rax), %rcx
cmpq 0x2c75(%rip), %rcx      # 0x4078
jbe 0x1417
xorl %eax, %eax
callq 0x1344
movq 0x2c5d(%rip), %rax      # 0x4070
leaq 0x18(%rax), %rcx
movq %rcx, 0x2c52(%rip)      # 0x4070
andl $0x0, (%rax)
addq $0x8, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/2space/copy.c
// Function: copy_from_roots
void copy_from_roots(struct gc_node **alloc_pos_ptr)
{
  struct gc_node *init_ptr = *alloc_pos_ptr;
  
  for (int i = 0; i < num_roots; i++) {
    copy_or_forward(root_addrs[i], alloc_pos_ptr);
  }

  traverse_copied(init_ptr, alloc_pos_ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x2c54(%rip), %r15      # 0x4090
xorl %r12d, %r12d
movslq 0x2c3a(%rip), %rax      # 0x4080
cmpq %rax, %r12
jge 0x147b
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x148c
incq %r12
addq $0x8, %r15
jmp 0x143f
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x148c
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x148c
addq $0x18, %r14
cmpq (%rbx), %r14
jb 0x145f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/2space/copy.c
// Function: copy_or_forward
static void copy_or_forward(struct node **addr,
                            struct gc_node **alloc_pos_ptr)
{
  if (is_allocated(*addr)) {
    struct gc_node *nh;
    nh = NODE_TO_GC(*addr);
    
    if (nh->forwarded) {
      /* Object already copied */
      *addr = nh->forward_to;
    } else {
      /* Allocate a copy: */
      struct gc_node *nh2;
      nh2 = *alloc_pos_ptr;
      (*alloc_pos_ptr)++;
      memcpy(nh2, nh, sizeof(struct gc_node));

      /* Mark old location as copied and set forwarding pointer */
      nh->forwarded = 1;
      nh->forward_to = &nh2->n;
      *addr = &nh2->n;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x13ce
testl %eax, %eax
je 0x14dd
movq (%rbx), %rax
cmpl $0x0, -0x8(%rax)
je 0x14b0
movq (%rax), %rcx
jmp 0x14da
leaq -0x8(%rax), %rdx
movq (%r14), %rcx
leaq 0x18(%rcx), %rsi
movq %rsi, (%r14)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx)
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movl $0x1, -0x8(%rax)
addq $0x8, %rcx
movq %rcx, (%rax)
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq