LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/msender.c
// Function: udp_csum
unsigned short
udp_csum(unsigned short *pseudo_header, unsigned short *buf, int nwords)
{
    unsigned long sum = 0;
	int  i = 0;

	for ( ; i < sizeof(pseudo_header_t)>>1; i++ )
		sum += *pseudo_header++;

    for ( ;nwords > 0; nwords--)
        sum += *buf++;

    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);

    return (unsigned short)~sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x6, %rax
jae 0x12dd
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movzwl (%rax), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12ae
jmp 0x12df
cmpl $0x0, -0x14(%rbp)
jle 0x130a
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x10(%rbp)
movzwl (%rax), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12df
movq -0x20(%rbp), %rax
shrq $0x10, %rax
movq -0x20(%rbp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x10, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
xorq $-0x1, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/msender.c
// Function: usage
void usage()
{
    printf("Usage: ./msender -s source -g group -p port -t ttl -l length -c count\n");
	printf(" -s source	the source ip\n");
	printf(" -g group	the group ip\n");
	printf(" -p port	the port\n");
	printf(" -t ttl		the ttl, default ttl is 1\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" -c count	the packet count, default count is unlimited\n");
    printf(" Version	%s\n",version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd01(%rip), %rdi       # 0x204c
movb $0x0, %al
callq 0x1060
leaq 0xd3a(%rip), %rdi       # 0x2093
movb $0x0, %al
callq 0x1060
leaq 0xd46(%rip), %rdi       # 0x20ad
movb $0x0, %al
callq 0x1060
leaq 0xd50(%rip), %rdi       # 0x20c5
movb $0x0, %al
callq 0x1060
leaq 0xd55(%rip), %rdi       # 0x20d8
movb $0x0, %al
callq 0x1060
leaq 0xd6b(%rip), %rdi       # 0x20fc
movb $0x0, %al
callq 0x1060
leaq 0xd98(%rip), %rdi       # 0x2137
movb $0x0, %al
callq 0x1060
leaq 0xdc2(%rip), %rdi       # 0x216f
leaq 0xdc8(%rip), %rsi       # 0x217c
movb $0x0, %al
callq 0x1060
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: count_keys
static
int count_keys(const char* str)
{
    int     keys    = 1;

    while (*str != '\0') {
        if (*str == TAB)
            keys++;
        str++;
    }

    return keys;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x100ae
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x100a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1007f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: get_polyaness
char* get_polyaness(const char* key, int record, polyaness_t** polyaness)
{
    if (polyaness == NULL   ||
            key == NULL     ||
            (*polyaness)->recs < record)
        return NULL;

    int     i       = 0,
            j       = 0;
    
    char*   match   = NULL,
        **  keys    = (*polyaness)->record[record]->key;

    j = (*polyaness)->record[record]->keys - 1;
    while (i < (*polyaness)->record[record]->keys && i <= j) {
        if (strcmp_lite(*(keys + i), key) == 0)
            return match = (*polyaness)->record[record]->value[i];
        if (strcmp_lite(*(keys + j), key) == 0)
            return match = (*polyaness)->record[record]->value[j];
        i++;
        j--;
    }

    return match;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x100ef
cmpq $0x0, -0x10(%rbp)
je 0x100ef
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x100fc
movq $0x0, -0x8(%rbp)
jmp 0x10224
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x39(%rbp)
jge 0x10173
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1017f
jmp 0x1021c
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x10230
cmpl $0x0, %eax
jne 0x101c2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x8(%rbp)
jmp 0x10224
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x10230
cmpl $0x0, %eax
jne 0x10205
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x8(%rbp)
jmp 0x10224
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10148
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: release_polyaness
void release_polyaness(polyaness_t* polyaness)
{
    if (polyaness == NULL)
        return;

    int     i   = 0,
            j   = 0;

    if (polyaness->record != NULL) {
        i = 0;
        j = polyaness->recs - 1;
        while (i <= j) {
            if (polyaness->record[i] != NULL)
                release_polyaness_cell(&polyaness->record[i]);
            if (polyaness->record[j] != NULL)
                release_polyaness_cell(&polyaness->record[j]);
            i++;
            j--;
        }
        free(polyaness->record);
    }

    free(polyaness);
    polyaness = NULL;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10338
jmp 0x103f8
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x103e7
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x103da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1039b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10400
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x103c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10368
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x8(%rbp), %rdi
callq 0x2170
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: concat_file_path
static 
int concat_file_path(STRING* path, yasuna_t* yasuna)
{
    int     status  = 0;

    if (yasuna->flag & YASUNA_FILE) {
        if (path->assign(&path, yasuna->farg) < 0) {
            status = -1; goto ERR;
        }
    } else {
#ifdef  WITH_MONO
        if (path->append(&path, DICNAME) < 0) {
            status = -2; goto ERR;
        }
#else
        if (path->assign(&path, DICPATH) < 0) {
            status = -3; goto ERR;
        }
        if (path->append(&path, DICNAME) < 0) {
            status = -4; goto ERR;
        }
/* WITH_MONO */
#endif
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1095b
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x10959
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x109a6
jmp 0x1099d
movq -0x10(%rbp), %rax
leaq -0x10(%rbp), %rdi
leaq 0x1ccf(%rip), %rsi      # 0x12639
callq *0x58(%rax)
cmpl $0x0, %eax
jge 0x1097b
movl $0xfffffffd, -0x1c(%rbp) # imm = 0xFFFFFFFD
jmp 0x109a6
movq -0x10(%rbp), %rax
leaq -0x10(%rbp), %rdi
leaq 0x1cc8(%rip), %rsi      # 0x12652
callq *0x68(%rax)
cmpl $0x0, %eax
jge 0x1099b
movl $0xfffffffc, -0x1c(%rbp) # imm = 0xFFFFFFFC
jmp 0x109a6
jmp 0x1099d
movl $0x0, -0x4(%rbp)
jmp 0x109ac
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: read_dict_file
int read_dict_file(FILE* fp, polyaness_t** pt)
{
    int     status  = 0;

    /* initialize libpolyaness */
    if (init_polyaness(fp, 0, pt) < 0) {
        status = -1; goto ERR;
    }

    /* no data */
    if ((*pt)->recs == 0) {
        status = -2; goto ERR;
    }

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stderr, "%s: init_polyaness() failure\n",
                    PROGNAME);
            break;
        case    -2:
            release_polyaness(*pt);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0xf840
cmpl $0x0, %eax
jge 0x109f4
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x10a12
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0x10a09
movl $0xfffffffe, -0x1c(%rbp) # imm = 0xFFFFFFFE
jmp 0x10a12
movl $0x0, -0x4(%rbp)
jmp 0x10a5c
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x2, %eax
je 0x10a4a
jmp 0x10a1f
movl -0x20(%rbp), %eax
subl $-0x1, %eax
jne 0x10a56
jmp 0x10a29
movq 0x55b0(%rip), %rax      # 0x15fe0
movq (%rax), %rdi
leaq 0x1b42(%rip), %rsi      # 0x1257c
leaq 0x17d9(%rip), %rdx      # 0x1221a
movb $0x0, %al
callq 0x23a0
jmp 0x10a56
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10320
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: create_rand
int create_rand(int lines)
{
    struct  timeval lo_timeval;

    /* get localtime */
    gettimeofday(&lo_timeval, NULL);

    /* 
     * # setting factor for pseudo-random number
     * current microseconds * PID
     */
    srand((unsigned)(
        lo_timeval.tv_usec * getpid()
    ));

    /* create pseudo-random number */
    return (int)(rand()%(lines+1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
imulq %rcx, %rax
movl %eax, %edi
callq 0x2310
callq 0x2390
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: search_all_quotes
int search_all_quotes(char* pattern, polyaness_t* pt, int flag)
{
#ifdef  WITH_REGEX
    int     cflags  = 0;

    /*
     * extended regular expression
     */
    if (flag & YASUNA_SEARCH_REGEX_IGNORE       ||
            flag & YASUNA_SEARCH_REGEX_EXTENDED ||
            flag & YASUNA_SEARCH_REGEX_BASIC) {
        /* POSIX extended regular expression */
        if (flag & YASUNA_SEARCH_REGEX_EXTENDED)
            cflags |= REG_EXTENDED;
        /* POSIX basic regular expression */
        if (flag & YASUNA_SEARCH_REGEX_BASIC)
            cflags &= ~REG_EXTENDED;
        /* ignore case distinctions */
        if (flag & YASUNA_SEARCH_REGEX_IGNORE)
            cflags |= REG_ICASE;

        return search_all_quotes_with_regexp_string(pattern, pt, cflags);
    }
/* WITH_REGEX */
#endif
    
    /* 
     * fixed string
     */
    return search_all_quotes_with_fixed_string(pattern, pt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x1115f
movl -0x1c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x1115f
movl -0x1c(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x111b4
movl -0x1c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x11173
movl -0x20(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x11189
movl -0x20(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x1119f
movl -0x20(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x111d0
movl %eax, -0x4(%rbp)
jmp 0x111c4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11330
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: search_all_quotes_with_regexp_string
static
int search_all_quotes_with_regexp_string(char* pattern, polyaness_t* pt, int cflags)
{
    int         i           = 0,
                status      = 0;

    short       match       = 0;

    char        errbuf[64]  = {'\0'},
        *       quote       = NULL;

    regex_t     reg;

    if ((status = regcomp(&reg, pattern, cflags | REG_NOSUB)) != 0)
        goto ERR;

    while (i < pt->recs) {
        quote = get_polyaness("quote", i, &pt);
        if (regexec(&reg, quote, 8, 0, 0) == 0) {
            match |= 1;
            fprintf(stdout, "%4d %s\n",
                    i, quote);
        }
        i++;
    }
    regfree(&reg);

    /* no match */
    if (match == 0)
        return -1;

    return 0;

ERR:
    regerror(status, &reg, errbuf, sizeof(errbuf));
    fprintf(stderr, "%s: regexec(): %s: %s\n",
            PROGNAME, pattern, errbuf);

    return -2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movw $0x0, -0x26(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2050
movq $0x0, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
orl $0x8, %edx
leaq -0xb8(%rbp), %rdi
callq 0x2290
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x11235
jmp 0x112d6
jmp 0x11237
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x112af
movl -0x20(%rbp), %esi
leaq 0x13e7(%rip), %rdi      # 0x12633
leaq -0x18(%rbp), %rdx
callq 0x100c0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x8, %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x2100
cmpl $0x0, %eax
jne 0x112a4
movswl -0x26(%rbp), %eax
orl $0x1, %eax
movw %ax, -0x26(%rbp)
movq 0x4d64(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movl -0x20(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq 0x138e(%rip), %rsi      # 0x1262b
movb $0x0, %al
callq 0x23a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x11237
leaq -0xb8(%rbp), %rdi
callq 0x2320
movswl -0x26(%rbp), %eax
cmpl $0x0, %eax
jne 0x112cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1131c
movl $0x0, -0x4(%rbp)
jmp 0x1131c
movl -0x24(%rbp), %edi
leaq -0x70(%rbp), %rdx
leaq -0xb8(%rbp), %rsi
movl $0x40, %ecx
callq 0x21f0
movq 0x4ceb(%rip), %rax      # 0x15fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
leaq -0x70(%rbp), %r8
leaq 0x1377(%rip), %rsi      # 0x1267e
leaq 0xf0c(%rip), %rdx       # 0x1221a
movb $0x0, %al
callq 0x23a0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: search_all_quotes_with_fixed_string
static
int search_all_quotes_with_fixed_string(char* pattern, polyaness_t* pt)
{
    int     i       = 0;

    short   match   = 0;

    char*   quote   = 0;

    while (i < pt->recs) {
        quote = get_polyaness("quote", i, &pt);
        if (strstr2(quote, pattern) != NULL) {
            match |= 1;
            fprintf(stdout, "%4d %s\n",
                    i, quote);
        }
        i++;
    }
    /* no match */
    if (match == 0)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movw $0x0, -0x1e(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x113bf
movl -0x1c(%rbp), %esi
leaq 0x12c9(%rip), %rdi      # 0x12633
leaq -0x18(%rbp), %rdx
callq 0x100c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x114a0
cmpq $0x0, %rax
je 0x113b4
movswl -0x1e(%rbp), %eax
orl $0x1, %eax
movw %ax, -0x1e(%rbp)
movq 0x4c54(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
leaq 0x127e(%rip), %rsi      # 0x1262b
movb $0x0, %al
callq 0x23a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11355
movswl -0x1e(%rbp), %eax
cmpl $0x0, %eax
jne 0x113d1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x113d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: print_all_quotes
void print_all_quotes(polyaness_t* pt, yasuna_t* yasuna)
{
    int     i   = 0;

    if (yasuna->flag & YASUNA_SPEAKER)
        fprintf(stdout, "*** speaker = %s, %d quotes ***\n",
                yasuna->sarg, pt->recs);

    while (i < pt->recs) {
        fprintf(stdout, "%4d %s\n",
                i, get_polyaness("quote", i, &pt));
        i++;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1143b
movq 0x4bd4(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x11d6(%rip), %rsi      # 0x1260a
movb $0x0, %al
callq 0x23a0
jmp 0x1143d
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x11492
movq 0x4ba1(%rip), %rax      # 0x15ff0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %esi
leaq 0x11cd(%rip), %rdi      # 0x12633
leaq -0x8(%rbp), %rdx
callq 0x100c0
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %edx
movq %rax, %rcx
leaq 0x11ab(%rip), %rsi      # 0x1262b
movb $0x0, %al
callq 0x23a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1143d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/subset.c
// Function: strstr2
static
char* strstr2(char* str1, char* str2)
{
    size_t  off     = 0;

    char*   p1      = str1,
        *   p2      = NULL;

    while (*p1 != '\0') {
        p2 = str2;
        while (*p1 == *p2 && *p2 != '\0') {
            p1++;
            p2++;
        }
        if (*p2 == '\0')
            return p1;
        p1 = str1 + (off++);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1155b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movq -0x30(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x11503
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1150c
jmp 0x11526
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x114dc
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1153c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11563
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x114c4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/yasuna.c
// Function: release
static
void release(FILE* fp, polyaness_t* pt)
{
    if (fp != NULL) {
        fclose(fp);
        fp = NULL;
    }
    if (pt != NULL)
        release_polyaness(pt);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11958
movq -0x8(%rbp), %rdi
callq 0x2340
movq $0x0, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11968
movq -0x10(%rbp), %rdi
callq 0x10320
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pencode-lab[P]Shoit/sendfile.c
// Function: open_data_source
static bool open_data_source(shoit_core_t *sender)
{

    sender->fromFd = -1;
    if(!sender->iStream){/*data source is file of disk*/

        if(!sender->fileName || access(sender->fileName,F_OK)==-1){
            fprintf(stderr,"The file does not exist <%s>\n",sender->fileName);
            return false;
        }

        struct stat filestat;
        if (stat(sender->fileName, &filestat) < 0) {
            fprintf(stderr,"stat error(%s).\n",strerror(errno));
            return false;
        }
        sender->fileSize = filestat.st_size;
        sender->fromFd = open(sender->fileName, O_RDONLY);
        if (sender->fromFd < 0) {
            fprintf(stderr,"open file failed(%s).\n",sender->fileName);
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1a4(%rax)
jne 0x2ab3
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x29c3
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
xorl %esi, %esi
callq 0x2390
cmpl $-0x1, %eax
jne 0x29f2
movq 0x962e(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
leaq 0x6716(%rip), %rsi      # 0x90f5
movb $0x0, %al
callq 0x2250
movl $0x0, -0x4(%rbp)
jmp 0x2aba
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jge 0x2a4c
movq 0x95e3(%rip), %rax      # 0xbff8
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2470
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
leaq 0x66d7(%rip), %rsi      # 0x9113
movb $0x0, %al
callq 0x2250
movl $0x0, -0x4(%rbp)
jmp 0x2aba
movq -0x70(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2380
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xf8(%rax)
jge 0x2ab1
movq 0x956c(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
leaq 0x6683(%rip), %rsi      # 0x9124
movb $0x0, %al
callq 0x2250
movl $0x0, -0x4(%rbp)
jmp 0x2aba
jmp 0x2ab3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: fact(int)
int fact(int n){
  int i;
  int factorial=1;
  for(i=1;i<=n;i++)
    factorial = factorial * i;
  return factorial;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x1282
movl -0xc(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1265
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: do_some_work()
void do_some_work ()
{
  int k = 1;
  while (1) {
    /* Do some useful things here...  */
    cout << "factorial(" << k << ") = " << fact(k) << "\n";
    if (k++ == MAX)
      throw ThreadExitException (/* thread's return value = */ NULL);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x1, -0x4(%rbp)
movq 0x2d32(%rip), %rdi      # 0x3fd8
leaq 0xd57(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x10d0
movq %rax, %rdi
leaq 0xd48(%rip), %rsi       # 0x200f
callq 0x1090
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x1250
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x10d0
movq %rax, %rdi
leaq 0xd27(%rip), %rsi       # 0x2014
callq 0x1090
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x5, %eax
jne 0x134c
movl $0x8, %edi
callq 0x1050
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1420
jmp 0x1321
movq -0x28(%rbp), %rdi
leaq 0x2a7c(%rip), %rsi      # 0x3da8
xorl %eax, %eax
movl %eax, %edx
callq 0x10c0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1060
jmp 0x1351
jmp 0x129f
movq -0x10(%rbp), %rdi
callq 0x10e0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: main
int main(){
	pthread_t thread_id;
	pthread_create(&thread_id, NULL, &thread_function, NULL);
	pthread_join(thread_id, NULL);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x9e(%rip), %rdx       # 0x1360
movq %rcx, %rsi
callq 0x1100
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff_2_calcul
void	addr_diff_2_calcul(int i, int cmp, int inst_pos, int *count)
{
	if (i == cmp && *count == 0)
		*count = -1;
	else if (i == inst_pos && *count == 0)
		*count = 1;
	if (i == inst_pos && *count == -1)
		*count = 0;
	else if (i == cmp && *count == 1)
		*count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x11be
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11be
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x11db
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x11d9
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11d9
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x11db
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x11f8
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x11f8
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1215
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x1213
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1213
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1215
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff_2
int		addr_diff_2(t_data *data, int cmp, int inst_pos, int i)
{
	int			count;
	int			diff;
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;

	count = 0;
	diff = 0;
	tmp_lbl = data->label;
	while (tmp_lbl)
	{
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			addr_diff_2_calcul(i, cmp, inst_pos, &count);
			if (count != 0)
				diff += 1 + get_params_size_ocp(tmp_inst);
			i++;
			tmp_inst = tmp_inst->next;
		}
		tmp_lbl = tmp_lbl->next;
	}
	return (diff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12b6
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x12a9
movl -0x14(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x18(%rbp), %rcx
callq 0x1190
cmpl $0x0, -0x18(%rbp)
je 0x1293
movq -0x30(%rbp), %rdi
callq 0x28a0
addl $0x1, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1262
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x124f
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff
int		addr_diff(t_data *data, char *lbl_name, int inst_pos)
{
	int			i;
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;

	i = 0;
	tmp_lbl = data->label;
	while (tmp_lbl)
	{
		if (ft_strcmp(tmp_lbl->name, lbl_name) == 0)
			break ;
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			i++;
			tmp_inst = tmp_inst->next;
		}
		tmp_lbl = tmp_lbl->next;
	}
	return (addr_diff_2(data, i, inst_pos, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x133b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ce0
cmpl $0x0, %eax
jne 0x1305
jmp 0x133b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x132e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1311
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12e6
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x1220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/asm.c
// Function: init_data
void	init_data(t_data *data)
{
	data->filename = NULL;
	data->name = NULL;
	data->comment = NULL;
	data->cor = NULL;
	data->cor_len = 0;
	data->label = NULL;
	data->line = 1;
	data->prog_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/asm.c
// Function: free_data
void	free_data(t_data *data)
{
	free(data->filename);
	free(data->name);
	free(data->comment);
	free(data->cor);
	free_inst_lbl(data->label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3f80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/asm.c
// Function: usage
void	usage(int argc, char *argv[])
{
	if (argc != 1)
		return ;
	ft_putstr("Usage : ");
	ft_putstr(argv[0]);
	ft_putendl(" [-v|-l|-b] <sourcefile.s>");
	ft_putendl("\t-v : verbose mode, write data and program in hexadecimal.");
	ft_printf("\t-l : live coding mode, you can write %s",
											"directly your s file manualy.\n");
	ft_printf("\t-b : binary mode, return your binary file %s",
													"in standard output.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
je 0x1447
jmp 0x14a1
leaq 0x8bb6(%rip), %rdi      # 0xa004
callq 0x64d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x64d0
leaq 0x8ba7(%rip), %rdi      # 0xa00d
callq 0x6510
leaq 0x8bb6(%rip), %rdi      # 0xa028
callq 0x6510
leaq 0x8be5(%rip), %rdi      # 0xa063
leaq 0x8c07(%rip), %rsi      # 0xa08c
movb $0x0, %al
callq 0x6ba0
leaq 0x8c18(%rip), %rdi      # 0xa0ab
leaq 0x8c3f(%rip), %rsi      # 0xa0d9
movb $0x0, %al
callq 0x6ba0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/asm.c
// Function: run
void	run(t_data *data, char *filename)
{
	init_data(data);
	if (filename != NULL)
	{
		set_filename(data, filename);
		data->fd = open(filename, O_RDONLY);
	}
	else
		live_coding_mode(data, filename);
	if (data->fd < 0)
		error("Open fail");
	parser(data);
	build(data);
	write_header(data);
	write_file(data);
	free_data(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1360
cmpq $0x0, -0x10(%rbp)
je 0x14f5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2270
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1070
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1502
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ec0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x1518
leaq 0x8bdb(%rip), %rdi      # 0xa0ee
callq 0x2580
movq -0x8(%rbp), %rdi
callq 0x4ca0
movq -0x8(%rbp), %rdi
callq 0x16a0
movq -0x8(%rbp), %rdi
callq 0x59f0
movq -0x8(%rbp), %rdi
callq 0x2410
movq -0x8(%rbp), %rdi
callq 0x13d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/asm.c
// Function: main
int		main(int argc, char *argv[])
{
	t_data	data;
	int		i;

	essential_char_in_label_chars();
	i = 1;
	data.verbose = 0;
	data.binary = 0;
	while (i < argc)
	{
		if (ft_strcmp(argv[i], "-v") == 0 && ++i > 0)
			data.verbose = 1;
		if (ft_strcmp(argv[i], "-b") == 0 && ++i > 0)
			data.binary = 1;
		if (ft_strcmp(argv[i], "-b") == 0 || ft_strcmp(argv[i], "-v") == 0)
			continue ;
		if (ft_strcmp(argv[i], "-l") == 0)
			run(&data, NULL);
		else
			run(&data, argv[i]);
		i++;
	}
	usage(argc, argv);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x35c0
movl $0x1, -0x6c(%rbp)
movl $0x0, -0x68(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x167e
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8b59(%rip), %rsi      # 0xa0f8
callq 0x5ce0
cmpl $0x0, %eax
jne 0x15be
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
jle 0x15be
movl $0x1, -0x68(%rbp)
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8b2a(%rip), %rsi      # 0xa0fb
callq 0x5ce0
cmpl $0x0, %eax
jne 0x15f0
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
jle 0x15f0
movl $0x1, -0x64(%rbp)
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8af8(%rip), %rsi      # 0xa0fb
callq 0x5ce0
cmpl $0x0, %eax
je 0x162a
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8ad8(%rip), %rsi      # 0xa0f8
callq 0x5ce0
cmpl $0x0, %eax
jne 0x162f
jmp 0x1580
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8abc(%rip), %rsi      # 0xa0fe
callq 0x5ce0
cmpl $0x0, %eax
jne 0x165b
leaq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14b0
jmp 0x1670
movq -0x10(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x68(%rbp), %rdi
callq 0x14b0
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1580
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1430
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/build.c
// Function: build
void	build(t_data *data)
{
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;
	int			inst_pos;

	tmp_lbl = data->label;
	inst_pos = 0;
	while (tmp_lbl)
	{
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			add_to_prog(data, ((unsigned char *)(&tmp_inst->opcode))[0]);
			if (tmp_inst->ocp > 0)
				add_to_prog(data, ((unsigned char *)(&tmp_inst->ocp))[0]);
			add_param_to_prog(data, tmp_inst, tmp_lbl->name, inst_pos);
			tmp_inst = tmp_inst->next;
			inst_pos++;
		}
		tmp_lbl = tmp_lbl->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1743
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1733
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %esi
callq 0x4d70
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x1705
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x38(%rax), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1750
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16d2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x16bf
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/build.c
// Function: add_param_to_prog
void	add_param_to_prog(t_data *data, t_instruc *inst, char *lbl_name,
															int inst_pos)
{
	int		ind;

	ind = 0;
	if (ft_strcmp(inst->name, "sti") == 0 ||
			ft_strcmp(inst->name, "lldi") == 0 ||
			ft_strcmp(inst->name, "ldi") == 0)
		ind = 1;
	if (inst->param_1 != NULL)
	{
		if (inst->ocp == -4)
			set_live(data, inst->param_1, lbl_name, inst_pos);
		else if (inst->ocp == -2)
			set_special(data, inst->param_1, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 0) == 1)
			set_register(data, inst->param_1);
		else if (ind == 0 && get_ocp(inst->ocp, 0) == 2)
			set_direct(data, inst->param_1, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 0) == 3)
			set_indirect(data, inst->param_1, lbl_name, inst_pos);
		else if (ind == 1)
			set_address(data, inst->param_1, lbl_name, inst_pos);
	}
	add_param_to_prog_2(data, inst, lbl_name, inst_pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8984(%rip), %rsi      # 0xa101
callq 0x5ce0
cmpl $0x0, %eax
je 0x17b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x896f(%rip), %rsi      # 0xa105
callq 0x5ce0
cmpl $0x0, %eax
je 0x17b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8957(%rip), %rsi      # 0xa106
callq 0x5ce0
cmpl $0x0, %eax
jne 0x17c0
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x18d0
movq -0x10(%rbp), %rax
cmpl $-0x4, 0x38(%rax)
jne 0x17f6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x53c0
jmp 0x18ce
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x38(%rax)
jne 0x181d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x54b0
jmp 0x18cc
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
xorl %esi, %esi
callq 0x26e0
cmpl $0x1, %eax
jne 0x1846
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x52d0
jmp 0x18ca
cmpl $0x0, -0x20(%rbp)
jne 0x1879
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
xorl %esi, %esi
callq 0x26e0
cmpl $0x2, %eax
jne 0x1879
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5130
jmp 0x18c8
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
xorl %esi, %esi
callq 0x26e0
cmpl $0x3, %eax
jne 0x18a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5220
jmp 0x18c6
cmpl $0x1, -0x20(%rbp)
jne 0x18c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5310
jmp 0x18c6
jmp 0x18c8
jmp 0x18ca
jmp 0x18cc
jmp 0x18ce
jmp 0x18d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1a30
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/build.c
// Function: add_param_to_prog_3
void	add_param_to_prog_3(t_data *data, t_instruc *inst, char *lbl_name,
		int inst_pos)
{
	int		ind;

	ind = 0;
	if (ft_strcmp(inst->name, "sti") == 0 ||
			ft_strcmp(inst->name, "lldi") == 0 ||
			ft_strcmp(inst->name, "ldi") == 0)
		ind = 1;
	if (inst->param_3 != NULL)
	{
		if (get_ocp(inst->ocp, 2) == 1)
			set_register(data, inst->param_3);
		else if (ind == 0 && get_ocp(inst->ocp, 2) == 2)
			set_direct(data, inst->param_3, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 2) == 3)
			set_indirect(data, inst->param_3, lbl_name, inst_pos);
		else if (ind == 1)
			set_address(data, inst->param_3, lbl_name, inst_pos);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x87e4(%rip), %rsi      # 0xa101
callq 0x5ce0
cmpl $0x0, %eax
je 0x1959
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x87cf(%rip), %rsi      # 0xa105
callq 0x5ce0
cmpl $0x0, %eax
je 0x1959
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x87b7(%rip), %rsi      # 0xa106
callq 0x5ce0
cmpl $0x0, %eax
jne 0x1960
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1a27
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x2, %esi
callq 0x26e0
cmpl $0x1, %eax
jne 0x199b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x52d0
jmp 0x1a25
cmpl $0x0, -0x20(%rbp)
jne 0x19d1
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x2, %esi
callq 0x26e0
cmpl $0x2, %eax
jne 0x19d1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5130
jmp 0x1a23
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x2, %esi
callq 0x26e0
cmpl $0x3, %eax
jne 0x1a01
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5220
jmp 0x1a21
cmpl $0x1, -0x20(%rbp)
jne 0x1a1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5310
jmp 0x1a21
jmp 0x1a23
jmp 0x1a25
jmp 0x1a27
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/build.c
// Function: add_param_to_prog_2
void	add_param_to_prog_2(t_data *data, t_instruc *inst, char *lbl_name,
															int inst_pos)
{
	int		ind;

	ind = 0;
	if (ft_strcmp(inst->name, "sti") == 0 ||
			ft_strcmp(inst->name, "lldi") == 0 ||
			ft_strcmp(inst->name, "ldi") == 0)
		ind = 1;
	if (inst->param_2 != NULL)
	{
		if (get_ocp(inst->ocp, 1) == 1)
			set_register(data, inst->param_2);
		else if (ind == 0 && get_ocp(inst->ocp, 1) == 2)
			set_direct(data, inst->param_2, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 1) == 3)
			set_indirect(data, inst->param_2, lbl_name, inst_pos);
		else if (ind == 1)
			set_address(data, inst->param_2, lbl_name, inst_pos);
	}
	add_param_to_prog_3(data, inst, lbl_name, inst_pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x86a4(%rip), %rsi      # 0xa101
callq 0x5ce0
cmpl $0x0, %eax
je 0x1a99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x868f(%rip), %rsi      # 0xa105
callq 0x5ce0
cmpl $0x0, %eax
je 0x1a99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8677(%rip), %rsi      # 0xa106
callq 0x5ce0
cmpl $0x0, %eax
jne 0x1aa0
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1b67
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x1, %esi
callq 0x26e0
cmpl $0x1, %eax
jne 0x1adb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x52d0
jmp 0x1b65
cmpl $0x0, -0x20(%rbp)
jne 0x1b11
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x1, %esi
callq 0x26e0
cmpl $0x2, %eax
jne 0x1b11
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5130
jmp 0x1b63
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x1, %esi
callq 0x26e0
cmpl $0x3, %eax
jne 0x1b41
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5220
jmp 0x1b61
cmpl $0x1, -0x20(%rbp)
jne 0x1b5f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5310
jmp 0x1b61
jmp 0x1b63
jmp 0x1b65
jmp 0x1b67
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x18f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/build.c
// Function: label_exist
int		label_exist(t_data *data, char *param_name, char *lbl_name)
{
	t_label		*tmp_lbl;
	int			position;

	tmp_lbl = data->label;
	position = -1;
	while (tmp_lbl)
	{
		if (ft_strcmp(param_name, tmp_lbl->name) == 0)
			return (position);
		if (ft_strcmp(lbl_name, tmp_lbl->name) == 0)
			position = 1;
		tmp_lbl = tmp_lbl->next;
	}
	error_str(NULL, "Label name doesn't exist : ", param_name);
	return (-999999999);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x28(%rbp)
je 0x1c06
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5ce0
cmpl $0x0, %eax
jne 0x1bdc
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c21
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5ce0
cmpl $0x0, %eax
jne 0x1bf9
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1bb7
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x84f5(%rip), %rsi      # 0xa10a
callq 0x25b0
movl $0xc4653601, -0x4(%rbp) # imm = 0xC4653601
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)