LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/fight.c
// Function: prname
char *prname(char *who,bool upper)
{
static char tbuf[LINLEN];

	*tbuf = '\0';
	if (who == 0)
		strcpy(tbuf, "you"); 
	else if (pl_on(ISBLIND))
		strcpy(tbuf, "it");
	else {
		strcpy(tbuf, "the ");
		strcat(tbuf, who);
	}
	if (upper)
		*tbuf = toupper(*tbuf);
	return tbuf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movb $0x0, 0x23430(%rip)     # 0x2d7f0
testq %rdi, %rdi
je 0xa3e8
movq %rdi, %r14
movl $0x1, %edi
callq 0x9595
testb %al, %al
je 0xa3f4
movb $0x0, 0x23415(%rip)     # 0x2d7f2
movw $0x7469, 0x2340a(%rip)  # imm = 0x7469
jmp 0xa414
movl $0x756f79, 0x233fe(%rip) # imm = 0x756F79
jmp 0xa414
movb $0x0, 0x233f9(%rip)     # 0x2d7f4
movl $0x20656874, 0x233eb(%rip) # imm = 0x20656874
leaq 0x233e4(%rip), %rdi     # 0x2d7f0
movq %r14, %rsi
callq 0x64d0
testb %bl, %bl
je 0xa431
callq 0x6030
movq (%rax), %rax
movsbq 0x233c8(%rip), %rcx     # 0x2d7f0
movb (%rax,%rcx,4), %al
movb %al, 0x233bf(%rip)      # 0x2d7f0
leaq 0x233b8(%rip), %rax     # 0x2d7f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/fight.c
// Function: remove_monster
void remove_monster(struct coord *mp,struct linked_list *item)
{
	char what;

	mvwaddch(mw, mp->y, mp->x, ' ');
	if (pl_on(ISBLIND))
		what = ' ';							/* if blind, then a blank */
	else
		what = (THINGPTR(item))->t_oldch;	/* normal char */
	mvwaddch(cw, mp->y, mp->x, what);
	detach(mlist, item);
	discard(item);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x25b50(%rip), %r15     # 0x309f0
movq (%r15), %rdi
movl (%r14), %edx
movl 0x4(%r14), %esi
callq 0x6490
cmpl $-0x1, %eax
je 0xaec1
movq (%r15), %rdi
movl $0x20, %esi
callq 0x64c0
movl $0x1, %edi
callq 0x9595
movl $0x20, %ebp
testb %al, %al
jne 0xaedf
movq 0x10(%rbx), %rax
movsbl 0x8f(%rax), %ebp
leaq 0x25afa(%rip), %r15     # 0x309e0
movq (%r15), %rdi
movl (%r14), %edx
movl 0x4(%r14), %esi
callq 0x6490
cmpl $-0x1, %eax
je 0xaf04
movq (%r15), %rdi
movl %ebp, %esi
callq 0x64c0
leaq 0x22935(%rip), %rdi     # 0x2d840
movq %rbx, %rsi
callq 0xbe00
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbe93
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/fight.c
// Function: check_level
void check_level()
{
	int lev, add, dif;

	for (lev = 0; e_levels[lev] != 0; lev++)
	if (e_levels[lev] > him->s_exp)
		break;
	lev += 1;
	if (lev > him->s_lvl) {
		dif = lev - him->s_lvl;
		add = roll(dif, 10) + (dif * getpcon(him));
		him->s_maxhp += add;
		if ((him->s_hpt += add) > him->s_maxhp)
			him->s_hpt = him->s_maxhp;
		msg("Welcome to level %d", lev);
	}
	him->s_lvl = lev;
}

// Assembly:
leaq 0x21ad1(%rip), %rcx     # 0x2ca30
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xaf8b
leaq 0x22df2(%rip), %rax     # 0x2dd60
movq (%rax), %rax
movq 0x20(%rax), %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
jg 0xaf8d
movq 0x8(%rcx,%rax,8), %rdx
incq %rax
testq %rdx, %rdx
jne 0xaf77
jmp 0xaf8d
xorl %eax, %eax
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leal 0x1(%rax), %ebx
leaq 0x22dc2(%rip), %r15     # 0x2dd60
movq (%r15), %rcx
movl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jl 0xafef
movl %ebx, %ebp
subl %ecx, %ebp
movl %ebp, %edi
movl $0xa, %esi
callq 0xc74e
movl %eax, %r14d
movq (%r15), %rdi
callq 0x12173
imull %ebp, %eax
addl %r14d, %eax
movq (%r15), %rcx
movl 0x34(%rcx), %edx
addl %eax, %edx
movl %edx, 0x34(%rcx)
addl 0x30(%rcx), %eax
cmpl %edx, %eax
cmovgel %edx, %eax
movl %eax, 0x30(%rcx)
leaq 0x14abc(%rip), %rdi     # 0x1faa2
movl %ebx, %esi
xorl %eax, %eax
callq 0xb6e0
movq (%r15), %rax
movl %ebx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_things
void init_things()
{
	struct magic_item *mi;
	
	/*
	 * init general things
	 */
	for (mi = &things[1]; mi < &things[NUMTHINGS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("things", things);
	/*
	 * init armor things
	 */
	for (mi = &a_magic[1]; mi < &a_magic[MAXARMORS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("armor", a_magic);
	/*
	 * init weapon stuff
	 */
	for (mi = &w_magic[1]; mi < &w_magic[MAXWEAPONS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("weapon", w_magic);
}

// Assembly:
pushq %rax
leaq 0x20cf8(%rip), %rax     # 0x2bdd0
leaq 0x10(%rax), %rcx
subq $-0x80, %rax
movl -0x8(%rcx), %edx
addl %edx, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0xb0e0
leaq 0x15956(%rip), %rdi     # 0x20a4c
leaq 0x20cd3(%rip), %rsi     # 0x2bdd0
callq 0xb175
leaq 0x20d57(%rip), %rax     # 0x2be60
addq $0x10, %rax
movl $0xa0, %ecx
addq 0x1ee77(%rip), %rcx     # 0x29f90
movl -0x8(%rax), %edx
addl %edx, 0x8(%rax)
addq $0x10, %rax
cmpq %rcx, %rax
jb 0xb119
leaq 0x14ecb(%rip), %rdi     # 0x1fffa
leaq 0x20d2a(%rip), %rsi     # 0x2be60
callq 0xb175
leaq 0x20e4e(%rip), %rax     # 0x2bf90
addq $0x10, %rax
movl $0x120, %ecx            # imm = 0x120
addq 0x1edce(%rip), %rcx     # 0x29f20
movl -0x8(%rax), %edx
addl %edx, 0x8(%rax)
addq $0x10, %rax
cmpq %rcx, %rax
jb 0xb152
leaq 0x14d7e(%rip), %rdi     # 0x1fee6
leaq 0x20e21(%rip), %rsi     # 0x2bf90
popq %rax
jmp 0xb175
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: badcheck
int badcheck(char *name,struct magic_item *magic)
{
	struct magic_item *mg;

	for (mg = magic; mg->mi_name != NULL; mg++)
		;
	if ((mg - 1)->mi_prob == 1000)
		return 0;
	printf("\nBad percentages for %s:\n", name);
	for (mg = magic; mg->mi_name != NULL; mg++)
		printf("%4d%% %s\n", mg->mi_prob, mg->mi_name);
	printf("%s", retstr);
	fflush(stdout);
	while (getchar() != '\n')
		continue;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rax
cmpq $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0xb182
cmpl $0x3e8, -0x18(%rax)     # imm = 0x3E8
je 0xb1fd
leaq 0x158d4(%rip), %rdi     # 0x20a70
xorl %eax, %eax
callq 0x61c0
movq (%rbx), %rdx
testq %rdx, %rdx
je 0xb1cf
addq $0x10, %rbx
leaq 0x158d4(%rip), %r14     # 0x20a8a
movl -0x8(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x61c0
movq (%rbx), %rdx
addq $0x10, %rbx
testq %rdx, %rdx
jne 0xb1b6
leaq 0x14412(%rip), %rdi     # 0x1f5e8
leaq 0x1f163(%rip), %rsi     # 0x2a340
xorl %eax, %eax
callq 0x61c0
movq 0x1ed15(%rip), %rax     # 0x29f00
movq (%rax), %rdi
callq 0x6350
callq 0x6270
cmpl $0xa, %eax
jne 0xb1f3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_colors
void init_colors()
{
	int i, j;
	char *str;
	bool used[NCOLORS];

	for (i = 0; i < NCOLORS; i++)
		used[i] = FALSE;
	for (i = 0; i < MAXPOTIONS; i++) {
		do {
			j = rnd(NCOLORS);
		} until (!used[j]);
		used[j] = TRUE;
		p_colors[i] = rainbow[j];
		p_know[i] = FALSE;
		p_guess[i] = NULL;
		if (i > 0)
			p_magic[i].mi_prob += p_magic[i-1].mi_prob;
	}
	badcheck("potions", p_magic);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x218f8(%rip), %rbx     # 0x2cb20
leaq 0x253c1(%rip), %r14     # 0x305f0
leaq 0x251ca(%rip), %r15     # 0x30400
leaq 0x24f53(%rip), %r12     # 0x30190
leaq 0x2126c(%rip), %r13     # 0x2c4b0
xorl %ebp, %ebp
movl $0x20, %edi
xorl %eax, %eax
callq 0xc72d
cltq
cmpb $0x0, (%rsp,%rax)
jne 0xb246
movb $0x1, (%rsp,%rax)
movq (%rbx,%rax,8), %rax
movq %rax, (%r14,%rbp,8)
movb $0x0, (%r15,%rbp)
movq $0x0, (%r12,%rbp,8)
testq %rbp, %rbp
je 0xb289
movq %rbp, %rax
shlq $0x4, %rax
movl -0x8(%r13,%rax), %ecx
addl %ecx, 0x8(%r13,%rax)
incq %rbp
cmpq $0x15, %rbp
jne 0xb246
leaq 0x157ba(%rip), %rdi     # 0x20a53
leaq 0x21210(%rip), %rsi     # 0x2c4b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb175
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_names
void init_names()
{
	int nsyl;
	char *cp, *sp;
	int i, nwords;

	for (i = 0; i < MAXSCROLLS; i++) {
		cp = prbuf;
		nwords = rnd(3)+1;
		while(nwords--)	{
			nsyl = rnd(3)+2;
			while(nsyl--) {
				sp = sylls[rnd(NSYLS)];
				while(*sp)
					*cp++ = *sp++;
			}
			*cp++ = ' ';
		}
		*--cp = '\0';
		s_names[i] = new(strlen(prbuf)+1);
		s_know[i] = FALSE;
		s_guess[i] = NULL;
		strcpy(s_names[i], prbuf);
		if (i > 0)
			s_magic[i].mi_prob += s_magic[i-1].mi_prob;
	}
	badcheck("scrolls", s_magic);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x22bcb(%rip), %r15     # 0x2de90
leaq 0x21954(%rip), %r12     # 0x2cc20
xorl %r13d, %r13d
movl $0x3, %edi
xorl %eax, %eax
callq 0xc72d
movq %r15, %rbx
cmpl $-0x1, %eax
je 0xb339
movl %eax, %ebp
movq %r15, %rbx
movl $0x3, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $-0x2, %eax
je 0xb32e
movl %eax, %r14d
incl %r14d
movl $0x9f, %edi
xorl %eax, %eax
callq 0xc72d
cltq
movq (%r12,%rax,8), %rax
movb (%rax), %cl
testb %cl, %cl
je 0xb328
incq %rax
movb %cl, (%rbx)
incq %rbx
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xb31a
subl $0x1, %r14d
jae 0xb2ff
movb $0x20, (%rbx)
incq %rbx
subl $0x1, %ebp
jae 0xb2e8
xorl %r14d, %r14d
movb %r14b, -0x1(%rbx)
movq %r15, %rdi
callq 0x6170
leal 0x1(%rax), %edi
callq 0xbee3
leaq 0x251c9(%rip), %rcx     # 0x30520
movq %rax, (%rcx,%r13,8)
leaq 0x2507e(%rip), %rcx     # 0x303e0
movb %r14b, (%rcx,%r13)
leaq 0x24d53(%rip), %rcx     # 0x300c0
movq $0x0, (%rcx,%r13,8)
movq %rax, %rdi
movq %r15, %rsi
callq 0x60e0
testq %r13, %r13
je 0xb39b
movq %r13, %rax
shlq $0x4, %rax
leaq 0x20f6d(%rip), %rdx     # 0x2c300
movl -0x8(%rdx,%rax), %ecx
addl %ecx, 0x8(%rdx,%rax)
incq %r13
cmpq $0x1a, %r13
jne 0xb2cf
leaq 0x156ac(%rip), %rdi     # 0x20a5b
leaq 0x20f4a(%rip), %rsi     # 0x2c300
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb175
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_stones
void init_stones()
{
	int i, j;
	char *str;
	bool used[NSTONES];

	for (i = 0; i < NSTONES; i++)
		used[i] = FALSE;

	for (i = 0; i < MAXRINGS; i++) {
		do {
			j = rnd(NSTONES);
		} until (!used[j]);
		used[j] = TRUE;
		r_stones[i] = stones[j];
		r_know[i] = FALSE;
		r_guess[i] = NULL;
		if (i > 0)
			r_magic[i].mi_prob += r_magic[i-1].mi_prob;
	}
	badcheck("rings", r_magic);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x0, 0x1f(%rsp)
leaq 0x21d2e(%rip), %rbx     # 0x2d120
leaq 0x252a7(%rip), %r14     # 0x306a0
leaq 0x25020(%rip), %r15     # 0x30420
leaq 0x24e39(%rip), %r12     # 0x30240
leaq 0x21202(%rip), %r13     # 0x2c610
xorl %ebp, %ebp
movl $0x23, %edi
xorl %eax, %eax
callq 0xc72d
cltq
cmpb $0x0, (%rsp,%rax)
jne 0xb410
movb $0x1, (%rsp,%rax)
movq (%rbx,%rax,8), %rax
movq %rax, (%r14,%rbp,8)
movb $0x0, (%r15,%rbp)
movq $0x0, (%r12,%rbp,8)
testq %rbp, %rbp
je 0xb453
movq %rbp, %rax
shlq $0x4, %rax
movl -0x8(%r13,%rax), %ecx
addl %ecx, 0x8(%r13,%rax)
incq %rbp
cmpq $0x1a, %rbp
jne 0xb410
leaq 0x15600(%rip), %rdi     # 0x20a63
leaq 0x211a6(%rip), %rsi     # 0x2c610
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb175
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_materials
void init_materials()
{
	int i, j;
	char *str;
	struct rod *rd;
	bool metused[NMETAL], woodused[NWOOD];

	for (i = 0; i < NWOOD; i++)
		woodused[i] = FALSE;
	for (i = 0; i < NMETAL; i++)
		metused[i] = FALSE;

	for (i = 0; i < MAXSTICKS; i++) {
		rd = &ws_stuff[i];
		for (;;)  {
			if (rnd(100) > 50) {
				j = rnd(NMETAL);
				if (!metused[j]) {
					str = metal[j];
					rd->ws_type = "wand";
					rd->ws_vol = V_WS_WAND;
					rd->ws_wght = W_WS_WAND;
					metused[j] = TRUE;
					break;
				}
			}
			else {
				j = rnd(NWOOD);
				if (!woodused[j]) {
					str = wood[j];
					rd->ws_type = "staff";
					rd->ws_vol = V_WS_STAFF;
					rd->ws_wght = W_WS_WAND;
					woodused[j] = TRUE;
					break;
				}
			}
		} 
		ws_stuff[i].ws_made = str;
		ws_know[i] = FALSE;
		ws_guess[i] = NULL;
		if (i > 0)
			ws_magic[i].mi_prob += ws_magic[i-1].mi_prob;
	}
	badcheck("sticks", ws_magic);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rax, (%rsp)
movq %rax, 0x7(%rsp)
leaq 0x252c6(%rip), %rbx     # 0x30770
leaq 0x24f8f(%rip), %r12     # 0x30440
leaq 0x24e58(%rip), %r13     # 0x30310
leaq 0x21301(%rip), %rbp     # 0x2c7c0
xorl %r14d, %r14d
leaq (%r14,%r14,2), %r15
shlq $0x3, %r15
addq %rbx, %r15
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $0x33, %eax
jl 0xb4f5
movl $0xf, %edi
xorl %eax, %eax
callq 0xc72d
movslq %eax, %rcx
cmpb $0x0, (%rsp,%rcx)
jne 0xb4cd
jmp 0xb52c
movl $0x18, %edi
xorl %eax, %eax
callq 0xc72d
movslq %eax, %rcx
cmpb $0x0, 0x10(%rsp,%rcx)
jne 0xb4cd
leaq (%rsp,%rcx), %rax
addq $0x10, %rax
leaq 0x21d26(%rip), %rdx     # 0x2d240
leaq (%rdx,%rcx,8), %rcx
movl $0xc8, %edx
leaq 0x14915(%rip), %rsi     # 0x1fe3f
jmp 0xb547
leaq (%rsp,%rcx), %rax
leaq 0x21dc9(%rip), %rdx     # 0x2d300
leaq (%rdx,%rcx,8), %rcx
movl $0x6e, %edx
leaq 0x14cf6(%rip), %rsi     # 0x2023d
movq (%rcx), %rcx
movq %rsi, (%r15)
movl %edx, 0x10(%r15)
movl $0x3c, 0x14(%r15)
movb $0x1, (%rax)
movq %rcx, 0x8(%r15)
movb $0x0, (%r12,%r14)
movq $0x0, (%r13,%r14,8)
testq %r14, %r14
je 0xb582
movq %r14, %rax
shlq $0x4, %rax
movl -0x8(%rbp,%rax), %ecx
addl %ecx, 0x8(%rbp,%rax)
incq %r14
cmpq $0x1a, %r14
jne 0xb4c2
leaq 0x154d3(%rip), %rdi     # 0x20a69
leaq 0x21223(%rip), %rsi     # 0x2c7c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb175
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_player
void init_player()
{
	player.t_nomove = 0;
	player.t_nocmd = 0;
	him = &player.t_stats;
	him->s_lvl = 1;
	him->s_exp = 0L;
	him->s_maxhp = him->s_hpt = pinit();		/* hit points */
	him->s_re.a_str = pinit();		/* strength */
	him->s_re.a_dex = pinit();		/* dexterity */
	him->s_re.a_wis = pinit();		/* wisdom */
	him->s_re.a_con = pinit();		/* constitution */
	him->s_ef = him->s_re;			/* effective = real */
	strcpy(him->s_dmg, "1d4");
	him->s_arm = NORMAC;
	him->s_carry = totalenc();
	him->s_pack = 0;
	pack = NULL;				/* empty pack so far */
	max_stats = *him;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x226a4(%rip), %rbx     # 0x2dc60
xorl %r14d, %r14d
movq %r14, 0x84(%rbx)
leaq 0x22793(%rip), %r15     # 0x2dd60
movq %rbx, (%r15)
movl $0x1, 0x28(%rbx)
movq %r14, 0x20(%rbx)
callq 0xb662
movq (%r15), %rcx
movl %eax, 0x30(%rcx)
movl %eax, 0x34(%rcx)
callq 0xb662
movq (%r15), %rcx
movl %eax, (%rcx)
callq 0xb662
movq (%r15), %rcx
movl %eax, 0x4(%rcx)
callq 0xb662
movq (%r15), %rcx
movl %eax, 0x8(%rcx)
callq 0xb662
movq (%r15), %rcx
movl %eax, 0xc(%rcx)
movq (%rcx), %rax
movq %rax, 0x10(%rcx)
movl 0x8(%rcx), %eax
movl %eax, 0x18(%rcx)
movl 0xc(%rcx), %eax
movl %eax, 0x1c(%rcx)
movl $0x346431, 0x40(%rcx)   # imm = 0x346431
movl $0xa, 0x2c(%rcx)
xorl %eax, %eax
callq 0x98cf
movq (%r15), %rsi
movl %eax, 0x3c(%rsi)
movl $0x0, 0x38(%rsi)
movq %r14, 0x68(%rbx)
leaq 0x226a4(%rip), %rdi     # 0x2dcf8
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: pinit
int pinit()
{
	int best[4];
	int i, min, minind, dicetot;

	for (i = 0 ; i < 4 ; i++)
		best[i] = roll(1,6);	/* populate array */
	min = best[0];				/* assume that 1st entry */
	minind = 0;					/* is the lowest */
	for (i = 1 ; i < 4 ; i++) {	/* find the lowest */
		if (best[i] < min) {	/* if < minimum then update */
			min = best[i];
			minind = i;			/* point to lowest value */
		}
	}
	dicetot = 0;				/* start with nothing */
	for (i = 0 ; i < 4 ; i++) {
		if (i != minind)		/* if not minimum, then add it */
			dicetot += best[i];
	}
	return(dicetot);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
movl $0x1, %edi
movl $0x6, %esi
callq 0xc74e
movl %eax, (%rsp,%rbx,4)
incq %rbx
cmpq $0x4, %rbx
jne 0xb669
xorl %eax, %eax
movl $0x1, %ecx
movl (%rsp), %edx
movl (%rsp,%rcx,4), %esi
cmpl %edx, %esi
cmovll %esi, %edx
cmovll %ecx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0xb68e
movl %eax, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0xb6b0
addl (%rsp,%rdx,4), %eax
incq %rdx
cmpq $0x4, %rdx
jne 0xb6a8
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/init.c
// Function: init_everything
void init_everything()
{
	init_player();			/* Roll up the rogue */
	init_things();			/* Set up probabilities */
	init_names();			/* Set up names of scrolls */
	init_colors();			/* Set up colors of potions */
	init_stones();			/* Set up stones in rings */
	init_materials();		/* Set up materials of wands */
}

// Assembly:
pushq %rax
callq 0xb5b0
callq 0xb0d0
callq 0xb2b3
callq 0xb207
callq 0xb3c9
popq %rax
jmp 0xb47d
nop
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/io.c
// Function: msg
int msg(char *fmt, ...)
{
	va_list ap;
	/*
	 * if the string is "", just clear the line
	 */
	if (*fmt == '\0') {
		wmove(cw, 0, 0);
		wclrtoeol(cw);
		mpos = 0;
		return 0;
	}
	/*
	 * otherwise add to the message and flush it out
	 */
	va_start(ap, fmt);
	doadd(fmt, ap);
	va_end(ap);
	endmsg();
  return 0;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xb73c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpb $0x0, (%rdi)
je 0xb797
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movslq 0x27290(%rip), %rdi     # 0x32a00
leaq 0x25289(%rip), %rbx     # 0x30a00
addq %rbx, %rdi
movq %r10, %rsi
callq 0x6400
movq %rbx, %rdi
callq 0x6170
movl %eax, 0x27270(%rip)     # 0x32a00
callq 0xb8a6
jmp 0xb7bf
leaq 0x25242(%rip), %rbx     # 0x309e0
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6490
movq (%rbx), %rdi
callq 0x64a0
leaq 0x220b7(%rip), %rax     # 0x2d870
movl $0x0, (%rax)
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/io.c
// Function: endmsg
void endmsg()
{
	strcpy(huh, msgbuf);
	if (mpos > 0) {
		wmove(cw, 0, mpos);
		waddstr(cw, morestr);
		draw(cw);
		wait_for(cw, ' ');
	}
	mvwaddstr(cw, 0, 0, msgbuf);
	wclrtoeol(cw);
	mpos = newpos;
	newpos = 0;
	draw(cw);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x226cf(%rip), %rdi     # 0x2df80
leaq 0x25148(%rip), %rsi     # 0x30a00
callq 0x60e0
leaq 0x21fac(%rip), %r14     # 0x2d870
movl (%r14), %edx
testl %edx, %edx
jle 0xb908
leaq 0x2510e(%rip), %rbx     # 0x309e0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6490
movq (%rbx), %rdi
leaq 0x1ea48(%rip), %rsi     # 0x2a32e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6550
movq (%rbx), %rdi
callq 0x6200
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x6110
cmpl $0x20, %eax
jne 0xb8fb
leaq 0x250d1(%rip), %rbx     # 0x309e0
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6490
cmpl $-0x1, %eax
je 0xb934
movq (%rbx), %rdi
leaq 0x250d6(%rip), %rsi     # 0x30a00
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6550
movq (%rbx), %rdi
callq 0x64a0
movl 0x270be(%rip), %eax     # 0x32a00
movl %eax, (%r14)
movl $0x0, 0x270b1(%rip)     # 0x32a00
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6200
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/list.c
// Function: detach
void _detach(struct linked_list **list,struct linked_list *item)
{
	if (*list == item)
		*list = next(item);
	if (prev(item) != NULL)
		item->l_prev->l_next = next(item);
	if (next(item) != NULL)
		item->l_next->l_prev = prev(item);
	item->l_next = NULL;
	item->l_prev = NULL;
}

// Assembly:
cmpq %rsi, (%rdi)
jne 0xbe0b
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xbe1a
movq (%rsi), %rcx
movq %rcx, (%rax)
movq (%rsi), %rcx
testq %rcx, %rcx
je 0xbe26
movq %rax, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/list.c
// Function: attach
void _attach(struct linked_list **list,struct linked_list *item)
{
	if (*list != NULL) 	{
		item->l_next = *list;
		(*list)->l_prev = item;
		item->l_prev = NULL;
	}
	else 	{
		item->l_next = NULL;
		item->l_prev = NULL;
	}
	*list = item;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xbe49
movq %rax, (%rsi)
movq (%rdi), %rax
movq %rsi, 0x8(%rax)
movq $0x0, 0x8(%rsi)
jmp 0xbe4f
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/list.c
// Function: free_list
void _free_list(struct linked_list **ptr)
{
	struct linked_list *item;

	while (*ptr != NULL) {
		item = *ptr;
		*ptr = next(item);
		discard(item);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xbe8d
movq %rdi, %rbx
leaq 0x21a0e(%rip), %r15     # 0x2d878
movq (%r14), %rax
movq %rax, (%rbx)
addl $-0x2, (%r15)
movq 0x10(%r14), %rdi
callq 0x6050
movq %r14, %rdi
callq 0x6050
movq (%rbx), %r14
testq %r14, %r14
jne 0xbe6a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/list.c
// Function: new_item
struct linked_list *new_item(int size)
{
	struct linked_list *item;

	item = (struct linked_list *) new(sizeof *item);
	item->l_data = new(size);
	item->l_next = item->l_prev = NULL;
	return item;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x18, %edi
callq 0xbee3
movq %rax, %r14
movl %ebx, %edi
callq 0xbee3
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/list.c
// Function: new
char *new(int size)
{
	char *space = ALLOC(size);

	if (space == NULL) {
		sprintf(prbuf,"Rogue ran out of memory.");
		fatal(prbuf);
	}
	total++;
	return space;
}

// Assembly:
pushq %rbx
movl %edi, %edi
callq 0x6340
movq %rax, %rbx
testq %rax, %rax
jne 0xbf14
movups 0x14c8c(%rip), %xmm0    # 0x20b86
leaq 0x21f8f(%rip), %rdi     # 0x2de90
movups %xmm0, 0x9(%rdi)
movups 0x14c71(%rip), %xmm0    # 0x20b7d
movups %xmm0, (%rdi)
callq 0xc6c5
leaq 0x2195d(%rip), %rax     # 0x2d878
incl (%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: fatal
void fatal(char *s)
{
	clear();
	refresh();
	endwin();
	fprintf(stderr,"%s\n\r",s);
	fflush(stderr);
	byebye(2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d85d(%rip), %r14     # 0x29f30
movq (%r14), %rdi
callq 0x6120
movq (%r14), %rdi
callq 0x6200
callq 0x6530
movq 0x1d909(%rip), %r14     # 0x29ff8
movq (%r14), %rdi
leaq 0x15693(%rip), %rsi     # 0x21d8c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6290
movq (%r14), %rdi
callq 0x6350
movl $0x2, %edi
callq 0xc715
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: rnd
int rnd(int range)
{
	int wh;

	if (range == 0)
		wh = 0;
	else {
		wh = lrand48() % range;
		wh &= 0x7FFFFFFF;
	}
	return wh;
}

// Assembly:
testl %edi, %edi
je 0xc74b
pushq %rbx
movl %edi, %ebx
callq 0x6380
movslq %ebx, %rcx
cqto
idivq %rcx
movq %rdx, %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: roll
int roll(int number,int sides)
{
	int dtotal = 0;

	while(number-- > 0)
		dtotal += rnd(sides)+1;
	return dtotal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0xc78e
movl %esi, %ebx
movl %edi, %ebp
movslq %esi, %r15
incl %ebp
xorl %r14d, %r14d
testl %ebx, %ebx
je 0xc77d
callq 0x6380
cqto
idivq %r15
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
incl %edx
jmp 0xc782
movl $0x1, %edx
addl %edx, %r14d
decl %ebp
cmpl $0x1, %ebp
jg 0xc765
jmp 0xc791
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: setup
void setup()
{
	signal(SIGHUP, auto_save);
	signal(SIGINT, auto_save);
	signal(SIGQUIT,  byebye);
	signal(SIGILL, game_err);
	signal(SIGTRAP, game_err);
#ifdef SIGIOT
	signal(SIGIOT, game_err);
#endif
#ifdef SIGEMT
	signal(SIGEMT, game_err);
#endif
	signal(SIGFPE, game_err);
#ifdef SIGBUS
	signal(SIGBUS, game_err);
#endif
	signal(SIGSEGV, game_err);
#ifdef SIGSYS
	signal(SIGSYS, game_err);
#endif
	signal(SIGPIPE, game_err);
	signal(SIGTERM, game_err);

	cbreak();
	noecho();
}

// Assembly:
pushq %rbx
leaq 0x7ad8(%rip), %rbx      # 0x1427f
movl $0x1, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x2, %edi
movq %rbx, %rsi
callq 0x6280
leaq -0xb3(%rip), %rsi       # 0xc715
movl $0x3, %edi
callq 0x6280
leaq 0x7ab9(%rip), %rbx      # 0x14292
movl $0x4, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x5, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x6, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x8, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x7, %edi
movq %rbx, %rsi
callq 0x6280
movl $0xb, %edi
movq %rbx, %rsi
callq 0x6280
movl $0x1f, %edi
movq %rbx, %rsi
callq 0x6280
movl $0xd, %edi
movq %rbx, %rsi
callq 0x6280
movl $0xf, %edi
movq %rbx, %rsi
callq 0x6280
callq 0x6320
popq %rbx
jmp 0x6180
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: playit
void playit()
{
	char *opts;

	tcgetattr(0,&terminal);


	/* parse environment declaration of options */

	if ((opts = getenv("ROGUEOPTS")) != NULL)
		parse_opts(opts);

	player.t_oldpos = hero;
	oldrp = roomin(&hero);
	nochange = FALSE;
	while (playing)
		command();		/* Command execution */
	endit(0);
}

// Assembly:
pushq %rbx
leaq 0x261ff(%rip), %rsi     # 0x32a60
xorl %edi, %edi
callq 0x6430
leaq 0x1437d(%rip), %rdi     # 0x20bec
callq 0x6040
testq %rax, %rax
je 0xc881
movq %rax, %rdi
callq 0x1013f
leaq 0x213d8(%rip), %rax     # 0x2dc60
leaq 0x50(%rax), %rdi
movq 0x50(%rax), %rcx
movq %rcx, 0x58(%rax)
callq 0x7052
leaq 0x213b8(%rip), %rcx     # 0x2dc58
movq %rax, (%rcx)
leaq 0x20ff9(%rip), %rax     # 0x2d8a3
movb $0x0, (%rax)
leaq 0x1da58(%rip), %rbx     # 0x2a30c
cmpb $0x1, (%rbx)
jne 0xc8c5
xorl %eax, %eax
callq 0x75e8
cmpb $0x0, (%rbx)
jne 0xc8b9
leaq 0x143be(%rip), %rdi     # 0x20c8a
callq 0xc6c5
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/main.c
// Function: roguehome
char *roguehome()
{
    static char path[1024];
    char *end,*home;

    if ( (home = getenv("ROGUEHOME")) != NULL)
    {
        if (*home)
        {
            strncpy(path, home, PATH_MAX - 20);

            end = &path[strlen(path)-1];


            while( (end >= path) && ((*end == '/') || (*end == '\\')))
                *end-- = '\0';

            if (directory_exists(path))
                return(path);
        }
    }

    if (directory_exists("/var/games/roguelike"))
        return("/var/games/roguelike");
    if (directory_exists("/var/lib/roguelike"))
        return("/var/lib/roguelike");
    if (directory_exists("/var/roguelike"))
        return("/var/roguelike");
    if (directory_exists("/usr/games/lib"))
        return("/usr/games/lib");
    if (directory_exists("/games/roguelik"))
        return("/games/roguelik");

    return(NULL);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x14396(%rip), %rdi     # 0x20cc4
callq 0x6040
testq %rax, %rax
je 0xc99f
cmpb $0x0, (%rax)
je 0xc99f
leaq 0x2615c(%rip), %rbx     # 0x32aa0
movl $0xfec, %edx            # imm = 0xFEC
movq %rbx, %rdi
movq %rax, %rsi
callq 0x60b0
movq %rbx, %rdi
callq 0x6170
decq %rax
js 0xc97c
addq %rbx, %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0xc971
cmpl $0x2f, %ecx
jne 0xc97c
movb $0x0, (%rax)
decq %rax
cmpq %rbx, %rax
jae 0xc964
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x62b0
testl %eax, %eax
jne 0xc99f
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0xca63
leaq 0x14328(%rip), %rbx     # 0x20cce
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x62b0
movl $0xf000, %ebp           # imm = 0xF000
testl %eax, %eax
jne 0xc9cb
movl 0x18(%rsp), %eax
andl %ebp, %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0xca63
leaq 0x14311(%rip), %rbx     # 0x20ce3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x62b0
testl %eax, %eax
jne 0xc9ed
andl 0x18(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
je 0xca63
leaq 0x14302(%rip), %rbx     # 0x20cf6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x62b0
movl $0xf000, %ebp           # imm = 0xF000
testl %eax, %eax
jne 0xca15
movl 0x18(%rsp), %eax
andl %ebp, %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0xca63
leaq 0x142e9(%rip), %rbx     # 0x20d05
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x62b0
testl %eax, %eax
jne 0xca37
andl 0x18(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
je 0xca63
leaq 0x142d6(%rip), %r14     # 0x20d14
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62b0
movl 0x18(%rbx), %ecx
andl $0xf000, %ecx           # imm = 0xF000
xorl $0x4000, %ecx           # imm = 0x4000
xorl %ebx, %ebx
orl %eax, %ecx
cmoveq %r14, %rbx
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: waste_time
int waste_time()
{
	if (inwhgt)		/* if from wghtchk, then done */
	     return 0;
	do_daemons(BEFORE);
	do_daemons(AFTER);
	do_fuses();
  return 0;
}

// Assembly:
leaq 0x20e20(%rip), %rax     # 0x2d89b
cmpb $0x0, (%rax)
jne 0xcaa0
pushq %rax
movl $0x1, %edi
callq 0x8c14
movl $0x2, %edi
callq 0x8c14
xorl %eax, %eax
callq 0x8d32
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: getindex
int getindex(char what)
{
	int index = -1;

	switch (what) {
		case POTION:	index = TYP_POTION;
		when SCROLL:	index = TYP_SCROLL;
		when FOOD:		index = TYP_FOOD;
		when RING:		index = TYP_RING;
		when AMULET:	index = TYP_AMULET;
		when ARMOR:		index = TYP_ARMOR;
		when WEAPON:	index = TYP_WEAPON;
		when STICK:		index = TYP_STICK;
	}
	return index;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x39, %edi
jg 0xcac2
cmpl $0x2b, %edi
jg 0xcad7
cmpl $0x21, %edi
je 0xcaf7
cmpl $0x29, %edi
jne 0xcb05
movl $0x3, %eax
retq
cmpl $0x3e, %edi
jg 0xcae7
cmpl $0x3a, %edi
je 0xcafa
cmpl $0x3d, %edi
jne 0xcb05
movl $0x5, %eax
retq
cmpl $0x2c, %edi
je 0xcb00
cmpl $0x2f, %edi
jne 0xcb05
movl $0x6, %eax
retq
cmpl $0x3f, %edi
je 0xcb06
cmpl $0x5d, %edi
jne 0xcb05
movl $0x4, %eax
retq
xorl %eax, %eax
retq
movl $0x2, %eax
retq
movl $0x7, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: tr_name
char *tr_name(char ch)
{
	char *s;

	switch (ch) {
		case TRAPDOOR:
			s = "A trapdoor.";
		when BEARTRAP:
			s = "A beartrap.";
		when SLEEPTRAP:
			s = "A sleeping gas trap.";
		when ARROWTRAP:
			s = "An arrow trap.";
		when TELTRAP:
			s = "A teleport trap.";
		when DARTTRAP:
			s = "A dart trap.";
		when POOL:
			s = "A magic pool.";
		when POST:
			s = "A trading post.";
		when MAZETRAP:
			s = "A maze trap.";
	otherwise:
		s = "A bottomless pit.";		/* shouldn't get here */
	}
	return s;
}

// Assembly:
cmpl $0x5d, %edi
jle 0xcb2d
cmpl $0x7a, %edi
jle 0xcb56
cmpl $0x7b, %edi
je 0xcb78
cmpl $0x7e, %edi
je 0xcb88
cmpl $0x7d, %edi
jne 0xcb90
leaq 0x14334(%rip), %rax     # 0x20e60
retq
cmpl $0x3d, %edi
jg 0xcb44
cmpl $0x22, %edi
je 0xcb68
cmpl $0x24, %edi
jne 0xcb90
leaq 0x14329(%rip), %rax     # 0x20e6c
retq
cmpl $0x3e, %edi
je 0xcb70
cmpl $0x5c, %edi
jne 0xcb90
leaq 0x14377(%rip), %rax     # 0x20ecc
retq
cmpl $0x5e, %edi
je 0xcb80
cmpl $0x60, %edi
jne 0xcb90
leaq 0x1433a(%rip), %rax     # 0x20ea1
retq
leaq 0x1433f(%rip), %rax     # 0x20eae
retq
leaq 0x142dd(%rip), %rax     # 0x20e54
retq
leaq 0x14302(%rip), %rax     # 0x20e81
retq
leaq 0x14335(%rip), %rax     # 0x20ebc
retq
leaq 0x14301(%rip), %rax     # 0x20e90
retq
leaq 0x14342(%rip), %rax     # 0x20ed9
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: eat
int eat()
{
	struct linked_list *item;
	struct object *obj;
	int goodfood, cursed;

	if ((item = get_item("eat", FOOD)) == NULL)
		return 0;
	obj = OBJPTR(item);
	if (obj->o_type != FOOD) {
		msg("That's Inedible!");
		after = FALSE;
		return 0;
	}
	cursed = 1;
	if (o_on(obj, ISCURSED))
		cursed += 1;
	else if (o_on(obj, ISBLESS))
		cursed -= 1;
	if (obj->o_which == FRUITFOOD) {
		msg("My, that was a yummy %s.", fruit);
		goodfood = 100;
	}
	else {
		if (rnd(100) > 80 || o_on(obj, ISCURSED)) {
			msg("Yuk, this food tastes like ARA.");
			goodfood = 300;
			him->s_exp += 1;
			check_level();
		}
		else {
			msg("Yum, that tasted good.");
			goodfood = 200;
		}
	}
	goodfood *= cursed;
	if ((food_left += HUNGERTIME + rnd(400) - goodfood) > STOMACHSIZE)
		food_left = STOMACHSIZE;
	hungry_state = F_OKAY;
	updpack();					/* update pack */
	if (obj == cur_weapon)
		cur_weapon = NULL;
	del_pack(item);		/* get rid of the food */
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x13d5f(%rip), %rdi     # 0x20eeb
movl $0x3a, %esi
callq 0x10881
testq %rax, %rax
je 0xd2d5
movq %rax, %rbx
movq 0x10(%rax), %r14
cmpl $0x3a, 0x20(%r14)
jne 0xd1f9
movl $0x1, %esi
movq %r14, %rdi
callq 0x95b3
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testb %al, %al
jne 0xd1d5
movl $0x20, %esi
movq %r14, %rdi
callq 0x95b3
movzbl %al, %ebp
decl %ebp
cmpl $0x1, 0x28(%r14)
jne 0xd216
leaq 0x13d1d(%rip), %rdi     # 0x20f00
leaq 0x20d46(%rip), %rsi     # 0x2df30
xorl %eax, %eax
callq 0xb6e0
movl $0x64, %r15d
jmp 0xd277
leaq 0x13cef(%rip), %rdi     # 0x20eef
xorl %eax, %eax
callq 0xb6e0
leaq 0x1d0ff(%rip), %rax     # 0x2a30d
movb $0x0, (%rax)
jmp 0xd2d5
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $0x50, %eax
jg 0xd238
movl $0x1, %esi
movq %r14, %rdi
callq 0x95b3
testb %al, %al
je 0xd263
leaq 0x13cda(%rip), %rdi     # 0x20f19
xorl %eax, %eax
callq 0xb6e0
leaq 0x20b13(%rip), %rax     # 0x2dd60
movq (%rax), %rax
incq 0x20(%rax)
xorl %eax, %eax
callq 0xaf58
movl $0x12c, %r15d           # imm = 0x12C
jmp 0xd277
leaq 0x13ccf(%rip), %rdi     # 0x20f39
xorl %eax, %eax
callq 0xb6e0
movl $0xc8, %r15d
imull %ebp, %r15d
movl $0x190, %edi            # imm = 0x190
xorl %eax, %eax
callq 0xc72d
addl %r15d, %eax
leaq 0x1d06f(%rip), %rcx     # 0x2a300
movl (%rcx), %edx
addl %edx, %eax
addl $0x514, %eax            # imm = 0x514
movl $0x7d0, %edx            # imm = 0x7D0
cmpl %edx, %eax
cmovll %eax, %edx
movl %edx, (%rcx)
leaq 0x205e3(%rip), %rax     # 0x2d890
movl $0x0, (%rax)
xorl %eax, %eax
callq 0x95e0
leaq 0x2058f(%rip), %rax     # 0x2d850
cmpq (%rax), %r14
jne 0xd2cd
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x10cdf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: is_current
bool is_current(struct object *obj)
{
	if (obj == NULL)
		return FALSE;
	if (obj == cur_armor || obj == cur_weapon || obj == cur_ring[LEFT]
	  || obj == cur_ring[RIGHT]) {
		msg("Already in use.");
		return TRUE;
	}
	return FALSE;
}

// Assembly:
testq %rdi, %rdi
je 0xd387
leaq 0x204f4(%rip), %rax     # 0x2d858
cmpq %rdi, (%rax)
je 0xd38a
leaq 0x204e0(%rip), %rax     # 0x2d850
cmpq %rdi, (%rax)
je 0xd38a
leaq 0x209d4(%rip), %rax     # 0x2dd50
cmpq %rdi, (%rax)
je 0xd38a
cmpq %rdi, 0x8(%rax)
je 0xd38a
xorl %eax, %eax
retq
pushq %rax
leaq 0x13bbe(%rip), %rdi     # 0x20f50
xorl %eax, %eax
callq 0xb6e0
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/misc.c
// Function: initfood
void initfood(struct object *what)
{
	what->o_type = FOOD;
	what->o_group = NORMFOOD;
	if (rnd(100) < 15)
		what->o_group = FRUITFOOD;
	what->o_which = what->o_group;
	what->o_count = 1 + extras();
	what->o_flags = ISKNOW;
	what->o_weight = things[TYP_FOOD].mi_wght;
	what->o_typname = things[TYP_FOOD].mi_name;
	what->o_hplus = what->o_dplus = 0;
	what->o_vol = itemvol(what);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3a, 0x20(%rdi)
movl $0x0, 0x3c(%rdi)
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $0xe, %eax
jg 0xd508
movl $0x1, 0x3c(%rbx)
movl 0x3c(%rbx), %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
callq 0x1bac1
incl %eax
movl %eax, 0x24(%rbx)
movl $0x2, 0x38(%rbx)
leaq 0x1e8a8(%rip), %rax     # 0x2bdd0
movl 0x2c(%rax), %ecx
movl %ecx, 0x40(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x18(%rbx)
movq $0x0, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x9804
movl %eax, 0x44(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: rnd_mon
int rnd_mon(bool wander,bool baddie)
/* baddie == TRUE when from a polymorph stick */
{
	int i, ok, cnt;

	cnt = 0;
	if (levcount == 0)			/* if only asmodeus possible */
		return(MAXMONS);
	if (baddie) {
		while (1) {
			i = rnd(MAXMONS);					/* pick ANY monster */
			if (monsters[i].m_lev.l_lev < 0)	/* skip genocided ones */
				continue;
			return i;
		}
	}
	ok = FALSE;
	do {
		/*
		 * get a random monster from this range
		 */
		i = rnd(levcount);
		/*
		 * Only create a wandering monster if we want one
		 * (or the count is exceeded)
		 */
		if (!wander || mtlev[i]->m_lev.d_wand || ++cnt > 500)
			ok = TRUE;
	} while(!ok);
	return (midx(mtlev[i]->m_show));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x20302(%rip), %r14     # 0x2d860
cmpl $0x0, (%r14)
je 0xd58c
testb %sil, %sil
je 0xd5a0
leaq 0x1ce50(%rip), %rbx     # 0x2a3c0
movl $0x34, %edi
xorl %eax, %eax
callq 0xc72d
movslq %eax, %rcx
imulq $0x70, %rcx, %rcx
cmpl $0x0, 0xc(%rbx,%rcx)
js 0xd570
jmp 0xd591
movl $0x34, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebx
leaq 0x22ed7(%rip), %r15     # 0x30480
movl $0x1, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movl (%r14), %edi
xorl %eax, %eax
callq 0xc72d
testb %bl, %bl
je 0xd5cf
movslq %eax, %rcx
movq (%r15,%rcx,8), %rcx
cmpb $0x0, 0x14(%rcx)
je 0xd5d7
movl $0x1, %r12d
jmp 0xd5e9
cmpl $0x1f4, %r13d           # imm = 0x1F4
leal 0x1(%r13), %ecx
cmovgel %ebp, %r12d
movl %ecx, %r13d
testl %r12d, %r12d
je 0xd5b4
cltq
movq (%r15,%rax,8), %rax
movsbl 0x8(%rax), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd60b
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: lev_mon
void lev_mon()
{
	int i;
	struct monster *mm;

	levcount = 0;
	for (i = 0; i < MAXMONS; i++) {
		mm = &monsters[i];
		if (mm->m_lev.h_lev >= level && mm->m_lev.l_lev <= level) {
			mtlev[levcount] = mm;
			if (++levcount >= MONRANGE)
				break;
		}
	}
	if (levcount == 0)					/* if no monsters are possible */
		mtlev[0] = &monsters[MAXMONS];	/* then asmodeus 'A' */
}

// Assembly:
leaq 0x2021e(%rip), %rax     # 0x2d860
movl $0x0, (%rax)
leaq 0x1cca1(%rip), %rcx     # 0x2a2f0
movl (%rcx), %edx
xorl %esi, %esi
leaq 0x1cd66(%rip), %rdi     # 0x2a3c0
leaq 0x22e1f(%rip), %rcx     # 0x30480
xorl %r8d, %r8d
cmpl %edx, 0x10(%rdi,%rsi)
jl 0xd688
cmpl %edx, 0xc(%rdi,%rsi)
jg 0xd688
leaq (%rdi,%rsi), %r9
movslq %r8d, %r10
movq %r9, (%rcx,%r10,8)
leal 0x1(%r10), %r8d
movl %r8d, (%rax)
cmpl $0x12, %r10d
jg 0xd695
addq $0x70, %rsi
cmpq $0x16c0, %rsi           # imm = 0x16C0
jne 0xd664
cmpl $0x0, (%rax)
je 0xd69b
retq
movl $0x16c0, %eax           # imm = 0x16C0
addq 0x1c941(%rip), %rax     # 0x29fe8
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: wanderer
void wanderer()
{
	int ch;
	struct room *rp, *hr = player.t_room;
	struct linked_list *item;
	struct thing *tp;
	struct coord mp;

	do {
		rp = &rooms[rnd_room()];
		if (rp != hr || levtype == MAZELEV) {
			mp = *rnd_pos(rp);
			ch = mvinch(mp.y, mp.x);
		}
	} while (!step_ok(ch));
	item = new_monster(rnd_mon(TRUE,FALSE), &mp, FALSE);
	tp = THINGPTR(item);
	tp->t_flags |= ISRUN;
	tp->t_dest = &hero;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2035a(%rip), %r14     # 0x2dc60
movq 0x70(%r14), %r15
leaq 0x1ff9f(%rip), %r12     # 0x2d8b0
leaq 0x1ff4c(%rip), %r13     # 0x2d864
movq 0x1c611(%rip), %rbp     # 0x29f30
xorl %eax, %eax
callq 0xfa3f
cltq
imulq $0x68, %rax, %rdi
addq %r12, %rdi
cmpq %r15, %rdi
jne 0xd93b
cmpl $0x2, (%r13)
jne 0xd96b
callq 0x14063
movq (%rax), %rdx
movq %rdx, (%rsp)
movq (%rbp), %rdi
movl 0x4(%rsp), %esi
callq 0x6490
cmpl $-0x1, %eax
je 0xd966
movq (%rbp), %rdi
callq 0x6330
movl %eax, %ebx
jmp 0xd96b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movslq %ebx, %rdi
callq 0xb995
testb %al, %al
je 0xd91f
movl $0x1, %edi
xorl %esi, %esi
callq 0xd54c
movsbl %al, %edi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd6ab
movq 0x10(%rax), %rax
orq $0x4, 0x78(%rax)
addq $0x50, %r14
movq %r14, 0x60(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: genocide
int genocide()
{
	struct linked_list *ip, *nip;
	struct thing *mp;
	struct monster *mm;
	int i, ii, c;

	if (levcount == 0) {
		mpos = 0;
		msg("You cannot genocide Asmodeus !!");
		return 0;
	}
tryagain:
	i = TRUE;		/* assume an error now */
	while (i) {
		msg("Which monster (remember UPPER & lower case)?");
		c = readchar();		/* get a char */
		if (c == ESCAPE) {	/* he can abort (the fool) */
			msg("");
			return 0;
		}
		if (isalpha(c))		/* valid char here */
			i = FALSE;		/* exit the loop */
		else {				/* he didn't type a letter */
			mpos = 0;
			msg("Please specify a letter between 'A' and 'z'");
		}
	}
	i = midx(c);						/* get index to monster */
	mm = &monsters[i];
	if (mm->m_lev.l_lev < 0) {
		mpos = 0;
		msg("You have already eliminated the %s.",mm->m_name);
		goto tryagain;
	}
	for (ip = mlist; ip != NULL; ip = nip) {
		mp = THINGPTR(ip);
		nip = next(ip);
		if (mp->t_type == c)
			remove_monster(&mp->t_pos, ip);
	}
	mm->m_lev.l_lev = -1;				/* get rid of it */
	mm->m_lev.h_lev = -1;
	lev_mon();							/* redo monster list */
	mpos = 0;
	msg("You have wiped out the %s.",mm->m_name);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1fc9f(%rip), %rax     # 0x2d860
cmpl $0x0, (%rax)
je 0xdc7e
leaq 0x133ef(%rip), %rdi     # 0x20fc0
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
callq 0xb9fd
cmpb $0x1b, %al
je 0xdc75
movl %eax, %ebx
callq 0x65b0
movq %rax, %r14
leaq 0x1fc78(%rip), %rbp     # 0x2d870
leaq 0x133c1(%rip), %r12     # 0x20fc0
leaq 0x1c7ba(%rip), %r15     # 0x2a3c0
movq (%r14), %rax
movsbq %bl, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0xdc2b
movl $0x0, (%rbp)
leaq 0x133cb(%rip), %rdi     # 0x20fed
xorl %eax, %eax
callq 0xb6e0
jmp 0xdc5e
movsbl %bl, %edi
callq 0xd60b
cltq
imulq $0x70, %rax, %rax
leaq (%r15,%rax), %r13
cmpl $0x0, 0xc(%r15,%rax)
jns 0xdcaa
movl $0x0, (%rbp)
movq (%r13), %rsi
leaq 0x133c2(%rip), %rdi     # 0x21019
xorl %eax, %eax
callq 0xb6e0
movq %r12, %rdi
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
callq 0xb9fd
movl %eax, %ebx
cmpb $0x1b, %al
jne 0xdc06
leaq 0x15c95(%rip), %rdi     # 0x23911
jmp 0xdc92
leaq 0x1fbeb(%rip), %rax     # 0x2d870
movl $0x0, (%rax)
leaq 0x1330e(%rip), %rdi     # 0x20fa0
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fb8f(%rip), %rax     # 0x2d840
movq (%rax), %rsi
testq %rsi, %rsi
je 0xdcd9
movq (%rsi), %r14
movq 0x10(%rsi), %rdi
cmpb 0x8d(%rdi), %bl
jne 0xdcd1
addq $0x50, %rdi
callq 0xae8c
movq %r14, %rsi
testq %r14, %r14
jne 0xdcb9
movq $-0x1, 0xc(%r13)
callq 0xd63b
movl $0x0, (%rbp)
movq (%r13), %rsi
leaq 0x13345(%rip), %rdi     # 0x2103d
xorl %eax, %eax
callq 0xb6e0
jmp 0xdc99
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: unhold
void unhold(char whichmon)
{
	switch (whichmon) {
		case 'F':
			fung_hit = 0;
			strcpy(monsters[midx('F')].m_stats.s_dmg, "000d0");
		case 'd':
			player.t_flags &= ~ISHELD;
	}
}

// Assembly:
pushq %rax
cmpl $0x64, %edi
je 0xdd5c
cmpl $0x46, %edi
jne 0xdd67
leaq 0x1fb75(%rip), %rax     # 0x2d888
movl $0x0, (%rax)
callq 0x65b0
movq (%rax), %rax
movzwl 0x8c(%rax), %eax
xorl %ecx, %ecx
btl $0x9, %eax
sbbq %rcx, %rcx
orq $0x34, %rcx
btl $0x8, %eax
movl $0x5, %eax
cmovaeq %rcx, %rax
imulq $0x70, %rax, %rax
leaq 0x1c673(%rip), %rcx     # 0x2a3c0
movw $0x30, 0x64(%rcx,%rax)
movl $0x64303030, 0x60(%rcx,%rax) # imm = 0x64303030
leaq 0x1fefd(%rip), %rax     # 0x2dc60
andb $-0x2, 0x79(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/monsters.c
// Function: monhurt
bool monhurt(struct thing *th)
{
	int ewis, crithp, f1, f2;
	struct stats *st;

	st = &th->t_stats;
	ewis = st->s_ef.a_wis;
	if (ewis <= MONWIS)				/* stupid monsters dont know */
		return FALSE;
	f1 = st->s_maxhp / 4;			/* base hpt for being hurt */
	f2 = (ewis - MONWIS) * 5 / 3;	/* bonus for smart monsters */
	if (th->t_flags & ISWOUND)		/* if recovering from being */
		f1 *= 2;					/* wounded, then double the base */
	crithp = f1 + f2;				/* get critical hpt for hurt */
	if (crithp > st->s_maxhp)		/* only up to max hpt */
		crithp = st->s_maxhp;
	if (st->s_hpt < crithp)			/* if < critical, then still hurt */
		return TRUE;
	return FALSE;
}

// Assembly:
movl 0x18(%rdi), %eax
cmpl $0xb, %eax
jge 0xdd74
xorl %eax, %eax
retq
movl 0x34(%rdi), %edx
leal 0x3(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x2, %esi
leal (%rax,%rax,4), %eax
addl $-0x32, %eax
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
imulq %rax, %r8
shrq $0x21, %r8
movb 0x78(%rdi), %cl
shrb $0x7, %cl
shll %cl, %esi
addl %r8d, %esi
cmpl %edx, %esi
cmovgel %edx, %esi
cmpl %esi, 0x30(%rdi)
setl %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ajpaulson[P]srogue11/move.c
// Function: show
char show(int y,int x)
{
	unsigned long ch = winat(y, x);
	struct linked_list *it;
	struct thing *tp;
	struct trap *ta;

	if (isatrap(ch)) {
		if ((ta = trap_at(y, x)) == NULL)
			return FLOOR;
		if (iswearing(R_FTRAPS))
			ta->tr_flags |= ISFOUND;
		return ((ta->tr_flags & ISFOUND) ? ta->tr_type : FLOOR);
	}
	if (ch == SECRETDOOR && iswearing(R_FTRAPS)) {
		mvaddch(y,x,DOOR);
		return DOOR;
	}
	if ((it = find_mons(y, x)) != NULL) {	/* maybe a monster */
		tp = THINGPTR(it);
		if (ch == 'M' || (tp->t_flags & ISINVIS)) {
			if (ch == 'M')
				ch = tp->t_disguise;
			else if (pl_off(CANSEE)) {
				if (ch == 's')
					ch = ' ';		/* shadows show as a blank */
				else
					ch = mvinch(y, x);	/* hide invisibles */
			}
		}
	}
	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
callq 0x9514
movl %eax, %ebx
movsbl %al, %edi
callq 0xe4fd
testb %al, %al
je 0xe451
leaq 0x1fa7e(%rip), %rax     # 0x2de68
movslq (%rax), %rax
testq %rax, %rax
jle 0xe41c
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x1bbbf(%rip), %rax     # 0x29fc0
leaq 0x1f968(%rip), %r15     # 0x2dd70
cmpl %r14d, 0x4(%r15)
jne 0xe413
cmpl %ebp, (%r15)
je 0xe41f
addq $0x18, %r15
cmpq %rax, %r15
jb 0xe408
xorl %r15d, %r15d
movb $0x2e, %bl
testq %r15, %r15
je 0xe4f0
movl $0xe, %edi
callq 0x12d9c
testb %al, %al
je 0xe43d
orb $0x8, 0x10(%r15)
testb $0x8, 0x10(%r15)
je 0xe4f0
movb 0x14(%r15), %bl
jmp 0xe4f0
cmpb $0x26, %bl
jne 0xe48e
movl $0xe, %edi
callq 0x12d9c
testb %al, %al
je 0xe48e
movq 0x1bac5(%rip), %r15     # 0x29f30
movq (%r15), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x6490
movb $0x2b, %bl
cmpl $-0x1, %eax
je 0xe4f0
movq (%r15), %rdi
movl $0x2b, %esi
callq 0x64c0
jmp 0xe4f0
movl %r14d, %edi
movl %ebp, %esi
callq 0x75c5
testq %rax, %rax
je 0xe4f0
movq 0x10(%rax), %rax
cmpb $0x4d, %bl
jne 0xe4ae
movb 0x8e(%rax), %bl
jmp 0xe4f0
testb $0x10, 0x78(%rax)
je 0xe4f0
movl $0x1000, %edi           # imm = 0x1000
callq 0x95a4
testb %al, %al
je 0xe4f0
cmpb $0x73, %bl
movb $0x20, %bl
je 0xe4f0
movq 0x1ba60(%rip), %rbx     # 0x29f30
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x6490
cmpl $-0x1, %eax
je 0xe4ee
movq (%rbx), %rdi
callq 0x6330
movl %eax, %ebx
jmp 0xe4f0
movb $-0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq