LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: readBytes
int readBytes(void *target, long num) {
    char peek = (num < 0) ? 1 : 0;
    num = (num < 0) ? -num : num;

    pos p = positions[level];
    if (p.offset + num > p.size) {
        return 0;
    } else {
        memcpy(target, (void*)((size_t)p.data + p.offset), num);
        if (!peek) positions[level].offset += num;
    }
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
movzbl 0x4fb6(%rip), %eax      # 0x6260
imulq $0x18, %rax, %r14
leaq 0x4e2b(%rip), %r15      # 0x60e0
movq 0x10(%r14,%r15), %rsi
leaq (%rsi,%rdx), %r12
xorl %eax, %eax
cmpq 0x8(%r14,%r15), %r12
ja 0x12e0
leaq (%r15,%r14), %rax
addq (%rax), %rsi
callq 0x10e0
pushq $0x1
popq %rax
testq %rbx, %rbx
js 0x12e0
movq %r12, 0x10(%r14,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: processHeader
int processHeader() {
    char buf[10] = "_________";
    int dump_version;

    if (!readBytes(buf, 9)) {
        ERROR("Cannot read header\n");
    }

    /* expect the first 5 bytes to equal REDIS */
    if (memcmp(buf,"REDIS",5) != 0) {
        ERROR("Wrong signature in header\n");
    }

    dump_version = (int)strtol(buf + 5, NULL, 10);
    if (dump_version < 1 || dump_version > 6) {
        ERROR("Unknown RDB format version: %d\n", dump_version);
    }
    return dump_version;
}

// Assembly:
subq $0x18, %rsp
movabsq $0x5f5f5f5f5f5f5f5f, %rax # imm = 0x5F5F5F5F5F5F5F5F
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movw $0x5f, 0x8(%rdi)
pushq $0x9
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x1348
leaq 0x1d63(%rip), %rsi      # 0x307e
leaq 0x8(%rsp), %rdi
pushq $0x5
popq %rdx
callq 0x1110
testl %eax, %eax
jne 0x1351
leaq 0xd(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x10d0
leal -0x7(%rax), %ecx
cmpl $-0x7, %ecx
jbe 0x135f
addq $0x18, %rsp
retq
leaq 0x210d(%rip), %rdi      # 0x345c
jmp 0x1358
leaq 0x2117(%rip), %rdi      # 0x346f
callq 0x1070
jmp 0x136f
leaq 0x1d1e(%rip), %rdi      # 0x3084
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadType
int loadType(entry *e) {
    uint32_t offset = CURR_OFFSET;

    /* this byte needs to qualify as type */
    unsigned char t;
    if (readBytes(&t, 1)) {
        if (checkType(t)) {
            e->type = t;
            return 1;
        } else {
            SHIFT_ERROR(offset, "Unknown type (0x%02x)", t);
        }
    } else {
        SHIFT_ERROR(offset, "Could not read type");
    }

    /* failure */
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x4edb(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x4d50(%rip), %rcx      # 0x60e0
movl 0x10(%rax,%rcx), %r14d
leaq 0x7(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x13c2
movzbl 0x7(%rsp), %edx
cmpl $0xd, %edx
ja 0x140a
movl $0x3e1f, %eax           # imm = 0x3E1F
btl %edx, %eax
jae 0x140a
movl %edx, 0x8(%rbx)
pushq $0x1
popq %rax
jmp 0x1402
movq 0x8f1f(%rip), %rax      # 0xa2e8
leaq 0x4e98(%rip), %rcx      # 0x6268
movq %rax, %rdx
shlq $0xa, %rdx
movups 0x1cdc(%rip), %xmm0     # 0x30ba
movups %xmm0, (%rdx,%rcx)
movl $0x657079, 0x10(%rdx,%rcx) # imm = 0x657079
leaq 0x4e77(%rip), %rcx      # 0x6268
movq %r14, 0x4000(%rcx,%rax,8)
incq 0x8ee8(%rip)            # 0xa2e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $-0x4, %dl
jae 0x13ba
leaq 0x4e52(%rip), %rax      # 0x6268
movq 0x8ecb(%rip), %rdi      # 0xa2e8
shlq $0xa, %rdi
addq %rax, %rdi
leaq 0x1c79(%rip), %rsi      # 0x30a4
xorl %eax, %eax
callq 0x1140
movq 0x8eaf(%rip), %rax      # 0xa2e8
jmp 0x13ea
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0x7(%rsp), %rdi
pushq $-0x1
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x1479
movzbl 0x7(%rsp), %eax
cmpl $0xe, %eax
jae 0x146f
movl $0x3e1f, %ecx           # imm = 0x3E1F
btl %eax, %ecx
jae 0x146f
movl %eax, %eax
leaq 0x1bd2(%rip), %rcx      # 0x303c
movl (%rcx,%rax,4), %eax
jmp 0x147c
cmpb $-0x4, %al
pushq $-0x1
popq %rcx
cmovbl %ecx, %eax
jmp 0x147c
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movzbl 0x4dd6(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x4c4b(%rip), %rcx      # 0x60e0
movl 0x10(%rax,%rcx), %ebx
xorl %eax, %eax
cmpl $0xfc, %edi
sete %al
leaq 0x4(,%rax,4), %rsi
leaq 0x8(%rsp), %rdi
callq 0x128e
testl %eax, %eax
je 0x14bf
pushq $0x1
popq %rax
jmp 0x14f8
leaq 0x4da2(%rip), %rax      # 0x6268
movq 0x8e1b(%rip), %rcx      # 0xa2e8
movq %rcx, %rdx
shlq $0xa, %rdx
movups 0x1bf3(%rip), %xmm0     # 0x30ce
movups %xmm0, (%rdx,%rax)
movl $0x656d69, 0x10(%rdx,%rax) # imm = 0x656D69
movq %rbx, 0x4000(%rax,%rcx,8)
incq 0x8df2(%rip)            # 0xa2e8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
je 0x150e
andl $0x0, (%r14)
leaq 0x2(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x128e
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0x154c
movzbl 0x2(%rsp), %eax
cmpl $0x40, %eax
jb 0x154a
movl %eax, %ecx
shrl $0x6, %ecx
cmpl $0x1, %ecx
je 0x1556
cmpl $0x3, %ecx
jne 0x157b
testq %r14, %r14
je 0x1547
movl $0x1, (%r14)
andl $0x3f, %eax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x154c
movzbl 0x2(%rsp), %eax
andl $0x3f, %eax
shll $0x8, %eax
movzbl 0x3(%rsp), %ebx
orl %eax, %ebx
jmp 0x154c
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x154c
movl 0x4(%rsp), %eax
bswapl %eax
jmp 0x154e
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x2, %edi
je 0x15df
movl %edi, %edx
cmpl $0x1, %edi
je 0x15c6
testl %edx, %edx
jne 0x161c
leaq 0xc(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x1618
movsbq 0xc(%rsp), %r14
jmp 0x15f5
leaq 0xc(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x1618
movswq 0xc(%rsp), %r14
jmp 0x15f5
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x1618
movslq 0xc(%rsp), %r14
movl $0x80, %edi
callq 0x10f0
movq %rax, %rbx
leaq 0x1afb(%rip), %rsi      # 0x3104
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1140
jmp 0x166e
xorl %ebx, %ebx
jmp 0x166e
movzbl 0x4c3d(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x4ab2(%rip), %rcx      # 0x60e0
movl 0x10(%rax,%rcx), %r14d
leaq 0x4c2e(%rip), %r15      # 0x6268
movq 0x8ca7(%rip), %rdi      # 0xa2e8
shlq $0xa, %rdi
addq %r15, %rdi
leaq 0x1a93(%rip), %rsi      # 0x30e2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1140
movq 0x8c89(%rip), %rax      # 0xa2e8
movq %r14, 0x4000(%r15,%rax,8)
incq 0x8c7a(%rip)            # 0xa2e8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x14fe
cmpl $-0x1, %eax
je 0x16f8
movl %eax, %ebx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x14fe
cmpl $-0x1, %eax
je 0x16f8
movl %eax, %ebp
movl %ebx, %r14d
movq %r14, %rdi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x128e
testl %eax, %eax
je 0x16ed
movl %ebp, %edi
incl %edi
callq 0x10f0
movq %rax, %r14
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x2a0c
movl %eax, %ebx
movq %r15, %rdi
callq 0x1030
movq %r14, %r15
testl %ebx, %ebx
jne 0x16f8
movq %r15, %rdi
callq 0x1030
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x4b4b(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x49c0(%rip), %rcx      # 0x60e0
movl 0x10(%rax,%rcx), %r15d
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x14fe
movl %eax, %r14d
cmpl $0x0, (%rbx)
je 0x174a
cmpl $0x3, %r14d
jae 0x177b
movl %r14d, %edi
callq 0x1594
jmp 0x1782
cmpl $-0x1, %r14d
je 0x1777
leal 0x1(%r14), %edi
callq 0x10f0
movq %rax, %rbx
movl %r14d, %esi
movb $0x0, (%rax,%rsi)
movq %rax, %rdi
callq 0x128e
testl %eax, %eax
jne 0x1785
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
jmp 0x1785
jne 0x1794
callq 0x167b
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4acd(%rip), %r12      # 0x6268
movq 0x8b46(%rip), %rdi      # 0xa2e8
shlq $0xa, %rdi
addq %r12, %rdi
leaq 0x1959(%rip), %rsi      # 0x3109
xorl %ebx, %ebx
movl %r14d, %edx
xorl %eax, %eax
callq 0x1140
movq 0x8b25(%rip), %rax      # 0xa2e8
movq %r15, 0x4000(%r12,%rax,8)
incq 0x8b16(%rip)            # 0xa2e8
jmp 0x1785
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x4a7e(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x48f3(%rip), %rcx      # 0x60e0
movq 0x10(%rax,%rcx), %r14
callq 0x1706
testq %rax, %rax
je 0x1806
testq %rbx, %rbx
je 0x1845
movq %rax, (%rbx)
jmp 0x184d
leaq 0x4a5b(%rip), %rax      # 0x6268
movq 0x8ad4(%rip), %rcx      # 0xa2e8
movq %rcx, %rdx
shlq $0xa, %rdx
movups 0x1914(%rip), %xmm0     # 0x3136
movups %xmm0, 0xc(%rdx,%rax)
movups 0x18fc(%rip), %xmm0     # 0x312a
movups %xmm0, (%rdx,%rax)
movq %r14, 0x4000(%rax,%rcx,8)
incq 0x8aa7(%rip)            # 0xa2e8
xorl %eax, %eax
jmp 0x1850
movq %rax, %rdi
callq 0x1030
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq 0xf(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x128e
testl %eax, %eax
je 0x18fc
pushq $0x8
popq %rdi
callq 0x10f0
movq %rax, %rbx
movzbl 0xf(%rsp), %r14d
cmpl $0xfd, %r14d
je 0x18b7
cmpl $0xfe, %r14d
je 0x18ad
cmpl $0xff, %r14d
jne 0x18c5
movsd 0x8a45(%rip), %xmm0     # 0xa2f0
jmp 0x18bf
movsd 0x8a43(%rip), %xmm0     # 0xa2f8
jmp 0x18bf
movsd 0x8a41(%rip), %xmm0     # 0xa300
movsd %xmm0, (%rbx)
jmp 0x18fe
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x128e
testl %eax, %eax
je 0x18f4
movb $0x0, 0x10(%rsp,%r14)
leaq 0x1863(%rip), %rsi      # 0x3146
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
jmp 0x18fe
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x4946(%rip), %eax      # 0x6260
imulq $0x18, %rax, %rax
leaq 0x47bb(%rip), %rcx      # 0x60e0
movq 0x10(%rax,%rcx), %r14
callq 0x1858
testq %rax, %rax
je 0x193e
testq %rbx, %rbx
je 0x197d
movq %rax, (%rbx)
jmp 0x1985
leaq 0x4923(%rip), %rax      # 0x6268
movq 0x899c(%rip), %rcx      # 0xa2e8
movq %rcx, %rdx
shlq $0xa, %rdx
movups 0x17fb(%rip), %xmm0     # 0x3155
movups %xmm0, 0xb(%rdx,%rax)
movups 0x17e4(%rip), %xmm0     # 0x314a
movups %xmm0, (%rdx,%rax)
movq %r14, 0x4000(%rax,%rcx,8)
incq 0x896f(%rip)            # 0xa2e8
xorl %eax, %eax
jmp 0x1988
movq %rax, %rdi
callq 0x1030
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r12d
leaq 0x100(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq %rsp, %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10b0
movslq %r12d, %r12
pushq $0x3d
popq %r13
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x10b0
subl %r12d, %ebp
addl $-0x2, %ebp
movslq %ebp, %r12
movq %rbx, %rdi
callq 0x1080
subq %rax, %r12
movq %r15, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x10b0
leaq 0x133a(%rip), %rdi      # 0x32d5
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: printErrorStack
void printErrorStack(entry *e) {
    unsigned int i;
    char body[64];

    if (e->type == -1) {
        sprintf(body, "Error trace");
    } else if (e->type >= 253) {
        sprintf(body, "Error trace (%s)", types[e->type]);
    } else if (!e->key) {
        sprintf(body, "Error trace (%s: (unknown))", types[e->type]);
    } else {
        char tmp[41];
        strncpy(tmp, e->key, 40);

        /* display truncation at the last 3 chars */
        if (strlen(e->key) > 40) {
            memset(&tmp[37], '.', 3);
        }

        /* display unprintable characters as ? */
        for (i = 0; i < strlen(tmp); i++) {
            if (tmp[i] <= 32) tmp[i] = '?';
        }
        sprintf(body, "Error trace (%s: %s)", types[e->type], tmp);
    }

    printCentered(4, 80, body);

    /* display error stack */
    for (i = 0; i < errors.level; i++) {
        printf("0x%08lx - %s\n",
            (unsigned long) errors.offset[i], errors.error[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl 0x8(%rdi), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x205d
cmpl $0xfd, %r14d
jl 0x2079
shlq $0x4, %r14
leaq 0x82c2(%rip), %rdx      # 0xa310
addq %r14, %rdx
leaq 0x12ea(%rip), %rsi      # 0x3342
jmp 0x2111
movabsq $0x727420726f727245, %rax # imm = 0x727420726F727245
movq %rax, 0x30(%rsp)
movl $0x656361, 0x38(%rsp)   # imm = 0x656361
jmp 0x211d
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x20f9
movq %rsp, %rdi
pushq $0x28
popq %rdx
movq %rbx, %rsi
callq 0x1060
movq %rbx, %rdi
callq 0x1080
cmpq $0x29, %rax
jb 0x20a9
movb $0x2e, 0x27(%rsp)
movw $0x2e2e, 0x25(%rsp)     # imm = 0x2E2E
xorl %r15d, %r15d
movq %rsp, %rbx
movl %r15d, %r15d
movq %rbx, %rdi
callq 0x1080
cmpq %r15, %rax
jbe 0x20d0
cmpb $0x20, (%rsp,%r15)
jg 0x20cb
movb $0x3f, (%rsp,%r15)
incl %r15d
jmp 0x20af
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x8232(%rip), %rdx      # 0xa310
addq %rax, %rdx
leaq 0x1287(%rip), %rsi      # 0x336f
leaq 0x30(%rsp), %rdi
movq %rsp, %rcx
xorl %eax, %eax
callq 0x1140
jmp 0x211d
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x8209(%rip), %rdx      # 0xa310
addq %rax, %rdx
leaq 0x1242(%rip), %rsi      # 0x3353
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
callq 0x1140
pushq $0x4
popq %rdi
pushq $0x50
popq %rsi
leaq 0x30(%rsp), %rdx
callq 0x1f1b
leaq 0x4134(%rip), %r14      # 0x6268
leaq 0x1249(%rip), %rbx      # 0x3384
xorl %eax, %eax
movl %eax, %r15d
cmpq %r15, 0x81a1(%rip)      # 0xa2e8
jbe 0x216b
movq 0x4000(%r14,%r15,8), %rsi
movq %r15, %rdx
shlq $0xa, %rdx
addq %r14, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
leal 0x1(%r15), %eax
jmp 0x213d
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/TheDiamondProject[P]lib68/cpu/instructions/abcd_m8_m8.c
// Function: abcd_m8_m8
void abcd_m8_m8(void)
{
	union m68_abcd_opcode opcode = { m68_mmu_read_word(CPU68.PC.value) };

	uint8_t Rx = opcode.field.Rx;
	uint8_t Ry = opcode.field.Ry;
	uint8_t Vx = m68_mmu_read_byte(--CPU68.A[Rx].value);
	uint8_t Vy = m68_mmu_read_byte(--CPU68.A[Ry].value);
	uint8_t X = CPU68.CCR.bitmask.user.X;

	uint8_t r = Vx + Vy + X;
	uint8_t bc = ((Vx & Vy) | (~r & Vx) | (~r & Vy)) & 0x88;
	uint8_t dc = (((r + 0x66) ^ r) & 0x110) >> 1;
	uint8_t corf = (bc | dc) - ((bc | dc) >> 2);
	uint8_t rr = r + corf;

	m68_mmu_write_byte(CPU68.A[Ry].value, rr);
	     
	CPU68.CCR.bitmask.user.C = (bc | (r & ~rr)) >> 7;
	CPU68.CCR.bitmask.user.X = CPU68.CCR.bitmask.user.C;
	CPU68.CCR.bitmask.user.V = (~r && r) >> 7;
	CPU68.CCR.bitmask.user.Z &= (rr == 0);
	CPU68.CCR.bitmask.user.N = rr >> 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x103832(%rip), %r15    # 0x108078
movl 0x40(%r15), %edi
callq 0x4c1b
movl %eax, %ebx
movl %ebx, %eax
shrl $0x9, %eax
andl $0x7, %eax
andl $0x7, %ebx
movl 0x20(%r15,%rax,4), %edi
decl %edi
movl %edi, 0x20(%r15,%rax,4)
callq 0x4c0e
movl %eax, %r14d
movl 0x20(%r15,%rbx,4), %edi
decl %edi
movl %edi, 0x20(%r15,%rbx,4)
callq 0x4c0e
movzbl %r14b, %ecx
btl $0x4, 0x44(%r15)
movzbl %al, %eax
movl %eax, %edx
adcb %cl, %dl
movzbl %dl, %r12d
movl %r12d, %r14d
notl %r14d
movl %r14d, %edx
orl %eax, %edx
andl %ecx, %edx
andl %eax, %r14d
orl %edx, %r14d
leal 0x66(%r12), %eax
xorl %r12d, %eax
shrl %eax
orl %r14d, %eax
andl $-0x78, %eax
movl %eax, %ecx
shrl $0x2, %ecx
subl %ecx, %eax
addb %r12b, %al
movl 0x20(%r15,%rbx,4), %edi
movzbl %al, %ebx
movl %ebx, %esi
callq 0x4bc5
movl %ebx, %eax
notl %eax
andl %r12d, %eax
orl %r14d, %eax
shrb $0x7, %al
movb 0x44(%r15), %cl
movl %ecx, %edx
andb $-0x20, %dl
movl %eax, %esi
shlb $0x4, %sil
orb %dl, %sil
andb $0x4, %cl
xorl %edx, %edx
testb %bl, %bl
movzbl %cl, %ecx
cmovnel %edx, %ecx
orb %sil, %cl
shrb $0x4, %bl
andb $0x8, %bl
orb %cl, %bl
orb %al, %bl
movb %bl, 0x44(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_page_alloc
void *m68_mmu_page_alloc(uint32_t address)
{
	union m68_mmu_page_entry *table = NULL;
	void *page = NULL;

	/* First determine the page table and the page that the address relates
	 * to. */
	uint32_t dir_idx = (address >> 22) & 0x3FF;
	uint32_t table_idx = (address >> 12) & 0x3FF;

	/* Now check if a table already exists. If not create it. To do this we need
	 * to request an allocation for the page and then ensure it is aligned to a
	 * 16 byte boundary. */
	if (!MMU_PAGE_DIR[dir_idx].field.present) {
		table = calloc(MMU_PAGE_TABLE_MAX_ENTRIES + 4, sizeof(union m68_mmu_page_entry));
		uintptr_t address = (uintptr_t)table;
		if (address & 0xF) {
			address = ((address + 0x10) & ~0xF);
			table = (void *)address;
		}

		MMU_PAGE_DIR[dir_idx].field.address = (address >> 2);
		MMU_PAGE_DIR[dir_idx].field.present = 1;
	} else {
		table = (void *)((uintptr_t)MMU_PAGE_DIR[dir_idx].field.address << 2);
	}

	/* Now check for the presence of the desired page in the table. If the page
	 * is not there then allocate it. */
	if (!table[table_idx].field.present) {
		page = calloc(0x1000, 1);
		uintptr_t address = (uintptr_t)page;
		if (address & 0xF) {
			address = ((address + 0x10) & ~0xF);
			page = (void *)address;
		}

		table[table_idx].field.address = (address >> 2);
		table[table_idx].field.present = 1;
	} else {
		page = (void *)((uintptr_t)table[table_idx].field.address << 2);
	}

	return page;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movabsq $0x3ffffffffffffffc, %rax # imm = 0x3FFFFFFFFFFFFFFC
movl %edi, %r12d
shrl $0x16, %r12d
shrl $0xc, %ebx
andl $0x3ff, %ebx            # imm = 0x3FF
leaq 0x1035f2(%rip), %rcx    # 0x108070
movq (%rcx), %r14
movq (%r14,%r12,8), %r15
testb $0x1, %r15b
jne 0x4ad4
pushq $0x8
popq %rsi
movl $0x404, %edi            # imm = 0x404
callq 0x3050
movq %rax, %r13
andq $-0x10, %r13
addq $0x10, %r13
testb $0xf, %al
cmoveq %rax, %r13
andl $0xe, %r15d
leaq (%r15,%r13,4), %rax
shll $0x3, %r12d
movq %rax, (%r14,%r12)
leaq 0x1035b0(%rip), %rax    # 0x108070
movq (%rax), %rax
orq $0x1, (%rax,%r12)
movabsq $0x3ffffffffffffffc, %rax # imm = 0x3FFFFFFFFFFFFFFC
jmp 0x4ade
shrq $0x2, %r15
andq %rax, %r15
movq %r15, %r13
movl %ebx, %r14d
movq (%r13,%r14,8), %rbx
testb $0x1, %bl
jne 0x4b1b
pushq $0x1
popq %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x3050
movq %rax, %rcx
andq $-0x10, %rax
addq $0x10, %rax
testb $0xf, %cl
cmoveq %rcx, %rax
andl $0xe, %ebx
leaq (%rbx,%rax,4), %rcx
incq %rcx
movq %rcx, (%r13,%r14,8)
jmp 0x4b25
shrq $0x2, %rbx
andq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x10352a(%rip), %r14    # 0x108070
cmpq $0x0, (%r14)
je 0x4b9f
xorl %r15d, %r15d
movq (%r14), %rdi
cmpq $0x400, %r15            # imm = 0x400
je 0x4b96
movq (%rdi,%r15,8), %rbx
testb $0x1, %bl
je 0x4b91
andq $-0x10, %rbx
movl $0x400, %r12d           # imm = 0x400
subl $0x1, %r12d
jb 0x4b89
movq (%rbx,%r15,8), %rdi
testb $0x1, %dil
je 0x4b6e
andq $-0x10, %rdi
callq 0x3030
jmp 0x4b6e
movq %rbx, %rdi
callq 0x3030
incq %r15
jmp 0x4b4f
callq 0x3030
andq $0x0, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x5d
popq %rsi
callq 0x10d0
testq %rax, %rax
cmoveq %r14, %rax
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x10d0
testq %rax, %rax
je 0x1dcd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x7448(%rip), %rdi      # 0x9237
xorl %eax, %eax
callq 0x10e0
cmpl $0x1, %ebx
jg 0x1dfd
popq %rbx
retq
movq 0xb954(%rip), %rdi      # 0xd758
callq 0x10a0
leaq 0xbad0(%rip), %rdi      # 0xd8e0
callq 0x1060
movl %ebx, %edi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0xbe5d(%rip), %rax      # 0xdc80
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x1e37
cmpl $0x20, %ecx
je 0x1e38
incq %rax
cmpb %dil, %cl
jne 0x1e23
retq
movb %dil, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0xbd1e(%rip), %rax      # 0xdb70
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %edx, %eax
andb $0xf, %al
sarl $0x4, %edx
movslq %edx, %rdx
leaq 0xbe76(%rip), %rsi      # 0xdce0
movzwl (%rsi,%rdx,2), %edi
movl %edi, %r8d
btrl %eax, %r8d
btsl %eax, %edi
testl %ebx, %ebx
cmovel %r8d, %edi
movw %di, (%rsi,%rdx,2)
cmpl $0x7fe, %ecx            # imm = 0x7FE
jl 0x1ea0
leaq 0x73ac(%rip), %rdi      # 0x923d
leaq 0x7c81(%rip), %rsi      # 0x9b19
pushq $0x4
popq %rdx
callq 0x1ddf
leaq 0xbcd1(%rip), %rax      # 0xdb78
andl %ebx, (%rax)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
je 0x4104
cmpl $0x22, %ecx
jne 0x4130
movb 0x1(%rdi), %sil
testb %sil, %sil
je 0x4130
movq %rdi, %rdx
incq %rdi
cmpb %cl, %sil
jne 0x4104
movb 0x2(%rdx), %sil
addq $0x2, %rdx
movq %rdx, %rdi
cmpb %cl, %sil
je 0x4104
xorl %eax, %eax
testb %sil, %sil
sete %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/express.c
// Function: evalsym
long evalsym() {
	char sym[32]; /* save symbol */
	int i = 0;    /* position of last character added to sym */

	sym[i++] = toupper(*(lp - 1));
	while (isalpha(*lp) || isdigit(*lp) || *lp == '$' || *lp == '.' ||
	       *lp == '_') {
		sym[i] = toupper(*lp); /* gather the symbol name */
		lp++;
		if (i < 31) i++;
	}
	sym[i] = 0;             /* terminate the symbol name */
	ptr = find_symbol(sym); /* get a pointer to the symbol table entry */
	if (!ptr)
		insert_symbol(sym, 0L, 0, 0,
		              0); /* insert an undefined symbol */
	else
		addref(&ptr->xref,
		       0); /* add a reference to symbol is it exists */
	if (ptr->section)  /* bad idea to use section names in expressions */
		display_error(error = 'S');
	if (ptr->multiple) /* use of multiply defined symbol */
		display_error(error = 'S');
	if (ptr->known)              /* is the value of the symbol known? */
		return (ptr->value); /* value of symbol */
	if (pass == 2) display_error(error = 'U');
	expdef = FALSE; /* symbol value is unknown */
	return (0L);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x1030
movq %rax, %rbx
movq (%rax), %rax
movq 0xa193(%rip), %r14      # 0xe2e0
movsbq -0x1(%r14), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rsp)
callq 0x1240
incq %r14
pushq $0x1
popq %rcx
movabsq $0x800000000000401, %rdx # imm = 0x800000000000401
movq (%rax), %rdi
movsbq -0x1(%r14), %rsi
movzwl (%rdi,%rsi,2), %r8d
movl %ecx, %edi
testw $0xc00, %r8w            # imm = 0xC00
jne 0x4198
movzbl %sil, %r8d
addl $-0x24, %r8d
cmpl $0x3b, %r8d
ja 0x41b5
btq %r8, %rdx
jae 0x41b5
movq (%rbx), %r8
movb (%r8,%rsi,4), %sil
movb %sil, (%rsp,%rdi)
movq %r14, 0xa136(%rip)      # 0xe2e0
cmpl $0x1f, %ecx
adcl $0x0, %ecx
incq %r14
jmp 0x416d
movb $0x0, (%rsp,%rdi)
movq %rsp, %rdi
callq 0x83d7
leaq 0x9a88(%rip), %rbx      # 0xdc50
movq %rax, (%rbx)
testq %rax, %rax
je 0x41e0
addq $0x10, %rax
movq %rax, %rdi
xorl %esi, %esi
callq 0x800f
jmp 0x41f1
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x812d
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x10, %cl
je 0x4216
leaq 0x9bfc(%rip), %rax      # 0xde00
movb $0x53, (%rax)
pushq $0x53
popq %rdi
callq 0x1e1c
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x8, %cl
je 0x4234
leaq 0x9bde(%rip), %rax      # 0xde00
movb $0x53, (%rax)
pushq $0x53
popq %rdi
callq 0x1e1c
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
btl $0x8, %ecx
jb 0x4266
leaq 0x95c3(%rip), %rax      # 0xd804
cmpl $0x2, (%rax)
jne 0x4258
leaq 0x9bb3(%rip), %rax      # 0xde00
movb $0x55, (%rax)
pushq $0x55
popq %rdi
callq 0x1e1c
leaq 0x9b89(%rip), %rax      # 0xdde8
andl $0x0, (%rax)
xorl %eax, %eax
jmp 0x426a
movq 0x18(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x1240
movq %rax, %r14
movl %ebx, %r12d
movq 0xa04f(%rip), %r13      # 0xe2e0
incq %r13
xorl %r15d, %r15d
movq (%r14), %rax
movsbq -0x1(%r13), %rbp
testb $0x10, 0x1(%rax,%rbp,2)
je 0x42e3
callq 0x1030
movq (%rax), %rax
movb (%rax,%rbp,4), %al
leal -0x30(%rax), %ecx
addb $-0x37, %al
cmpb $0xa, %cl
movzbl %al, %edx
movzbl %cl, %eax
cmovgel %edx, %eax
testb %al, %al
js 0x42e3
movsbl %al, %ecx
cmpl %ebx, %ecx
jge 0x42e3
imulq %r12, %r15
movzbl %al, %eax
addq %rax, %r15
movq %r13, 0xa002(%rip)      # 0xe2e0
incq %r13
jmp 0x4297
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/express.c
// Function: evalocal
long evalocal() { /* evaluate a local symbol */
	int loc = 0;
	char *p, sym[8];

	for (p = lp; isdigit(*p); p++)
		loc = loc * 10 + *p -
		      '0'; /* get the decimal # part of local symbol */
	if (*p == '$') {   /* yes it is a local symbol */
		lp = ++p;  /* point past the $ */
		if (loc < 1 ||
		    loc > 255) { /* it is a valid local symbol name */
			display_error(error = 'E');
			return (0L);
		}
		makelocal(loc, sym);
		ptr = find_symbol(
		        sym); /* get a pointer to the symbol table entry */
		if (!ptr)
			insert_symbol(sym, 0L, 0, 0,
			              1); /* insert an undefined symbol */
		if (ptr->section)         /* bad idea to use section names in
		                             expressions */
			display_error(error = 'S');
		if (ptr->multiple) /* use of multiply defined symbol */
			display_error(error = 'S');
		if (ptr->known) /* is the value of the symbol known? */
			return (ptr->value); /* value of symbol */
		if (pass == 2) display_error(error = 'U');
		expdef = FALSE; /* symbol value is unknown */
		return (0L);
	}
	/* wasn't local symbol - must be a constant */
	return (evalcon(radix));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x9fdf(%rip), %rbx      # 0xe2e0
callq 0x1240
movq (%rax), %rax
incq %rbx
xorl %edi, %edi
movsbq -0x1(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x4328
imull $0xa, %edi, %edx
leal (%rdx,%rcx), %edi
addl $-0x30, %edi
incq %rbx
jmp 0x430e
cmpb $0x24, %cl
jne 0x4357
movq %rbx, 0x9fac(%rip)      # 0xe2e0
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
leal (%rdi,%rax), %ecx
cmpl %eax, %ecx
ja 0x436a
leaq 0x9ab9(%rip), %rax      # 0xde00
movb $0x45, (%rax)
pushq $0x45
popq %rdi
callq 0x1e1c
jmp 0x4413
leaq 0x9816(%rip), %rax      # 0xdb74
movl (%rax), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x4272
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x80de
movq %rbx, %rdi
callq 0x83d7
leaq 0x98ca(%rip), %rbx      # 0xdc50
movq %rax, (%rbx)
testq %rax, %rax
jne 0x43a5
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %r8
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x812d
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x10, %cl
je 0x43c7
leaq 0x9a4b(%rip), %rax      # 0xde00
movb $0x53, (%rax)
pushq $0x53
popq %rdi
callq 0x1e1c
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x8, %cl
je 0x43e5
leaq 0x9a2d(%rip), %rax      # 0xde00
movb $0x53, (%rax)
pushq $0x53
popq %rdi
callq 0x1e1c
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
btl $0x8, %ecx
jb 0x4417
leaq 0x9412(%rip), %rax      # 0xd804
cmpl $0x2, (%rax)
jne 0x4409
leaq 0x9a02(%rip), %rax      # 0xde00
movb $0x55, (%rax)
pushq $0x55
popq %rdi
callq 0x1e1c
leaq 0x99d8(%rip), %rax      # 0xdde8
andl $0x0, (%rax)
xorl %eax, %eax
jmp 0x441b
movq 0x18(%rax), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x9eb7(%rip), %rcx      # 0xe2e0
movslq %edi, %rax
xorl %ebx, %ebx
movsbq (%rcx), %rdx
testq %rdx, %rdx
je 0x446c
leaq 0x1(%rcx), %rsi
movq %rsi, 0x9e9e(%rip)      # 0xe2e0
cmpb %dil, %dl
jne 0x4460
cmpb %dil, (%rsi)
jne 0x446c
shlq $0x8, %rbx
addq %rax, %rbx
addq $0x2, %rcx
movq %rcx, 0x9e82(%rip)      # 0xe2e0
jmp 0x442e
shlq $0x8, %rbx
addq %rdx, %rbx
movq %rsi, %rcx
jmp 0x442e
testq %rbx, %rbx
setne %al
movq %rbx, %rcx
shrq $0x10, %rcx
testw %cx, %cx
sete %cl
testb %cl, %al
jne 0x4495
leaq 0x9976(%rip), %rax      # 0xde00
movb $0x56, (%rax)
pushq $0x56
popq %rdi
callq 0x1e1c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x24(%rdi), %eax
cmpl $0xb, %eax
ja 0x44b6
leaq 0x5013(%rip), %rcx      # 0x94bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
jmp 0x44c2
cmpl $0x5e, %edi
je 0x44c0
cmpl $0x7c, %edi
jne 0x44c4
pushq $0x3
popq %rax
retq
pushq %rax
leaq 0x9934(%rip), %rax      # 0xde00
movb $0x43, (%rax)
pushq $0x43
popq %rdi
callq 0x1e1c
pushq $0x9
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
pushq $0x1
jmp 0x44c2
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4544
movq (%rbx), %rax
movslq 0x9f6d(%rip), %rcx      # 0xe480
leaq -0x1(%rcx), %rdx
movl %edx, 0x9f63(%rip)      # 0xe480
leaq 0x9dcc(%rip), %rdx      # 0xe2f0
movq %rax, -0x8(%rdx,%rcx,8)
movl (%r14), %eax
addl %eax, 0x9f52(%rip)      # 0xe484
movl $0x1, 0x9f4c(%rip)      # 0xe488
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/express.c
// Function: do_oper
void do_oper() { /* perform binary operations */

	long l = stack[vsp++];
	char c = opstk[osp++];
	if (vsp > MAXESTK) {
		vsp = MAXESTK;
		display_error(error = 'C');
	}
	if (osp > MAXESTK) {
		osp = MAXESTK;
		display_error(error = 'C');
	}
	lastval = TRUE;
	switch (c) {
		case '+':
			stack[vsp] += l;
			break;
		case '-':
			stack[vsp] -= l;
			break;
		case '*':
			stack[vsp] *= l;
			break;
		case '^':
			stack[vsp] ^= l;
			break;
		case '&':
			stack[vsp] &= l;
			break;
		case '|':
			stack[vsp] |= l;
			break;
		case '/':
			if (l)
				stack[vsp] /= l; /* divide by 0? */
			else
				display_error(error = 'E');
			break;
		default:
			display_error(error = 'C');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x9edb(%rip), %rcx      # 0xe480
leal 0x1(%rcx), %edx
movslq 0x9ed5(%rip), %rsi      # 0xe484
leal 0x1(%rsi), %eax
movl %edx, 0x9ec8(%rip)      # 0xe480
leaq 0x9d31(%rip), %rbx      # 0xe2f0
leaq 0x9eca(%rip), %rdx      # 0xe490
movzbl (%rsi,%rdx), %r15d
movq (%rbx,%rcx,8), %r14
movl %eax, 0x9eaf(%rip)      # 0xe484
cmpq $0x32, %rcx
jl 0x45fd
movl $0x32, 0x9e9b(%rip)     # 0xe480
leaq 0x9814(%rip), %rax      # 0xde00
movb $0x43, (%rax)
pushq $0x43
popq %rdi
callq 0x1e1c
movl 0x9e87(%rip), %eax      # 0xe484
cmpl $0x33, %eax
jl 0x461e
movl $0x32, 0x9e78(%rip)     # 0xe484
leaq 0x97ed(%rip), %rax      # 0xde00
movb $0x43, (%rax)
pushq $0x43
popq %rdi
callq 0x1e1c
movl $0x1, 0x9e60(%rip)      # 0xe488
leal -0x26(%r15), %eax
cmpl $0x9, %eax
ja 0x464e
leaq 0x4eb4(%rip), %rcx      # 0x94ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq 0x9e38(%rip), %rax      # 0xe480
andq %r14, (%rbx,%rax,8)
jmp 0x46c7
cmpl $0x5e, %r15d
je 0x46bc
cmpl $0x7c, %r15d
jne 0x4667
movslq 0x9e1f(%rip), %rax      # 0xe480
orq %r14, (%rbx,%rax,8)
jmp 0x46c7
leaq 0x9792(%rip), %rax      # 0xde00
movb $0x43, (%rax)
pushq $0x43
jmp 0x46d9
movslq 0x9e04(%rip), %rax      # 0xe480
imulq (%rbx,%rax,8), %r14
movq %r14, (%rbx,%rax,8)
jmp 0x46c7
movslq 0x9df2(%rip), %rax      # 0xe480
addq %r14, (%rbx,%rax,8)
jmp 0x46c7
movslq 0x9de5(%rip), %rax      # 0xe480
subq %r14, (%rbx,%rax,8)
jmp 0x46c7
testq %r14, %r14
je 0x46cd
movslq 0x9dd3(%rip), %rcx      # 0xe480
movq (%rbx,%rcx,8), %rax
cqto
idivq %r14
movq %rax, (%rbx,%rcx,8)
jmp 0x46c7
movslq 0x9dbd(%rip), %rax      # 0xe480
xorq %r14, (%rbx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x972c(%rip), %rax      # 0xde00
movb $0x45, (%rax)
pushq $0x45
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1e1c
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x28(%rbx), %eax
cmpl $0x37, %eax
ja 0x4705
movabsq $0x80000000500001, %rcx # imm = 0x80000000500001
btq %rax, %rcx
jb 0x470e
cmpl $0x7e, %ebx
jne 0x4799
movslq 0x9d6f(%rip), %rax      # 0xe484
leaq -0x1(%rax), %rcx
movl %ecx, 0x9d65(%rip)      # 0xe484
leaq 0x9d6a(%rip), %rcx      # 0xe490
movb %bl, -0x1(%rax,%rcx)
andl $0x0, 0x9d57(%rip)      # 0xe488
movb $0x1, %r14b
leaq 0x9d55(%rip), %r15      # 0xe490
movsbl %bl, %ebp
testb $0x1, %r14b
jne 0x478e
movslq 0x9d39(%rip), %rax      # 0xe484
movsbl (%rax,%r15), %edi
callq 0x449a
movl %eax, %r14d
movl %ebp, %edi
callq 0x449a
cmpl %eax, %r14d
setb %r14b
jae 0x4787
movslq 0x9d15(%rip), %rax      # 0xe484
leaq -0x1(%rax), %rcx
movl %ecx, 0x9d0b(%rip)      # 0xe484
movb %bl, -0x1(%rax,%r15)
andl $0x0, 0x9d03(%rip)      # 0xe488
jmp 0x473e
callq 0x4599
jmp 0x473e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x4734
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0x4a67(%rip), %rdi      # 0x9587
callq 0x1090
leaq 0x4a9f(%rip), %rdi      # 0x95cb
callq 0x1090
leaq 0x4add(%rip), %rdi      # 0x9615
callq 0x1090
leaq 0x4b01(%rip), %rdi      # 0x9645
callq 0x1090
leaq 0x4b2b(%rip), %rdi      # 0x967b
callq 0x1090
leaq 0x4b47(%rip), %rdi      # 0x96a3
callq 0x1090
leaq 0x4b5a(%rip), %rdi      # 0x96c2
callq 0x1090
leaq 0x4b8c(%rip), %rdi      # 0x9700
callq 0x1090
leaq 0x4bcd(%rip), %rdi      # 0x974d
callq 0x1090
leaq 0x4c07(%rip), %rdi      # 0x9793
callq 0x1090
leaq 0x4c19(%rip), %rdi      # 0x97b1
callq 0x1090
leaq 0x4c50(%rip), %rdi      # 0x97f4
callq 0x1090
leaq 0x4c82(%rip), %rdi      # 0x9832
callq 0x1090
leaq 0x4cb6(%rip), %rdi      # 0x9872
callq 0x1090
leaq 0x4cdb(%rip), %rdi      # 0x98a3
callq 0x1090
leaq 0x4d1a(%rip), %rdi      # 0x98ee
callq 0x1090
leaq 0x4d24(%rip), %rdi      # 0x9904
callq 0x1090
leaq 0x4d34(%rip), %rdi      # 0x9920
callq 0x1090
leaq 0x4d47(%rip), %rdi      # 0x993f
popq %rax
jmp 0x1090
nop