LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/daemons.c
// Function: notinvinc
int notinvinc(int fromfuse)
{
	if (pl_on(ISINVINC))
		msg("You no longer feel invincible.");
	player.t_flags &= ~ISINVINC;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x8, %edi
callq 0xaa60
testb $0x1, %al
jne 0xa54b
jmp 0xa559
leaq 0x1f588(%rip), %rdi     # 0x29ada
movb $0x0, %al
callq 0xd8f0
leaq 0x2cb70(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x9, %rcx
leaq 0x2cb61(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/disply.c
// Function: dispmons
void dispmons()
{
	int ch, y, x;
	struct thing *it;
	struct linked_list *item;

	for (item = mlist; item != NULL; item = next(item)) {
		it = THINGPTR(item);
		y = it->t_pos.y;
		x = it->t_pos.x;
		mvwaddch(cw, y, x, it->t_type);
		it->t_flags |= ISFOUND;
		if (it->t_type == 'M')			/* if a mimic */
			it->t_disguise = 'M';		/* give it away */
	}
	draw(cw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x2c411(%rip), %rax     # 0x36cb0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa944
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x2f578(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0xa8ed
jmp 0xa907
leaq 0x2f55c(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movsbl 0x8d(%rax), %esi
callq 0x64c0
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
orq $0x8, %rcx
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
movsbl 0x8d(%rax), %eax
cmpl $0x4d, %eax
jne 0xa932
movq -0x18(%rbp), %rax
movb $0x4d, 0x8e(%rax)
jmp 0xa934
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa8a6
leaq 0x2f505(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x61f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/disply.c
// Function: winat
char winat(int y,int x)
{
	unsigned long ch;

	if (mvwinch(mw,y,x) == ' ')
		ch = mvinch(y, x);			/* non-monsters */
	else
		ch = winch(mw);				/* monsters */
	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x2f4eb(%rip), %rax     # 0x39e60
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0xa992
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0xa9a4
leaq 0x2f4c7(%rip), %rax     # 0x39e60
movq (%rax), %rdi
callq 0x6340
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl $0x20, %eax
jne 0xa9ed
movq 0x2860d(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0xa9d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xa9e2
movq 0x285e9(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x6340
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xaa02
leaq 0x2f46c(%rip), %rax     # 0x39e60
movq (%rax), %rdi
callq 0x6340
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/disply.c
// Function: o_on
bool o_on(struct object *what,long bit)
{
	int flag;

	flag = FALSE;
	if (what != NULL)
		flag = (what->o_flags & bit);
	return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xaae9
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
andq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: updpack
void updpack()
{
	int topcarry, curcarry;

	him->s_carry = totalenc();			/* get total encumb */
	curcarry = packweight();			/* get pack weight */
	topcarry = him->s_carry / 5;		/* 20% of total carry */
	if (curcarry > 4 * topcarry) {
		if (rnd(100) < 80)
			foodlev = 3;				/* > 80% of pack */
	}
	else if (curcarry > 3 * topcarry) {
		if (rnd(100) < 60)
			foodlev = 2;				/* > 60% of pack */
	}
	else
		foodlev = 1;					/* <= 60% of pack */
	him->s_pack = curcarry;				/* update pack weight */
	packvol = pack_vol();				/* update pack volume */
	nochange = FALSE;					/* also change display */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb070
movl %eax, %ecx
leaq 0x2c61a(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x3c(%rax)
callq 0xac80
movl %eax, -0x8(%rbp)
leaq 0x2c605(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x3c(%rax), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jle 0xac09
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0x50, %eax
jge 0xac07
leaq 0x28707(%rip), %rax     # 0x33308
movl $0x3, (%rax)
jmp 0xac43
movl -0x8(%rbp), %eax
imull $0x3, -0x4(%rbp), %ecx
cmpl %ecx, %eax
jle 0xac34
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0x3c, %eax
jge 0xac32
leaq 0x286dc(%rip), %rax     # 0x33308
movl $0x2, (%rax)
jmp 0xac41
leaq 0x286cd(%rip), %rax     # 0x33308
movl $0x1, (%rax)
jmp 0xac43
movl -0x8(%rbp), %ecx
leaq 0x2c583(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x38(%rax)
callq 0xae30
movl %eax, %ecx
leaq 0x2c083(%rip), %rax     # 0x36ce4
movl %ecx, (%rax)
leaq 0x2c0a9(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: packweight
int packweight()
{
	struct object *obj;
	struct linked_list *pc;
	int weight, i;

	weight = 0;
	for (pc = pack ; pc != NULL ; pc = next(pc)) {
		obj = OBJPTR(pc);
		weight += itemweight(obj) * obj->o_count;
	}
	if (weight < 0)		/* in case of amulet */
		 weight = 0;
	for (i = LEFT; i <= RIGHT; i += 1) {
		obj = cur_ring[i];
		if (obj != NULL) {
			if (obj->o_type == R_HEAVY && o_off(obj, ISBLESS))
				weight += weight / 4;
		}
	}
	return weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x14(%rbp)
leaq 0x2c43a(%rip), %rax     # 0x370d0
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xacd5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xad50
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xac9e
cmpl $0x0, -0x14(%rbp)
jge 0xace2
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jg 0xad47
movslq -0x18(%rbp), %rcx
leaq 0x2c4c6(%rip), %rax     # 0x371c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xad3a
movq -0x8(%rbp), %rax
cmpl $0x15, 0x20(%rax)
jne 0xad38
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0xab00
testb $0x1, %al
jne 0xad27
jmp 0xad38
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xad3a
jmp 0xad3c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xace9
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: itemweight
int itemweight(struct object *wh)
{
	int weight;

	weight = wh->o_weight;		/* get base weight */
	switch (wh->o_type) {
		case ARMOR:
			if ((armors[wh->o_which].a_class - wh->o_ac) > 0)
				weight /= 2;
		when WEAPON:
			if ((wh->o_hplus + wh->o_dplus) > 0)
				weight /= 2;
	}
	if (o_on(wh,ISCURSED))
		weight += weight / 5;	/* 20% more for cursed */
	if (o_on(wh, ISBLESS))
		weight -= weight / 5;	/* 20% less for blessed */
	return weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x29, %eax
je 0xadb5
jmp 0xad77
movl -0x10(%rbp), %eax
subl $0x5d, %eax
jne 0xadd8
jmp 0xad81
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x2a180(%rip), %rax     # 0x34f10
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x34(%rcx), %eax
cmpl $0x0, %eax
jle 0xadb3
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0xadd8
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x30(%rcx), %eax
cmpl $0x0, %eax
jle 0xadd6
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0xadd8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xaac0
testb $0x1, %al
jne 0xadec
jmp 0xadfd
movl -0xc(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0xaac0
testb $0x1, %al
jne 0xae11
jmp 0xae26
movl -0xc(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: pack_vol
int pack_vol()
{
	struct object *obj;
	struct linked_list *pc;
	int volume;

	volume = 0;
	for (pc = pack ; pc != NULL ; pc = next(pc)) {
		obj = OBJPTR(pc);
		volume += itemvol(obj);
	}
	return volume;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x14(%rbp)
leaq 0x2c28a(%rip), %rax     # 0x370d0
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xae7d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xae90
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xae4e
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: itemvol
int itemvol(struct object *wh)
{
	int volume, what, extra;

	extra = 0;
	what = getindex(wh->o_type);
	switch (wh->o_type) {
		case ARMOR:		extra = armors[wh->o_which].a_vol;
		when WEAPON:	extra = weaps[wh->o_which].w_vol;
		when STICK:		if (strcmp(ws_stuff[wh->o_which].ws_type,"staff") == 0)
							extra = V_WS_STAFF;
						else
							extra = V_WS_WAND;
	}
	volume = thnginfo[what].mf_vol + extra;
	volume *= wh->o_count;
	return volume;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x20(%rax), %edi
callq 0xf3b0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x29, %eax
je 0xaef6
jmp 0xaec4
movl -0x18(%rbp), %eax
subl $0x2f, %eax
je 0xaf14
jmp 0xaece
movl -0x18(%rbp), %eax
subl $0x5d, %eax
jne 0xaf50
jmp 0xaed8
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x2a029(%rip), %rax     # 0x34f10
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xaf50
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x2a1bb(%rip), %rax     # 0x350c0
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xaf50
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x2ecbd(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x1f2d7(%rip), %rsi     # 0x2a20b
callq 0x6250
cmpl $0x0, %eax
jne 0xaf47
movl $0xc8, -0x14(%rbp)
jmp 0xaf4e
movl $0x6e, -0x14(%rbp)
jmp 0xaf50
movslq -0x10(%rbp), %rcx
leaq 0x2aa15(%rip), %rax     # 0x35970
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: playenc
int playenc()
{
	int estr = him->s_ef.a_str;
	if (estr >= 24)
		return 3000;
	switch(him->s_ef.a_str) {
		case 23: return 2000;
		case 22: return 1500;
		case 21: return 1250;
		case 20: return 1100;
		case 19: return 1000;
		case 18: return 700;
		case 17: return 500;
		case 16: return 350;
		case 15:
		case 14: return 200;
		case 13:
		case 12: return 100;
		case 11:
		case 10:
		case  9:
		case  8: return 0;
		case  7:
		case  6: return -150;
		case  5:
		case  4: return -250;
	}
	return -350;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2c235(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x18, -0x8(%rbp)
jl 0xafb6
movl $0xbb8, -0x4(%rbp)      # imm = 0xBB8
jmp 0xb065
leaq 0x2c213(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x10(%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0xb05e
movq -0x10(%rbp), %rax
leaq 0x1eb1c(%rip), %rcx     # 0x29afc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7d0, -0x4(%rbp)      # imm = 0x7D0
jmp 0xb065
movl $0x5dc, -0x4(%rbp)      # imm = 0x5DC
jmp 0xb065
movl $0x4e2, -0x4(%rbp)      # imm = 0x4E2
jmp 0xb065
movl $0x44c, -0x4(%rbp)      # imm = 0x44C
jmp 0xb065
movl $0x3e8, -0x4(%rbp)      # imm = 0x3E8
jmp 0xb065
movl $0x2bc, -0x4(%rbp)      # imm = 0x2BC
jmp 0xb065
movl $0x1f4, -0x4(%rbp)      # imm = 0x1F4
jmp 0xb065
movl $0x15e, -0x4(%rbp)      # imm = 0x15E
jmp 0xb065
movl $0xc8, -0x4(%rbp)
jmp 0xb065
movl $0x64, -0x4(%rbp)
jmp 0xb065
movl $0x0, -0x4(%rbp)
jmp 0xb065
movl $0xffffff6a, -0x4(%rbp) # imm = 0xFFFFFF6A
jmp 0xb065
movl $0xffffff06, -0x4(%rbp) # imm = 0xFFFFFF06
jmp 0xb065
movl $0xfffffea2, -0x4(%rbp) # imm = 0xFFFFFEA2
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: totalenc
int totalenc()
{
	int wtotal;

	wtotal = NORMENCB + playenc();
	switch(hungry_state) {
		case F_OKAY:
		case F_HUNGRY:	;						/* no change */
		when F_WEAK:	wtotal -= wtotal / 10;	/* 10% off weak */
		when F_FAINT:	wtotal /= 2;			/* 50% off faint */
	}
	return wtotal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xaf90
addl $0x5dc, %eax            # imm = 0x5DC
movl %eax, -0x4(%rbp)
leaq 0x2bc74(%rip), %rax     # 0x36d00
movl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
jb 0xb0ac
jmp 0xb098
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0xb0ae
jmp 0xb0a2
movl -0x8(%rbp), %eax
subl $0x3, %eax
je 0xb0c5
jmp 0xb0d3
jmp 0xb0d3
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb0d3
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/encumb.c
// Function: wghtchk
int wghtchk(int fromfuse)
{
	int dropchk, err = TRUE;
	char ch;

	inwhgt = TRUE;
	if (him->s_pack > him->s_carry) {
		ch = player.t_oldch;
		extinguish(wghtchk);
		if ((ch != FLOOR && ch != PASSAGE) || isfight) {
			fuse(wghtchk, TRUE, 1);
			inwhgt = FALSE;
			return 0;
		}
		msg("Your pack is too heavy for you.");
		do {
			dropchk = drop(NULL);
			if (dropchk == SOMTHERE)
				err = FALSE;
			else if (dropchk == FALSE) {
				mpos = 0;
				msg("You must drop something");
			}
			if (dropchk == TRUE)
				err = FALSE;
		} while(err);
	}
	inwhgt = FALSE;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0x10(%rbp)
leaq 0x2bc12(%rip), %rax     # 0x36d0b
movb $0x1, (%rax)
leaq 0x2c0cd(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x38(%rax), %eax
leaq 0x2c0c0(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpl 0x3c(%rcx), %eax
jle 0xb1e4
leaq 0x2bfad(%rip), %rax     # 0x370d0
movb 0x8f(%rax), %al
movb %al, -0x11(%rbp)
leaq -0x53(%rip), %rdi       # 0xb0e0
callq 0x9cd0
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
je 0xb14a
movsbl -0x11(%rbp), %eax
cmpl $0x23, %eax
jne 0xb156
leaq 0x2bbb7(%rip), %rax     # 0x36d08
testb $0x1, (%rax)
je 0xb17c
leaq -0x7d(%rip), %rdi       # 0xb0e0
movl $0x1, %edx
movl %edx, %esi
callq 0x9c30
leaq 0x2bb9b(%rip), %rax     # 0x36d0b
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb1f5
leaq 0x1e9c9(%rip), %rdi     # 0x29b4c
movb $0x0, %al
callq 0xd8f0
xorl %eax, %eax
movl %eax, %edi
callq 0x23c10
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jne 0xb1aa
movl $0x0, -0x10(%rbp)
jmp 0xb1cd
cmpl $0x0, -0xc(%rbp)
jne 0xb1cb
leaq 0x2bb29(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
leaq 0x1e9a8(%rip), %rdi     # 0x29b6c
movb $0x0, %al
callq 0xd8f0
jmp 0xb1cd
cmpl $0x1, -0xc(%rbp)
jne 0xb1da
movl $0x0, -0x10(%rbp)
jmp 0xb1dc
cmpl $0x0, -0x10(%rbp)
jne 0xb18a
jmp 0xb1e4
leaq 0x2bb20(%rip), %rax     # 0x36d0b
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb $0x0, 0x2ae35(%rip)     # 0x36c60
cmpq $0x0, -0x8(%rbp)
jne 0xbe47
leaq 0x2ae27(%rip), %rdi     # 0x36c60
leaq 0x1df0c(%rip), %rsi     # 0x29d4c
callq 0x60d0
jmp 0xbe91
movl $0x1, %edi
callq 0xaa60
testb $0x1, %al
jne 0xbe57
jmp 0xbe6c
leaq 0x2ae02(%rip), %rdi     # 0x36c60
leaq 0x1f294(%rip), %rsi     # 0x2b0f9
callq 0x60d0
jmp 0xbe8f
leaq 0x2aded(%rip), %rdi     # 0x36c60
leaq 0x1e008(%rip), %rsi     # 0x29e82
callq 0x60d0
movq -0x8(%rbp), %rsi
leaq 0x2add6(%rip), %rdi     # 0x36c60
callq 0x64d0
jmp 0xbe91
testb $0x1, -0x9(%rbp)
je 0xbea9
movsbl 0x2adc2(%rip), %edi     # 0x36c60
callq 0x60e0
movb %al, 0x2adb7(%rip)      # 0x36c60
leaq 0x2adb0(%rip), %rax     # 0x36c60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2d389(%rip), %rax     # 0x39e60
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0xcaf3
jmp 0xcb07
leaq 0x2d366(%rip), %rax     # 0x39e60
movq (%rax), %rdi
movl $0x20, %esi
callq 0x64c0
movl $0x1, %edi
callq 0xaa60
testb $0x1, %al
jne 0xcb17
jmp 0xcb1d
movb $0x20, -0x11(%rbp)
jmp 0xcb2e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb 0x8f(%rax), %al
movb %al, -0x11(%rbp)
leaq 0x2d31b(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0xcb51
jmp 0xcb64
leaq 0x2d2f8(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movsbl -0x11(%rbp), %esi
callq 0x64c0
movq -0x10(%rbp), %rsi
leaq 0x2a141(%rip), %rdi     # 0x36cb0
callq 0xe360
movq -0x10(%rbp), %rdi
callq 0xe490
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x28e36(%rip), %rax     # 0x35a30
cmpq $0x0, (%rax,%rcx,8)
je 0xcc2f
movslq -0x4(%rbp), %rcx
leaq 0x28e24(%rip), %rax     # 0x35a30
movq (%rax,%rcx,8), %rax
leaq 0x2a5b9(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpq 0x20(%rcx), %rax
jle 0xcc22
jmp 0xcc2f
jmp 0xcc24
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcbef
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x2a58e(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpl 0x28(%rcx), %eax
jle 0xccf6
movl -0x4(%rbp), %eax
leaq 0x2a578(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
subl 0x28(%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0xa, %esi
callq 0xef70
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0x2a552(%rip), %rax     # 0x371d0
movq (%rax), %rdi
callq 0x16e40
movl -0x14(%rbp), %ecx
movl %eax, %edx
movl -0x10(%rbp), %eax
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
leaq 0x2a530(%rip), %rax     # 0x371d0
movq (%rax), %rax
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
movl -0x8(%rbp), %eax
leaq 0x2a51d(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
addl 0x30(%rcx), %eax
movl %eax, 0x30(%rcx)
leaq 0x2a50d(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpl 0x34(%rcx), %eax
jle 0xcce5
leaq 0x2a4fe(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x34(%rax), %ecx
leaq 0x2a4f1(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x30(%rax)
movl -0x4(%rbp), %esi
leaq 0x1d17f(%rip), %rdi     # 0x29e6e
movb $0x0, %al
callq 0xd8f0
movl -0x4(%rbp), %ecx
leaq 0x2a4d0(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/fight.c
// Function: mindex
char *mindex(char *cp,char c)
{
	int i;

	for (i = 0; i < 3; i++)
		if (*cp != c)  cp++;
	if (*cp == c)
		return cp;
	else
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0xcd53
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xcd46
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xcd48
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcd25
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xcd6c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd74
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/fight.c
// Function: is_magic
bool is_magic(struct object *obj)
{
	switch (obj->o_type) {
		case ARMOR:
			return obj->o_ac != armors[obj->o_which].a_class;
		case WEAPON:
			return obj->o_hplus != 0 || obj->o_dplus != 0;
		case POTION:
		case SCROLL:
		case STICK:
		case RING:
		case AMULET:
			return TRUE;
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x21, %eax
je 0xced9
jmp 0xce4d
movl -0x14(%rbp), %eax
subl $0x29, %eax
je 0xceb2
jmp 0xce57
movl -0x14(%rbp), %eax
subl $0x2c, %eax
je 0xced9
jmp 0xce61
movl -0x14(%rbp), %eax
subl $0x2f, %eax
je 0xced9
jmp 0xce6b
movl -0x14(%rbp), %eax
subl $0x3d, %eax
je 0xced9
jmp 0xce75
movl -0x14(%rbp), %eax
subl $0x3f, %eax
je 0xced9
jmp 0xce7f
movl -0x14(%rbp), %eax
subl $0x5d, %eax
jne 0xcedf
jmp 0xce89
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rdx
leaq 0x28071(%rip), %rcx     # 0x34f10
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcee3
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x2c(%rcx)
movb %al, -0x15(%rbp)
jne 0xcecf
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcee3
movb $0x1, -0x1(%rbp)
jmp 0xcee3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x27ed1(%rip), %rax     # 0x34dd0
addq $0x10, %rax
movq %rax, -0x8(%rbp)
leaq 0x27ec2(%rip), %rax     # 0x34dd0
addq $0x80, %rax
cmpq %rax, -0x8(%rbp)
jae 0xcf39
movq -0x8(%rbp), %rax
movl -0x8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0xcf07
leaq 0x1ded8(%rip), %rdi     # 0x2ae18
leaq 0x27e89(%rip), %rsi     # 0x34dd0
callq 0xd000
leaq 0x27f0d(%rip), %rax     # 0x34e60
addq $0x10, %rax
movq %rax, -0x8(%rbp)
leaq 0x27efe(%rip), %rax     # 0x34e60
addq $0xa0, %rax
cmpq %rax, -0x8(%rbp)
jae 0xcf8d
movq -0x8(%rbp), %rax
movl -0x8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0xcf5b
leaq 0x1d432(%rip), %rdi     # 0x2a3c6
leaq 0x27ec5(%rip), %rsi     # 0x34e60
callq 0xd000
leaq 0x27fe9(%rip), %rax     # 0x34f90
addq $0x10, %rax
movq %rax, -0x8(%rbp)
leaq 0x27fda(%rip), %rax     # 0x34f90
addq $0x120, %rax            # imm = 0x120
cmpq %rax, -0x8(%rbp)
jae 0xcfe1
movq -0x8(%rbp), %rax
movl -0x8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0xcfaf
leaq 0x1d2ca(%rip), %rdi     # 0x2a2b2
leaq 0x27fa1(%rip), %rsi     # 0x34f90
callq 0xd000
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd032
jmp 0xd024
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0xd018
movq -0x20(%rbp), %rax
cmpl $0x3e8, -0x8(%rax)      # imm = 0x3E8
jne 0xd04b
movl $0x0, -0x4(%rbp)
jmp 0xd0d0
movq -0x10(%rbp), %rsi
leaq 0x1dde6(%rip), %rdi     # 0x2ae3c
movb $0x0, %al
callq 0x61b0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd099
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x1ddd2(%rip), %rdi     # 0x2ae56
movb $0x0, %al
callq 0x61b0
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0xd065
leaq 0x1c8a0(%rip), %rdi     # 0x29940
leaq 0x26299(%rip), %rsi     # 0x33340
movb $0x0, %al
callq 0x61b0
movq 0x25f03(%rip), %rax     # 0x32fb8
movq (%rax), %rdi
callq 0x6360
callq 0x6270
cmpl $0xa, %eax
je 0xd0c9
jmp 0xd0bd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0xd109
movslq -0x4(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd0ef
movl $0x0, -0x4(%rbp)
cmpl $0x15, -0x4(%rbp)
jge 0xd1cc
jmp 0xd11c
movl $0x20, %edi
movb $0x0, %al
callq 0xef20
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movb -0x30(%rbp,%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd11c
movslq -0x8(%rbp), %rax
movb $0x1, -0x30(%rbp,%rax)
movslq -0x8(%rbp), %rcx
leaq 0x289d1(%rip), %rax     # 0x35b20
movq (%rax,%rcx,8), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x2c902(%rip), %rax     # 0x39a60
movq %rdx, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x2c703(%rip), %rax     # 0x39870
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x2c484(%rip), %rax     # 0x39600
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, -0x4(%rbp)
jle 0xd1bc
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x28316(%rip), %rax     # 0x354b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x28301(%rip), %rax     # 0x354b0
shlq $0x4, %rdx
addq %rdx, %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0xd1be
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd110
leaq 0x1dc4c(%rip), %rdi     # 0x2ae1f
leaq 0x282d6(%rip), %rsi     # 0x354b0
callq 0xd000
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x1c(%rbp)
cmpl $0x1a, -0x1c(%rbp)
jge 0xd381
leaq 0x2a0f0(%rip), %rax     # 0x37300
movq %rax, -0x10(%rbp)
movl $0x3, %edi
movb $0x0, %al
callq 0xef20
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0xd2c0
movl $0x3, %edi
movb $0x0, %al
callq 0xef20
addl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0xd2a9
movl $0x9f, %edi
movb $0x0, %al
callq 0xef20
movslq %eax, %rcx
leaq 0x289ae(%rip), %rax     # 0x35c20
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xd2a7
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xd27a
jmp 0xd24c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0xd226
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, -0x1(%rax)
leaq 0x2a026(%rip), %rdi     # 0x37300
callq 0x6160
addq $0x1, %rax
movl %eax, %edi
callq 0xe520
movq %rax, %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x2c698(%rip), %rax     # 0x39990
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rcx
leaq 0x2c549(%rip), %rax     # 0x39850
movb $0x0, (%rax,%rcx)
movslq -0x1c(%rbp), %rcx
leaq 0x2c21a(%rip), %rax     # 0x39530
movq $0x0, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rcx
leaq 0x2c667(%rip), %rax     # 0x39990
movq (%rax,%rcx,8), %rdi
leaq 0x29fcc(%rip), %rsi     # 0x37300
callq 0x60d0
cmpl $0x0, -0x1c(%rbp)
jle 0xd371
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x27fb1(%rip), %rax     # 0x35300
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movslq -0x1c(%rbp), %rdx
leaq 0x27f9c(%rip), %rax     # 0x35300
shlq $0x4, %rdx
addq %rdx, %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0xd373
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1ff
leaq 0x1da9f(%rip), %rdi     # 0x2ae27
leaq 0x27f71(%rip), %rsi     # 0x35300
callq 0xd000
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x23, -0x4(%rbp)
jge 0xd3c9
movslq -0x4(%rbp), %rax
movb $0x0, -0x40(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd3af
movl $0x0, -0x4(%rbp)
cmpl $0x1a, -0x4(%rbp)
jge 0xd48c
jmp 0xd3dc
movl $0x23, %edi
movb $0x0, %al
callq 0xef20
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movb -0x40(%rbp,%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd3dc
movslq -0x8(%rbp), %rax
movb $0x1, -0x40(%rbp,%rax)
movslq -0x8(%rbp), %rcx
leaq 0x28d11(%rip), %rax     # 0x36120
movq (%rax,%rcx,8), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x2c6f2(%rip), %rax     # 0x39b10
movq %rdx, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x2c463(%rip), %rax     # 0x39890
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x2c274(%rip), %rax     # 0x396b0
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, -0x4(%rbp)
jle 0xd47c
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x281b6(%rip), %rax     # 0x35610
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x281a1(%rip), %rax     # 0x35610
shlq $0x4, %rdx
addq %rdx, %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0xd47e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd3d0
leaq 0x1d99c(%rip), %rdi     # 0x2ae2f
leaq 0x28176(%rip), %rsi     # 0x35610
callq 0xd000
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x29a35(%rip), %rax     # 0x370d0
movl $0x0, 0x84(%rax)
leaq 0x29a24(%rip), %rax     # 0x370d0
movl $0x0, 0x88(%rax)
leaq 0x29b13(%rip), %rax     # 0x371d0
leaq 0x29a0c(%rip), %rcx     # 0x370d0
movq %rcx, (%rax)
leaq 0x29b02(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl $0x1, 0x28(%rax)
leaq 0x29af1(%rip), %rax     # 0x371d0
movq (%rax), %rax
movq $0x0, 0x20(%rax)
callq 0xd800
movl %eax, %ecx
leaq 0x29ad8(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x30(%rax)
leaq 0x29acb(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x34(%rax)
callq 0xd800
movl %eax, %ecx
leaq 0x29ab7(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, (%rax)
callq 0xd800
movl %eax, %ecx
leaq 0x29aa4(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x4(%rax)
callq 0xd800
movl %eax, %ecx
leaq 0x29a90(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x8(%rax)
callq 0xd800
movl %eax, %ecx
leaq 0x29a7c(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0xc(%rax)
leaq 0x29a6f(%rip), %rax     # 0x371d0
movq (%rax), %rax
leaq 0x29a65(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
leaq 0x29a4c(%rip), %rax     # 0x371d0
movq (%rax), %rdi
addq $0x40, %rdi
leaq 0x1cd15(%rip), %rsi     # 0x2a4a7
callq 0x60d0
leaq 0x29a32(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl $0xa, 0x2c(%rax)
movb $0x0, %al
callq 0xb070
movl %eax, %ecx
leaq 0x29a18(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x3c(%rax)
leaq 0x29a0b(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl $0x0, 0x38(%rax)
leaq 0x298fa(%rip), %rax     # 0x370d0
movq $0x0, 0x68(%rax)
leaq 0x299eb(%rip), %rax     # 0x371d0
movq (%rax), %rsi
leaq 0x29979(%rip), %rdi     # 0x37168
movl $0x50, %edx
callq 0x62c0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd839
movl $0x1, %edi
movl $0x6, %esi
callq 0xef70
movl %eax, %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x10(%rbp,%rax,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd80f
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd87e
movslq -0x14(%rbp), %rax
movl -0x10(%rbp,%rax,4), %eax
cmpl -0x18(%rbp), %eax
jge 0xd871
movslq -0x14(%rbp), %rax
movl -0x10(%rbp,%rax,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xd873
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd84d
movl $0x0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd8b5
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xd8a8
movslq -0x14(%rbp), %rax
movl -0x10(%rbp,%rax,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xd8aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd88c
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0xd690
callq 0xcef0
callq 0xd1f0
callq 0xd0e0
callq 0xd3a0
callq 0xd4b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xd928
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd993
leaq 0x2c4ee(%rip), %rax     # 0x39e50
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6490
leaq 0x2c4db(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x64a0
leaq 0x2935c(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xd9d4
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd9e0
leaq -0x30(%rbp), %rax
callq 0xdad0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x29915(%rip), %rdi     # 0x373f0
leaq 0x2c38e(%rip), %rsi     # 0x39e70
callq 0x60d0
leaq 0x291f2(%rip), %rax     # 0x36ce0
cmpl $0x0, (%rax)
jle 0xdb4b
leaq 0x2c356(%rip), %rax     # 0x39e50
movq (%rax), %rdi
leaq 0x291dc(%rip), %rax     # 0x36ce0
movl (%rax), %edx
xorl %esi, %esi
callq 0x6490
leaq 0x2c33c(%rip), %rax     # 0x39e50
movq (%rax), %rdi
leaq 0x25810(%rip), %rsi     # 0x3332e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6560
leaq 0x2c321(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x61f0
leaq 0x2c312(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movl $0x20, %esi
callq 0xdbc0
leaq 0x2c2fe(%rip), %rax     # 0x39e50
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6490
cmpl $-0x1, %eax
jne 0xdb65
jmp 0xdb80
leaq 0x2c2e4(%rip), %rax     # 0x39e50
movq (%rax), %rdi
leaq 0x2c2fa(%rip), %rsi     # 0x39e70
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6560
leaq 0x2c2c9(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x64a0
movl 0x2e2db(%rip), %ecx     # 0x3be70
leaq 0x29144(%rip), %rax     # 0x36ce0
movl %ecx, (%rax)
movl $0x0, 0x2e2c8(%rip)     # 0x3be70
leaq 0x2c2a1(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x61f0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/io.c
// Function: wait_for
void wait_for(WINDOW *win,char ch)
{
	char c;

	if (ch == '\n')
	    while ((c = wgetch(win)) != '\n' && c != '\r')
			continue;
	else
	    while (wgetch(win) != ch)
			continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0xdc10
jmp 0xdbdd
movq -0x8(%rbp), %rdi
callq 0x6100
movb %al, -0xa(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0xb(%rbp)
je 0xdc03
movsbl -0xa(%rbp), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0xdc0c
jmp 0xdc0e
jmp 0xdbdd
jmp 0xdc27
jmp 0xdc12
movq -0x8(%rbp), %rdi
callq 0x6100
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xdc25
jmp 0xdc12
jmp 0xdc27
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/io.c
// Function: step_ok
bool step_ok(unsigned long ch)
{
	if (dead_end(ch))
		return FALSE;
	else if (ch >= 32 && ch <= 127 && !isalpha(ch))
		return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl %al, %edi
callq 0xdca0
testb $0x1, %al
jne 0xdc4e
jmp 0xdc54
movb $0x0, -0x1(%rbp)
jmp 0xdc8b
cmpq $0x20, -0x10(%rbp)
jb 0xdc85
cmpq $0x7f, -0x10(%rbp)
ja 0xdc85
callq 0x65b0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xdc85
movb $0x1, -0x1(%rbp)
jmp 0xdc8b
jmp 0xdc87
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/io.c
// Function: illeg_ch
bool illeg_ch(unsigned char ch)
{
	if (ch < 32 || ch > 127)
		return TRUE;
	if (ch >= '0' && ch <= '9')
		return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x20, %eax
jl 0xe23c
movzbl -0x2(%rbp), %eax
cmpl $0x7f, %eax
jle 0xe242
movb $0x1, -0x1(%rbp)
jmp 0xe25e
movzbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jl 0xe25a
movzbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0xe25a
movb $0x1, -0x1(%rbp)
jmp 0xe25e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/io.c
// Function: npch
char npch(char ch)
{
	char nch;
	if (ch >= 'z')
		nch = 'A';
	else
		nch = ch + 1;
	return nch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x7a, %eax
jl 0xe349
movb $0x41, -0x2(%rbp)
jmp 0xe353
movsbl -0x1(%rbp), %eax
addl $0x1, %eax
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xe387
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe3a4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe3c1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe421
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xe438
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe48a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xe490
jmp 0xe45c
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0xe520
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0xe520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)