LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/market.c
// Function: fluctuate_market
void fluctuate_market() {
    char out[MAX_MESSAGE_BUFFER];
    memcpy(dawn->market.prevprice, dawn->market.materials, sizeof(dawn->market.materials));
    dawn->market.materials[WOOD] = rrange(100, 500);
    dawn->market.materials[LEATHER] = rrange(250, 800);
    dawn->market.materials[ORE] = rrange(400, 1200);
    dawn->market.materials[STONE] = rrange(500, 1400);
    dawn->market.materials[BRONZE] = rrange(700, 2000);
    dawn->market.materials[MAIL] = rrange(1000, 3000);
    dawn->market.materials[STEEL] = rrange(4000, 12000);
    dawn->market.materials[DIAMOND] = rrange(25000, 100000);
    sprintf(out, "PRIVMSG %s :Market prices have been updated\r\n", dawn->active_room);
    add_msg(out, strlen(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
leaq 0x18e8e(%rip), %rax     # 0x28a70
movq (%rax), %rax
leaq 0x18e84(%rip), %rcx     # 0x28a70
movq (%rcx), %rcx
movq 0xf2e78(%rcx), %rdx
movq %rdx, 0xf2e98(%rax)
movq 0xf2e80(%rcx), %rdx
movq %rdx, 0xf2ea0(%rax)
movq 0xf2e88(%rcx), %rdx
movq %rdx, 0xf2ea8(%rax)
movq 0xf2e90(%rcx), %rcx
movq %rcx, 0xf2eb0(%rax)
movl $0x64, %edi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0xfd90
movl %eax, %ecx
leaq 0x18e31(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e78(%rax)
movl $0xfa, %edi
movl $0x320, %esi            # imm = 0x320
callq 0xfd90
movl %eax, %ecx
leaq 0x18e10(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e7c(%rax)
movl $0x190, %edi            # imm = 0x190
movl $0x4b0, %esi            # imm = 0x4B0
callq 0xfd90
movl %eax, %ecx
leaq 0x18def(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e80(%rax)
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x578, %esi            # imm = 0x578
callq 0xfd90
movl %eax, %ecx
leaq 0x18dce(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e84(%rax)
movl $0x2bc, %edi            # imm = 0x2BC
movl $0x7d0, %esi            # imm = 0x7D0
callq 0xfd90
movl %eax, %ecx
leaq 0x18dad(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e88(%rax)
movl $0x3e8, %edi            # imm = 0x3E8
movl $0xbb8, %esi            # imm = 0xBB8
callq 0xfd90
movl %eax, %ecx
leaq 0x18d8c(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e8c(%rax)
movl $0xfa0, %edi            # imm = 0xFA0
movl $0x2ee0, %esi           # imm = 0x2EE0
callq 0xfd90
movl %eax, %ecx
leaq 0x18d6b(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e90(%rax)
movl $0x61a8, %edi           # imm = 0x61A8
movl $0x186a0, %esi          # imm = 0x186A0
callq 0xfd90
movl %eax, %ecx
leaq 0x18d4a(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl %ecx, 0xf2e94(%rax)
leaq -0x190(%rbp), %rdi
leaq 0x18d33(%rip), %rax     # 0x28a70
movq (%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq 0xf776(%rip), %rsi      # 0x1f4c4
movb $0x0, %al
callq 0x2050
leaq -0x190(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x20c0
movq -0x198(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/market.c
// Function: print_market
void print_market() {
    char out[MAX_MESSAGE_BUFFER];
    sprintf(out, "PRIVMSG %s :", dawn->active_room);
    for (int i=0; i<MAX_MATERIAL_TYPE; i++) {
        char *temp;
        size_t len = strlen(out);
        CALLEXIT(!(temp = malloc(MAX_MESSAGE_BUFFER-len)))
        int difference = dawn->market.materials[i] - dawn->market.prevprice[i];
        snprintf(temp, MAX_MESSAGE_BUFFER-len, "[%s: %d (%s%+d" IRC_NORMAL ")] ",
                 material_to_str(i),
                 dawn->market.materials[i],
                 ((difference >= 0) ? IRC_GREEN : IRC_RED),
                 difference);
        strncat(out, temp, MAX_MESSAGE_BUFFER-len);
        free(temp);
    }
    strncat(out, "\r\n", 3);
    add_msg(out, strlen(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x190(%rbp), %rdi
leaq 0x18c87(%rip), %rax     # 0x28a70
movq (%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq 0xbadc(%rip), %rsi      # 0x1b8d6
movb $0x0, %al
callq 0x2050
movl $0x0, -0x194(%rbp)
cmpl $0x8, -0x194(%rbp)
jge 0xff5c
leaq -0x190(%rbp), %rdi
callq 0x20c0
movq %rax, -0x1a8(%rbp)
movl $0x190, %edi            # imm = 0x190
subq -0x1a8(%rbp), %rdi
callq 0x22b0
movq %rax, -0x1a0(%rbp)
cmpq $0x0, %rax
jne 0xfe5f
leaq 0xf6a2(%rip), %rdi      # 0x1f4f2
callq 0x2190
movl $0x1, %edi
callq 0x2260
leaq 0x18c0a(%rip), %rax     # 0x28a70
movq (%rax), %rax
movslq -0x194(%rbp), %rcx
movl 0xf2e78(%rax,%rcx,4), %eax
leaq 0x18bf2(%rip), %rcx     # 0x28a70
movq (%rcx), %rcx
movslq -0x194(%rbp), %rdx
subl 0xf2e98(%rcx,%rdx,4), %eax
movl %eax, -0x1ac(%rbp)
movq -0x1a0(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x190, %eax            # imm = 0x190
subq -0x1a8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movl -0x194(%rbp), %edi
callq 0xffb0
movq -0x1c0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
movq %rax, %rcx
leaq 0x18b97(%rip), %rax     # 0x28a70
movq (%rax), %rax
movslq -0x194(%rbp), %rdx
movl 0xf2e78(%rax,%rdx,4), %r8d
movl -0x1ac(%rbp), %edx
leaq 0xae38(%rip), %r9       # 0x1ad30
leaq 0xd2de(%rip), %rax      # 0x1d1dd
cmpl $0x0, %edx
cmovgeq %rax, %r9
movl -0x1ac(%rbp), %eax
leaq 0xf62c(%rip), %rdx      # 0x1f53f
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2390
leaq -0x190(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
movl $0x190, %edx            # imm = 0x190
subq -0x1a8(%rbp), %rdx
callq 0x2120
movq -0x1a0(%rbp), %rdi
callq 0x2240
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0xfe0b
leaq -0x190(%rbp), %rdi
leaq 0xcd1c(%rip), %rsi      # 0x1cc86
movl $0x3, %edx
callq 0x2120
leaq -0x190(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x20c0
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/market.c
// Function: material_to_str
static char *material_to_str(int index) {
    switch (index) {
        case WOOD:    return "Wood";
        case LEATHER: return "Leather";
        case ORE:     return "Ore";
        case STONE:   return "Stone";
        case BRONZE:  return "Bronze";
        case MAIL:    return "Mail";
        case STEEL:   return "Steel";
        case DIAMOND: return "Diamond";
        default: return "Error";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x10040
movq -0x18(%rbp), %rax
leaq 0xf4d5(%rip), %rcx      # 0x1f4a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xf744(%rip), %rax      # 0x1f723
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf73c(%rip), %rax      # 0x1f728
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf737(%rip), %rax      # 0x1f730
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf72e(%rip), %rax      # 0x1f734
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf727(%rip), %rax      # 0x1f73a
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf721(%rip), %rax      # 0x1f741
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf719(%rip), %rax      # 0x1f746
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf712(%rip), %rax      # 0x1f74c
movq %rax, -0x8(%rbp)
jmp 0x1004b
leaq 0xf70d(%rip), %rax      # 0x1f754
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/market.c
// Function: get_itemID
static int get_itemID (char *which) {
    if (strcmp(which, "wood") == 0)
        return WOOD;
    else if (strcmp(which, "leather") == 0)
        return LEATHER;
    else if (strcmp(which, "ore") == 0)
        return ORE;
    else if (strcmp(which, "stone") == 0)
        return STONE;
    else if (strcmp(which, "bronze") == 0)
        return BRONZE;
    else if (strcmp(which, "mail") == 0)
        return MAIL;
    else if (strcmp(which, "steel") == 0)
        return STEEL;
    else if (strcmp(which, "diamond") == 0)
        return DIAMOND;
    else
        return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcffc(%rip), %rsi      # 0x1d4b3
callq 0x22d0
cmpl $0x0, %eax
jne 0x104cd
movl $0x0, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcfe0(%rip), %rsi      # 0x1d4b8
callq 0x22d0
cmpl $0x0, %eax
jne 0x104ee
movl $0x1, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcfcd(%rip), %rsi      # 0x1d4c6
callq 0x22d0
cmpl $0x0, %eax
jne 0x1050f
movl $0x2, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcfa6(%rip), %rsi      # 0x1d4c0
callq 0x22d0
cmpl $0x0, %eax
jne 0x1052d
movl $0x3, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcf92(%rip), %rsi      # 0x1d4ca
callq 0x22d0
cmpl $0x0, %eax
jne 0x1054b
movl $0x4, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcf7b(%rip), %rsi      # 0x1d4d1
callq 0x22d0
cmpl $0x0, %eax
jne 0x10569
movl $0x5, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcf62(%rip), %rsi      # 0x1d4d6
callq 0x22d0
cmpl $0x0, %eax
jne 0x10587
movl $0x6, -0x4(%rbp)
jmp 0x105ac
movq -0x10(%rbp), %rdi
leaq 0xcf4a(%rip), %rsi      # 0x1d4dc
callq 0x22d0
cmpl $0x0, %eax
jne 0x105a5
movl $0x7, -0x4(%rbp)
jmp 0x105ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/monsters.c
// Function: get_monstring
static char *get_monstring (enum MonsterType type, char *temp) {
    switch (type) {
        case BERSERKER: snprintf(temp, 100, "%s%s%s", IRC_RED, "Berserker (2x Stats)", IRC_NORMAL); break;
        case ELDER:     snprintf(temp, 100, "%s%s%s", IRC_GREEN, "Elder (3x Experience)", IRC_NORMAL); break;
        case THIEF:     snprintf(temp, 100, "%s%s%s", IRC_ORANGE, "Thief (5x Gold)", IRC_NORMAL); break;
        case TANK:      snprintf(temp, 100, "%s%s%s", IRC_DBLUE, "Tank (4x Defense)", IRC_NORMAL); break;
        case BOSS:      snprintf(temp, 100, "%s%s%s", IRC_BROWN, "BOSS (10x ALL 6x Payout)", IRC_NORMAL); break;
        case DEFMON:    snprintf(temp, 1, "%s", "\0");
    }
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x1147e
movq -0x18(%rbp), %rax
leaq 0xe409(%rip), %rcx      # 0x1f774
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl $0x64, %esi
leaq 0xe8d3(%rip), %rdx      # 0x1fc57
leaq 0x99a5(%rip), %rcx      # 0x1ad30
leaq 0xe8cc(%rip), %r8       # 0x1fc5e
leaq 0xbe4c(%rip), %r9       # 0x1d1e5
movb $0x0, %al
callq 0x2390
jmp 0x1147e
movq -0x10(%rbp), %rdi
movl $0x64, %esi
leaq 0xe8a2(%rip), %rdx      # 0x1fc57
leaq 0xbe21(%rip), %rcx      # 0x1d1dd
leaq 0xe8b0(%rip), %r8       # 0x1fc73
leaq 0xbe1b(%rip), %r9       # 0x1d1e5
movb $0x0, %al
callq 0x2390
jmp 0x1147e
movq -0x10(%rbp), %rdi
movl $0x64, %esi
leaq 0xe871(%rip), %rdx      # 0x1fc57
leaq 0xc0ae(%rip), %rcx      # 0x1d49b
leaq 0xe895(%rip), %r8       # 0x1fc89
leaq 0xbdea(%rip), %r9       # 0x1d1e5
movb $0x0, %al
callq 0x2390
jmp 0x1147e
movq -0x10(%rbp), %rdi
movl $0x64, %esi
leaq 0xe843(%rip), %rdx      # 0x1fc57
leaq 0xc088(%rip), %rcx      # 0x1d4a3
leaq 0xe877(%rip), %r8       # 0x1fc99
leaq 0xbdbc(%rip), %r9       # 0x1d1e5
movb $0x0, %al
callq 0x2390
jmp 0x1147e
movq -0x10(%rbp), %rdi
movl $0x64, %esi
leaq 0xe815(%rip), %rdx      # 0x1fc57
leaq 0xc05e(%rip), %rcx      # 0x1d4a7
leaq 0xe85b(%rip), %r8       # 0x1fcab
leaq 0xbd8e(%rip), %r9       # 0x1d1e5
movb $0x0, %al
callq 0x2390
jmp 0x1147e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xf0ca(%rip), %rdx      # 0x2053a
leaq 0xe315(%rip), %rcx      # 0x1f78c
movb $0x0, %al
callq 0x2390
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/namegen.c
// Function: init_name_gen
NameGen init_name_gen(unsigned int markov_tier) {
    if(markov_tier == 0)
        return 0;
    struct namegen * ng;
    CALLEXIT(!(ng = malloc(sizeof *ng)))
    ng->markov_tier = markov_tier;
    ng->success = 0;
    CALLEXIT(!(ng->tiers = malloc(markov_tier * sizeof *ng->tiers)))
    for(size_t i = 0; i < markov_tier; i++) {
        ng->tiers[i] = init_analyzer(i+1);
    }
    return ng;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x11bfe
movq $0x0, -0x8(%rbp)
jmp 0x11cb7
movl $0x10, %edi
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x11c28
leaq 0xe0bf(%rip), %rdi      # 0x1fcd8
callq 0x2190
movl $0x1, %edi
callq 0x2260
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0xc(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x22b0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x11c6e
leaq 0xe0b9(%rip), %rdi      # 0x1fd18
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x11caf
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x2590
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11c76
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/namegen.c
// Function: free_name_gen
void free_name_gen(NameGen ng) {
    if(!ng)
        return;
    struct namegen * cng = ng;
    for(size_t i = 0; i < cng->markov_tier; i++) {
        free_analyzer(cng->tiers[i]);
    }
    free(cng->tiers);
    free(cng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11ce5
jmp 0x11d3c
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jae 0x11d27
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2620
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11cf5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x10(%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/namegen.c
// Function: add_file
void add_file(NameGen ng, char const * fn) {
    if(!ng || !fn || strlen(fn) == 0)
        return;
    struct namegen * cng = ng;
    for(size_t i = 0; i < cng->markov_tier; i++) {
        if(!analyze(cng->tiers[i], fn)) {
            cng->success = 0;
            return;
        }
    }
    cng->success = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11d7d
cmpq $0x0, -0x10(%rbp)
je 0x11d7d
movq -0x10(%rbp), %rdi
callq 0x20c0
cmpq $0x0, %rax
jne 0x11d7f
jmp 0x11de4
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jae 0x11dd9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x26b0
cmpl $0x0, %eax
jne 0x11dc9
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x11de4
jmp 0x11dcb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11d8f
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/namegen.c
// Function: is_producible
int is_producible(NameGen ng, char src, size_t max_tier) {
    if(!ng || src == '\0')
        return 0;
    int valid = 0;
    struct namegen * cng = ng;
    for(size_t i = 0; i < max_tier && i < cng->markov_tier; i++) {
        if(has_rule_for(cng->tiers[i], src)) {
            valid = 1;
            break;
        }
    }
    return valid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12326
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x1232f
movl $0x0, -0x4(%rbp)
jmp 0x123ae
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x39(%rbp)
jae 0x12369
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x12372
jmp 0x123a8
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movsbl -0x11(%rbp), %esi
callq 0x2df0
cmpl $0x0, %eax
je 0x12398
movl $0x1, -0x24(%rbp)
jmp 0x123a8
jmp 0x1239a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x12346
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: init_msg_list
MsgList init_msg_list() {
    if(msgQ_singleton)
        return 0;
    struct msg_list * new_list;
    CALLEXIT(!(new_list = calloc(1, sizeof *new_list)))
    msgQ_singleton++;
    return new_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x13ec9(%rip)     # 0x262b8
je 0x123fb
movq $0x0, -0x8(%rbp)
jmp 0x12441
movl $0x1, %edi
movl $0x20, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1242a
leaq 0xdcd8(%rip), %rdi      # 0x200f3
callq 0x2190
movl $0x1, %edi
callq 0x2260
movl 0x13e88(%rip), %eax     # 0x262b8
addl $0x1, %eax
movl %eax, 0x13e7f(%rip)     # 0x262b8
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/network.c
// Function: init_msg_hist_list
MsgHistoryList init_msg_hist_list() {
    if(msgHQ_singleton)
        return 0;
    struct msg_hist_list * new_list;
    CALLEXIT(!(new_list = calloc(1, sizeof *new_list)))
    msgHQ_singleton++;
    return new_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x13e55(%rip)     # 0x262b4
je 0x1246b
movq $0x0, -0x8(%rbp)
jmp 0x124b1
movl $0x1, %edi
movl $0x20, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1249a
leaq 0xdb4f(%rip), %rdi      # 0x1ffda
callq 0x2190
movl $0x1, %edi
callq 0x2260
movl 0x13e14(%rip), %eax     # 0x262b4
addl $0x1, %eax
movl %eax, 0x13e0b(%rip)     # 0x262b4
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/network.c
// Function: init_connect_server
int init_connect_server (const char *ip_addr, const char *port) {
    errno = 0;
    struct addrinfo destination, *res;
    memset(&destination, 0, sizeof destination);
    destination.ai_family = AF_INET;
    destination.ai_socktype = SOCK_STREAM;
    getaddrinfo(ip_addr, port, &destination, &res);
    CALLEXIT((con_socket = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1)
    printf(INFO "Trying to connect to %s:%s\n", ip_addr, port);
    CALLEXIT(connect(con_socket, res->ai_addr, res->ai_addrlen) == -1)
    printf(INFO "Connected to %s:%s\n", ip_addr, port);
    freeaddrinfo(res);
    return errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2030
movl $0x0, (%rax)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x20f0
movl $0x2, -0x3c(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x2280
movq -0x48(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x48(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x48(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2070
movl %eax, 0x13d82(%rip)     # 0x262b0
cmpl $-0x1, %eax
jne 0x12549
leaq 0xd92c(%rip), %rdi      # 0x1fe66
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd983(%rip), %rdi      # 0x1fedb
movb $0x0, %al
callq 0x2040
movl 0x13d4b(%rip), %edi     # 0x262b0
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x48(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2180
cmpl $-0x1, %eax
jne 0x12594
leaq 0xd985(%rip), %rdi      # 0x1ff0a
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd9c5(%rip), %rdi      # 0x1ff68
movb $0x0, %al
callq 0x2040
movq -0x48(%rbp), %rdi
callq 0x22a0
callq 0x2030
movl (%rax), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: free_msg_hist_list
void free_msg_hist_list() {
    if(!msgHQ_singleton || !mhlist)
        return;
    struct msg_hist_list * cmhlist = mhlist;
    struct msg_hist_node * tmp = cmhlist->head;
    while(tmp) {
        struct msg_hist_node * next = tmp->next;
        free(tmp);
        tmp = next;
    }
    free(cmhlist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x13c75(%rip)     # 0x262b4
je 0x1264b
cmpq $0x0, 0x13c5f(%rip)     # 0x262a8
jne 0x1264d
jmp 0x12692
movq 0x13c54(%rip), %rax     # 0x262a8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12689
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12663
movq -0x8(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: add_hist_msg
void add_hist_msg(size_t len) {
    if(mhlist == 0)
        return;
    struct msg_hist_list * cmhlist = mhlist;

    time_t cur_time = time(0);
    if(cmhlist->head == 0) {
        add_event(MSGSEND, 0, SENDQ_INTERVAL, NORMAL); //should be unique, though there should also never be multiple MSGSEND events in the queue
        CALLEXIT(!(cmhlist->head = cmhlist->tail = calloc(1, sizeof *cmhlist->head)))
    } else {
        CALLEXIT(!(cmhlist->tail->next = calloc(1, sizeof *cmhlist->tail)))
        cmhlist->tail = cmhlist->tail->next;
    }
    cmhlist->tail->date = cur_time;
    cmhlist->tail->len = len;

    cmhlist->byte_size += len;
    cmhlist->msgs++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x13bf4(%rip)     # 0x262a8
jne 0x126bb
jmp 0x127b6
movq 0x13be6(%rip), %rax     # 0x262a8
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1272c
movl $0x4, %edi
xorl %ecx, %ecx
movl $0x5, %edx
movl %ecx, %esi
callq 0x17280
movl $0x1, %edi
movl $0x18, %esi
callq 0x2110
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1272a
leaq 0xd90e(%rip), %rdi      # 0x20029
callq 0x2190
movl $0x1, %edi
callq 0x2260
jmp 0x12777
movl $0x1, %edi
movl $0x18, %esi
callq 0x2110
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x12763
leaq 0xd93f(%rip), %rdi      # 0x20093
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: free_msg_list
void free_msg_list() {
    if(!mlist || !msgQ_singleton)
        return;
    struct msg_list * cmlist = mlist;
    struct msg_node * tmp = cmlist->head;
    while(tmp) {
        struct msg_node * next = tmp->next;
        free(tmp->msg);
        free(tmp);
        tmp = next;
    }
    free(cmlist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x13ad0(%rip)     # 0x262a0
je 0x127db
cmpl $0x0, 0x13adf(%rip)     # 0x262b8
jne 0x127dd
jmp 0x1282e
movq 0x13abc(%rip), %rax     # 0x262a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12825
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x127f3
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/network.c
// Function: add_msg
void add_msg(char * msg, size_t len) {
    if(mlist == 0)
        return;
    struct msg_list * cmlist = mlist;

    if(cmlist->head == 0) {
        CALLEXIT(!(cmlist->head = cmlist->tail = calloc(1, sizeof *cmlist->head)))
    } else {
        CALLEXIT(!(cmlist->tail->next = calloc(1, sizeof *cmlist->tail)))
        cmlist->tail = cmlist->tail->next;
    }
    CALLEXIT(!(cmlist->tail->msg = malloc(len+1)))
    strcpy(cmlist->tail->msg, msg);
    cmlist->tail->len = len;
    cmlist->byte_size += len;
    cmlist->msgs++;
    process_messages();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x13a48(%rip)     # 0x262a0
jne 0x1285f
jmp 0x12978
movq 0x13a3a(%rip), %rax     # 0x262a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x128b0
movl $0x1, %edi
movl $0x18, %esi
callq 0x2110
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x128ae
leaq 0xd8a4(%rip), %rdi      # 0x20143
callq 0x2190
movl $0x1, %edi
callq 0x2260
jmp 0x128fb
movl $0x1, %edi
movl $0x18, %esi
callq 0x2110
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x128e7
leaq 0xd8d2(%rip), %rdi      # 0x201aa
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x22b0
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1292f
leaq 0xd8e8(%rip), %rdi      # 0x20208
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x21c0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
callq 0x12980
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: process_messages
void process_messages() {
    if(mlist == 0 || mhlist == 0)
        return;
    struct msg_list * csrc = mlist;
    struct msg_hist_list * cdest = mhlist;

    size_t len;
    while(csrc->head != 0 && cdest->msgs < MAX_MSGS_IN_INTERVAL && cdest->byte_size + (len = peek_msg_size()) < MAX_SENDQ_SIZE) {
        if(len > MAX_MESSAGE_BUFFER) {
            PRINTERR("Message too long")
        }
        char * msg = retr_msg();
        send_socket(msg, len);
        free(msg);
        add_hist_msg(len);
        //printf("MQueue: %zu of %d (PUSH)\n", cdest->byte_size, MAX_SENDQ_SIZE);

    }
    if(cdest->msgs >= MAX_MSGS_IN_INTERVAL || cdest->byte_size + peek_msg_size() >= MAX_SENDQ_SIZE) {
        printf(INFO "Send queue full\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
cmpq $0x0, 0x13910(%rip)     # 0x262a0
je 0x1299c
cmpq $0x0, 0x1390e(%rip)     # 0x262a8
jne 0x129a1
jmp 0x12a89
movq 0x138f8(%rip), %rax     # 0x262a0
movq %rax, -0x8(%rbp)
movq 0x138f5(%rip), %rax     # 0x262a8
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x12a01
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0xa, 0x18(%rcx)
movb %al, -0x21(%rbp)
jae 0x12a01
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x12ba0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
addq %rcx, %rax
cmpq $0x1f4, %rax            # imm = 0x1F4
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x12a0a
jmp 0x12a4d
cmpq $0x190, -0x18(%rbp)     # imm = 0x190
jbe 0x12a20
leaq 0xd838(%rip), %rdi      # 0x20253
callq 0x2190
callq 0x12c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x125e0
movq -0x20(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rdi
callq 0x126a0
jmp 0x129b7
movq -0x10(%rbp), %rax
cmpq $0xa, 0x18(%rax)
jae 0x12a7b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x12ba0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
cmpq $0x1f4, %rax            # imm = 0x1F4
jb 0x12a89
leaq 0xd808(%rip), %rdi      # 0x2028a
movb $0x0, %al
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: pop_hist_msg
void pop_hist_msg() {
    if(mhlist == 0)
        return;
    struct msg_hist_list * cmhlist = mhlist;
    if(cmhlist->head == 0)
        return;
    time_t cur_time = time(0);
    while(cmhlist->head != 0 && cur_time - SENDQ_INTERVAL >= cmhlist->head->date) {
        cmhlist->byte_size -= cmhlist->head->len;
        //printf("MQueue: %zu of %d (POP)\n", cmhlist->byte_size, MAX_SENDQ_SIZE);
        cmhlist->msgs--;
        struct msg_hist_node * new_head = cmhlist->head->next;
        free(cmhlist->head);
        cmhlist->head = new_head;
    }
    if(cmhlist->head != 0) {
        add_event(MSGSEND, 1, (unsigned int)(SENDQ_INTERVAL - (cur_time - cmhlist->head->date)), NORMAL);
    }
    process_messages();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x13808(%rip)     # 0x262a8
jne 0x12aa7
jmp 0x12b8c
movq 0x137fa(%rip), %rax     # 0x262a8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12ac1
jmp 0x12b8c
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x12af6
movq -0x10(%rbp), %rax
subq $0x5, %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
setge %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x12aff
jmp 0x12b53
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12ace
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12b87
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq 0x8(%rax), %rcx
movl $0x5, %eax
subq %rcx, %rax
movl %eax, %edx
movl $0x4, %edi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x17280
callq 0x12980
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: peek_msg_size
size_t peek_msg_size() {
    if(mlist == 0)
        return 0;
    struct msg_list * cmlist = mlist;
    if(cmlist->head == 0)
        return 0;
    return cmlist->head->len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x136f4(%rip)     # 0x262a0
jne 0x12bb8
movq $0x0, -0x8(%rbp)
jmp 0x12be6
movq 0x136e1(%rip), %rax     # 0x262a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12bd7
movq $0x0, -0x8(%rbp)
jmp 0x12be6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: hostname_to_ip
int hostname_to_ip(char *hostname , char *ip) {
    struct hostent *he;
    struct in_addr **addr_list;
    int i;
         
    if ((he = gethostbyname(hostname)) == NULL) {
        herror("gethostbyname");
        return 1;
    }
 
    addr_list = (struct in_addr **) he->h_addr_list;
     
    for(i=0; addr_list[i] != NULL; i++) {
        strcpy(ip , inet_ntoa(*addr_list[i]));
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2220
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x12c28
leaq 0xd694(%rip), %rdi      # 0x202ae
callq 0x2250
movl $0x1, -0x4(%rbp)
jmp 0x12c81
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12c7a
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %edi
callq 0x20d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movl $0x0, -0x4(%rbp)
jmp 0x12c81
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/network.c
// Function: retr_msg
static char *retr_msg() {
    if(mlist == 0)
        return 0;
    struct msg_list * cmlist = mlist;
    if(cmlist->head == 0)
        return 0;

    char * data = cmlist->head->msg;

    cmlist->byte_size -= cmlist->head->len;
    cmlist->msgs--;

    struct msg_node * new_head = cmlist->head->next;
    free(cmlist->head);
    cmlist->head = new_head;
    if(cmlist->head == 0)
        cmlist->tail = 0;
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x13600(%rip)     # 0x262a0
jne 0x12caf
movq $0x0, -0x8(%rbp)
jmp 0x12d4a
movq 0x135ea(%rip), %rax     # 0x262a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12cce
movq $0x0, -0x8(%rbp)
jmp 0x12d4a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12d42
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: to_lower
char *to_lower (char *str) {
    for (size_t i=0; i<strlen(str); i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
            str[i] += 32;
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x12dd5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x12dc5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x12dc5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl $0x20, %edx
movb %dl, (%rax,%rcx)
jmp 0x12dc7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12d74
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: xor_flip
char *xor_flip (char * password) { //password -> 64
    unsigned int key = 0xDEADBEBE;
    for (size_t i=0; i<strlen(password); i++)
        password[i] ^= key;
    return password;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xdeadbebe, -0xc(%rbp) # imm = 0xDEADBEBE
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x12e3a
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12dfb
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/parse.c
// Function: gen_salt
void gen_salt(char * salt, size_t len) {
    size_t pos;
    for(pos = 0; pos < len-1; pos++) {
        do {
            salt[pos] = (char)(rand() % 256 - 128); //char -> (-128...127); mod 2^x does not skew random distribution
        } while(salt[pos] != 0);
    }
    salt[pos] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x12eba
jmp 0x12e7b
callq 0x2080
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
subl $0x80, %edx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x12e7b
jmp 0x12eac
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12e68
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: hash_pwd
void hash_pwd(unsigned char * digest, char const * salt, char const * password) {
    size_t concatlen = strnlen(salt, 16) + strnlen(password, 64) + 2;
    char *concat;
    unsigned int outLen;

    CALLEXIT(!(concat = malloc(concatlen)))
    snprintf(concat, concatlen, "!%s%s", password, salt);

    EVP_MD_CTX *ctx;
    ctx = EVP_MD_CTX_new();

    EVP_DigestInit(ctx, EVP_sha256());
    EVP_DigestUpdate(ctx, concat, concatlen);
    EVP_DigestFinal(ctx, digest, &outLen);

    printf("concat %s - concatlen: %zu - salt: %s - pass: %s - digest: %s\n", concat, concatlen, salt, password, digest);

	free(concat);
    EVP_MD_CTX_free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x2350
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x2350
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x12f3f
leaq 0xd38c(%rip), %rdi      # 0x202bc
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0xd3a7(%rip), %rdx      # 0x202fd
movb $0x0, %al
callq 0x2390
callq 0x2210
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x23f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2450
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2460
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x22f0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x8(%rbp), %r9
leaq 0xd347(%rip), %rdi      # 0x20303
movb $0x0, %al
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2240
movq -0x38(%rbp), %rdi
callq 0x2410
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: hash_cmp
int hash_cmp(unsigned char const * s1, unsigned char const * s2) {
    int i;
    for(i = 0; i < SHA256_DIGEST_LENGTH && s1 && *s1 && s2 && *s2 && *s1 == *s2; i++) {
        s1++;
        s2++;
    }
    return i == SHA256_DIGEST_LENGTH;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x20, -0x14(%rbp)
movb %al, -0x15(%rbp)
jge 0x1304e
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x15(%rbp)
je 0x1304e
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x1304e
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x15(%rbp)
je 0x1304e
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x1304e
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x13057
jmp 0x1307d
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12ff3
cmpl $0x20, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: handle_login
void handle_login (char *nick, char *pass __attribute__((unused)), char *real, char *ident) {
    char out[MAX_MESSAGE_BUFFER];
    sprintf(out, "NICK %s\r\n", nick);
    add_msg(out, strlen(out));
    sprintf(out, "USER %s * * :%s\r\n", ident, real);
    add_msg(out, strlen(out));
    //printf(INFO "Using password '%s'\n", pass); //TODO:quieting down warnings for now but this will be nickserv
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x1b0(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd154(%rip), %rsi      # 0x203f1
movb $0x0, %al
callq 0x2050
leaq -0x1b0(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x20c0
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
leaq -0x1b0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xd118(%rip), %rsi      # 0x203fb
movb $0x0, %al
callq 0x2050
leaq -0x1b0(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x20c0
movq -0x1b8(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/parse.c
// Function: command_allowed
int command_allowed(char *command, int pindex) { //command -> 16
    if (dawn->players[pindex].travel_timer.active) {
        char disallowed[2][16] = {"melee", "gmelee"}; //remember to change array limits
        for (int i=0; i<2; i++) {
            printf("recv '%s' iter '%s'\n", command, disallowed[i]);
            if (strcmp(command, disallowed[i]) == 0) return 0;
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x152ea(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x14(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
cmpl $0x0, 0x114c(%rax)
je 0x13839
movq 0xceaf(%rip), %rax      # 0x20660
movq %rax, -0x40(%rbp)
movq 0xceac(%rip), %rax      # 0x20668
movq %rax, -0x38(%rbp)
movq 0xcea9(%rip), %rax      # 0x20670
movq %rax, -0x30(%rbp)
movq 0xcea6(%rip), %rax      # 0x20678
movq %rax, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x2, -0x44(%rbp)
jge 0x13837
movq -0x10(%rbp), %rsi
movslq -0x44(%rbp), %rax
leaq -0x40(%rbp), %rdx
shlq $0x4, %rax
addq %rax, %rdx
leaq 0xcd40(%rip), %rdi      # 0x2053d
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rax
leaq -0x40(%rbp), %rsi
shlq $0x4, %rax
addq %rax, %rsi
callq 0x22d0
cmpl $0x0, %eax
jne 0x1382a
movl $0x0, -0x4(%rbp)
jmp 0x13840
jmp 0x1382c
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x137dd
jmp 0x13839
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: get_pindex
int get_pindex(char const *username) { //username -> MAX_NICK_LENGTH
    for (int i = 0; i < dawn->player_count; i++) {
        if (strcasecmp(dawn->players[i].username, username) == 0)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x14eb3(%rip), %rcx     # 0x28a70
movq (%rcx), %rcx
cmpl 0x148(%rcx), %eax
jge 0x13c0a
leaq 0x14ea1(%rip), %rax     # 0x28a70
movq (%rax), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
movslq -0x14(%rbp), %rax
imulq $0x26a8, %rax, %rax     # imm = 0x26A8
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2200
cmpl $0x0, %eax
jne 0x13bfd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13c11
jmp 0x13bff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13bb3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: get_bindex
int get_bindex (struct Bot *b, char const * username, char const * location) { //username -> MAX_NICK_LENGTH, location -> 64
    int pindex = get_pindex(username);
    for (int i=0; i<MAX_BUILDINGS; i++) {
        if (strcmp(location, dawn->players[pindex].current_map.buildings[i].name) == 0) {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13ba0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x40, -0x28(%rbp)
jge 0x13ca1
movq -0x20(%rbp), %rdi
leaq 0x14e18(%rip), %rax     # 0x28a70
movq (%rax), %rsi
addq $0x1a0, %rsi            # imm = 0x1A0
movslq -0x24(%rbp), %rax
imulq $0x26a8, %rax, %rax     # imm = 0x26A8
addq %rax, %rsi
addq $0x119c, %rsi           # imm = 0x119C
movslq -0x28(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x22d0
cmpl $0x0, %eax
jne 0x13c94
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13ca8
jmp 0x13c96
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x13c47
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/player.c
// Function: save_players
void save_players(void) {
    if (dawn == 0)
        return;
    FILE *file = fopen("players.bin", "wb");
    if(!file) {
        PRINTWARN("Could not save players")
        return;
    }
    size_t len;
    CALLEXIT(!(len = fwrite(dawn, sizeof *dawn, 1, file)))
    fclose(file);
    printf(INFO "Saved players (%zu bytes)\n", len * (sizeof *dawn));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x14951(%rip), %rax     # 0x28a70
cmpq $0x0, (%rax)
jne 0x1412a
jmp 0x141b2
leaq 0xc764(%rip), %rdi      # 0x20895
leaq 0xa64e(%rip), %rsi      # 0x1e786
callq 0x2230
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14156
leaq 0xc752(%rip), %rdi      # 0x208a1
callq 0x2190
jmp 0x141b2
leaq 0x14913(%rip), %rax     # 0x28a70
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
movl $0xf2eb8, %esi          # imm = 0xF2EB8
movl $0x1, %edx
callq 0x2470
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x14193
leaq 0xc759(%rip), %rdi      # 0x208dd
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rdi
callq 0x21f0
imulq $0xf2eb8, -0x10(%rbp), %rsi # imm = 0xF2EB8
leaq 0xc784(%rip), %rdi      # 0x2092f
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)