LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_object_list
int rs_read_object_list(int inf, struct linked_list **list)
{
    int id;
    int i, cnt;
    struct linked_list *l = NULL, *previous = NULL, *head = NULL;

    if (rs_read_int(inf,&id) != 0)
    {
        if (rs_read_int(inf,&cnt) != 0)
        {
            for (i = 0; i < cnt; i++) 
            {
                l = new_item(sizeof(struct object));
                memset(l->l_data,0,sizeof(struct object));
                l->l_prev = previous;
                if (previous != NULL)
                    previous->l_next = l;
                rs_read_object(inf,(struct object *) l->l_data);
                if (previous == NULL)
                    head = l;
                previous = l;
            }
            
            if (l != NULL)
                l->l_next = NULL;
    
            *list = head;
        }
        else
            format_error = TRUE;
    }
    else
        format_error = TRUE;


    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1f13d
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1f131
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1f112
movl $0x50, %edi
callq 0xe4d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x6220
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x1f0e0
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1ed90
cmpq $0x0, -0x30(%rbp)
jne 0x1f0ff
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f098
cmpq $0x0, -0x28(%rbp)
je 0x1f124
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f13b
movl $0x1, 0x1d7bd(%rip)     # 0x3c8f8
jmp 0x1f147
movl $0x1, 0x1d7b1(%rip)     # 0x3c8f8
xorl %eax, %eax
cmpl $0x0, 0x1d7a8(%rip)     # 0x3c8f8
movb %al, -0x39(%rbp)
jne 0x1f162
cmpl $0x0, 0x1d794(%rip)     # 0x3c8f0
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_object_list
int rs_write_object_list(FILE *savef, struct linked_list *l)
{
    rs_write_int(savef, RSID_OBJECTLIST);
    rs_write_int(savef, list_size(l));

    while (l != NULL) 
    {
        rs_write_object(savef, (struct object *) l->l_data);
        l = l->l_next;
    }
    
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xabcd0007, %esi       # imm = 0xABCD0007
callq 0x1bf60
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1be00
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x1bf60
cmpq $0x0, -0x10(%rbp)
je 0x1f1cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1e9e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f1aa
cmpl $0x0, 0x1d71e(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_traps
int rs_write_traps(FILE *savef, struct trap *trap,int count)
{
    int n;

    rs_write_int(savef, RSID_TRAP);
    rs_write_int(savef, count);
    
    for(n=0; n<count; n++)
    {
        rs_write_coord(savef, trap[n].tr_pos);
        rs_write_coord(savef, trap[n].tr_goto);
        rs_write_int(savef, trap[n].tr_flags);
        rs_write_char(savef, trap[n].tr_type);
    }
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xabcd000c, %esi       # imm = 0xABCD000C
callq 0x1bf60
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f2a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1d360
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x1d360
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsbl 0x14(%rax), %esi
callq 0x1bec0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f224
cmpl $0x0, 0x1d645(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_monsters
int rs_write_monsters(FILE * savef, struct monster * m, int count)
{
    int n;
    
    rs_write_int(savef, RSID_MONSTERS);
    rs_write_int(savef, count);

    for(n=0;n<count;n++)
    {
        rs_write_monlev(savef, m[n].m_lev);
        rs_write_stats(savef, &m[n].m_stats);
    }
    
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xabcd000b, %esi       # imm = 0xABCD000B
callq 0x1bf60
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f4e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0xc(%rax), %rcx
movq %rcx, -0x28(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movzbl -0x20(%rbp), %edx
callq 0x1e300
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
addq $0x20, %rsi
callq 0x1e650
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f484
cmpl $0x0, 0x1d40c(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_monsters
int rs_read_monsters(int inf, struct monster *m, int count)
{
    int id = 0, value = 0, n = 0;
    
    if (rs_read_int(inf, &id) != 0)
    {
        if (id != RSID_MONSTERS)
        {
            printf("Invalid id. %x != %x(RSID_MONSTERS)\n",
                id,RSID_MONSTERS);
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }
        else if (rs_read_int(inf, &value) != 0)
        {
            for(n=0;n<value;n++)
            {
                rs_read_monlev(inf, &m[n].m_lev);
                rs_read_stats(inf, &m[n].m_stats);
            }
        }
        else
            format_error = TRUE;
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1f5e6
cmpl $0xabcd000b, -0x18(%rbp) # imm = 0xABCD000B
je 0x1f575
movl -0x18(%rbp), %esi
leaq 0xe309(%rip), %rdi      # 0x2d858
movl $0xabcd000b, %edx       # imm = 0xABCD000B
movb $0x0, %al
callq 0x61b0
leaq 0xdf16(%rip), %rdi      # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1d385(%rip)     # 0x3c8f8
jmp 0x1f5e4
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1f5d8
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1f5d6
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
addq $0xc, %rsi
callq 0x1e370
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
addq $0x20, %rsi
callq 0x1e740
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1f58d
jmp 0x1f5e2
movl $0x1, 0x1d316(%rip)     # 0x3c8f8
jmp 0x1f5e4
jmp 0x1f5e6
xorl %eax, %eax
cmpl $0x0, 0x1d309(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1f601
cmpl $0x0, 0x1d2f5(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: find_thing_coord
int find_thing_coord(struct linked_list *monlist, struct coord *c)
{
    struct linked_list *mitem;
    struct thing *tp;
    int i = 0;

    for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
    {
        tp = THINGPTR(mitem);
        if (c == &tp->t_pos)
            return(i);
        i++;
    }

    return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f66d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x50, %rcx
cmpq %rcx, %rax
jne 0x1f657
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f674
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f62b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: find_object_coord
int find_object_coord(struct linked_list *objlist, struct coord *c)
{
    struct linked_list *oitem;
    struct object *obj;
    int i = 0;

    for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
    {
        obj = OBJPTR(oitem);
        if (c == &obj->o_pos)
            return(i);
        i++;
    }

    return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f6d9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1f6c3
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f6e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f69b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_fix_thing
void rs_fix_thing(struct thing *t)
{
    struct linked_list *item;
    struct thing *tp;

    if (t->t_reserved < 0)
        return;

    item = get_list_item(mlist,t->t_reserved);

    if (item != NULL)
    {
        tp = THINGPTR(item);
        t->t_dest = &tp->t_pos;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x90(%rax), %eax
cmpl $0x0, %eax
jge 0x1f70e
jmp 0x1f74f
leaq 0x1759b(%rip), %rax     # 0x36cb0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movsbl 0x90(%rax), %esi
callq 0x1bd40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f74f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: find_room_coord
int find_room_coord(struct room *rmlist, struct coord *c, int n)
{
    int i = 0;
    
    for(i=0; i < n; i++)
        if(&rmlist[i].r_gold == c)
            return(i);
    
    return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1f7b3
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
cmpq -0x18(%rbp), %rax
jne 0x1f7a6
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f7ba
jmp 0x1f7a8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1f77d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_monster_list
int rs_write_monster_list(FILE *savef, struct linked_list *l)
{
    int cnt = 0;
    
    rs_write_int(savef, RSID_MONSTERLIST);

    cnt = list_size(l);

    rs_write_int(savef, cnt);

    if (cnt < 1)
        return(WRITESTAT);

    while (l != NULL) {
        rs_write_thing(savef, (struct thing *)l->l_data);
        l = l->l_next;
    }
    
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xabcd0009, %esi       # imm = 0xABCD0009
callq 0x1bf60
movq -0x18(%rbp), %rdi
callq 0x1be00
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bf60
cmpl $0x1, -0x1c(%rbp)
jge 0x1fd77
cmpl $0x0, 0x1cb8a(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1fdb0
jmp 0x1fd79
cmpq $0x0, -0x18(%rbp)
je 0x1fd9e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1f7c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1fd79
cmpl $0x0, 0x1cb4f(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_monster_list
int rs_read_monster_list(int inf, struct linked_list **list)
{
    int id;
    int i, cnt;
    struct linked_list *l = NULL, *previous = NULL, *head = NULL;

    if (rs_read_int(inf,&id) != 0)
    {
        if (id != RSID_MONSTERLIST)
        {
            printf("Invalid id. %x != %x(RSID_MONSTERLIST)\n",
                id,RSID_MONSTERLIST);
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }
        else if (rs_read_int(inf,&cnt) != 0)
        {
            for (i = 0; i < cnt; i++) 
            {
                l = new_item(sizeof(struct thing));
                l->l_prev = previous;
                if (previous != NULL)
                    previous->l_next = l;
                rs_read_thing(inf,(struct thing *)l->l_data);
                if (previous == NULL)
                    head = l;
                previous = l;
            }
        

            if (l != NULL)
                l->l_next = NULL;

            *list = head;
        }
    }
    else format_error = TRUE;
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1fedb
cmpl $0xabcd0009, -0x14(%rbp) # imm = 0xABCD0009
je 0x1fe38
movl -0x14(%rbp), %esi
leaq 0xda90(%rip), %rdi      # 0x2d89f
movl $0xabcd0009, %edx       # imm = 0xABCD0009
movb $0x0, %al
callq 0x61b0
leaq 0xd656(%rip), %rdi      # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1cac5(%rip)     # 0x3c8f8
jmp 0x1fed9
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1fed7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1feba
movl $0x98, %edi
callq 0xe4d0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x1fe88
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1fa50
cmpq $0x0, -0x30(%rbp)
jne 0x1fea7
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1fe54
cmpq $0x0, -0x28(%rbp)
je 0x1fecc
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1fed9
jmp 0x1fee5
movl $0x1, 0x1ca13(%rip)     # 0x3c8f8
xorl %eax, %eax
cmpl $0x0, 0x1ca0a(%rip)     # 0x3c8f8
movb %al, -0x39(%rbp)
jne 0x1ff00
cmpl $0x0, 0x1c9f6(%rip)     # 0x3c8f0
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_object_reference
int rs_read_object_reference(int inf, struct linked_list *list, struct object **item)
{
    int i;
    
    rs_read_int(inf, &i);
    *item = get_list_item(list,i);
            
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bd40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1c95a(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1ffb0
cmpl $0x0, 0x1c946(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_scrolls
int rs_read_scrolls(int inf)
{
    int i;

    for(i = 0; i < MAXSCROLLS; i++)
    {
        rs_read_new_string(inf,&s_names[i]);
        rs_read_boolean(inf,&s_know[i]);
        rs_read_new_string(inf,&s_guess[i]);
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1a, -0x8(%rbp)
jge 0x2002d
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x199aa(%rip), %rsi     # 0x39990
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d030
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x19850(%rip), %rsi     # 0x39850
addq %rax, %rsi
callq 0x1c7b0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x1951a(%rip), %rsi     # 0x39530
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1ffd2
xorl %eax, %eax
cmpl $0x0, 0x1c8c2(%rip)     # 0x3c8f8
movb %al, -0x9(%rbp)
jne 0x20048
cmpl $0x0, 0x1c8ae(%rip)     # 0x3c8f0
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_scrolls
int rs_write_scrolls(FILE *savef)
{
    int i;

    for(i = 0; i < MAXSCROLLS; i++)
    {
        rs_write_string(savef,s_names[i]);
        rs_write_boolean(savef,s_know[i]);
        rs_write_string(savef,s_guess[i]);
    }
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1a, -0xc(%rbp)
jge 0x200d0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19908(%rip), %rax     # 0x39990
movq (%rax,%rcx,8), %rsi
callq 0x1c4d0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x197b0(%rip), %rax     # 0x39850
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19474(%rip), %rax     # 0x39530
movq (%rax,%rcx,8), %rsi
callq 0x1c4d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20073
xorl %eax, %eax
cmpl $0x0, 0x1c81f(%rip)     # 0x3c8f8
movb %al, -0xd(%rbp)
jne 0x200eb
cmpl $0x0, 0x1c80b(%rip)     # 0x3c8f0
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_potions
int rs_read_potions(int inf)
{
    int i;

    for(i = 0; i < MAXPOTIONS; i++)
    {
        rs_read_string_index(inf,rainbow,NCOLORS,&p_colors[i]);
        rs_read_boolean(inf,&p_know[i]);
        rs_read_new_string(inf,&p_guess[i]);
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x15, -0x8(%rbp)
jge 0x20179
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x1993a(%rip), %rcx     # 0x39a60
shlq $0x3, %rax
addq %rax, %rcx
leaq 0x159ec(%rip), %rsi     # 0x35b20
movl $0x20, %edx
callq 0x1d0e0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x19724(%rip), %rsi     # 0x39870
addq %rax, %rsi
callq 0x1c7b0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x1949e(%rip), %rsi     # 0x39600
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x20112
xorl %eax, %eax
cmpl $0x0, 0x1c776(%rip)     # 0x3c8f8
movb %al, -0x9(%rbp)
jne 0x20194
cmpl $0x0, 0x1c762(%rip)     # 0x3c8f0
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_potions
int rs_write_potions(FILE *savef)
{
    int i;

    for(i = 0; i < MAXPOTIONS; i++)
    {
        rs_write_string_index(savef,rainbow,NCOLORS,p_colors[i]);
        rs_write_boolean(savef,p_know[i]);
        rs_write_string(savef,p_guess[i]);
    }

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x15, -0xc(%rbp)
jge 0x2022c
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19888(%rip), %rax     # 0x39a60
movq (%rax,%rcx,8), %rcx
leaq 0x1593d(%rip), %rsi     # 0x35b20
movl $0x20, %edx
callq 0x1c540
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19674(%rip), %rax     # 0x39870
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x193e8(%rip), %rax     # 0x39600
movq (%rax,%rcx,8), %rsi
callq 0x1c4d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x201c3
cmpl $0x0, 0x1c6c1(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_rings
int rs_read_rings(int inf)
{
    int i;

    for(i = 0; i < MAXRINGS; i++)
    {
        rs_read_string_index(inf,stones,NSTONES,&r_stones[i]);
        rs_read_boolean(inf,&r_know[i]);
        rs_read_new_string(inf,&r_guess[i]);
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1a, -0x8(%rbp)
jge 0x202c9
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x1989a(%rip), %rcx     # 0x39b10
shlq $0x3, %rax
addq %rax, %rcx
leaq 0x15e9c(%rip), %rsi     # 0x36120
movl $0x23, %edx
callq 0x1d0e0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x195f4(%rip), %rsi     # 0x39890
addq %rax, %rsi
callq 0x1c7b0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x193fe(%rip), %rsi     # 0x396b0
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x20262
xorl %eax, %eax
cmpl $0x0, 0x1c626(%rip)     # 0x3c8f8
movb %al, -0x9(%rbp)
jne 0x202e4
cmpl $0x0, 0x1c612(%rip)     # 0x3c8f0
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_rings
int rs_write_rings(FILE *savef)
{
    int i;

    for(i = 0; i < MAXRINGS; i++)
    {
        rs_write_string_index(savef,stones,NSTONES,r_stones[i]);
        rs_write_boolean(savef,r_know[i]);
        rs_write_string(savef,r_guess[i]);
    }

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1a, -0xc(%rbp)
jge 0x2037c
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x197e8(%rip), %rax     # 0x39b10
movq (%rax,%rcx,8), %rcx
leaq 0x15ded(%rip), %rsi     # 0x36120
movl $0x23, %edx
callq 0x1c540
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19544(%rip), %rax     # 0x39890
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19348(%rip), %rax     # 0x396b0
movq (%rax,%rcx,8), %rsi
callq 0x1c4d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20313
cmpl $0x0, 0x1c571(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_sticks
int rs_write_sticks(FILE *savef)
{
    int i;

    for (i = 0; i < MAXSTICKS; i++)
    {
        if (strcmp(ws_stuff[i].ws_type,"staff") == 0)
        {
            rs_write_int(savef,0);
            rs_write_string_index(savef, wood, NWOOD, ws_stuff[i].ws_made);
        }
        else
        {
            rs_write_int(savef,1);
            rs_write_string_index(savef, metal, NMETAL, ws_stuff[i].ws_made);
        }
        rs_write_int(savef, ws_stuff[i].ws_vol);
        rs_write_int(savef, ws_stuff[i].ws_wght);
        rs_write_boolean(savef, ws_know[i]);
        rs_write_string(savef, ws_guess[i]);
    }

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1a, -0xc(%rbp)
jge 0x204d2
movslq -0xc(%rbp), %rcx
leaq 0x19818(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x9e32(%rip), %rsi      # 0x2a20b
callq 0x6250
cmpl $0x0, %eax
jne 0x2041b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x197e3(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x15e31(%rip), %rsi     # 0x36240
movl $0x18, %edx
callq 0x1c540
jmp 0x20454
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x197a8(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x15eb6(%rip), %rsi     # 0x36300
movl $0xf, %edx
callq 0x1c540
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x1977d(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x1975f(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x19411(%rip), %rax     # 0x398b0
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x192c5(%rip), %rax     # 0x39780
movq (%rax,%rcx,8), %rsi
callq 0x1c4d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x203b3
cmpl $0x0, 0x1c41b(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_sticks
int rs_read_sticks(int inf)
{
    int i = 0, list = 0;

    for(i = 0; i < MAXSTICKS; i++)
    {
        rs_read_int(inf,&list);
        if (list == 0)
        {
            rs_read_string_index(inf,wood,NWOOD,&ws_stuff[i].ws_made);
            ws_stuff[i].ws_type = "staff";
        }
        else
        {
            rs_read_string_index(inf,metal,NMETAL,&ws_stuff[i].ws_made);
            ws_stuff[i].ws_type = "wand";
        }
        rs_read_int(inf, &ws_stuff[i].ws_vol);
        rs_read_int(inf, &ws_stuff[i].ws_wght);

        rs_read_boolean(inf, &ws_know[i]);
        rs_read_new_string(inf, &ws_guess[i]);
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1a, -0x8(%rbp)
jge 0x20634
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
callq 0x1c810
cmpl $0x0, -0xc(%rbp)
jne 0x20574
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x196a6(%rip), %rcx     # 0x39be0
imulq $0x18, %rax, %rax
addq %rax, %rcx
addq $0x8, %rcx
leaq 0x15cf4(%rip), %rsi     # 0x36240
movl $0x18, %edx
callq 0x1d0e0
movslq -0x8(%rbp), %rcx
leaq 0x1967f(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
leaq 0x9c9c(%rip), %rcx      # 0x2a20b
movq %rcx, (%rax)
jmp 0x205ba
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x1965e(%rip), %rcx     # 0x39be0
imulq $0x18, %rax, %rax
addq %rax, %rcx
addq $0x8, %rcx
leaq 0x15d6c(%rip), %rsi     # 0x36300
movl $0xf, %edx
callq 0x1d0e0
movslq -0x8(%rbp), %rcx
leaq 0x19637(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
leaq 0xa052(%rip), %rcx      # 0x2a609
movq %rcx, (%rax)
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x19618(%rip), %rsi     # 0x39be0
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x195fa(%rip), %rsi     # 0x39be0
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x14, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x192ac(%rip), %rsi     # 0x398b0
addq %rax, %rsi
callq 0x1c7b0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x19166(%rip), %rsi     # 0x39780
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x20510
xorl %eax, %eax
cmpl $0x0, 0x1c2bb(%rip)     # 0x3c8f8
movb %al, -0xd(%rbp)
jne 0x2064f
cmpl $0x0, 0x1c2a7(%rip)     # 0x3c8f0
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/sticks.c
// Function: fix_stick
void fix_stick(struct object *cur)
{
	struct rod *rd;

	cur->o_type = STICK;
	cur->o_charges = 4 + rnd(5);
	strcpy(cur->o_hurldmg, "1d1");
	rd = &ws_stuff[cur->o_which];
	cur->o_weight = rd->ws_wght;
	cur->o_vol = rd->ws_vol;
	if (strcmp(rd->ws_type, "staff") == 0) {
		strcpy(cur->o_damage, "2d3");
		cur->o_charges += rnd(5) + 3;
	}
	else {
		strcpy(cur->o_damage, "1d1");
	}
	switch (cur->o_which) {
		case WS_HIT:
			if(rnd(100) < 15) {
				cur->o_hplus = 9;
				cur->o_dplus = 9;
				strcpy(cur->o_damage,"3d8");
			}
			else {
				cur->o_hplus = 3;
				cur->o_dplus = 3;
				strcpy(cur->o_damage,"1d8");
			}
		when WS_LIGHT:
			cur->o_charges += 7 + rnd(9);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2f, 0x20(%rax)
movl $0x5, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x4, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0x9291(%rip), %rsi      # 0x2a49f
callq 0x60d0
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0x189be(%rip), %rax     # 0x39be0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x8fb4(%rip), %rsi      # 0x2a20b
callq 0x6250
cmpl $0x0, %eax
jne 0x21292
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xc728(%rip), %rsi      # 0x2d998
callq 0x60d0
movl $0x5, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x3, %ecx
movq -0x8(%rbp), %rax
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
jmp 0x212a6
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x91fe(%rip), %rsi      # 0x2a49f
callq 0x60d0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x2132d
jmp 0x212b6
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x21348
jmp 0x212c4
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0xf, %eax
jge 0x21301
movq -0x8(%rbp), %rax
movl $0x9, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xc6a2(%rip), %rsi      # 0x2d99c
callq 0x60d0
jmp 0x2132b
movq -0x8(%rbp), %rax
movl $0x3, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x9189(%rip), %rsi      # 0x2a4af
callq 0x60d0
jmp 0x21348
movl $0x9, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x7, %ecx
movq -0x8(%rbp), %rax
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/sticks.c
// Function: charge_str
char *charge_str(struct object *obj)
{
	static char buf[20];

	buf[0] = '\0';
	if (o_on(obj,ISKNOW) || o_on(obj,ISPOST))
		sprintf(buf, " [%d]", obj->o_charges);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, 0x1990d(%rip)     # 0x3c910
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xaac0
testb $0x1, %al
jne 0x23029
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xaac0
testb $0x1, %al
jne 0x23029
jmp 0x23045
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
leaq 0x198d9(%rip), %rdi     # 0x3c910
leaq 0xaa89(%rip), %rsi      # 0x2dac7
movb $0x0, %al
callq 0x64f0
leaq 0x198c4(%rip), %rax     # 0x3c910
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/things.c
// Function: money
void money()
{
	struct room *rp;
	struct linked_list *item;
	struct thing *tp;

	rp = player.t_room;
	if (rp != NULL && ce(hero, rp->r_gold)) {
		msg("%d gold pieces.", rp->r_goldval);
		purse += rp->r_goldval;
		rp->r_goldval = 0;
		cmov(rp->r_gold);
		addch(FLOOR);
		/*
		 * once gold is taken, all monsters will chase him
		 */
		for (item = mlist; item != NULL; item = next(item)) {
			tp = THINGPTR(item);
			if (rnd(100) < 70 && tp->t_room == rp && !iswearing(R_STEALTH)
			  && ((tp->t_flags & (ISMEAN | ISGREED)) || rnd(1000) < 20))
				runto(&tp->t_pos, &hero);
		}
	}
	else
		msg("That gold must have been counterfeit.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x13621(%rip), %rax     # 0x370d0
movq 0x70(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23bfb
leaq 0x13607(%rip), %rax     # 0x370d0
movl 0x50(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x23bfb
leaq 0x135f0(%rip), %rax     # 0x370d0
movl 0x54(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x23bfb
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
leaq 0xa1d9(%rip), %rdi      # 0x2dcd7
movb $0x0, %al
callq 0xd8f0
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
leaq 0x131c9(%rip), %rax     # 0x36cdc
addl (%rax), %ecx
leaq 0x131c0(%rip), %rax     # 0x36cdc
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq 0xf490(%rip), %rax      # 0x32fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x6490
movq 0xf473(%rip), %rax      # 0x32fc0
movq (%rax), %rdi
movl $0x2e, %esi
callq 0x64c0
leaq 0x1314f(%rip), %rax     # 0x36cb0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x23bf9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
cmpl $0x46, %eax
jge 0x23be7
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x23be7
movl $0xc, %edi
callq 0x18220
testb $0x1, %al
jne 0x23be7
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
andq $0x60, %rax
cmpq $0x0, %rax
jne 0x23bcf
movl $0x3e8, %edi            # imm = 0x3E8
movb $0x0, %al
callq 0xef20
cmpl $0x14, %eax
jge 0x23be7
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
leaq 0x134f2(%rip), %rsi     # 0x370d0
addq $0x50, %rsi
callq 0x7bf0
jmp 0x23be9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x23b68
jmp 0x23c09
leaq 0xa0e5(%rip), %rdi      # 0x2dce7
movb $0x0, %al
callq 0xd8f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/things.c
// Function: dropcheck
bool dropcheck(struct object *op)
{
	if (op == NULL)
		return TRUE;
	if (levtype == POSTLEV) {
		if (o_on(op,ISCURSED) && o_on(op,ISKNOW)) {
			msg("The trader does not accept shoddy merchandise.");
			return FALSE;
		}
		else {
			cur_null(op);	/* update cur_weapon, etc */
			return TRUE;
		}
	}
	if (op != cur_armor && op != cur_weapon
	  && op != cur_ring[LEFT] && op != cur_ring[RIGHT])
		return TRUE;
	if (o_on(op,ISCURSED)) {
		msg("You can't.  It appears to be cursed.");
		return FALSE;
	}
	if (op == cur_weapon)
		cur_weapon = NULL;
	else if (op == cur_armor) {
		waste_time();
		cur_armor = NULL;
	}
	else if (op == cur_ring[LEFT] || op == cur_ring[RIGHT])
		toss_ring(op);
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x23ecc
movb $0x1, -0x1(%rbp)
jmp 0x24014
leaq 0x12e01(%rip), %rax     # 0x36cd4
cmpl $0x1, (%rax)
jne 0x23f29
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xaac0
testb $0x1, %al
jne 0x23eec
jmp 0x23f17
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xaac0
testb $0x1, %al
jne 0x23f00
jmp 0x23f17
leaq 0x9e84(%rip), %rdi      # 0x2dd8b
movb $0x0, %al
callq 0xd8f0
movb $0x0, -0x1(%rbp)
jmp 0x24014
movq -0x10(%rbp), %rdi
callq 0x15160
movb $0x1, -0x1(%rbp)
jmp 0x24014
movq -0x10(%rbp), %rax
leaq 0x12d94(%rip), %rcx     # 0x36cc8
cmpq (%rcx), %rax
je 0x23f73
movq -0x10(%rbp), %rax
leaq 0x12d7c(%rip), %rcx     # 0x36cc0
cmpq (%rcx), %rax
je 0x23f73
movq -0x10(%rbp), %rax
leaq 0x1326c(%rip), %rcx     # 0x371c0
cmpq (%rcx), %rax
je 0x23f73
movq -0x10(%rbp), %rax
leaq 0x1325c(%rip), %rcx     # 0x371c0
cmpq 0x8(%rcx), %rax
je 0x23f73
movb $0x1, -0x1(%rbp)
jmp 0x24014
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xaac0
testb $0x1, %al
jne 0x23f87
jmp 0x23f9b
leaq 0x9e2c(%rip), %rdi      # 0x2ddba
movb $0x0, %al
callq 0xd8f0
movb $0x0, -0x1(%rbp)
jmp 0x24014
movq -0x10(%rbp), %rax
leaq 0x12d1a(%rip), %rcx     # 0x36cc0
cmpq (%rcx), %rax
jne 0x23fbb
leaq 0x12d0e(%rip), %rax     # 0x36cc0
movq $0x0, (%rax)
jmp 0x24010
movq -0x10(%rbp), %rax
leaq 0x12d02(%rip), %rcx     # 0x36cc8
cmpq (%rcx), %rax
jne 0x23fe2
movb $0x0, %al
callq 0xf360
leaq 0x12cef(%rip), %rax     # 0x36cc8
movq $0x0, (%rax)
jmp 0x2400e
movq -0x10(%rbp), %rax
leaq 0x131d3(%rip), %rcx     # 0x371c0
cmpq (%rcx), %rax
je 0x24003
movq -0x10(%rbp), %rax
leaq 0x131c3(%rip), %rcx     # 0x371c0
cmpq 0x8(%rcx), %rax
jne 0x2400c
movq -0x10(%rbp), %rdi
callq 0x17a20
jmp 0x2400e
jmp 0x24010
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/things.c
// Function: basic_init
void basic_init(struct object *cur)
{
	cur->o_ac = 11;
	cur->o_count = 1;
	cur->o_launch = 0;
	cur->o_typname = NULL;
	cur->o_group = newgrp();
	cur->o_weight = cur->o_vol = 0;
	cur->o_hplus = cur->o_dplus = 0;
	strcpy(cur->o_damage,"0d0");
	strcpy(cur->o_hurldmg,"0d0");
	cur->o_flags = cur->o_type = cur->o_which = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xb, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
leaq 0xef47(%rip), %rax      # 0x33304
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xef3b(%rip), %rax      # 0x33304
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x724d(%rip), %rsi      # 0x2b65a
callq 0x60d0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7239(%rip), %rsi      # 0x2b65a
callq 0x60d0
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/things.c
// Function: pick_one
int pick_one(struct magic_item *mag)
{
	struct magic_item *start;
	int i;

	start = mag;
	for (i = rnd(1000); mag->mi_name != NULL; mag++) {
		if (i < mag->mi_prob)
			break;
		if (mag->mi_name == NULL) {
			if (author() || wizard) {
				for (mag = start; mag->mi_name != NULL; mag++)
					msg("%s: %d%%", mag->mi_name, mag->mi_prob);
			}
			mag = start;
		}
	}
	return mag - start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x3e8, %edi            # imm = 0x3E8
movb $0x0, %al
callq 0xef20
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24509
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2448f
jmp 0x24509
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x244f6
movb $0x0, %al
callq 0xf130
testb $0x1, %al
jne 0x244b0
leaq 0x12862(%rip), %rax     # 0x36d0d
testb $0x1, (%rax)
je 0x244ee
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x244ec
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x990d(%rip), %rdi      # 0x2dde4
movb $0x0, %al
callq 0xd8f0
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x244b8
jmp 0x244ee
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x244f8
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x24473
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/things.c
// Function: extras
int extras()
{
	int i;

	i = rnd(100);
	if (i < 4)			/* 4% for 2 more */
		return 2;
	else if (i < 11)	/* 7% for 1 more */
		return 1;
	else				/* otherwise no more */
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
movl %eax, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x24546
movl $0x2, -0x4(%rbp)
jmp 0x2455c
cmpl $0xb, -0x8(%rbp)
jge 0x24555
movl $0x1, -0x4(%rbp)
jmp 0x2455c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/trader.c
// Function: price_it
bool price_it()
{
	static char *bargain[] = {
		"great bargain",
		"quality product",
		"exceptional find",
	};
	struct linked_list *item;
	struct object *obj;
	int worth;

	if (!open_market())		/* after buying hours */
		return FALSE;
	if ((item = find_obj(hero.y,hero.x)) == NULL)
		return FALSE;
	obj = OBJPTR(item);
	if (curprice == NOTPRICED) {
		worth = get_worth(obj);
		worth += 50 - rnd(100);
		if (worth < 25)
			worth = 25;
		worth *= 3;							/* slightly expensive */
		curprice = worth;					/* save price */
		strcpy(curpurch, obj->o_typname);	/* save item */
	}
	msg("That %s is a %s for only %d pieces of gold", curpurch,
	  bargain[rnd(3)], curprice);
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x24e40
testb $0x1, %al
jne 0x247ba
movb $0x0, -0x1(%rbp)
jmp 0x24897
leaq 0x1290f(%rip), %rax     # 0x370d0
movl 0x54(%rax), %edi
leaq 0x12905(%rip), %rax     # 0x370d0
movl 0x50(%rax), %esi
movb $0x0, %al
callq 0xfcb0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x247e8
movb $0x0, -0x1(%rbp)
jmp 0x24897
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xeaf9(%rip), %rax      # 0x332f4
cmpl $-0x1, (%rax)
jne 0x2485b
movq -0x18(%rbp), %rdi
callq 0x248b0
movl %eax, -0x1c(%rbp)
movl $0x64, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
movl $0x32, %eax
subl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x19, -0x1c(%rbp)
jge 0x24834
movl $0x19, -0x1c(%rbp)
imull $0x3, -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
leaq 0xeaaf(%rip), %rax      # 0x332f4
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x12a90(%rip), %rdi     # 0x372e6
callq 0x60d0
movl $0x3, %edi
movb $0x0, %al
callq 0xef20
movslq %eax, %rcx
leaq 0x11ddf(%rip), %rax     # 0x36650
movq (%rax,%rcx,8), %rdx
leaq 0xea78(%rip), %rax      # 0x332f4
movl (%rax), %ecx
leaq 0x9764(%rip), %rdi      # 0x2dfe9
leaq 0x12a5a(%rip), %rsi     # 0x372e6
movb $0x0, %al
callq 0xd8f0
movb $0x1, -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/weapons.c
// Function: fall
int fall(struct linked_list *item,bool pr)
{
	struct object *obj;
	struct room *rp;
	static struct coord fpos;

	obj = OBJPTR(item);
	if (fallpos(&obj->o_pos, &fpos, TRUE)) {
		mvaddch(fpos.y, fpos.x, obj->o_type);
		obj->o_pos = fpos;
		rp = player.t_room;
		if (rp != NULL && !rf_on(rp,ISDARK)) {
			light(&hero);
			mvwaddch(cw, hero.y, hero.x, PLAYER);
		}
		attach(lvl_obj, item);
		return 0;
	}

	if (pr) {
        if (obj->o_type == WEAPON) { /* BUGFIX: Identification trick */
            msg("Your %s vanishes as it hits the ground.", w_magic[obj->o_which].mi_name);
        } else {
            msg("%s vanishes as it hits the ground.", inv_name(obj,TRUE));
        }
  }

	discard(item);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x16cf5(%rip), %rsi     # 0x3c950
movl $0x1, %edx
callq 0x25dc0
testb $0x1, %al
jne 0x25c6e
jmp 0x25d44
movq 0xd34b(%rip), %rax      # 0x32fc0
movq (%rax), %rdi
movl 0x16cd6(%rip), %esi     # 0x3c954
movl 0x16ccc(%rip), %edx     # 0x3c950
callq 0x6490
cmpl $-0x1, %eax
jne 0x25c90
jmp 0x25ca6
movq 0xd329(%rip), %rax      # 0x32fc0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x64c0
movq -0x20(%rbp), %rax
movq 0x16c9f(%rip), %rcx     # 0x3c950
movq %rcx, (%rax)
leaq 0x11415(%rip), %rax     # 0x370d0
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x25d2b
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x19950
cmpl $0x0, %eax
jne 0x25d2b
leaq 0x113ec(%rip), %rdi     # 0x370d0
addq $0x50, %rdi
callq 0x123b0
leaq 0x1415c(%rip), %rax     # 0x39e50
movq (%rax), %rdi
leaq 0x113d2(%rip), %rax     # 0x370d0
movl 0x54(%rax), %esi
leaq 0x113c8(%rip), %rax     # 0x370d0
movl 0x50(%rax), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0x25d17
jmp 0x25d2b
leaq 0x14132(%rip), %rax     # 0x39e50
movq (%rax), %rdi
movl $0x40, %esi
callq 0x64c0
movq -0x10(%rbp), %rsi
leaq 0x10f82(%rip), %rdi     # 0x36cb8
callq 0xe3e0
movl $0x0, -0x4(%rbp)
jmp 0x25dae
testb $0x1, -0x11(%rbp)
je 0x25d9e
movq -0x20(%rbp), %rax
cmpl $0x29, 0x20(%rax)
jne 0x25d7d
movq -0x20(%rbp), %rax
movslq 0x28(%rax), %rcx
leaq 0xf22d(%rip), %rax      # 0x34f90
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x83dd(%rip), %rdi      # 0x2e151
movb $0x0, %al
callq 0xd8f0
jmp 0x25d9c
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movq %rax, %rsi
leaq 0x83c1(%rip), %rdi      # 0x2e156
movb $0x0, %al
callq 0xd8f0
jmp 0x25d9e
movq -0x10(%rbp), %rdi
callq 0xe490
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)