LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: gsumln
static double gsumln(double a, double b)
{
/* ----------------------------------------------------------------------- */
/*          EVALUATION OF THE FUNCTION LN(GAMMA(A + B)) */
/*          FOR 1 <= A <= 2  AND  1 <= B <= 2 */
/* ----------------------------------------------------------------------- */

    double x = a + b - 2.;/* in [0, 2] */

    if (x <= 0.25)
    return gamln1(x + 1.);

    /* else */
    if (x <= 1.25)
    return gamln1(x) + alnrel(x);
    /* else x > 1.25 : */
    return gamln1(x - 1.) + log(x * (x + 1.));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0x985c(%rip), %xmm1     # 0x311c0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xaec3(%rip), %xmm0     # 0x32838
ucomisd -0x20(%rbp), %xmm0
jb 0x27998
movsd 0x9c74(%rip), %xmm0     # 0x315f8
addsd -0x20(%rbp), %xmm0
callq 0x268c0
movsd %xmm0, -0x8(%rbp)
jmp 0x27a1a
movsd 0xb118(%rip), %xmm0     # 0x32ab8
ucomisd -0x20(%rbp), %xmm0
jb 0x279d3
movsd -0x20(%rbp), %xmm0
callq 0x268c0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x25fc0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x27a1a
movsd -0x20(%rbp), %xmm0
movsd 0x9c18(%rip), %xmm1     # 0x315f8
subsd %xmm1, %xmm0
callq 0x268c0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x9bfd(%rip), %xmm1     # 0x315f8
addsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x2250
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/enzyme.c
// Function: re_cuts_init
re_cuts_t *re_cuts_init(uint32_t n)
{
    re_cuts_t *re_cuts = (re_cuts_t *) malloc(sizeof(re_cuts_t));
    re_cuts->n = n;
    re_cuts->density = 0;
    re_cuts->re = (re_t *) malloc(n * sizeof(re_t));
    uint32_t i;
    for (i = 0; i < n; ++i)
        re_cuts->re[i].sites = 0;
    return re_cuts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x2340
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x4(%rbp), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x2340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x2972b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x296fe
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/enzyme.c
// Function: re_cuts_destroy
void re_cuts_destroy(re_cuts_t *re_cuts)
{
    if (!re_cuts) return;
    uint32_t i;
    for (i = 0; i < re_cuts->n; ++i)
        if (re_cuts->re[i].sites)
            free(re_cuts->re[i].sites);
    free(re_cuts->re);
    free(re_cuts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x29755
jmp 0x297be
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x297a8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x2979b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2050
jmp 0x2979d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2975c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/enzyme.c
// Function: bin_search
static uint32_t bin_search(uint32_t *a, uint32_t n, uint32_t s)
{
    uint32_t low, high, mid;
    low = 0;
    high = n;
    while (low != high) {
        mid = (low >> 1) + (high >> 1);
        if (a[mid] < s)
            low = mid + 1;
        else
            high = mid;
    }
    return low;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x2a374
movl -0x14(%rbp), %eax
shrl %eax
movl -0x18(%rbp), %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jae 0x2a36c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a372
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2a33b
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/telo.c
// Function: check_motif
int check_motif(char *motif)
{
	int i, c, n;

	if (motif == NULL)
		return 0;

	n = strlen(motif);
	for (i = 0; i < n; i++) {
		c = seq_nt6_table[(uint8_t) motif[i]];
		if (c < 1 || c > 4)
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2a8ac
movl $0x0, -0x4(%rbp)
jmp 0x2a90c
movq -0x10(%rbp), %rdi
callq 0x2160
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2a905
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xf224(%rip), %rax      # 0x39b00
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jl 0x2a8ef
cmpl $0x4, -0x18(%rbp)
jle 0x2a8f8
movl $0x1, -0x4(%rbp)
jmp 0x2a90c
jmp 0x2a8fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a8bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/telo.c
// Function: list_telo_motifs
void list_telo_motifs(FILE *fo)
{
	int i, ntelo;
	ntelo = sizeof(telo_motif_db) / sizeof(char *);
	for (i = 0; i < ntelo; i++)
		fprintf(fo, "[%2d] %s\n", i+1, telo_motif_db[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x17, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2a974
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq -0xc(%rbp), %rcx
leaq 0xf0e9(%rip), %rax      # 0x39a40
movq (%rax,%rcx,8), %rcx
leaq 0x8358(%rip), %rsi      # 0x32cba
movb $0x0, %al
callq 0x22c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a93a
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/yahs.c
// Function: scaffold_error_break
int scaffold_error_break(char *fai, char *link_file, uint32_t ml, uint8_t mq, char *agp, int flank_size, double noise, char *out)
{
    int dist_thres;
    sdict_t *sdict = make_sdict_from_index(fai, ml);
    asm_dict_t *dict = make_asm_dict_from_agp(sdict, agp, 1);

    dist_thres = flank_size * 2;
    //dist_thres = estimate_dist_thres_from_file(link_file, dict, ec_min_frac, ec_resolution);
    //dist_thres = MAX(dist_thres, ec_min_window);
    //fprintf(stderr, "[I::%s] dist threshold for scaffold error break: %d\n", __func__, dist_thres);
    link_mat_t *link_mat = link_mat_from_file(link_file, dict, dist_thres, ec_bin, noise, ec_move_avg, mq);

#ifdef DEBUG_ERROR_BREAK
    fprintf(stderr, "[DEBUG_ERROR_BREAK::%s] link matrix\n", __func__);
    print_link_mat(link_mat, dict, stderr);
#endif

    uint32_t bp_n = 0;
    bp_t *breaks = detect_break_points_local_joint(link_mat, ec_bin, ec_fold_thresh, flank_size, dict, &bp_n);
#ifdef DEBUG
    fprintf(stderr, "[DEBUG::%s] number scaffold breaks: %u\n", __func__, bp_n);
#endif

    FILE *agp_out = fopen(out, "w");
    write_break_agp(dict, breaks, bp_n, agp_out);
    fclose(agp_out);
    link_mat_destroy(link_mat);
    asm_destroy(dict);
    sd_destroy(sdict);
    int i;
    for (i = 0; i < bp_n; ++i)
        free(breaks[i].p);
    free(breaks);
    
    return bp_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17660
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x18560
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x34(%rbp), %edx
movl 0xd3d0(%rip), %ecx      # 0x39c18
movsd -0x30(%rbp), %xmm0
movl 0xd570(%rip), %r8d      # 0x39dc4
movzbl -0x15(%rbp), %r9d
callq 0x4aa0
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x50(%rbp), %rdi
movl 0xd3a5(%rip), %esi      # 0x39c18
movsd 0xd3a5(%rip), %xmm0     # 0x39c20
movl -0x24(%rbp), %edx
movq -0x48(%rbp), %rcx
leaq -0x54(%rbp), %r8
callq 0x52e0
movq %rax, -0x60(%rbp)
movq 0x10(%rbp), %rdi
leaq 0x4776(%rip), %rsi      # 0x31010
callq 0x23f0
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl -0x54(%rbp), %edx
movq -0x68(%rbp), %rcx
callq 0x6380
movq -0x68(%rbp), %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
callq 0x4680
movq -0x48(%rbp), %rdi
callq 0x16780
movq -0x40(%rbp), %rdi
callq 0x16650
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x54(%rbp), %eax
jae 0x2c90d
movq -0x60(%rbp), %rax
movslq -0x6c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2050
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x2c8e2
movq -0x60(%rbp), %rdi
callq 0x2050
movl -0x54(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/yahs.c
// Function: print_asm_stats
static void print_asm_stats(uint64_t *n_stats, uint32_t *l_stats, int all)
{
#ifdef DEBUG
    int i;
    fprintf(stderr, "[I::%s] assembly stats:\n", __func__);
    for (i = 0; i < 10; ++i)
        fprintf(stderr, "[I::%s] N%d: %lu (n = %u)\n", __func__, (i + 1) * 10, n_stats[i], l_stats[i]);
#else
    fprintf(stderr, "[I::%s] assembly stats:\n", __func__);
    fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 50, n_stats[4], l_stats[4]);
    fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 90, n_stats[8], l_stats[8]);
    if (all)
        fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 100, n_stats[9], l_stats[9]);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0xbdde(%rip), %rax      # 0x38ff8
movq (%rax), %rdi
leaq 0x68c7(%rip), %rsi      # 0x33aeb
leaq 0x68d9(%rip), %rdx      # 0x33b04
movb $0x0, %al
callq 0x22c0
movq 0xbdbf(%rip), %rax      # 0x38ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r9d
leaq 0x68c1(%rip), %rsi      # 0x33b14
leaq 0x68aa(%rip), %rdx      # 0x33b04
movl $0x32, %ecx
movb $0x0, %al
callq 0x22c0
movq 0xbd8b(%rip), %rax      # 0x38ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r9d
leaq 0x688d(%rip), %rsi      # 0x33b14
leaq 0x6876(%rip), %rdx      # 0x33b04
movl $0x5a, %ecx
movb $0x0, %al
callq 0x22c0
cmpl $0x0, -0x14(%rbp)
je 0x2d2d4
movq 0xbd51(%rip), %rax      # 0x38ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r9d
leaq 0x6853(%rip), %rsi      # 0x33b14
leaq 0x683c(%rip), %rdx      # 0x33b04
movl $0x64, %ecx
movb $0x0, %al
callq 0x22c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: fill_buffer
int _fill_buffer(FILE *file_p)
{
  int buffer_size;

  if (file_p->flag._READ == 0 || file_p->flag._EOF == 1 || file_p->flag._ERR == 1)
  {
    return EOF;
  }

  buffer_size = (file_p->flag._UNBUF == 1) ? 1 : BUFFER_SIZE;

  if (file_p->base == NULL)
  {
    if ((file_p->base = (char *)malloc(buffer_size)) == NULL)
    {
      return EOF;
    }
  }

  file_p->next_char_pos_p = file_p->base;
  file_p->counter = read(file_p->file_descriptor, file_p->next_char_pos_p, buffer_size);

  if (--file_p->counter < 0)
  {
    if (file_p->counter == -1)
    {
      file_p->flag._EOF = 1;
    }
    else
    {
      file_p->flag._ERR = 1;
    }

    file_p->counter = 0;
    return EOF;
  }

  return (unsigned char)*file_p->next_char_pos_p++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x11fb
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x4, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
je 0x11fb
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x3, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x1207
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f1
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x5, %al
sarb $0x7, %al
movsbl %al, %edx
movl $0x400, %eax            # imm = 0x400
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x125a
movslq -0x14(%rbp), %rdi
callq 0x1080
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x1258
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f1
jmp 0x125a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1070
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x12d8
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x12b5
movq -0x10(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x18(%rax)
jmp 0x12c5
movq -0x10(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f1
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: flush_buffer
int _flush_buffer(int c, FILE *file_p)
{
  int buffer_size;

  if (file_p->flag._WRITE == 0 || file_p->flag._ERR == 1)
  {
    return EOF;
  }

  buffer_size = (file_p->flag._UNBUF == 1) ? 1 : BUFFER_SIZE;

  if (file_p->base == NULL)
  {
    if ((file_p->base = (char *)malloc(buffer_size)) == NULL)
    {
      return EOF;
    }
  }
  else
  {
    unsigned long nr_of_bytes = file_p->next_char_pos_p - file_p->base;
    if ((write(file_p->file_descriptor, file_p->base, nr_of_bytes)) != nr_of_bytes)
    {
      file_p->flag._ERR = 1;
      return EOF;
    }
  }

  file_p->next_char_pos_p = file_p->base;
  *file_p->next_char_pos_p++ = c;
  file_p->counter = buffer_size - 1;

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1339
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x3, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x1345
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1424
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x5, %al
sarb $0x7, %al
movsbl %al, %edx
movl $0x400, %eax            # imm = 0x400
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1398
movslq -0x14(%rbp), %rdi
callq 0x1080
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x1396
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1424
jmp 0x13e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1040
cmpq -0x20(%rbp), %rax
je 0x13e6
movq -0x10(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1424
jmp 0x13e8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %cl, (%rax)
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: file_flush
int file_flush(FILE *file_p)
{
  if (file_p->flag._WRITE == 0)
  {
    file_p->flag._ERR = 1;
    return EOF;
  }

  if (_flush_buffer('0', file_p) == EOF)
  {
    return EOF;
  }

  file_p->next_char_pos_p = file_p->base;
  file_p->counter = (file_p->flag._UNBUF == 1) ? 1 : BUFFER_SIZE;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x146a
movq -0x10(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14c3
movq -0x10(%rbp), %rsi
movl $0x30, %edi
callq 0x1300
cmpl $-0x1, %eax
jne 0x1486
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14c3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x5, %al
sarb $0x7, %al
movsbl %al, %edx
movl $0x400, %ecx            # imm = 0x400
movl $0x1, %eax
cmpl $0x1, %edx
cmovel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: file_close
int file_close(FILE *file_p)
{
  if (file_p->flag._WRITE == 1 && file_flush(file_p) == EOF)
  {
    return EOF;
  }

  free(file_p->base);
  file_p->next_char_pos_p = NULL;
  file_p->base = NULL;
  file_p->counter = 0;
  close(file_p->file_descriptor);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x16f8
movq -0x10(%rbp), %rdi
callq 0x1430
cmpl $-0x1, %eax
jne 0x16f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x173a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: file_seek
int file_seek(FILE *file_p, long offset, int whence)
{
  if (file_p->flag._UNBUF == 0)
  {
    if (file_p->flag._READ == 1)
    {
      file_p->counter = 0;
      file_p->next_char_pos_p = file_p->base;
    }
    else if (file_p->flag._WRITE == 1)
    {
      file_flush(file_p);
    }
  }

  return (lseek(file_p->file_descriptor, offset, whence) < 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x5, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x17cb
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x17a9
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x17c9
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x17c7
movq -0x8(%rbp), %rdi
callq 0x1430
jmp 0x17c9
jmp 0x17cb
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1050
cmpq $0x0, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: main
int main(void)
{
  FILE *file_in_p;
  FILE *file_out_p;

  if ((file_in_p = file_open("syscalls.c", "r")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  if ((file_out_p = file_open("out.txt", "w")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  if (file_seek(file_in_p, 5, SEEK_SET) == -1)
  {
    return EXIT_FAILURE;
  }

  char c;
  while ((c = getc(file_in_p)) != EOF)
  {
    putc(c, file_out_p);
  }
  file_close(file_in_p);
  file_close(file_out_p);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x7fe(%rip), %rdi       # 0x2004
leaq 0x802(%rip), %rsi       # 0x200f
callq 0x14d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x183e
movl $0x1, %edi
leaq 0x7e9(%rip), %rsi       # 0x2011
movl $0x21, %edx
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x193d
leaq 0x7ed(%rip), %rdi       # 0x2032
leaq 0x7ee(%rip), %rsi       # 0x203a
callq 0x14d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x187d
movl $0x1, %edi
leaq 0x7aa(%rip), %rsi       # 0x2011
movl $0x21, %edx
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x193d
movq -0x10(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x1750
cmpl $-0x1, %eax
jne 0x189e
movl $0x1, -0x4(%rbp)
jmp 0x193d
jmp 0x18a0
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jl 0x18cb
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x18d7
movq -0x10(%rbp), %rdi
callq 0x11b0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1924
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jl 0x1912
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %al, (%rcx)
movsbl %al, %eax
jmp 0x191f
movsbl -0x19(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1300
jmp 0x18a0
movq -0x10(%rbp), %rdi
callq 0x16c0
movq -0x18(%rbp), %rdi
callq 0x16c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/main_checker.c
// Function: checker
void	checker(t_lists *lists, t_list *commands, int ac)
{
	if (ft_read_command(commands) == -1)
		exit_failure(lists, commands);
	use_commands(commands, lists);
	check_sort(ac, lists);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c90
cmpl $-0x1, %eax
jne 0x42ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1240
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1c20
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2010
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/main_checker.c
// Function: main
int		main(int ac, char **av)
{
	int		i;
	t_lists lists;
	t_list	*commands;

	i = 1;
	init_list(&lists);
	commands = ft_lstnew(NULL);
	if (ac < 2)
		exit_success(&lists, commands);
	else
	{
		while (i < ac)
		{
			if (parsing_ac(av[i]) == -1)
				exit_failure(&lists, commands);
			if (check_existant(av, i) == 1)
				exit_failure(&lists, commands);
			if (is_an_int(av[i]) == -1)
				exit_failure(&lists, commands);
			ft_lstadd_back(&lists.list_a, fill_list_a(av[i]));
			i++;
		}
	}
	checker(&lists, commands, ac);
	exit_success(&lists, commands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12c0
xorl %eax, %eax
movl %eax, %edi
callq 0x43f0
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x431b
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1290
jmp 0x43c2
jmp 0x431d
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x43c0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x13c0
cmpl $-0x1, %eax
jne 0x434c
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1240
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12f0
cmpl $0x1, %eax
jne 0x436a
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1240
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1460
cmpl $-0x1, %eax
jne 0x438d
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1240
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4520
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x431d
jmp 0x43c2
movq -0x30(%rbp), %rsi
movl -0x8(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x4280
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1290
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void *content)
{
	t_list	*new;

	if (!(new = malloc(sizeof(t_list))))
		return (NULL);
	new->content = content;
	new->next = NULL;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x441a
movq $0x0, -0x8(%rbp)
jmp 0x4439
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_lstadd_front.c
// Function: ft_lstadd_front
void	ft_lstadd_front(t_list **alst, t_list *new)
{
	if (!alst[0])
	{
		alst[0] = new;
		return ;
	}
	if (!new)
		return ;
	new->next = alst[0];
	alst[0] = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4473
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4496
cmpq $0x0, -0x10(%rbp)
jne 0x447c
jmp 0x4496
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_lstsize.c
// Function: ft_lstsize
int		ft_lstsize(t_list *lst)
{
	int			len;
	t_list		*list;

	len = 0;
	list = lst;
	while (list)
	{
		len++;
		list = list->next;
	}
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x44d5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x44b7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_lstlast.c
// Function: ft_lstlast
t_list		*ft_lstlast(t_list *lst)
{
	if (lst)
		while (lst->next)
			lst = lst->next;
	return (lst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x450c
jmp 0x44f1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x450a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x44f1
jmp 0x450c
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_lstadd_back.c
// Function: ft_lstadd_back
void	ft_lstadd_back(t_list **alst, t_list *new)
{
	t_list		*last;

	if (!new)
		return ;
	if (!*alst)
	{
		*alst = new;
		return ;
	}
	last = ft_lstlast(*alst);
	last->next = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4539
jmp 0x456c
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4550
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x456c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x44e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t	j;

	j = 0;
	while (s[j])
	{
		j++;
	}
	return (j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x45ac
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4590
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t	i;

	i = 0;
	while ((s1[i] || s2[i]) && i < n)
	{
		if (s1[i] != s2[i])
			return ((unsigned char)s1[i] - (unsigned char)s2[i]);
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x45ff
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x460d
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4616
jmp 0x4662
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4651
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4669
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x45d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_atoi.c
// Function: ft_atoi
long int		ft_atoi(const char *str)
{
	long int		i;
	long int		neg;
	long int		res;

	i = 0;
	res = 0;
	neg = 1;
	while (str[i] == '\t' || str[i] == '\v' || str[i] == '\n'
			|| str[i] == '\f' || str[i] == '\r' || str[i] == ' ')
		i++;
	if (str[i] == '+' || str[i] == '-')
	{
		if (str[i] == '-')
			neg = -neg;
		i++;
	}
	while (str[i] >= '0' && str[i] <= '9')
	{
		res = res * 10 + str[i] - '0';
		i++;
	}
	return (res * neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x21(%rbp)
je 0x4713
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x21(%rbp)
je 0x4713
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x4713
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x21(%rbp)
je 0x4713
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x21(%rbp)
je 0x4713
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x471c
jmp 0x472d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4690
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x474f
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x4776
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x476a
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4778
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x22(%rbp)
jl 0x47a3
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x47ac
jmp 0x47d7
imulq $0xa, -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
subq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4778
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char			*str;
	unsigned int	i;

	i = 0;
	if (!(str = malloc(sizeof(char) * (ft_strlen(s1) + 1))))
		return (NULL);
	while (s1[i])
	{
		str[i] = s1[i];
		i++;
	}
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4580
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4830
movq $0x0, -0x8(%rbp)
jmp 0x4871
jmp 0x4832
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x485e
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4832
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
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/WalterLuong[P]push_swap/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int		i;

	i = 0;
	while (s1[i] || s2[i])
	{
		if (s1[i] != s2[i])
			return (s1[i] - s2[i]);
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
jne 0x48be
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x48c7
jmp 0x490d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4902
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4914
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4893
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/unit_test.c
// Function: run_program
int _run_program(const char *filename) {
	printf("%c[%dm%s%c[%dm\n", 0x1B, 32, filename, 0x1B, 0);
	char *buf = NULL;
	size_t buf_siz = 0;

	buf = lair_load_file(filename, &buf_siz);
	int rc = lair_execute(buf, buf_siz);
	if (rc != 0) {
		lair_unload_file(buf, buf_siz);
		return 1;
	}

	lair_unload_file(buf, buf_siz);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x4d3d(%rip), %rdi      # 0x6004
movl $0x1b, %r8d
movl $0x20, %edx
xorl %r9d, %r9d
movl %r8d, %esi
movb $0x0, %al
callq 0x1080
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5a30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b20
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x132c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5c00
movl $0x1, -0x4(%rbp)
jmp 0x1340
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5c00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/upload-reset/upload-reset.c
// Function: openserial
int openserial(char *devicename) 
{
     struct termios attr;

     if ((fd = open(devicename, O_RDWR)) == -1) return 0; /* Error */ 
     atexit(closeserial);

     if (tcgetattr(fd, &oldterminfo) == -1) return 0; /* Error */
     attr = oldterminfo;
     attr.c_cflag |= CRTSCTS | CLOCAL;
     attr.c_oflag = 0;
     if (tcflush(fd, TCIOFLUSH) == -1) return 0; /* Error */
     if (tcsetattr(fd, TCSANOW, &attr) == -1) return 0; /* Error */ 

     /* Set the lines to a known state, and */
     /* finally return non-zero is successful. */
     return setRTS(0) && setDTR(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x10c0
movl %eax, 0x2e42(%rip)      # 0x4094
cmpl $-0x1, %eax
jne 0x1263
movl $0x0, -0x4(%rbp)
jmp 0x1324
leaq -0x6a(%rip), %rdi       # 0x1200
callq 0x1570
movl 0x2e1f(%rip), %edi      # 0x4094
leaq 0x2e1c(%rip), %rsi      # 0x4098
callq 0x1090
cmpl $-0x1, %eax
jne 0x1292
movl $0x0, -0x4(%rbp)
jmp 0x1324
leaq -0x4c(%rbp), %rdi
leaq 0x2dfb(%rip), %rsi      # 0x4098
movl $0x3c, %edx
callq 0x1080
movl -0x44(%rbp), %eax
orl $0x80000800, %eax       # imm = 0x80000800
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl 0x2dd5(%rip), %edi      # 0x4094
movl $0x2, %esi
callq 0x1040
cmpl $-0x1, %eax
jne 0x12d7
movl $0x0, -0x4(%rbp)
jmp 0x1324
movl 0x2db7(%rip), %edi      # 0x4094
xorl %esi, %esi
leaq -0x4c(%rbp), %rdx
callq 0x10a0
cmpl $-0x1, %eax
jne 0x12f6
movl $0x0, -0x4(%rbp)
jmp 0x1324
xorl %edi, %edi
callq 0x1330
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x4d(%rbp)
je 0x1319
xorl %edi, %edi
callq 0x13d0
cmpl $0x0, %eax
setne %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/upload-reset/upload-reset.c
// Function: setRTS
int setRTS(unsigned short level)
{
     int status;

     if (ioctl(fd, TIOCMGET, &status) == -1) {
	  perror("setRTS(): TIOCMGET");
	  return 0;
     }
     if (level) status |= TIOCM_RTS;
     else status &= ~TIOCM_RTS;
     if (ioctl(fd, TIOCMSET, &status) == -1) {
	  perror("setRTS(): TIOCMSET");
	  return 0;
     }
     return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movl 0x2d4f(%rip), %edi      # 0x4094
movl $0x5415, %esi           # imm = 0x5415
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1060
cmpl $-0x1, %eax
jne 0x136f
leaq 0xca3(%rip), %rdi       # 0x2004
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x13c1
cmpw $0x0, -0x6(%rbp)
je 0x1381
movl -0xc(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x138a
movl -0xc(%rbp), %eax
andl $-0x5, %eax
movl %eax, -0xc(%rbp)
movl 0x2d04(%rip), %edi      # 0x4094
movl $0x5418, %esi           # imm = 0x5418
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1060
cmpl $-0x1, %eax
jne 0x13ba
leaq 0xc6b(%rip), %rdi       # 0x2017
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x13c1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/upload-reset/upload-reset.c
// Function: setDTR
int setDTR(unsigned short level)
{
     int status;

     if (ioctl(fd, TIOCMGET, &status) == -1) {
	  perror("setDTR(): TIOCMGET");
	  return 0;
     }
     if (level) status |= TIOCM_DTR;
     else status &= ~TIOCM_DTR;
     if (ioctl(fd, TIOCMSET, &status) == -1) {
	  perror("setDTR: TIOCMSET");
	  return 0;
     }
     return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movl 0x2caf(%rip), %edi      # 0x4094
movl $0x5415, %esi           # imm = 0x5415
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1060
cmpl $-0x1, %eax
jne 0x140f
leaq 0xc29(%rip), %rdi       # 0x202a
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x1461
cmpw $0x0, -0x6(%rbp)
je 0x1421
movl -0xc(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x142a
movl -0xc(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0xc(%rbp)
movl 0x2c64(%rip), %edi      # 0x4094
movl $0x5418, %esi           # imm = 0x5418
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1060
cmpl $-0x1, %eax
jne 0x145a
leaq 0xbf1(%rip), %rdi       # 0x203d
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x1461
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/upload-reset/upload-reset.c
// Function: main
int main(int argc, char *argv[])
{
 	
	if (argc<2 || argc >3)
	{
		printf("Usage upload-reset <serial_device> <Optional_delay_in_milliseconds>\n\r");
		return 0;
	}

 	if (openserial(argv[1]))
	{
		// Send magic sequence of DTR and RTS followed by the magic word "1EAF"
		setRTS(false);
 		setDTR(false);
 		setDTR(true);

		usleep(50000L);

		setDTR(false);
		setRTS(true);
		setDTR(true);

		usleep(50000L);

		setDTR(false);

		usleep(50000L);

		write(fd,"1EAF",4);
 		
		closeserial();
		if (argc==3)
		{
			usleep(atol(argv[2])*1000L);
		}
	}
	else
	{
		printf("Failed to open serial device.\n\r");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x1492
cmpl $0x3, -0x8(%rbp)
jle 0x14ac
leaq 0xbb5(%rip), %rdi       # 0x204e
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
jmp 0x1567
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1230
cmpl $0x0, %eax
je 0x1559
xorl %edi, %edi
callq 0x1330
xorl %edi, %edi
callq 0x13d0
movl $0x1, %edi
callq 0x13d0
movl $0xc350, %edi           # imm = 0xC350
callq 0x10f0
xorl %edi, %edi
callq 0x13d0
movl $0x1, %edi
callq 0x1330
movl $0x1, %edi
callq 0x13d0
movl $0xc350, %edi           # imm = 0xC350
callq 0x10f0
xorl %edi, %edi
callq 0x13d0
movl $0xc350, %edi           # imm = 0xC350
callq 0x10f0
movl 0x2b74(%rip), %edi      # 0x4094
leaq 0xb6d(%rip), %rsi       # 0x2094
movl $0x4, %edx
callq 0x1030
callq 0x1200
cmpl $0x3, -0x8(%rbp)
jne 0x1557
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10b0
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movl %eax, %edi
callq 0x10f0
jmp 0x1567
leaq 0xb39(%rip), %rdi       # 0x2099
movb $0x0, %al
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_06/ungetc.c
// Function: main
int main(void)
{
	FILE *fp;
	int i;
	char c;

	/* Open a file for writing */
	fp = fopen("file.txt", "r");
	if (!fp) {
		perror("fopen");
		return -1;
	}

	/* Start reading first three bytes */
	for (i = 0; i < 3; i++) {
		c = fgetc(fp);
		if (ferror(fp) || feof(fp)) {
			fprintf(stderr, "cannot read\n");
			return -1;
		}
		printf("\ngot '%c'", c);
	}

	/* Do the unread */
	if (ungetc('x', fp) == EOF) {
		fprintf(stderr, "cannot unread\n");
		return -1;
	}
	printf(" but unread 'x'\n");

	/* Now continue reading the whole file */
	while (1) {
		c = fgetc(fp);
		if (ferror(fp)) {
			fprintf(stderr, "cannot read\n");
			return -1;
		}
		if (feof(fp))
			break;
		printf("got '%c'\n", c);
	}

	fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe2e(%rip), %rdi       # 0x2004
leaq 0xe30(%rip), %rsi       # 0x200d
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1205
leaq 0xe1b(%rip), %rdi       # 0x200f
callq 0x10b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132c
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x127b
movq -0x10(%rbp), %rdi
callq 0x1060
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
jne 0x123a
movq -0x10(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x125e
movq 0x2db7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdca(%rip), %rsi       # 0x2015
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132c
movsbl -0x15(%rbp), %esi
leaq 0xdb9(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x120c
movq -0x10(%rbp), %rsi
movl $0x78, %edi
callq 0x1090
cmpl $-0x1, %eax
jne 0x12af
movq 0x2d63(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd8d(%rip), %rsi       # 0x202c
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132c
leaq 0xd85(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1060
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
je 0x12f8
movq 0x2d1a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd2d(%rip), %rsi       # 0x2015
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132c
movq -0x10(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x1308
jmp 0x131c
movsbl -0x15(%rbp), %esi
leaq 0xd39(%rip), %rdi       # 0x204c
movb $0x0, %al
callq 0x1050
jmp 0x12bd
movq -0x10(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq