LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/psi.h
// Function: psi_table_compare
static inline bool psi_table_compare(uint8_t **pp_sections1,
                                     uint8_t **pp_sections2)
{
    uint8_t i_last_section = psi_table_get_lastsection(pp_sections1);
    uint8_t i;

    if (i_last_section != psi_table_get_lastsection(pp_sections2))
        return false;

    for (i = 0; i <= i_last_section; i++) {
        const uint8_t *p_section1 = psi_table_get_section(pp_sections1, i);
        const uint8_t *p_section2 = psi_table_get_section(pp_sections2, i);
        if (!psi_compare(p_section1, p_section2))
            return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2440
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2440
movb %al, %cl
movl -0x34(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2504
movb $0x0, -0x1(%rbp)
jmp 0x255d
movb $0x0, -0x1a(%rbp)
movzbl -0x1a(%rbp), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jg 0x2559
movq -0x10(%rbp), %rdi
movzbl -0x1a(%rbp), %esi
callq 0x2710
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movzbl -0x1a(%rbp), %esi
callq 0x2710
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x28b0
testb $0x1, %al
jne 0x254d
movb $0x0, -0x1(%rbp)
jmp 0x255d
jmp 0x254f
movb -0x1a(%rbp), %al
addb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x2508
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/pat.h
// Function: pat_table_validate
static inline bool pat_table_validate(uint8_t **pp_sections)
{
    uint8_t i_last_section = psi_table_get_lastsection(pp_sections);
    uint8_t i;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p_section = psi_table_get_section(pp_sections, i);
        uint8_t *p_program;
        int j = 0;

        if (!psi_check_crc(p_section))
            return false;

        while ((p_program = pat_get_program(p_section, j)) != NULL) {
            uint8_t *p_program2 = pat_table_find_program(pp_sections,
                                      patn_get_program(p_program));
            j++;
            /* check that the program number is not already in the table
             * with another PID */
            if (patn_get_pid(p_program) != patn_get_pid(p_program2))
                return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2440
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jg 0x26ce
movq -0x10(%rbp), %rdi
movzbl -0x12(%rbp), %esi
callq 0x2710
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2960
testb $0x1, %al
jne 0x264d
movb $0x0, -0x1(%rbp)
jmp 0x26d2
jmp 0x264f
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %eax
movzbl %al, %esi
callq 0x2730
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26bf
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27b0
movq -0x48(%rbp), %rdi
movzwl %ax, %esi
callq 0x2800
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27d0
movzwl %ax, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x27d0
movw %ax, %cx
movl -0x3c(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x26bd
movb $0x0, -0x1(%rbp)
jmp 0x26d2
jmp 0x264f
jmp 0x26c1
movb -0x12(%rbp), %al
addb $0x1, %al
movb %al, -0x12(%rbp)
jmp 0x260f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/pat.h
// Function: pat_table_find_program
static inline uint8_t *pat_table_find_program(uint8_t **pp_sections,
                                              uint16_t i_program)
{
    uint8_t i_last_section = psi_table_get_lastsection(pp_sections);
    uint8_t i;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p_section = psi_table_get_section(pp_sections, i);
        uint8_t *p_program;
        int j = 0;

        while ((p_program = pat_get_program(p_section, j)) != NULL) {
            j++;
            if (patn_get_program(p_program) == i_program)
                return p_program;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2440
movb %al, -0x13(%rbp)
movb $0x0, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
movzbl -0x13(%rbp), %ecx
cmpl %ecx, %eax
jg 0x2898
movq -0x10(%rbp), %rdi
movzbl -0x14(%rbp), %esi
callq 0x2710
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %eax
movzbl %al, %esi
callq 0x2730
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x288c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27b0
movzwl %ax, %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x288a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28a0
jmp 0x284a
jmp 0x288e
movb -0x14(%rbp), %al
addb $0x1, %al
movb %al, -0x14(%rbp)
jmp 0x2826
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/psi.h
// Function: psi_compare
static inline bool psi_compare(const uint8_t *p_section1,
                               const uint8_t *p_section2)
{
    return psi_get_version(p_section1) == psi_get_version(p_section2)
        && psi_get_length(p_section1) == psi_get_length(p_section2)
        && !memcmp(p_section1, p_section2,
                   psi_get_length(p_section1) + PSI_HEADER_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2460
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2460
movl -0x18(%rbp), %ecx
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2948
movq -0x8(%rbp), %rdi
callq 0x1b70
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b70
movl -0x1c(%rbp), %ecx
movzwl %ax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2948
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b70
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movzwl %ax, %eax
addl $0x3, %eax
movslq %eax, %rdx
callq 0x1080
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/psi.h
// Function: psi_check_crc
static inline bool psi_check_crc(const uint8_t *p_section)
{
    uint32_t i_crc = 0xffffffff;
    uint16_t i_end = psi_get_length(p_section)
                      + PSI_HEADER_SIZE - PSI_CRC_SIZE;
    uint16_t i;

    for (i = 0; i < i_end; i++)
        i_crc = (i_crc << 8) ^ p_psi_crc_table[(i_crc >> 24) ^ (p_section[i])];

    return p_section[i_end] == (i_crc >> 24)
            && p_section[i_end + 1] == ((i_crc >> 16) & 0xff)
            && p_section[i_end + 2] == ((i_crc >> 8) & 0xff)
            && p_section[i_end + 3] == (i_crc & 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x1b70
movzwl %ax, %eax
addl $0x3, %eax
subl $0x4, %eax
movw %ax, -0xe(%rbp)
movw $0x0, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jge 0x29d4
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl -0xc(%rbp), %ecx
shrl $0x18, %ecx
movq -0x8(%rbp), %rdx
movzwl -0x10(%rbp), %esi
movzbl (%rdx,%rsi), %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x680(%rip), %rcx       # 0x3040
xorl (%rcx,%rdx,4), %eax
movl %eax, -0xc(%rbp)
movw -0x10(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x10(%rbp)
jmp 0x298f
movq -0x8(%rbp), %rax
movzwl -0xe(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
shrl $0x18, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2a60
movq -0x8(%rbp), %rax
movzwl -0xe(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
shrl $0x10, %edx
andl $0xff, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2a60
movq -0x8(%rbp), %rax
movzwl -0xe(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2a60
movq -0x8(%rbp), %rax
movzwl -0xe(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0xc(%rbp), %ecx
andl $0xff, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/descriptors.h
// Function: descl_validate
static inline bool descl_validate(const uint8_t *p_descl, uint16_t i_length)
{
    const uint8_t *p_desc = p_descl;

    while (p_desc + DESC_HEADER_SIZE - p_descl <= i_length)
        p_desc += DESC_HEADER_SIZE + desc_get_length(p_desc);

    return (p_desc - p_descl == i_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movzwl -0xa(%rbp), %ecx
cmpq %rcx, %rax
jg 0x2d52
movq -0x18(%rbp), %rdi
callq 0x2da0
movzbl %al, %ecx
addl $0x2, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d1b
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movzwl -0xa(%rbp), %ecx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/analyzer.c
// Function: init_analyzer
Analyzer init_analyzer(size_t markov_tier) {
    if(markov_tier == 0)
        return 0;
    struct analyzer * a;
    CALLEXIT(!(a = malloc(sizeof *a)))

    a->tlists = 0;
    a->markov_tier = markov_tier;
    a->tokens = 0;
    a->start = 0;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25ad
movq $0x0, -0x8(%rbp)
jmp 0x260e
movl $0x20, %edi
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x25d7
leaq 0x17a68(%rip), %rdi     # 0x1a030
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/analyzer.c
// Function: free_analyzer
void free_analyzer(Analyzer a) {
    if(!a)
        return;
    struct analyzer * ca = a;
    if(ca->tlists) {
        for(size_t i = 0; i < CHAR_LEN; i++) {
            free_token_list(ca->tlists[i]);
        }
    }
    free(ca->tlists);
    free_token_list(ca->start);
    free(ca);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2635
jmp 0x26a2
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x267f
movq $0x0, -0x18(%rbp)
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x267d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x17b90
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2650
jmp 0x267f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17b90
movq -0x10(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/analyzer.c
// Function: gen_start
char * gen_start(Analyzer a) {
    if(!a) {
        return 0;
    }

    struct analyzer * ca = a;
    if(!ca->start || ca->tokens == 0) {
        return 0;
    }

    if(get_len(ca->start) == 0) {
        return 0;
    }

    double prob = randd();
    TokenIterator it = get_iterator(ca->start);

    while(has_elem(it) && (prob > ((double)(get_num_consumed(it)))/get_num_total(ca->start))) {
        next(it);
    }

    if(!has_elem(it)) {
        free_iterator(it);
        return 0;
    }

    char * res = get_str(it);
    free_iterator(it);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2c80
movq $0x0, -0x8(%rbp)
jmp 0x2de1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2c9e
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2cab
movq $0x0, -0x8(%rbp)
jmp 0x2de1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17f60
cmpq $0x0, %rax
jne 0x2ccb
movq $0x0, -0x8(%rbp)
jmp 0x2de1
callq 0x181c0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17fe0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x180a0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x2d8b
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x181a0
movq %rax, %xmm0
movaps 0x172f2(%rip), %xmm1    # 0x1a010
movaps %xmm1, -0x70(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x172f2(%rip), %xmm1    # 0x1a020
movaps %xmm1, -0x60(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17fa0
movaps -0x70(%rbp), %xmm4
movaps -0x60(%rbp), %xmm3
movsd -0x48(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
movq %rax, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2d94
jmp 0x2da2
movq -0x28(%rbp), %rdi
callq 0x180e0
jmp 0x2ce6
movq -0x28(%rbp), %rdi
callq 0x180a0
cmpl $0x0, %eax
jne 0x2dc3
movq -0x28(%rbp), %rdi
callq 0x18080
movq $0x0, -0x8(%rbp)
jmp 0x2de1
movq -0x28(%rbp), %rdi
callq 0x18140
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x18080
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/analyzer.c
// Function: has_rule_for
int has_rule_for(Analyzer a, char src) {
    if(!a) {
        return 0;
    }

    struct analyzer * ca = a;
    if(!ca->tlists) {
        return 0;
    }
    return get_len(ca->tlists[(unsigned char)src]) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e12
movl $0x0, -0x4(%rbp)
jmp 0x2e52
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2e2e
movl $0x0, -0x4(%rbp)
jmp 0x2e52
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzbl -0x11(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x17f60
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/bounty.c
// Function: gen_global_bounty
void gen_global_bounty (void) {
    char out[MAX_MESSAGE_BUFFER];
    if (dawn->gbounty.amount) return;
    struct Bounty global_bounty;
    dawn->gbounty.name[0] = '\0';
    strcpy(global_bounty.name, dawn->monsters[rand() % MAX_MONSTERS].name);
    global_bounty.amount = 1 + rand() % 25;
    global_bounty.multiplier = 1 + rand() % 5;
    dawn->gbounty = global_bounty;

    snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :New bounty! Kill %d %s's, (%dx reward)\r\n",
            dawn->active_room, dawn->gbounty.amount, dawn->gbounty.name, dawn->gbounty.multiplier);
    add_msg(out, strlen(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
leaq 0x25bfe(%rip), %rax     # 0x28a70
movq (%rax), %rax
cmpl $0x0, 0x198(%rax)
je 0x2e83
jmp 0x2fba
leaq 0x25be6(%rip), %rax     # 0x28a70
movq (%rax), %rax
movb $0x0, 0x158(%rax)
leaq -0x1d8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq 0x25bc7(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0xf1b40, %rax          # imm = 0xF1B40
movq %rax, -0x1f0(%rbp)
callq 0x2080
movq -0x1f0(%rbp), %rsi
movq -0x1e8(%rbp), %rdi
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rax
imulq $0x78, %rax, %rax
addq %rax, %rsi
callq 0x21c0
callq 0x2080
movl $0x19, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x198(%rbp)
callq 0x2080
movl $0x5, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x194(%rbp)
leaq 0x25b5a(%rip), %rax     # 0x28a70
movq (%rax), %rdi
addq $0x158, %rdi            # imm = 0x158
leaq -0x1d8(%rbp), %rsi
movl $0x48, %edx
callq 0x2170
leaq -0x190(%rbp), %rdi
leaq 0x25b31(%rip), %rax     # 0x28a70
movq (%rax), %rcx
addq $0x100, %rcx            # imm = 0x100
leaq 0x25b20(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl 0x198(%rax), %r8d
leaq 0x25b0f(%rip), %rax     # 0x28a70
movq (%rax), %r9
addq $0x158, %r9             # imm = 0x158
leaq 0x25afe(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl 0x19c(%rax), %eax
movl $0x190, %esi            # imm = 0x190
leaq 0x17221(%rip), %rdx     # 0x1a1a8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2390
leaq -0x190(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x20c0
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/bounty.c
// Function: check_bounty
void check_bounty (struct Message *msg) {
    int pindex = get_pindex(msg->sender_nick);
    char out[MAX_MESSAGE_BUFFER];
    if (strcmp(dawn->gbounty.name, dawn->global_monster.name) == 0) {
        dawn->players[pindex].bounty++;
        snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :%s has taken down one more %s, %d to go until they win the bounty!\r\n",
                dawn->active_room, msg->sender_nick, dawn->gbounty.name, (dawn->gbounty.amount - dawn->players[pindex].bounty));
        add_msg(out, strlen(out));
        if (dawn->players[pindex].bounty == dawn->gbounty.amount) collect_bounty(pindex);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13ba0
movl %eax, -0xc(%rbp)
leaq 0x25a7e(%rip), %rax     # 0x28a70
movq (%rax), %rdi
addq $0x158, %rdi            # imm = 0x158
leaq 0x25a6d(%rip), %rax     # 0x28a70
movq (%rax), %rsi
addq $0xf2e00, %rsi          # imm = 0xF2E00
callq 0x22d0
cmpl $0x0, %eax
jne 0x3129
leaq 0x25a4e(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0xc(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movl 0x25f4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x25f4(%rax)
leaq -0x1a0(%rbp), %rdi
leaq 0x25a1a(%rip), %rax     # 0x28a70
movq (%rax), %rcx
addq $0x100, %rcx            # imm = 0x100
movq -0x8(%rbp), %r8
leaq 0x25a05(%rip), %rax     # 0x28a70
movq (%rax), %r9
addq $0x158, %r9             # imm = 0x158
leaq 0x259f4(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl 0x198(%rax), %eax
leaq 0x259e4(%rip), %rdx     # 0x28a70
movq (%rdx), %rdx
addq $0x1a0, %rdx            # imm = 0x1A0
movslq -0xc(%rbp), %rsi
imulq $0x26a8, %rsi, %rsi     # imm = 0x26A8
addq %rsi, %rdx
subl 0x25f4(%rdx), %eax
movl $0x190, %esi            # imm = 0x190
leaq 0x17127(%rip), %rdx     # 0x1a1dd
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2390
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x20c0
movq -0x1a8(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
leaq 0x25980(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0xc(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movl 0x25f4(%rax), %eax
leaq 0x2595c(%rip), %rcx     # 0x28a70
movq (%rcx), %rcx
cmpl 0x198(%rcx), %eax
jne 0x3127
movl -0xc(%rbp), %edi
callq 0x3140
jmp 0x3129
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/cmdsys.c
// Function: init_cmd_sys
CmdSys init_cmd_sys() {
    struct cmd_sys * ccs;
    CALLEXIT(!(ccs = calloc(1, sizeof *ccs)))
    ccs->flags = CMD_INITIALIZED;
    return ccs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x40, %esi
callq 0x2110
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x3397
leaq 0x16f14(%rip), %rdi     # 0x1a29c
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x8(%rbp), %rax
movq $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/cmdsys.c
// Function: free_cmd_sys
void free_cmd_sys(CmdSys cs) {
    struct cmd_sys * ccs = cs ? cs : commands;
    assert(ccs);

    free(ccs->hashes);

    //free allocated character strings
    for(size_t i = 0; i < ccs->len; i++) {
        free(ccs->cmds[i]);
        free(ccs->helptexts[i]);
    }

    free(ccs->cmds);
    free(ccs->helptexts);
    free(ccs->auth_levels);
    free(ccs->fn);

    free(ccs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x33cd
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x33d8
movq 0x22e94(%rip), %rax     # 0x26268
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x33e9
jmp 0x3408
leaq 0x16ef0(%rip), %rdi     # 0x1a2e0
leaq 0x16eed(%rip), %rsi     # 0x1a2e4
movl $0x1a, %edx
leaq 0x16eee(%rip), %rcx     # 0x1a2f1
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2240
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3462
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x341d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x30(%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/cmdsys.c
// Function: trim_arrays
void trim_arrays(CmdSys cs) {
    struct cmd_sys * ccs = cs;
    assert(ccs);
    assert(ccs->len != 0);
    ccs->hashes = realloc(ccs->hashes, ccs->capacity * sizeof *ccs->hashes);
    ccs->cmds = realloc(ccs->cmds, ccs->capacity * sizeof *ccs->cmds);
    ccs->helptexts = realloc(ccs->helptexts, ccs->capacity * sizeof *ccs->helptexts);
    ccs->auth_levels = realloc(ccs->auth_levels, ccs->capacity * sizeof *ccs->auth_levels);
    ccs->fn = realloc(ccs->fn, ccs->capacity * sizeof *ccs->fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x382d
jmp 0x384c
leaq 0x16aac(%rip), %rdi     # 0x1a2e0
leaq 0x16aa9(%rip), %rsi     # 0x1a2e4
movl $0xfa, %edx
leaq 0x17269(%rip), %rcx     # 0x1aab0
callq 0x2100
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3858
jmp 0x3877
leaq 0x1726a(%rip), %rdi     # 0x1aac9
leaq 0x16a7e(%rip), %rsi     # 0x1a2e4
movl $0xfb, %edx
leaq 0x1723e(%rip), %rcx     # 0x1aab0
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x2, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/cmdsys.c
// Function: hash_code
uint64_t hash_code(char * str) {
    uint64_t hash = 1;
    uint64_t const prime = 13835058055282163729ull;
    size_t len = strlen(str);
    for(size_t i = 0; i < len; i++) {
        hash += hash * 31 + (unsigned char)(str[i]);
        hash %= prime;
    }
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movabsq $-0x3fffffffffffffef, %rax # imm = 0xC000000000000011
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x39c2
imulq $0x1f, -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movabsq $-0x3fffffffffffffef, %rcx # imm = 0xC000000000000011
xorl %edx, %edx
divq %rcx
movq %rdx, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3977
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/cmdsys.c
// Function: finalize_cmd_sys
void finalize_cmd_sys(CmdSys cs) {
    struct cmd_sys * ccs = cs ? cs : commands;
    assert(ccs);

    ccs->capacity = ccs->len;
    trim_arrays(ccs);

    sort_cmd_sys(ccs);
    ccs->flags = CMD_FINALIZED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x39ed
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x39f8
movq 0x22874(%rip), %rax     # 0x26268
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a09
jmp 0x3a28
leaq 0x168d0(%rip), %rdi     # 0x1a2e0
leaq 0x168cd(%rip), %rsi     # 0x1a2e4
movl $0x53, %edx
leaq 0x16bb7(%rip), %rcx     # 0x1a5da
callq 0x2100
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3810
movq -0x10(%rbp), %rdi
callq 0x3a60
movq -0x10(%rbp), %rax
movq $0x4, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/combat.c
// Function: monster_attacks
void monster_attacks(struct Message *message, int player_defense, int pindex) {
    int monster_attack = rand() % dawn->global_monster.str;
    char out[MAX_MESSAGE_BUFFER];

    if (monster_attack > 0 && (monster_attack - player_defense) > 0 && dawn->players[pindex].alive) {
        dawn->players[pindex].health -= monster_attack;
        sprintf(out, "PRIVMSG %s :The %s attacks %s viciously for %d damage! (Remaining: %ld)\r\n",
                message->receiver, dawn->global_monster.name, message->sender_nick,
                monster_attack, dawn->players[pindex].health);
        add_msg(out, strlen(out));
        check_alive(message);
    } else {
        if (dawn->global_monster.hp > 0) {
            sprintf(out, "PRIVMSG %s :%s has blocked the %s's attack!\r\n",
                    message->receiver, message->sender_nick, dawn->global_monster.name);
            add_msg(out, strlen(out));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x2080
leaq 0x2383f(%rip), %rcx     # 0x28a70
movq (%rcx), %rcx
cltd
idivl 0xf2e4c(%rcx)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x534b
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x534b
leaq 0x23812(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x10(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
cmpl $0x0, 0x2660(%rax)
je 0x534b
movslq -0x14(%rbp), %rdx
leaq 0x237e3(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x10(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movq 0x2650(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x2650(%rax)
leaq -0x1b0(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0xc0, %rdx
leaq 0x237a2(%rip), %rax     # 0x28a70
movq (%rax), %rcx
addq $0xf2e00, %rcx          # imm = 0xF2E00
movq -0x8(%rbp), %r8
movl -0x14(%rbp), %r9d
leaq 0x23789(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x10(%rbp), %rsi
imulq $0x26a8, %rsi, %rsi     # imm = 0x26A8
addq %rsi, %rax
movq 0x2650(%rax), %rax
leaq 0x15a95(%rip), %rsi     # 0x1ada1
movq %rax, (%rsp)
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
movq -0x8(%rbp), %rdi
callq 0x4590
jmp 0x53be
leaq 0x2371e(%rip), %rax     # 0x28a70
movq (%rax), %rax
cmpl $0x0, 0xf2e40(%rax)
jle 0x53bc
leaq -0x1b0(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0xc0, %rdx
movq -0x8(%rbp), %rcx
leaq 0x236f5(%rip), %rax     # 0x28a70
movq (%rax), %r8
addq $0xf2e00, %r8           # imm = 0xF2E00
leaq 0x15a5f(%rip), %rsi     # 0x1adeb
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
jmp 0x53be
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/combat.c
// Function: calc_contribution
static void calc_contribution(int pindex, int amount, int monster_mhp, int monster_hp) {
    if (amount >= monster_mhp) {
        dawn->players[pindex].contribution = monster_mhp;
    } else {
        if (dawn->players[pindex].contribution + amount > monster_hp) {
            dawn->players[pindex].contribution += monster_hp;
        } else {
            dawn->players[pindex].contribution += amount;
        }
        if (dawn->players[pindex].contribution > monster_mhp) {
            dawn->players[pindex].contribution = monster_mhp;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x5414
movl -0xc(%rbp), %ecx
leaq 0x2367e(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
movl %ecx, 0x266c(%rax)
jmp 0x54ee
leaq 0x23655(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movl 0x266c(%rax), %eax
addl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x546f
movl -0x10(%rbp), %ecx
leaq 0x23626(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
addl 0x266c(%rax), %ecx
movl %ecx, 0x266c(%rax)
jmp 0x549c
movl -0x8(%rbp), %ecx
leaq 0x235f7(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
addl 0x266c(%rax), %ecx
movl %ecx, 0x266c(%rax)
leaq 0x235cd(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
movl 0x266c(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x54ec
movl -0xc(%rbp), %ecx
leaq 0x235a1(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
movl %ecx, 0x266c(%rax)
jmp 0x54ee
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_cry
void cmd_cry(int pindex __attribute__((unused)), struct Message * msg) {
    char * out;
    CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
    snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :You break down in tears\r\n", msg->receiver);
    add_msg(out, strlen(out));
    free(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5b59
leaq 0x167e6(%rip), %rdi     # 0x1c330
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
movl $0x190, %esi            # imm = 0x190
leaq 0x16807(%rip), %rdx     # 0x1c37b
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_new
void cmd_new(int pindex, struct Message * msg) {
    char * out;
    CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
    if(pindex == -1) {
        init_new_character(msg);
        snprintf(out, MAX_MESSAGE_BUFFER, "WHOIS %s\r\n", msg->sender_nick);
        add_msg(out, strlen(out));
    } else {
        sprintf(out, "PRIVMSG %s :You already have an account!\r\n", dawn->active_room);
        add_msg(out, strlen(out));
    }
    free(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x6029
leaq 0x158c9(%rip), %rdi     # 0x1b8e3
callq 0x2190
movl $0x1, %edi
callq 0x2260
cmpl $-0x1, -0x4(%rbp)
jne 0x6072
movq -0x10(%rbp), %rdi
callq 0x13cc0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x190, %esi            # imm = 0x190
leaq 0x158e2(%rip), %rdx     # 0x1b92e
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
jmp 0x60b2
movq -0x18(%rbp), %rdi
leaq 0x229f3(%rip), %rax     # 0x28a70
movq (%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq 0x158ab(%rip), %rsi     # 0x1b939
movb $0x0, %al
callq 0x2050
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_ap
void cmd_ap(int pindex, struct Message * msg) {
    char * out;
    CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
    snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :%s, you have %d attribute points which you can assign\r\n",
            msg->receiver, msg->sender_nick, dawn->players[pindex].attr_pts);
    add_msg(out, strlen(out));
    free(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x6109
leaq 0x16075(%rip), %rdi     # 0x1c16f
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
movq -0x10(%rbp), %r8
leaq 0x2294d(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
movl 0x2698(%rax), %r9d
movl $0x190, %esi            # imm = 0x190
leaq 0x1606d(%rip), %rdx     # 0x1c1ba
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_assign
void cmd_assign(int pindex, struct Message * msg) {
    if (matches_regex(msg->message, CMD_LIT" (\\w+) (\\d+)")) {
        assign_attr_points(msg, to_lower(regex_group[1]), atoi(regex_group[2]));
    } else {
        char * out;
        CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
        snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :To assign your attribute points, use \";assign <type> <amount>\"; type can be "
                "str, def, int or mdef. You have %d attribute points left which you can assign\r\n",
                msg->receiver, dawn->players[pindex].attr_pts);
        add_msg(out, strlen(out));
        free(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x15a4a(%rip), %rsi     # 0x1bbeb
callq 0x13090
cmpl $0x0, %eax
je 0x61f1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x21116(%rip), %rdi     # 0x272d0
addq $0x190, %rdi            # imm = 0x190
callq 0x12d60
movq %rax, -0x20(%rbp)
leaq 0x210ff(%rip), %rdi     # 0x272d0
addq $0x320, %rdi            # imm = 0x320
callq 0x2360
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0x14c30
jmp 0x6288
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x621b
leaq 0x15e70(%rip), %rdi     # 0x1c07c
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
leaq 0x2283f(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
movl 0x2698(%rax), %r8d
movl $0x190, %esi            # imm = 0x190
leaq 0x15e6c(%rip), %rdx     # 0x1c0c7
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_cheese
void cmd_cheese(int pindex, struct Message *msg) {
    char *out;
    CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))

    snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :%s, you currently have %d wedges of cheese\r\n", 
            msg->receiver, msg->sender_nick, dawn->players[pindex].cheese);
    add_msg(out, strlen(out));
    free(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x62e9
leaq 0x15fd2(%rip), %rdi     # 0x1c2ac
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
movq -0x10(%rbp), %r8
leaq 0x2276d(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x4(%rbp), %rdx
imulq $0x26a8, %rdx, %rdx     # imm = 0x26A8
addq %rdx, %rax
movl 0x269c(%rax), %r9d
movl $0x190, %esi            # imm = 0x190
leaq 0x15fca(%rip), %rdx     # 0x1c2f7
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_drop
void cmd_drop(int pindex __attribute__((unused)), struct Message * msg) {
    if (matches_regex(msg->message, CMD_LIT" (\\d+)")) {
        int slot = atoi(regex_group[1]);
        drop_item(msg, slot);
    } else if (matches_regex(msg->message, CMD_LIT" (\\w+)")) {
        if (strcmp(regex_group[1], "common") == 0) {
            puts("common match");
            int flag = 1;
            int pindex = get_pindex(msg->sender_nick);
            while (flag == 1) {
                puts("in while");
                flag = 0;
                for (int i=0; i<MAX_INVENTORY_SLOTS; i++) {
                    if (dawn->players[pindex].inventory[i].rarity == 1) {
                        flag = 1;
                        drop_item(msg, i);
                        puts("dropped\n");
                        puts("breaking");
                    }
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x15375(%rip), %rsi     # 0x1bc66
callq 0x13090
cmpl $0x0, %eax
je 0x6922
leaq 0x209ce(%rip), %rdi     # 0x272d0
addq $0x190, %rdi            # imm = 0x190
callq 0x2360
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xb050
jmp 0x6a2c
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x1507b(%rip), %rsi     # 0x1b9af
callq 0x13090
cmpl $0x0, %eax
je 0x6a2a
leaq 0x20987(%rip), %rdi     # 0x272d0
addq $0x190, %rdi            # imm = 0x190
leaq 0x15320(%rip), %rsi     # 0x1bc77
callq 0x22d0
cmpl $0x0, %eax
jne 0x6a28
leaq 0x15312(%rip), %rdi     # 0x1bc7e
callq 0x2330
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13ba0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x6a26
leaq 0x152f6(%rip), %rdi     # 0x1bc8b
callq 0x2330
movl $0x0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x19, -0x20(%rbp)
jge 0x6a21
leaq 0x220bb(%rip), %rax     # 0x28a70
movq (%rax), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movslq -0x1c(%rbp), %rcx
imulq $0x26a8, %rcx, %rcx     # imm = 0x26A8
addq %rcx, %rax
addq $0x190, %rax            # imm = 0x190
movslq -0x20(%rbp), %rcx
imulq $0x9c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x94(%rax)
jne 0x6a14
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xb050
leaq 0x15291(%rip), %rdi     # 0x1bc94
callq 0x2330
leaq 0x1528e(%rip), %rdi     # 0x1bc9d
callq 0x2330
jmp 0x6a16
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x69a8
jmp 0x6984
jmp 0x6a28
jmp 0x6a2a
jmp 0x6a2c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_ghunt
void cmd_ghunt (int pindex __attribute__((unused)), struct Message * msg) {
    if (dawn->global_monster.active) {
        char *out;
        CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
        snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :You must either kill the "
                "monster or use ;gslay!\r\n", msg->receiver);
        add_msg(out, strlen(out));
        free(out);
    } else {
        call_monster(msg->sender_nick, 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x21d1a(%rip), %rax     # 0x28a70
movq (%rax), %rax
cmpl $0x0, 0xf2e64(%rax)
je 0x6dd6
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x6d8c
leaq 0x156db(%rip), %rdi     # 0x1c458
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
movl $0x190, %esi            # imm = 0x190
leaq 0x156fc(%rip), %rdx     # 0x1c4a3
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
jmp 0x6de4
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x10780
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ziddykins[P]Dawn/src/commands.c
// Function: cmd_gslay
void cmd_gslay(int pindex __attribute__((unused)), struct Message * msg) {
    if(matches_regex(msg->message, CMD_LIT" (\\d+)")) {
        slay_monster(msg->sender_nick, 1, atoi(regex_group[1]));
    } else {
        char * out;
        CALLEXIT(!(out = malloc(MAX_MESSAGE_BUFFER)))
        snprintf(out, MAX_MESSAGE_BUFFER, "PRIVMSG %s :The %s will cost %d more gold to slay. Contribute to hiring a warrior "
                "with ;gslay <amount>\r\n", msg->receiver, dawn->global_monster.name,
                dawn->global_monster.slay_cost);
        add_msg(out, strlen(out));
        free(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq 0x14c45(%rip), %rsi     # 0x1bc66
callq 0x13090
cmpl $0x0, %eax
je 0x705b
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x20296(%rip), %rdi     # 0x272d0
addq $0x190, %rdi            # imm = 0x190
callq 0x2360
movq -0x20(%rbp), %rdi
movl %eax, %edx
movl $0x1, %esi
callq 0x11490
jmp 0x70ef
movl $0x190, %edi            # imm = 0x190
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x7085
leaq 0x14f52(%rip), %rdi     # 0x1bfc8
callq 0x2190
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0xc0, %rcx
leaq 0x219d5(%rip), %rax     # 0x28a70
movq (%rax), %r8
addq $0xf2e00, %r8           # imm = 0xF2E00
leaq 0x219c4(%rip), %rax     # 0x28a70
movq (%rax), %rax
movl 0xf2e68(%rax), %r9d
movl $0x190, %esi            # imm = 0x190
leaq 0x14f51(%rip), %rdx     # 0x1c013
movb $0x0, %al
callq 0x2390
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x12840
movq -0x18(%rbp), %rdi
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)