LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: load_device_from_csv
int load_device_from_csv(char *path)
{
    FILE *fp;
    char ch;
    int line = 0, i;
    device_t invalid = {0};
    char tmp[128] = {0};
    
    fp = fopen(path, "r+");
    if (!fp) {
        printf("open file:%s error!\n", path);
        return -1;
    }
    
    while (NULL != fgets(&tmp[0], sizeof(tmp), fp)) {
       line++;
    }
    fseek(fp, 0, SEEK_SET);
    
    g_devices_count = line - 1;
    g_devices = malloc(g_devices_count * sizeof(device_t));
    memset(g_devices, 0, g_devices_count * sizeof(device_t));
    for (i = 0; i < line; i++) {
        if (i == 0) {
            fscanf(fp, "%s\n", &tmp[0]);
        } else {
            fscanf(fp, "%[^','],%[^','],%s\n", &g_devices[i - 1].dn[0], &tmp[0], &g_devices[i - 1].pk[0]);
        }        
    }
    fclose(fp);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x1040
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1040
movq -0x10(%rbp), %rdi
leaq 0x17db(%rip), %rsi      # 0x305f
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18b2
movq -0x10(%rbp), %rsi
leaq 0x17c3(%rip), %rdi      # 0x3062
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19bf
jmp 0x18b4
leaq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x80, %esi
callq 0x10d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18de
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x18b4
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1070
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, 0x389f(%rip)      # 0x5198
movslq 0x3898(%rip), %rax      # 0x5198
imulq $0x3c, %rax, %rdi
callq 0x10b0
movq %rax, 0x3890(%rip)      # 0x51a0
movq 0x3889(%rip), %rdi      # 0x51a0
movslq 0x387a(%rip), %rax      # 0x5198
imulq $0x3c, %rax, %rdx
xorl %esi, %esi
callq 0x1040
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x19af
cmpl $0x0, -0x24(%rbp)
jne 0x1959
movq -0x18(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq 0x187e(%rip), %rsi      # 0x31ce
movb $0x0, %al
callq 0x1060
jmp 0x19a2
movq -0x18(%rbp), %rdi
movq 0x383c(%rip), %rdx      # 0x51a0
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x3c, %rax, %rax
addq %rax, %rdx
addq $0x10, %rdx
leaq -0xe0(%rbp), %rcx
movq 0x381b(%rip), %r8       # 0x51a0
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x3c, %rax, %rax
addq %rax, %r8
leaq 0x16dc(%rip), %rsi      # 0x3077
movb $0x0, %al
callq 0x1060
jmp 0x19a4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1930
movq -0x18(%rbp), %rdi
callq 0x11f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: unload_device_list
void unload_device_list()
{
    if (g_devices) {
        free(g_devices);
        g_devices = NULL;
    }
    g_devices_count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x37c4(%rip)      # 0x51a0
je 0x19f5
movq 0x37bb(%rip), %rdi      # 0x51a0
callq 0x10f0
movq $0x0, 0x37ab(%rip) # 0x51a0
movl $0x0, 0x3799(%rip)      # 0x5198
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: cb_state_changed
static void cb_state_changed(leda_conn_state_e state, void *usr)
{
    int ret = -1;
    printf("connection state: %s\n", !state ? "connected" : "disconnected");
    if (LEDA_WS_CONNECTED == state) {
        g_is_connected = 1;
    } else {
        g_is_connected = 0;
    }
    pthread_mutex_lock(&g_mtx_online);
    pthread_cond_signal(&g_cond_conn_state_changed);
    pthread_mutex_unlock(&g_mtx_online);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
setne %cl
xorb $-0x1, %cl
leaq 0x144b(%rip), %rsi      # 0x31d2
leaq 0x1447(%rip), %rax      # 0x31d5
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x1420(%rip), %rdi      # 0x31bc
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jne 0x1db6
movl $0x1, 0x33e8(%rip)      # 0x519c
jmp 0x1dc0
movl $0x0, 0x33dc(%rip)      # 0x519c
leaq 0x33a9(%rip), %rdi      # 0x5170
callq 0x1220
leaq 0x336d(%rip), %rdi      # 0x5140
callq 0x1080
leaq 0x3391(%rip), %rdi      # 0x5170
callq 0x1230
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1f3e
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rdi
addq $0x4, %rdi
leaq 0x11d4(%rip), %rsi      # 0x300f
callq 0x11a0
cmpl $0x0, %eax
jne 0x1ea2
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x844, %rcx, %rcx      # imm = 0x844
addq %rcx, %rax
addq $0x44, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1420
movq -0x40(%rbp), %rdi
movl %eax, %ecx
movl $0x800, %esi            # imm = 0x800
leaq 0x1197(%rip), %rdx      # 0x3015
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x844, %rcx, %rcx      # imm = 0x844
addq %rcx, %rax
movl $0x1, (%rax)
jmp 0x1f2e
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rdi
addq $0x4, %rdi
leaq 0x1145(%rip), %rsi      # 0x3004
callq 0x11a0
cmpl $0x0, %eax
jne 0x1f23
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x844, %rcx, %rcx      # imm = 0x844
addq %rcx, %rax
addq $0x44, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14c0
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl $0x800, %esi            # imm = 0x800
leaq 0x1113(%rip), %rdx      # 0x3015
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x844, %rcx, %rcx      # imm = 0x844
addq %rcx, %rax
movl $0x0, (%rax)
jmp 0x1f2c
movl $0x1a9ca, -0x4(%rbp)    # imm = 0x1A9CA
jmp 0x1f45
jmp 0x1f2e
jmp 0x1f30
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e12
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x186a0, -0x34(%rbp)   # imm = 0x186A0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x207a
movq -0x20(%rbp), %rsi
movslq -0x38(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rsi
addq $0x4, %rsi
leaq 0x1062(%rip), %rdi      # 0x3004
callq 0x11a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1fee
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x38(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rdi
addq $0x44, %rdi
callq 0x1170
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
callq 0x1460
movl %eax, -0x34(%rbp)
jmp 0x2062
movq -0x20(%rbp), %rsi
movslq -0x38(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rsi
addq $0x4, %rsi
leaq 0x1004(%rip), %rdi      # 0x300f
callq 0x11a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2057
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x38(%rbp), %rax
imulq $0x844, %rax, %rax      # imm = 0x844
addq %rax, %rdi
addq $0x44, %rdi
callq 0x1170
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl %eax, %edx
callq 0x13b0
movl %eax, -0x34(%rbp)
jmp 0x2060
movl $0x1a9ca, -0x4(%rbp)    # imm = 0x1A9CA
jmp 0x2080
jmp 0x2062
cmpl $0x0, -0x34(%rbp)
je 0x206a
jmp 0x207a
jmp 0x206c
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1f79
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x20c2
cmpq $0x0, -0x38(%rbp)
jne 0x20cb
movl $0x186a1, -0x4(%rbp)    # imm = 0x186A1
jmp 0x2109
movq -0x20(%rbp), %rsi
leaq 0x1109(%rip), %rdi      # 0x31df
callq 0x11a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2102
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x10f3(%rip), %rdi      # 0x31e5
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x2109
movl $0x1a9cd, -0x4(%rbp)    # imm = 0x1A9CD
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x305f9(%rip), %rax     # 0x36cc8
cmpq $0x0, (%rax)
je 0x66f9
leaq 0x22928(%rip), %rdi     # 0x29004
movb $0x0, %al
callq 0xd8f0
leaq 0x2cc23(%rip), %rax     # 0x3330d
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x67a8
leaq 0x22922(%rip), %rdi     # 0x29022
movl $0x5d, %esi
callq 0x14b90
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x6720
movl $0x0, -0x4(%rbp)
jmp 0x67a8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5d, 0x20(%rax)
je 0x674d
leaq 0x228ea(%rip), %rdi     # 0x29027
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x67a8
movb $0x0, %al
callq 0xf360
movq -0x18(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x2e6fd(%rip), %rax     # 0x34e60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x228c8(%rip), %rdi     # 0x2903c
movb $0x0, %al
callq 0xd8f0
movq -0x18(%rbp), %rcx
leaq 0x30542(%rip), %rax     # 0x36cc8
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0xab50
leaq 0x30575(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x304f9(%rip), %rax     # 0x36cc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x67f3
leaq 0x22865(%rip), %rdi     # 0x29048
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x685f
leaq 0x304ce(%rip), %rax     # 0x36cc8
movq (%rax), %rdi
callq 0x23eb0
testb $0x1, %al
jne 0x680f
movl $0x0, -0x4(%rbp)
jmp 0x685f
leaq 0x304b2(%rip), %rax     # 0x36cc8
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x14790
movsbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movl -0x14(%rbp), %esi
movq %rax, %rdx
leaq 0x22818(%rip), %rdi     # 0x2905f
movb $0x0, %al
callq 0xd8f0
leaq 0x304be(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x5d, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x2e675(%rip), %rax     # 0x34f10
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x2e5af(%rip), %rax     # 0x34e60
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
leaq 0x2e4e4(%rip), %rax     # 0x34dd0
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6992
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0xaac0
testb $0x1, %al
jne 0x694a
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0xaac0
testb $0x1, %al
jne 0x6939
jmp 0x6950
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0xa, %eax
jge 0x6950
movb $0x0, -0x1(%rbp)
jmp 0x6996
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
je 0x6990
cmpl $0x0, -0x14(%rbp)
je 0x6990
cmpl $0x2, -0x14(%rbp)
jne 0x697c
cmpl $0x8, -0x18(%rbp)
jl 0x6988
cmpl $0x2, -0x14(%rbp)
je 0x698e
cmpl $0x9, -0x18(%rbp)
jge 0x698e
movb $0x1, -0x1(%rbp)
jmp 0x6996
jmp 0x6990
jmp 0x6992
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x302f1(%rip), %rax     # 0x36cb0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6ac9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x100, %rax            # imm = 0x100
cmpq $0x0, %rax
jne 0x6aba
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x6aba
movq -0x8(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jle 0x6a3f
movq -0x8(%rbp), %rcx
movl 0x84(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x84(%rcx)
cmpl $0x0, %eax
jle 0x6a3d
jmp 0x6abc
jmp 0x6a3f
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x8000, %rax           # imm = 0x8000
cmpq $0x0, %rax
je 0x6a65
movq -0x10(%rbp), %rdi
callq 0x6ae0
cmpl $-0x1, %eax
jne 0x6a63
jmp 0x6abc
jmp 0x6a65
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
je 0x6a86
movq -0x8(%rbp), %rax
testb $0x1, 0x8c(%rax)
je 0x6a98
movq -0x10(%rbp), %rdi
callq 0x6ae0
cmpl $-0x1, %eax
jne 0x6a96
jmp 0x6abc
jmp 0x6a98
movq -0x8(%rbp), %rax
movb 0x8c(%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl $0x1, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x8c(%rax)
jmp 0x6abc
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x69c6
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
callq 0xaa60
testb $0x1, %al
jne 0x749e
jmp 0x74a7
movb $0x0, -0x1(%rbp)
jmp 0x754a
leaq 0x2fc22(%rip), %rax     # 0x370d0
movl 0x50(%rax), %eax
subl -0xc(%rbp), %eax
leaq 0x2fc15(%rip), %rcx     # 0x370d0
movl 0x50(%rcx), %ecx
subl -0xc(%rbp), %ecx
imull %ecx, %eax
leaq 0x2fc05(%rip), %rcx     # 0x370d0
movl 0x54(%rcx), %ecx
subl -0x8(%rbp), %ecx
leaq 0x2fbf8(%rip), %rdx     # 0x370d0
movl 0x54(%rdx), %edx
subl -0x8(%rbp), %edx
imull %edx, %ecx
addl %ecx, %eax
cmpl $0x3, %eax
jge 0x74ee
movb $0x1, -0x1(%rbp)
jmp 0x754a
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7560
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7546
leaq 0x2f7bf(%rip), %rax     # 0x36cd4
cmpl $0x2, (%rax)
je 0x7546
movq -0x18(%rbp), %rax
leaq 0x2fbab(%rip), %rcx     # 0x370d0
cmpq 0x70(%rcx), %rax
jne 0x7544
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x19950
cmpl $0x0, %eax
jne 0x7544
movb $0x1, -0x1(%rbp)
jmp 0x754a
jmp 0x7546
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xaa10
testb $0x1, %al
jne 0x7587
jmp 0x761c
leaq 0x2f792(%rip), %rax     # 0x36d20
movq %rax, -0x18(%rbp)
leaq 0x2f787(%rip), %rax     # 0x36d20
addq $0x3a8, %rax            # imm = 0x3A8
cmpq %rax, -0x18(%rbp)
jae 0x761a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movq -0x18(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x7607
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x7607
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
movl 0xc(%rdx), %edx
subl $0x1, %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x7607
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x7607
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7624
jmp 0x7609
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
jmp 0x7592
jmp 0x761c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x7b2e
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x7b37
movb $0x1, -0x1(%rbp)
jmp 0x7bdf
movq 0x2b482(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0x7b62
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x7b74
movq 0x2b457(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x6340
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0xdc30
testb $0x1, %al
jne 0x7b86
jmp 0x7bdb
movq 0x2b433(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0x7bb1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x7bc3
movq 0x2b408(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x6340
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0xdc30
testb $0x1, %al
jne 0x7bd5
jmp 0x7bdb
movb $0x1, -0x1(%rbp)
jmp 0x7bdf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x7c90
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7c25
movl $0x0, -0x4(%rbp)
jmp 0x7c82
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x7c4c
movl $0x0, -0x4(%rbp)
jmp 0x7c82
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rcx
orq $0x4, %rcx
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rcx
andq $-0x101, %rcx           # imm = 0xFEFF
movq %rcx, 0x78(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/chase.c
// Function: find_mons
struct linked_list *find_mons(int y,int x)
{
	struct linked_list *item;
	struct thing *th;

	for (item = mlist; item != NULL; item = next(item)) {
		th = THINGPTR(item);
		if (th->t_pos.y == y && th->t_pos.x == x)
			return item;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
leaq 0x2f00f(%rip), %rax     # 0x36cb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7cec
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x7cdd
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x7cdd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7cf4
jmp 0x7cdf
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7ca8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x2, %edi
leaq -0x17(%rip), %rsi       # 0x8cf0
callq 0x6280
leaq -0x23(%rip), %rcx       # 0x8cf0
cmpq %rcx, %rax
je 0x8d25
leaq 0x2dfc1(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
leaq 0x20a26(%rip), %rdi     # 0x29752
movb $0x0, %al
callq 0xd8f0
movb $0x0, %al
callq 0xdce0
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x79, %eax
jne 0x8da4
movq 0x2a273(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x6110
movq 0x2a264(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
movq 0x2a27a(%rip), %rax     # 0x32fe0
movl (%rax), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0x6490
movq 0x2a247(%rip), %rax     # 0x32fc0
movq (%rax), %rdi
callq 0x61f0
leaq 0x2df54(%rip), %rax     # 0x36cdc
movl (%rax), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x18640
xorl %edi, %edi
movb $0x0, %al
callq 0xeef0
jmp 0x8e53
movsbl -0x5(%rbp), %eax
cmpl $0x73, %eax
jne 0x8deb
movb $0x0, %al
callq 0x19e00
movb %al, -0x6(%rbp)
cmpb $0x0, -0x6(%rbp)
je 0x8de9
leaq 0x3108c(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x6110
leaq 0x3107d(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x61f0
callq 0x6530
xorl %edi, %edi
movb $0x0, %al
callq 0xeef0
jmp 0x8e51
movl $0x2, %edi
leaq -0x107(%rip), %rsi      # 0x8cf0
callq 0x6280
leaq 0x3104d(%rip), %rax     # 0x39e50
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6490
leaq 0x3103a(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x64a0
leaq 0x3102b(%rip), %rax     # 0x39e50
movq (%rax), %rdi
callq 0x61f0
leaq 0x2deac(%rip), %rax     # 0x36ce0
movl $0x0, (%rax)
leaq 0x2deb3(%rip), %rax     # 0x36cf4
movl $0x0, (%rax)
leaq 0x2dec5(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
jmp 0x8e53
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2dd31(%rip), %rax     # 0x370d0
movl 0x54(%rax), %edi
leaq 0x2dd27(%rip), %rax     # 0x370d0
movl 0x50(%rax), %esi
callq 0xa960
movsbl %al, %eax
cmpl $0x25, %eax
je 0x93c9
leaq 0x204fa(%rip), %rdi     # 0x298ba
movb $0x0, %al
callq 0xd8f0
jmp 0x940c
movl $0x100, %edi            # imm = 0x100
callq 0xaa60
testb $0x1, %al
jne 0x93d9
jmp 0x93f0
leaq 0x204ed(%rip), %rdi     # 0x298cd
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x9413
leaq 0x29ef9(%rip), %rax     # 0x332f0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x29eed(%rip), %rax     # 0x332f0
movl %ecx, (%rax)
xorl %edi, %edi
callq 0x13060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2dca1(%rip), %rax     # 0x370d0
movl 0x54(%rax), %edi
leaq 0x2dc97(%rip), %rax     # 0x370d0
movl 0x50(%rax), %esi
callq 0xa960
movsbl %al, %eax
cmpl $0x25, %eax
jne 0x94c6
movl $0x100, %edi            # imm = 0x100
callq 0xaa60
testb $0x1, %al
jne 0x9459
jmp 0x9470
leaq 0x2046d(%rip), %rdi     # 0x298cd
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x94db
leaq 0x2d89a(%rip), %rax     # 0x36d11
testb $0x1, (%rax)
je 0x94c2
leaq 0x29e6d(%rip), %rax     # 0x332f0
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x29e61(%rip), %rax     # 0x332f0
movl %ecx, (%rax)
leaq 0x29e58(%rip), %rax     # 0x332f0
cmpl $0x0, (%rax)
jne 0x94a4
movb $0x0, %al
callq 0x19240
xorl %edi, %edi
callq 0x13060
leaq 0x2042f(%rip), %rdi     # 0x298e1
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0x94db
jmp 0x94c4
jmp 0x94c6
leaq 0x20440(%rip), %rdi     # 0x2990d
movb $0x0, %al
callq 0xd8f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x2d384(%rip), %rax     # 0x36cec
cmpl $0x14, (%rax)
jge 0x99d1
leaq 0x2d378(%rip), %rax     # 0x36cec
movslq (%rax), %rcx
leaq 0x2d0f2(%rip), %rax     # 0x36a70
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq 0x2d333(%rip), %rax     # 0x36cec
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2d327(%rip), %rax     # 0x36cec
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x99d9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x2d081(%rip), %rax     # 0x36a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x2d2ee(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2d068(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9aed
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x9ada
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x2d2af(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2d029(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9a8a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x9a32
leaq 0x2d25b(%rip), %rax     # 0x36cec
movl (%rax), %ecx
subl $0x1, %ecx
leaq 0x2d24f(%rip), %rax     # 0x36cec
movl %ecx, (%rax)
leaq 0x2d246(%rip), %rax     # 0x36cec
movslq (%rax), %rcx
leaq 0x2cfc0(%rip), %rax     # 0x36a70
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9af4
jmp 0x9adc
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x99f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/daemon.c
// Function: find_slot
struct delayed_action *find_slot(int (*func)())
{
	struct delayed_action *dev;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x2cf61(%rip), %rax     # 0x36a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x2d1ce(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2cf48(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9b65
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b55
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9b55
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b6d
jmp 0x9b57
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x9b13
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2ceae(%rip), %rax     # 0x36a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x2d11b(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2ce95(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9c1f
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x9c0f
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
jne 0x9c0f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
movb $0x0, %al
callq *%rcx
jmp 0x9c11
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x9bc6
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2cdfe(%rip), %rax     # 0x36a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x2d06b(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2cde5(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9ccb
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9cbb
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9cbb
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
jmp 0x9cbd
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x9c76
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2cd8d(%rip), %rax     # 0x36a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x2cffa(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2cd74(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9d38
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d28
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9d28
movq -0x10(%rbp), %rdi
callq 0x99e0
jmp 0x9d2a
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x9ce7
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2cd21(%rip), %rax     # 0x36a70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x2cf8e(%rip), %rcx     # 0x36cec
movslq (%rcx), %rdx
leaq 0x2cd08(%rip), %rcx     # 0x36a70
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9dc7
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x9db7
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
jle 0x9db7
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rcx)
cmpl $0x0, %eax
jne 0x9db5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x99e0
jmp 0x9db7
jmp 0x9db9
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x9d53
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d3be(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0x2d3ae(%rip), %rax     # 0x371d0
movq (%rax), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x2cebf(%rip), %rax     # 0x36cfc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2ceb3(%rip), %rax     # 0x36cfc
movl %ecx, (%rax)
leaq 0x2d37e(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jle 0x9e84
leaq 0x2cea0(%rip), %rax     # 0x36d08
testb $0x1, (%rax)
jne 0x9e84
movl -0x1c(%rbp), %edi
subl $0xf, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x8, -0x14(%rbp)
jge 0x9eb0
leaq 0x2ce6b(%rip), %rax     # 0x36cfc
movl (%rax), %eax
movl -0x14(%rbp), %edx
shll %edx
movl $0x14, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x9eae
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x9ed8
leaq 0x2ce45(%rip), %rax     # 0x36cfc
cmpl $0x3, (%rax)
jl 0x9ed6
movl -0x14(%rbp), %edi
subl $0x7, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x9ed8
xorl %edi, %edi
movl $0x9, %esi
callq 0x181d0
testb $0x1, %al
jne 0x9eea
jmp 0x9ef5
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x9, %esi
callq 0x181d0
testb $0x1, %al
jne 0x9f0a
jmp 0x9f15
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x400, %edi            # imm = 0x400
callq 0xaa60
testb $0x1, %al
jne 0x9f25
jmp 0x9f30
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x9f7a
leaq 0x2cdd1(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
leaq 0x2d27e(%rip), %rcx     # 0x371d0
movq (%rcx), %rcx
cmpl 0x34(%rcx), %eax
jle 0x9f6d
leaq 0x2d26f(%rip), %rax     # 0x371d0
movq (%rax), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq 0x2cd88(%rip), %rax     # 0x36cfc
movl $0x0, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x2cc7f(%rip), %eax     # 0x36c50
addl $0x1, %eax
movl %eax, 0x2cc76(%rip)     # 0x36c50
cmpl $0x4, %eax
jl 0xa032
movl $0x1, %edi
movl $0x6, %esi
callq 0xef70
cmpl $0x4, %eax
jne 0xa028
leaq 0x2ccda(%rip), %rax     # 0x36cd4
cmpl $0x1, (%rax)
je 0xa006
movb $0x0, %al
callq 0x10900
leaq -0x4d(%rip), %rdi       # 0x9fc0
callq 0x9cd0
leaq -0x89(%rip), %rdi       # 0x9f90
movl $0x1, %esi
movl $0x46, %edx
callq 0x9c30
movl $0x0, 0x2cc1e(%rip)     # 0x36c50
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xaa60
testb $0x1, %al
jne 0xa05b
jmp 0xa069
leaq 0x1f933(%rip), %rdi     # 0x29995
movb $0x0, %al
callq 0xd8f0
leaq 0x2d060(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x201, %rcx           # imm = 0xFDFF
leaq 0x2d04e(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
callq 0xaa60
testb $0x1, %al
jne 0xa0db
jmp 0xa0e9
leaq 0x1f8cf(%rip), %rdi     # 0x299b1
movb $0x0, %al
callq 0xd8f0
leaq 0x2cfe0(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x2, %rcx
leaq 0x2cfd1(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
leaq 0x2cfc6(%rip), %rdi     # 0x370d0
addq $0x50, %rdi
callq 0x123b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x8000, %edi           # imm = 0x8000
callq 0xaa60
testb $0x1, %al
jne 0xa13b
jmp 0xa149
leaq 0x1f88b(%rip), %rdi     # 0x299cd
movb $0x0, %al
callq 0xd8f0
leaq 0x2cf80(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x8001, %rcx          # imm = 0xFFFF7FFF
leaq 0x2cf6e(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10000, %edi          # imm = 0x10000
callq 0xaa60
testb $0x1, %al
jne 0xa39b
jmp 0xa3fe
leaq 0x1f6c4(%rip), %rdi     # 0x29a66
movb $0x0, %al
callq 0xd8f0
leaq 0x2cd20(%rip), %rax     # 0x370d0
movsbl 0x8f(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0xdca0
testb $0x1, %al
jne 0xa3cb
jmp 0xa3fc
movl -0x8(%rbp), %edi
callq 0x8a50
movq %rax, %rsi
leaq 0x1f6ab(%rip), %rdi     # 0x29a88
movb $0x0, %al
callq 0xd8f0
leaq 0x213a7(%rip), %rdi     # 0x2b792
movb $0x0, %al
callq 0xd8f0
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x18260
jmp 0xa3fe
leaq 0x2cccb(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x10001, %rcx         # imm = 0xFFFEFFFF
leaq 0x2ccb9(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x4, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %edi
addl $0x1, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x16910
leaq -0x32(%rip), %rdi       # 0xa430
movl $0x1, %esi
movl $0x96, %edx
callq 0x9c30
leaq 0x2c89b(%rip), %rax     # 0x36d13
movb $0x0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x4000, %edi           # imm = 0x4000
callq 0xaa60
testb $0x1, %al
jne 0xa4ab
jmp 0xa4b9
leaq 0x1f5ed(%rip), %rdi     # 0x29a9f
movb $0x0, %al
callq 0xd8f0
leaq 0x2cc10(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x4001, %rcx          # imm = 0xBFFF
leaq 0x2cbfe(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0xaa60
testb $0x1, %al
jne 0xa4fb
jmp 0xa509
leaq 0x1f5ba(%rip), %rdi     # 0x29abc
movb $0x0, %al
callq 0xd8f0
leaq 0x2cbc0(%rip), %rax     # 0x370d0
movq 0x78(%rax), %rcx
andq $-0x401, %rcx           # imm = 0xFBFF
leaq 0x2cbae(%rip), %rax     # 0x370d0
movq %rcx, 0x78(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop