LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: runas
int runas(const char* user)
{
    struct passwd* passwd = getpwuid(getuid());

    if(strcmp(passwd->pw_name, user) == 0) {
        return 0;
    }

    passwd = getpwnam(user);
    if(passwd == NULL) {
        return -1;
    }

/*    struct group* group = getgrnam(grp);
    if(group == NULL) {
        return -1;
    }*/

    if(setuid(passwd->pw_uid) != 0) {
        fprintf(stderr, "setuid failed,: %s\n", strerror(errno));
        return -1;
    }
/*    if(setgid(group->gr_gid) != 0){
        fprintf(stderr, "setgid failed: %s\n", strerror(errno));
        return -1;
    }*/

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x2130
movl %eax, %edi
callq 0x2110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2200
cmpl $0x0, %eax
jne 0x692a
movl $0x0, -0x4(%rbp)
jmp 0x6997
movq -0x10(%rbp), %rdi
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6947
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6997
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x2360
cmpl $0x0, %eax
je 0x6990
movq 0x7699(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2370
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x3902(%rip), %rsi      # 0xa282
movb $0x0, %al
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6997
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: write_pid_file
int write_pid_file(const char* file)
{
    FILE* fp = fopen(file, "w");
    if(fp == NULL){
        return -1;
    }

    fprintf(fp, "%d", getpid());

    fclose(fp);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x38df(%rip), %rsi      # 0xa296
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x69d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a01
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x20f0
movq -0x20(%rbp), %rdi
movl %eax, %edx
leaq 0x3866(%rip), %rsi      # 0xa250
movb $0x0, %al
callq 0x2220
movq -0x18(%rbp), %rdi
callq 0x2100
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: read_pid_file
int read_pid_file(pid_t* pid, const char* file)
{
    FILE* fp = fopen(file, "r");
    if(fp == NULL){
        return -1;
    }

    fscanf(fp, "%d", pid);

    fclose(fp);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3735(%rip), %rsi      # 0xa160
callq 0x2300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6a44
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a6a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x37fd(%rip), %rsi      # 0xa250
movb $0x0, %al
callq 0x20a0
movq -0x20(%rbp), %rdi
callq 0x2100
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: get_1970_sec_0_am
time_t get_1970_sec_0_am()
{
    time_t now = get_1970_sec();
    struct tm now_tm = {0};

    localtime_r(&now, &now_tm);

    now_tm.tm_hour = 0;
    now_tm.tm_min = 0;
    now_tm.tm_sec = 0;

    return mktime(&now_tm) + SEC_1900_1970;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x6a80
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2190
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2080
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x22d0
movabsq $0x83aa7e80, %rcx       # imm = 0x83AA7E80
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: sec_1970_to_datetime
int sec_1970_to_datetime(time_t sec, const char* fmt, char* datetime, int len)
{
    if(datetime == NULL)
        return -1;

    memset(datetime, 0, len);

    struct tm rst;
    localtime_r(&sec, &rst);
    snprintf(datetime, len, fmt, rst.tm_year + 1900, rst.tm_mon + 1,
            rst.tm_mday, rst.tm_hour, rst.tm_min, rst.tm_sec);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c4a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6cad
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2080
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x4c(%rbp), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl -0x50(%rbp), %r8d
addl $0x1, %r8d
movl -0x54(%rbp), %r9d
movl -0x58(%rbp), %r11d
movl -0x5c(%rbp), %r10d
movl -0x60(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: sec_1970_to_date
int sec_1970_to_date(time_t sec, const char* fmt, char* time, int len)
{
    if(time == NULL) return -1;

    memset(time, 0, len);

    struct tm rst;
    localtime_r(&sec, &rst);
    snprintf(time, len, fmt,  rst.tm_year + 1900, rst.tm_mon + 1,
            rst.tm_mday);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ce7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d32
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2080
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x4c(%rbp), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl -0x50(%rbp), %r8d
addl $0x1, %r8d
movl -0x54(%rbp), %r9d
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: sec_1970_to_time
int sec_1970_to_time(time_t sec, const char* fmt, char* time, int len)
{
    if(time == NULL) return -1;

    memset(time, 0, len);

    struct tm rst;
    localtime_r(&sec, &rst);
    snprintf(time, len, fmt,  rst.tm_hour, rst.tm_min, rst.tm_sec);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6d67
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6da8
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2080
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x58(%rbp), %ecx
movl -0x5c(%rbp), %r8d
movl -0x60(%rbp), %r9d
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: sec_1970_to_numeric
int sec_1970_to_numeric(time_t s,
        int* year, int* mon, int* day,
        int* hour, int* min, int* sec)
{
    if(!year || !mon || !day ||
            !hour || !min || !sec){
        return -1;
    }

    struct tm rst;
    localtime_r(&s, &rst);
    *year = rst.tm_year + 1900;
    *mon = rst.tm_mon + 1;
    *day = rst.tm_mday;

    *hour = rst.tm_hour;
    *min = rst.tm_min;
    *sec = rst.tm_sec;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e0e
cmpq $0x0, -0x20(%rbp)
je 0x6e0e
cmpq $0x0, -0x28(%rbp)
je 0x6e0e
cmpq $0x0, -0x30(%rbp)
je 0x6e0e
cmpq $0x0, -0x38(%rbp)
je 0x6e0e
cmpq $0x0, 0x10(%rbp)
jne 0x6e17
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6e6a
leaq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2080
movl -0x5c(%rbp), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x60(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x64(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x68(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x6c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x70(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: split
int split(const char* text, char needle, char** dest, int size, int num)
{
    if (!text || text[0] == 0 || !dest || size <= 0 || num <= 0) {
        return -1;
    }
    const char* orig = text;
    const char* tmp = text;

    int cur_num = 0;
    while ((tmp = strchr(tmp, needle)) != NULL) {
        int len = tmp - orig;

        if (len >= size) {
            return -1;
        }
        if (cur_num >= num) {
            return -1;
        }

        memcpy((char*)dest + size*cur_num, orig, len);
        *((char*)dest + size*cur_num + len) = 0;

        cur_num++;
        tmp++;
        orig = tmp;
    }
    if(orig != NULL){
        strcpy((char*)dest + size*cur_num, orig);
        cur_num ++ ;
    }
    if(cur_num == 0){
        strcpy((char*)dest, text);
        cur_num++;
    }
    return cur_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7153
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7153
cmpq $0x0, -0x20(%rbp)
je 0x7153
cmpl $0x0, -0x24(%rbp)
jle 0x7153
cmpl $0x0, -0x28(%rbp)
jg 0x715f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x726a
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x2140
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x721f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x71b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x726a
movl -0x3c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x71c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x726a
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
imull -0x3c(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movslq -0x40(%rbp), %rdx
callq 0x2250
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x3c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movslq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7176
cmpq $0x0, -0x30(%rbp)
je 0x7248
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
imull -0x3c(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x2090
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x7264
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2090
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: trim_left
const char* trim_left(const char* text, const char* needle, char* dest, int size)
{
    if(!text || text[0] == 0 ||
            !needle || needle[0] == 0 ||
            !dest || size <= 0){
        return NULL;
    }

    memset(dest, 0, size);

    int count = 0;
    int match = 0;
    while (*(text + count) != 0) {
        if (NULL != strchr(needle, *(text + count))) {
            ++match;
        } else {
            break;
        }
        ++count;
    }
    count = strlen(text + match);
    if (count >= size) {
        return NULL;
    }
    strncpy(dest, text + match, size);

    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x72ca
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x72ca
cmpq $0x0, -0x18(%rbp)
je 0x72ca
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x72ca
cmpq $0x0, -0x20(%rbp)
je 0x72ca
cmpl $0x0, -0x24(%rbp)
jg 0x72d7
movq $0x0, -0x8(%rbp)
jmp 0x7381
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x733c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x2140
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x732f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7331
jmp 0x733c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x72f4
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
callq 0x2120
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x7361
movq $0x0, -0x8(%rbp)
jmp 0x7381
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movslq -0x24(%rbp), %rdx
callq 0x2070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: trim_right
const char* trim_right(const char* text, const char* needle, char* dest, int size)
{
    if(!text || text[0] == 0 ||
            !needle || needle[0] == 0 ||
            !dest || size <= 0){
        return NULL;
    }

    memset(dest, 0, size);

    int len = strlen(text);

    const char *p = text + len - 1;

    while (p >= text) {
        if (strchr(needle, *p) != NULL) {
            --p;
            --len;
        } else {
            break;
        }

    }
    if(len >= size) {
        return NULL;
    }
    strncpy(dest, text, len);

    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73da
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x73da
cmpq $0x0, -0x18(%rbp)
je 0x73da
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x73da
cmpq $0x0, -0x20(%rbp)
je 0x73da
cmpl $0x0, -0x24(%rbp)
jg 0x73e7
movq $0x0, -0x8(%rbp)
jmp 0x747b
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
movq -0x10(%rbp), %rdi
callq 0x2120
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x7450
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
callq 0x2140
cmpq $0x0, %rax
je 0x744c
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x744e
jmp 0x7450
jmp 0x7415
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x7462
movq $0x0, -0x8(%rbp)
jmp 0x747b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x2070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/util.c
// Function: trim
const char* trim(const char* text, const char* needle, char* dest, int size)
{
    char tmp[size];
    memset(tmp, 0, size);

    if(trim_left(text, needle, tmp, size) == NULL) {
        return NULL;
    }

    if(trim_right(tmp, needle, dest, size) == NULL) {
        return NULL;
    }
    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rsp
movq %rax, -0x38(%rbp)
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
callq 0x7280
cmpq $0x0, %rax
jne 0x7503
movq $0x0, -0x8(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x753d
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x7390
cmpq $0x0, %rax
jne 0x752e
movq $0x0, -0x8(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x753d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: uninit_context
void uninit_context(sch_info_t* info)
{
    if(info->progq) {
        list_iter* it = list_get_iterator(info->progq, AL_START_HEAD);
        list_node* n = NULL;
        while((n = list_next(it)) != NULL) {
            prog_t* p = list_node_value(n);
            if(p->cond) {
                list_release(p->cond, AL_FREE);
            }
        }

        list_release_iterator(it);
        list_release(info->progq, AL_FREE);
    }
    if(info->waitq) {
        dict_release(info->waitq);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
je 0x7944
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rdi
xorl %esi, %esi
callq 0x40f0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7929
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xa58(%rax)
je 0x7927
movq -0x20(%rbp), %rax
movq 0xa58(%rax), %rdi
xorl %esi, %esi
callq 0x3d10
jmp 0x78e8
movq -0x10(%rbp), %rdi
callq 0x4160
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rdi
xorl %esi, %esi
callq 0x3d10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x7962
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rdi
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: usage
void usage()
{
    printf("./myshc [-c config] [-h]\n");
    printf("--simple program scheduler\n\n");
    printf("  -c config    load configuration file.\n");
    printf("  -e           don't run as daemon process.\n");
    printf("  -t           test configuration file.\n");
    printf("  -h           show this help message.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x18da(%rip), %rdi      # 0xa585
movb $0x0, %al
callq 0x2150
leaq 0x18e6(%rip), %rdi      # 0xa59f
movb $0x0, %al
callq 0x2150
leaq 0x18f5(%rip), %rdi      # 0xa5bc
movb $0x0, %al
callq 0x2150
leaq 0x1910(%rip), %rdi      # 0xa5e5
movb $0x0, %al
callq 0x2150
leaq 0x192f(%rip), %rdi      # 0xa612
movb $0x0, %al
callq 0x2150
leaq 0x194a(%rip), %rdi      # 0xa63b
movb $0x0, %al
callq 0x2150
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: judge_condition
int judge_condition(prog_t* prog)
{
    if(prog->flag <= 0 || !prog->cond) {
        return 1;
    }

    struct timeval tv = {0};
    gettimeofday(&tv, NULL);
    struct tm* tm = localtime(&tv.tv_sec);

    int wday = tm->tm_wday;
    if(wday == 0) {
        wday = 7; // 星期天
    }
    int sec = tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;

    list_iter* it = list_get_iterator(prog->cond, AL_START_HEAD);
    list_node* node = NULL;
    while((node = list_next(it)) != NULL) {
        cond_t* c = list_node_value(node);

        if(c->day[wday] == 1) {
        	if(prog->flag == FORK_PERIOD) {
        		int diff = time(NULL) - prog->time;
        		if(diff > c->start) {
        			list_release_iterator(it);
        			return 1;
        		}
        	}
            if(sec >= c->start && sec <= c->end) {
                list_release_iterator(it);
                return 1;
            }
        }
    }

    list_release_iterator(it);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xa50(%rax)
jle 0x8d27
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa58(%rax)
jne 0x8d33
movl $0x1, -0x4(%rbp)
jmp 0x8e6f
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2190
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2180
leaq -0x20(%rbp), %rdi
callq 0x2050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x8d74
movl $0x7, -0x2c(%rbp)
movq -0x28(%rbp), %rax
imull $0xe10, 0x8(%rax), %eax # imm = 0xE10
movq -0x28(%rbp), %rcx
imull $0x3c, 0x4(%rcx), %ecx
addl %ecx, %eax
movq -0x28(%rbp), %rcx
addl (%rcx), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xa58(%rax), %rdi
xorl %esi, %esi
callq 0x40f0
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x41e0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x8e5f
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x8e5a
movq -0x10(%rbp), %rax
cmpl $0x2, 0xa50(%rax)
jne 0x8e2a
xorl %eax, %eax
movl %eax, %edi
callq 0x2270
movq -0x10(%rbp), %rcx
subq 0xa68(%rcx), %rax
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x8e28
movq -0x38(%rbp), %rdi
callq 0x4160
movl $0x1, -0x4(%rbp)
jmp 0x8e6f
jmp 0x8e2a
movslq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x8e58
movslq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jg 0x8e58
movq -0x38(%rbp), %rdi
callq 0x4160
movl $0x1, -0x4(%rbp)
jmp 0x8e6f
jmp 0x8e5a
jmp 0x8db0
movq -0x38(%rbp), %rdi
callq 0x4160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: handle_sigchild
void handle_sigchild()
{
    pid_t pid;
    int status = 0;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        prog_t** pp = (prog_t**)dict_fetch_value(g_info.waitq,
                &pid, sizeof(pid));
        prog_t* p = *pp;

        p->status = status;
        p->time = time(NULL);

        if(dict_delete(g_info.waitq, &pid, sizeof(pid))!= DICT_OK) {
            LOG_ERROR("dict_delete failed. pid = %d\n", pid);
        }
    }
    g_chld = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x22e0
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jle 0x8f26
movq 0x5907(%rip), %rdi      # 0xe7b8
leaq -0x4(%rbp), %rsi
movl $0x4, %edx
callq 0x3230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xa60(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2270
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa68(%rax)
movq 0x58bf(%rip), %rdi      # 0xe7b8
leaq -0x4(%rbp), %rsi
movl $0x4, %edx
callq 0x2ed0
cmpl $0x0, %eax
je 0x8f21
jmp 0x8f0e
movl -0x4(%rbp), %esi
leaq 0x1851(%rip), %rdi      # 0xa769
movb $0x0, %al
callq 0x58a0
jmp 0x8f21
jmp 0x8e8f
movl $0x0, 0x5890(%rip)      # 0xe7c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: handle_sigusr1
void handle_sigusr1()
{
    int ret = 0;

    ret = load_conf(&g_info, LOAD_CONF_RELOAD);
    if(ret != 0) {
        LOG_ERROR("reload config failed. exiting...\n");
    }else{
        LOG_INFO("prepare for restart program. killing...\n");
    }

    clean_proccess(1);

    g_usr1 = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5612(%rip), %rdi      # 0xe568
movl $0x1, %esi
callq 0x7970
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x8f7b
jmp 0x8f6b
leaq 0x1815(%rip), %rdi      # 0xa787
movb $0x0, %al
callq 0x58a0
jmp 0x8f8d
jmp 0x8f7d
leaq 0x1825(%rip), %rdi      # 0xa7a9
movb $0x0, %al
callq 0x5720
jmp 0x8f8d
movl $0x1, %edi
callq 0x8fb0
movl $0x0, 0x5823(%rip)      # 0xe7c4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: clean_proccess
void clean_proccess(int killflag)
{
    dict_iterator* it = dict_get_iterator(g_info.waitq);
    dict_entry* de = NULL;
    while((de = dict_next(it)) != NULL) {
        pid_t* p = (pid_t*) dict_get_entry_key(de);
        if (killflag) {
            LOG_INFO("killing %d\n", *p);
            kill(*p, SIGTERM);
            waitpid(*p, NULL, 0);
            LOG_INFO("%d killed\n", *p);
        }else{
            prog_t* prog = *(prog_t**)dict_get_entry_val(de);
            LOG_INFO("program %s continue running even i die, pid: %d\n",
                    prog->cmd, *p);
        }

        dict_delete(g_info.waitq, p, sizeof(*p));
    }

    dict_release_iterator(it);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x57f6(%rip), %rdi      # 0xe7b8
callq 0x3280
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9093
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x9049
jmp 0x8ffe
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq 0x17c7(%rip), %rdi      # 0xa7d2
movb $0x0, %al
callq 0x5720
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0xf, %esi
callq 0x2260
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22e0
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq 0x179e(%rip), %rdi      # 0xa7de
movb $0x0, %al
callq 0x5720
jmp 0x9079
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq $0x10c, %rsi            # imm = 0x10C
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq 0x1779(%rip), %rdi      # 0xa7e9
movb $0x0, %al
callq 0x5720
jmp 0x9079
movq 0x5738(%rip), %rdi      # 0xe7b8
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x2ed0
jmp 0x8fd3
movq -0x10(%rbp), %rdi
callq 0x3460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buf1024[P]mysch/mysch.c
// Function: update_pid
int update_pid(prog_t* prog)
{
    int ret = 0;
    if(!prog->update_pid && prog->has_pid_file) {
        if (prog->pid_file[0] != 0) {
            pid_t pid;
            if (read_pid_file(&pid, prog->pid_file) == 0) {
                if (kill(pid, 0) == 0) {
                    LOG_INFO("update pid from %d to %d\n", prog->pid, pid);

                    prog->pid = pid;
                    prog->update_pid = 1;

                    // 新进程信息

                    pid_t* dp = (pid_t*)malloc(sizeof(dp));
                    prog_t** dpp = (prog_t**)malloc(sizeof(dpp));

                    *dp = pid;
                    *dpp = prog;

                    dict_add(g_info.waitq, dp, sizeof(*dp), dpp, sizeof(*dpp));
                }
            } else {
                LOG_WARN("read_pid_file failed, pidfile = %s, error  = %s\n",
                        prog->pid_file, strerror(errno));
                ret = -1;
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x94a1
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x94a1
movq -0x8(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x0, %eax
je 0x949f
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
leaq -0x10(%rbp), %rdi
callq 0x6a10
cmpl $0x0, %eax
jne 0x9467
movl -0x10(%rbp), %edi
xorl %esi, %esi
callq 0x2260
cmpl $0x0, %eax
jne 0x9465
jmp 0x93eb
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0x10(%rbp), %edx
leaq 0x148d(%rip), %rdi      # 0xa888
movb $0x0, %al
callq 0x5720
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movl $0x8, %edi
callq 0x22b0
movq %rax, -0x18(%rbp)
movl $0x8, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq 0x536b(%rip), %rdi      # 0xe7b8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x4, %edx
movl $0x8, %r8d
callq 0x2ac0
jmp 0x949d
jmp 0x9469
movq -0x8(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x28(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2370
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x1413(%rip), %rdi      # 0xa8a2
movb $0x0, %al
callq 0x57e0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x949f
jmp 0x94a1
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/common/tree.c
// Function: main
int main(int argc, char **argv)
{
  /* create one tree without intermediate garbage: */
  struct node *init_n = make_tree(10);
  PUSH_STACK_POINTER(init_n);

  /* create a larger tree with lots of intermediate garbage: */
  create_garbage = 1;
  struct node *n = NULL;
  PUSH_STACK_POINTER(n);
  SET_NODE(n, make_tree(16));

  /* check the trees: */
  printf("%d\n", count(n) + count(init_n));
  
  destroy_tree(n);
  destroy_tree(init_n);

  UNSET_NODE(n);
  UNSET_NODE(init_n);

  POP_STACK_POINTER(n);
  POP_STACK_POINTER(init_n);

  printf("Peak memory use: %ld\n", peak_mem_use);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, %edi
callq 0x1200
movq %rax, -0x18(%rbp)
movl $0x1, 0x2eb6(%rip)      # 0x4044
movq $0x0, -0x20(%rbp)
movl $0x10, %edi
callq 0x1200
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12c0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12c0
movl -0x24(%rbp), %esi
addl %eax, %esi
leaq 0xe3f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1310
movq -0x18(%rbp), %rdi
callq 0x1310
leaq 0x2e6b(%rip), %rax      # 0x4050
movq (%rax), %rsi
leaq 0xe19(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/common/tree.c
// Function: make_tree
static struct node *make_tree(int depth)
{
  if (depth == 0)
    return NULL;
  else {
    if (create_garbage) {
      /* create and destroy a junk branch */
      struct node *n = NULL;
      PUSH_STACK_POINTER(n);
      SET_NODE(n, make_tree(depth-1));
      destroy_tree(n);
      UNSET_NODE(n);
      POP_STACK_POINTER(n);
    }
    
    /* Left subtree */
    struct node *l = NULL;
    PUSH_STACK_POINTER(l);
    SET_NODE(l, make_tree(depth-1));
    
    /* Right subtree */
    struct node *r = NULL;
    PUSH_STACK_POINTER(r);
    SET_NODE(r, make_tree(depth-1));
    
    /* New node */
    struct node *t = NULL;
    PUSH_STACK_POINTER(t);
    SET_NODE(t, allocate());
    SET_NODE(t->left, l);
    UNSET_NODE(l);
    SET_NODE(t->right, r);
    UNSET_NODE(r);

    UNSET_RETURN_NODE(t);

    POP_STACK_POINTER(t);
    POP_STACK_POINTER(r);
    POP_STACK_POINTER(l);

    return t;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x121e
movq $0x0, -0x8(%rbp)
jmp 0x12a7
cmpl $0x0, 0x2e1f(%rip)      # 0x4044
je 0x1247
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x1200
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1310
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x1200
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x1200
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, %al
callq 0x13e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/common/tree.c
// Function: destroy_tree
static void destroy_tree(struct node *n)
{
#if MANUAL_DEALLOCATE
  if (n != NULL) {
    destroy_tree(n->left);
    destroy_tree(n->right);
    deallocate(n);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1345
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1310
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1310
movq -0x8(%rbp), %rdi
callq 0x13f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/common/mem.c
// Function: raw_malloc
void *raw_malloc(size_t s)
{
  mem_use += s;
  if (mem_use > peak_mem_use)
    peak_mem_use = mem_use;
  return malloc(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq 0x2ce1(%rip), %rax      # 0x4048
movq %rax, 0x2cda(%rip)      # 0x4048
movq 0x2cd3(%rip), %rax      # 0x4048
cmpq 0x2cd4(%rip), %rax      # 0x4050
jbe 0x138c
movq 0x2cc3(%rip), %rax      # 0x4048
movq %rax, 0x2cc4(%rip)      # 0x4050
movq -0x8(%rbp), %rdi
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: itoa
int itoa (int n, char *buff, int base)
{ int i,l;   // this only works with base <= 10, but who cares...
  l=sizeof(buff);
  for(i=0;i<l;i++)
     { buff[l-1-i]='0'+n%base;
       n/=base;
     }
  return 0;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x8, -0x1c(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x12b5
movl -0x4(%rsp), %eax
cltd
idivl -0x14(%rsp)
addl $0x30, %edx
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
subl -0x18(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %ecx
movl -0x4(%rsp), %eax
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x126d
xorl %eax, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: strupr
char *strupr(char *s)
{ int i,l;
  l=strlen(s);
  for(i=0;i<l;i++) if((s[i]>='a')&&(s[i]<='z')) s[i]-=32;
  return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1080
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x1332
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x1323
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x1323
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %edx
subl $0x20, %edx
movb %dl, (%rax,%rcx)
jmp 0x1325
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12df
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: strlwr
char *strlwr(char *s)
{ int i,l;
  l=strlen(s);
  for(i=0;i<l;i++) if((s[i]>='A')&&(s[i]<='Z')) s[i]+=32;
  return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1080
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x13b2
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x13a3
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x13a3
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %edx
addl $0x20, %edx
movb %dl, (%rax,%rcx)
jmp 0x13a5
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x135f
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: strnset
char *strnset(char *s, int ch, int n)
{ int i;
  if(n>strlen(s)) n=strlen(s);
  for(i=0;i<n;i++) s[i]=ch;
  return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x1400
movq 0x20(%rsp), %rdi
callq 0x1080
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x1432
movl 0x1c(%rsp), %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1408
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: strrev
char *strrev(char *s)
{ int i;
  char c;
  for(i=0;i<(strlen(s)+1)/2;i++)
     { c=s[i];
       s[i]=s[strlen(s)-1-i];
       s[strlen(s)-1-i]=c;
     }
  return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1080
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq $0x1, %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x150d
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x2b(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1080
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movslq 0x2c(%rsp), %rdx
subq %rdx, %rcx
movb (%rax,%rcx), %dl
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movb 0x2b(%rsp), %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1080
movb 0x17(%rsp), %dl
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
movslq 0x2c(%rsp), %rsi
subq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1451
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: eof
int eof(int h)
{ long l,m;
  l=lseek(h,0,SEEK_CUR);
  m=lseek(h,0,SEEK_END);
  lseek(h,l,SEEK_SET);
  return (l==m);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x10b0
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10b0
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10b0
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: CloseFiles
void CloseFiles(void)
{
  close(inpfile.handle);
  if (outfile.bufpoint) Flush(&outfile);
  close(outfile.handle);
  fclose(logfile);
}

// Assembly:
pushq %rax
movzbl 0x11a28(%rip), %edi     # 0x13260
callq 0x10d0
cmpl $0x0, 0x15c34(%rip)     # 0x17478
je 0x1852
leaq 0x15b2b(%rip), %rdi     # 0x17378
callq 0x1870
movzbl 0x15b1f(%rip), %edi     # 0x17378
callq 0x10d0
movq 0x19c2b(%rip), %rdi     # 0x1b490
callq 0x1070
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: PushFilePointers
void PushFilePointers(void)
{
  stackitem *pointer;
  byte item=stack1.busy+stack2.busy+stack3.busy+stack4.busy+stack5.busy+1;
  if (item>5) item=5;
  switch (item)
	 {
	   case 1 : pointer=&stack1; break;
	   case 2 : pointer=&stack2; break;
	   case 3 : pointer=&stack3; break;
	   case 4 : pointer=&stack4; break;
	   case 5 : pointer=&stack5; break;
	 }
  (*pointer).busy=1;
  (*pointer).savedir=direction;
  (*pointer).saverev=revsamples;
  (*pointer).savelast=lastsample;
  (*pointer).savebtype=blocktype;
  (*pointer).savepos=filepos;
  (*pointer).savetotal=totalread;
  (*pointer).saveprocess=processed;
  (*pointer).saveblocklen=blocklength;
}

// Assembly:
movzbl 0x1dcc9(%rip), %eax     # 0x1f5b0
movzbl 0x1dcf2(%rip), %ecx     # 0x1f5e0
addl %ecx, %eax
movzbl 0x1dd19(%rip), %ecx     # 0x1f610
addl %ecx, %eax
movzbl 0x1dd40(%rip), %ecx     # 0x1f640
addl %ecx, %eax
movzbl 0x1dd67(%rip), %ecx     # 0x1f670
addl %ecx, %eax
addl $0x1, %eax
movb %al, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
cmpl $0x5, %eax
jle 0x1921
movb $0x5, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x4, %eax
ja 0x198d
movq -0x18(%rsp), %rax
leaq 0xd708(%rip), %rcx      # 0xf048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1dc60(%rip), %rax     # 0x1f5b0
movq %rax, -0x8(%rsp)
jmp 0x198d
leaq 0x1dc82(%rip), %rax     # 0x1f5e0
movq %rax, -0x8(%rsp)
jmp 0x198d
leaq 0x1dca4(%rip), %rax     # 0x1f610
movq %rax, -0x8(%rsp)
jmp 0x198d
leaq 0x1dcc6(%rip), %rax     # 0x1f640
movq %rax, -0x8(%rsp)
jmp 0x198d
leaq 0x1dce8(%rip), %rax     # 0x1f670
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x1, (%rax)
movb 0x11736(%rip), %cl      # 0x130d1
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x1183e(%rip), %rcx     # 0x131e8
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movb 0x1dce7(%rip), %cl      # 0x1f6a0
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movb 0x1dcda(%rip), %cl      # 0x1f6a1
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x117f2(%rip), %rcx     # 0x131c8
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x117ca(%rip), %rcx     # 0x131b0
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x117b2(%rip), %rcx     # 0x131a8
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x1179a(%rip), %rcx     # 0x131a0
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: PopFilePointers
void PopFilePointers(void)
{
  stackitem *pointer;
  byte item=stack1.busy+stack2.busy+stack3.busy+stack4.busy+stack5.busy;
  switch (item)
	 {
	   case 0 :
	   case 1 : pointer=&stack1; break;
	   case 2 : pointer=&stack2; break;
	   case 3 : pointer=&stack3; break;
	   case 4 : pointer=&stack4; break;
	   case 5 : pointer=&stack5; break;
	 }
  (*pointer).busy=0;
  direction=(*pointer).savedir;
  revsamples=(*pointer).saverev;
  lastsample=(*pointer).savelast;
  blocktype=(*pointer).savebtype;
  filepos=(*pointer).savepos;
  totalread=(*pointer).savetotal;
  processed=(*pointer).saveprocess;
  blocklength=(*pointer).saveblocklen;
}

// Assembly:
movl 0x1db9a(%rip), %eax     # 0x1f5b0
movl 0x1dbc4(%rip), %ecx     # 0x1f5e0
addl %ecx, %eax
movl 0x1dbec(%rip), %ecx     # 0x1f610
addl %ecx, %eax
movl 0x1dc14(%rip), %ecx     # 0x1f640
addl %ecx, %eax
movl 0x1dc3c(%rip), %ecx     # 0x1f670
addl %ecx, %eax
movb %al, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0x1aa3
movq -0x18(%rsp), %rax
leaq 0xd606(%rip), %rcx      # 0xf05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1db4a(%rip), %rax     # 0x1f5b0
movq %rax, -0x8(%rsp)
jmp 0x1aa3
leaq 0x1db6c(%rip), %rax     # 0x1f5e0
movq %rax, -0x8(%rsp)
jmp 0x1aa3
leaq 0x1db8e(%rip), %rax     # 0x1f610
movq %rax, -0x8(%rsp)
jmp 0x1aa3
leaq 0x1dbb0(%rip), %rax     # 0x1f640
movq %rax, -0x8(%rsp)
jmp 0x1aa3
leaq 0x1dbd2(%rip), %rax     # 0x1f670
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x11618(%rip)      # 0x130d1
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x1171f(%rip)     # 0x131e8
movq -0x8(%rsp), %rax
movb 0x3(%rax), %al
movb %al, 0x1dbc9(%rip)      # 0x1f6a0
movq -0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x1dbbc(%rip)      # 0x1f6a1
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x116d3(%rip)     # 0x131c8
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x116ab(%rip)     # 0x131b0
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x11693(%rip)     # 0x131a8
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x1167b(%rip)     # 0x131a0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: RemoveFilePointers
void RemoveFilePointers(void)
{
  stackitem *pointer;
  byte item=stack1.busy+stack2.busy+stack3.busy+stack4.busy+stack5.busy;
  switch (item)
	 {
	   case 1 : pointer=&stack1; break;
	   case 2 : pointer=&stack2; break;
	   case 3 : pointer=&stack3; break;
	   case 4 : pointer=&stack4; break;
	   case 5 : pointer=&stack5; break;
	 }
  (*pointer).busy=0;
}

// Assembly:
movl 0x1da7a(%rip), %eax     # 0x1f5b0
movl 0x1daa4(%rip), %ecx     # 0x1f5e0
addl %ecx, %eax
movl 0x1dacc(%rip), %ecx     # 0x1f610
addl %ecx, %eax
movl 0x1daf4(%rip), %ecx     # 0x1f640
addl %ecx, %eax
movl 0x1db1c(%rip), %ecx     # 0x1f670
addl %ecx, %eax
movb %al, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x4, %eax
ja 0x1bc6
movq -0x18(%rsp), %rax
leaq 0xd4fb(%rip), %rcx      # 0xf074
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1da27(%rip), %rax     # 0x1f5b0
movq %rax, -0x8(%rsp)
jmp 0x1bc6
leaq 0x1da49(%rip), %rax     # 0x1f5e0
movq %rax, -0x8(%rsp)
jmp 0x1bc6
leaq 0x1da6b(%rip), %rax     # 0x1f610
movq %rax, -0x8(%rsp)
jmp 0x1bc6
leaq 0x1da8d(%rip), %rax     # 0x1f640
movq %rax, -0x8(%rsp)
jmp 0x1bc6
leaq 0x1daaf(%rip), %rax     # 0x1f670
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: RecoverFilePointers
void RecoverFilePointers(void)
{
  stackitem *pointer;
  byte item=stack1.busy+stack2.busy+stack3.busy+stack4.busy+stack5.busy;
  switch (item)
	 {
	   case 0 :
	   case 1 : pointer=&stack1; break;
	   case 2 : pointer=&stack2; break;
	   case 3 : pointer=&stack3; break;
	   case 4 : pointer=&stack4; break;
	   case 5 : pointer=&stack5; break;
	 }
  (*pointer).busy=1;
}

// Assembly:
movl 0x1d9da(%rip), %eax     # 0x1f5b0
movl 0x1da04(%rip), %ecx     # 0x1f5e0
addl %ecx, %eax
movl 0x1da2c(%rip), %ecx     # 0x1f610
addl %ecx, %eax
movl 0x1da54(%rip), %ecx     # 0x1f640
addl %ecx, %eax
movl 0x1da7c(%rip), %ecx     # 0x1f670
addl %ecx, %eax
movb %al, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0x1c63
movq -0x18(%rsp), %rax
leaq 0xd472(%rip), %rcx      # 0xf088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1d98a(%rip), %rax     # 0x1f5b0
movq %rax, -0x8(%rsp)
jmp 0x1c63
leaq 0x1d9ac(%rip), %rax     # 0x1f5e0
movq %rax, -0x8(%rsp)
jmp 0x1c63
leaq 0x1d9ce(%rip), %rax     # 0x1f610
movq %rax, -0x8(%rsp)
jmp 0x1c63
leaq 0x1d9f0(%rip), %rax     # 0x1f640
movq %rax, -0x8(%rsp)
jmp 0x1c63
leaq 0x1da12(%rip), %rax     # 0x1f670
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x1, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mincebert[P]maketzx/maketzx.c
// Function: Instructions
void Instructions(void)
{
  printf("Translates VOC files in TZX format for ZX Spectrum emulators\n\n");
  printf("Syntax: MAKETZX <inputfile> [outputfile] [switches]\n\n");
  printf("Switches:\n\n");
  printf("   -n: operate in normal mode         -s n: use Speedlock type n algorithm\n");
  printf("   -a: use Alkatraz algorithm         -k n: skip n blocks before considering\n");
  printf("   -f: use Softlock algorithm               specific loaders\n");
  printf("   -b: use Bleepload algorithm        -x: display file informations in hex\n");
  printf("   -z: use ZetaLoad algorithm         -q: disable hi-fi reproduction tones\n");
  printf("   -l: enable logfile generation      -r: use TZX revision 1.01\n\n");
/*printf("          -digital : use Digital Integrations algorithm and timings\n");*/
  exit(0);
}

// Assembly:
pushq %rax
leaq 0xdbdc(%rip), %rdi      # 0xfe54
movb $0x0, %al
callq 0x1090
leaq 0xdc0d(%rip), %rdi      # 0xfe93
movb $0x0, %al
callq 0x1090
leaq 0xdc35(%rip), %rdi      # 0xfec9
movb $0x0, %al
callq 0x1090
leaq 0xdc33(%rip), %rdi      # 0xfed5
movb $0x0, %al
callq 0x1090
leaq 0xdc71(%rip), %rdi      # 0xff21
movb $0x0, %al
callq 0x1090
leaq 0xdcb1(%rip), %rdi      # 0xff6f
movb $0x0, %al
callq 0x1090
leaq 0xdce1(%rip), %rdi      # 0xffad
movb $0x0, %al
callq 0x1090
leaq 0xdd1f(%rip), %rdi      # 0xfff9
movb $0x0, %al
callq 0x1090
leaq 0xdd5d(%rip), %rdi      # 0x10045
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1140
nopw %cs:(%rax,%rax)