LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: cb_call_service
static int cb_call_service(const char *pk, const char *dn, const char *method_name, const leda_device_data_t *data, int count, 
                            leda_device_data_t *output, void *usr)
{
    if (!method_name || !output) {
        return LE_ERROR_INVAILD_PARAM;
    }
    if (0 == strcmp("blink", method_name)) {
        printf("%s:%s blinking\n", pk, dn);
        return LE_SUCCESS;
    } else {
        return LEDA_ERROR_SERVICE_NOT_EXIST;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
sete %al
testq %r9, %r9
sete %cl
movl $0x186a1, %r15d         # imm = 0x186A1
orb %al, %cl
jne 0x1c91
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x466(%rip), %rdi       # 0x20ce
movq %rdx, %rsi
callq 0x11a0
movl $0x1a9cd, %r15d         # imm = 0x1A9CD
testl %eax, %eax
jne 0x1c91
leaq 0x453(%rip), %rdi       # 0x20d4
xorl %r15d, %r15d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1030
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/armor.c
// Function: wear
int wear()
{
	struct linked_list *item;
	struct object *obj;

	if (cur_armor != NULL) {
		msg("You are already wearing some.");
		after = FALSE;
		return 0;
	}
	if ((item = get_item("wear", ARMOR)) == NULL)
		return 0;
	obj = OBJPTR(item);
	if (obj->o_type != ARMOR) {
		msg("You can't wear that.");
		return 0;
	}
	waste_time();
	msg("Wearing %s.", a_magic[obj->o_which].mi_name);
	cur_armor = obj;
	setoflg(obj,ISKNOW);
	nochange = FALSE;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x271a1(%rip), %r14     # 0x2d848
cmpq $0x0, (%r14)
je 0x66cf
leaq 0x16950(%rip), %rdi     # 0x1d004
xorl %eax, %eax
callq 0xb178
leaq 0x23c3b(%rip), %rax     # 0x2a2fd
movb $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1694c(%rip), %rdi     # 0x1d022
pushq $0x5d
popq %rsi
callq 0xfd08
testq %rax, %rax
je 0x66c5
movq 0x10(%rax), %rbx
cmpl $0x5d, 0x20(%rbx)
jne 0x672c
xorl %eax, %eax
callq 0xc284
movslq 0x28(%rbx), %rax
shlq $0x4, %rax
leaq 0x2574d(%rip), %rcx     # 0x2be50
movq (%rcx,%rax), %rsi
leaq 0x1692e(%rip), %rdi     # 0x1d03c
xorl %eax, %eax
callq 0xb178
movq %rbx, (%r14)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x936c
leaq 0x27169(%rip), %rax     # 0x2d893
jmp 0x66c2
leaq 0x168f4(%rip), %rdi     # 0x1d027
xorl %eax, %eax
callq 0xb178
jmp 0x66c5
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/armor.c
// Function: take_off
int take_off()
{
	struct object *obj;

	if ((obj = cur_armor) == NULL) {
		msg("Not wearing any armor.");
		return 0;
	}
	if (!dropcheck(cur_armor))
		return 0;
	cur_armor = NULL;
	msg("Was wearing %c) %s",pack_char(obj),inv_name(obj,TRUE));
	nochange = FALSE;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x27101(%rip), %r14     # 0x2d848
movq (%r14), %rbx
testq %rbx, %rbx
je 0x6794
movq %rbx, %rdi
callq 0x19ba9
testb %al, %al
je 0x67a2
andq $0x0, (%r14)
movq %rbx, %rdi
callq 0xfa6c
movsbl %al, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1908c
leaq 0x168e3(%rip), %rdi     # 0x1d05f
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb178
leaq 0x27104(%rip), %rax     # 0x2d893
movb $0x0, (%rax)
jmp 0x67a2
leaq 0x168ad(%rip), %rdi     # 0x1d048
xorl %eax, %eax
callq 0xb178
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/armor.c
// Function: initarmor
void initarmor(struct object *obj,int what)
{
	struct init_armor *iwa;
	struct magic_item *mi;

	obj->o_type = ARMOR;
	obj->o_which = what;
	iwa = &armors[what];
	mi = &a_magic[what];
	obj->o_vol = iwa->a_vol;
	obj->o_ac = iwa->a_class;
	obj->o_weight = iwa->a_wght;
	obj->o_typname = things[TYP_ARMOR].mi_name;
}

// Assembly:
movl $0x5d, 0x20(%rdi)
movl %esi, 0x28(%rdi)
movslq %esi, %rax
imulq $0xc, %rax, %rax
leaq 0x2573f(%rip), %rcx     # 0x2bf00
movl (%rcx,%rax), %edx
movl %edx, 0x34(%rdi)
movq 0x4(%rcx,%rax), %rax
movq %rax, 0x40(%rdi)
leaq 0x255e9(%rip), %rax     # 0x2bdc0
movq 0x40(%rax), %rax
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/armor.c
// Function: hurt_armor
bool hurt_armor(struct object *obj)
{
	int type, ac;

	if (obj != NULL) {
		if (o_on(obj, ISPROT) || (o_on(obj, ISBLESS) && rnd(100) < 10))
			return FALSE;
		ac = obj->o_ac;
		type = obj->o_which;
		if (type != PADDED && type != LEATHER)
			if ((type == STUDDED && ac < 8) || (type != STUDDED && ac < 9))
				return TRUE;
	}
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6849
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0x934a
testb %al, %al
jne 0x6849
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x934a
testb %al, %al
je 0x6817
xorl %ebp, %ebp
pushq $0x64
popq %rdi
xorl %eax, %eax
callq 0xc004
cmpl $0xa, %eax
jl 0x684b
movl 0x28(%rbx), %eax
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
je 0x6849
movl 0x34(%rbx), %ecx
cmpl $0x2, %eax
sete %dl
cmpl $0x8, %ecx
setl %sil
movb $0x1, %bpl
testb %sil, %dl
jne 0x684b
cmpl $0x2, %eax
setne %al
cmpl $0x9, %ecx
setl %cl
testb %cl, %al
jne 0x684b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/chase.c
// Function: runners
int runners()
{
	struct thing *tp;
	struct linked_list *mon,*nextmon;

	for (mon = mlist; mon != NULL; mon = nextmon) {
		tp = THINGPTR(mon);
		nextmon = next(mon);
		if (off(*tp, ISHELD) && on(*tp, ISRUN)) {
			if (tp->t_nomove > 0)
				if (--tp->t_nomove > 0)
					continue;
			if (on(*tp, ISHASTE))
				if (do_chase(mon) == -1)
					continue;
			if (off(*tp, ISSLOW) || tp->t_turn)
				if (do_chase(mon) == -1)
					continue;
			tp->t_turn ^= TRUE;
		}
	}
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x26fd0(%rip), %rax     # 0x2d830
movq (%rax), %r14
testq %r14, %r14
je 0x68e3
movq %r14, %rbx
movq (%r14), %r14
movq 0x10(%rbx), %r15
movq 0x78(%r15), %rax
movl %eax, %ecx
andl $0x104, %ecx            # imm = 0x104
cmpl $0x4, %ecx
jne 0x6863
movl 0x84(%r15), %ecx
testl %ecx, %ecx
jle 0x689d
leal -0x1(%rcx), %edx
movl %edx, 0x84(%r15)
cmpl $0x1, %ecx
jne 0x6863
testw %ax, %ax
jns 0x68b3
movq %rbx, %rdi
callq 0x68eb
cmpl $-0x1, %eax
je 0x6863
movq 0x78(%r15), %rax
btl $0xe, %eax
jae 0x68c4
movb 0x8c(%r15), %al
cmpb $0x1, %al
jne 0x68d8
movq %rbx, %rdi
callq 0x68eb
cmpl $-0x1, %eax
je 0x6863
movb 0x8c(%r15), %al
xorb $0x1, %al
movb %al, 0x8c(%r15)
jmp 0x6863
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/chase.c
// Function: cansee
bool cansee(int y,int x)
{
	struct room *rer;
	struct coord tp;

	if (pl_on(ISBLIND))
		return FALSE;
	/*
	 * We can only see if the hero in the same room as
	 * the coordinate and the room is lit or if it is close.
	 */
	if (DISTANCE(y, x, hero.y, hero.x) < 3)
		return TRUE;
	tp.y = y;
	tp.x = x;
	rer = roomin(&tp);
	if (rer != NULL && levtype != MAZELEV)
		if (rer == player.t_room && !rf_on(rer,ISDARK))
			return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
pushq $0x1
popq %rdi
callq 0x932c
testb %al, %al
je 0x6ede
xorl %ebx, %ebx
jmp 0x6f01
leaq 0x26d6b(%rip), %r15     # 0x2dc50
movl 0x50(%r15), %eax
movl 0x54(%r15), %ecx
subl %ebp, %eax
imull %eax, %eax
subl %r14d, %ecx
imull %ecx, %ecx
addl %eax, %ecx
movb $0x1, %bl
cmpl $0x3, %ecx
jae 0x6f0e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
movl %r14d, 0x4(%rdi)
movl %ebp, (%rdi)
callq 0x6f44
testq %rax, %rax
je 0x6eda
leaq 0x2692c(%rip), %rcx     # 0x2d854
cmpl $0x2, (%rcx)
je 0x6eda
cmpq 0x70(%r15), %rax
jne 0x6eda
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x12f50
testl %eax, %eax
jne 0x6eda
jmp 0x6f01
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/chase.c
// Function: roomin
struct room *roomin(struct coord *cp)
{
	struct room *rp;

	if (cordok(cp->y, cp->x)) {
		for (rp = rooms; rp < &rooms[MAXROOMS]; rp += 1)
			if (inroom(rp, cp))
				return rp;
	}
	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edi
callq 0x9308
testb %al, %al
je 0x6fa0
xorl %eax, %eax
leaq 0x26941(%rip), %rdx     # 0x2d8a0
xorl %ecx, %ecx
cmpq $0x3a7, %rcx            # imm = 0x3A7
ja 0x6fae
movl (%rbx), %esi
movl (%rdx,%rcx), %edi
cmpl %esi, %edi
jg 0x6f9a
movl 0x8(%rdx,%rcx), %r8d
addl %r8d, %edi
decl %edi
cmpl %edi, %esi
jg 0x6f9a
movl 0x4(%rbx), %esi
movl 0x4(%rdx,%rcx), %edi
cmpl %esi, %edi
jg 0x6f9a
movl 0xc(%rdx,%rcx), %r8d
addl %r8d, %edi
decl %edi
cmpl %edi, %esi
jle 0x6fa4
addq $0x68, %rcx
jmp 0x6f61
xorl %eax, %eax
jmp 0x6fae
addq 0x22f65(%rip), %rcx     # 0x29f10
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/chase.c
// Function: diag_ok
bool diag_ok(struct coord *sp,struct coord *ep)
{
	if (ep->x == sp->x || ep->y == sp->y)
		return TRUE;
	if (step_ok(mvinch(ep->y,sp->x)) && step_ok(mvinch(sp->y,ep->x)))
		return TRUE;
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %edx
movb $0x1, %bl
cmpl %edx, (%rsi)
je 0x741b
movq %rsi, %r15
movq %rdi, %r12
movl 0x4(%rsi), %esi
cmpl 0x4(%rdi), %esi
je 0x741b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq 0x22b74(%rip), %r13     # 0x29f38
movq (%r13), %rdi
callq 0x6470
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x73e2
movq (%r13), %rdi
callq 0x6320
movl %eax, %edi
callq 0xb3d0
testb %al, %al
je 0x7419
movq (%r13), %rdi
movl 0x4(%r12), %esi
movl (%r15), %edx
callq 0x6470
cmpl $-0x1, %eax
je 0x740d
movq (%r13), %rdi
callq 0x6320
movl %eax, %r14d
movq %r14, %rdi
callq 0xb3d0
testb %al, %al
jne 0x741b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/chase.c
// Function: runto
int runto(struct coord *runner,struct coord *spot)
{
	struct linked_list *item;
	struct thing *tp;

	if ((item = find_mons(runner->y, runner->x)) == NULL)
		return 0;
	tp = THINGPTR(item);
	if (tp->t_flags & ISPARA)
		return 0;
	tp->t_dest = spot;
	tp->t_flags |= ISRUN;
	tp->t_flags &= ~ISHELD;
  return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edi
callq 0x745e
testq %rax, %rax
je 0x745a
movq 0x10(%rax), %rax
movq 0x78(%rax), %rcx
testb $0x2, %cl
jne 0x745a
movq %rbx, 0x60(%rax)
andq $-0x107, %rcx           # imm = 0xFEF9
orq $0x4, %rcx
movq %rcx, 0x78(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/command.c
// Function: quit
void quit(int a)
{
	char ch, good;
	/*
	 * Reset the signal in case we got here via an interrupt
	 */
	if (signal(SIGINT, quit) != quit)
		mpos = 0;
	msg("Really quit? [y/n/s]");
/*	ch = tolower(readchar());*/
	ch = readchar();
	if (ch == 'y') {
		clear();
		move(LINES-1, 0);
		refresh();
		score(purse, CHICKEN, 0);
		byebye(0);
	}
	else if (ch == 's') {
		good = save_game();
		if (good) {
			wclear(cw);
			draw(cw);
			endwin();
			byebye(0);
		}
	}
	else {
		signal(SIGINT, quit);
		wmove(cw, 0, 0);
		wclrtoeol(cw);
		draw(cw);
		mpos = 0;
		count = 0;
		nochange = FALSE;
	}
}

// Assembly:
pushq %rbx
leaq -0x8(%rip), %rbx        # 0x8083
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x6270
cmpq %rbx, %rax
je 0x80a5
leaq 0x257be(%rip), %rax     # 0x2d860
andl $0x0, (%rax)
leaq 0x1534e(%rip), %rdi     # 0x1d3fa
xorl %eax, %eax
callq 0xb178
xorl %eax, %eax
callq 0xb447
cmpb $0x73, %al
je 0x8107
movzbl %al, %eax
cmpl $0x79, %eax
jne 0x8138
movq 0x21e6b(%rip), %rbx     # 0x29f38
movq (%rbx), %rdi
callq 0x6120
movq (%rbx), %rdi
movq 0x21ee1(%rip), %rax     # 0x29fc0
movl (%rax), %esi
decl %esi
xorl %edx, %edx
callq 0x6470
movq (%rbx), %rdi
callq 0x6200
leaq 0x25763(%rip), %rax     # 0x2d85c
movl (%rax), %edi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x1222b
jmp 0x812e
xorl %eax, %eax
callq 0x13235
testb %al, %al
je 0x8188
leaq 0x288b7(%rip), %rbx     # 0x309d0
movq (%rbx), %rdi
callq 0x6120
movq (%rbx), %rdi
callq 0x6200
callq 0x6510
xorl %edi, %edi
xorl %eax, %eax
popq %rbx
jmp 0xbfec
leaq -0xbc(%rip), %rsi       # 0x8083
pushq $0x2
popq %rdi
callq 0x6270
leaq 0x28882(%rip), %rbx     # 0x309d0
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6470
movq (%rbx), %rdi
callq 0x6480
movq (%rbx), %rdi
callq 0x6200
leaq 0x256ef(%rip), %rax     # 0x2d860
andl $0x0, (%rax)
leaq 0x256f9(%rip), %rax     # 0x2d874
andl $0x0, (%rax)
leaq 0x2570e(%rip), %rax     # 0x2d893
movb $0x0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/command.c
// Function: d_level
int d_level()
{
	if (winat(hero.y, hero.x) != STAIRS)
		msg("I see no way down.");
	else {
		if (pl_on(ISHELD)) {
			msg("You are being held.");
			return 0;
		}
		level++;
		new_level(NORMLEV);
	}
  return 0;
}

// Assembly:
pushq %rax
leaq 0x2572c(%rip), %rax     # 0x2dc50
movl 0x50(%rax), %esi
movl 0x54(%rax), %edi
callq 0x92ab
cmpb $0x25, %al
jne 0x854a
movl $0x100, %edi            # imm = 0x100
callq 0x932c
testb %al, %al
je 0x855a
leaq 0x1502d(%rip), %rdi     # 0x1d575
jmp 0x8551
leaq 0x15011(%rip), %rdi     # 0x1d562
xorl %eax, %eax
callq 0xb178
jmp 0x856a
leaq 0x21d7f(%rip), %rax     # 0x2a2e0
incl (%rax)
xorl %edi, %edi
callq 0xeb48
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/command.c
// Function: u_level
int u_level()
{
	if (winat(hero.y, hero.x) == STAIRS)  {
		if (pl_on(ISHELD)) {
			msg("You are being held.");
			return 0;
		}
		else {				/* player not held here */
			if (amulet) {
				level--;
				if (level == 0)
					total_winner();
				new_level(NORMLEV);
				msg("You feel a wrenching sensation in your gut.");
				return 0;
			}
		}
	}
	msg("I see no way up.");
  return 0;
}

// Assembly:
pushq %rbx
leaq 0x256da(%rip), %rax     # 0x2dc50
movl 0x50(%rax), %esi
movl 0x54(%rax), %edi
callq 0x92ab
leaq 0x1502d(%rip), %rbx     # 0x1d5b5
cmpb $0x25, %al
jne 0x85cf
movl $0x100, %edi            # imm = 0x100
callq 0x932c
testb %al, %al
je 0x85a3
leaq 0x14fd4(%rip), %rbx     # 0x1d575
jmp 0x85cf
leaq 0x252e7(%rip), %rax     # 0x2d891
cmpb $0x1, (%rax)
jne 0x85cf
leaq 0x21d2a(%rip), %rax     # 0x2a2e0
decl (%rax)
jne 0x85c1
xorl %eax, %eax
callq 0x12a86
xorl %edi, %edi
callq 0xeb48
leaq 0x14fba(%rip), %rbx     # 0x1d589
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb178
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/command.c
// Function: call
int call()
{
	struct object *obj;
	struct linked_list *item;
	char **guess, *elsewise;
	int wh;

	if ((item = get_item("call", 0)) == NULL)
		return 0;
	obj = OBJPTR(item);
	wh = obj->o_which;
	switch (obj->o_type) {
	case RING:
		guess = r_guess;
		elsewise = (r_guess[wh] != NULL ? r_guess[wh] : r_stones[wh]);
	when POTION:
		guess = p_guess;
		elsewise = (p_guess[wh] != NULL ? p_guess[wh] : p_colors[wh]);
	when SCROLL:
		guess = s_guess;
		elsewise = (s_guess[wh] != NULL ? s_guess[wh] : s_names[wh]);
	when STICK:
		guess = ws_guess;
		elsewise =(ws_guess[wh] != NULL ?
			ws_guess[wh] : ws_stuff[wh].ws_made);
	otherwise:
		msg("You can't call %ss anything",obj->o_typname);
		return 0;
	}
	msg("Was called \"%s\"", elsewise);
	msg(callit);
	if (guess[wh] != NULL)
		free(guess[wh]);
	strcpy(prbuf, elsewise);
	if (get_str(prbuf, cw) == NORM) {
		guess[wh] = new(strlen(prbuf) + 1);
		strcpy(guess[wh], prbuf);
	}
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x14e7b(%rip), %rdi     # 0x1d5eb
xorl %esi, %esi
callq 0xfd08
testq %rax, %rax
je 0x88d8
movq 0x10(%rax), %rax
movslq 0x28(%rax), %r15
movl 0x20(%rax), %ecx
cmpl $0x21, %ecx
je 0x8825
cmpl $0x2f, %ecx
je 0x87d2
cmpl $0x3f, %ecx
je 0x87fd
cmpl $0x3d, %ecx
jne 0x88c6
leaq 0x27a82(%rip), %r12     # 0x30230
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x884e
movq %r15, %rax
shlq $0x3, %rax
addq 0x2171f(%rip), %rax     # 0x29ee8
leaq 0x27a60(%rip), %r12     # 0x30230
jmp 0x884b
leaq 0x27b27(%rip), %r12     # 0x30300
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x884e
imulq $0x18, %r15, %rax
leaq 0x27f73(%rip), %rcx     # 0x30760
addq %rcx, %rax
addq $0x8, %rax
leaq 0x27b05(%rip), %r12     # 0x30300
jmp 0x884b
leaq 0x278ac(%rip), %r12     # 0x300b0
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x884e
leaq (,%r15,8), %rax
addq 0x217ac(%rip), %rax     # 0x29fc8
leaq 0x2788d(%rip), %r12     # 0x300b0
jmp 0x884b
leaq 0x27954(%rip), %r12     # 0x30180
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x884e
leaq (,%r15,8), %rax
addq 0x2169c(%rip), %rax     # 0x29ee0
leaq 0x27935(%rip), %r12     # 0x30180
movq (%rax), %rbx
leaq 0x14db7(%rip), %rdi     # 0x1d60c
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb178
leaq 0x21b20(%rip), %rdi     # 0x2a386
xorl %eax, %eax
callq 0xb178
movq (%r12,%r15,8), %rdi
callq 0x6050
leaq 0x25603(%rip), %r14     # 0x2de80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60e0
leaq 0x28141(%rip), %rax     # 0x309d0
movq (%rax), %rsi
movq %r14, %rdi
callq 0xf37e
testl %eax, %eax
jne 0x88d8
leaq 0x255db(%rip), %rbx     # 0x2de80
movq %rbx, %rdi
callq 0x6170
leal 0x1(%rax), %edi
callq 0xb8a5
movq %rax, (%r12,%r15,8)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x60e0
jmp 0x88d8
movq 0x18(%rax), %rsi
leaq 0x14d1f(%rip), %rdi     # 0x1d5f0
xorl %eax, %eax
callq 0xb178
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: d_insert
struct delayed_action *d_insert(int (*func)(),int arg,int type,int time)
{
	struct delayed_action *dev;

	if (demoncnt < MAXDAEMONS) {
		dev = &d_list[demoncnt];
		dev->d_type = type;
		dev->d_time = time;
		dev->d_func = func;
		dev->d_arg = arg;
		demoncnt += 1;
		return dev;
	}
	return NULL;
}

// Assembly:
leaq 0x24f7d(%rip), %r8      # 0x2d86c
movslq (%r8), %r9
cmpq $0x13, %r9
jg 0x8922
imulq $0x18, %r9, %r10
leaq 0x24ced(%rip), %r11     # 0x2d5f0
leaq (%r11,%r10), %rax
movl %edx, (%r10,%r11)
movl %ecx, 0x14(%r10,%r11)
movq %rdi, 0x8(%r10,%r11)
movl %esi, 0x10(%r10,%r11)
leal 0x1(%r9), %ecx
movl %ecx, (%r8)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: d_delete
int d_delete(struct delayed_action *wire)
{
	struct delayed_action *d1, *d2;

	for (d1 = d_list; d1 < &d_list[demoncnt]; d1++) {
		if (wire == d1) {
			for (d2 = d1 + 1; d2 < &d_list[demoncnt]; d2++)
				*d1++ = *d2;
			demoncnt -= 1;
			d1 = &d_list[demoncnt];
			d1->d_type = EMPTY;
			d1->d_func = EMPTY;
			return 0;
		}
	}
  return 0;
}

// Assembly:
leaq 0x24f40(%rip), %rax     # 0x2d86c
movslq (%rax), %rcx
imulq $0x18, %rcx, %rdx
leaq 0x24cb6(%rip), %rsi     # 0x2d5f0
addq %rsi, %rdx
cmpq %rdx, %rsi
jae 0x8982
cmpq %rdi, %rsi
je 0x895f
addq $0x18, %rsi
jmp 0x893d
leaq -0x18(%rsi), %rdi
movq 0x10(%rsi), %r8
movq %r8, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
addq $0x18, %rsi
cmpq %rdx, %rsi
jb 0x894d
decq %rcx
imulq $0x18, %rcx, %rdx
leaq 0x24c7a(%rip), %rsi     # 0x2d5f0
andl $0x0, (%rdx,%rsi)
movl %ecx, (%rax)
andq $0x0, 0x8(%rdx,%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: do_daemons
void do_daemons(int flag)
{
	struct delayed_action *dev;

	for (dev = d_list; dev < &d_list[demoncnt]; dev++)
		if (dev->d_type == flag && dev->d_time == DAEMON)
			(*dev->d_func)(dev->d_arg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x24e71(%rip), %r14     # 0x2d86c
movl (%r14), %eax
leaq 0x24beb(%rip), %r15     # 0x2d5f0
movq %r15, %r12
movslq %eax, %rcx
imulq $0x18, %rcx, %rcx
addq %r15, %rcx
cmpq %rcx, %r12
jae 0x8a3a
cmpl %ebx, (%r12)
jne 0x8a34
cmpl $-0x1, 0x14(%r12)
jne 0x8a34
movl 0x10(%r12), %edi
xorl %eax, %eax
callq *0x8(%r12)
movl (%r14), %eax
addq $0x18, %r12
jmp 0x8a08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: lengthen
void lengthen(int (*func)(),int xtime)
{
	struct delayed_action *wire;

	for (wire = d_list; wire < &d_list[demoncnt]; wire++)
		if (wire->d_type != EMPTY && func == wire->d_func)
			wire->d_time += xtime;
}

// Assembly:
leaq 0x24de8(%rip), %rax     # 0x2d86c
movslq (%rax), %rax
imulq $0x18, %rax, %rax
leaq 0x24b5e(%rip), %rcx     # 0x2d5f0
addq %rcx, %rax
cmpq %rax, %rcx
jae 0x8aae
cmpl $0x0, (%rcx)
je 0x8aa8
cmpq %rdi, 0x8(%rcx)
jne 0x8aa8
addl %esi, 0x14(%rcx)
addq $0x18, %rcx
jmp 0x8a95
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: extinguish
void extinguish(int (*func)())
{
	struct delayed_action *dev;

	for (dev = d_list; dev < &d_list[demoncnt]; dev++)
		if (dev->d_type != EMPTY && func == dev->d_func)
			d_delete(dev);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24dab(%rip), %r15     # 0x2d86c
movl (%r15), %eax
leaq 0x24b25(%rip), %r12     # 0x2d5f0
movq %r12, %r14
movslq %eax, %rcx
imulq $0x18, %rcx, %rcx
addq %r12, %rcx
cmpq %rcx, %r14
jae 0x8afa
cmpl $0x0, (%r14)
je 0x8af4
cmpq %rbx, 0x8(%r14)
jne 0x8af4
movq %r14, %rdi
callq 0x8925
movl (%r15), %eax
addq $0x18, %r14
jmp 0x8ace
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemon.c
// Function: do_fuses
void do_fuses()
{
	struct delayed_action *dev;

	for (dev = d_list; dev < &d_list[demoncnt]; dev++) {
		if (dev->d_type == AFTER && dev->d_time > DAEMON) {
			if (--dev->d_time == 0) {
				(*dev->d_func)(dev->d_arg);
				d_delete(dev);
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x24d5a(%rip), %r14     # 0x2d86c
movl (%r14), %eax
leaq 0x24ad4(%rip), %r15     # 0x2d5f0
movq %r15, %rbx
movslq %eax, %rcx
imulq $0x18, %rcx, %rcx
addq %r15, %rcx
cmpq %rcx, %rbx
jae 0x8b5a
cmpl $0x2, (%rbx)
jne 0x8b54
movl 0x14(%rbx), %ecx
testl %ecx, %ecx
js 0x8b54
decl %ecx
movl %ecx, 0x14(%rbx)
jne 0x8b54
movl 0x10(%rbx), %edi
xorl %eax, %eax
callq *0x8(%rbx)
movq %rbx, %rdi
callq 0x8925
movl (%r14), %eax
addq $0x18, %rbx
jmp 0x8b1f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: doctor
int doctor(int fromfuse)
{
	int *thp, lv, ohp, ccon;

	lv = him->s_lvl;
	thp = &him->s_hpt;
	ohp = *thp;
	quiet += 1;

	ccon = him->s_ef.a_con;
	if (ccon > 16 && !isfight)
		*thp += rnd(ccon - 15);
	if (lv < 8) {
		if (quiet > 20 - lv * 2)
			*thp += 1;
	}
	else {
		if (quiet >= 3)
			*thp += rnd(lv - 7) + 1;
	}
	if (isring(LEFT, R_REGEN))
		*thp += 1;
	if (isring(RIGHT, R_REGEN))
		*thp += 1;
	if (pl_on(ISREGEN))
		*thp += 1;
	if (ohp != *thp) {
		nochange = FALSE;
		if (*thp > him->s_maxhp)
			*thp = him->s_maxhp;
		quiet = 0;
	}
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x251c1(%rip), %r12     # 0x2dd50
movq (%r12), %r14
movl 0x28(%r14), %ebx
movl 0x30(%r14), %ebp
leaq 0x24cda(%rip), %r15     # 0x2d87c
incl (%r15)
movl 0x1c(%r14), %edi
movl %ebp, %eax
cmpl $0x11, %edi
jl 0x8bd0
leaq 0x24cd1(%rip), %rax     # 0x2d888
cmpb $0x0, (%rax)
movl %ebp, %eax
jne 0x8bd0
addl $-0xf, %edi
xorl %eax, %eax
callq 0xc004
addl 0x30(%r14), %eax
movl %eax, 0x30(%r14)
movl (%r15), %ecx
cmpl $0x7, %ebx
jg 0x8be7
addl %ebx, %ebx
pushq $0x14
popq %rdx
subl %ebx, %edx
cmpl %edx, %ecx
jle 0x8c04
incl %eax
jmp 0x8c00
cmpl $0x3, %ecx
jl 0x8c04
addl $-0x7, %ebx
movl %ebx, %edi
xorl %eax, %eax
callq 0xc004
movl 0x30(%r14), %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x30(%r14)
pushq $0x9
popq %rsi
xorl %edi, %edi
callq 0x11f88
testb %al, %al
je 0x8c16
incl 0x30(%r14)
pushq $0x1
popq %rdi
pushq $0x9
popq %rsi
callq 0x11f88
testb %al, %al
je 0x8c29
incl 0x30(%r14)
movl $0x400, %edi            # imm = 0x400
callq 0x932c
movl 0x30(%r14), %ecx
testb %al, %al
je 0x8c41
incl %ecx
movl %ecx, 0x30(%r14)
cmpl %ecx, %ebp
je 0x8c62
leaq 0x24c47(%rip), %rax     # 0x2d893
movb $0x0, (%rax)
movq (%r12), %rax
movl 0x34(%rax), %eax
cmpl %eax, %ecx
jle 0x8c5e
movl %eax, 0x30(%r14)
andl $0x0, (%r15)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: rollwand
int rollwand(int fromfuse)
{

	if (++between >= 4) {
		if (roll(1, 6) == 4) {
			if (levtype != POSTLEV)		/* no monsters for posts */
				wanderer();
			extinguish(rollwand);
			fuse(swander, TRUE, WANDERTIME);
		}
		between = 0;
	}
  return 0;
}

// Assembly:
movl 0x24b47(%rip), %eax     # 0x2d7d0
leal 0x1(%rax), %ecx
movl %ecx, 0x24b3e(%rip)     # 0x2d7d0
cmpl $0x3, %eax
jl 0x8ce4
pushq %rax
pushq $0x1
popq %rdi
pushq $0x6
popq %rsi
callq 0xc025
cmpl $0x4, %eax
jne 0x8cd9
leaq 0x24ba5(%rip), %rax     # 0x2d854
cmpl $0x1, (%rax)
je 0x8cbb
xorl %eax, %eax
callq 0xd0c1
leaq -0x3f(%rip), %rdi       # 0x8c83
callq 0x8aaf
leaq -0x61(%rip), %rdi       # 0x8c6d
pushq $0x1
popq %rsi
pushq $0x46
popq %rdx
callq 0x8a46
andl $0x0, 0x24af0(%rip)     # 0x2d7d0
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: unconfuse
int unconfuse(int fromfuse)
{
	if (pl_on(ISHUH))
		msg("You feel less confused now.");
	player.t_flags &= ~ISHUH;
  return 0;
}

// Assembly:
pushq %rax
movl $0x200, %edi            # imm = 0x200
callq 0x932c
testb %al, %al
je 0x8d04
leaq 0x14940(%rip), %rdi     # 0x1d63d
xorl %eax, %eax
callq 0xb178
leaq 0x24f45(%rip), %rax     # 0x2dc50
andb $-0x3, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: sight
int sight(int fromfuse)
{
	if (pl_on(ISBLIND))
		msg("The veil of darkness lifts.");
	player.t_flags &= ~ISBLIND;
	light(&hero);
  return 0;
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
callq 0x932c
testb %al, %al
je 0x8d3c
leaq 0x14924(%rip), %rdi     # 0x1d659
xorl %eax, %eax
callq 0xb178
leaq 0x24f0d(%rip), %rdi     # 0x2dc50
andb $-0x2, 0x78(%rdi)
addq $0x50, %rdi
callq 0xe29f
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: nohaste
int nohaste(int fromfuse)
{
	if (pl_on(ISHASTE))
		msg("You feel yourself slowing down.");
	player.t_flags &= ~ISHASTE;
  return 0;
}

// Assembly:
pushq %rax
movl $0x8000, %edi           # imm = 0x8000
callq 0x932c
testb %al, %al
je 0x8d71
leaq 0x1490b(%rip), %rdi     # 0x1d675
xorl %eax, %eax
callq 0xb178
leaq 0x24ed8(%rip), %rax     # 0x2dc50
andb $0x7f, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: stomach
int stomach(int fromfuse)
{
	int oldfood, old_hunger;

	old_hunger = hungry_state;
	if (food_left <= 0) {		 /* the hero is fainting */
		if (--food_left == -150) {
			msg("Your stomach writhes with hunger pains.");
		}
		else if (food_left < -350) {
			msg("You starve to death !!");
			msg(" ");
			death(K_STARVE);
		}
		if (player.t_nocmd > 0 || rnd(100) > 20)
			return 0;
		player.t_nocmd = rnd(8)+4;
		msg("You faint.");
		running = FALSE;
		count = 0;
		hungry_state = F_FAINT;
	}
	else {
		oldfood = food_left;
		food_left -= ringfood + foodlev - amulet;
		if (player.t_nocmd > 0)		/* wait till he can move */
			return 0;
		if (food_left < WEAKTIME && oldfood >= WEAKTIME) {
			msg("You are starting to feel weak.");
			hungry_state = F_WEAK;
		}
		else if(food_left < HUNGTIME && oldfood >= HUNGTIME) {
			msg("Getting hungry.");
			hungry_state = F_HUNGRY;
		}
	}
	if (old_hunger != hungry_state)
	    updpack();				/* new pack weight */
	wghtchk(FALSE);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x24af4(%rip), %r14     # 0x2d880
movl (%r14), %ebx
leaq 0x2155a(%rip), %rdx     # 0x2a2f0
movl (%rdx), %eax
testl %eax, %eax
jle 0x8e00
leaq 0x24ae1(%rip), %rcx     # 0x2d884
movl (%rcx), %esi
leaq 0x2154c(%rip), %rcx     # 0x2a2f8
leaq 0x24ade(%rip), %rdi     # 0x2d891
addl (%rcx), %esi
movzbl (%rdi), %edi
movl %eax, %ecx
subl %esi, %ecx
addl %edi, %ecx
movl %ecx, (%rdx)
leaq 0x24e89(%rip), %rdx     # 0x2dc50
cmpl $0x0, 0x88(%rdx)
jg 0x8ed7
cmpl $0x96, %eax
jb 0x8ea2
cmpl $0x95, %ecx
jg 0x8ea2
leaq 0x148ed(%rip), %rdi     # 0x1d6df
xorl %eax, %eax
callq 0xb178
pushq $0x2
jmp 0x8ec1
leal -0x1(%rax), %ecx
movl %ecx, (%rdx)
cmpl $0xffffff6a, %ecx       # imm = 0xFFFFFF6A
jne 0x8e1d
leaq 0x14881(%rip), %rdi     # 0x1d695
xorl %eax, %eax
callq 0xb178
jmp 0x8e48
cmpl $0xfffffea2, %eax       # imm = 0xFFFFFEA2
jg 0x8e48
leaq 0x14892(%rip), %rdi     # 0x1d6bd
xorl %eax, %eax
callq 0xb178
leaq 0x163c7(%rip), %rdi     # 0x1f200
xorl %eax, %eax
callq 0xb178
pushq $-0x9
popq %rdi
callq 0x11fd0
leaq 0x24e01(%rip), %r15     # 0x2dc50
cmpl $0x0, 0x88(%r15)
jg 0x8ed7
pushq $0x64
popq %rdi
xorl %eax, %eax
callq 0xc004
cmpl $0x14, %eax
jg 0x8ed7
pushq $0x8
popq %rdi
xorl %eax, %eax
callq 0xc004
addl $0x4, %eax
movl %eax, 0x88(%r15)
leaq 0x14851(%rip), %rdi     # 0x1d6d4
xorl %eax, %eax
callq 0xb178
leaq 0x249fb(%rip), %rax     # 0x2d88c
movb $0x0, (%rax)
leaq 0x249d9(%rip), %rax     # 0x2d874
andl $0x0, (%rax)
pushq $0x3
jmp 0x8ec1
cmpl $0x12c, %eax            # imm = 0x12C
jb 0x8ed0
cmpl $0x12b, %ecx            # imm = 0x12B
jg 0x8ed0
leaq 0x14846(%rip), %rdi     # 0x1d6fe
xorl %eax, %eax
callq 0xb178
pushq $0x1
popq %rax
movl %eax, (%r14)
cmpl %eax, %ebx
je 0x8ed0
xorl %eax, %eax
callq 0x9378
xorl %edi, %edi
callq 0x963f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: noteth
int noteth(int fromfuse)
{
	int ch;

	if (pl_on(ISETHER)) {
		msg("You begin to feel more corporeal.");
		ch = player.t_oldch;
		if (dead_end(ch)) {
			msg("You materialize in %s.",identify(ch));
			msg(" ");
			death(K_STONE);	/* can't materialize in walls */
		}
	}
	player.t_flags &= ~ISETHER;
  return 0;
}

// Assembly:
pushq %rbx
movl $0x10000, %edi          # imm = 0x10000
callq 0x932c
testb %al, %al
je 0x8f43
leaq 0x14819(%rip), %rdi     # 0x1d70e
xorl %eax, %eax
callq 0xb178
leaq 0x24d4d(%rip), %rax     # 0x2dc50
movsbl 0x8f(%rax), %ebx
movl %ebx, %edi
callq 0xb415
testb %al, %al
je 0x8f43
movl %ebx, %edi
callq 0x7e63
leaq 0x1480d(%rip), %rdi     # 0x1d730
movq %rax, %rsi
xorl %eax, %eax
callq 0xb178
leaq 0x162cc(%rip), %rdi     # 0x1f200
xorl %eax, %eax
callq 0xb178
pushq $-0xa
popq %rdi
callq 0x11fd0
leaq 0x24d06(%rip), %rax     # 0x2dc50
andb $-0x2, 0x7a(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: sapem
int sapem(int fromfuse)
{
	chg_abil(rnd(4) + 1, -1, TRUE);
	fuse(sapem, TRUE, 150);
	nochange = FALSE;
  return 0;
}

// Assembly:
pushq %rbx
pushq $0x4
popq %rdi
xorl %eax, %eax
callq 0xc004
leal 0x1(%rax), %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x111a5
leaq -0x22(%rip), %rdi       # 0x8f52
movl %ebx, %esi
movl $0x96, %edx
callq 0x8a46
leaq 0x2490c(%rip), %rax     # 0x2d893
movb $0x0, (%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: notslow
int notslow(int fromfuse)
{
	if (pl_on(ISSLOW))
		msg("You no longer feel hindered.");
	player.t_flags &= ~ISSLOW;
  return 0;
}

// Assembly:
pushq %rax
movl $0x4000, %edi           # imm = 0x4000
callq 0x932c
testb %al, %al
je 0x8fab
leaq 0x147a3(%rip), %rdi     # 0x1d747
xorl %eax, %eax
callq 0xb178
leaq 0x24c9e(%rip), %rax     # 0x2dc50
andb $-0x41, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/daemons.c
// Function: notregen
int notregen(int fromfuse)
{
	if (pl_on(ISREGEN))
		msg("You no longer feel bolstered.");
	player.t_flags &= ~ISREGEN;
  return 0;
}

// Assembly:
pushq %rax
movl $0x400, %edi            # imm = 0x400
callq 0x932c
testb %al, %al
je 0x8fd7
leaq 0x14794(%rip), %rdi     # 0x1d764
xorl %eax, %eax
callq 0xb178
leaq 0x24c72(%rip), %rax     # 0x2dc50
andb $-0x5, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x8
popq %rdi
callq 0x932c
testb %al, %al
je 0x9001
leaq 0x14788(%rip), %rdi     # 0x1d782
xorl %eax, %eax
callq 0xb178
leaq 0x24c48(%rip), %rax     # 0x2dc50
andb $-0x9, 0x78(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0x245e3(%rip), %r14     # 0x2d830
leaq 0x2777c(%rip), %rbx     # 0x309d0
movq (%r14), %r14
testq %r14, %r14
je 0x929e
movq 0x10(%r14), %r15
movl 0x50(%r15), %edx
movl 0x54(%r15), %esi
movq (%rbx), %rdi
callq 0x6470
cmpl $-0x1, %eax
je 0x9285
movq (%rbx), %rdi
movsbl 0x8d(%r15), %esi
callq 0x64a0
orb $0x8, 0x78(%r15)
cmpb $0x4d, 0x8d(%r15)
jne 0x9254
movb $0x4d, 0x8e(%r15)
jmp 0x9254
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6200
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x27726(%rip), %r14     # 0x309e0
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6470
cmpl $-0x1, %eax
je 0x92f7
leaq 0x2770e(%rip), %r14     # 0x309e0
movq (%r14), %rdi
callq 0x6320
cmpl $0x20, %eax
jne 0x92f7
movq 0x20c52(%rip), %r14     # 0x29f38
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6470
cmpl $-0x1, %eax
je 0x9304
movq (%r14), %rdi
callq 0x6320
popq %rbx
popq %r14
popq %rbp
retq
movb $-0x1, %al
jmp 0x92ff
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/disply.c
// Function: o_off
bool o_off(struct object *what,long bit)
{
	int flag;

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

// Assembly:
testq %rdi, %rdi
je 0x9369
movslq 0x38(%rdi), %rax
testq %rsi, %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x9606
leaq 0x249c8(%rip), %r14     # 0x2dd50
movq (%r14), %rcx
movl %eax, 0x3c(%rcx)
callq 0x940b
movl %eax, %ebx
movq (%r14), %rax
movl 0x3c(%rax), %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
leal (,%rax,4), %ecx
cmpl %ecx, %ebx
jle 0x93bf
pushq $0x64
popq %rdi
xorl %eax, %eax
callq 0xc004
cmpl $0x50, %eax
jge 0x93e5
pushq $0x3
jmp 0x93db
leal (%rax,%rax,2), %eax
cmpl %eax, %ebx
jle 0x93d9
pushq $0x64
popq %rdi
xorl %eax, %eax
callq 0xc004
cmpl $0x3b, %eax
jg 0x93e5
pushq $0x2
jmp 0x93db
pushq $0x1
popq %rax
leaq 0x20f15(%rip), %rcx     # 0x2a2f8
movl %eax, (%rcx)
movq (%r14), %rax
movl %ebx, 0x38(%rax)
callq 0x950d
leaq 0x2446d(%rip), %rcx     # 0x2d864
movl %eax, (%rcx)
leaq 0x24493(%rip), %rax     # 0x2d893
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x24836(%rip), %r15     # 0x2dc50
addq $0x68, %r15
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x943d
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x948c
imull 0x24(%r14), %eax
addl %eax, %ebx
jmp 0x9420
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x248f3(%rip), %r12     # 0x2dd40
pushq $0x20
popq %r14
cmpq $0x2, %r15
je 0x947e
movq (%r12,%r15,8), %rdi
testq %rdi, %rdi
je 0x9479
cmpl $0x15, 0x20(%rdi)
jne 0x9479
movq %r14, %rsi
callq 0x9359
testb %al, %al
je 0x9479
movl %ebx, %eax
shrl $0x2, %eax
addl %eax, %ebx
incq %r15
jmp 0x9451
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x20(%rdi), %eax
movl 0x40(%rdi), %ebx
cmpl $0x29, %eax
je 0x94bd
cmpl $0x5d, %eax
jne 0x94d1
movslq 0x28(%r14), %rax
imulq $0xc, %rax, %rax
leaq 0x22a4e(%rip), %rcx     # 0x2bf00
movl (%rcx,%rax), %eax
cmpl 0x34(%r14), %eax
jg 0x94c7
jmp 0x94d1
movl 0x30(%r14), %eax
addl 0x2c(%r14), %eax
jle 0x94d1
pushq $0x2
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
movl %eax, %ebx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x934a
testb %al, %al
je 0x94ea
pushq $0x5
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
addl %eax, %ebx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x934a
testb %al, %al
je 0x9503
pushq $-0x5
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x24738(%rip), %r14     # 0x2dc50
addq $0x68, %r14
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x9533
movq 0x10(%r14), %rdi
callq 0x953d
addl %eax, %ebx
jmp 0x951e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl 0x20(%rdi), %edi
callq 0xc2af
movl %eax, %ebp
movl 0x20(%rbx), %ecx
cmpl $0x29, %ecx
je 0x95a5
cmpl $0x2f, %ecx
je 0x9577
xorl %eax, %eax
cmpl $0x5d, %ecx
jne 0x95b8
movslq 0x28(%rbx), %rax
imulq $0xc, %rax, %rax
leaq 0x2298f(%rip), %rcx     # 0x2bf00
movl 0x8(%rcx,%rax), %eax
jmp 0x95b8
movslq 0x28(%rbx), %rax
imulq $0x18, %rax, %rax
leaq 0x271da(%rip), %rcx     # 0x30760
movq (%rcx,%rax), %rdi
leaq 0x148ae(%rip), %rsi     # 0x1de3f
callq 0x6240
testl %eax, %eax
movl $0xc8, %ecx
pushq $0x6e
popq %rax
cmovel %ecx, %eax
jmp 0x95b8
movslq 0x28(%rbx), %rax
shlq $0x5, %rax
leaq 0x22afc(%rip), %rcx     # 0x2c0b0
movl 0x18(%rcx,%rax), %eax
movslq %ebp, %rcx
imulq $0x18, %rcx, %rcx
leaq 0x2339a(%rip), %rdx     # 0x2c960
addl 0x4(%rdx,%rcx), %eax
imull 0x24(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x95d5
movl %eax, %ecx
addl $0x5dc, %ecx            # imm = 0x5DC
leaq 0x24265(%rip), %rax     # 0x2d880
movl (%rax), %eax
cmpl $0x3, %eax
je 0x9639
cmpl $0x2, %eax
jne 0x963b
movw $0xa, %si
movl %ecx, %eax
xorl %edx, %edx
divw %si
movzwl %ax, %eax
subl %eax, %ecx
jmp 0x963b
shrl %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2423e(%rip), %rbx     # 0x2d88b
movb $0x1, (%rbx)
leaq 0x246f9(%rip), %rax     # 0x2dd50
movq (%rax), %rax
movl 0x38(%rax), %ecx
cmpl 0x3c(%rax), %ecx
jle 0x96a3
leaq 0x245e7(%rip), %rax     # 0x2dc50
movzbl 0x8f(%rax), %ebp
leaq -0x38(%rip), %rdi       # 0x963f
callq 0x8aaf
cmpl $0x2e, %ebp
je 0x9686
cmpl $0x23, %ebp
jne 0x9692
leaq 0x241fb(%rip), %rax     # 0x2d888
cmpb $0x0, (%rax)
je 0x96b3
leaq -0x5a(%rip), %rdi       # 0x963f
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x8a46
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x140e7(%rip), %rdi     # 0x1d7a1
leaq 0x2419f(%rip), %r14     # 0x2d860
leaq 0x140f9(%rip), %r15     # 0x1d7c1
xorl %eax, %eax
callq 0xb178
xorl %edi, %edi
callq 0x1999e
testb %al, %al
jne 0x96a3
andl $0x0, (%r14)
movq %r15, %rdi
jmp 0x96c8
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/fight.c
// Function: prname
char *prname(char *who,bool upper)
{
static char tbuf[LINLEN];

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movb $0x0, 0x2383f(%rip)     # 0x2d7e0
testq %rdi, %rdi
je 0x9fc7
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x932c
testb %al, %al
je 0x9fd3
movb $0x0, 0x23826(%rip)     # 0x2d7e2
movw $0x7469, 0x2381b(%rip)  # imm = 0x7469
jmp 0x9ff3
movl $0x756f79, 0x2380f(%rip) # imm = 0x756F79
jmp 0x9ff3
movb $0x0, 0x2380a(%rip)     # 0x2d7e4
movl $0x20656874, 0x237fc(%rip) # imm = 0x20656874
leaq 0x237f5(%rip), %rdi     # 0x2d7e0
movq %r14, %rsi
callq 0x64b0
testb %bl, %bl
je 0xa010
callq 0x6030
movq (%rax), %rax
movsbq 0x237d9(%rip), %rcx     # 0x2d7e0
movb (%rax,%rcx,4), %al
movb %al, 0x237d0(%rip)      # 0x2d7e0
leaq 0x237c9(%rip), %rax     # 0x2d7e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/fight.c
// Function: remove_monster
void remove_monster(struct coord *mp,struct linked_list *item)
{
	char what;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2608d(%rip), %r15     # 0x309e0
movq (%r15), %rdi
movl (%r14), %edx
movl 0x4(%r14), %esi
callq 0x6470
cmpl $-0x1, %eax
je 0xa972
movq (%r15), %rdi
pushq $0x20
popq %rsi
callq 0x64a0
pushq $0x1
popq %rdi
callq 0x932c
testb %al, %al
je 0xa983
pushq $0x20
popq %rbp
jmp 0xa98e
movq 0x10(%rbx), %rax
movsbl 0x8f(%rax), %ebp
leaq 0x2603b(%rip), %r15     # 0x309d0
movq (%r15), %rdi
movl (%r14), %edx
movl 0x4(%r14), %esi
callq 0x6470
cmpl $-0x1, %eax
je 0xa9b3
movq (%r15), %rdi
movl %ebp, %esi
callq 0x64a0
leaq 0x22e76(%rip), %rdi     # 0x2d830
movq %rbx, %rsi
callq 0xb7f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb857
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2333f(%rip), %r15     # 0x2dd50
movq (%r15), %rax
xorl %r14d, %r14d
leaq 0x22002(%rip), %rcx     # 0x2ca20
movq (%rcx,%r14,8), %rdx
testq %rdx, %rdx
je 0xaa32
cmpq 0x20(%rax), %rdx
jg 0xaa32
incq %r14
jmp 0xaa1e
leaq 0x1(%r14), %rbx
movl 0x28(%rax), %ecx
cmpl %r14d, %ecx
jg 0xaa88
subl %ecx, %r14d
incl %r14d
pushq $0xa
popq %rsi
movl %r14d, %edi
callq 0xc025
movl %eax, %ebp
movq (%r15), %rdi
callq 0x113d6
imull %r14d, %eax
addl %ebp, %eax
movq (%r15), %rcx
movl 0x34(%rcx), %edx
addl %eax, %edx
movl %edx, 0x34(%rcx)
addl 0x30(%rcx), %eax
cmpl %edx, %eax
cmovgel %edx, %eax
movl %eax, 0x30(%rcx)
leaq 0x13026(%rip), %rdi     # 0x1daa2
movl %ebx, %esi
xorl %eax, %eax
callq 0xb178
movq (%r15), %rax
movl %ebx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x3
popq %rax
movb (%rdi), %cl
subl $0x1, %eax
jb 0xaaad
xorl %edx, %edx
cmpb %sil, %cl
setne %dl
addq %rdx, %rdi
jmp 0xaa99
xorl %eax, %eax
cmpb %sil, %cl
cmoveq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ajpaulson[P]srogue11/init.c
// Function: init_things
void init_things()
{
	struct magic_item *mi;
	
	/*
	 * init general things
	 */
	for (mi = &things[1]; mi < &things[NUMTHINGS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("things", things);
	/*
	 * init armor things
	 */
	for (mi = &a_magic[1]; mi < &a_magic[MAXARMORS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("armor", a_magic);
	/*
	 * init weapon stuff
	 */
	for (mi = &w_magic[1]; mi < &w_magic[MAXWEAPONS]; mi++)
		mi->mi_prob += (mi-1)->mi_prob;
	badcheck("weapon", w_magic);
}

// Assembly:
pushq %rax
leaq 0x2125c(%rip), %rax     # 0x2bdc0
leaq 0x10(%rax), %rcx
subq $-0x80, %rax
cmpq %rax, %rcx
jae 0xab7d
movl -0x8(%rcx), %edx
addl %edx, 0x8(%rcx)
addq $0x10, %rcx
jmp 0xab6c
leaq 0x13ec8(%rip), %rdi     # 0x1ea4c
leaq 0x21235(%rip), %rsi     # 0x2bdc0
callq 0xac07
leaq 0x212b9(%rip), %rax     # 0x2be50
addq $0x10, %rax
movl $0xa0, %ecx
addq 0x1f3f1(%rip), %rcx     # 0x29f98
cmpq %rcx, %rax
jae 0xabb8
movl -0x8(%rax), %edx
addl %edx, 0x8(%rax)
addq $0x10, %rax
jmp 0xaba7
leaq 0x1343b(%rip), %rdi     # 0x1dffa
leaq 0x2128a(%rip), %rsi     # 0x2be50
callq 0xac07
leaq 0x213ae(%rip), %rax     # 0x2bf80
addq $0x10, %rax
movl $0x120, %ecx            # imm = 0x120
addq 0x1f346(%rip), %rcx     # 0x29f28
cmpq %rcx, %rax
jae 0xabf3
movl -0x8(%rax), %edx
addl %edx, 0x8(%rax)
addq $0x10, %rax
jmp 0xabe2
leaq 0x132ec(%rip), %rdi     # 0x1dee6
leaq 0x2137f(%rip), %rsi     # 0x2bf80
popq %rax
jmp 0xac07