LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/yahs.c
// Function: find_aseq_telos
int8_t *find_aseq_telos(asm_dict_t *dict, int8_t *telo_ends)
{   
    int i, n;
    int8_t *telos;
    sdict_t *sdict;
    sd_aseq_t *aseq;
    sd_seg_t *segs, *seg;
    
    sdict = dict->sdict;
    n = dict->n;
    telos = (int8_t *) calloc(dict->n * 2, sizeof(int8_t));

    segs = dict->seg;
    for (i = 0; i < n; i++) {
        aseq = &dict->s[i];
        // first seg
        seg = &segs[aseq->s];
        if ((telo_ends[seg->c>>1<<1] && seg->x <= MAX_TELO_CLIP && (seg->c&1) == 0) ||
            (telo_ends[seg->c>>1<<1|1] && (seg->x + seg->y + MAX_TELO_CLIP) >= sdict->s[seg->c>>1].len && (seg->c&1) == 1))
            telos[i<<1] = 1;
        // last seg
        seg = &segs[aseq->s + aseq->n - 1];
        if ((telo_ends[seg->c>>1<<1] && seg->x <= MAX_TELO_CLIP && (seg->c&1) == 1) ||
            (telo_ends[seg->c>>1<<1|1] && (seg->x + seg->y + MAX_TELO_CLIP) >= sdict->s[seg->c>>1].len && (seg->c&1) == 0))
            telos[i<<1|1] = 1;
    }

    return telos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
movl (%rdi), %r12d
leal (%r12,%r12), %edi
pushq $0x1
popq %rsi
callq 0x2290
movq 0x20(%r14), %rcx
xorl %edx, %edx
testl %r12d, %r12d
cmovlel %edx, %r12d
addl %r12d, %r12d
pushq $0xe
popq %rsi
cmpq %rdx, %r12
je 0x1a7f6
movq 0x8(%r14), %r8
movl (%r8,%rsi,2), %edi
imulq $0x30, %rdi, %r9
leaq (%rcx,%r9), %r10
movl 0x18(%rcx,%r9), %r9d
movl %r9d, %r11d
andl $-0x2, %r11d
cmpb $0x0, (%rbx,%r11)
je 0x1a73d
testb $0x1, %r9b
jne 0x1a73d
cmpl $0x33, 0x1c(%r10)
jb 0x1a772
movq %r9, %r11
orq $0x1, %r11
cmpb $0x0, (%rbx,%r11)
je 0x1a77a
testb $0x1, %r9b
je 0x1a77a
shrl %r9d
movl 0x1c(%r10), %r11d
movl 0x20(%r10), %r10d
addl %r11d, %r10d
addl $0x32, %r10d
movq 0x8(%r15), %r11
imulq $0x18, %r9, %r9
cmpl 0x10(%r11,%r9), %r10d
jb 0x1a77a
movslq %edx, %r9
movb $0x1, (%rax,%r9)
movl -0x4(%r8,%rsi,2), %r8d
addl %r8d, %edi
decl %edi
imulq $0x30, %rdi, %rdi
leaq (%rcx,%rdi), %r8
movl 0x18(%rcx,%rdi), %edi
movl %edi, %r9d
andl $-0x2, %r9d
cmpb $0x0, (%rbx,%r9)
je 0x1a7ab
testb $0x1, %dil
je 0x1a7ab
cmpl $0x33, 0x1c(%r8)
jb 0x1a7df
movq %rdi, %r9
orq $0x1, %r9
cmpb $0x0, (%rbx,%r9)
je 0x1a7e9
testb $0x1, %dil
jne 0x1a7e9
shrl %edi
movl 0x1c(%r8), %r9d
movl 0x20(%r8), %r8d
addl %r9d, %r8d
addl $0x32, %r8d
movq 0x8(%r15), %r9
imulq $0x18, %rdi, %rdi
cmpl 0x10(%r9,%rdi), %r8d
jb 0x1a7e9
leal 0x1(%rdx), %edi
movslq %edi, %rdi
movb $0x1, (%rax,%rdi)
addq $0x2, %rdx
addq $0x2c, %rsi
jmp 0x1a704
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl %r9d, %r14d
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %r13
movq 0x50(%rsp), %r12
movl %edx, %esi
callq 0xeb03
movq %rax, 0x10(%rsp)
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0xf408
movq %rax, %r15
leal (%r14,%r14), %edx
xorl %ebx, %ebx
movq %r13, %rdi
movq %rax, %rsi
movl $0x3e8, %ecx            # imm = 0x3E8
movsd 0x8(%rsp), %xmm0
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x389b
movq %rax, %r13
leaq 0x4(%rsp), %rbp
andl $0x0, (%rbp)
movsd 0x48cf(%rip), %xmm0     # 0x1f820
movq %rax, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movl %r14d, %edx
movq %r15, %rcx
movq %rbp, %r8
callq 0x3d39
movq %rax, %r14
leaq 0x309f(%rip), %rsi      # 0x1e010
movq %r12, %rdi
callq 0x23e0
movq %rax, %r12
movl (%rbp), %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x4862
movq %r12, %rdi
callq 0x2150
movq %r13, %rdi
callq 0x35b6
movq %r15, %rdi
callq 0xe2a0
movq 0x10(%rsp), %rdi
callq 0xe20a
movq %r14, %r15
addq $0x10, %r15
movl 0x4(%rsp), %eax
cmpq %rax, %rbx
jae 0x1afd0
movq (%r15), %rdi
callq 0x2060
incq %rbx
addq $0x18, %r15
jmp 0x1afb6
movq %r14, %rdi
callq 0x2060
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xc906(%rip), %r12      # 0x27ff8
movq (%r12), %rdi
leaq 0x5a1e(%rip), %rsi      # 0x2111b
leaq 0x5a30(%rip), %r14      # 0x21134
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
movq (%r12), %rdi
movq 0xcf37(%rip), %r8       # 0x28650
movl 0xcf70(%rip), %r9d      # 0x28690
leaq 0x5a1d(%rip), %r15      # 0x21144
pushq $0x32
popq %rcx
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
movq (%r12), %rdi
movq 0xcf2e(%rip), %r8       # 0x28670
movl 0xcf57(%rip), %r9d      # 0x286a0
pushq $0x5a
popq %rcx
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
testl %ebx, %ebx
jne 0x1b769
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %rdi
movq 0xcf04(%rip), %r8       # 0x28678
movl 0xcf29(%rip), %r9d      # 0x286a4
leaq 0x59c2(%rip), %rsi      # 0x21144
leaq 0x59ab(%rip), %rdx      # 0x21134
pushq $0x64
popq %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/./agp-spec.h
// Function: agp_component_type_key
static inline const uint32_t agp_component_type_key(const char *val)
{
    uint32_t key = AGPSpec_hash(val);
    int c = 0;
    switch ((AGP_CT_t) key) {
        case AGP_CT_A: c = check_collision(val, "A"); break;
        case AGP_CT_D: c = check_collision(val, "D"); break;
        case AGP_CT_F: c = check_collision(val, "F"); break;
        case AGP_CT_G: c = check_collision(val, "G"); break;
        case AGP_CT_O: c = check_collision(val, "O"); break;
        case AGP_CT_P: c = check_collision(val, "P"); break;
        case AGP_CT_W: c = check_collision(val, "W"); break;
        case AGP_CT_N: c = check_collision(val, "N"); break;
        case AGP_CT_U: c = check_collision(val, "U"); break;
        default:       AGPSpec_die("[E::%s] AGP component type VAL error: %s\n", __func__, val);
    }
    if (c) AGPSpec_die("[E::%s] AGP component type VAL error (hash collision): %s\n", __func__, val);
    return key;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1d7d6
movl %eax, %r14d
leal -0x2b609(%r14), %eax
cmpl $0x13, %eax
ja 0x1d5fe
leaq 0x2e2c(%rip), %rcx      # 0x20418
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3412(%rip), %rsi      # 0x20a0e
jmp 0x1d64d
cmpl $0x2b606, %r14d         # imm = 0x2B606
jne 0x1d67c
leaq 0x1b06(%rip), %rsi      # 0x1f114
jmp 0x1d64d
leaq 0x1b05(%rip), %rsi      # 0x1f11c
jmp 0x1d64d
leaq 0x18aa(%rip), %rsi      # 0x1eeca
jmp 0x1d64d
leaq 0x1aed(%rip), %rsi      # 0x1f116
jmp 0x1d64d
leaq 0x33e4(%rip), %rsi      # 0x20a16
jmp 0x1d64d
leaq 0x1adf(%rip), %rsi      # 0x1f11a
jmp 0x1d64d
leaq 0x1ad4(%rip), %rsi      # 0x1f118
jmp 0x1d64d
leaq 0x2c2c(%rip), %rsi      # 0x20279
movq %rbx, %rdi
callq 0x1d800
testl %eax, %eax
jne 0x1d664
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1af4(%rip), %rdi      # 0x1f15f
leaq 0x1ad6(%rip), %rsi      # 0x1f148
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1d708
leaq 0x1a9b(%rip), %rdi      # 0x1f11e
jmp 0x1d66b
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testb $0x1, 0x18(%rdi)
je 0x1218
movq %rdi, %r14
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
jne 0x11db
movl $0x400, %edi            # imm = 0x400
callq 0x1080
movq %rax, %rsi
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1218
movq %rsi, 0x8(%r14)
movl 0x1c(%r14), %edi
movl $0x400, %edx            # imm = 0x400
callq 0x1070
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
testl %eax, %eax
jle 0x1208
movq 0x8(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r14)
movzbl (%rax), %ebx
jmp 0x1218
setne %al
shlb $0x3, %al
addb $0x8, %al
orb %al, 0x18(%r14)
andl $0x0, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %r14
testb $0x2, 0x18(%rsi)
je 0x128b
movq %rsi, %rbx
movl %edi, %ebp
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x125e
movq 0x8(%rbx), %r15
subq %rsi, %r15
movl 0x1c(%rbx), %edi
movq %r15, %rdx
callq 0x1040
cmpq %r15, %rax
jne 0x1287
movq 0x10(%rbx), %rax
jmp 0x1271
movl $0x400, %edi            # imm = 0x400
callq 0x1080
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x128b
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb %bpl, (%rax)
movl $0x3ff, (%rbx)          # imm = 0x3FF
movl %ebp, %r14d
jmp 0x128b
orb $0x10, 0x18(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movb 0x18(%rdi), %al
testb $0x2, %al
jne 0x12ab
orb $0x10, %al
movb %al, 0x18(%rbx)
jmp 0x12cd
pushq $0x30
popq %rdi
movq %rbx, %rsi
callq 0x1222
cmpl $-0x1, %eax
je 0x12cd
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0x400, (%rbx)          # imm = 0x400
xorl %eax, %eax
jmp 0x12d0
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_04/syscalls.c
// Function: file_open
FILE *file_open(char *name, char *mode)
{
  int file_descriptor;
  FILE *file_p;

  if (*mode != 'r' && *mode != 'w' && *mode != 'a')
  {
    return NULL;
  }

  for (file_p = _io_buffer; file_p < _io_buffer + MAX_NR_OF_OPEN_FILES; ++file_p)
  {
    if (file_p->flag._READ == 0 && file_p->flag._WRITE == 0)
    {
      break; // found free slot
    }
  }

  if (file_p >= _io_buffer + MAX_NR_OF_OPEN_FILES)
  {
    return NULL; // no free slots
  }

  if (*mode == 'w')
  {
    file_descriptor = creat(name, PERMISSIONS);
  }
  else if (*mode == 'a')
  {
    if ((file_descriptor = open(name, O_WRONLY, 0)) == -1)
    {
      file_descriptor = creat(name, PERMISSIONS);
    }
    lseek(file_descriptor, 0L, 2);
  }
  else
  {
    file_descriptor = open(name, O_RDONLY, 0);
  }

  if (file_descriptor == -1)
  {
    return NULL; // couldn't access name
  }

  file_p->file_descriptor = file_descriptor;
  file_p->counter = 0;
  file_p->base = NULL;
  file_p->flag._EOF = 0;
  file_p->flag._ERR = 0;
  file_p->flag._READ = (*mode == 'r') ? 1 : 0;
  file_p->flag._WRITE = (*mode == 'r') ? 0 : 1;

  return file_p;
}

// Assembly:
movzbl (%rsi), %ecx
xorl %eax, %eax
leal -0x61(%rcx), %edx
cmpl $0x16, %edx
ja 0x13cc
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl $0x420001, %esi         # imm = 0x420001
btl %edx, %esi
jae 0x13c4
movq %rdi, %r14
xorl %eax, %eax
leaq 0x2d68(%rip), %r15      # 0x4070
xorl %edx, %edx
cmpq $0x27f, %rdx            # imm = 0x27F
ja 0x13c4
leaq 0x20(%rdx), %r12
testb $0x3, 0x18(%rdx,%r15)
movq %r12, %rdx
jne 0x130a
cmpl $0x61, %ecx
je 0x133f
movq %r14, %rdi
cmpl $0x77, %ecx
jne 0x1372
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x10a0
jmp 0x137d
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1090
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x1364
movq %r14, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x10a0
movl %eax, %ebp
pushq $0x2
popq %rdx
movl %ebp, %edi
xorl %esi, %esi
callq 0x1050
jmp 0x137f
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1090
movl %eax, %ebp
cmpl $-0x1, %ebp
je 0x13c2
leaq (%r12,%r15), %rax
addq $-0x20, %rax
movl %ebp, 0x1c(%rax)
andl $0x0, (%rax)
andq $0x0, 0x10(%rax)
movb 0x18(%rax), %cl
movl %ecx, %edx
andb $-0x19, %dl
movb %dl, 0x18(%rax)
cmpb $0x72, (%rbx)
sete %dl
andb $-0x1a, %cl
orb %dl, %cl
movb %cl, 0x18(%rax)
cmpb $0x72, (%rbx)
setne %dl
addb %dl, %dl
andb $-0x1b, %cl
orb %dl, %cl
movb %cl, 0x18(%rax)
jmp 0x13c4
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0xbfa(%rip), %rdi       # 0x2004
leaq 0xbfe(%rip), %rsi       # 0x200f
callq 0x12d2
testq %rax, %rax
je 0x1497
movq %rax, %rbx
leaq 0xc0d(%rip), %rdi       # 0x2032
leaq 0xc0e(%rip), %rsi       # 0x203a
callq 0x12d2
testq %rax, %rax
je 0x1497
movq %rax, %r14
pushq $0x5
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13f0
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x1461
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
jmp 0x1469
movq %rbx, %rdi
callq 0x11ac
cmpb $-0x1, %al
je 0x14ad
movl (%r14), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%r14)
testl %ecx, %ecx
jle 0x148a
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %al, (%rcx)
jmp 0x1446
movsbl %al, %edi
movq %r14, %rsi
callq 0x1222
jmp 0x1446
leaq 0xb73(%rip), %rsi       # 0x2011
pushq $0x1
popq %rbx
pushq $0x21
popq %rdx
movl %ebx, %edi
callq 0x1040
jmp 0x14bf
movq %rbx, %rdi
callq 0x13cd
movq %r14, %rdi
callq 0x13cd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x16ed
cmpl $-0x1, %eax
jne 0x2d89
movq %r14, %rdi
movq %r15, %rsi
callq 0x1202
movq %r15, %rdi
movq %r14, %rsi
callq 0x16a4
movl %ebx, %edi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a28
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl %edi, %ebx
leaq 0x8(%rsp), %rdi
callq 0x1250
xorl %edi, %edi
callq 0x2e80
movq %rax, %r14
cmpl $0x2, %ebx
jge 0x2e0a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1242
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2d64
movq %r15, %rdi
movq %r14, %rsi
callq 0x1242
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %ebp
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r13
cmpq %r12, %rbp
je 0x2ddc
movq (%r15,%r12,8), %rdi
callq 0x12d0
cmpl $-0x1, %eax
jne 0x2e33
movq %r13, %rdi
movq %r14, %rsi
callq 0x1202
movq %r15, %rdi
movl %r12d, %esi
callq 0x1257
cmpl $0x1, %eax
jne 0x2e4e
movq %r13, %rdi
movq %r14, %rsi
callq 0x1202
movq (%r15,%r12,8), %rdi
callq 0x1300
cmpl $-0x1, %eax
jne 0x2e67
movq %r13, %rdi
movq %r14, %rsi
callq 0x1202
movq (%r15,%r12,8), %rdi
callq 0x1317
movq %r13, %rdi
movq %rax, %rsi
callq 0x2edc
incq %r12
jmp 0x2e15
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x2ed6
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2ec9
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x2f00
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2efc
movq %rax, %rdi
callq 0x2ec4
movq %rax, %rdi
addq $0x8, %rdi
movq %rbx, (%rdi)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x2f2d
cmpq %rdx, %rcx
jae 0x2f4e
movb (%rsi,%rcx), %r9b
jmp 0x2f3b
cmpq %rdx, %rcx
jae 0x2f4d
movb (%rsi,%rcx), %r9b
testb %r9b, %r9b
je 0x2f4d
incq %rcx
cmpb %r9b, %r8b
je 0x2f18
movzbl %r9b, %eax
subl %eax, %r8d
movl %r8d, %eax
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movabsq $0x100003e00, %rcx      # imm = 0x100003E00
movzbl (%rdi,%rax), %edx
cmpq $0x2d, %rdx
ja 0x2f9a
btq %rdx, %rcx
jae 0x2f75
incq %rax
jmp 0x2f60
movabsq $0x280000000000, %rcx   # imm = 0x280000000000
btq %rdx, %rcx
jae 0x2f9a
xorl %ecx, %ecx
cmpb $0x2d, %dl
setne %cl
leaq -0x1(,%rcx,2), %rcx
incq %rax
jmp 0x2f9d
pushq $0x1
popq %rcx
addq %rax, %rdi
xorl %eax, %eax
movzbl (%rdi), %edx
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x2fbe
imulq $0xa, %rax, %rax
addq %rdx, %rax
addq $-0x30, %rax
incq %rdi
jmp 0x2fa2
imulq %rcx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x2f04
leaq 0x1(%rax), %rdi
callq 0x1080
testq %rax, %rax
je 0x2ff1
xorl %ecx, %ecx
movl %ecx, %ecx
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x2fed
movb %dl, (%rax,%rcx)
incl %ecx
jmp 0x2fdd
movb $0x0, (%rax,%rcx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %edx, %edx
movsbl (%rdi,%rdx), %ecx
movb (%rsi,%rdx), %r8b
movl %ecx, %r9d
orb %r8b, %r9b
je 0x3018
incq %rdx
cmpb %r8b, %cl
je 0x2ff8
movsbl %r8b, %eax
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2d26(%rip), %rdi      # 0x4004
pushq $0x20
popq %rdx
pushq $0x1b
popq %rsi
movq %rbx, %rcx
movl %esi, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x10a0
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x386e
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3901
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3998
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x48, %rsp
xorl %ebx, %ebx
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x10b0
movl %eax, 0x2e61(%rip)      # 0x408c
cmpl $-0x1, %eax
je 0x12cf
leaq -0x4f(%rip), %rdi       # 0x11ec
callq 0x14c0
movl 0x2e46(%rip), %edi      # 0x408c
leaq 0x2e43(%rip), %rsi      # 0x4090
callq 0x1080
cmpl $-0x1, %eax
je 0x12cf
movups 0x2e32(%rip), %xmm0     # 0x4090
movaps %xmm0, -0x50(%rbp)
movups 0x2e53(%rip), %xmm0     # 0x40bc
movups %xmm0, -0x24(%rbp)
movups 0x2e3c(%rip), %xmm0     # 0x40b0
movaps %xmm0, -0x30(%rbp)
movups 0x2e21(%rip), %xmm0     # 0x40a0
movaps %xmm0, -0x40(%rbp)
orl $0x80000800, -0x48(%rbp) # imm = 0x80000800
andl $0x0, -0x4c(%rbp)
movl 0x2df8(%rip), %edi      # 0x408c
pushq $0x2
popq %rsi
callq 0x1040
cmpl $-0x1, %eax
je 0x12cf
movl 0x2de5(%rip), %edi      # 0x408c
xorl %ebx, %ebx
leaq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0x1090
cmpl $-0x1, %eax
je 0x12cf
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x12d8
testl %eax, %eax
je 0x12cf
xorl %edi, %edi
callq 0x1356
movl %eax, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
leal -0x4(%r14), %eax
cmpl $-0x3, %eax
ja 0x13f6
leaq 0xc5d(%rip), %rdi       # 0x204e
jmp 0x149d
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1210
testl %eax, %eax
je 0x1496
xorl %edi, %edi
callq 0x12d8
xorl %edi, %edi
callq 0x1356
pushq $0x1
popq %r15
movl %r15d, %edi
callq 0x1356
movl $0xc350, %edi           # imm = 0xC350
callq 0x10e0
xorl %edi, %edi
callq 0x1356
movl %r15d, %edi
callq 0x12d8
movl %r15d, %edi
callq 0x1356
movl $0xc350, %edi           # imm = 0xC350
callq 0x10e0
xorl %edi, %edi
callq 0x1356
movl $0xc350, %edi           # imm = 0xC350
callq 0x10e0
movl 0x2c26(%rip), %edi      # 0x408c
leaq 0xc27(%rip), %rsi       # 0x2094
pushq $0x4
popq %rdx
callq 0x1030
callq 0x11ec
cmpl $0x3, %r14d
jne 0x14a4
movq 0x10(%rbx), %rdi
callq 0x10a0
imull $0x3e8, %eax, %edi      # imm = 0x3E8
callq 0x10e0
jmp 0x14a4
leaq 0xbfc(%rip), %rdi       # 0x2099
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/X1319RAY[P]fileIO/geninput.cpp
// Function: main
int main(int argc, char* argv[]){
	using namespace std;
	
	random_device seed_gen; // 乱数のseedを生成
	mt19937 mt(seed_gen()); // メルセンヌ・ツイスターと呼ばれる乱数生成法
	
	ofstream out("input.txt", ios::out);
	
	uniform_int_distribution<> dista(1, 'a');
	out << "ant: " << dista(mt) << endl;
	
	uniform_int_distribution<> distb(1, 'b');
	out << "buffalo: " << distb(mt) << endl;
	
	uniform_int_distribution<> distc(1, 'c');
	out << "cat: " << distc(mt) << endl;
	
	uniform_int_distribution<> distd(1, 'd');
	out << "dog: " << distd(mt) << endl;
	
	out.close();
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2938, %rsp           # imm = 0x2938
leaq -0x2938(%rbp), %rbx
movq %rbx, %rdi
callq 0x145c
movq %rbx, %rdi
callq 0x10e0
movl %eax, %esi
leaq -0x15b0(%rbp), %rdi
callq 0x15bc
leaq 0xd30(%rip), %rsi       # 0x2004
leaq -0x228(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x10d0
movabsq $0x6100000001, %rax     # imm = 0x6100000001
movq %rax, -0x28(%rbp)
leaq 0xd16(%rip), %rsi       # 0x200e
leaq -0x228(%rbp), %rdi
callq 0x10c0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x15b0(%rbp), %rsi
callq 0x14b2
movq %rbx, %rdi
movl %eax, %esi
callq 0x1130
movq %rax, %rdi
callq 0x1070
movabsq $0x6200000001, %rax     # imm = 0x6200000001
movq %rax, -0x20(%rbp)
leaq 0xcd6(%rip), %rsi       # 0x2014
leaq -0x228(%rbp), %rdi
callq 0x10c0
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
leaq -0x15b0(%rbp), %rsi
callq 0x14b2
movq %rbx, %rdi
movl %eax, %esi
callq 0x1130
movq %rax, %rdi
callq 0x1070
movabsq $0x6300000001, %rax     # imm = 0x6300000001
movq %rax, -0x18(%rbp)
leaq 0xc9a(%rip), %rsi       # 0x201e
leaq -0x228(%rbp), %rdi
callq 0x10c0
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
leaq -0x15b0(%rbp), %rsi
callq 0x14b2
movq %rbx, %rdi
movl %eax, %esi
callq 0x1130
movq %rax, %rdi
callq 0x1070
movabsq $0x6400000001, %rax     # imm = 0x6400000001
movq %rax, -0x10(%rbp)
leaq 0xc5a(%rip), %rsi       # 0x2024
leaq -0x228(%rbp), %rdi
callq 0x10c0
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
leaq -0x15b0(%rbp), %rsi
callq 0x14b2
movq %rbx, %rdi
movl %eax, %esi
callq 0x1130
movq %rax, %rdi
callq 0x1070
leaq -0x228(%rbp), %rdi
callq 0x10f0
leaq -0x228(%rbp), %rdi
callq 0x1100
leaq -0x2938(%rbp), %rdi
callq 0x14c0
xorl %eax, %eax
addq $0x2938, %rsp           # imm = 0x2938
popq %rbx
popq %rbp
retq
jmp 0x142d
movq %rax, %rbx
jmp 0x1447
jmp 0x1438
jmp 0x1438
jmp 0x1438
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x1100
leaq -0x2938(%rbp), %rdi
callq 0x14c0
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe2a(%rip), %rdi       # 0x2004
leaq 0xe2c(%rip), %rsi       # 0x200d
callq 0x10a0
testq %rax, %rax
je 0x12ab
movq %rax, %rbx
pushq $0x3
popq %r15
leaq 0xe25(%rip), %r14       # 0x2022
subl $0x1, %r15d
jb 0x1235
movq %rbx, %rdi
callq 0x1070
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1040
testl %eax, %eax
jne 0x1296
movq %rbx, %rdi
callq 0x1080
testl %eax, %eax
jne 0x1296
movsbl %bpl, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
jmp 0x11fd
pushq $0x78
popq %rdi
movq %rbx, %rsi
callq 0x1090
cmpl $-0x1, %eax
je 0x12b9
leaq 0xdf9(%rip), %rdi       # 0x2045
callq 0x1030
leaq 0xde3(%rip), %r14       # 0x203b
movq %rbx, %rdi
callq 0x1070
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1040
testl %eax, %eax
jne 0x1296
movq %rbx, %rdi
callq 0x1080
testl %eax, %eax
jne 0x128a
movsbl %bpl, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
jmp 0x1258
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
jmp 0x12d8
movq 0x2d5b(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd6e(%rip), %rdi       # 0x2015
pushq $0xc
jmp 0x12cc
leaq 0xd5d(%rip), %rdi       # 0x200f
callq 0x10b0
jmp 0x12d5
movq 0x2d38(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd62(%rip), %rdi       # 0x202c
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/mono/mono.c
// Function: commentHandler
static void commentHandler(FILE *in, FILE *out)
    {
    int ch, count=0;
    char s[512] = "";
    char *token = NULL;

    ch = fgetc(in);

    if(ch == 'm')
        {
        fprintf(stderr,"mono comment found \n");
        
        while(ch != '\n')
            {
            s[count++] = ch;
            ch = fgetc(in);
            }

        s[count] = '\0';

        token = strtok(s," ");

        token  =strtok(NULL , " ");

        Channel = atoi(token);

        fprintf(stderr,"Channel selected is %d\n",Channel);

        if (trackChannel < Channel)
            {
            Fatal("mono: bad channel: %d\n",Channel);
            Channel = -1;
            }
        }
    else
        {
        ungetc(ch,out);
        outputComment(in,out);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x220(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x10d0
movq %rbx, %rdi
callq 0x10e0
cmpl $0x6d, %eax
je 0x176e
movl %eax, %edi
movq %r14, %rsi
callq 0x1190
movq %rbx, %rdi
movq %r14, %rsi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bb5
movq 0x5883(%rip), %r14      # 0x6ff8
movq (%r14), %rcx
leaq 0x28fe(%rip), %rdi      # 0x407d
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
pushq $0x6d
popq %rax
xorl %r15d, %r15d
cmpl $0xa, %eax
je 0x17aa
movb %al, -0x220(%rbp,%r15)
incq %r15
movq %rbx, %rdi
callq 0x10e0
jmp 0x1790
movl %r15d, %eax
movb $0x0, -0x220(%rbp,%rax)
leaq 0x2e4b(%rip), %rbx      # 0x4607
leaq -0x220(%rbp), %rdi
movq %rbx, %rsi
callq 0x11d0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x11d0
movq %rax, %rdi
callq 0x1200
movl %eax, 0x596d(%rip)      # 0x7150
movq (%r14), %rdi
leaq 0x28a5(%rip), %rsi      # 0x4092
movl %eax, %edx
xorl %eax, %eax
callq 0x1140
movl 0x5954(%rip), %esi      # 0x7150
cmpl %esi, 0x5952(%rip)      # 0x7154
jge 0x1819
leaq 0x2822(%rip), %rdi      # 0x402d
xorl %eax, %eax
callq 0x1828
orl $-0x1, 0x5937(%rip)     # 0x7150
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AtifChy[P]st/x.c
// Function: reload
void
reload(int sig)
{
	config_init();

	/* colors, fonts */
	xloadcols();
	xunloadfonts();
	usedfont = (opt_font == NULL)? font : opt_font;
	xloadfonts(usedfont, 0);

	/* pretend the window just got resized */
	cresize(win.w, win.h);

	redraw();

	/* triggers re-render if we're visible. */
	ttywrite("\033[O", 3, 1);

	signal(SIGUSR1, reload);
}

// Assembly:
pushq %rax
callq 0xc649
callq 0xb104
callq 0xc6a7
movq 0x123e2(%rip), %rdi     # 0x1e9d8
testq %rdi, %rdi
jne 0xc602
movq 0xb006(%rip), %rdi      # 0x17608
movq %rdi, 0x123d7(%rip)     # 0x1e9e0
xorps %xmm0, %xmm0
callq 0xc70f
movl 0x12381(%rip), %edi     # 0x1e998
movl 0x1237f(%rip), %esi     # 0x1e99c
callq 0xc9b3
callq 0x896c
leaq 0x46f9(%rip), %rdi      # 0x10d27
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x79d0
leaq -0x61(%rip), %rsi       # 0xc5df
pushq $0xa
popq %rdi
popq %rax
jmp 0x6070
// File: /workspace/github_c_makefile_star2_O2/AtifChy[P]st/x.c
// Function: config_init
void
config_init(void)
{
	char *resm;
	XrmDatabase db;
	ResourcePref *p;

	XrmInitialize();
	resm = XResourceManagerString(XOpenDisplay(NULL));
	if (!resm)
		return;

	db = XrmGetStringDatabase(resm);
	for (p = resources; p < resources + LEN(resources); p++)
		resource_load(db, p->name, p->type, p->dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x65e0
xorl %edi, %edi
callq 0x6310
movq %rax, %rdi
callq 0x6190
testq %rax, %rax
je 0xc6a1
movq %rax, %rdi
callq 0x6760
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0xb7e4(%rip), %r15      # 0x17e60
cmpq $0x2e7, %r14            # imm = 0x2E7
ja 0xc6a1
movq (%r14,%r15), %rsi
movl 0x8(%r14,%r15), %edx
movq 0x10(%r14,%r15), %rcx
movq %rbx, %rdi
callq 0xc4a7
addq $0x18, %r14
jmp 0xc67c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AtifChy[P]st/x.c
// Function: xunloadfonts
void
xunloadfonts(void)
{
	/* Clear Harfbuzz font cache. */
	hbunloadfonts();

	/* Free the loaded fonts in the font cache.  */
	while (frclen > 0)
		XftFontClose(xw.dpy, frc[--frclen].font);

	xunloadfont(&dc.font);
	xunloadfont(&dc.bfont);
	xunloadfont(&dc.ifont);
	xunloadfont(&dc.ibfont);
}

// Assembly:
pushq %rax
xorl %eax, %eax
callq 0xf930
movl 0x1239b(%rip), %eax     # 0x1ea50
testl %eax, %eax
jle 0xc6de
movq 0x121d0(%rip), %rdi     # 0x1e890
movq 0x12391(%rip), %rcx     # 0x1ea58
decl %eax
movl %eax, 0x12381(%rip)     # 0x1ea50
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x60e0
jmp 0xc6af
leaq 0x120c3(%rip), %rdi     # 0x1e7a8
callq 0xda9d
leaq 0x120ef(%rip), %rdi     # 0x1e7e0
callq 0xda9d
leaq 0x1211b(%rip), %rdi     # 0x1e818
callq 0xda9d
leaq 0x12147(%rip), %rdi     # 0x1e850
popq %rax
jmp 0xda9d
// File: /workspace/github_c_makefile_star2_O2/AtifChy[P]st/x.c
// Function: opencopied
void
opencopied(const Arg *arg)
{
	const size_t max_cmd = 2048;
	const char *clip = xsel.clipboard;
	if(!clip) {
		fprintf(stderr, "Warning: nothing copied to clipboard\n");
		return;
	}

	/* account for space/quote (3) and \0 (1) and & (1) */
	char cmd[max_cmd + strlen(clip) + 5];
	strncpy(cmd, (char *)arg->v, max_cmd);
	cmd[max_cmd] = '\0';

	strcat(cmd, " \"");
	strcat(cmd, clip);
	strcat(cmd, "\"");
	strcat(cmd, "&");

	system(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x1109f(%rip), %rbx     # 0x1ea28
testq %rbx, %rbx
je 0xda31
movq %rdi, %r15
movq %rbx, %rdi
callq 0x63b0
movq %rax, %r12
movq %rsp, -0x30(%rbp)
movq %rsp, %r13
addq $0x814, %r12            # imm = 0x814
andq $-0x10, %r12
movq %r13, %r14
subq %r12, %r14
movq %r14, %rsp
movq (%r15), %rsi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
callq 0x6860
negq %r12
xorl %r15d, %r15d
movb %r15b, 0x800(%r13,%r12)
movq %r14, %rdi
callq 0x63b0
movb %r15b, 0x2(%rax,%r14)
movw $0x2220, (%rax,%r14)    # imm = 0x2220
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6500
movq %r14, %rdi
callq 0x63b0
movw $0x22, (%rax,%r14)
movq %r14, %rdi
callq 0x63b0
movw $0x26, (%rax,%r14)
movq %r14, %rdi
callq 0x6240
movq -0x30(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x95b8(%rip), %rax      # 0x16ff0
movq (%rax), %rcx
leaq 0x3307(%rip), %rdi      # 0x10d49
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6930
// File: /workspace/github_c_makefile_star2_O2/AtifChy[P]st/x.c
// Function: cmessage
void
cmessage(XEvent *e)
{
	/*
	 * See xembed specs
	 *  http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html
	 */
	if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
		if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {
			win.mode |= MODE_FOCUSED;
			xseturgency(0);
		} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
			win.mode &= ~MODE_FOCUSED;
		}
	} else if (e->xclient.data.l[0] == xw.wmdeletewin) {
		ttyhangup();
		exit(0);
	} else if (strcmp(XGetAtomName(xw.dpy, e->xclient.message_type), "ReloadColors") == 0) {
		config_init();
		xloadcols();
		cresize(win.w, win.h);
	}
}

// Assembly:
pushq %rax
movq 0x28(%rdi), %rsi
cmpq 0xfe2a(%rip), %rsi      # 0x1e8b8
jne 0xeab5
cmpl $0x20, 0x30(%rdi)
jne 0xeab5
movq 0x40(%rdi), %rax
cmpq $0x5, %rax
je 0xeaff
cmpq $0x4, %rax
jne 0xeae1
orb $0x2, 0xff03(%rip)      # 0x1e9b0
xorl %edi, %edi
popq %rax
jmp 0xc44b
movq 0x38(%rdi), %rax
cmpq 0xfe00(%rip), %rax      # 0x1e8c0
je 0xeb08
movq 0xfdc7(%rip), %rdi      # 0x1e890
callq 0x66e0
leaq 0x2a89(%rip), %rsi      # 0x1155e
movq %rax, %rdi
callq 0x6700
testl %eax, %eax
je 0xeae3
popq %rax
retq
callq 0xc649
callq 0xb104
movl 0xfea5(%rip), %edi      # 0x1e998
movl 0xfea3(%rip), %esi      # 0x1e99c
popq %rax
jmp 0xc9b3
andb $-0x3, 0xfeaa(%rip)     # 0x1e9b0
jmp 0xeae1
callq 0x7cca
xorl %edi, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/open1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char *tmpfile = tmpfiles[nr];

	while (1) {
		int fd = open(tmpfile, O_RDWR);
		assert(fd >= 0);
		close(fd);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
imulq $0x18, %rsi, %r14
addq 0xa515(%rip), %r14      # 0xc1a8
pushq $0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1220
testl %eax, %eax
js 0x1cb2
movl %eax, %edi
callq 0x1160
incq (%rbx)
jmp 0x1c96
leaq 0x60c(%rip), %rdi       # 0x22c5
leaq 0x5ba(%rip), %rsi       # 0x227a
leaq 0x606(%rip), %rcx       # 0x22cd
pushq $0x27
popq %rdx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tools/gftool.c
// Function: gf_dump
static void gf_dump(const gf_elem_t *tab)
{
	const int tab_size = 1 << gf_degree;
	const int digits = (gf_degree + 3) >> 2;
	const int per_line = 72 / (digits + 5);
	char fmt[16];
	int i;

	snprintf(fmt, sizeof(fmt), "0x%%0%dx,", digits);

	for (i = 0; i < tab_size; i++) {
		if (i % per_line)
			printf(" ");

		printf(fmt, tab[i]);

		if (!((i + 1) % per_line))
			printf("\n");
	}

	if (i % per_line)
		printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzwl 0x2962(%rip), %ecx      # 0x40a2
pushq $0x1
popq %r14
shll %cl, %r14d
addl $0x3, %ecx
shrl $0x2, %ecx
leal 0x5(%rcx), %esi
xorl %r12d, %r12d
movw $0x48, %ax
xorl %edx, %edx
divw %si
movzwl %ax, %ebp
leaq 0xa5d(%rip), %rdx       # 0x21c3
movq %rsp, %r15
pushq $0x10
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1080
testl %r14d, %r14d
cmovlel %r12d, %r14d
pushq $0x20
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x17c4
movl %r13d, %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
je 0x179c
movl %r12d, %edi
callq 0x1040
movzwl (%rbx,%r13,2), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
leal 0x1(%r13), %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
jne 0x17bf
pushq $0xa
popq %rdi
callq 0x1040
incq %r13
jmp 0x1784
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
je 0x17e5
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tools/gftool.c
// Function: print_poly
static void print_poly(char var, poly_t p)
{
	int have_term = 0;
	int i;

	printf("0x%lx [0x%lx] -> ", p, reciprocal(p));

	for (i = MAX_DEGREE; i >= 0; i--) {
		if (!((p >> i) & 1))
			continue;

		if (have_term)
			printf(" + ");

		if (!i)
			printf("1");
		else if (i == 1)
			printf("%c", var);
		else
			printf("%c^%d", var, i);

		have_term = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x189e
leaq 0x93d(%rip), %rdi       # 0x214b
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1070
pushq $0x3f
popq %r14
pushq $0x78
popq %rbp
pushq $0x1
popq %r15
leaq 0x934(%rip), %r12       # 0x2161
leaq 0x929(%rip), %r13       # 0x215d
xorl %eax, %eax
testl %r14d, %r14d
js 0x187f
btq %r14, %rbx
jae 0x187a
testl %eax, %eax
je 0x184f
movq %r13, %rdi
xorl %eax, %eax
callq 0x1070
cmpl $0x1, %r14d
je 0x185f
testl %r14d, %r14d
jne 0x1868
pushq $0x31
popq %rdi
jmp 0x1861
movl %ebp, %edi
callq 0x1040
jmp 0x1877
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1070
movl %r15d, %eax
decl %r14d
jmp 0x1836
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baines[P]MiniGBS/minigbs.c
// Function: cpu_frame
void cpu_frame(void){

	while(regs.sp != h.sp || regs.pc){
		cpu_step();
	}

	debug_separator();

	regs.pc = h.play_addr;
	mem[regs.sp-1] = mem[regs.sp-2] = 0;
	regs.sp -= 2;

	ui_redraw(&h);
}

// Assembly:
pushq %rax
movzwl 0xccd4(%rip), %eax      # 0x123c8
cmpw 0xccdd(%rip), %ax       # 0x123d8
jne 0x5707
cmpw $0x0, 0xccc5(%rip)      # 0x123ca
je 0x570e
callq 0x575c
jmp 0x56ed
callq 0x8151
leaq 0xccb2(%rip), %rdi      # 0x123cc
movzwl 0xccb5(%rip), %eax      # 0x123d6
movw %ax, 0xcca2(%rip)       # 0x123ca
movq 0xcd11(%rip), %rax      # 0x12440
movzwl 0xcc92(%rip), %ecx      # 0x123c8
xorl %edx, %edx
movb %dl, -0x2(%rax,%rcx)
movq 0xccfd(%rip), %rax      # 0x12440
movzwl 0xcc7e(%rip), %ecx      # 0x123c8
movb %dl, -0x1(%rax,%rcx)
addw $-0x2, 0xcc72(%rip)     # 0x123c8
popq %rax
jmp 0x9cd8
// File: /workspace/github_c_makefile_star2_O2/baines[P]MiniGBS/minigbs.c
// Function: mem_write
static inline void mem_write(uint16_t addr, uint8_t val){
	if(addr >= 0x2000 && addr < 0x4000){
		bank_switch(val);
	} else if(addr >= 0xFF10 && addr <= 0xFF40){
		audio_write(addr, val);
	} else if(addr < 0x8000){
		debug_msg("rom write?: [%4x] <- [%2x]", addr, val);
	} else if(addr == 0xFF06 || addr == 0xFF07){
		if(mem[addr] != val){
			mem[addr] = val;
			audio_update_rate();
		}
	} else {
		switch(addr){
			case 0xFF04: debug_msg("DIV write: %2x", val); break;
			case 0xFF05: debug_msg("TIMA write: %2x", val); break;
			case 0xFF0F: debug_msg("IF write: %2x", val); break;
			case 0xFF41: debug_msg("STAT: %2x", val); break;
			case 0xFF46: debug_msg("DMA: %2x", val); break;
			case 0xFFFF: debug_msg("IE: %2x", val); break;
		}
		mem[addr] = val;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %eax
andl $0xe000, %eax           # imm = 0xE000
cmpw $0x2000, %ax            # imm = 0x2000
jne 0x7783
movzbl %bl, %ebp
leaq 0x5059(%rip), %rdi      # 0xc77f
movl %ebp, %esi
xorl %eax, %eax
callq 0x817d
cmpb $0x1f, %bl
ja 0x7867
cmpb $0x2, %bl
pushq $0x1
popq %rax
cmovael %ebp, %eax
movzbl %al, %eax
leaq 0xad35(%rip), %rcx      # 0x12480
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
je 0x7867
movl $0x4000, %eax           # imm = 0x4000
movq 0xacdc(%rip), %rdi      # 0x12440
addq %rax, %rdi
movl $0x4000, %edx           # imm = 0x4000
callq 0x55b0
leaq 0x501d(%rip), %rdi      # 0xc795
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x817d
movl %edi, %esi
leal 0xf0(%rsi), %eax
cmpw $0x30, %ax
ja 0x77a0
movzwl %si, %edi
movzbl %bl, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x92f1
testw %si, %si
js 0x77ba
movzbl %bl, %edx
leaq 0x4f6d(%rip), %rdi      # 0xc71c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x817d
movl %esi, %eax
andl $0xfffe, %eax           # imm = 0xFFFE
cmpw $0xff06, %ax            # imm = 0xFF06
jne 0x77e6
movq 0xac72(%rip), %rax      # 0x12440
movzwl %si, %ecx
cmpb %bl, (%rax,%rcx)
je 0x7867
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
jmp 0x8f43
movzwl %si, %r14d
cmpw $0xff04, %si            # imm = 0xFF04
je 0x784b
cmpl $0xffff, %r14d          # imm = 0xFFFF
je 0x7842
cmpl $0xff0f, %r14d          # imm = 0xFF0F
je 0x7827
cmpl $0xff41, %r14d          # imm = 0xFF41
je 0x7839
cmpl $0xff46, %r14d          # imm = 0xFF46
je 0x7830
cmpl $0xff05, %r14d          # imm = 0xFF05
jne 0x785c
leaq 0x4f21(%rip), %rdi      # 0xc746
jmp 0x7852
leaq 0x4f28(%rip), %rdi      # 0xc756
jmp 0x7852
leaq 0x4f37(%rip), %rdi      # 0xc76e
jmp 0x7852
leaq 0x4f24(%rip), %rdi      # 0xc764
jmp 0x7852
leaq 0x4f2e(%rip), %rdi      # 0xc777
jmp 0x7852
leaq 0x4ee5(%rip), %rdi      # 0xc737
movzbl %bl, %esi
xorl %eax, %eax
callq 0x817d
movq 0xabdd(%rip), %rax      # 0x12440
movb %bl, (%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq