LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read
int rs_read(int inf, void *ptr, int size)
{
    int actual;

    end_of_file = FALSE;

    if (!read_error && !format_error)
    {
        actual = encread(ptr, size, inf);

        if ((actual == 0) && (size != 0))
           end_of_file = TRUE;
    }
       
    if (read_error)
    {
        printf("read error has occurred. restore short-circuited.\n");
        abort();
    }

    if (format_error)
    {
        printf("format error: %s\r\n", fmterr);
        printf("game format invalid. restore short-circuited.\n");
        abort();
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, 0x20250(%rip)     # 0x3c8fc
cmpl $0x0, 0x2023d(%rip)     # 0x3c8f0
jne 0x1c6e8
cmpl $0x0, 0x2023c(%rip)     # 0x3c8f8
jne 0x1c6e8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x1bc90
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x1c6e6
cmpl $0x0, -0x14(%rbp)
je 0x1c6e6
movl $0x1, 0x20216(%rip)     # 0x3c8fc
jmp 0x1c6e8
cmpl $0x0, 0x20201(%rip)     # 0x3c8f0
je 0x1c704
leaq 0x10c43(%rip), %rdi     # 0x2d33b
movb $0x0, %al
callq 0x61b0
callq 0x6080
cmpl $0x0, 0x201ed(%rip)     # 0x3c8f8
je 0x1c735
movq 0x19e5c(%rip), %rsi     # 0x36570
leaq 0x10c53(%rip), %rdi     # 0x2d36e
movb $0x0, %al
callq 0x61b0
leaq 0x10c58(%rip), %rdi     # 0x2d381
movb $0x0, %al
callq 0x61b0
callq 0x6080
xorl %eax, %eax
cmpl $0x0, 0x201ba(%rip)     # 0x3c8f8
movb %al, -0x19(%rbp)
jne 0x1c750
cmpl $0x0, 0x201a6(%rip)     # 0x3c8f0
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%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_boolean
int rs_read_boolean(int inf, bool *i)
{
    unsigned char buf;
    
    rs_read(inf, &buf, 1);
    
    *i = (bool) buf;
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1c690
cmpb $0x0, -0x11(%rbp)
setne %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x2010f(%rip)     # 0x3c8f8
movb %al, -0x12(%rbp)
jne 0x1c7fb
cmpl $0x0, 0x200fb(%rip)     # 0x3c8f0
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %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_read_int
int rs_read_int(int inf, int *i)
{
    unsigned char bytes[4];
    int  input;
    unsigned char *buf = (unsigned char *)&input;
    
    rs_read(inf, &input, 4);

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    *i = *((int *) buf);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1c690
cmpl $0x0, 0x200c1(%rip)     # 0x3c900
je 0x1c870
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x13(%rbp)
movq -0x20(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x20073(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1c897
cmpl $0x0, 0x2005f(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %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_booleans
int rs_read_booleans(int inf, bool *i, int count)
{
    int n = 0, value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
        {
            printf("Invalid booleans block. %d != requested %d\n",value,count); 
            format_error = TRUE;
        }
        else
        {
            for(n = 0; n < value; n++)
                rs_read_boolean(inf, &i[n]);
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1c93a
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1c909
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x10aba(%rip), %rdi     # 0x2d3b0
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1fff1(%rip)     # 0x3c8f8
jmp 0x1c938
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1c936
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
callq 0x1c7b0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c910
jmp 0x1c938
jmp 0x1c93a
xorl %eax, %eax
cmpl $0x0, 0x1ffb5(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1c955
cmpl $0x0, 0x1ffa1(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %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_read_shint
int rs_read_shint(int inf, unsigned char *i)
{
    unsigned char buf;
    
    rs_read(inf, &buf, 1);
    
    *i = (unsigned char) buf;
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1c690
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1ff56(%rip)     # 0x3c8f8
movb %al, -0x12(%rbp)
jne 0x1c9b4
cmpl $0x0, 0x1ff42(%rip)     # 0x3c8f0
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %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_read_short
int rs_read_short(int inf, short *i)
{
    unsigned char bytes[2];
    short  input;
    unsigned char *buf = (unsigned char *)&input;
    
    rs_read(inf, &input, 2);

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

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x2, %edx
callq 0x1c690
cmpl $0x0, 0x1ff01(%rip)     # 0x3c900
je 0x1ca1c
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1fec5(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1ca45
cmpl $0x0, 0x1feb1(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %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_shorts
int rs_read_shorts(int inf, short *i, int count)
{
    int n = 0, value = 0;

    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
            format_error = TRUE;
        else
        {
            for(n = 0; n < value; n++)
                rs_read_short(inf, &i[n]);
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1cad9
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1caa5
movl $0x1, 0x1fe55(%rip)     # 0x3c8f8
jmp 0x1cad7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1cad5
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq %rax
addq %rax, %rsi
callq 0x1c9d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1caac
jmp 0x1cad7
jmp 0x1cad9
xorl %eax, %eax
cmpl $0x0, 0x1fe16(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1caf4
cmpl $0x0, 0x1fe02(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %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_read_ushort
int rs_read_ushort(int inf, unsigned short *i)
{
    unsigned char bytes[2];
    unsigned short  input;
    unsigned char *buf = (unsigned char *)&input;
    
    rs_read(inf, &input, 2);

    if (big_endian)
    {
        bytes[1] = buf[0];
        bytes[0] = buf[1];
        buf = bytes;
    }
    
    *i = *((unsigned short *) buf);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x2, %edx
callq 0x1c690
cmpl $0x0, 0x1fdc1(%rip)     # 0x3c900
je 0x1cb5c
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1fd85(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1cb85
cmpl $0x0, 0x1fd71(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %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_ints
int rs_read_ints(int inf, int *i, int count)
{
    int n = 0, value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
            format_error = TRUE;
        else
        {
            for(n = 0; n < value; n++)
                rs_read_int(inf, &i[n]);
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1cc1a
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1cbe5
movl $0x1, 0x1fd15(%rip)     # 0x3c8f8
jmp 0x1cc18
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1cc16
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x1c810
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1cbec
jmp 0x1cc18
jmp 0x1cc1a
xorl %eax, %eax
cmpl $0x0, 0x1fcd5(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1cc35
cmpl $0x0, 0x1fcc1(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %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_read_uint
int rs_read_uint(int inf, unsigned int *i)
{
    unsigned char bytes[4];
    int  input;
    unsigned char *buf = (unsigned char *)&input;
    
    rs_read(inf, &input, 4);

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    *i = *((unsigned int *) buf);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1c690
cmpl $0x0, 0x1fc81(%rip)     # 0x3c900
je 0x1ccb0
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x13(%rbp)
movq -0x20(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1fc33(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1ccd7
cmpl $0x0, 0x1fc1f(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %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_long
int rs_read_long(int inf, long *i)
{
    unsigned char bytes[4];
    long input;
    unsigned char *buf = (unsigned char *) &input;
    
    rs_read(inf, &input, 4);

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    *i = *((long *) buf);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1c690
cmpl $0x0, 0x1fbe1(%rip)     # 0x3c900
je 0x1cd50
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x28(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x13(%rbp)
movq -0x28(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1fb91(%rip)     # 0x3c8f8
movb %al, -0x29(%rbp)
jne 0x1cd79
cmpl $0x0, 0x1fb7d(%rip)     # 0x3c8f0
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_longs
int rs_read_longs(int inf, long *i, int count)
{
    int n = 0, value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
            format_error = TRUE;
        else
        {
            for(n = 0; n < value; n++)
                rs_read_long(inf, &i[n]);
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1ce0a
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1cdd5
movl $0x1, 0x1fb25(%rip)     # 0x3c8f8
jmp 0x1ce08
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1ce06
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1ccf0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1cddc
jmp 0x1ce08
jmp 0x1ce0a
xorl %eax, %eax
cmpl $0x0, 0x1fae5(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1ce25
cmpl $0x0, 0x1fad1(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %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_read_ulong
int rs_read_ulong(int inf, unsigned long *i)
{
    unsigned char bytes[4];
    unsigned long input;
    unsigned char *buf = (unsigned char *) &input;
    
    rs_read(inf, &input, 4);

    if (big_endian)
    {
        bytes[3] = buf[0];
        bytes[2] = buf[1];
        bytes[1] = buf[2];
        bytes[0] = buf[3];
        buf = bytes;
    }
    
    *i = *((unsigned long *) buf);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1c690
cmpl $0x0, 0x1fa91(%rip)     # 0x3c900
je 0x1cea0
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x28(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x13(%rbp)
movq -0x28(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1fa41(%rip)     # 0x3c8f8
movb %al, -0x29(%rbp)
jne 0x1cec9
cmpl $0x0, 0x1fa2d(%rip)     # 0x3c8f0
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_ulongs
int rs_read_ulongs(int inf, unsigned long *i, int count)
{
    int n = 0, value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
            format_error = TRUE;
        else
        {
            for(n = 0; n < value; n++)
                rs_read_ulong(inf, &i[n]);
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1cf5a
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1cf25
movl $0x1, 0x1f9d5(%rip)     # 0x3c8f8
jmp 0x1cf58
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1cf56
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1ce40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1cf2c
jmp 0x1cf58
jmp 0x1cf5a
xorl %eax, %eax
cmpl $0x0, 0x1f995(%rip)     # 0x3c8f8
movb %al, -0x1d(%rbp)
jne 0x1cf75
cmpl $0x0, 0x1f981(%rip)     # 0x3c8f0
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %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_read_string
int rs_read_string(int inf, char *s, int max)
{
    int len = 0;

    if (rs_read_int(inf, &len) != FALSE)
    {
        if (len > max)
        {
            printf("String too long to restore. %d > %d\n",len,max);
            printf("Sorry, invalid save game format\n");
            format_error = TRUE;
        }
    
        rs_read(inf, s, len);
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1cffd
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1cfee
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x1040d(%rip), %rdi     # 0x2d3dc
movb $0x0, %al
callq 0x61b0
leaq 0x10424(%rip), %rdi     # 0x2d401
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1f90a(%rip)     # 0x3c8f8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x1c690
xorl %eax, %eax
cmpl $0x0, 0x1f8f2(%rip)     # 0x3c8f8
movb %al, -0x19(%rbp)
jne 0x1d018
cmpl $0x0, 0x1f8de(%rip)     # 0x3c8f0
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %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_read_new_string
int rs_read_new_string(int inf, char **s)
{
    int len=0;
    char *buf=0;

    if (rs_read_int(inf, &len) != 0)
    {
        if (len == 0)
            *s = NULL;
        else
        { 
            buf = malloc(len);

            if (buf == NULL)            
                read_error = TRUE;
            else
            {
                rs_read(inf, buf, len);
                *s = buf;
            }
        }
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1d0b0
cmpl $0x0, -0x14(%rbp)
jne 0x1d072
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1d0ae
movslq -0x14(%rbp), %rdi
callq 0x6350
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1d092
movl $0x1, 0x1f860(%rip)     # 0x3c8f0
jmp 0x1d0ac
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1c690
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d0ae
jmp 0x1d0b0
xorl %eax, %eax
cmpl $0x0, 0x1f83f(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1d0cb
cmpl $0x0, 0x1f82b(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_string_index
int rs_read_string_index(int inf, char *master[], int maxindex, char **str)
{
    int i;

    if (rs_read_int(inf,&i) != 0)
    {
        if (i > maxindex)
        {
            printf("String index is out of range. %d > %d\n", i, maxindex);
            printf("Sorry, invalid save game format\n");
            format_error = TRUE;
        }
        else if (i >= 0)
            *str = master[i];
        else
            *str = NULL;
    }

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x24(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1d167
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1d13d
movl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x10306(%rip), %rdi     # 0x2d422
movb $0x0, %al
callq 0x61b0
leaq 0x102d7(%rip), %rdi     # 0x2d401
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1f7bd(%rip)     # 0x3c8f8
jmp 0x1d165
cmpl $0x0, -0x24(%rbp)
jl 0x1d158
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d163
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1d165
jmp 0x1d167
xorl %eax, %eax
cmpl $0x0, 0x1f788(%rip)     # 0x3c8f8
movb %al, -0x25(%rbp)
jne 0x1d182
cmpl $0x0, 0x1f774(%rip)     # 0x3c8f0
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_strings
int rs_read_strings(int inf, char **s, int count, int max)
{
    int len   = 0;
    int n     = 0;
    int value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
        {
            printf("Incorrect number of strings in block. %d > %d.", 
                value, count);
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }
        else
        {
            for(n = 0; n < value; n++)
            {
                rs_read_string(inf, s[n], max);
            }
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x4(%rbp), %edi
leaq -0x24(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1d236
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1d201
movl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x10269(%rip), %rdi     # 0x2d449
movb $0x0, %al
callq 0x61b0
leaq 0x1028a(%rip), %rdi     # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1f6f9(%rip)     # 0x3c8f8
jmp 0x1d234
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1d232
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x18(%rbp), %edx
callq 0x1cf90
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d208
jmp 0x1d234
jmp 0x1d236
xorl %eax, %eax
cmpl $0x0, 0x1f6b9(%rip)     # 0x3c8f8
movb %al, -0x25(%rbp)
jne 0x1d251
cmpl $0x0, 0x1f6a5(%rip)     # 0x3c8f0
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%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: rs_read_new_strings
int rs_read_new_strings(int inf, char **s, int count)
{
    int len   = 0;
    int n     = 0;
    int value = 0;
    
    if (rs_read_int(inf,&value) != 0)
    {
        if (value != count)
        {
            printf("Incorrect number of new strings in block. %d > %d.",
                value,count);abort();
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }
        else
            for(n=0; n<value; n++)
            {
                rs_read_int(inf, &len);
            
                if (len == 0)
                    s[n]=0;
                else 
                {
                    s[n] = malloc(len);
                    rs_read(inf,s[n],len);
                }
            }
    }
    
    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 -0x20(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1d330
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1d2bd
movl -0x20(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x101e7(%rip), %rdi     # 0x2d498
movb $0x0, %al
callq 0x61b0
callq 0x6080
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1d32c
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
callq 0x1c810
cmpl $0x0, -0x18(%rbp)
jne 0x1d2f0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1d31f
movslq -0x18(%rbp), %rdi
callq 0x6350
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x18(%rbp), %edx
callq 0x1c690
jmp 0x1d321
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d2c4
jmp 0x1d32e
jmp 0x1d330
xorl %eax, %eax
cmpl $0x0, 0x1f5bf(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1d34b
cmpl $0x0, 0x1f5ab(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_window
int rs_write_window(FILE *savef, WINDOW *win)
{
    int row,col,height,width;
    width = getmaxx(win);
    height = getmaxy(win);

    rs_write_int(savef,RSID_WINDOW);
    rs_write_int(savef,height);
    rs_write_int(savef,width);
    
    for(row=0;row<height;row++)
        for(col=0;col<width;col++)
            rs_write_int(savef, mvwinch(win,row,col));
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d428
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d432
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x1d432
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d450
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1d45a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x1d45a
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xabcd000d, %esi       # imm = 0xABCD000D
callq 0x1bf60
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x1bf60
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1d4fa
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1d4ed
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0x1d4ca
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x1d4d6
movq -0x10(%rbp), %rdi
callq 0x6340
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1bf60
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d49c
jmp 0x1d4ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d48d
cmpl $0x0, 0x1f3f3(%rip)     # 0x3c8f4
sete %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_window
int rs_read_window(int inf, WINDOW *win)
{
    int id,row,col,maxlines,maxcols,value,width,height;
    
    width = getmaxx(win);
    height = getmaxy(win);

    if (rs_read_int(inf, &id) != 0)
    {
        if (id != RSID_WINDOW)
        {
            printf("Invalid head id. %x != %x(RSID_WINDOW)\n", id, RSID_WINDOW);
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }   
        else
        {
            rs_read_int(inf,&maxlines);
            rs_read_int(inf,&maxcols);
            if (maxlines > height)
               abort();
            if (maxcols > width)
               abort();
               
            for(row=0;row<maxlines;row++)
                for(col=0;col<maxcols;col++)
                {
                    rs_read_int(inf, &value);
                    mvwaddch(win,row,col,value);
                }
        }
    }
        
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d537
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1d541
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x1d541
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d55f
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1d569
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x38(%rbp)
jmp 0x1d569
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1d65a
cmpl $0xabcd000d, -0x14(%rbp) # imm = 0xABCD000D
je 0x1d5c0
movl -0x14(%rbp), %esi
leaq 0xff34(%rip), %rdi      # 0x2d4cb
movl $0xabcd000d, %edx       # imm = 0xABCD000D
movb $0x0, %al
callq 0x61b0
leaq 0xfece(%rip), %rdi      # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1f33d(%rip)     # 0x3c8f8
jmp 0x1d658
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
leaq -0x24(%rbp), %rsi
callq 0x1c810
movl -0x20(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x1d5e5
callq 0x6080
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x1d5f2
callq 0x6080
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1d656
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1d649
movl -0x4(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0x1c810
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x6490
cmpl $-0x1, %eax
jne 0x1d632
jmp 0x1d63e
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x64c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d608
jmp 0x1d64b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d5f9
jmp 0x1d658
jmp 0x1d65a
xorl %eax, %eax
cmpl $0x0, 0x1f295(%rip)     # 0x3c8f8
movb %al, -0x39(%rbp)
jne 0x1d675
cmpl $0x0, 0x1f281(%rip)     # 0x3c8f0
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_room_reference
int rs_write_room_reference(FILE *savef, struct room *rp)
{
    int i, room = -1;
    
    for (i = 0; i < MAXROOMS; i++)
        if (&rooms[i] == rp)
            room = i;

    rs_write_int(savef, room);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jge 0x1de4f
movslq -0x14(%rbp), %rcx
leaq 0x18ef1(%rip), %rax     # 0x36d20
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpq -0x10(%rbp), %rax
jne 0x1de42
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1de44
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1de1e
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1bf60
cmpl $0x0, 0x1ea92(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_room_reference
int rs_read_room_reference(int inf, struct room **rp)
{
    int i;
    
    rs_read_int(inf, &i);

    *rp = &rooms[i];
            
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
movslq -0x14(%rbp), %rax
leaq 0x18e8a(%rip), %rcx     # 0x36d20
imulq $0x68, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1ea4b(%rip)     # 0x3c8f8
movb %al, -0x15(%rbp)
jne 0x1debf
cmpl $0x0, 0x1ea37(%rip)     # 0x3c8f0
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %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_monlev
int rs_write_monlev(FILE *savef, struct monlev m)
{
    rs_write_int(savef, m.l_lev);
    rs_write_int(savef, m.h_lev);
    rs_write_boolean(savef, m.d_wand);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rsi, -0x1c(%rbp)
movb %al, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1bf60
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x1bf60
movq -0x28(%rbp), %rdi
movb -0x4(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1bf00
cmpl $0x0, 0x1e5a1(%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_monlev
int rs_read_monlev(int inf, struct monlev *m)
{
    rs_read_int(inf, &m->l_lev);
    rs_read_int(inf, &m->h_lev);
    rs_read_boolean(inf, &m->d_wand);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1c7b0
xorl %eax, %eax
cmpl $0x0, 0x1e544(%rip)     # 0x3c8f8
movb %al, -0x11(%rbp)
jne 0x1e3c6
cmpl $0x0, 0x1e530(%rip)     # 0x3c8f0
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %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_magic_items
int rs_write_magic_items(FILE *savef, struct magic_item *i, int count)
{
    int n;
    
    rs_write_int(savef, RSID_MAGICITEMS);
    rs_write_int(savef, count);

    for(n = 0; n < count; n++)
    {
        /* mi_name is constant, defined at compile time in all cases */
        rs_write_int(savef,i[n].mi_prob);
    }
    
    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 $0xabcd0004, %esi       # imm = 0xABCD0004
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 0x1e442
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x1bf60
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e414
cmpl $0x0, 0x1e4ab(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_magic_items
int rs_read_magic_items(int inf, struct magic_item *mi, int count)
{
    int id;
    int n;
    int value;

    if (rs_read_int(inf, &id) != 0)
    {
        if (id != RSID_MAGICITEMS)
        {
            printf("Invalid id. %x != %x(RSID_MAGICITEMS)\n",
                id, RSID_MAGICITEMS);
            printf("Sorry, invalid save game format");
            format_error = TRUE;
        }   
        else if (rs_read_int(inf, &value) != 0)
        {
            if (value > count)
            {
                printf("Incorrect number of magic items in block. %d > %d.",
                    value, count);
                printf("Sorry, invalid save game format");
                format_error = TRUE;
            }
            else
            {
                for(n = 0; n < value; n++)
                {
                    rs_read_int(inf,&mi[n].mi_prob);
                }
            }
        }
    }
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1e547
cmpl $0xabcd0004, -0x18(%rbp) # imm = 0xABCD0004
je 0x1e4c3
movl -0x18(%rbp), %esi
leaq 0xf0f4(%rip), %rdi      # 0x2d58e
movl $0xabcd0004, %edx       # imm = 0xABCD0004
movb $0x0, %al
callq 0x61b0
leaq 0xefcb(%rip), %rdi      # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1e43a(%rip)     # 0x3c8f8
jmp 0x1e545
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x1c810
cmpl $0x0, %eax
je 0x1e543
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1e50a
movl -0x20(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0xf0cc(%rip), %rdi      # 0x2d5b5
movb $0x0, %al
callq 0x61b0
leaq 0xef81(%rip), %rdi      # 0x2d478
movb $0x0, %al
callq 0x61b0
movl $0x1, 0x1e3f0(%rip)     # 0x3c8f8
jmp 0x1e541
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1e53f
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
addq $0x8, %rsi
callq 0x1c810
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e511
jmp 0x1e541
jmp 0x1e543
jmp 0x1e545
jmp 0x1e547
xorl %eax, %eax
cmpl $0x0, 0x1e3a8(%rip)     # 0x3c8f8
movb %al, -0x21(%rbp)
jne 0x1e562
cmpl $0x0, 0x1e394(%rip)     # 0x3c8f0
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_real
int rs_write_real(FILE *savef, struct real r)
{
    rs_write_int(savef, r.a_str);
    rs_write_int(savef, r.a_dex);
    rs_write_int(savef, r.a_wis);
    rs_write_int(savef, r.a_con);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1bf60
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1bf60
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x1bf60
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1bf60
cmpl $0x0, 0x1e339(%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_read_real
int rs_read_real(int inf, struct real *r)
{
    rs_read_int(inf,&r->a_str);
    rs_read_int(inf,&r->a_dex);
    rs_read_int(inf,&r->a_wis);
    rs_read_int(inf,&r->a_con);

    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
callq 0x1c810
xorl %eax, %eax
cmpl $0x0, 0x1e2d4(%rip)     # 0x3c8f8
movb %al, -0x11(%rbp)
jne 0x1e636
cmpl $0x0, 0x1e2c0(%rip)     # 0x3c8f0
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %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_stats
int rs_write_stats(FILE *savef, struct stats *s)
{
    rs_write_int(savef, RSID_STATS);
    rs_write_real(savef, s->s_re);
    rs_write_real(savef, s->s_ef);
    rs_write_long(savef, s->s_exp);
    rs_write_int(savef, s->s_lvl);
    rs_write_int(savef, s->s_arm);
    rs_write_int(savef, s->s_hpt);
    rs_write_int(savef, s->s_maxhp);
    rs_write_int(savef, s->s_pack);
    rs_write_int(savef, s->s_carry);
    rs_write(savef, s->s_dmg, sizeof(s->s_dmg));

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xabcd0001, %esi       # imm = 0xABCD0001
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x1e570
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x1e570
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1c2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %esi
callq 0x1bf60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movl $0x10, %edx
callq 0x1be50
cmpl $0x0, 0x1e1cf(%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_stats
int rs_read_stats(int inf, struct stats *s)
{
    int id;

    rs_read_int(inf, &id);
    rs_read_real(inf, &s->s_re);
    rs_read_real(inf, &s->s_ef);

    rs_read_long(inf,&s->s_exp);
    rs_read_int(inf,&s->s_lvl);
    rs_read_int(inf,&s->s_arm);
    rs_read_int(inf,&s->s_hpt);
    rs_read_int(inf,&s->s_maxhp);
    rs_read_int(inf,&s->s_pack);
    rs_read_int(inf,&s->s_carry);

    rs_read(inf,s->s_dmg,sizeof(s->s_dmg));
    
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1e5d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1e5d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x1ccf0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x2c, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x34, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x3c, %rsi
callq 0x1c810
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movl $0x10, %edx
callq 0x1c690
xorl %eax, %eax
cmpl $0x0, 0x1e0f3(%rip)     # 0x3c8f8
movb %al, -0x15(%rbp)
jne 0x1e817
cmpl $0x0, 0x1e0df(%rip)     # 0x3c8f0
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %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_monster_reference
int rs_write_monster_reference(FILE *savef, struct monster *m)
{
    int i, mon = -1;
    
    for (i = 0; i < (MAXMONS+1); i++)
        if (&monsters[i] == m)
            mon = i;

    rs_write_int(savef, mon);

    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x35, -0x14(%rbp)
jge 0x1e87f
movslq -0x14(%rbp), %rcx
leaq 0x14b61(%rip), %rax     # 0x333c0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq -0x10(%rbp), %rax
jne 0x1e872
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1e874
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e84e
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1bf60
cmpl $0x0, 0x1e062(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_monster_reference
int rs_read_monster_reference(int inf, struct monster **mp)
{
    int i;
    
    rs_read_int(inf, &i);

    if (i < 0)
        *mp = NULL;
    else
        *mp = &monsters[i];
            
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x1c810
cmpl $0x0, -0x14(%rbp)
jge 0x1e8ce
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1e8e7
movslq -0x14(%rbp), %rax
leaq 0x14ae7(%rip), %rcx     # 0x333c0
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x1e008(%rip)     # 0x3c8f8
movb %al, -0x15(%rbp)
jne 0x1e902
cmpl $0x0, 0x1dff4(%rip)     # 0x3c8f0
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_write_monster_references
int rs_write_monster_references(FILE *savef, struct monster *marray[], int count)
{
    int i;

    for(i = 0; i < count; i++)
        rs_write_monster_reference(savef, marray[i]);
    return(WRITESTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e952
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1e830
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e92a
cmpl $0x0, 0x1df9b(%rip)     # 0x3c8f4
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/state.c
// Function: rs_read_monster_references
int rs_read_monster_references(int inf, struct monster *marray[], int count)
{
    int i;

    for(i = 0; i < count; i++)
        rs_read_monster_reference(inf, &marray[i]);
    return(READSTAT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e9b3
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1e8a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e989
xorl %eax, %eax
cmpl $0x0, 0x1df3c(%rip)     # 0x3c8f8
movb %al, -0x19(%rbp)
jne 0x1e9ce
cmpl $0x0, 0x1df28(%rip)     # 0x3c8f0
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)