LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: load_players
void load_players(void) {
    FILE *file = fopen("players.bin", "rb");

    if (!file) {
        fprintf(stderr, WARN "Could not load players\n");
        return;
    }

    CALLEXIT(!(fread(dawn, sizeof *dawn, 1, file)))
    fclose(file);
    printf(INFO "Players loaded (%zu bytes)\n", sizeof *dawn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc6c6(%rip), %rdi      # 0x20895
leaq 0x9f71(%rip), %rsi      # 0x1e147
callq 0x2230
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14200
movq 0x11df3(%rip), %rax     # 0x25fe0
movq (%rax), %rdi
leaq 0xc766(%rip), %rsi      # 0x2095d
movb $0x0, %al
callq 0x2310
jmp 0x14255
leaq 0x14869(%rip), %rax     # 0x28a70
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
movl $0xf2eb8, %esi          # imm = 0xF2EB8
movl $0x1, %edx
callq 0x2320
cmpq $0x0, %rax
jne 0x14239
leaq 0xc75e(%rip), %rdi      # 0x20988
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rdi
callq 0x21f0
leaq 0xc78a(%rip), %rdi      # 0x209d3
movl $0xf2eb8, %esi          # imm = 0xF2EB8
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: get_nextlvl_exp
unsigned long long get_nextlvl_exp(char const *username) { //username -> MAX_NICK_LENGTH
    unsigned long long curr_level = (unsigned long long) dawn->players[get_pindex(username)].level;
    if (curr_level > 10) {
        return (500ULL * curr_level * curr_level * curr_level - 500ULL * curr_level);
    } else {
        return (100ULL * curr_level *curr_level * curr_level - 100ULL * curr_level);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x147fd(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13ba0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movslq 0x2668(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0xa, -0x18(%rbp)
jbe 0x142d1
imulq $0x1f4, -0x18(%rbp), %rax # imm = 0x1F4
imulq -0x18(%rbp), %rax
imulq -0x18(%rbp), %rax
imulq $0x1f4, -0x18(%rbp), %rcx # imm = 0x1F4
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x142ec
imulq $0x64, -0x18(%rbp), %rax
imulq -0x18(%rbp), %rax
imulq -0x18(%rbp), %rax
imulq $0x64, -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: progress_bar
static const char *progress_bar(char const *username) { //username -> MAX_NICK_LENGTH
    static char bar[48];
    int i = get_pindex(username);
    unsigned long long nextlvl_exp = get_nextlvl_exp(username);
    nextlvl_exp = nextlvl_exp ? nextlvl_exp : 5;
    long double temp_cyan = ((dawn->players[i].experience / (long double) nextlvl_exp) * 100) / 10;
    int blue_count  = 9  - (int)temp_cyan;
    int cyan_count  = 10 - blue_count;
    snprintf(bar, 47, "%s,10%0*d%s,02%0*d%s", IRC_CYAN, cyan_count, 0, IRC_DBLUE, blue_count, 0, IRC_NORMAL);
    return bar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13ba0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14839
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x14844
movl $0x5, %eax
movq %rax, -0x60(%rbp)
jmp 0x14844
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1421d(%rip), %rax     # 0x28a70
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
movq 0x27f8(%rax,%rcx), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
sets %al
movzbl %al, %eax
movl %eax, %ecx
fildll -0x48(%rbp)
leaq 0xbe16(%rip), %rax      # 0x20698
flds (%rax,%rcx,4)
faddp %st, %st(1)
movq -0x18(%rbp), %rcx
movq %rcx, -0x50(%rbp)
testq %rcx, %rcx
sets %cl
movzbl %cl, %ecx
fildll -0x50(%rbp)
flds (%rax,%rcx,4)
faddp %st, %st(1)
fdivrp %st, %st(1)
flds 0xbe00(%rip)            # 0x206a8
fmulp %st, %st(1)
flds 0xbdfc(%rip)            # 0x206ac
fdivrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
fnstcw -0x52(%rbp)
movzwl -0x52(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x54(%rbp)
fldcw -0x54(%rbp)
fistpl -0x3c(%rbp)
fldcw -0x52(%rbp)
movl -0x3c(%rbp), %ecx
movl $0x9, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl $0xa, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %r8d
movl -0x34(%rbp), %r10d
leaq 0x14148(%rip), %rdi     # 0x28a40
movl $0x2f, %esi
leaq 0xc409(%rip), %rdx      # 0x20d0d
leaq 0x8b8c(%rip), %rcx      # 0x1d497
xorl %r9d, %r9d
leaq 0x8b8e(%rip), %r11      # 0x1d4a3
leaq 0x88c9(%rip), %rax      # 0x1d1e5
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x2390
leaq 0x14100(%rip), %rax     # 0x28a40
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: auth_level_to_str
char * auth_level_to_str(int al) { //enum auth_level
    switch(al) {
        case AL_NOAUTH:
            return "NO AUTH";
        case AL_USER:
            return "USER";
        case AL_REG:
            return "REG";
        case AL_ADMIN:
            return "ADMIN";
        case AL_ROOT:
            return "ROOT";
        default:
            PRINTERR("INVALID AUTH")
    }
    return "INVALID AUTH";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x1517d
movq -0x18(%rbp), %rax
leaq 0xb57d(%rip), %rcx      # 0x206b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xbb7c(%rip), %rax      # 0x20cbf
movq %rax, -0x8(%rbp)
jmp 0x15194
leaq 0xbb77(%rip), %rax      # 0x20cc7
movq %rax, -0x8(%rbp)
jmp 0x15194
leaq 0xbb6f(%rip), %rax      # 0x20ccc
movq %rax, -0x8(%rbp)
jmp 0x15194
leaq 0xbb66(%rip), %rax      # 0x20cd0
movq %rax, -0x8(%rbp)
jmp 0x15194
leaq 0xbb5f(%rip), %rax      # 0x20cd6
movq %rax, -0x8(%rbp)
jmp 0x15194
leaq 0xbb57(%rip), %rdi      # 0x20cdb
callq 0x2190
leaq 0xbb70(%rip), %rax      # 0x20d00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: str_to_auth_level
enum auth_level str_to_auth_level(char * al) {
    if(strcasecmp(al, "USER") == 0) {
        return AL_USER;
    } else if(strcasecmp(al, "REG") == 0) {
        return AL_REG;
    } else if(strcasecmp(al, "ADMIN") == 0) {
        return AL_ADMIN;
    } else if(strcasecmp(al, "ROOT") == 0) {
        return AL_ROOT;
    }
    return AL_NOAUTH;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbb10(%rip), %rsi      # 0x20cc7
callq 0x2200
cmpl $0x0, %eax
jne 0x151ca
movl $0x1, -0x4(%rbp)
jmp 0x15231
movq -0x10(%rbp), %rdi
leaq 0xbaf7(%rip), %rsi      # 0x20ccc
callq 0x2200
cmpl $0x0, %eax
jne 0x151e8
movl $0x2, -0x4(%rbp)
jmp 0x15231
movq -0x10(%rbp), %rdi
leaq 0xbadd(%rip), %rsi      # 0x20cd0
callq 0x2200
cmpl $0x0, %eax
jne 0x15206
movl $0x3, -0x4(%rbp)
jmp 0x15231
movq -0x10(%rbp), %rdi
leaq 0xbac5(%rip), %rsi      # 0x20cd6
callq 0x2200
cmpl $0x0, %eax
jne 0x15224
movl $0x4, -0x4(%rbp)
jmp 0x15231
jmp 0x15226
jmp 0x15228
jmp 0x1522a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/spells.c
// Function: cast_teleport
void cast_teleport(const char *username, int x, int y) {
    struct Message temp;
    strcpy(temp.sender_nick, username);
    strcpy(temp.receiver, dawn->active_room);
    move_player(&temp, x, y, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x910, %rsp            # imm = 0x910
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x910(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x21c0
leaq -0x910(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x129e6(%rip), %rax     # 0x28a70
movq (%rax), %rsi
addq $0x100, %rsi            # imm = 0x100
callq 0x21c0
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x910(%rbp), %rdi
movl $0x1, %ecx
callq 0xeca0
addq $0x910, %rsp            # imm = 0x910
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: init_timers
void init_timers (struct Bot *b, char const * fn) {
    //Times are defined in limits.h and are in seconds
    struct sigaction act;
    memset(&act, '\0', sizeof act);

    act.sa_handler = event_handler; //use simple signal handler
    act.sa_flags = SA_RESTART; //use SA_SIGINFO for more advanced handler

    CALLEXIT(sigaction(SIGALRM, &act, NULL) < 0) //hook SIGALRM to call our message_handler function

    load_events(fn);
    dawn = b;
    add_event(HEALING,         0, HEALING_INTERVAL,         UNIQUE | KEEP);
    add_event(SAVING,          0, SAVING_INTERVAL,          UNIQUE | KEEP);
    add_event(HOURLY,          0, 3600,                     UNIQUE | KEEP);
    add_event(LOTTERY_COLLECT, 0, LOTTERY_COLLECT_INTERVAL, UNIQUE | KEEP);
    add_event(LOTTERY_REWARD,  0, LOTTERY_REWARD_INTERVAL,  UNIQUE | KEEP);
    add_event(BOUNTY_RESET,    0, BOUNTY_RESET_INTERVAL,    UNIQUE | KEEP);
    add_event(BOUNTY_INIT,     0, 15,                       UNIQUE | KEEP);
    printf(INFO "Timers started\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x20f0
leaq 0x103(%rip), %rax       # 0x16a70
movq %rax, -0xa8(%rbp)
movl $0x10000000, -0x20(%rbp) # imm = 0x10000000
movl $0xe, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2270
cmpl $0x0, %eax
jge 0x169ab
leaq 0xa8c8(%rip), %rdi      # 0x21264
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x10(%rbp), %rdi
callq 0x16e70
movq -0x8(%rbp), %rax
movq %rax, 0x120b1(%rip)     # 0x28a70
xorl %esi, %esi
movl $0x708, %edx            # imm = 0x708
movl $0x3, %ecx
movl %esi, %edi
callq 0x17280
movl $0x1, %edi
xorl %esi, %esi
movl $0x384, %edx            # imm = 0x384
movl $0x3, %ecx
callq 0x17280
movl $0x2, %edi
xorl %esi, %esi
movl $0xe10, %edx            # imm = 0xE10
movl $0x3, %ecx
callq 0x17280
movl $0x5, %edi
xorl %esi, %esi
movl $0x708, %edx            # imm = 0x708
movl $0x3, %ecx
callq 0x17280
movl $0x6, %edi
xorl %esi, %esi
movl $0xa8c0, %edx           # imm = 0xA8C0
movl $0x3, %ecx
callq 0x17280
movl $0x7, %edi
xorl %esi, %esi
movl $0x15180, %edx          # imm = 0x15180
movl $0x3, %ecx
callq 0x17280
movl $0x8, %edi
xorl %esi, %esi
movl $0xf, %edx
movl $0x3, %ecx
callq 0x17280
leaq 0xa84e(%rip), %rdi      # 0x212ab
movb $0x0, %al
callq 0x2040
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: init_event_list
EventList init_event_list() {
    if(eventQ_singleton) //if an instance already exists do not create a new one
        return 0;
    eventQ_singleton++;
    struct event_list * newlist;
    CALLEXIT(!(newlist = calloc(1, sizeof *newlist)))
    return newlist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x11519(%rip)     # 0x28a78
je 0x1756b
movq $0x0, -0x8(%rbp)
jmp 0x175b1
movl 0x11507(%rip), %eax     # 0x28a78
addl $0x1, %eax
movl %eax, 0x114fe(%rip)     # 0x28a78
movl $0x1, %edi
movl $0x10, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x175a9
leaq 0x9d34(%rip), %rdi      # 0x212ce
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: free_event_list
void free_event_list() {
    if(elist == 0)
        return;
    struct event_list * celist = (struct event_list *)elist;

    struct event_node * tmp = celist->head;
    while(tmp != 0) {
        struct event_node * next = tmp->next;
        free(tmp->elem);
        free(tmp);
        tmp = next;
    }
    free(elist);
    eventQ_singleton--;
    elist = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x114b0(%rip)     # 0x28a80
jne 0x175d4
jmp 0x17642
movq 0x114a5(%rip), %rax     # 0x28a80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1761c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x175ea
movq 0x1145d(%rip), %rdi     # 0x28a80
callq 0x2240
movl 0x1144a(%rip), %eax     # 0x28a78
addl $-0x1, %eax
movl %eax, 0x11441(%rip)     # 0x28a78
movq $0x0, 0x1143e(%rip) # 0x28a80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: update_alarm
void update_alarm() {
    if(elist == 0)
        return;
    struct event_list* celist = (struct event_list *)elist;
    if(celist->head == 0)
        return;

    time_t curtime = time(0);
    time_t event = celist->head->event_time;
    if(event < curtime)
        event_handler(SIGALRM);
    else
        alarm((unsigned int)(event - curtime));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x11420(%rip)     # 0x28a80
jne 0x17664
jmp 0x176bc
movq 0x11415(%rip), %rax     # 0x28a80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1767b
jmp 0x176bc
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x176ad
movl $0xe, %edi
callq 0x16a70
jmp 0x176bc
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x2430
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: remove_event
void remove_event(struct event_node * prev) { //requires the /PREVIOUS/ node or 0 for head
    struct event_list * celist = (struct event_list *)elist;
    if(elist == 0)
        return;
    if(prev == 0) {
        struct event_node * next = celist->head->next;
        free(celist->head->elem);
        free(celist->head);
        celist->head = next;
    } else {
        struct event_node * to_free = prev->next;
        prev->next = prev->next->next;
        free(to_free->elem);
        free(to_free);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1137d(%rip), %rax     # 0x28a80
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x11371(%rip)     # 0x28a80
jne 0x17713
jmp 0x17783
cmpq $0x0, -0x8(%rbp)
jne 0x17751
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x17783
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x20(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: retr_event
struct event * retr_event() { //callee must free the data himself
    if(elist == 0)
        return 0;
    struct event_list * celist = (struct event_list *)elist;
    if(celist->head == 0)
        return 0;

    struct event * ret = celist->head->elem;
    struct event_node * to_free = celist->head;
    celist->head = celist->head->next;
    free(to_free);
    celist->len--;
    update_alarm();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x112e0(%rip)     # 0x28a80
jne 0x177ac
movq $0x0, -0x8(%rbp)
jmp 0x1781c
movq 0x112cd(%rip), %rax     # 0x28a80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x177cb
movq $0x0, -0x8(%rbp)
jmp 0x1781c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
callq 0x17650
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: is_next_due
int is_next_due() {
    if(elist == 0)
        return 0;
    struct event_list * celist = (struct event_list *)elist;
    if(celist->head == 0)
        return 0;
    return celist->head->event_time <= time(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x11240(%rip)     # 0x28a80
jne 0x1784b
movl $0x0, -0x4(%rbp)
jmp 0x17896
movq 0x1122e(%rip), %rax     # 0x28a80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17869
movl $0x0, -0x4(%rbp)
jmp 0x17896
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/status.c
// Function: event_to_str
char * event_to_str(enum Events x) {
    switch(x) {
        case HEALING:
            return "HEALING";
        case SAVING:
            return "SAVING";
        case HOURLY:
            return "HOURLY";
        case TRAVEL:
            return "TRAVEL";
        case MSGSEND:
            return "MSGSEND";
        case LOTTERY_COLLECT:
            return "LOTTERYCOLLECT";
        case LOTTERY_REWARD:
            return "LOTTERYREWARD";
        case BOUNTY_RESET:
            return "BOUNTYRESET";
        case BOUNTY_INIT:
            return "BOUNTYINIT";
    }
    return "NONE";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x8, %rax
ja 0x17941
movq -0x18(%rbp), %rax
leaq 0x997d(%rip), %rcx      # 0x21240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9b93(%rip), %rax      # 0x21466
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b8e(%rip), %rax      # 0x2146e
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b88(%rip), %rax      # 0x21475
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b82(%rip), %rax      # 0x2147c
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b7c(%rip), %rax      # 0x21483
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b77(%rip), %rax      # 0x2148b
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b79(%rip), %rax      # 0x2149a
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b7a(%rip), %rax      # 0x214a8
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b79(%rip), %rax      # 0x214b4
movq %rax, -0x8(%rbp)
jmp 0x1794c
leaq 0x9b77(%rip), %rax      # 0x214bf
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: init_token_list
TokenList init_token_list() {
    struct token_list * new_list;
    CALLEXIT(!(new_list = malloc(sizeof *new_list)))
    new_list->head = 0;
    new_list->len = 0;
    new_list->num_total = 0;
    return new_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x22b0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x17b62
leaq 0x9db9(%rip), %rdi      # 0x2190c
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: free_token_list
void free_token_list(TokenList l) {
    if(!l) {
        return;
    }
    struct token_list * cl = l;
    struct token_node * tmp = cl->head;

    while(tmp) {
        struct token_node * next = tmp->next;
        free(tmp->elem);
        free(tmp);
        tmp = next;
    }
    free(cl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17ba5
jmp 0x17bf3
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17bea
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rdi
callq 0x2240
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x17bb8
movq -0x10(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: swap
void swap(struct token_node * a, struct token_node * b) {
    assert(a && b);

    char * elemA = a->elem;
    unsigned int numA = a->num;
    int endA = a->end;

    a->elem = b->elem;
    a->num = b->num;
    a->end = b->end;

    b->elem = elemA;
    b->num = numA;
    b->end = endA;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x17ec0
cmpq $0x0, -0x10(%rbp)
je 0x17ec0
jmp 0x17edf
leaq 0x9c0f(%rip), %rdi      # 0x21ad6
leaq 0x9c0f(%rip), %rsi      # 0x21add
movl $0x8d, %edx
leaq 0x9c13(%rip), %rcx      # 0x21aed
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: get_len
size_t get_len(TokenList l) {
    if(!l)
        return 0;
    struct token_list * cl = l;
    return cl->len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17f79
movq $0x0, -0x8(%rbp)
jmp 0x17f8d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: get_num_total
size_t get_num_total(TokenList l) {
    if(!l)
        return 0;
    struct token_list * cl = l;
    return cl->num_total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17fb9
movq $0x0, -0x8(%rbp)
jmp 0x17fcd
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: get_iterator
TokenIterator get_iterator(TokenList l) {
    if(!l)
        return 0;
    struct token_list * cl = l;
    struct token_iterator * it;
    CALLEXIT(!(it = malloc(sizeof *it)))
    it->cur_node = cl->head;
    it->consumed = cl->head ? cl->head->num : 0;
    return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17ffd
movq $0x0, -0x8(%rbp)
jmp 0x18074
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x10, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1802f
leaq 0x9a73(%rip), %rdi      # 0x21a93
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x18056
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x1805d
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x1805d
movl -0x24(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/tokenlist.c
// Function: has_elem
int has_elem(TokenIterator it) {
    if(!it)
        return 0;
    struct token_iterator * cit = it;
    return cit->cur_node ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x180b8
movl $0x0, -0x4(%rbp)
jmp 0x180d8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: gaussrand
double gaussrand() {
    static double V1, V2, S;
    static int phase = 0;
    double X;

    if(phase == 0) {
        do {
            V1 = 2 * randd() - 1;
            V2 = 2 * randd() - 1;
            S = V1 * V1 + V2 * V2;
        } while(S >= 1 || !(S < 0 || S > 0)); //S must be != 0
        X = V1 * sqrt(-2 * log(S) / S);
    } else {
        X = V2 * sqrt(-2 * log(S) / S);
    }
    phase = !phase;

    return X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x108b1(%rip)     # 0x28aa0
jne 0x182ff
jmp 0x181f7
callq 0x181c0
addsd %xmm0, %xmm0
movsd 0x7ac8(%rip), %xmm1     # 0x1fcd0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10874(%rip)    # 0x28a88
callq 0x181c0
addsd %xmm0, %xmm0
movsd 0x7aab(%rip), %xmm1     # 0x1fcd0
addsd %xmm1, %xmm0
movsd %xmm0, 0x1085f(%rip)    # 0x28a90
movsd 0x1084f(%rip), %xmm0    # 0x28a88
movsd 0x10847(%rip), %xmm2    # 0x28a88
movsd 0x10847(%rip), %xmm1    # 0x28a90
mulsd 0x1083f(%rip), %xmm1    # 0x28a90
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10837(%rip)    # 0x28a98
movsd 0x1082f(%rip), %xmm0    # 0x28a98
movb $0x1, %al
movsd 0x7a55(%rip), %xmm1     # 0x1fcc8
ucomisd %xmm1, %xmm0
movb %al, -0x9(%rbp)
jae 0x182ab
movb $0x1, %al
xorps %xmm0, %xmm0
ucomisd 0x1080f(%rip), %xmm0    # 0x28a98
movb %al, -0xa(%rbp)
ja 0x182a3
movsd 0x10802(%rip), %xmm0    # 0x28a98
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x181f7
movsd 0x107ca(%rip), %xmm0    # 0x28a88
movsd %xmm0, -0x18(%rbp)
movsd 0x107cd(%rip), %xmm0    # 0x28a98
callq 0x2160
movaps %xmm0, %xmm1
movsd 0x9855(%rip), %xmm0     # 0x21b30
mulsd %xmm1, %xmm0
divsd 0x107b1(%rip), %xmm0    # 0x28a98
callq 0x2150
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x18346
movsd 0x10789(%rip), %xmm0    # 0x28a90
movsd %xmm0, -0x20(%rbp)
movsd 0x10784(%rip), %xmm0    # 0x28a98
callq 0x2160
movaps %xmm0, %xmm1
movsd 0x980c(%rip), %xmm0     # 0x21b30
mulsd %xmm1, %xmm0
divsd 0x10768(%rip), %xmm0    # 0x28a98
callq 0x2150
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
cmpl $0x0, 0x10753(%rip)     # 0x28aa0
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x10743(%rip)     # 0x28aa0
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: perlin_init
void perlin_init() { //this is a very wrong way to do this but it works for our purposes
    int permutation[256];
    for(int i = 0; i < 256; i++) {
        permutation[i] = i;
    }
    for(int i = 0; i < 256; i++) {
        unsigned pos = (unsigned)(i + randd()*(256-i));
        int tmp = permutation[i];
        permutation[i] = permutation[pos];
        permutation[pos] = tmp;
    }
    if(p_noise_arr) {
        free(p_noise_arr);
    }
    CALLEXIT(!(p_noise_arr = malloc(512 * sizeof *p_noise_arr)))
    for (int i=0; i < 256 ; i++) {
        p_noise_arr[256+i] = p_noise_arr[i] = permutation[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl $0x0, -0x404(%rbp)
cmpl $0x100, -0x404(%rbp)    # imm = 0x100
jge 0x18566
movl -0x404(%rbp), %ecx
movslq -0x404(%rbp), %rax
movl %ecx, -0x400(%rbp,%rax,4)
movl -0x404(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x404(%rbp)
jmp 0x18535
movl $0x0, -0x408(%rbp)
cmpl $0x100, -0x408(%rbp)    # imm = 0x100
jge 0x18617
cvtsi2sdl -0x408(%rbp), %xmm0
movsd %xmm0, -0x420(%rbp)
callq 0x181c0
movsd -0x420(%rbp), %xmm1
movl -0x408(%rbp), %ecx
movl $0x100, %eax            # imm = 0x100
subl %ecx, %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x40c(%rbp)
movslq -0x408(%rbp), %rax
movl -0x400(%rbp,%rax,4), %eax
movl %eax, -0x410(%rbp)
movl -0x40c(%rbp), %eax
movl -0x400(%rbp,%rax,4), %ecx
movslq -0x408(%rbp), %rax
movl %ecx, -0x400(%rbp,%rax,4)
movl -0x410(%rbp), %ecx
movl -0x40c(%rbp), %eax
movl %ecx, -0x400(%rbp,%rax,4)
movl -0x408(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x408(%rbp)
jmp 0x18570
cmpq $0x0, 0x10489(%rip)     # 0x28aa8
je 0x1862d
movq 0x10480(%rip), %rdi     # 0x28aa8
callq 0x2240
movl $0x800, %edi            # imm = 0x800
callq 0x22b0
movq %rax, 0x1046a(%rip)     # 0x28aa8
cmpq $0x0, %rax
jne 0x1865a
leaq 0x94f5(%rip), %rdi      # 0x21b40
callq 0x2190
movl $0x1, %edi
callq 0x2260
movl $0x0, -0x414(%rbp)
cmpl $0x100, -0x414(%rbp)    # imm = 0x100
jge 0x186b9
movslq -0x414(%rbp), %rax
movl -0x400(%rbp,%rax,4), %edx
movq 0x10423(%rip), %rax     # 0x28aa8
movslq -0x414(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10412(%rip), %rax     # 0x28aa8
movl -0x414(%rbp), %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x18664
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: grad
static inline float grad(int hash, float x, float y, float z) {
    int h = hash & 15;                      // CONVERT LO 4 BITS OF HASH CODE
    float u = h<8 ? x : y,                 // INTO 12 GRADIENT DIRECTIONS.
            v = h<4 ? y : h==12||h==14 ? x : z;
    return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x18c01
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x18c0b
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x18c27
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0x18c53
cmpl $0xc, -0x14(%rbp)
je 0x18c33
cmpl $0xe, -0x14(%rbp)
jne 0x18c3f
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x18c49
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x18c74
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x18c8b
movss -0x18(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x18cac
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x18cc3
movss -0x1c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: init_priority_queue
PriorityQueue init_priority_queue(void) {
    struct priority_queue * rop;
    CALLEXIT(!(rop = malloc(sizeof *rop)))
    rop->head = NULL;
    rop->min = NULL;
    rop->min_prev = NULL;
    rop->size = 0;
    return rop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x22b0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x18d12
leaq 0x8e92(%rip), %rdi      # 0x21b95
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: free_priority_queue
void free_priority_queue(PriorityQueue pq, int free_elem) {
    while(pq->head) {
        struct priority_node * next = pq->head->next;
        free_tree(pq->head->tree, free_elem);
        free(pq->head);
        pq->head = next;
    }
    free(pq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x18da3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x18dc0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x18d5f
movq -0x8(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: free_tree
static void free_tree(struct priority_tree * pt, int free_elem) {
    while(pt->children) {
        struct priority_node * next = pt->children->next;
        free_tree(pt->children->tree, free_elem);
        free(pt->children);
        pt->children = next;
    }
    if(free_elem) {
        free(pt->elem);
    }
    free(pt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18e18
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x18dc0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x18dcf
cmpl $0x0, -0xc(%rbp)
je 0x18e2a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x8(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: priority_insert
void priority_insert(PriorityQueue pq, float priority, void * elem) {
    struct priority_tree * new_tree;
    CALLEXIT(!(new_tree = malloc(sizeof *new_tree)))
    new_tree->children = NULL;
    new_tree->last_child = NULL;
    new_tree->degree = 0;
    new_tree->elem = elem;
    new_tree->priority = priority;

    priority_insert_tree(pq, new_tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x18e7f
leaq 0x8d65(%rip), %rdi      # 0x21bd5
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movss -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x18ed0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: priority_insert_tree
static void priority_insert_tree(PriorityQueue pq, struct priority_tree * pn) {
    struct priority_node * new_node;
    CALLEXIT(!(new_node = malloc(sizeof *new_node)))
    new_node->next = pq->head;
    new_node->tree = pn;
    pq->head = new_node;
    priority_update_min(pq);
    pq->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x18f0a
leaq 0x8d6c(%rip), %rdi      # 0x21c67
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x192c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: priority_add_child
static void priority_add_child(struct priority_tree * parent, struct priority_node * new_child) {
    new_child->next = parent->children;
    parent->children = new_child;
    parent->degree++;
    if(!parent->last_child) {
        parent->last_child = parent->children;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x192b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/util.c
// Function: priority_update_min
static inline void priority_update_min(PriorityQueue pq) {
    if(!pq->min || pq->min->tree->priority > pq->head->tree->priority) {
        pq->min_prev = NULL;
        pq->min = pq->head;
    } else if(!pq->min_prev && pq->min) {
        pq->min_prev = pq->head;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x192f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movss 0x1c(%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
ucomiss 0x1c(%rax), %xmm0
jbe 0x19310
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x19337
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x19335
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x19335
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x19337
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src/main.c
// Function: main
int	main(int ac, char **av)
{
	t_ls	ls;

	init_lsdir(&ls, 0);
	ls.size_d = 0;
	ls.size_f = 0;
	ls.filerr = 0;
	ft_bzero(ls.flags, sizeof(ls.flags));
	ls.dirs = ft_calloc(ac, sizeof(char *));
	ls.files = ft_calloc(ac, sizeof(char *));
	if (!ls.dirs || !ls.files || !input_handler(ac - 1, &av[1], &ls))
		exit_ls(&ls, EXIT_FAILURE);
	if (!ls.dirs[0] && !ls.files[0] && !ls.filerr)
		ls.dirs[0] = ".";
	ft_ls(&ls);
	exit_ls(&ls, EXIT_SUCCESS);
	return (EXIT_SUCCESS);
}

// Assembly:
subq $0xc8, %rsp
movl $0x0, 0xc4(%rsp)
movl %edi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2410
movq $0x0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0xa0(%rsp)
leaq 0x8(%rsp), %rdi
addq $0x20, %rdi
movl $0x78, %esi
callq 0x7650
movslq 0xc0(%rsp), %rdi
movl $0x8, %esi
callq 0x34b0
movq %rax, 0x8(%rsp)
movslq 0xc0(%rsp), %rdi
movl $0x8, %esi
callq 0x34b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x131d
cmpq $0x0, 0x18(%rsp)
je 0x131d
movl 0xc0(%rsp), %edi
subl $0x1, %edi
movq 0xb8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdx
callq 0x1380
cmpl $0x0, %eax
jne 0x132c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x15a0
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x135b
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x135b
cmpb $0x0, 0xa0(%rsp)
jne 0x135b
movq 0x8(%rsp), %rax
leaq 0x6d8e(%rip), %rcx      # 0x80e6
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x2460
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x15a0
xorl %eax, %eax
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src/main.c
// Function: input_handler
static int	input_handler(int ac, char **av, t_ls *ls)
{
	int	i;

	i = 0;
	while (i < ac)
	{
		if (!ft_strcmp(av[i], "--help"))
			exit_ls(ls, ft_usage());
		if (!(av[i][0] == '-' && av[i][1]) || !ft_strcmp(av[i], "--"))
		{
			if (is_dir(av[i]))
				ls->dirs[ls->size_d++] = av[i];
			else if (is_file(av[i]) > 0)
				ls->files[ls->size_f++] = av[i];
			else
				ls->filerr += ft_printf_fd(2, WACCESS, av[i], strerror(errno));
		}
		else if (av[i][0] == '-' && av[i][1] && !extract_flags(&av[i][1], ls))
			return (0);
		i++;
	}
	return (1);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x1584
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6c47(%rip), %rsi      # 0x8004
callq 0x6fb0
cmpl $0x0, %eax
jne 0x13e2
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x15e0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x15a0
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1432
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x1432
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6e5f(%rip), %rsi      # 0x8283
callq 0x6fb0
cmpl $0x0, %eax
jne 0x151a
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x17c0
cmpl $0x0, %eax
je 0x147d
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x1518
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1810
cmpl $0x0, %eax
jle 0x14c6
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x18(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x18(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x1516
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x6b12(%rip), %rsi      # 0x800b
movb $0x0, %al
callq 0x3570
movl %eax, %edx
movq 0x20(%rsp), %rax
movzbl 0x98(%rax), %ecx
addl %edx, %ecx
movb %cl, 0x98(%rax)
jmp 0x1518
jmp 0x1574
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1572
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x1572
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
movq 0x20(%rsp), %rsi
callq 0x1690
cmpl $0x0, %eax
jne 0x1572
movl $0x0, 0x34(%rsp)
jmp 0x158c
jmp 0x1574
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x139a
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src/main.c
// Function: ft_usage
static int	ft_usage(void)
{
	ft_printf_fd(2, BOLD"USAGE:\n\t\t"E0M"ls [OPTION]... [FILE]...\n");
	ft_printf_fd(2, BOLD"DESCRIPTION:\n\t\t"E0M"List information about the\
 FILEs (the current directory by default).\n");
	ft_printf_fd(2, "\t\tSort entries alphabetically if -t is not specified.");
	ft_printf_fd(2, BOLD"\nOPTIONS:\n"E0M);
	ft_printf_fd(2, BOLD"-l:\t\t"E0M"Use a long listing format\n");
	ft_printf_fd(2, BOLD"-a:\t\t"E0M"Do not ignore entries starting with .\n");
	ft_printf_fd(2, BOLD"-r:\t\t"E0M"Reverse order while sorting\n");
	ft_printf_fd(2, BOLD"-R:\t\t"E0M"List subdirectories recursively\n");
	ft_printf_fd(2, BOLD"-t:\t\t"E0M"Sort by modification time, newest\
 first\n");
	return (EXIT_SUCCESS);
}

// Assembly:
pushq %rax
movl $0x2, %edi
leaq 0x6a3d(%rip), %rsi      # 0x802a
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6a55(%rip), %rsi      # 0x8055
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6a9f(%rip), %rsi      # 0x80b2
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6ac2(%rip), %rsi      # 0x80e8
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6ac2(%rip), %rsi      # 0x80fb
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6ad7(%rip), %rsi      # 0x8123
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6af8(%rip), %rsi      # 0x8157
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6b0f(%rip), %rsi      # 0x8181
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6b2a(%rip), %rsi      # 0x81af
movb $0x0, %al
callq 0x3570
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src/main.c
// Function: extract_flags
static int	extract_flags(char *str, t_ls *ls)
{
	while (*str)
	{
		if (*str == 'l')
			ls->flags['l'] = 1;
		else if (*str == 'R')
			ls->flags['R'] = 1;
		else if (*str == 'a')
			ls->flags['a'] = 1;
		else if (*str == 'r')
			ls->flags['r'] = 1;
		else if (*str == 't')
			ls->flags['t'] = 1;
		else
		{
			if (*str != '-')
				ft_printf_fd(2, "ft_ls: invalid option -- '%c'\n", *str);
			else
				ft_printf_fd(2, "ft_ls: unrecognized option '-%s'\n", str);
			ft_printf_fd(2, "Try 'ft_ls --help' for more information.\n");
			return (0);
		}
		str++;
	}
	return (1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x17ad
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x16c8
movq (%rsp), %rax
movb $0x1, 0x8c(%rax)
jmp 0x179a
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
jne 0x16e2
movq (%rsp), %rax
movb $0x1, 0x72(%rax)
jmp 0x1798
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x16ff
movq (%rsp), %rax
movb $0x1, 0x81(%rax)
jmp 0x1796
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x1719
movq (%rsp), %rax
movb $0x1, 0x92(%rax)
jmp 0x1794
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x1733
movq (%rsp), %rax
movb $0x1, 0x94(%rax)
jmp 0x1792
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x175d
movq 0x8(%rsp), %rax
movsbl (%rax), %edx
movl $0x2, %edi
leaq 0x6a91(%rip), %rsi      # 0x81e5
movb $0x0, %al
callq 0x3570
jmp 0x1775
movq 0x8(%rsp), %rdx
movl $0x2, %edi
leaq 0x6a96(%rip), %rsi      # 0x8204
movb $0x0, %al
callq 0x3570
movl $0x2, %edi
leaq 0x6aa5(%rip), %rsi      # 0x8226
movb $0x0, %al
callq 0x3570
movl $0x0, 0x14(%rsp)
jmp 0x17b5
jmp 0x1794
jmp 0x1796
jmp 0x1798
jmp 0x179a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x169d
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/types.c
// Function: is_dir
int	is_dir(char *filename)
{
	DIR	*dir;

	dir = opendir(filename);
	if (dir)
	{
		closedir(dir);
		return (1);
	}
	return (0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1070
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x17f1
movq (%rsp), %rdi
callq 0x10c0
movl $0x1, 0x14(%rsp)
jmp 0x17f9
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)