LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/codeniko[P]CS214-Malloc-Free/Test10.c
// Function: main
void main()
{
    void* p = malloc(sizeof(int));
    *((int*)p) = 5;
    printf("integer: address: %p, value: %d\n", p, *((int*)p));
    free(p);
    char* c = "Hello World"; 
    p = malloc(sizeof(char) * (strlen(c) + 1));
    memcpy(p, c, strlen(c));
    printf("String: address: %p, value: %s\n", p, (char*)p);
    free(p);
    p = malloc(sizeof(float));
    *((float*)p) = 1.2345;
    printf("float: address: %p, value: %f\n", p, *((float*)p));
    free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xeb6(%rip), %rbx       # 0x2010
movl $0x4, %edi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x1234
movq %rax, %r14
movl $0x5, (%rax)
leaq 0xe9d(%rip), %rdi       # 0x2019
movq %rax, %rsi
movl $0x5, %edx
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
movq %rbx, %rsi
movl $0xb, %edx
callq 0x138d
movl $0xc, %edi
movq %rbx, %rsi
movl $0xd, %edx
callq 0x1234
movq %rax, %r14
movabsq $0x6f57206f6c6c6548, %rax # imm = 0x6F57206F6C6C6548
movq %rax, (%r14)
movl $0x646c726f, 0x7(%r14)  # imm = 0x646C726F
leaq 0xe7a(%rip), %rdi       # 0x2046
movq %r14, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x138d
movl $0x4, %edi
movq %rbx, %rsi
movl $0x11, %edx
callq 0x1234
movq %rax, %r14
movl $0x3f9e0419, (%rax)     # imm = 0x3F9E0419
leaq 0xe5b(%rip), %rdi       # 0x2066
movsd 0xdf5(%rip), %xmm0      # 0x2008
movq %rax, %rsi
movb $0x1, %al
callq 0x1030
movq %r14, %rdi
movq %rbx, %rsi
movl $0x14, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x138d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_07/ungets.c
// Function: main
int main(void)
{
  char line[MAXLEN];
  char temp[MAXLEN];

  getstr(line, MAXLEN);
  printf("%s", line);

  ungetstr(line);

  getstr(temp, MAXLEN);
  printf("%s", temp);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
leaq 0x3f0(%rsp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d1
leaq 0xe72(%rip), %r14       # 0x2004
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x1238
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d1
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_07/ungets.c
// Function: getstr
int getstr(char line[], int limit)
{
  int i = 0, c;

  while (limit - 1 > 0 && (c = getch()) != EOF && c != '\n')
  {
    line[i++] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x2, %esi
jl 0x1221
xorl %r14d, %r14d
leaq 0x2e85(%rip), %r15      # 0x4070
movl 0x2e6f(%rip), %eax      # 0x4060
testl %eax, %eax
jle 0x1204
decl %eax
movl %eax, 0x2e63(%rip)      # 0x4060
movsbl (%rax,%r15), %eax
jmp 0x1209
callq 0x1060
cmpl $-0x1, %eax
je 0x121c
cmpl $0xa, %eax
je 0x121c
movb %al, (%rbx,%r14)
incq %r14
jmp 0x11eb
cmpl $0xa, %eax
jne 0x122b
movl %r14d, %eax
incl %r14d
movb $0xa, (%rbx,%rax)
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_alltoall64.c
// Function: shmem_alltoall64
void shmem_alltoall64( void* dest, const void* source, size_t nelems,
	int pe_start, int log_pe_stride, int pe_size, long* psync)
{
	debug("[%d] shmem_alltoall_x begin\n",__shmem.my_pe);
	int j;
	int dst_offset = ((__shmem.my_pe - pe_start) >> log_pe_stride)*nelems;
	int pe_size_stride = pe_size << log_pe_stride;
	int step = 1 << log_pe_stride;
	int pe_end = pe_size_stride + pe_start;
	int64_t* psrc = (int64_t*)source;
	int64_t* pdsto = (int64_t*)dest + dst_offset;
	shmemx_memcpy((void*)pdsto, (void*)psrc, nelems*sizeof(int64_t));
	for (j = 1; j < pe_size; j++) {
		int pe_to = __shmem.my_pe + j*step;
		if (pe_to >= pe_end) pe_to -= pe_size_stride;
		int64_t* pdst = (int64_t*)shmem_ptr(pdsto, pe_to);
		shmemx_memcpy((void*)pdst, (void*)psrc, nelems*sizeof(int64_t));
	}
	debug("[%d] shmem_alltoall_x before barrier\n",__shmem.my_pe);
	shmem_barrier(pe_start, log_pe_stride, pe_size, psync);
	debug("[%d] shmem_alltoall_x end\n",__shmem.my_pe);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movq %rdx, %r8
leaq 0x3102(%rip), %r15      # 0x6200
movl 0x4(%r15), %eax
movq %rcx, (%rsp)
subl %ecx, %eax
movl %ebp, %ecx
sarl %cl, %eax
imull %eax, %edx
movl %r9d, %eax
shll %cl, %eax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq %edx, %rax
leaq (%rdi,%rax,8), %r13
shlq $0x3, %r8
movq %r13, %rdi
movq %rsi, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r8, %rdx
callq 0x3274
movl %ebx, %edx
cmpl $0x2, %ebx
jl 0x31a8
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
leal (%rcx,%rax), %r12d
movl $0x1, %ebx
movl %ebx, %esi
movl %ebp, %ecx
shll %cl, %esi
addl 0x4(%r15), %esi
cmpl %r12d, %esi
movq 0x8(%rsp), %rax
movl $0x0, %ecx
cmovll %ecx, %eax
subl %eax, %esi
movq %r13, %rdi
movq %r15, %r14
movl %ebp, %r15d
movl %edx, %ebp
callq 0x1cf8
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3274
movl %ebp, %edx
movl %r15d, %ebp
movq %r14, %r15
incl %ebx
cmpl %ebx, %edx
jne 0x315c
movq (%rsp), %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c8
nop
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: checkType
int checkType(unsigned char t) {
    /* In case a new object type is added, update the following 
     * condition as necessary. */
    return
        (t >= REDIS_HASH_ZIPMAP && t <= REDIS_HASH_ZIPLIST) ||
        t <= REDIS_HASH ||
        t >= REDIS_EXPIRETIME_MS;
}

// Assembly:
cmpb $0xe, %dil
jae 0x1696
movl $0x1, %eax
movzbl %dil, %ecx
movl $0x3e1f, %edx           # imm = 0x3E1F
btl %ecx, %edx
jae 0x1696
retq
xorl %eax, %eax
cmpb $-0x4, %dil
setae %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4b94(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %r14
leaq 0x4a09(%rip), %r15      # 0x60d0
movq 0x10(%r15,%r14,8), %rsi
leaq (%rsi,%rdx), %r12
xorl %eax, %eax
cmpq 0x8(%r15,%r14,8), %r12
ja 0x16f4
leaq (%r15,%r14,8), %rax
addq (%rax), %rsi
callq 0x10e0
movl $0x1, %eax
testq %rbx, %rbx
js 0x16f4
movq %r12, 0x10(%r15,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rax, 0x8(%rsp)
movw $0x5f, 0x10(%rsp)
movzbl 0x4b2f(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rdx
leaq 0x49a4(%rip), %rsi      # 0x60d0
movq 0x10(%rsi,%rdx,8), %rcx
leaq 0x9(%rcx), %rax
cmpq 0x8(%rsi,%rdx,8), %rax
ja 0x178d
leaq (%rsi,%rdx,8), %rdx
movq (%rdx), %rsi
movb 0x8(%rcx,%rsi), %dil
movb %dil, 0x10(%rsp)
movq (%rcx,%rsi), %rcx
movq %rcx, 0x8(%rsp)
movl $0x49444552, %ecx       # imm = 0x49444552
xorl 0x8(%rsp), %ecx
movq %rax, 0x10(%rdx)
movzbl 0xc(%rsp), %eax
xorl $0x53, %eax
orl %ecx, %eax
jne 0x1796
leaq 0xd(%rsp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x10d0
leal -0x7(%rax), %ecx
cmpl $-0x7, %ecx
jbe 0x17a4
addq $0x18, %rsp
retq
leaq 0x1cc8(%rip), %rdi      # 0x345c
jmp 0x179d
leaq 0x1cd2(%rip), %rdi      # 0x346f
callq 0x1070
jmp 0x17b4
leaq 0x18d9(%rip), %rdi      # 0x3084
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movzbl 0x4a8a(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rcx
leaq 0x48ff(%rip), %rdx      # 0x60d0
movq 0x10(%rdx,%rcx,8), %rbx
leaq 0x1(%rbx), %rax
cmpq 0x8(%rdx,%rcx,8), %rax
jbe 0x1825
movq 0x8af0(%rip), %rax      # 0xa2d8
leaq 0x4a69(%rip), %rcx      # 0x6258
movq %rax, %rdx
shlq $0xa, %rdx
movups 0x18bd(%rip), %xmm0     # 0x30ba
movups %xmm0, (%rdx,%rcx)
movl $0x657079, 0x10(%rdx,%rcx) # imm = 0x657079
movl %ebx, %ecx
leaq 0x4a46(%rip), %rdx      # 0x6258
movq %rcx, 0x4000(%rdx,%rax,8)
incq 0x8ab7(%rip)            # 0xa2d8
xorl %eax, %eax
jmp 0x184f
leaq (%rdx,%rcx,8), %rcx
addq $0x10, %rcx
movq -0x10(%rcx), %rdx
movzbl (%rbx,%rdx), %edx
movq %rax, (%rcx)
cmpl $0xd, %edx
ja 0x1851
movl $0x3e1f, %eax           # imm = 0x3E1F
btl %edx, %eax
jae 0x1851
movl %edx, 0x8(%rdi)
movl $0x1, %eax
popq %rbx
retq
cmpb $-0x4, %dl
jae 0x1847
leaq 0x49fb(%rip), %rax      # 0x6258
movq 0x8a74(%rip), %rdi      # 0xa2d8
shlq $0xa, %rdi
addq %rax, %rdi
leaq 0x1832(%rip), %rsi      # 0x30a4
xorl %eax, %eax
callq 0x1130
movq 0x8a58(%rip), %rax      # 0xa2d8
jmp 0x1809
// File: /workspace/github_c_makefile_star2_O3/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:
movzbl 0x496d(%rip), %eax      # 0x6250
xorl %esi, %esi
cmpl $0xfc, %edi
sete %sil
leaq (%rax,%rax,2), %rcx
leaq 0x47d6(%rip), %rdx      # 0x60d0
movq 0x10(%rdx,%rcx,8), %rax
leaq (%rax,%rsi,4), %rsi
addq $0x4, %rsi
cmpq 0x8(%rdx,%rcx,8), %rsi
jbe 0x194a
leaq 0x4943(%rip), %rcx      # 0x6258
movq 0x89bc(%rip), %rdx      # 0xa2d8
movq %rdx, %rsi
shlq $0xa, %rsi
movups 0x17a4(%rip), %xmm0     # 0x30ce
movups %xmm0, (%rsi,%rcx)
movl $0x656d69, 0x10(%rsi,%rcx) # imm = 0x656D69
movl %eax, %eax
movq %rax, 0x4000(%rcx,%rdx,8)
incq 0x8991(%rip)            # 0xa2d8
xorl %eax, %eax
retq
movq %rsi, 0x10(%rdx,%rcx,8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1960
movl $0x0, (%rdi)
movzbl 0x48e9(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %r10
leaq 0x475e(%rip), %r11      # 0x60d0
movq 0x8(%r11,%r10,8), %r8
movq 0x10(%r11,%r10,8), %rcx
leaq 0x1(%rcx), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rsi
ja 0x19a1
leaq (%r11,%r10,8), %rax
movq (%rax), %r9
movzbl (%rcx,%r9), %edx
movq %rsi, 0x10(%rax)
movl %edx, %eax
cmpl $0x40, %edx
jae 0x19a2
retq
leaq (%r11,%r10,8), %r10
addq $0x10, %r10
movl %edx, %eax
shrl $0x6, %eax
cmpl $0x1, %eax
je 0x19c9
cmpl $0x3, %eax
jne 0x19ea
testq %rdi, %rdi
je 0x19c4
movl $0x1, (%rdi)
andl $0x3f, %edx
jmp 0x19e7
addq $0x2, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rcx
ja 0x19a1
movzbl (%rsi,%r9), %eax
movq %rcx, (%r10)
andl $0x3f, %edx
shll $0x8, %edx
orl %eax, %edx
movl %edx, %eax
retq
addq $0x5, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rcx
ja 0x19a1
movl (%rsi,%r9), %eax
movq %rcx, (%r10)
bswapl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movzbl 0x4842(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rcx
leaq 0x46b7(%rip), %rsi      # 0x60d0
leaq (%rsi,%rcx,8), %rax
addq $0x10, %rax
cmpl $0x2, %edi
je 0x1a6d
movl %edi, %edx
cmpl $0x1, %edi
je 0x1a4f
testl %edx, %edx
jne 0x1a81
movq 0x10(%rsi,%rcx,8), %rdx
leaq 0x1(%rdx), %rdi
cmpq 0x8(%rsi,%rcx,8), %rdi
ja 0x1a7d
leaq (%rsi,%rcx,8), %rcx
movq (%rcx), %rcx
movsbq (%rdx,%rcx), %r14
jmp 0x1acc
movq 0x10(%rsi,%rcx,8), %rdx
leaq 0x2(%rdx), %rdi
cmpq 0x8(%rsi,%rcx,8), %rdi
ja 0x1a7d
leaq (%rsi,%rcx,8), %rcx
movq (%rcx), %rcx
movswq (%rdx,%rcx), %r14
jmp 0x1acc
movq 0x10(%rsi,%rcx,8), %rdx
leaq 0x4(%rdx), %rdi
cmpq 0x8(%rsi,%rcx,8), %rdi
jbe 0x1ac1
xorl %ebx, %ebx
jmp 0x1af0
movl (%rax), %r14d
leaq 0x47cd(%rip), %r15      # 0x6258
movq 0x8846(%rip), %rdi      # 0xa2d8
shlq $0xa, %rdi
addq %r15, %rdi
leaq 0x1642(%rip), %rsi      # 0x30e2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1130
movq 0x8828(%rip), %rax      # 0xa2d8
movq %r14, 0x4000(%r15,%rax,8)
incq 0x8819(%rip)            # 0xa2d8
jmp 0x1af0
leaq (%rsi,%rcx,8), %rcx
movq (%rcx), %rcx
movslq (%rdx,%rcx), %r14
movq %rdi, (%rax)
movl $0x80, %edi
callq 0x10f0
movq %rax, %rbx
leaq 0x1621(%rip), %rsi      # 0x3104
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1130
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x1955
cmpl $-0x1, %eax
je 0x1bac
movl %eax, %ebx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x1955
cmpl $-0x1, %eax
je 0x1bac
movl %eax, %ebp
movl %ebx, %r15d
movq %r15, %rdi
callq 0x10f0
movq %rax, %r14
movzbl 0x470d(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rax
leaq 0x4582(%rip), %rcx      # 0x60d0
movq 0x10(%rcx,%rax,8), %rsi
leaq (%rsi,%r15), %r12
cmpq 0x8(%rcx,%rax,8), %r12
ja 0x1ba1
leaq (%rcx,%rax,8), %r13
addq (%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x10e0
movq %r12, 0x10(%r13)
movl %ebp, %edi
incl %edi
callq 0x10f0
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x2c20
movl %eax, %ebx
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testl %ebx, %ebx
jne 0x1bac
movq %r14, %rdi
callq 0x1030
xorl %r15d, %r15d
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_O3/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 0x4683(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rax
leaq 0x44f8(%rip), %r12      # 0x60d0
movl 0x10(%r12,%rax,8), %r15d
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x1955
movl %eax, %r14d
cmpl $0x0, (%rbx)
je 0x1c02
cmpl $0x3, %r14d
jae 0x1c42
movl %r14d, %edi
callq 0x1a02
jmp 0x1c49
cmpl $-0x1, %r14d
je 0x1c3e
leal 0x1(%r14), %edi
callq 0x10f0
movq %rax, %rbx
movl %r14d, %edx
movb $0x0, (%rax,%rdx)
movzbl 0x462e(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rax
movq 0x10(%r12,%rax,8), %rsi
leaq (%rsi,%rdx), %r14
cmpq 0x8(%r12,%rax,8), %r14
jbe 0x1c9b
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
jmp 0x1c4c
jne 0x1c5b
callq 0x1af9
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x45f6(%rip), %r12      # 0x6258
movq 0x866f(%rip), %rdi      # 0xa2d8
shlq $0xa, %rdi
addq %r12, %rdi
leaq 0x1492(%rip), %rsi      # 0x3109
xorl %ebx, %ebx
movl %r14d, %edx
xorl %eax, %eax
callq 0x1130
movq 0x864e(%rip), %rax      # 0xa2d8
movq %r15, 0x4000(%r12,%rax,8)
incq 0x863f(%rip)            # 0xa2d8
jmp 0x1c4c
leaq (%r12,%rax,8), %r15
addq (%r15), %rsi
movq %rbx, %rdi
callq 0x10e0
movq %r14, 0x10(%r15)
jmp 0x1c4c
// File: /workspace/github_c_makefile_star2_O3/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 0x4592(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rax
leaq 0x4407(%rip), %rcx      # 0x60d0
movq 0x10(%rcx,%rax,8), %r14
callq 0x1bbe
testq %rax, %rax
je 0x1ce2
testq %rbx, %rbx
je 0x1d21
movq %rax, (%rbx)
jmp 0x1d29
leaq 0x456f(%rip), %rax      # 0x6258
movq 0x85e8(%rip), %rcx      # 0xa2d8
movq %rcx, %rdx
shlq $0xa, %rdx
movups 0x1438(%rip), %xmm0     # 0x3136
movups %xmm0, 0xc(%rdx,%rax)
movups 0x1420(%rip), %xmm0     # 0x312a
movups %xmm0, (%rdx,%rax)
movq %r14, 0x4000(%rax,%rcx,8)
incq 0x85bb(%rip)            # 0xa2d8
xorl %eax, %eax
jmp 0x1d2e
movq %rax, %rdi
callq 0x1030
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4403(%rip), %eax      # 0x6250
leaq (%rax,%rax,2), %rax
leaq 0x4278(%rip), %rcx      # 0x60d0
movq 0x10(%rcx,%rax,8), %r14
callq 0x1d36
testq %rax, %rax
je 0x1e71
testq %rbx, %rbx
je 0x1eb0
movq %rax, (%rbx)
jmp 0x1eb8
leaq 0x43e0(%rip), %rax      # 0x6258
movq 0x8459(%rip), %rcx      # 0xa2d8
movq %rcx, %rdx
shlq $0xa, %rdx
movups 0x12c8(%rip), %xmm0     # 0x3155
movups %xmm0, 0xb(%rdx,%rax)
movups 0x12b1(%rip), %xmm0     # 0x314a
movups %xmm0, (%rdx,%rax)
movq %r14, 0x4000(%rax,%rcx,8)
incq 0x842c(%rip)            # 0xa2d8
xorl %eax, %eax
jmp 0x1ebd
movq %rax, %rdi
callq 0x1030
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl 0x8(%rdi), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x25db
cmpl $0xfd, %r14d
jl 0x25f7
shlq $0x4, %r14
leaq 0x7d34(%rip), %rdx      # 0xa300
addq %r14, %rdx
leaq 0xd6c(%rip), %rsi       # 0x3342
jmp 0x269d
movabsq $0x727420726f727245, %rax # imm = 0x727420726F727245
movq %rax, 0x30(%rsp)
movl $0x656361, 0x38(%rsp)   # imm = 0x656361
jmp 0x26a9
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2685
movq %rsp, %rdi
movl $0x28, %edx
movq %rbx, %rsi
callq 0x1060
movq %rbx, %rdi
callq 0x1080
cmpq $0x29, %rax
jb 0x262d
movb $0x2e, 0x27(%rsp)
movw $0x2e2e, 0x25(%rsp)     # imm = 0x2E2E
cmpb $0x0, (%rsp)
je 0x265c
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rsp, %rbx
cmpb $0x20, (%rsp,%r15)
jg 0x264a
movb $0x3f, (%rsp,%r15)
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x1080
incl %ebp
cmpq %r15, %rax
ja 0x263e
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x7c96(%rip), %rdx      # 0xa300
addq %rax, %rdx
leaq 0xcfb(%rip), %rsi       # 0x336f
leaq 0x30(%rsp), %rdi
movq %rsp, %rcx
xorl %eax, %eax
callq 0x1130
jmp 0x26a9
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x7c6d(%rip), %rdx      # 0xa300
addq %rax, %rdx
leaq 0xcb6(%rip), %rsi       # 0x3353
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
callq 0x1130
leaq 0x30(%rsp), %rdx
movl $0x4, %edi
movl $0x50, %esi
callq 0x2494
cmpq $0x0, 0x7c13(%rip)      # 0xa2d8
je 0x2702
movl $0x1, %ebp
leaq 0x3b85(%rip), %r14      # 0x6258
leaq 0xcaa(%rip), %rbx       # 0x3384
xorl %edx, %edx
movq 0x4000(%r14,%rdx,8), %rsi
shlq $0xa, %rdx
addq %r14, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edx
incl %ebp
cmpq %rdx, 0x7bd8(%rip)      # 0xa2d8
ja 0x26dc
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1037ee(%rip), %r15    # 0x108078
movl 0x40(%r15), %edi
callq 0x4c98
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 0x4c7b
movl %eax, %r14d
movl 0x20(%r15,%rbx,4), %edi
decl %edi
movl %edi, 0x20(%r15,%rbx,4)
callq 0x4c7b
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 0x4c11
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_O3/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 0x1035aa(%rip), %rcx    # 0x108070
movq (%rcx), %r14
movq (%r14,%r12,8), %r15
testb $0x1, %r15b
jne 0x4b1e
movl $0x404, %edi            # imm = 0x404
movl $0x8, %esi
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 0x103566(%rip), %rax    # 0x108070
movq (%rax), %rax
orq $0x1, (%rax,%r12)
movabsq $0x3ffffffffffffffc, %rax # imm = 0x3FFFFFFFFFFFFFFC
jmp 0x4b28
shrq $0x2, %r15
andq %rax, %r15
movq %r15, %r13
movl %ebx, %r14d
movq (%r13,%r14,8), %rbx
testb $0x1, %bl
jne 0x4b67
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
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 0x4b71
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_O3/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 0x1034de(%rip), %r14    # 0x108070
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4beb
xorl %r15d, %r15d
movq (%rdi,%r15,8), %rbx
testb $0x1, %bl
je 0x4bd3
andq $-0x10, %rbx
movl $0x400, %r12d           # imm = 0x400
movq (%rbx,%r15,8), %rdi
testb $0x1, %dil
je 0x4bc3
andq $-0x10, %rdi
callq 0x3030
decl %r12d
jne 0x4bb0
movq %rbx, %rdi
callq 0x3030
movq (%r14), %rdi
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x4b9d
callq 0x3030
movq $0x0, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0x4a95
andl $0xfff, %r14d           # imm = 0xFFF
bswapl %ebx
movl %ebx, (%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/wgsim.c
// Function: ran_normal
double ran_normal()
{ 
	static int iset = 0; 
	static double gset; 
	double fac, rsq, v1, v2; 
	if (iset == 0) {
		do { 
			v1 = 2.0 * drand48() - 1.0;
			v2 = 2.0 * drand48() - 1.0; 
			rsq = v1 * v1 + v2 * v2;
		} while (rsq >= 1.0 || rsq == 0.0);
		fac = sqrt(-2.0 * log(rsq) / rsq); 
		gset = v1 * fac; 
		iset = 1;
		return v2 * fac;
	} else {
		iset = 0;
		return gset;
	}
}

// Assembly:
cmpb $0x0, 0x3265(%rip)      # 0x5128
je 0x1ed9
movb $0x0, 0x325c(%rip)      # 0x5128
movsd 0x325c(%rip), %xmm1     # 0x5130
jmp 0x1f95
subq $0x18, %rsp
callq 0x11d0
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0x1116(%rip), %xmm0     # 0x3008
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x11d0
addsd %xmm0, %xmm0
addsd 0x10fc(%rip), %xmm0     # 0x3008
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
ucomisd 0x10e7(%rip), %xmm2     # 0x3010
jae 0x1edd
ucomisd 0x10ed(%rip), %xmm2     # 0x3020
jne 0x1f37
jnp 0x1edd
movsd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x10c0
mulsd 0x10c4(%rip), %xmm0     # 0x3018
divsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1f6a
sqrtsd %xmm0, %xmm0
jmp 0x1f6f
callq 0x11b0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x31b0(%rip)     # 0x5130
movb $0x1, 0x31a1(%rip)      # 0x5128
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
addq $0x18, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x5d, %esi
callq 0x10d0
testq %rax, %rax
cmoveq %r14, %rax
movq %rax, %rdi
movl $0x2e, %esi
callq 0x10d0
testq %rax, %rax
je 0x1e79
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11e0
// File: /workspace/github_c_makefile_star2_O3/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 0x839c(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x10e0
cmpl $0x1, %ebx
jg 0x1ea9
popq %rbx
retq
movq 0xb898(%rip), %rdi      # 0xd748
callq 0x10a0
leaq 0xba14(%rip), %rdi      # 0xd8d0
callq 0x1060
movl %ebx, %edi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O3/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 0xbda1(%rip), %rax      # 0xdc70
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x1ee3
cmpl $0x20, %ecx
je 0x1ee4
incq %rax
cmpb %dil, %cl
jne 0x1ecf
retq
movb %dil, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbc62(%rip), %rax      # 0xdb60
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %edx, %eax
andb $0xf, %al
sarl $0x4, %edx
movslq %edx, %rdx
leaq 0xbdba(%rip), %rsi      # 0xdcd0
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 0x1f4e
leaq 0x8300(%rip), %rdi      # 0xa23d
leaq 0x8bf3(%rip), %rsi      # 0xab37
movl $0x4, %edx
callq 0x1e8b
leaq 0xbc13(%rip), %rax      # 0xdb68
andl %ebx, (%rax)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4348
cmpl $0x22, %ecx
jne 0x4377
movb 0x1(%rdi), %sil
testb %sil, %sil
je 0x4377
leaq 0x1(%rdi), %rdx
cmpb %cl, %sil
jne 0x4368
movb 0x2(%rdi), %dl
cmpb %cl, %dl
jne 0x4378
addq $0x2, %rdi
movq %rdi, %rdx
movq %rdx, %rdi
incq %rdx
movb 0x1(%rdi), %sil
testb %sil, %sil
jne 0x4355
retq
xorl %eax, %eax
testb %dl, %dl
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9f37(%rip), %r14      # 0xe2d0
movsbq -0x1(%r14), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rsp)
callq 0x1230
incq %r14
movl $0x1, %ecx
movabsq $0x800000000000401, %rdx # imm = 0x800000000000401
movq (%rax), %rdi
movsbq -0x1(%r14), %rsi
movzwl (%rdi,%rsi,2), %edi
testl $0xc00, %edi            # imm = 0xC00
jne 0x43e1
movzbl %sil, %edi
addl $-0x24, %edi
cmpl $0x3b, %edi
ja 0x4400
btq %rdi, %rdx
jae 0x4400
movq (%rbx), %rdi
movb (%rdi,%rsi,4), %sil
movl %ecx, %edi
movb %sil, (%rsp,%rdi)
movq %r14, 0x9edb(%rip)      # 0xe2d0
cmpl $0x1f, %ecx
adcl $0x0, %ecx
incq %r14
jmp 0x43bb
movl %ecx, %eax
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
callq 0x8e31
leaq 0x982b(%rip), %rbx      # 0xdc40
movq %rax, (%rbx)
testq %rax, %rax
je 0x442d
addq $0x10, %rax
movq %rax, %rdi
xorl %esi, %esi
callq 0x8a4e
jmp 0x443e
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b70
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x10, %cl
je 0x4465
leaq 0x999f(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ec8
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x8, %cl
je 0x4485
leaq 0x997f(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ec8
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
btl $0x8, %ecx
jb 0x44bc
leaq 0x9362(%rip), %rax      # 0xd7f4
cmpl $0x2, (%rax)
jne 0x44ab
leaq 0x9952(%rip), %rax      # 0xddf0
movb $0x55, (%rax)
movl $0x55, %edi
callq 0x1ec8
leaq 0x9926(%rip), %rax      # 0xddd8
movl $0x0, (%rax)
xorl %eax, %eax
jmp 0x44c0
movq 0x18(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x1230
movq %rax, %r14
movq (%rax), %rax
movq 0x9dec(%rip), %r15      # 0xe2d0
movsbq (%r15), %r12
testb $0x10, 0x1(%rax,%r12,2)
jne 0x44f4
xorl %eax, %eax
jmp 0x4552
callq 0x1030
movq %rax, %rcx
movl %ebx, %edx
incq %r15
xorl %eax, %eax
movq (%rcx), %rsi
movb (%rsi,%r12,4), %sil
leal -0x30(%rsi), %edi
addb $-0x37, %sil
cmpb $0xa, %dil
movzbl %sil, %r8d
movzbl %dil, %esi
cmovgel %r8d, %esi
testb %sil, %sil
js 0x4552
movsbl %sil, %edi
cmpl %ebx, %edi
jge 0x4552
imulq %rdx, %rax
movzbl %sil, %esi
addq %rsi, %rax
movq %r15, 0x9d90(%rip)      # 0xe2d0
movq (%r14), %rsi
movsbq (%r15), %r12
incq %r15
testb $0x10, 0x1(%rsi,%r12,2)
jne 0x4503
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9d66(%rip), %rbx      # 0xe2d0
callq 0x1230
movq (%rax), %rcx
movsbq (%rbx), %rax
xorl %edi, %edi
testb $0x8, 0x1(%rcx,%rax,2)
je 0x459c
xorl %edi, %edi
movsbl %al, %eax
leal (%rdi,%rdi,4), %edx
leal (%rax,%rdx,2), %edi
addl $-0x30, %edi
movsbq 0x1(%rbx), %rax
incq %rbx
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x4581
cmpb $0x24, %al
jne 0x45cf
incq %rbx
movq %rbx, 0x9d26(%rip)      # 0xe2d0
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
leal (%rdi,%rax), %ecx
cmpl %eax, %ecx
ja 0x45e2
leaq 0x9833(%rip), %rax      # 0xddf0
movb $0x45, (%rax)
movl $0x45, %edi
callq 0x1ec8
jmp 0x4696
leaq 0x958e(%rip), %rax      # 0xdb64
movl (%rax), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x44c8
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x8b21
movq %rbx, %rdi
callq 0x8e31
leaq 0x9642(%rip), %rbx      # 0xdc40
movq %rax, (%rbx)
testq %rax, %rax
jne 0x461f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x8b70
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x10, %cl
je 0x4643
leaq 0x97c1(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ec8
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
testb $0x8, %cl
je 0x4663
leaq 0x97a1(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ec8
movq (%rbx), %rax
movzwl 0x20(%rax), %ecx
btl $0x8, %ecx
jb 0x469a
leaq 0x9184(%rip), %rax      # 0xd7f4
cmpl $0x2, (%rax)
jne 0x4689
leaq 0x9774(%rip), %rax      # 0xddf0
movb $0x55, (%rax)
movl $0x55, %edi
callq 0x1ec8
leaq 0x9748(%rip), %rax      # 0xddd8
movl $0x0, (%rax)
xorl %eax, %eax
jmp 0x469e
movq 0x18(%rax), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9c24(%rip), %rcx      # 0xe2d0
movb (%rcx), %dl
testb %dl, %dl
je 0x4711
movsbq %dil, %rax
xorl %ebx, %ebx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x9c0d(%rip)      # 0xe2d0
cmpb %dil, %dl
jne 0x46e4
cmpb %dil, (%rsi)
jne 0x46f8
shlq $0x8, %rbx
addq %rax, %rbx
addq $0x2, %rcx
movq %rcx, 0x9bf1(%rip)      # 0xe2d0
movq %rcx, %rsi
jmp 0x46f2
shlq $0x8, %rbx
movsbq %dl, %rcx
addq %rcx, %rbx
movq %rsi, %rcx
movb (%rsi), %dl
testb %dl, %dl
jne 0x46b8
testq %rbx, %rbx
setne %al
movq %rbx, %rcx
shrq $0x10, %rcx
testw %cx, %cx
sete %cl
testb %cl, %al
je 0x4713
jmp 0x4727
xorl %ebx, %ebx
leaq 0x96d6(%rip), %rax      # 0xddf0
movb $0x56, (%rax)
movl $0x56, %edi
callq 0x1ec8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x474a
leaq 0x5d81(%rip), %rcx      # 0xa4bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, %eax
retq
cmpl $0x5e, %edi
je 0x4754
cmpl $0x7c, %edi
jne 0x475a
movl $0x3, %eax
retq
pushq %rax
leaq 0x968e(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x1ec8
movl $0x9, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47e3
movq (%rbx), %rax
movslq 0x9cbe(%rip), %rcx      # 0xe470
leaq -0x1(%rcx), %rdx
movl %edx, 0x9cb4(%rip)      # 0xe470
leaq 0x9b1d(%rip), %rdx      # 0xe2e0
movq %rax, -0x8(%rdx,%rcx,8)
movl (%r14), %eax
addl %eax, 0x9ca3(%rip)      # 0xe474
movl $0x1, 0x9c9d(%rip)      # 0xe478
addq $0x18, %rsp
popq %rbx
popq %r14
retq