LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/pstats.c
// Function: getpcon
int getpcon(struct stats *who)
{
	int econ;

	econ = who->s_ef.a_con;
	if (econ > 18)
		return (econ - 14);
	switch(econ) {
		case 18: return 4;
		case 17: return 3;
		case 16: return 2;
		case 15: return 1;
		case 14:
		case 13:
		case 12:
		case 11:
		case 10:
		case 9:
		case 8:
		case 7: return 0;
		case 6:
		case 5:
		case 4: return -1;
		default: return -2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x12, -0x14(%rbp)
jle 0x16e63
movl -0x14(%rbp), %eax
subl $0xe, %eax
movl %eax, -0x4(%rbp)
jmp 0x16ec5
movl -0x14(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0x16ebe
movq -0x20(%rbp), %rax
leaq 0x1525d(%rip), %rcx     # 0x2c0dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, -0x4(%rbp)
jmp 0x16ec5
movl $0x3, -0x4(%rbp)
jmp 0x16ec5
movl $0x2, -0x4(%rbp)
jmp 0x16ec5
movl $0x1, -0x4(%rbp)
jmp 0x16ec5
movl $0x0, -0x4(%rbp)
jmp 0x16ec5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16ec5
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/pstats.c
// Function: str_plus
int str_plus(struct stats *who)
{
	int hitplus, str;

	hitplus = 0;
	str = who->s_ef.a_str;
	if (str > 24)			/* > 24 */
		hitplus = str - 21;
	else if (str == 24)		/* 24 */
		hitplus = 3;
	else if (str > 20)		/* 21 to 23 */
		hitplus = 2;
	else if(str >= 17)		/* 17 to 20 */
		hitplus = 1;
	else if(str > 7)		/* 8 to 16 */
		hitplus = 0;
	else if(str > 5)		/* 6 to 7 */
		hitplus = -1;
	else if(str > 3)		/* 4 to 5 */
		hitplus = -2;
	else
		hitplus = -3;		/* < 4 */
	if (who == him)			/* add pack weight if hero */
		hitplus += hitweight();
	return hitplus;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x18, -0x10(%rbp)
jle 0x16efe
movl -0x10(%rbp), %eax
subl $0x15, %eax
movl %eax, -0xc(%rbp)
jmp 0x16f6b
cmpl $0x18, -0x10(%rbp)
jne 0x16f0d
movl $0x3, -0xc(%rbp)
jmp 0x16f69
cmpl $0x14, -0x10(%rbp)
jle 0x16f1c
movl $0x2, -0xc(%rbp)
jmp 0x16f67
cmpl $0x11, -0x10(%rbp)
jl 0x16f2b
movl $0x1, -0xc(%rbp)
jmp 0x16f65
cmpl $0x7, -0x10(%rbp)
jle 0x16f3a
movl $0x0, -0xc(%rbp)
jmp 0x16f63
cmpl $0x5, -0x10(%rbp)
jle 0x16f49
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x16f61
cmpl $0x3, -0x10(%rbp)
jle 0x16f58
movl $0xfffffffe, -0xc(%rbp) # imm = 0xFFFFFFFE
jmp 0x16f5f
movl $0xfffffffd, -0xc(%rbp) # imm = 0xFFFFFFFD
jmp 0x16f61
jmp 0x16f63
jmp 0x16f65
jmp 0x16f67
jmp 0x16f69
jmp 0x16f6b
movq -0x8(%rbp), %rax
leaq 0x2025a(%rip), %rcx     # 0x371d0
cmpq (%rcx), %rax
jne 0x16f88
movb $0x0, %al
callq 0xb200
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/pstats.c
// Function: add_dam
int add_dam(struct stats *who)
{
	int exdam, str;

	exdam = 0;
	str = who->s_ef.a_str;
	if (str > 24)			/* > 24 */
		exdam = str - 18;
	else if (str == 24)		/* 24 */
		exdam = 6;
	else if (str == 23)		/* 23 */
		exdam = 5;
	else if (str > 20)		/* 21 to 22 */
		exdam = 4;
	else if (str > 18)		/* 19 to 20 */
		exdam = 3;
	else if (str == 18)		/* 18 */
		exdam = 2;
	else if (str > 15)		/* 16 to 17 */
		exdam = 1;
	else if (str > 6)		/* 7 to 14 */
		exdam = 0;
	else
		exdam = -1;			/* 3 to 6 */
	if (who == him)
		exdam += hungdam();		/* add hungry state if hero */
	return exdam;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x18, -0x10(%rbp)
jle 0x16fce
movl -0x10(%rbp), %eax
subl $0x12, %eax
movl %eax, -0xc(%rbp)
jmp 0x1704c
cmpl $0x18, -0x10(%rbp)
jne 0x16fdd
movl $0x6, -0xc(%rbp)
jmp 0x1704a
cmpl $0x17, -0x10(%rbp)
jne 0x16fec
movl $0x5, -0xc(%rbp)
jmp 0x17048
cmpl $0x14, -0x10(%rbp)
jle 0x16ffb
movl $0x4, -0xc(%rbp)
jmp 0x17046
cmpl $0x12, -0x10(%rbp)
jle 0x1700a
movl $0x3, -0xc(%rbp)
jmp 0x17044
cmpl $0x12, -0x10(%rbp)
jne 0x17019
movl $0x2, -0xc(%rbp)
jmp 0x17042
cmpl $0xf, -0x10(%rbp)
jle 0x17028
movl $0x1, -0xc(%rbp)
jmp 0x17040
cmpl $0x6, -0x10(%rbp)
jle 0x17037
movl $0x0, -0xc(%rbp)
jmp 0x1703e
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x17040
jmp 0x17042
jmp 0x17044
jmp 0x17046
jmp 0x17048
jmp 0x1704a
jmp 0x1704c
movq -0x8(%rbp), %rax
leaq 0x20179(%rip), %rcx     # 0x371d0
cmpq (%rcx), %rax
jne 0x17067
callq 0x17070
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/pstats.c
// Function: hungdam
int hungdam()
{
	switch (hungry_state) {
		case F_OKAY:
		case F_HUNGRY:	return 0;
		when F_WEAK:	return -1;
		when F_FAINT:	return -2;
	}
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1fc85(%rip), %rax     # 0x36d00
movl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
jb 0x1709b
jmp 0x17087
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0x170a4
jmp 0x17091
movl -0x8(%rbp), %eax
subl $0x3, %eax
je 0x170ad
jmp 0x170b6
movl $0x0, -0x4(%rbp)
jmp 0x170bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x170bd
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x170bd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/pstats.c
// Function: heal_self
void heal_self(int factor,bool updmaxhp)
{
	him->s_hpt += roll(him->s_lvl + getpcon(him), factor);
	if (updmaxhp)
		him->s_maxhp += 1;
	if (him->s_hpt > him->s_maxhp)
		him->s_hpt = him->s_maxhp;
	nochange = FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
leaq 0x200e6(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x200d6(%rip), %rax     # 0x371d0
movq (%rax), %rdi
callq 0x16e40
movl -0xc(%rbp), %edi
addl %eax, %edi
movl -0x4(%rbp), %esi
callq 0xef70
movl %eax, %ecx
leaq 0x200b8(%rip), %rax     # 0x371d0
movq (%rax), %rax
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
testb $0x1, -0x5(%rbp)
je 0x1713a
leaq 0x200a2(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
leaq 0x2008f(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x30(%rax), %eax
leaq 0x20082(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpl 0x34(%rcx), %eax
jle 0x17170
leaq 0x20073(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x34(%rax), %ecx
leaq 0x20066(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl %ecx, 0x30(%rax)
leaq 0x1fb9c(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rings.c
// Function: ring_off
int ring_off()
{
	int ring;
	struct object *obj;
	
	if (cur_ring[LEFT] == NULL && cur_ring[RIGHT] == NULL) {
		msg("You're not wearing any rings.");
		return 0;
	}
	else if (cur_ring[LEFT] == NULL)
		ring = RIGHT;
	else if (cur_ring[RIGHT] == NULL)
		ring = LEFT;
	else
		if ((ring = gethand(TRUE)))
			return 0;
	mpos = 0;
	obj = cur_ring[ring];
	if (obj == NULL) {
		msg("Not wearing such a ring.");
		return 0;
	}
	if (dropcheck(obj)) {
		msg("Was wearing %s", inv_name(obj, TRUE));
		nochange = FALSE;
		ringfood = ring_eat();
	}
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1f8c1(%rip), %rax     # 0x371c0
cmpq $0x0, (%rax)
jne 0x1792d
leaq 0x1f8b4(%rip), %rax     # 0x371c0
cmpq $0x0, 0x8(%rax)
jne 0x1792d
leaq 0x14a88(%rip), %rdi     # 0x2c3a2
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x17a14
leaq 0x1f88c(%rip), %rax     # 0x371c0
cmpq $0x0, (%rax)
jne 0x17943
movl $0x1, -0x8(%rbp)
jmp 0x17985
leaq 0x1f876(%rip), %rax     # 0x371c0
cmpq $0x0, 0x8(%rax)
jne 0x1795a
movl $0x0, -0x8(%rbp)
jmp 0x17983
movl $0x1, %edi
callq 0x176f0
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x8(%rbp)
testb $0x1, %al
jne 0x17975
jmp 0x17981
movl $0x0, -0x4(%rbp)
jmp 0x17a14
jmp 0x17983
jmp 0x17985
jmp 0x17987
leaq 0x1f352(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
movslq -0x8(%rbp), %rcx
leaq 0x1f821(%rip), %rax     # 0x371c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x179c5
leaq 0x14a0b(%rip), %rdi     # 0x2c3c0
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x17a14
movq -0x10(%rbp), %rdi
callq 0x23eb0
testb $0x1, %al
jne 0x179d4
jmp 0x17a0d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movq %rax, %rsi
leaq 0x149ed(%rip), %rdi     # 0x2c3d9
movb $0x0, %al
callq 0xd8f0
leaq 0x1f319(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
callq 0x17c50
movl %eax, %ecx
leaq 0x1f2f9(%rip), %rax     # 0x36d04
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rings.c
// Function: ring_num
char * ring_num(struct object *what)
{
	static char number[5];

	number[0] = '\0';
	if (o_on(what,ISKNOW) || o_on(what,ISPOST)) {
		if (magring(what)) {	/* only rings with numbers */
			number[0] = ' ';
			strcpy(&number[1], num(what->o_ac, 0));
		}
	}
	return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, 0x244d5(%rip)     # 0x3c328
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xaac0
testb $0x1, %al
jne 0x17e79
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xaac0
testb $0x1, %al
jne 0x17e79
jmp 0x17eae
movq -0x8(%rbp), %rdi
callq 0x17ec0
testb $0x1, %al
jne 0x17e88
jmp 0x17eac
movb $0x20, 0x24499(%rip)    # 0x3c328
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edi
xorl %esi, %esi
callq 0x25fb0
movq %rax, %rsi
leaq 0x24482(%rip), %rdi     # 0x3c329
callq 0x60d0
jmp 0x17eae
leaq 0x24473(%rip), %rax     # 0x3c328
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rings.c
// Function: magring
bool magring(struct object *what)
{
	switch(what->o_which) {
		case R_SPEED:
		case R_ADDSTR:
		case R_PROTECT:
		case R_ADDHIT:
		case R_ADDDAM:
		case R_DIGEST:
		case R_CONST:
		case R_KNOW:
		case R_DEX:
			return TRUE;
		default:
			return FALSE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
jb 0x17f11
jmp 0x17ed9
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x17f11
jmp 0x17ee3
movl -0x14(%rbp), %eax
addl $-0x7, %eax
subl $0x2, %eax
jb 0x17f11
jmp 0x17ef0
movl -0x14(%rbp), %eax
subl $0xa, %eax
je 0x17f11
jmp 0x17efa
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x17f11
jmp 0x17f04
movl -0x14(%rbp), %eax
addl $-0x18, %eax
subl $0x1, %eax
ja 0x17f17
jmp 0x17f11
movb $0x1, -0x1(%rbp)
jmp 0x17f1b
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/rings.c
// Function: ringabil
void ringabil()
{
	struct object *rptr;
	int i;

	for(i = LEFT; i <= RIGHT; i++) {
		rptr = cur_ring[i];
		if (rptr != NULL) {
			switch(rptr->o_which) {
				case R_ADDSTR:
					chg_abil(STR,rptr->o_ac,FROMRING);
				when R_DEX: 
					chg_abil(DEX,rptr->o_ac,FROMRING);
				when R_KNOW:
					chg_abil(WIS,rptr->o_ac,FROMRING);
				when R_CONST:
					chg_abil(CON,rptr->o_ac,FROMRING);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x17ffc
movslq -0xc(%rbp), %rcx
leaq 0x1f26c(%rip), %rax     # 0x371c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x17fec
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x18, %eax
ja 0x17fea
movq -0x18(%rbp), %rax
leaq 0x142da(%rip), %rcx     # 0x2c260
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl $0x1, %edi
movl $0x2, %edx
callq 0x16910
jmp 0x17fea
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl $0x2, %edx
movl %edx, %edi
callq 0x16910
jmp 0x17fea
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl $0x4, %edi
movl $0x2, %edx
callq 0x16910
jmp 0x17fea
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl $0x3, %edi
movl $0x2, %edx
callq 0x16910
jmp 0x17fec
jmp 0x17fee
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17f3f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rings.c
// Function: init_ring
void init_ring(struct object *what,bool fromwiz) // fromwiz == TRUE when wizard
{
	int much;

	switch (what->o_which) {
		case R_DIGEST:		/* -3 to +3 rings */
		case R_ADDSTR:
		case R_PROTECT:
		case R_ADDHIT:
		case R_ADDDAM:
		case R_DEX:
		case R_KNOW:
		case R_CONST:
			if (fromwiz) {
				much = getbless();		/* get wizards response */
			}
			else {						/* normal users */
				if (rnd(100) < 25)
					much = -rnd(3) - 1;
				else
					much = rnd(3) + 1;
			}
			what->o_ac = much;
			if (much < 0)
				setoflg(what,ISCURSED);
		when R_SPEED:
			what->o_ac = rnd(4) + 1;
		when R_AGGR:
		case R_DELUS:
		case R_HEAVY:
		case R_BLIND:
		case R_SLOW:
		case R_SAPEM:
		case R_TELEPORT:
			what->o_ac = 0;
			setoflg(what,ISCURSED);	
		when R_GIANT:
			what->o_ac = 25;		/* lots !! of STR */
		otherwise:
			what->o_ac = 1;
	}
	what->o_type = RING;
	what->o_weight = things[TYP_RING].mi_wght;
	what->o_typname = things[TYP_RING].mi_name;
	what->o_vol = itemvol(what);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x19, %rax
ja 0x18100
movq -0x18(%rbp), %rax
leaq 0x14280(%rip), %rcx     # 0x2c2c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testb $0x1, -0x9(%rbp)
je 0x1805f
movb $0x0, %al
callq 0x26c10
movl %eax, -0x10(%rbp)
jmp 0x1809e
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0x19, %eax
jge 0x1808a
movl $0x3, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1809c
movl $0x3, %edi
movb $0x0, %al
callq 0xef20
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1809e
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
cmpl $0x0, -0x10(%rbp)
jge 0x180bc
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xab50
jmp 0x1810b
movl $0x4, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
jmp 0x1810b
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xab50
jmp 0x1810b
movq -0x8(%rbp), %rax
movl $0x19, 0x34(%rax)
jmp 0x1810b
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x3d, 0x20(%rax)
leaq 0x1ccb3(%rip), %rax     # 0x34dd0
movl 0x5c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
leaq 0x1cca2(%rip), %rax     # 0x34dd0
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xae90
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rings.c
// Function: ringex
int ringex(int rtype)
{
	int howmuch = 0;

	if (isring(LEFT, rtype))
		howmuch += cur_ring[LEFT]->o_ac;
	if (isring(RIGHT, rtype))
		howmuch += cur_ring[RIGHT]->o_ac;
	return howmuch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %esi
xorl %edi, %edi
callq 0x181d0
testb $0x1, %al
jne 0x18182
jmp 0x18195
leaq 0x1f037(%rip), %rax     # 0x371c0
movq (%rax), %rax
movl 0x34(%rax), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %esi
movl $0x1, %edi
callq 0x181d0
testb $0x1, %al
jne 0x181a8
jmp 0x181bc
leaq 0x1f011(%rip), %rax     # 0x371c0
movq 0x8(%rax), %rax
movl 0x34(%rax), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rip.c
// Function: killname
char *killname(unsigned char monst)
{
	if (monst < MAXMONS + 1)
		return monsters[monst].m_name;
	else		/* things other than monsters */
		switch (monst) {
			case K_ARROW:	return "crooked arrow";
			case K_DART:	return "sharp dart";
			case K_BOLT:	return "jagged bolt";
			case K_POOL:	return "magic pool";
			case K_ROD:	return "exploding rod";
			case K_SCROLL:	return "burning scroll";
			case K_STONE: 	return "transmogrification to stone";
			case K_STARVE:	return "starvation";
	}
	return "Bob Kindelberger";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x35, %eax
jge 0x18593
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x1ae40(%rip), %rax     # 0x333c0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x18630
movzbl -0x9(%rbp), %eax
addl $0xffffff10, %eax       # imm = 0xFFFFFF10
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x18623
movq -0x18(%rbp), %rax
leaq 0x13e7a(%rip), %rcx     # 0x2c42c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x142e2(%rip), %rax     # 0x2c8a4
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142e3(%rip), %rax     # 0x2c8b2
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142e1(%rip), %rax     # 0x2c8bd
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x1127a(%rip), %rax     # 0x29863
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142d3(%rip), %rax     # 0x2c8c9
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142d4(%rip), %rax     # 0x2c8d7
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142d6(%rip), %rax     # 0x2c8e6
movq %rax, -0x8(%rbp)
jmp 0x18630
leaq 0x142e5(%rip), %rax     # 0x2c902
movq %rax, -0x8(%rbp)
jmp 0x18630
jmp 0x18625
leaq 0x142e1(%rip), %rax     # 0x2c90d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/rooms.c
// Function: rnd_pos
struct coord *rnd_pos(struct room *rp)
{
	int y, x, i;
	static struct coord spot;

	i = 0;
	do {
		x = rp->r_pos.x + rnd(rp->r_max.x - 2) + 1;
		y = rp->r_pos.y + rnd(rp->r_max.y - 2) + 1;
		i += 1;
	} while(winat(y, x) != FLOOR && i < 1000);
	spot.x = x;
	spot.y = y;
	return &spot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
subl $0x2, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
subl $0x2, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xa960
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x1d(%rbp)
je 0x19c90
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x19c13
movl -0x10(%rbp), %eax
movl %eax, 0x22bb0(%rip)     # 0x3c854
movl -0xc(%rbp), %eax
movl %eax, 0x22bab(%rip)     # 0x3c858
leaq 0x22ba0(%rip), %rax     # 0x3c854
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/save.c
// Function: save_game
int save_game()
{
	FILE *savef;
	int c;
	char buf[LINLEN];

	mpos = 0;
	if (file_name[0] != '\0') {
		msg("Save file (%s)? ", file_name);
		do {
			c = wgetch(cw);
			if(c == ESCAPE) {
				msg("");
				return FALSE;
			}
		} while (c != 'n' && c != 'y');
		mpos = 0;
		if (c == 'y')
			goto gotfile;
	}
	msg("File name: ");
	mpos = 0;
	buf[0] = '\0';
	if (get_str(buf, cw) == QUIT) {
		msg("");
		return FALSE;
	}
	msg("");
	strcpy(file_name, buf);
gotfile:
	c = dosave();		/* try to save this game */
	if (c == FALSE)
		msg("Could not save game to file %s", file_name);
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x1cece(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
leaq 0x1d621(%rip), %rax     # 0x37440
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19ea3
leaq 0x12d65(%rip), %rdi     # 0x2cb93
leaq 0x1d60b(%rip), %rsi     # 0x37440
movb $0x0, %al
callq 0xd8f0
leaq 0x2000d(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x6100
movl %eax, -0x14(%rbp)
cmpl $0x1b, -0x14(%rbp)
jne 0x19e6e
leaq 0x14454(%rip), %rdi     # 0x2e2af
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x19f3d
jmp 0x19e70
xorl %eax, %eax
cmpl $0x6e, -0x14(%rbp)
movb %al, -0x71(%rbp)
je 0x19e85
cmpl $0x79, -0x14(%rbp)
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x19e3c
leaq 0x1ce4d(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
cmpl $0x79, -0x14(%rbp)
jne 0x19ea1
jmp 0x19f0f
jmp 0x19ea3
leaq 0x12cfa(%rip), %rdi     # 0x2cba4
movb $0x0, %al
callq 0xd8f0
leaq 0x1ce28(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
movb $0x0, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x1ff83(%rip), %rax     # 0x39e50
movq (%rax), %rsi
callq 0x13c10
cmpl $0x1, %eax
jne 0x19ef1
leaq 0x143ce(%rip), %rdi     # 0x2e2af
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x19f3d
leaq 0x143b7(%rip), %rdi     # 0x2e2af
movb $0x0, %al
callq 0xd8f0
leaq -0x70(%rbp), %rsi
leaq 0x1d536(%rip), %rdi     # 0x37440
callq 0x60d0
callq 0x1a010
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x19f37
leaq 0x12c87(%rip), %rdi     # 0x2cbb0
leaq 0x1d510(%rip), %rsi     # 0x37440
movb $0x0, %al
callq 0xd8f0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/save.c
// Function: game_err
void game_err(int a)
{
	int ok;

	ok = dosave();			/* try to save this game */
	clear();
	refresh();
	endwin();

	printf("\nInternal error !!!\n\nYour game was ");
	if (ok)
		printf("saved.");
	else
		printf("NOT saveable.");

	fflush(stdout);

#ifdef SIGIOT
	signal(SIGIOT, SIG_DFL);	/* allow core dump signal */
#endif

	abort();			/* cause core dump */
	byebye(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1a010
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movq 0x19021(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x6110
movq 0x19012(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x61f0
callq 0x6530
leaq 0x12c0d(%rip), %rdi     # 0x2cbcf
movb $0x0, %al
callq 0x61b0
cmpl $0x0, -0x8(%rbp)
je 0x19fdf
leaq 0x12c1d(%rip), %rdi     # 0x2cbf3
movb $0x0, %al
callq 0x61b0
jmp 0x19fed
leaq 0x12c14(%rip), %rdi     # 0x2cbfa
movb $0x0, %al
callq 0x61b0
movq 0x18fc4(%rip), %rax     # 0x32fb8
movq (%rax), %rdi
callq 0x6360
movl $0x6, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6280
callq 0x6080
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/save.c
// Function: dosave
bool dosave()
{
	FILE *savef;

	ignore();
	setuid(playuid);
	setgid(playgid);
	umask(022);

	if (file_name[0] != '\0') {
		if ((savef = fopen(file_name,"w")) != NULL)
		{
			save_file(savef);
			return TRUE;
		}
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x19dc0
leaq 0x1d2ac(%rip), %rax     # 0x372d0
movl (%rax), %edi
callq 0x6520
leaq 0x1d2a2(%rip), %rax     # 0x372d4
movl (%rax), %edi
callq 0x6410
movl $0x12, %edi
callq 0x62a0
leaq 0x1d3f6(%rip), %rax     # 0x37440
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a080
leaq 0x1d3e7(%rip), %rdi     # 0x37440
leaq 0x10f3a(%rip), %rsi     # 0x2af9a
callq 0x6460
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1a07e
movq -0x10(%rbp), %rdi
callq 0x1a090
movb $0x1, -0x1(%rbp)
jmp 0x1a084
jmp 0x1a080
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/save.c
// Function: save_file
void save_file(FILE *savef)
{
	int fnum;
	int slines = LINES;
	int scols = COLS;

#ifdef __DJGPP__                      /* st_ino w/ DJGPP under WinXP broken */
        _djstat_flags |= _STAT_INODE; /* so turn off computing it for now   */
#endif

	/*
	 * force allocation of the buffer now so that inodes, etc
	 * can be checked when restoring saved games.
	 */
	fnum = fileno(savef);
	fstat(fnum, &sbuf);
	write(fnum, "RDK", 4);
	lseek(fnum, 0L, 0);
	encwrite(version,strlen(version)+1,savef);
	encwrite(&sbuf.st_ino,sizeof(sbuf.st_ino),savef);
	encwrite(&sbuf.st_dev,sizeof(sbuf.st_dev),savef);
	encwrite(&sbuf.st_ctime,sizeof(sbuf.st_ctime),savef);
	encwrite(&sbuf.st_mtime,sizeof(sbuf.st_mtime),savef);
	encwrite(&slines,sizeof(slines),savef);
	encwrite(&scols,sizeof(scols),savef);
	msg("");
	rs_save_file(savef);
	close(fnum);
	signal(SIGINT, byebye);
	signal(SIGQUIT, byebye);
	wclear(cw);
	draw(cw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x18f3d(%rip), %rax     # 0x32fe0
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq 0x18f29(%rip), %rax     # 0x32fd8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6300
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x22796(%rip), %rsi     # 0x3c860
callq 0x6580
movl -0xc(%rbp), %edi
leaq 0x12b2f(%rip), %rsi     # 0x2cc08
movl $0x4, %edx
callq 0x60f0
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x61c0
leaq 0x1c578(%rip), %rdi     # 0x36670
callq 0x6160
addq $0x1, %rax
movl %eax, %esi
movq -0x8(%rbp), %rdx
leaq 0x1c562(%rip), %rdi     # 0x36670
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq 0x22742(%rip), %rdi     # 0x3c860
addq $0x8, %rdi
movl $0x8, %esi
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq 0x22729(%rip), %rdi     # 0x3c860
movl $0x8, %esi
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq 0x22714(%rip), %rdi     # 0x3c860
addq $0x68, %rdi
movl $0x8, %esi
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq 0x226fb(%rip), %rdi     # 0x3c860
addq $0x58, %rdi
movl $0x8, %esi
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x1bc00
movq -0x8(%rbp), %rdx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x1bc00
leaq 0x14111(%rip), %rdi     # 0x2e2af
movb $0x0, %al
callq 0xd8f0
movq -0x8(%rbp), %rdi
callq 0x20660
movl -0xc(%rbp), %edi
callq 0x6230
movl $0x2, %edi
leaq -0xb2d2(%rip), %rsi     # 0xeef0
callq 0x6280
movl $0x3, %edi
leaq -0xb2e3(%rip), %rsi     # 0xeef0
callq 0x6280
leaq 0x1fc71(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x6110
leaq 0x1fc62(%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/state.c
// Function: encwrite
void encwrite(void *starta,unsigned int size,FILE *outf)
{
    char *ep;
    char *start = starta;

    ep = encstr;

    while (size--)
    {
        putc(*start++ ^ *ep++, outf);
        if (*ep == '\0')
            ep = encstr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1a95e(%rip), %rax     # 0x36580
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1bc7e
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %edi
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
xorl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x6260
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1bc7c
leaq 0x1a908(%rip), %rax     # 0x36580
movq %rax, -0x20(%rbp)
jmp 0x1bc26
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: encread
int encread(void *starta,unsigned int size,int inf)
{
    char *ep;
    int read_size;
    char *start = starta;

    if ((read_size = read(inf, start, size)) == -1 || read_size == 0)
        return read_size;

    ep = encstr;

    while (size--)
    {
        *start++ ^= *ep++;
        if (*ep == '\0')
            ep = encstr;
    }
    return read_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x6240
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x1bcc9
cmpl $0x0, -0x24(%rbp)
jne 0x1bcd1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bd33
leaq 0x1a8a8(%rip), %rax     # 0x36580
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1bd2d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %edx
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movsbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1bd2b
leaq 0x1a859(%rip), %rax     # 0x36580
movq %rax, -0x20(%rbp)
jmp 0x1bcdc
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: get_list_item
void * get_list_item(struct linked_list *l, int i)
{
    int count = 0;

    while(l != NULL)
    {   
        if (count == i)
            return(l->l_data);
                        
        l = l->l_next;
        
        count++;
    }
    
    return(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bd85
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x1bd6f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bd8d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1bd52
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: find_list_ptr
int find_list_ptr(struct linked_list *l, void *ptr)
{
    int count = 0;

    while(l != NULL)
    {
        if (l->l_data == ptr)
            return(count);
            
        l = l->l_next;
        count++;
    }
    
    return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bde6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1bdd0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bded
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bdb3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: list_size
int list_size(struct linked_list *l)
{
    int count = 0;
    
    while(l != NULL)
    {
        if (l->l_data == NULL)
            return(count);
            
        count++;
        
        l = l->l_next;
    }
    
    return(count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1be3f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1be29
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1be45
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1be0f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write
int rs_write(FILE *savef, void *ptr, int size)
{
    if (!write_error)
        encwrite(ptr,size,savef);

    if (0)
        write_error = TRUE;
        
    assert(write_error == 0);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0x20a8a(%rip)     # 0x3c8f4
jne 0x1be7c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x1bc00
cmpl $0x0, 0x20a71(%rip)     # 0x3c8f4
jne 0x1be87
jmp 0x1bea6
leaq 0x11472(%rip), %rdi     # 0x2d300
leaq 0x1147c(%rip), %rsi     # 0x2d311
movl $0xb7, %edx
leaq 0x11478(%rip), %rcx     # 0x2d319
callq 0x61d0
cmpl $0x0, 0x20a47(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_int
int rs_write_int(FILE *savef, int c)
{
    unsigned char bytes[4];
    unsigned char *buf = (unsigned char *) &c;

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    rs_write(savef, buf, 4);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x20982(%rip)     # 0x3c900
je 0x1bfaf
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0xe(%rbp)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0xf(%rbp)
movq -0x18(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1be50
cmpl $0x0, 0x2092c(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_booleans
int rs_write_booleans(FILE *savef, bool *c, int count)
{
    int n = 0;

    rs_write_int(savef,count);
    
    for(n = 0; n < count; n++)
        rs_write_boolean(savef,c[n]);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c039
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c00d
cmpl $0x0, 0x208b4(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_short
int rs_write_short(FILE *savef, short c)
{
    unsigned char bytes[2];
    unsigned char *buf = (unsigned char *) &c;

    if (big_endian)
    {
        bytes[1] = buf[0];
        bytes[0] = buf[1];
        buf = bytes;
    }

    rs_write(savef, buf, 2);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
leaq -0xa(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x2084e(%rip)     # 0x3c900
je 0x1c0cf
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x1be50
cmpl $0x0, 0x2080c(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_shorts
int rs_write_shorts(FILE *savef, short *c, int count)
{
    int n = 0;

    rs_write_int(savef,count);
    
    for(n = 0; n < count; n++)
        rs_write_short(savef,c[n]);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c155
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl (%rax,%rcx,2), %esi
callq 0x1c090
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c12d
cmpl $0x0, 0x20798(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_ushort
int rs_write_ushort(FILE *savef, unsigned short c)
{
    unsigned char bytes[2];
    unsigned char *buf = (unsigned char *) &c;

    if (big_endian)
    {
        bytes[1] = buf[0];
        bytes[0] = buf[1];
        buf = bytes;
    }

    rs_write(savef, buf, 2);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
leaq -0xa(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x2076e(%rip)     # 0x3c900
je 0x1c1af
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x1be50
cmpl $0x0, 0x2072c(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_ints
int rs_write_ints(FILE *savef, int *c, int count)
{
    int n = 0;

    rs_write_int(savef,count);
    
    for(n = 0; n < count; n++)
        rs_write_int(savef,c[n]);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c234
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1bf60
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c20d
cmpl $0x0, 0x206b9(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_uint
int rs_write_uint(FILE *savef, unsigned int c)
{
    unsigned char bytes[4];
    unsigned char *buf = (unsigned char *) &c;

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    rs_write(savef, buf, 4);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x20692(%rip)     # 0x3c900
je 0x1c29f
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0xe(%rbp)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0xf(%rbp)
movq -0x18(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1be50
cmpl $0x0, 0x2063c(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_long
int rs_write_long(FILE *savef, long c)
{
    int c2;
    unsigned char bytes[4];
    unsigned char *buf = (unsigned char *)&c;

    if (sizeof(long) == 8)
    {
        c2 = c;
        buf = (unsigned char *) &c2;
    }

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    rs_write(savef, buf, 4);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x20602(%rip)     # 0x3c900
je 0x1c32f
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x15(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x16(%rbp)
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x17(%rbp)
movq -0x20(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1be50
cmpl $0x0, 0x205ac(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_longs
int rs_write_longs(FILE *savef, long *c, int count)
{
    int n = 0;

    rs_write_int(savef,count);
    
    for(n = 0; n < count; n++)
        rs_write_long(savef,c[n]);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c3b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1c2d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c38d
cmpl $0x0, 0x20538(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_ulong
int rs_write_ulong(FILE *savef, unsigned long c)
{
    unsigned int c2;
    unsigned char bytes[4];
    unsigned char *buf = (unsigned char *)&c;

    if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
    {
        c2 = c;
        buf = (unsigned char *) &c2;
    }

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    rs_write(savef, buf, 4);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x20502(%rip)     # 0x3c900
je 0x1c42f
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x15(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x16(%rbp)
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x17(%rbp)
movq -0x20(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1be50
cmpl $0x0, 0x204ac(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_ulongs
int rs_write_ulongs(FILE *savef, unsigned long *c, int count)
{
    int n = 0;

    rs_write_int(savef,count);
    
    for(n = 0; n < count; n++)
        rs_write_ulong(savef,c[n]);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c4b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1c3d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c48d
cmpl $0x0, 0x20438(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_string
int rs_write_string(FILE *savef, char *s)
{
    int len = 0;

    len = (s == NULL) ? 0 : strlen(s) + 1;

    rs_write_int(savef, len);
    rs_write(savef, s, len);
            
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c4f6
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x1c507
movq -0x10(%rbp), %rdi
callq 0x6160
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1be50
cmpl $0x0, 0x203c3(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_string_index
int rs_write_string_index(FILE *savef, char *master[], int max, char *str)
{
    int i;

    for(i = 0; i < max; i++)
    {
        if (str == master[i])
        {
            rs_write_int(savef,i);
            return(WRITESTAT);
        }
    }

    rs_write_int(savef,-1);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1c5a5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x1c598
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x1bf60
cmpl $0x0, 0x20369(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c5c5
jmp 0x1c59a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1c55e
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1bf60
cmpl $0x0, 0x2033a(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_strings
int rs_write_strings(FILE *savef, char *s[], int count)
{
    int len = 0;
    int n = 0;

    rs_write_int(savef,count);

    for(n = 0; n < count; n++)
    {
        len = (s[n] == NULL) ? 0L : strlen(s[n]) + 1;
        rs_write_int(savef, len);
        rs_write(savef, s[n], len);
    }
    
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c672
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1c623
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1c63c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6160
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x18(%rbp), %edx
callq 0x1be50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c604
cmpl $0x0, 0x2027b(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)