LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: cb_get_property
static int cb_get_property(const char *pk, const char *dn,
                                       leda_device_data_t properties[], 
                                       int properties_count, 
                                       void *usr_data)
{
    int i;
    for (i = 0; i < properties_count; i++) {
        if (strcmp(properties[i].key, "power") == 0) {
            snprintf(properties[i].value, MAX_PARAM_VALUE_LENGTH, "%d", get_led_power(pk, dn));
            properties[i].type = LEDA_TYPE_BOOL;
        } else if (strcmp(properties[i].key, "brightness") == 0) {
            snprintf(properties[i].value, MAX_PARAM_VALUE_LENGTH, "%d", get_led_brightness(pk, dn));
            properties[i].type = LEDA_TYPE_INT;
        } else {
            return LEDA_ERROR_PROPERTY_NOT_EXIST;
        }
    }

    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jle 0x1c1f
movq %rdx, %rbx
movq %rsi, %r14
movl %ecx, %r12d
addq $0x44, %rbx
leaq -0x40(%rbx), %r13
movq %r13, %rdi
leaq 0x480(%rip), %rsi       # 0x200f
callq 0x11b0
testl %eax, %eax
je 0x1bcc
movq %r13, %rdi
leaq 0x462(%rip), %rsi       # 0x2004
callq 0x11b0
testl %eax, %eax
jne 0x1c24
movq %r14, %rsi
callq 0x134c
movq 0x25ee(%rip), %rcx      # 0x41a8
cltq
imulq $0x3c, %rax, %rax
addq %rcx, %rax
addq $0x38, %rax
xorl %r15d, %r15d
jmp 0x1bee
movq %r14, %rsi
callq 0x134c
movq 0x25cd(%rip), %rcx      # 0x41a8
cltq
imulq $0x3c, %rax, %rax
addq %rcx, %rax
addq $0x34, %rax
movl $0x1, %r15d
movl (%rax), %ecx
xorl %r13d, %r13d
movl $0x800, %esi            # imm = 0x800
movq %rbx, %rdi
leaq 0x413(%rip), %rdx       # 0x2015
xorl %eax, %eax
callq 0x1050
movl %r15d, -0x44(%rbx)
addq $0x844, %rbx            # imm = 0x844
decq %r12
jne 0x1b81
jmp 0x1c2a
xorl %r13d, %r13d
jmp 0x1c2a
movl $0x1a9ca, %r13d         # imm = 0x1A9CA
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: cb_set_property
static int cb_set_property(const char *pk, const char *dn,
                                       const leda_device_data_t properties[], 
                                       int properties_count, 
                                       void *usr_data)
{
    int ret = LE_ERROR_UNKNOWN, i;

    for (i = 0; i < properties_count; i++) {
        if (0 == strcmp("brightness", properties[i].key)) {
            ret = set_led_brightness(pk, dn, atoi(properties[i].value));
        } else if (0 == strcmp("power", properties[i].key)) {
            ret = set_led_power(pk, dn, atoi(properties[i].value));
        } else {
            return LEDA_ERROR_PROPERTY_NOT_EXIST;
        }
        if (ret != LE_SUCCESS) {
            break;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jle 0x1d13
movq %rdx, %rbx
movq %rsi, %r14
movq 0x2549(%rip), %rax      # 0x41a8
movq %rax, -0x30(%rbp)
movl %ecx, %r15d
addq $0x44, %rbx
leaq -0x40(%rbx), %r13
leaq 0x38f(%rip), %rdi       # 0x2004
movq %r13, %rsi
callq 0x11b0
testl %eax, %eax
je 0x1cc4
leaq 0x387(%rip), %rdi       # 0x200f
movq %r13, %rsi
callq 0x11b0
testl %eax, %eax
jne 0x1d1b
movq %rbx, %rdi
callq 0x1180
xorl %r13d, %r13d
cmpl $0x1, %eax
ja 0x1cd4
movl %eax, %r12d
movq %r14, %rsi
callq 0x134c
cltq
imulq $0x3c, %rax, %rax
movq -0x30(%rbp), %rcx
movl %r12d, 0x34(%rcx,%rax)
jmp 0x1cf8
movq %rbx, %rdi
callq 0x1180
xorl %r13d, %r13d
cmpl $0x5, %eax
jbe 0x1cde
movl $0x186a7, %r13d         # imm = 0x186A7
xorl %eax, %eax
jmp 0x1cfa
movl %eax, %r12d
movq %r14, %rsi
callq 0x134c
cltq
imulq $0x3c, %rax, %rax
movq -0x30(%rbp), %rcx
movl %r12d, 0x38(%rcx,%rax)
movb $0x1, %al
testb %al, %al
je 0x1d21
addq $0x844, %rbx            # imm = 0x844
decq %r15
jne 0x1c6a
xorl %r13d, %r13d
jmp 0x1d21
movl $0x186a0, %r13d         # imm = 0x186A0
jmp 0x1d21
movl $0x1a9ca, %r13d         # imm = 0x1A9CA
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d89
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x36e(%rip), %rdi       # 0x20ce
movq %rdx, %rsi
callq 0x11b0
movl $0x1a9cd, %r15d         # imm = 0x1A9CD
testl %eax, %eax
jne 0x1d89
leaq 0x35b(%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_O1/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 0x27131(%rip), %r14     # 0x2d858
cmpq $0x0, (%r14)
je 0x674f
leaq 0x188d0(%rip), %rdi     # 0x1f004
xorl %eax, %eax
callq 0xb6e0
leaq 0x23bcb(%rip), %rax     # 0x2a30d
movb $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x188cc(%rip), %rdi     # 0x1f022
movl $0x5d, %esi
callq 0x10881
testq %rax, %rax
je 0x6745
movq 0x10(%rax), %rbx
cmpl $0x5d, 0x20(%rbx)
jne 0x67b0
xorl %eax, %eax
callq 0xca74
movslq 0x28(%rbx), %rax
shlq $0x4, %rax
leaq 0x256db(%rip), %rcx     # 0x2be60
movq (%rcx,%rax), %rsi
leaq 0x188ac(%rip), %rdi     # 0x1f03c
xorl %eax, %eax
callq 0xb6e0
movq %rbx, (%r14)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x95d5
leaq 0x270f5(%rip), %rax     # 0x2d8a3
jmp 0x6742
leaq 0x18870(%rip), %rdi     # 0x1f027
xorl %eax, %eax
callq 0xb6e0
jmp 0x6745
// File: /workspace/github_c_makefile_star2_O1/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 0x2708d(%rip), %r14     # 0x2d858
movq (%r14), %rbx
testq %rbx, %rbx
je 0x681d
movq %rbx, %rdi
callq 0x1b623
testb %al, %al
je 0x682b
movq $0x0, (%r14)
movq %rbx, %rdi
callq 0x105d8
movsbl %al, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1aaa4
leaq 0x1885a(%rip), %rdi     # 0x1f05f
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb6e0
leaq 0x2708b(%rip), %rax     # 0x2d8a3
movb $0x0, (%rax)
jmp 0x682b
leaq 0x18824(%rip), %rdi     # 0x1f048
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%rax,%rax,2), %rax
leaq 0x256c6(%rip), %rcx     # 0x2bf10
movl 0x8(%rcx,%rax,4), %edx
movl %edx, 0x44(%rdi)
movl (%rcx,%rax,4), %edx
movl %edx, 0x34(%rdi)
movl 0x4(%rcx,%rax,4), %eax
movl %eax, 0x40(%rdi)
leaq 0x2556b(%rip), %rax     # 0x2bdd0
movq 0x40(%rax), %rax
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68dd
movq %rdi, %rbx
movl $0x10, %esi
callq 0x95b3
testb %al, %al
jne 0x68dd
movl $0x20, %esi
movq %rbx, %rdi
callq 0x95b3
testb %al, %al
je 0x68ab
xorl %ebp, %ebp
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $0xa, %eax
jl 0x68df
movl 0x28(%rbx), %eax
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
je 0x68dd
movl 0x34(%rbx), %ecx
cmpl $0x2, %eax
sete %dl
cmpl $0x8, %ecx
setl %sil
movb $0x1, %bpl
testb %sil, %dl
jne 0x68df
cmpl $0x2, %eax
setne %al
cmpl $0x9, %ecx
setl %cl
testb %cl, %al
jne 0x68df
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26f4c(%rip), %rax     # 0x2d840
movq (%rax), %r14
testq %r14, %r14
je 0x696b
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 0x68f7
movl 0x84(%r15), %ecx
testl %ecx, %ecx
jle 0x6931
leal -0x1(%rcx), %edx
movl %edx, 0x84(%r15)
cmpl $0x1, %ecx
jne 0x68f7
testw %ax, %ax
jns 0x6943
movq %rbx, %rdi
callq 0x6973
cmpl $-0x1, %eax
je 0x68f7
testb $0x40, 0x79(%r15)
je 0x6954
cmpb $0x1, 0x8c(%r15)
jne 0x6961
movq %rbx, %rdi
callq 0x6973
cmpl $-0x1, %eax
je 0x68f7
xorb $0x1, 0x8c(%r15)
jmp 0x68f7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
callq 0x9595
testb %al, %al
je 0x6fea
xorl %ebx, %ebx
jmp 0x700d
leaq 0x26c6f(%rip), %r15     # 0x2dc60
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 0x701a
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 0x7052
testq %rax, %rax
je 0x6fe6
leaq 0x26830(%rip), %rcx     # 0x2d864
cmpl $0x2, (%rcx)
je 0x6fe6
cmpq 0x70(%r15), %rax
jne 0x6fe6
movl $0x1, %esi
movq %rax, %rdi
callq 0x13e74
testl %eax, %eax
jne 0x6fe6
jmp 0x700d
// File: /workspace/github_c_makefile_star2_O1/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 0x9571
testb %al, %al
je 0x70b5
movl (%rbx), %ecx
xorl %eax, %eax
leaq 0x26841(%rip), %rsi     # 0x2d8b0
xorl %edx, %edx
movl (%rsi,%rdx), %edi
cmpl %ecx, %edi
jg 0x70a3
movl 0x8(%rsi,%rdx), %r8d
addl %r8d, %edi
decl %edi
cmpl %edi, %ecx
jg 0x70a3
movl 0x4(%rbx), %edi
movl 0x4(%rsi,%rdx), %r8d
cmpl %edi, %r8d
jg 0x70a3
movl 0xc(%rsi,%rdx), %r9d
addl %r9d, %r8d
decl %r8d
cmpl %r8d, %edi
jle 0x70b9
leaq 0x68(%rdx), %rdi
cmpq $0x340, %rdx            # imm = 0x340
movq %rdi, %rdx
jb 0x7071
jmp 0x70c3
xorl %eax, %eax
jmp 0x70c3
addq 0x22e50(%rip), %rdx     # 0x29f10
movq %rdx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7565
movq %rsi, %r15
movq %rdi, %r12
movl 0x4(%rsi), %esi
cmpl 0x4(%rdi), %esi
je 0x7565
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq 0x22a22(%rip), %r13     # 0x29f30
movq (%r13), %rdi
callq 0x6490
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x752c
movq (%r13), %rdi
callq 0x6330
movl %eax, %edi
callq 0xb995
testb %al, %al
je 0x7563
movq (%r13), %rdi
movl 0x4(%r12), %esi
movl (%r15), %edx
callq 0x6490
cmpl $-0x1, %eax
je 0x7557
movq (%r13), %rdi
callq 0x6330
movl %eax, %r14d
movq %r14, %rdi
callq 0xb995
testb %al, %al
jne 0x7565
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x262c8(%rip), %rax     # 0x2d840
movq (%rax), %rax
testq %rax, %rax
je 0x759b
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
movq 0x10(%rax), %rdi
cmpl %edx, 0x54(%rdi)
jne 0x7593
cmpl %ecx, 0x50(%rdi)
je 0x759d
movq (%rax), %rax
testq %rax, %rax
jne 0x7585
xorl %eax, %eax
testq %rax, %rax
je 0x75c2
movq 0x10(%rax), %rax
movq 0x78(%rax), %rcx
testb $0x2, %cl
jne 0x75c2
movq %rsi, 0x60(%rax)
andq $-0x107, %rcx           # imm = 0xFEF9
orq $0x4, %rcx
movq %rcx, 0x78(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
leaq -0xa(%rip), %rbx        # 0x8256
movl $0x2, %edi
movq %rbx, %rsi
callq 0x6280
cmpq %rbx, %rax
je 0x827f
leaq 0x255f7(%rip), %rax     # 0x2d870
movl $0x0, (%rax)
leaq 0x17174(%rip), %rdi     # 0x1f3fa
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
callq 0xb9fd
cmpb $0x73, %al
je 0x82e3
movzbl %al, %eax
cmpl $0x79, %eax
jne 0x8319
movq 0x21c89(%rip), %rbx     # 0x29f30
movq (%rbx), %rdi
callq 0x6120
movq (%rbx), %rdi
movq 0x21cf7(%rip), %rax     # 0x29fb0
movl (%rax), %esi
decl %esi
xorl %edx, %edx
callq 0x6490
movq (%rbx), %rdi
callq 0x6200
leaq 0x25599(%rip), %rax     # 0x2d86c
movl (%rax), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x13052
jmp 0x830a
xorl %eax, %eax
callq 0x14190
testb %al, %al
je 0x836b
leaq 0x286eb(%rip), %rbx     # 0x309e0
movq (%rbx), %rdi
callq 0x6120
movq (%rbx), %rdi
callq 0x6200
callq 0x6530
xorl %edi, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc715
leaq -0xca(%rip), %rsi       # 0x8256
movl $0x2, %edi
callq 0x6280
leaq 0x286af(%rip), %rbx     # 0x309e0
movq (%rbx), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x6490
movq (%rbx), %rdi
callq 0x64a0
movq (%rbx), %rdi
callq 0x6200
leaq 0x2551a(%rip), %rax     # 0x2d870
movl %ebp, (%rax)
leaq 0x25525(%rip), %rax     # 0x2d884
movl %ebp, (%rax)
leaq 0x2553b(%rip), %rax     # 0x2d8a3
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25529(%rip), %rax     # 0x2dc60
movl 0x50(%rax), %esi
movl 0x54(%rax), %edi
callq 0x9514
cmpb $0x25, %al
jne 0x875d
movl $0x100, %edi            # imm = 0x100
callq 0x9595
testb %al, %al
je 0x876d
leaq 0x16e1a(%rip), %rdi     # 0x1f575
jmp 0x8764
leaq 0x16dfe(%rip), %rdi     # 0x1f562
xorl %eax, %eax
callq 0xb6e0
jmp 0x877d
leaq 0x21b7c(%rip), %rax     # 0x2a2f0
incl (%rax)
xorl %edi, %edi
callq 0xf658
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x254d7(%rip), %rax     # 0x2dc60
movl 0x50(%rax), %esi
movl 0x54(%rax), %edi
callq 0x9514
leaq 0x16e1a(%rip), %rbx     # 0x1f5b5
cmpb $0x25, %al
jne 0x87e2
movl $0x100, %edi            # imm = 0x100
callq 0x9595
testb %al, %al
je 0x87b6
leaq 0x16dc1(%rip), %rbx     # 0x1f575
jmp 0x87e2
leaq 0x250e4(%rip), %rax     # 0x2d8a1
cmpb $0x1, (%rax)
jne 0x87e2
leaq 0x21b27(%rip), %rax     # 0x2a2f0
decl (%rax)
jne 0x87d4
xorl %eax, %eax
callq 0x138f8
xorl %edi, %edi
callq 0xf658
leaq 0x16da7(%rip), %rbx     # 0x1f589
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb6e0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16cbf(%rip), %rdi     # 0x1f5eb
xorl %esi, %esi
callq 0x10881
testq %rax, %rax
je 0x8aa6
movq 0x10(%rax), %rax
movslq 0x28(%rax), %r15
movl 0x20(%rax), %ecx
cmpl $0x3c, %ecx
jg 0x898d
cmpl $0x21, %ecx
je 0x89da
cmpl $0x2f, %ecx
jne 0x89c3
leaq 0x279af(%rip), %r12     # 0x30310
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x8a2b
leaq (%r15,%r15,2), %rax
leaq 0x27df7(%rip), %rcx     # 0x30770
leaq (%rcx,%rax,8), %rax
addq $0x8, %rax
leaq 0x27988(%rip), %r12     # 0x30310
jmp 0x8a28
cmpl $0x3f, %ecx
je 0x8a02
cmpl $0x3d, %ecx
jne 0x89c3
leaq 0x278a2(%rip), %r12     # 0x30240
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x8a2b
leaq (,%r15,8), %rax
addq 0x2152e(%rip), %rax     # 0x29ee8
leaq 0x2787f(%rip), %r12     # 0x30240
jmp 0x8a28
movq 0x18(%rax), %rsi
leaq 0x16c22(%rip), %rdi     # 0x1f5f0
xorl %eax, %eax
callq 0xb6e0
jmp 0x8aa6
leaq 0x277af(%rip), %r12     # 0x30190
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x8a2b
leaq (,%r15,8), %rax
addq 0x214e7(%rip), %rax     # 0x29ee0
leaq 0x27790(%rip), %r12     # 0x30190
jmp 0x8a28
leaq 0x276b7(%rip), %r12     # 0x300c0
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
jne 0x8a2b
leaq (,%r15,8), %rax
addq 0x215a7(%rip), %rax     # 0x29fc8
leaq 0x27698(%rip), %r12     # 0x300c0
movq (%rax), %rbx
leaq 0x16bda(%rip), %rdi     # 0x1f60c
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6e0
leaq 0x21953(%rip), %rdi     # 0x2a396
xorl %eax, %eax
callq 0xb6e0
movq (%r12,%r15,8), %rdi
testq %rdi, %rdi
je 0x8a58
callq 0x6050
leaq 0x25431(%rip), %r14     # 0x2de90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60e0
leaq 0x27f6f(%rip), %rax     # 0x309e0
movq (%rax), %rsi
movq %r14, %rdi
callq 0xfe5d
testl %eax, %eax
jne 0x8aa6
leaq 0x25409(%rip), %rbx     # 0x2de90
movq %rbx, %rdi
callq 0x6170
leal 0x1(%rax), %edi
callq 0xbee3
movq %rax, (%r12,%r15,8)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x60e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24dc1(%rip), %r8      # 0x2d87c
movslq (%r8), %r9
cmpq $0x13, %r9
jg 0x8ae7
leaq (%r9,%r9,2), %rax
leaq 0x24b31(%rip), %r10     # 0x2d600
leaq (%r10,%rax,8), %rax
movl %edx, (%rax)
movl %ecx, 0x14(%rax)
movq %rdi, 0x8(%rax)
movl %esi, 0x10(%rax)
leal 0x1(%r9), %ecx
movl %ecx, (%r8)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x24d86(%rip), %r14     # 0x2d87c
movslq (%r14), %rbx
testq %rbx, %rbx
jle 0x8ba0
movq %rdi, %rcx
leaq (%rbx,%rbx,2), %rax
leaq 0x24af0(%rip), %r15     # 0x2d600
leaq (%r15,%rax,8), %rax
leaq 0x24b15(%rip), %r8      # 0x2d630
xorl %edx, %edx
leaq (%r15,%rdx), %rdi
leaq (%rdx,%r15), %rsi
addq $0x18, %rsi
cmpq %rcx, %rdi
je 0x8b3d
addq $0x18, %rdx
addq $0x18, %r8
cmpq %rax, %rsi
jb 0x8b1d
jmp 0x8ba0
cmpq %rax, %rsi
jae 0x8b83
cmpq %rax, %r8
cmovaq %r8, %rax
subq %r15, %rax
addq $-0x30, %rax
xorl %ecx, %ecx
cmpq %rdx, %rax
setne %cl
subq %rcx, %rax
subq %rdx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq $0x4, %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
callq 0x63f0
decl %ebx
movl %ebx, (%r14)
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
movl $0x0, (%r15,%rax,8)
movq $0x0, 0x8(%r15,%rax,8)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x24c59(%rip), %r14     # 0x2d87c
cmpl $0x0, (%r14)
jle 0x8c63
movl %edi, %ebx
leaq 0x249ce(%rip), %r15     # 0x2d600
movq %r15, %r12
cmpl %ebx, (%r12)
jne 0x8c4f
cmpl $-0x1, 0x14(%r12)
jne 0x8c4f
movl 0x10(%r12), %edi
xorl %eax, %eax
callq *0x8(%r12)
addq $0x18, %r12
movslq (%r14), %rax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %rax
cmpq %rax, %r12
jb 0x8c35
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24bcf(%rip), %rax     # 0x2d87c
movslq (%rax), %rax
testq %rax, %rax
jle 0x8cdb
leaq (%rax,%rax,2), %rcx
leaq 0x24940(%rip), %rax     # 0x2d600
leaq (%rax,%rcx,8), %rcx
cmpl $0x0, (%rax)
je 0x8cd2
cmpq %rdi, 0x8(%rax)
jne 0x8cd2
addl %esi, 0x14(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jb 0x8cc4
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x24b91(%rip), %r15     # 0x2d87c
cmpl $0x0, (%r15)
jle 0x8d26
movq %rdi, %rbx
leaq 0x24905(%rip), %r12     # 0x2d600
movq %r12, %r14
cmpl $0x0, (%r14)
je 0x8d12
cmpq %rbx, 0x8(%r14)
jne 0x8d12
movq %r14, %rdi
callq 0x8aea
addq $0x18, %r14
movslq (%r15), %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %rax
cmpq %rax, %r14
jb 0x8cfe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24b3e(%rip), %r14     # 0x2d87c
cmpl $0x0, (%r14)
jle 0x8d85
leaq 0x248b5(%rip), %r15     # 0x2d600
movq %r15, %rbx
cmpl $0x2, (%rbx)
jne 0x8d71
movl 0x14(%rbx), %eax
testl %eax, %eax
js 0x8d71
decl %eax
movl %eax, 0x14(%rbx)
jne 0x8d71
movl 0x10(%rbx), %edi
xorl %eax, %eax
callq *0x8(%rbx)
movq %rbx, %rdi
callq 0x8aea
addq $0x18, %rbx
movslq (%r14), %rax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %rax
cmpq %rax, %rbx
jb 0x8d4e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24fa5(%rip), %r12     # 0x2dd60
movq (%r12), %r14
movl 0x28(%r14), %ebx
movl 0x30(%r14), %ebp
leaq 0x24abe(%rip), %r15     # 0x2d88c
incl (%r15)
movl 0x1c(%r14), %edi
cmpl $0x11, %edi
jl 0x8df4
leaq 0x24ab7(%rip), %rax     # 0x2d898
cmpb $0x0, (%rax)
jne 0x8df4
addl $-0xf, %edi
xorl %eax, %eax
callq 0xc72d
addl %eax, 0x30(%r14)
movl (%r15), %eax
cmpl $0x7, %ebx
jg 0x8e11
addl %ebx, %ebx
movl $0x14, %ecx
subl %ebx, %ecx
cmpl %ecx, %eax
jle 0x8e2e
movl 0x30(%r14), %eax
incl %eax
jmp 0x8e2a
cmpl $0x3, %eax
jl 0x8e2e
addl $-0x7, %ebx
movl %ebx, %edi
xorl %eax, %eax
callq 0xc72d
movl 0x30(%r14), %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x30(%r14)
xorl %edi, %edi
movl $0x9, %esi
callq 0x12d7f
testb %al, %al
je 0x8e42
incl 0x30(%r14)
movl $0x1, %edi
movl $0x9, %esi
callq 0x12d7f
testb %al, %al
je 0x8e59
incl 0x30(%r14)
movl $0x400, %edi            # imm = 0x400
callq 0x9595
testb %al, %al
je 0x8e6b
incl 0x30(%r14)
movl 0x30(%r14), %eax
cmpl %eax, %ebp
je 0x8e93
leaq 0x24a29(%rip), %rcx     # 0x2d8a3
movb $0x0, (%rcx)
movq (%r12), %rcx
movl 0x34(%rcx), %ecx
cmpl %ecx, %eax
jle 0x8e8c
movl %ecx, 0x30(%r14)
movl $0x0, (%r15)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24921(%rip), %eax     # 0x2d7e0
leal 0x1(%rax), %ecx
movl %ecx, 0x24918(%rip)     # 0x2d7e0
cmpl $0x3, %eax
jl 0x8f25
pushq %rax
movl $0x1, %edi
movl $0x6, %esi
callq 0xc74e
cmpl $0x4, %eax
jne 0x8f17
leaq 0x2497b(%rip), %rax     # 0x2d864
cmpl $0x1, (%rax)
je 0x8ef5
xorl %eax, %eax
callq 0xd8f4
leaq -0x43(%rip), %rdi       # 0x8eb9
callq 0x8cdc
leaq -0x6a(%rip), %rdi       # 0x8e9e
movl $0x1, %esi
movl $0x46, %edx
callq 0x8c6f
movl $0x0, 0x248bf(%rip)     # 0x2d7e0
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9595
testb %al, %al
je 0x8f45
leaq 0x166ff(%rip), %rdi     # 0x1f63d
xorl %eax, %eax
callq 0xb6e0
leaq 0x24d14(%rip), %rax     # 0x2dc60
andb $-0x3, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
callq 0x9595
testb %al, %al
je 0x8f7f
leaq 0x166e1(%rip), %rdi     # 0x1f659
xorl %eax, %eax
callq 0xb6e0
leaq 0x24cda(%rip), %rdi     # 0x2dc60
andb $-0x2, 0x78(%rdi)
addq $0x50, %rdi
callq 0xecbc
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9595
testb %al, %al
je 0x8fb4
leaq 0x166c8(%rip), %rdi     # 0x1f675
xorl %eax, %eax
callq 0xb6e0
leaq 0x24ca5(%rip), %rax     # 0x2dc60
andb $0x7f, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
leaq 0x248c2(%rip), %rbx     # 0x2d890
movl (%rbx), %ebp
leaq 0x21329(%rip), %rdx     # 0x2a300
movl (%rdx), %eax
testl %eax, %eax
jle 0x9044
leaq 0x248b0(%rip), %rcx     # 0x2d894
movl (%rcx), %esi
leaq 0x2131b(%rip), %rcx     # 0x2a308
leaq 0x248ad(%rip), %rdi     # 0x2d8a1
addl (%rcx), %esi
movzbl (%rdi), %edi
movl %eax, %ecx
subl %esi, %ecx
addl %edi, %ecx
movl %ecx, (%rdx)
leaq 0x24c58(%rip), %rdx     # 0x2dc60
cmpl $0x0, 0x88(%rdx)
jg 0x912c
cmpl $0x96, %eax
jl 0x90f6
cmpl $0x95, %ecx
jg 0x90f6
leaq 0x166ac(%rip), %rdi     # 0x1f6df
xorl %eax, %eax
callq 0xb6e0
movl $0x2, %eax
jmp 0x9118
leal -0x1(%rax), %ecx
movl %ecx, (%rdx)
cmpl $0xffffff6a, %ecx       # imm = 0xFFFFFF6A
jne 0x9061
leaq 0x1663d(%rip), %rdi     # 0x1f695
xorl %eax, %eax
callq 0xb6e0
jmp 0x908e
cmpl $0xfffffea2, %eax       # imm = 0xFFFFFEA2
jg 0x908e
leaq 0x1664e(%rip), %rdi     # 0x1f6bd
xorl %eax, %eax
callq 0xb6e0
leaq 0x18111(%rip), %rdi     # 0x2118e
xorl %eax, %eax
callq 0xb6e0
movl $0xfffffff7, %edi       # imm = 0xFFFFFFF7
callq 0x12dc8
leaq 0x24bcb(%rip), %r14     # 0x2dc60
cmpl $0x0, 0x88(%r14)
jg 0x912c
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
cmpl $0x14, %eax
jg 0x912c
movl $0x8, %edi
xorl %eax, %eax
callq 0xc72d
addl $0x4, %eax
movl %eax, 0x88(%r14)
leaq 0x16603(%rip), %rdi     # 0x1f6d4
xorl %eax, %eax
callq 0xb6e0
leaq 0x247bd(%rip), %rax     # 0x2d89c
movb $0x0, (%rax)
leaq 0x2479b(%rip), %rax     # 0x2d884
movl $0x0, (%rax)
movl $0x3, %eax
jmp 0x9118
cmpl $0x12c, %eax            # imm = 0x12C
jl 0x911a
cmpl $0x12b, %ecx            # imm = 0x12B
jg 0x911a
leaq 0x165f2(%rip), %rdi     # 0x1f6fe
xorl %eax, %eax
callq 0xb6e0
movl $0x1, %eax
movl %eax, (%rbx)
cmpl (%rbx), %ebp
je 0x9125
xorl %eax, %eax
callq 0x95e0
xorl %edi, %edi
callq 0x9904
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9595
testb %al, %al
je 0x9199
leaq 0x165c5(%rip), %rdi     # 0x1f70e
xorl %eax, %eax
callq 0xb6e0
leaq 0x24b09(%rip), %rax     # 0x2dc60
movsbl 0x8f(%rax), %ebx
movl %ebx, %edi
callq 0xb9da
testb %al, %al
je 0x9199
movl %ebx, %edi
callq 0x8033
leaq 0x165b9(%rip), %rdi     # 0x1f730
movq %rax, %rsi
xorl %eax, %eax
callq 0xb6e0
leaq 0x18006(%rip), %rdi     # 0x2118e
xorl %eax, %eax
callq 0xb6e0
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x12dc8
leaq 0x24ac0(%rip), %rax     # 0x2dc60
andb $-0x2, 0x7a(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x4, %edi
xorl %eax, %eax
callq 0xc72d
leal 0x1(%rax), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x11f24
leaq -0x26(%rip), %rdi       # 0x91a8
movl $0x1, %esi
movl $0x96, %edx
callq 0x8c6f
leaq 0x246bf(%rip), %rax     # 0x2d8a3
movb $0x0, (%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9595
testb %al, %al
je 0x9208
leaq 0x16546(%rip), %rdi     # 0x1f747
xorl %eax, %eax
callq 0xb6e0
leaq 0x24a51(%rip), %rax     # 0x2dc60
andb $-0x41, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9595
testb %al, %al
je 0x9234
leaq 0x16537(%rip), %rdi     # 0x1f764
xorl %eax, %eax
callq 0xb6e0
leaq 0x24a25(%rip), %rax     # 0x2dc60
andb $-0x5, 0x79(%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x8, %edi
callq 0x9595
testb %al, %al
je 0x9260
leaq 0x16529(%rip), %rdi     # 0x1f782
xorl %eax, %eax
callq 0xb6e0
leaq 0x249f9(%rip), %rax     # 0x2dc60
andb $-0x9, 0x78(%rax)
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x24397(%rip), %rax     # 0x2d840
movq (%rax), %rbx
testq %rbx, %rbx
je 0x9500
leaq 0x27528(%rip), %r14     # 0x309e0
movq 0x10(%rbx), %r15
movl 0x50(%r15), %edx
movl 0x54(%r15), %esi
movq (%r14), %rdi
callq 0x6490
cmpl $-0x1, %eax
je 0x94e1
movq (%r14), %rdi
movsbl 0x8d(%r15), %esi
callq 0x64c0
orb $0x8, 0x78(%r15)
cmpb $0x4d, 0x8d(%r15)
jne 0x94f8
movb $0x4d, 0x8e(%r15)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x94b8
leaq 0x274d9(%rip), %rax     # 0x309e0
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6200
// File: /workspace/github_c_makefile_star2_O1/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 0x274cd(%rip), %r14     # 0x309f0
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6490
cmpl $-0x1, %eax
je 0x9560
leaq 0x274b5(%rip), %r14     # 0x309f0
movq (%r14), %rdi
callq 0x6330
cmpl $0x20, %eax
jne 0x9560
movq 0x209e1(%rip), %r14     # 0x29f30
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6490
cmpl $-0x1, %eax
je 0x956d
movq (%r14), %rdi
callq 0x6330
popq %rbx
popq %r14
popq %rbp
retq
movb $-0x1, %al
jmp 0x9568
// File: /workspace/github_c_makefile_star2_O1/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 0x95d2
movslq 0x38(%rdi), %rax
testq %rsi, %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x98cf
leaq 0x24770(%rip), %r14     # 0x2dd60
movq (%r14), %rcx
movl %eax, 0x3c(%rcx)
callq 0x96a9
movl %eax, %ebx
movq (%r14), %rax
movslq 0x3c(%rax), %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
leal (,%rax,4), %ecx
cmpl %ecx, %ebx
jle 0x963b
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
movl $0x3, %ecx
cmpl $0x50, %eax
jl 0x965d
jmp 0x9666
leal (%rax,%rax,2), %eax
movl $0x1, %ecx
cmpl %eax, %ebx
jle 0x965d
movl $0x64, %edi
xorl %eax, %eax
callq 0xc72d
movl $0x2, %ecx
cmpl $0x3b, %eax
jg 0x9666
leaq 0x20ca4(%rip), %rax     # 0x2a308
movl %ecx, (%rax)
movq (%r14), %rax
movl %ebx, 0x38(%rax)
leaq 0x245ed(%rip), %rax     # 0x2dc60
movq 0x68(%rax), %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x968e
movq 0x10(%r14), %rdi
callq 0x9804
addl %eax, %ebx
movq (%r14), %r14
jmp 0x9679
leaq 0x241df(%rip), %rax     # 0x2d874
movl %ebx, (%rax)
leaq 0x24205(%rip), %rax     # 0x2d8a3
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x245a8(%rip), %rax     # 0x2dc60
movq 0x68(%rax), %r12
xorl %r15d, %r15d
movl $0x0, %ebx
testq %r12, %r12
je 0x96e8
xorl %ebx, %ebx
movq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x9730
imull 0x24(%r14), %eax
addl %eax, %ebx
movq (%r12), %r12
testq %r12, %r12
jne 0x96cb
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x2465b(%rip), %r14     # 0x2dd50
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x9719
cmpl $0x15, 0x20(%rdi)
jne 0x9719
movl $0x20, %esi
callq 0x95c2
testb %al, %al
je 0x9719
movl %ebx, %eax
shrl $0x2, %eax
addl %eax, %ebx
incq %r15
cmpq $0x1, %r15
je 0x96f5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9761
cmpl $0x5d, %eax
jne 0x9776
movslq 0x28(%r14), %rax
leaq (%rax,%rax,2), %rax
leaq 0x227ba(%rip), %rcx     # 0x2bf10
movl (%rcx,%rax,4), %eax
cmpl 0x34(%r14), %eax
jg 0x976b
jmp 0x9776
movl 0x30(%r14), %eax
addl 0x2c(%r14), %eax
jle 0x9776
movl %ebx, %eax
shrl $0x1f, %eax
addl %ebx, %eax
sarl %eax
movl %eax, %ebx
movl $0x1, %esi
movq %r14, %rdi
callq 0x95b3
testb %al, %al
je 0x97a0
movslq %ebx, %rbx
imulq $0x66666667, %rbx, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
addl %eax, %ebx
movl $0x20, %esi
movq %r14, %rdi
callq 0x95b3
testb %al, %al
je 0x97ca
movslq %ebx, %rbx
imulq $-0x66666667, %rbx, %rax # imm = 0x99999999
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24481(%rip), %rax     # 0x2dc60
movq 0x68(%rax), %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x97fa
movq 0x10(%r14), %rdi
callq 0x9804
addl %eax, %ebx
movq (%r14), %r14
jmp 0x97e5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcaa3
movl %eax, %ebp
movl 0x20(%rbx), %ecx
cmpl $0x29, %ecx
je 0x986e
cmpl $0x2f, %ecx
je 0x983e
xorl %eax, %eax
cmpl $0x5d, %ecx
jne 0x9881
movslq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %rax
leaq 0x226d8(%rip), %rcx     # 0x2bf10
movl 0x8(%rcx,%rax,4), %eax
jmp 0x9881
movslq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %rax
leaq 0x26f23(%rip), %rcx     # 0x30770
movq (%rcx,%rax,8), %rdi
leaq 0x165e7(%rip), %rsi     # 0x1fe3f
callq 0x6250
testl %eax, %eax
movl $0xc8, %ecx
movl $0x6e, %eax
cmovel %ecx, %eax
jmp 0x9881
movslq 0x28(%rbx), %rax
shlq $0x5, %rax
leaq 0x22843(%rip), %rcx     # 0x2c0c0
movl 0x18(%rcx,%rax), %eax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x230e1(%rip), %rdx     # 0x2c970
addl 0x4(%rdx,%rcx,8), %eax
imull 0x24(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x989e
addl $0x5dc, %eax            # imm = 0x5DC
leaq 0x23faf(%rip), %rcx     # 0x2d890
movl (%rcx), %ecx
cmpl $0x3, %ecx
je 0x9900
cmpl $0x2, %ecx
jne 0x9902
movl %eax, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
subl %edx, %eax
jmp 0x9902
shrl %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x23f8b(%rip), %r14     # 0x2d89b
movb $0x1, (%r14)
leaq 0x24445(%rip), %rax     # 0x2dd60
movq (%rax), %rax
movl 0x38(%rax), %ecx
cmpl 0x3c(%rax), %ecx
jle 0x996c
leaq 0x24333(%rip), %rax     # 0x2dc60
movzbl 0x8f(%rax), %ebx
leaq -0x37(%rip), %rdi       # 0x9904
callq 0x8cdc
cmpl $0x2e, %ebx
je 0x994a
cmpl $0x23, %ebx
jne 0x9956
leaq 0x23f47(%rip), %rax     # 0x2d898
cmpb $0x1, (%rax)
jne 0x9978
leaq -0x59(%rip), %rdi       # 0x9904
movl $0x1, %esi
movl $0x1, %edx
callq 0x8c6f
movb $0x0, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x15e22(%rip), %rdi     # 0x1f7a1
xorl %eax, %eax
callq 0xb6e0
xorl %edi, %edi
callq 0x1b412
testb %al, %al
jne 0x996c
leaq 0x23ed8(%rip), %r15     # 0x2d870
leaq 0x15e22(%rip), %rbx     # 0x1f7c1
movl $0x0, (%r15)
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb6e0
xorl %edi, %edi
callq 0x1b412
testb %al, %al
je 0x999f
jmp 0x996c