LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: peekType
int peekType() {
    unsigned char t;
    if (readBytes(&t, -1) && (checkType(t)))
        return t;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x5(%rbp), %rdi
movq $-0x1, %rsi
callq 0x12b0
cmpl $0x0, %eax
je 0x15b4
movzbl -0x5(%rbp), %edi
callq 0x1260
cmpl $0x0, %eax
je 0x15b4
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: processTime
int processTime(int type) {
    uint32_t offset = CURR_OFFSET;
    unsigned char t[8];
    int timelen = (type == REDIS_EXPIRETIME_MS) ? 8 : 4;

    if (readBytes(t,timelen)) {
        return 1;
    } else {
        SHIFT_ERROR(offset, "Could not read time");
    }

    /* failure */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movzbl 0x5c6e(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5ae5(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edx
movl $0x4, %eax
movl $0x8, %ecx
cmpl $0xfc, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x12b0
cmpl $0x0, %eax
je 0x162d
movl $0x1, -0x4(%rbp)
jmp 0x1684
movq 0x9ca4(%rip), %rax      # 0xb2d8
leaq 0x5c1d(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
leaq 0x2a90(%rip), %rsi      # 0x40d9
movb $0x0, %al
callq 0x1120
movl -0xc(%rbp), %eax
movl %eax, %edx
movq 0x9c7c(%rip), %rcx      # 0xb2d8
leaq 0x5bf5(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x9c66(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x9c5b(%rip)      # 0xb2d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadLength
uint32_t loadLength(int *isencoded) {
    unsigned char buf[2];
    uint32_t len;
    int type;

    if (isencoded) *isencoded = 0;
    if (!readBytes(buf, 1)) return REDIS_RDB_LENERR;
    type = (buf[0] & 0xC0) >> 6;
    if (type == REDIS_RDB_6BITLEN) {
        /* Read a 6 bit len */
        return buf[0] & 0x3F;
    } else if (type == REDIS_RDB_ENCVAL) {
        /* Read a 6 bit len encoding type */
        if (isencoded) *isencoded = 1;
        return buf[0] & 0x3F;
    } else if (type == REDIS_RDB_14BITLEN) {
        /* Read a 14 bit len */
        if (!readBytes(buf+1,1)) return REDIS_RDB_LENERR;
        return ((buf[0] & 0x3F) << 8) | buf[1];
    } else {
        /* Read a 32 bit len */
        if (!readBytes(&len, 4)) return REDIS_RDB_LENERR;
        return (unsigned int)ntohl(len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16ad
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x16cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1775
movzbl -0x12(%rbp), %eax
andl $0xc0, %eax
sarl $0x6, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x16f0
movzbl -0x12(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x4(%rbp)
jmp 0x1775
cmpl $0x3, -0x1c(%rbp)
jne 0x1713
cmpq $0x0, -0x10(%rbp)
je 0x1707
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movzbl -0x12(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x4(%rbp)
jmp 0x1775
cmpl $0x1, -0x1c(%rbp)
jne 0x174e
leaq -0x12(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1739
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1775
movzbl -0x12(%rbp), %eax
andl $0x3f, %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1775
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x176a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1775
movl -0x18(%rbp), %edi
callq 0x1140
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadIntegerObject
char *loadIntegerObject(int enctype) {
    uint32_t offset = CURR_OFFSET;
    unsigned char enc[4];
    long long val;

    if (enctype == REDIS_RDB_ENC_INT8) {
        uint8_t v;
        if (!readBytes(enc, 1)) return NULL;
        v = enc[0];
        val = (int8_t)v;
    } else if (enctype == REDIS_RDB_ENC_INT16) {
        uint16_t v;
        if (!readBytes(enc, 2)) return NULL;
        v = enc[0]|(enc[1]<<8);
        val = (int16_t)v;
    } else if (enctype == REDIS_RDB_ENC_INT32) {
        uint32_t v;
        if (!readBytes(enc, 4)) return NULL;
        v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
        val = (int32_t)v;
    } else {
        SHIFT_ERROR(offset, "Unknown integer encoding (0x%02x)", enctype);
        return NULL;
    }

    /* convert val into string */
    char *buf;
    buf = malloc(sizeof(char) * 128);
    sprintf(buf, "%lld", val);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movzbl 0x5abe(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5935(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x17e3
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x17cf
movq $0x0, -0x8(%rbp)
jmp 0x1907
movb -0x14(%rbp), %al
movb %al, -0x21(%rbp)
movsbq -0x21(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18db
cmpl $0x1, -0xc(%rbp)
jne 0x1828
leaq -0x14(%rbp), %rdi
movl $0x2, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1809
movq $0x0, -0x8(%rbp)
jmp 0x1907
movzbl -0x14(%rbp), %eax
movzbl -0x13(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x24(%rbp)
movswq -0x24(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18d9
cmpl $0x2, -0xc(%rbp)
jne 0x187a
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x184e
movq $0x0, -0x8(%rbp)
jmp 0x1907
movzbl -0x14(%rbp), %eax
movzbl -0x13(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x12(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x11(%rbp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18d7
movq 0x9a57(%rip), %rax      # 0xb2d8
leaq 0x59d0(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
movl -0xc(%rbp), %edx
leaq 0x2854(%rip), %rsi      # 0x40ed
movb $0x0, %al
callq 0x1120
movl -0x10(%rbp), %eax
movl %eax, %edx
movq 0x9a2c(%rip), %rcx      # 0xb2d8
leaq 0x59a5(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x9a16(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x9a0b(%rip)      # 0xb2d8
movq $0x0, -0x8(%rbp)
jmp 0x1907
jmp 0x18d9
jmp 0x18db
movl $0x80, %edi
callq 0x10e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x2817(%rip), %rsi      # 0x410f
movb $0x0, %al
callq 0x1120
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadLzfStringObject
char* loadLzfStringObject() {
    unsigned int slen, clen;
    char *c, *s;

    if ((clen = loadLength(NULL)) == REDIS_RDB_LENERR) return NULL;
    if ((slen = loadLength(NULL)) == REDIS_RDB_LENERR) return NULL;

    c = malloc(clen);
    if (!readBytes(c, clen)) {
        free(c);
        return NULL;
    }

    s = malloc(slen+1);
    if (lzf_decompress(c,clen,s,slen) == 0) {
        free(c); free(s);
        return NULL;
    }

    free(c);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1690
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
jne 0x1946
movq $0x0, -0x8(%rbp)
jmp 0x19f0
xorl %eax, %eax
movl %eax, %edi
callq 0x1690
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x1964
movq $0x0, -0x8(%rbp)
jmp 0x19f0
movl -0x10(%rbp), %eax
movl %eax, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1998
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x19f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
callq 0x3c80
cmpl $0x0, %eax
jne 0x19df
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x19f0
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadStringObject
char* loadStringObject() {
    uint32_t offset = CURR_OFFSET;
    int isencoded;
    uint32_t len;

    len = loadLength(&isencoded);
    if (isencoded) {
        switch(len) {
        case REDIS_RDB_ENC_INT8:
        case REDIS_RDB_ENC_INT16:
        case REDIS_RDB_ENC_INT32:
            return loadIntegerObject(len);
        case REDIS_RDB_ENC_LZF:
            return loadLzfStringObject();
        default:
            /* unknown encoding */
            SHIFT_ERROR(offset, "Unknown string encoding (0x%02x)", len);
            return NULL;
        }
    }

    if (len == REDIS_RDB_LENERR) return NULL;

    char *buf = malloc(sizeof(char) * (len+1));
    buf[len] = '\0';
    if (!readBytes(buf, len)) {
        free(buf);
        return NULL;
    }
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movzbl 0x5841(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x56b8(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl %eax, -0xc(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1690
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1acf
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
jb 0x1a53
jmp 0x1a49
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x1a64
jmp 0x1a72
movl -0x14(%rbp), %edi
callq 0x1780
movq %rax, -0x8(%rbp)
jmp 0x1b2f
callq 0x1920
movq %rax, -0x8(%rbp)
jmp 0x1b2f
movq 0x985f(%rip), %rax      # 0xb2d8
leaq 0x57d8(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
movl -0x14(%rbp), %edx
leaq 0x2683(%rip), %rsi      # 0x4114
movb $0x0, %al
callq 0x1120
movl -0xc(%rbp), %eax
movl %eax, %edx
movq 0x9834(%rip), %rcx      # 0xb2d8
leaq 0x57ad(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x981e(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x9813(%rip)      # 0xb2d8
movq $0x0, -0x8(%rbp)
jmp 0x1b2f
cmpl $-0x1, -0x14(%rbp)
jne 0x1adf
movq $0x0, -0x8(%rbp)
jmp 0x1b2f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1b27
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x1b2f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: processStringObject
int processStringObject(char** store) {
    unsigned long offset = CURR_OFFSET;
    char *key = loadStringObject();
    if (key == NULL) {
        SHIFT_ERROR(offset, "Error reading string object");
        free(key);
        return 0;
    }

    if (store != NULL) {
        *store = key;
    } else {
        free(key);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x56fd(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5574(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1a00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1bdc
movq 0x9756(%rip), %rax      # 0xb2d8
leaq 0x56cf(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
leaq 0x259e(%rip), %rsi      # 0x4135
movb $0x0, %al
callq 0x1120
movq -0x18(%rbp), %rdx
movq 0x972f(%rip), %rcx      # 0xb2d8
leaq 0x56a8(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x9719(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x970e(%rip)      # 0xb2d8
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1c00
cmpq $0x0, -0x10(%rbp)
je 0x1bf0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1bf9
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadDoubleValue
double* loadDoubleValue() {
    char buf[256];
    unsigned char len;
    double* val;

    if (!readBytes(&len,1)) return NULL;

    val = malloc(sizeof(double));
    switch(len) {
    case 255: *val = R_NegInf;  return val;
    case 254: *val = R_PosInf;  return val;
    case 253: *val = R_Nan;     return val;
    default:
        if (!readBytes(buf, len)) {
            free(val);
            return NULL;
        }
        buf[len] = '\0';
        sscanf(buf, "%lg", val);
        return val;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
leaq -0x111(%rbp), %rdi
movl $0x1, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1c3e
movq $0x0, -0x8(%rbp)
jmp 0x1d4f
movl $0x8, %edi
callq 0x10e0
movq %rax, -0x120(%rbp)
movzbl -0x111(%rbp), %eax
movl %eax, -0x124(%rbp)
subl $0xfd, %eax
je 0x1cc9
jmp 0x1c65
movl -0x124(%rbp), %eax
subl $0xfe, %eax
je 0x1ca6
jmp 0x1c74
movl -0x124(%rbp), %eax
subl $0xff, %eax
jne 0x1ce9
jmp 0x1c83
movsd 0x9655(%rip), %xmm0     # 0xb2e0
movq -0x120(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d4f
movsd 0x963a(%rip), %xmm0     # 0xb2e8
movq -0x120(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d4f
movsd 0x961f(%rip), %xmm0     # 0xb2f0
movq -0x120(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d4f
leaq -0x110(%rbp), %rdi
movzbl -0x111(%rbp), %eax
movl %eax, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x1d19
movq -0x120(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x1d4f
movzbl -0x111(%rbp), %eax
movb $0x0, -0x110(%rbp,%rax)
leaq -0x110(%rbp), %rdi
movq -0x120(%rbp), %rdx
leaq 0x2414(%rip), %rsi      # 0x4151
movb $0x0, %al
callq 0x10f0
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: processDoubleValue
int processDoubleValue(double** store) {
    unsigned long offset = CURR_OFFSET;
    double *val = loadDoubleValue();
    if (val == NULL) {
        SHIFT_ERROR(offset, "Error reading double value");
        free(val);
        return 0;
    }

    if (store != NULL) {
        *store = val;
    } else {
        free(val);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x54dd(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5354(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1c10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1dfc
movq 0x9536(%rip), %rax      # 0xb2d8
leaq 0x54af(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
leaq 0x239e(%rip), %rsi      # 0x4155
movb $0x0, %al
callq 0x1120
movq -0x18(%rbp), %rdx
movq 0x950f(%rip), %rcx      # 0xb2d8
leaq 0x5488(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x94f9(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x94ee(%rip)      # 0xb2d8
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1e20
cmpq $0x0, -0x10(%rbp)
je 0x1e10
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1e19
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: printCentered
void printCentered(int indent, int width, char* body) {
    char head[256], tail[256];
    memset(head, '\0', 256);
    memset(tail, '\0', 256);

    memset(head, '=', indent);
    memset(tail, '=', width - 2 - indent - strlen(body));
    printf("%s %s %s\n", head, body, tail);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq -0x110(%rbp), %rdi
movslq -0x4(%rbp), %rdx
movl $0x3d, %esi
callq 0x1090
leaq -0x210(%rbp), %rax
movq %rax, -0x218(%rbp)
movl -0x8(%rbp), %eax
subl $0x2, %eax
subl -0x4(%rbp), %eax
cltq
movq %rax, -0x220(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x220(%rbp), %rdx
movq -0x218(%rbp), %rdi
subq %rax, %rdx
movl $0x3d, %esi
callq 0x1090
leaq -0x110(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x210(%rbp), %rcx
leaq 0x1aa3(%rip), %rdi      # 0x42e0
movb $0x0, %al
callq 0x1080
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: printValid
void printValid(uint64_t ops, uint64_t bytes) {
    char body[80];
    sprintf(body, "Processed %llu valid opcodes (in %llu bytes)",
        (unsigned long long) ops, (unsigned long long) bytes);
    printCentered(4, 80, body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1a77(%rip), %rsi      # 0x42ea
movb $0x0, %al
callq 0x1120
leaq -0x60(%rbp), %rdx
movl $0x4, %edi
movl $0x50, %esi
callq 0x2790
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: printSkipped
void printSkipped(uint64_t bytes, uint64_t offset) {
    char body[80];
    sprintf(body, "Skipped %llu bytes (resuming at 0x%08llx)",
        (unsigned long long) bytes, (unsigned long long) offset);
    printCentered(4, 80, body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1a54(%rip), %rsi      # 0x4317
movb $0x0, %al
callq 0x1120
leaq -0x60(%rbp), %rdx
movl $0x4, %edi
movl $0x50, %esi
callq 0x2790
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/libUnit/unit.c
// Function: test_suite_named
static struct suite *test_suite_named(const char *name)
{
    if (test_suites == NULL) {
        suite_capacity = 1;
        test_suites = calloc(suite_capacity, sizeof(*test_suites));
    }

    // Try and find the suite first, only add it if we can't find it.
    for (int i = 0; i < suite_count; ++i) {
        struct suite *s = test_suites[i];
        if (strcmp(s->name, name) == 0) {
            return s;
        }
    }

    // Do we have room for a new suite?
    if (suite_count >= suite_capacity) {
        suite_capacity <<= 1; // Double the amount of space.
        test_suites = realloc(test_suites, sizeof(struct suite *) * suite_capacity);
    }

    // Add the suite, and then configure it.
    struct suite *s = calloc(1, sizeof(*s));
    test_suites[suite_count++] = s;

    s->name = name;
    s->capacity = 1;
    s->count = 0;
    s->failed = 0;
    s->cases = calloc(s->capacity, sizeof(*s->cases));

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x10400c(%rip)    # 0x109060
jne 0x5079
movq $0x1, 0x104007(%rip) # 0x109068
movq 0x104000(%rip), %rdi    # 0x109068
movl $0x8, %esi
callq 0x3050
movq %rax, 0x103fe7(%rip)    # 0x109060
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq 0x103fcd(%rip), %rax    # 0x109058
jge 0x50cf
movq 0x103fcc(%rip), %rax    # 0x109060
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3060
cmpl $0x0, %eax
jne 0x50c2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5198
jmp 0x50c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5080
movq 0x103f82(%rip), %rax    # 0x109058
cmpq 0x103f8b(%rip), %rax    # 0x109068
jl 0x510e
movq 0x103f82(%rip), %rax    # 0x109068
shlq %rax
movq %rax, 0x103f78(%rip)    # 0x109068
movq 0x103f69(%rip), %rdi    # 0x109060
movq 0x103f6a(%rip), %rsi    # 0x109068
shlq $0x3, %rsi
callq 0x3070
movq %rax, 0x103f52(%rip)    # 0x109060
movl $0x1, %edi
movl $0x28, %esi
callq 0x3050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x103f34(%rip), %rax    # 0x109060
movq 0x103f25(%rip), %rcx    # 0x109058
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x103f17(%rip)    # 0x109058
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0x3050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/libUnit/unit.c
// Function: test_case_named
static struct test_case *test_case_named(struct suite *s, const char *restrict name)
{
    // Do we have room a for a new test case?
    if (s->count >= s->capacity) {
        s->capacity <<= 1; // Double the amount of space.
        s->cases = realloc(s->cases, sizeof(struct test_case *) * s->capacity);
    }

    // Add the suite and then configure it.
    struct test_case *tc = calloc(1, sizeof(*tc));
    s->cases[s->count++] = tc;

    tc->name = name;

    return tc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jl 0x5205
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x3070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x18, %esi
callq 0x3050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/libUnit/unit.c
// Function: fail_assertion
void fail_assertion(void *a, void *b, const char *condition)
{
	struct suite *s = a;
	struct test_case *tc = b;

	s->failed++;
	tc->failed++;

	printf("\t\x1b[1;30mFailed: %s\x1b[0m\n", condition);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq 0x1437(%rip), %rdi      # 0x68b0
movb $0x0, %al
callq 0x3040
addq $0x30, %rsp
popq %rbp
retq
nop
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_initialise
int m68_mmu_initialise(void)
{
	/* Ensure the prior page directory is destroyed first */
	// m68_mmu_destroy();

	/* Initialise the page directory, and setup the initial page table and 
	 * page, to ensure we have at least 4KiB of accessible memory. */
	MMU_PAGE_DIR = calloc(MMU_PAGE_DIR_MAX_ENTRIES, sizeof(union m68_mmu_page_table_entry));
	if (MMU_PAGE_DIR == NULL) {
		return 1;
	}
	m68_mmu_page_alloc(0x00000000);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x400, %edi            # imm = 0x400
movl $0x8, %esi
callq 0x3050
movq %rax, %rcx
leaq 0x1036ef(%rip), %rax    # 0x109070
movq %rcx, (%rax)
leaq 0x1036e5(%rip), %rax    # 0x109070
cmpq $0x0, (%rax)
jne 0x599a
movl $0x1, -0x4(%rbp)
jmp 0x59a8
xorl %edi, %edi
callq 0x59c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_destroy
void m68_mmu_destroy(void)
{
	if ( MMU_PAGE_DIR ) {
		/* Iterate over all tables and then over all tables and release 
		 * everything. */
		for (int i = 0; i < MMU_PAGE_DIR_MAX_ENTRIES; ++i) {
			/* Skip if the table is not present in the directory */
			if (!MMU_PAGE_DIR[i].field.present) {
				continue;
			}

			/* Fetch the page table */
			union m68_mmu_page_entry *PAGE_TABLE = (void *)((uintptr_t)MMU_PAGE_DIR[i].field.address << 4);

			/* Iterate over all pages in the table */
			for (int j = 0; j < MMU_PAGE_TABLE_MAX_ENTRIES; ++j) {
				if (!PAGE_TABLE[i].field.present) {
					continue;
				}

				/* Fetch the page */
				void *PAGE = (void *)((uintptr_t)PAGE_TABLE[i].field.address << 4);
				free(PAGE);
			}

			free(PAGE_TABLE);
		}

		free(MMU_PAGE_DIR);
		MMU_PAGE_DIR = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1034d1(%rip), %rax    # 0x109070
cmpq $0x0, (%rax)
je 0x5c81
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jge 0x5c64
leaq 0x1034ac(%rip), %rax    # 0x109070
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5bdb
jmp 0x5c56
leaq 0x10348e(%rip), %rax    # 0x109070
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x4, %rax
shlq $0x4, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x5c4d
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5c21
jmp 0x5c42
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x4, %rax
shlq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5c00
movq -0x10(%rbp), %rdi
callq 0x3030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5bb0
leaq 0x103405(%rip), %rax    # 0x109070
movq (%rax), %rdi
callq 0x3030
leaq 0x1033f6(%rip), %rax    # 0x109070
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_write_word
void m68_mmu_write_word(uint32_t address, uint16_t value)
{
	uint8_t *ptr = m68_mmu_translate(address);
	value = TO_BIG_WORD(value);
	*(ptr + 1) = (value >> 8);
	*(ptr + 0) = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movl -0x4(%rbp), %edi
callq 0x5c90
movq %rax, -0x10(%rbp)
movzwl -0x6(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movzwl -0x6(%rbp), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movw -0x6(%rbp), %ax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_write_long
void m68_mmu_write_long(uint32_t address, uint32_t value)
{
	uint8_t *ptr = m68_mmu_translate(address);
	value = TO_BIG_LONG(value);
	*(ptr + 3) = (value >> 24);
	*(ptr + 2) = (value >> 16);
	*(ptr + 1) = (value >> 8);
	*(ptr + 0) = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x5c90
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movl -0x8(%rbp), %ecx
andl $0xff, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl -0x8(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x8, %ecx
orl %ecx, %eax
movl -0x8(%rbp), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
shrl $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x8(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/asm.c
// Function: appendef
void appendef(char *file, char *ext) {
	char *pos;                          /* position of ] if any */
	pos = strchr(file, ']');            /* end of vax path */
	if (!strchr(pos ? pos : file, '.')) /* already a dot? */
		strcat(file, ext);          /* if not, append extention */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5d, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22b3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x22bb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2e, %esi
callq 0x10c0
cmpq $0x0, %rax
jne 0x22dc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/asm.c
// Function: error_msg
void error_msg(char *msg, char *info, int fatal) { /* serious error messages */
	printf("\n%s%s", msg, info);
	if (fatal <= 1) return;
	fclose(file_tmp); /* close temporary file */
	remove(tmpdev);   /* delete temporary file */
	exit(fatal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xaf2c(%rip), %rdi      # 0xd23e
movb $0x0, %al
callq 0x10d0
cmpl $0x1, -0x14(%rbp)
jg 0x2325
addq $0x20, %rsp
popq %rbp
retq
movq 0xe40c(%rip), %rdi      # 0x10738
callq 0x1090
leaq 0xe588(%rip), %rdi      # 0x108c0
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x11e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/asm.c
// Function: display_error
void display_error(char c) {
/* append another error to error field if this error has not occurred before */
	char *p = error_field;
	while (*p) {
		if (*p == ' ') *p = c;
		if (*p == c) break;
		p++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
leaq 0xe8ff(%rip), %rax      # 0x10c60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x23a2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2383
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2394
jmp 0x23a2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2365
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/direct1.c
// Function: pushcond
int pushcond(int cond) {
	int i = 1 << (++condlevel & 15);
	if (cond)
		condstk[condlevel >> 4] |= i;
	else
		condstk[condlevel >> 4] &= ~i;
	if (condlevel >= 16 * MAXCNDLEV - 1)
		error_msg("conditional nesting depth exceeds maximum", "", 4);
	condit &= cond;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xe76e(%rip), %rax      # 0x10b50
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xe762(%rip), %rax      # 0x10b50
movl %ecx, (%rax)
andl $0xf, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2432
movl -0x8(%rbp), %edx
leaq 0xe743(%rip), %rax      # 0x10b50
movl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0xe8a4(%rip), %rax      # 0x10cc0
movswl (%rax,%rcx,2), %eax
orl %edx, %eax
movw %ax, %dx
leaq 0xe894(%rip), %rax      # 0x10cc0
movw %dx, (%rax,%rcx,2)
jmp 0x2462
movl -0x8(%rbp), %edx
xorl $-0x1, %edx
leaq 0xe711(%rip), %rax      # 0x10b50
movl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0xe872(%rip), %rax      # 0x10cc0
movswl (%rax,%rcx,2), %eax
andl %edx, %eax
movw %ax, %dx
leaq 0xe862(%rip), %rax      # 0x10cc0
movw %dx, (%rax,%rcx,2)
leaq 0xe6e7(%rip), %rax      # 0x10b50
cmpl $0x7ff, (%rax)          # imm = 0x7FF
jl 0x2489
leaq 0xadeb(%rip), %rdi      # 0xd263
leaq 0xb621(%rip), %rsi      # 0xdaa0
movl $0x4, %edx
callq 0x22f0
movl -0x4(%rbp), %ecx
leaq 0xe6c5(%rip), %rax      # 0x10b58
andl (%rax), %ecx
leaq 0xe6bc(%rip), %rax      # 0x10b58
movl %ecx, (%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/direct2.c
// Function: direct2
int direct2() {
	spechar = ' ';
	print = 1;
	if (*s2 == '.') return dir2dot();
	return dir2equ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcd47(%rip), %rax      # 0x10c06
movb $0x20, (%rax)
leaq 0xcf13(%rip), %rax      # 0x10ddc
movl $0x1, (%rax)
leaq 0xd1b2(%rip), %rax      # 0x11088
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x3eeb
callq 0x43c0
movl %eax, -0x4(%rbp)
jmp 0x3ef3
callq 0x3f00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/direct2.c
// Function: isstring
int isstring(char *p) {
	if (*p == '\'' || *p == '\"') {
		char c, delimiter = *p;
		while ((c = *++p))
			if (c == delimiter)
				if (*++p != delimiter) return !*p;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x5b00
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5b65
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0x5b63
movsbl -0x11(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5b61
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
je 0x5b5f
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5b6c
jmp 0x5b61
jmp 0x5b09
jmp 0x5b65
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: evalcon
long evalcon(int r) { /* evaluate a constant in radix r */
	char c;
	long con = 0;

	while (isxdigit(*lp)) {
		c = toupper(*lp) - '0';
		if (c > 9) c -= 7;
		if (c < 0 || c >= r) return (con);
		con *= r;
		con += c;
		lp++;
	}
	return (con);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x1200
movq (%rax), %rax
movq 0xb4de(%rip), %rcx      # 0x112c0
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x5e6b
movq 0xb4c3(%rip), %rax      # 0x112c0
movsbl (%rax), %edi
callq 0x1080
subl $0x30, %eax
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x9, %eax
jle 0x5e1e
movsbl -0xd(%rbp), %eax
subl $0x7, %eax
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jl 0x5e30
movsbl -0xd(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x5e3a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e73
movslq -0xc(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbq -0xd(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xb465(%rip), %rax      # 0x112c0
addq $0x1, %rax
movq %rax, 0xb45a(%rip)      # 0x112c0
jmp 0x5dd3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: evalchar
long evalchar(char t) {
	long con = 0;
	char c;
	while ((c = *lp)) { /* test for end of field */
		lp++;
		if (t != c) /* test for terminator */
			con = (con << 8) + c;
		else if (*lp == t) { /* if double terminator use as char */
			con = (con << 8) + *lp;
			lp++;
		} else
			break; /* terminator found */
	}
	if (!con || con & 0xffff0000) /* error if more than 2 chars or */
		display_error(
		        error = 'V'); /* no characters and no terminator */
	return (con);                 /* end of expression found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
movq 0xb243(%rip), %rax      # 0x112c0
movb (%rax), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0x6103
movq 0xb233(%rip), %rax      # 0x112c0
addq $0x1, %rax
movq %rax, 0xb228(%rip)      # 0x112c0
movsbl -0x1(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x60ba
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movsbq -0x11(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x60fe
movq 0xb1ff(%rip), %rax      # 0x112c0
movsbl (%rax), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x60fa
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq 0xb1e5(%rip), %rcx      # 0x112c0
movsbq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0xb1d3(%rip), %rax      # 0x112c0
addq $0x1, %rax
movq %rax, 0xb1c8(%rip)      # 0x112c0
jmp 0x60fc
jmp 0x6103
jmp 0x60fe
jmp 0x6076
cmpq $0x0, -0x10(%rbp)
je 0x611e
movabsq $0xffff0000, %rax       # imm = 0xFFFF0000
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x6132
leaq 0xacbb(%rip), %rax      # 0x10de0
movb $0x56, (%rax)
movl $0x56, %edi
callq 0x2350
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: priority
int priority(char c) {
	if (c == '$') return (0);
	if (c == '(') return (1);
	if (c == '+' || c == '-') return (2);
	if (c == '*' || c == '/' || c == '&' || c == '|' || c == '^')
		return (3);
	display_error(error = 'C'); /* invalid operator on stack */
	return (9);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x24, %eax
jne 0x6160
movl $0x0, -0x4(%rbp)
jmp 0x61de
movsbl -0x5(%rbp), %eax
cmpl $0x28, %eax
jne 0x6172
movl $0x1, -0x4(%rbp)
jmp 0x61de
movsbl -0x5(%rbp), %eax
cmpl $0x2b, %eax
je 0x6184
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
jne 0x618d
movl $0x2, -0x4(%rbp)
jmp 0x61de
movsbl -0x5(%rbp), %eax
cmpl $0x2a, %eax
je 0x61ba
movsbl -0x5(%rbp), %eax
cmpl $0x2f, %eax
je 0x61ba
movsbl -0x5(%rbp), %eax
cmpl $0x26, %eax
je 0x61ba
movsbl -0x5(%rbp), %eax
cmpl $0x7c, %eax
je 0x61ba
movsbl -0x5(%rbp), %eax
cmpl $0x5e, %eax
jne 0x61c3
movl $0x3, -0x4(%rbp)
jmp 0x61de
leaq 0xac16(%rip), %rax      # 0x10de0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x2350
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: pushval
void pushval(long l) {
	int k = 0;
	do_unary(&l, &k); /* do unary operations before pushing value */
	stack[--vsp] = l; /* push value */
	osp += k;
	lastval = TRUE; /* last item scanned was a value */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6250
movq -0x8(%rbp), %rdx
movl 0xb246(%rip), %eax      # 0x11460
addl $-0x1, %eax
movl %eax, 0xb23d(%rip)      # 0x11460
movslq %eax, %rcx
leaq 0xb0a3(%rip), %rax      # 0x112d0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl 0xb22a(%rip), %eax      # 0x11464
movl %eax, 0xb224(%rip)      # 0x11464
movl $0x1, 0xb21e(%rip)      # 0x11468
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: do_unary
void do_unary(long *l, int *k) { /* perform unary operations */
	char c;

#if UNARYL2R

	c = opstk[*k + osp]; /* unary operations */
	if (c == '>' || c == '<' || c == '~' || c == '_') {
		*k += 1;
		do_unary(l, k);
	} else
		return;
	if (c == '>') {
		*l = (*l >> 8) & 255;
		return;
	}
	if (c == '<') {
		*l &= 255;
		return;
	}
	if (c == '~') {
		*l = ~*l;
		return;
	}
	if (c == '_') {
		*l = -*l;
		return;
	}

#else

	*k = 0;
	while (osp < MAXESTK) {
		c = opstk[osp];
		if (c == '>') {
			*l = (*l >> 8) & 255;
			osp++;
			continue;
		}
		if (c == '<') {
			*l &= 255;
			osp++;
			continue;
		}
		if (c == '~') {
			*l = ~*l;
			osp++;
			continue;
		}
		if (c == '_') {
			*l = -*l;
			osp++;
			continue;
		}
		break;
	}

#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpl $0x32, 0xb1f7(%rip)     # 0x11464
jge 0x6343
movslq 0xb1ea(%rip), %rcx      # 0x11464
leaq 0xb1ef(%rip), %rax      # 0x11470
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3e, %eax
jne 0x62ba
movq -0x8(%rbp), %rax
movq (%rax), %rcx
sarq $0x8, %rcx
andq $0xff, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0xb1b5(%rip), %eax      # 0x11464
addl $0x1, %eax
movl %eax, 0xb1ac(%rip)      # 0x11464
jmp 0x6266
movsbl -0x11(%rbp), %eax
cmpl $0x3c, %eax
jne 0x62e5
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $0xff, %rcx
movq %rcx, (%rax)
movl 0xb18a(%rip), %eax      # 0x11464
addl $0x1, %eax
movl %eax, 0xb181(%rip)      # 0x11464
jmp 0x6266
movsbl -0x11(%rbp), %eax
cmpl $0x7e, %eax
jne 0x6314
movq -0x8(%rbp), %rax
movq (%rax), %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0xb15e(%rip), %eax      # 0x11464
addl $0x1, %eax
movl %eax, 0xb155(%rip)      # 0x11464
jmp 0x6266
movsbl -0x11(%rbp), %eax
cmpl $0x5f, %eax
jne 0x6341
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0xb131(%rip), %eax      # 0x11464
addl $0x1, %eax
movl %eax, 0xb128(%rip)      # 0x11464
jmp 0x6266
jmp 0x6343
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/express.c
// Function: eval
void eval(char op) {
	int more = TRUE;
	if (op == '_' || op == '<' || op == '>' || op == '~' ||
	    op == '(') { /* unary operators */
		opstk[--osp] = op;
		more = lastval = FALSE;
	}
	while (more)
		if (priority(opstk[osp]) < priority(op)) {
			opstk[--osp] = op;
			more = lastval = FALSE;
		} else
			do_oper();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x5f, %eax
je 0x65e2
movsbl -0x1(%rbp), %eax
cmpl $0x3c, %eax
je 0x65e2
movsbl -0x1(%rbp), %eax
cmpl $0x3e, %eax
je 0x65e2
movsbl -0x1(%rbp), %eax
cmpl $0x7e, %eax
je 0x65e2
movsbl -0x1(%rbp), %eax
cmpl $0x28, %eax
jne 0x6612
movb -0x1(%rbp), %dl
movl 0xae79(%rip), %eax      # 0x11464
addl $-0x1, %eax
movl %eax, 0xae70(%rip)      # 0x11464
movslq %eax, %rcx
leaq 0xae72(%rip), %rax      # 0x11470
movb %dl, (%rax,%rcx)
movl $0x0, 0xae5d(%rip)      # 0x11468
movl $0x0, -0x8(%rbp)
jmp 0x6614
cmpl $0x0, -0x8(%rbp)
je 0x667f
movslq 0xae43(%rip), %rcx      # 0x11464
leaq 0xae48(%rip), %rax      # 0x11470
movsbl (%rax,%rcx), %edi
callq 0x6140
movl %eax, -0xc(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x6140
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jge 0x6678
movb -0x1(%rbp), %dl
movl 0xae15(%rip), %eax      # 0x11464
addl $-0x1, %eax
movl %eax, 0xae0c(%rip)      # 0x11464
movslq %eax, %rcx
leaq 0xae0e(%rip), %rax      # 0x11470
movb %dl, (%rax,%rcx)
movl $0x0, 0xadf9(%rip)      # 0x11468
movl $0x0, -0x8(%rbp)
jmp 0x667d
callq 0x6350
jmp 0x6614
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/help.c
// Function: help
void help() {
	printf("\nthe assembler command line consists of the file names and "
	       "switches\n");
	printf("\nC65> "
	       "[object],[listing]=source[,source]...[,source][/switch]...[/"
	       "switch]\n");
	printf("\nItems enclosed in brackets [...] are optional.\n");
	printf("\nThe default file extentions are .obj , .lst and .src\n");
	printf("\nSwitches  (either upper or lower case)\n");
	printf("/A absolute assembly (default)\n");
	printf("/Cn cpu instruction set /C0 for NMOS 6502   /C1 for CMOS "
	       "6502\n");
	printf("     /C2 for CMOS 6502 w/bit instructions   /C3 for Commodore "
	       "4502 (default)\n");
	printf("/Dpath specify path for intermediate file ( usually RAM disk "
	       "on PCs).\n");
	printf("/H help - prints this message\n");
	printf("/L assume long branches on pass1. (default= assume short "
	       "branches)\n");
	printf("/Mnnn maximum macro nesting depth (default=50, "
	       "limits=2-999).\n");
	printf("/Pnn maximum number of passes to try (default=15, "
	       "limits=2-99).\n");
	printf("/N don't print errors to console during assembly\n");
	printf("/R relocatable assembly - illegal since this is an absolute "
	       "assembler only\n");
	printf("/S narrow list format\n");
	printf("/T don't print symbol table\n");
	printf("/V don't print cross reference\n");
	printf("/X print cross reference (default)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6950(%rip), %rdi      # 0xd4fb
movb $0x0, %al
callq 0x10d0
leaq 0x6987(%rip), %rdi      # 0xd540
movb $0x0, %al
callq 0x10d0
leaq 0x69c4(%rip), %rdi      # 0xd58b
movb $0x0, %al
callq 0x10d0
leaq 0x69e7(%rip), %rdi      # 0xd5bc
movb $0x0, %al
callq 0x10d0
leaq 0x6a10(%rip), %rdi      # 0xd5f3
movb $0x0, %al
callq 0x10d0
leaq 0x6a2b(%rip), %rdi      # 0xd61c
movb $0x0, %al
callq 0x10d0
leaq 0x6a3d(%rip), %rdi      # 0xd63c
movb $0x0, %al
callq 0x10d0
leaq 0x6a6e(%rip), %rdi      # 0xd67b
movb $0x0, %al
callq 0x10d0
leaq 0x6aae(%rip), %rdi      # 0xd6c9
movb $0x0, %al
callq 0x10d0
leaq 0x6ae7(%rip), %rdi      # 0xd710
movb $0x0, %al
callq 0x10d0
leaq 0x6af8(%rip), %rdi      # 0xd72f
movb $0x0, %al
callq 0x10d0
leaq 0x6b2e(%rip), %rdi      # 0xd773
movb $0x0, %al
callq 0x10d0
leaq 0x6b5f(%rip), %rdi      # 0xd7b2
movb $0x0, %al
callq 0x10d0
leaq 0x6b92(%rip), %rdi      # 0xd7f3
movb $0x0, %al
callq 0x10d0
leaq 0x6bb6(%rip), %rdi      # 0xd825
movb $0x0, %al
callq 0x10d0
leaq 0x6bf4(%rip), %rdi      # 0xd871
movb $0x0, %al
callq 0x10d0
leaq 0x6bfd(%rip), %rdi      # 0xd888
movb $0x0, %al
callq 0x10d0
leaq 0x6c0c(%rip), %rdi      # 0xd8a5
movb $0x0, %al
callq 0x10d0
leaq 0x6c1e(%rip), %rdi      # 0xd8c5
movb $0x0, %al
callq 0x10d0
popq %rbp
retq