LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_write_func
void* gt_fa_xmmap_write_func(const char *path, size_t *len,
                             const char *src_file, int src_line)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, true, true, src_file, src_line,
                                NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74b6b
cmpq $0x0, 0xde086(%rip)     # 0x152bd0
je 0x74b70
movl %ecx, %r9d
movq %rdx, %r8
movq $0x0, (%rsp)
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7467f
popq %rcx
retq
callq 0x1b575
callq 0x1b53c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_write_func_range
void* gt_fa_xmmap_write_func_range(const char *path, size_t len, size_t offset,
                                   const char *src_file, int src_line)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, true, true, src_file,
                                      src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74ba4
cmpq $0x0, 0xde04d(%rip)     # 0x152bd0
je 0x74ba9
movl %r8d, %eax
movq %rcx, %r9
movl $0x1, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x74852
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b5e7
callq 0x1b5ae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmunmap
void gt_fa_xmunmap(void *addr)
{
  FAMapInfo *mapinfo;
  gt_assert(fa);
  if (!addr) return;
  gt_mutex_lock(fa->mmap_mutex);
  mapinfo = gt_hashmap_get(fa->memory_maps, addr);
  gt_assert(mapinfo);
#ifndef _WIN32
  gt_xmunmap(addr, mapinfo->len);
#else
  if (!UnmapViewOfFile(addr)) {
    fprintf(stderr, "cannot UnmapViewOfFile: 0x%08x\n",
            (unsigned int) GetLastError());
    exit(EXIT_FAILURE);
  }
  if (!CloseHandle(mapinfo->filemapping)) {
    fprintf(stderr, "cannot CloseHandle(fm): 0x%08x\n",
            (unsigned int) GetLastError());
    exit(EXIT_FAILURE);
  }
  if (!CloseHandle(mapinfo->filehandle)) {
    fprintf(stderr, "cannot CloseHandle(fh): 0x%08x\n",
            (unsigned int) GetLastError());
    exit(EXIT_FAILURE);
  }
#endif
  gt_assert(fa->current_size >= mapinfo->len);
  fa->current_size -= mapinfo->len;
  if (fa->global_space_peak)
    gt_spacepeak_free(mapinfo->len);
  gt_hashmap_remove(fa->memory_maps, addr);
  gt_mutex_unlock(fa->mmap_mutex);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xde017(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x74c4d
movq %rdi, %rbx
testq %rdi, %rdi
je 0x74c45
movq 0x8(%rax), %rdi
callq 0x3d9b7
movq 0xddff6(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x74c52
movq %rax, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x836dc
movq 0xddfd0(%rip), %rax     # 0x152bd0
movq 0x20(%rax), %rcx
movq (%r14), %rdi
subq %rdi, %rcx
jb 0x74c57
movq %rcx, 0x20(%rax)
cmpb $0x1, 0x30(%rax)
jne 0x74c1b
callq 0x3a6d9
movq 0xddfae(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x77182
movq 0xddf9b(%rip), %rax     # 0x152bd0
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d9d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1b692
callq 0x1b659
callq 0x1b620
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_check_size_with_suffix
void* gt_fa_mmap_check_size_with_suffix(const char *path, const char *suffix,
                                        GtUword expectedunits,
                                     size_t sizeofunit, GtError *err)
{
  size_t numofbytes;
  void *ptr;
  if (!(ptr = gt_fa_mmap_read_with_suffix(path, suffix, &numofbytes, err)))
    return NULL;
  if (check_mapped_file_size(path, suffix, numofbytes, expectedunits,
                             sizeofunit, err)) {
    gt_fa_xmunmap(ptr);
    return NULL;
  }
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r13
leaq 0x7bbd4(%rip), %rcx     # 0xf08d5
leaq 0x10(%rsp), %rdx
movl $0x2dd, %r8d            # imm = 0x2DD
movq %r12, %r9
callq 0x74c5c
testq %rax, %rax
je 0x74d75
movq %rax, %rbx
movq %rbp, 0x8(%rsp)
movq %r14, %rbp
movq 0x10(%rsp), %r14
testq %r12, %r12
je 0x74d3a
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x74d89
movq %r14, %rax
xorl %edx, %edx
divq %rbp
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x74d77
movq %rcx, (%rsp)
leaq 0x7c061(%rip), %rsi     # 0xf0db8
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3559f
movq %rbx, %rdi
callq 0x74bae
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b704
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_check_fptr_leak
int gt_fa_check_fptr_leak(void)
{
  CheckLeakInfo info;
  GT_UNUSED int had_err;
  gt_assert(fa);
  info.has_leak = false;
  had_err = gt_hashmap_foreach(fa->file_pointer, check_fptr_leak, &info, NULL);
  gt_assert(!had_err); /* cannot happen, check_fptr_leak() is sane */
  if (info.has_leak)
    return -1;
  return 0;
}

// Assembly:
pushq %rax
movq 0xdde3a(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x74dc2
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x10(%rax), %rdi
leaq 0x1e(%rip), %rsi        # 0x74dcc
xorl %ecx, %ecx
callq 0x771f5
testl %eax, %eax
jne 0x74dc7
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0x1b776
callq 0x1b73d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: check_fptr_leak
static int check_fptr_leak(GT_UNUSED void *key, void *value, void *data,
                           GT_UNUSED GtError *err)
{
  CheckLeakInfo *info = (CheckLeakInfo*) data;
  FAFileInfo *fileinfo = (FAFileInfo*) value;
  gt_assert(key && value && data);
  /* report only the first leak */
  if (!info->has_leak) {
    fprintf(stderr, "bug: file pointer leaked (opened on line %d in file "
            "\"%s\")\n", fileinfo->src_line, fileinfo->src_file);
    info->has_leak = true;
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74df2
testq %rsi, %rsi
je 0x74df2
testq %rdx, %rdx
je 0x74df2
cmpb $0x0, (%rdx)
je 0x74de5
xorl %eax, %eax
popq %rcx
retq
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1b7e8
jmp 0x74de1
callq 0x1b7af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_check_mmap_leak
int gt_fa_check_mmap_leak(void)
{
  CheckLeakInfo info;
  GT_UNUSED int had_err;
  gt_assert(fa);
  info.has_leak = false;
  had_err = gt_hashmap_foreach(fa->memory_maps, check_mmap_leak, &info, NULL);
  gt_assert(!had_err); /* cannot happen, check_mmap_leak() is sane */
  if (info.has_leak)
    return -1;
  return 0;
}

// Assembly:
pushq %rax
movq 0xdddd1(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x74e2b
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x18(%rax), %rdi
leaq 0x1e(%rip), %rsi        # 0x74e35
xorl %ecx, %ecx
callq 0x771f5
testl %eax, %eax
jne 0x74e30
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0x1b84b
callq 0x1b812
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: check_mmap_leak
static int check_mmap_leak(GT_UNUSED void *key, void *value, void *data,
                           GT_UNUSED GtError *err)
{
  CheckLeakInfo *info = (CheckLeakInfo*) data;
  FAMapInfo *mapinfo = (FAMapInfo*) value;
  gt_assert(key && value && data);
  /* report only the first leak */
  if (!info->has_leak) {
    fprintf(stderr, "bug: memory map of length "GT_ZU" leaked (opened on line "
            "%d in file \"%s\")\n", mapinfo->len, mapinfo->src_line,
            mapinfo->src_file);
    info->has_leak = true;
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74e5b
testq %rsi, %rsi
je 0x74e5b
testq %rdx, %rdx
je 0x74e5b
cmpb $0x0, (%rdx)
je 0x74e4e
xorl %eax, %eax
popq %rcx
retq
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1b8bd
jmp 0x74e4a
callq 0x1b884
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_clean
void gt_fa_clean(void)
{
  if (!fa) return;
  gt_mutex_delete(fa->file_mutex);
  gt_mutex_delete(fa->mmap_mutex);
  gt_hashmap_delete(fa->file_pointer);
  gt_hashmap_delete(fa->memory_maps);
  gt_free(fa);
  fa = NULL;
}

// Assembly:
movq 0xddcdc(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x74f59
pushq %rax
movq (%rax), %rdi
callq 0x3d995
movq 0xddcc7(%rip), %rax     # 0x152bd0
movq 0x8(%rax), %rdi
callq 0x3d995
movq 0xddcb7(%rip), %rax     # 0x152bd0
movq 0x10(%rax), %rdi
callq 0x77675
movq 0xddca7(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
callq 0x77675
movq 0xddc97(%rip), %rdi     # 0x152bd0
leaq 0x7b995(%rip), %rsi     # 0xf08d5
movl $0x340, %edx            # imm = 0x340
callq 0x362a0
movq $0x0, 0xddc7b(%rip) # 0x152bd0
addq $0x8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta.c
// Function: gt_fasta_show_entry_nt_with_suffix
void gt_fasta_show_entry_nt_with_suffix(const char *description,
                                        GtUword description_length,
                                        const char *sequence,
                                        GtUword sequence_length,
                                        const char *suffix,
                                        GtUword width,
                                        GtFile *outfp)
{
  GtUword i, current_length, suffix_length;
  gt_assert(sequence);
  gt_file_xfputc(GT_FASTA_SEPARATOR, outfp);
  if (description != NULL) {
    for (i = 0;
         i < description_length && description[i] != '\0';
         ++i) {
      gt_file_xfputc(description[i], outfp);
    }
  }
  gt_file_xfputc('\n', outfp);
  for (i = 0, current_length = 0;
       i < sequence_length && sequence[i] != '\0';
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(sequence[i], outfp);
  }
  suffix_length = suffix ? strlen(suffix) : 0;
  for (i = 0;
       i < suffix_length;
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(suffix[i], outfp);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rdx, %rdx
je 0x7517c
movq %r9, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq 0x50(%rsp), %r15
movl $0x3e, %edi
movq %r15, %rsi
callq 0x759ff
testq %r12, %r12
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x750a6
xorl %r14d, %r14d
movsbl (%r12,%r14), %edi
testl %edi, %edi
je 0x750a6
movq %r15, %rsi
callq 0x759ff
incq %r14
cmpq %r14, %rbp
jne 0x7508d
movl $0xa, %edi
movq %r15, %rsi
callq 0x759ff
cmpq $0x0, 0x10(%rsp)
je 0x7510c
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x8(%rsp), %r14
cmpb $0x0, (%r13,%r12)
je 0x75113
testq %rbx, %rbx
setne %al
cmpq %rbx, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x750ef
movl $0xa, %edi
movq %r15, %rsi
callq 0x759ff
xorl %ebp, %ebp
movsbl (%r13,%r12), %edi
movq %r15, %rsi
callq 0x759ff
incq %r12
incq %rbp
cmpq %r12, 0x10(%rsp)
jne 0x750c5
jmp 0x75113
xorl %ebp, %ebp
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x75125
movq %r14, %rdi
callq 0xb260
movq %rax, %r12
jmp 0x75128
xorl %r12d, %r12d
testq %r12, %r12
je 0x75161
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x75149
cmpq %rbx, %rbp
jne 0x75149
movl $0xa, %edi
movq %r15, %rsi
callq 0x759ff
xorl %ebp, %ebp
movsbl (%r14,%r13), %edi
movq %r15, %rsi
callq 0x759ff
incq %r13
incq %rbp
cmpq %r13, %r12
jne 0x75130
movl $0xa, %edi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x759ff
callq 0x1b9cf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta.c
// Function: gt_fasta_show_entry_nt_with_suffix_str
void gt_fasta_show_entry_nt_with_suffix_str(const char *description,
                                            GtUword description_length,
                                            const char *sequence,
                                            GtUword sequence_length,
                                            const char *suffix, GtUword width,
                                            GtStr *outstr)
{
  GtUword i, current_length, suffix_length;
  gt_assert(sequence && outstr);
  gt_str_append_char(outstr, GT_FASTA_SEPARATOR);
  if (description != NULL) {
    for (i = 0;
         i < description_length && description[i] != '\0';
         ++i) {
      gt_str_append_char(outstr, description[i]);
    }
  }
  gt_str_append_char(outstr, '\n');
  for (i = 0, current_length = 0;
       i < sequence_length && sequence[i] != '\0';
       i++, current_length++) {
    if (width && current_length == width) {
      gt_str_append_char(outstr, '\n');
      current_length = 0;
    }
    gt_str_append_char(outstr, sequence[i]);
  }
  suffix_length = suffix ? strlen(suffix) : 0;
  for (i = 0;
       i < suffix_length;
       i++, current_length++) {
    if (width && current_length == width) {
      gt_str_append_char(outstr, '\n');
      current_length = 0;
    }
    gt_str_append_char(outstr, suffix[i]);
  }
  gt_str_append_char(outstr, '\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rdx, %rdx
je 0x752e2
movq 0x50(%rsp), %r15
testq %r15, %r15
je 0x752e2
movq %r9, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq %r15, %rdi
movl $0x3e, %esi
callq 0x3c28d
testq %r12, %r12
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x7520c
xorl %r14d, %r14d
movb (%r12,%r14), %al
testb %al, %al
je 0x7520c
movsbl %al, %esi
movq %r15, %rdi
callq 0x3c28d
incq %r14
cmpq %r14, %rbp
jne 0x751f1
movq %r15, %rdi
movl $0xa, %esi
callq 0x3c28d
cmpq $0x0, 0x10(%rsp)
je 0x75272
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x8(%rsp), %r14
cmpb $0x0, (%r13,%r12)
je 0x75279
testq %rbx, %rbx
setne %al
cmpq %rbx, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x75255
movq %r15, %rdi
movl $0xa, %esi
callq 0x3c28d
xorl %ebp, %ebp
movsbl (%r13,%r12), %esi
movq %r15, %rdi
callq 0x3c28d
incq %r12
incq %rbp
cmpq %r12, 0x10(%rsp)
jne 0x7522b
jmp 0x75279
xorl %ebp, %ebp
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x7528b
movq %r14, %rdi
callq 0xb260
movq %rax, %r12
jmp 0x7528e
xorl %r12d, %r12d
testq %r12, %r12
je 0x752c7
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x752af
cmpq %rbx, %rbp
jne 0x752af
movq %r15, %rdi
movl $0xa, %esi
callq 0x3c28d
xorl %ebp, %ebp
movsbl (%r14,%r13), %esi
movq %r15, %rdi
callq 0x3c28d
incq %r13
incq %rbp
cmpq %r13, %r12
jne 0x75296
movq %r15, %rdi
movl $0xa, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c28d
callq 0x1ba06
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_mode_determine
GtFileMode gt_file_mode_determine(const char *path)
{
  size_t path_length;
  if (!path)
    return GT_FILE_MODE_UNCOMPRESSED;
  path_length = strlen(path);
  if (path_length >= 4 && strcmp(".gz", path + path_length - 3) == 0)
    return GT_FILE_MODE_GZIP;
  if (path_length >= 5 && strcmp(".bz2", path + path_length - 4) == 0)
    return GT_FILE_MODE_BZIP2;
  return GT_FILE_MODE_UNCOMPRESSED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x75347
movq %rdi, %r14
callq 0xb260
movq %rax, %r15
cmpq $0x4, %rax
jb 0x7531d
leaq (%r14,%r15), %rsi
addq $-0x3, %rsi
leaq 0x7bc22(%rip), %rdi     # 0xf0f36
callq 0xb890
testl %eax, %eax
je 0x75342
cmpq $0x5, %r15
jb 0x75347
leaq (%r14,%r15), %rsi
addq $-0x4, %rsi
leaq 0x7bc08(%rip), %rdi     # 0xf0f3a
callq 0xb890
testl %eax, %eax
jne 0x75347
movl $0x2, %ebx
jmp 0x75347
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_basename_length
size_t gt_file_basename_length(const char *path)
{
  size_t path_length;

  gt_assert(path);
  path_length = strlen(path);

  if (path_length >= 4 && strcmp(".gz", path + path_length - 3) == 0)
    return path_length - 3;
  if (path_length >= 5 && strcmp(".bz2", path + path_length - 4) == 0)
    return path_length - 4;
  return path_length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x753d2
movq %rdi, %r14
callq 0xb260
movq %rax, %rbx
cmpq $0x4, %rax
jb 0x7539d
leaq (%r14,%rbx), %rsi
addq $-0x3, %rsi
leaq 0x7bba2(%rip), %rdi     # 0xf0f36
callq 0xb890
testl %eax, %eax
je 0x753c3
cmpq $0x5, %rbx
jb 0x753c7
leaq (%rbx,%r14), %rsi
addq $-0x4, %rsi
leaq 0x7bb88(%rip), %rdi     # 0xf0f3a
callq 0xb890
leaq -0x4(%rbx), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0x753c7
addq $-0x3, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ba76
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_open
GtFile* gt_file_open(GtFileMode file_mode, const char *path, const char *mode,
                     GtError *err)
{
  GtFile *file;
  gt_error_check(err);
  gt_assert(mode);
  file = gt_calloc(1, sizeof (GtFile));
  file->mode = file_mode;
  file->reference_count = 0;
  if (path) {
    switch (file_mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        file->fileptr.file = gt_fa_fopen(path, mode, err);
        if (!file->fileptr.file) {
          gt_file_delete_without_handle(file);
          return NULL;
        }
        break;
      case GT_FILE_MODE_GZIP:
        file->fileptr.gzfile = gt_fa_gzopen(path, mode, err);
        if (!file->fileptr.gzfile) {
          gt_file_delete_without_handle(file);
          return NULL;
        }
        break;
      case GT_FILE_MODE_BZIP2:
        file->fileptr.bzfile = gt_fa_bzopen(path, mode, err);
        if (!file->fileptr.bzfile) {
          gt_file_delete_without_handle(file);
          return NULL;
        }
        file->orig_path = gt_cstr_dup(path);
        file->orig_mode = gt_cstr_dup(path);
        break;
      default: gt_assert(0);
    }
  }
  else {
    gt_assert(file_mode == GT_FILE_MODE_UNCOMPRESSED);
    file->fileptr.file = stdin;
    file->is_stdin = true;
  }
  return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
testq %rcx, %rcx
je 0x7544a
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0x75547
testq %r12, %r12
je 0x75542
leaq 0x7baf9(%rip), %rdx     # 0xf0f53
movl $0x1, %edi
movl $0x30, %esi
movl $0x6b, %ecx
callq 0x3601f
movq %rax, %rbx
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
testq %r14, %r14
je 0x754ae
cmpl $0x2, %ebp
je 0x754ef
cmpl $0x1, %ebp
je 0x754ca
testl %ebp, %ebp
jne 0x75551
leaq 0x7baba(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r12, %rsi
movl $0x71, %ecx
movq %r15, %r8
callq 0x73cbf
jmp 0x754e4
testl %ebp, %ebp
jne 0x7554c
movq 0xdbad3(%rip), %rax     # 0x150f90
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x75536
leaq 0x7ba82(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r12, %rsi
movl $0x78, %ecx
movq %r15, %r8
callq 0x74064
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x75536
jmp 0x7552c
leaq 0x7ba5d(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r12, %rsi
movl $0x7f, %ecx
movq %r15, %r8
callq 0x74161
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7552c
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x20(%rbx)
jmp 0x75536
movq %rbx, %rdi
callq 0x75566
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1bbc4
callq 0x1bb1b
callq 0x1bb8b
callq 0x1bb52
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_delete_without_handle
void gt_file_delete_without_handle(GtFile *file)
{
  if (!file) return;
  gt_free(file->orig_path);
  gt_free(file->orig_mode);
  gt_free(file);
}

// Assembly:
testq %rdi, %rdi
je 0x755b2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x7b9d6(%rip), %r14     # 0xf0f53
movq %r14, %rsi
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x362a0
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1ac, %edx            # imm = 0x1AC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xopen_file_mode
GtFile* gt_file_xopen_file_mode(GtFileMode file_mode, const char *path,
                                const char *mode)
{
  GtFile *file;
  gt_assert(mode);
  file = gt_calloc(1, sizeof (GtFile));
  file->mode = file_mode;
  file->reference_count = 0;
  if (path) {
    switch (file_mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        file->fileptr.file = gt_fa_xfopen(path, mode);
        break;
      case GT_FILE_MODE_GZIP:
        file->fileptr.gzfile = gt_fa_xgzopen(path, mode);
        break;
      case GT_FILE_MODE_BZIP2:
        file->fileptr.bzfile = gt_fa_xbzopen(path, mode);
        file->orig_path = gt_cstr_dup(path);
        file->orig_mode = gt_cstr_dup(path);
        break;
      default: gt_assert(0);
    }
  }
  else {
    gt_assert(file_mode == GT_FILE_MODE_UNCOMPRESSED);
    file->fileptr.file = stdin;
    file->is_stdin = true;
  }
  return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x75699
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
leaq 0x7b981(%rip), %rdx     # 0xf0f53
movl $0x1, %edi
movl $0x30, %esi
movl $0x97, %ecx
callq 0x3601f
movq %rax, %rbx
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
testq %r14, %r14
je 0x75623
cmpl $0x2, %ebp
je 0x75658
cmpl $0x1, %ebp
je 0x7563b
testl %ebp, %ebp
jne 0x756a3
leaq 0x7b942(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r15, %rsi
movl $0x9d, %ecx
callq 0x73e59
jmp 0x75652
testl %ebp, %ebp
jne 0x7569e
movq 0xdb962(%rip), %rax     # 0x150f90
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x7568b
leaq 0x7b911(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r15, %rsi
movl $0xa0, %ecx
callq 0x740d8
movq %rax, 0x10(%rbx)
jmp 0x7568b
leaq 0x7b8f4(%rip), %rdx     # 0xf0f53
movq %r14, %rdi
movq %r15, %rsi
movl $0xa3, %ecx
callq 0x741d5
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1bc6d
callq 0x1bc34
callq 0x1bbfb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_new_from_fileptr
GtFile* gt_file_new_from_fileptr(FILE *fp)
{
  GtFile *file;
  gt_assert(fp);
  file = gt_calloc(1, sizeof (GtFile));
  file->reference_count = 0;
  file->mode = GT_FILE_MODE_UNCOMPRESSED;
  file->fileptr.file = fp;
  return file;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7570d
movq %rdi, %rbx
leaq 0x7b86e(%rip), %rdx     # 0xf0f53
movl $0x1, %edi
movl $0x30, %esi
movl $0xbc, %ecx
callq 0x3601f
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
callq 0x1bcdf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_unget_char
void gt_file_unget_char(GtFile *file, char c)
{
  if (file) {
    gt_assert(!file->unget_used); /* only one char can be unget at a time */
    file->unget_char = c;
    file->unget_used = true;
  }
  else
    gt_xungetc(c, stdin);
}

// Assembly:
testq %rdi, %rdi
je 0x75788
cmpb $0x1, 0x2a(%rdi)
je 0x7579b
movb %sil, 0x28(%rdi)
movb $0x1, 0x2a(%rdi)
retq
movsbl %sil, %edi
movq 0xdb7fd(%rip), %rax     # 0x150f90
movq (%rax), %rsi
jmp 0x3dd5f
pushq %rax
callq 0x1bd8a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xprintf
void gt_file_xprintf(GtFile *file, const char *format, ...)
{
  va_list va;
  int rval;
  va_start(va, format);
  if ((rval = xvprintf(file, format, va, 0))) {
    gt_assert(rval > 0); /* negative return is not possible, rval should denote
                            the necessary buffer length -> try again with it */
    /* reset variable arguments */
    va_end(va);
    va_start(va, format);
    /* try again */
    rval = xvprintf(file, format, va, rval);
    gt_assert(!rval); /* xvprintf() should not fail with given buffer length */
  }
  va_end(va);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x75807
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
leaq 0x100(%rsp), %r12
movq %r12, 0x8(%rdx)
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %r13, (%rdx)
xorl %ecx, %ecx
callq 0x7586e
testl %eax, %eax
je 0x75853
jle 0x75864
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
movq %r12, 0x8(%rdx)
movq %r13, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %ecx
callq 0x7586e
testl %eax, %eax
jne 0x75869
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1bdc3
callq 0x1bdfc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: xvprintf
static int xvprintf(GtFile *file, const char *format, va_list va, int buflen)
{
  int rval = 0;

  if (!file) /* implies stdout */
    gt_xvfprintf(stdout, format, va);
  else {
    switch (file->mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        gt_xvfprintf(file->fileptr.file, format, va);
        break;
      case GT_FILE_MODE_GZIP:
        rval = vgzprintf(file->fileptr.gzfile, format, va, buflen);
        break;
      case GT_FILE_MODE_BZIP2:
        rval = vbzprintf(file->fileptr.bzfile, format, va, buflen);
        break;
      default: gt_assert(0);
    }
  }
  return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdx, %rbx
movq %rsi, %r15
testq %rdi, %rdi
je 0x758ab
movl %ecx, %r14d
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x75926
cmpl $0x1, %eax
je 0x758c5
testl %eax, %eax
jne 0x759f0
movq 0x10(%rdi), %rdi
jmp 0x758b5
movq 0xdb6a6(%rip), %rax     # 0x150f58
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3dd75
jmp 0x7598a
movq 0x10(%rdi), %r12
testl %r14d, %r14d
je 0x7599e
leal 0x1(%r14), %ebp
leaq 0x7b676(%rip), %rsi     # 0xf0f53
movq %rbp, %rdi
movl $0xff, %edx
callq 0x35ee2
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3dd86
cmpl %r14d, %eax
jne 0x759f5
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x8388d
leaq 0x7b637(%rip), %rsi     # 0xf0f53
movq %r13, %rdi
movl $0x103, %edx            # imm = 0x103
jmp 0x75985
movq 0x10(%rdi), %r12
testl %r14d, %r14d
je 0x759c7
leal 0x1(%r14), %ebp
leaq 0x7b615(%rip), %rsi     # 0xf0f53
movq %rbp, %rdi
movl $0x116, %edx            # imm = 0x116
callq 0x35ee2
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3dd86
cmpl %r14d, %eax
jne 0x759fa
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x835ad
leaq 0x7b5d6(%rip), %rsi     # 0xf0f53
movq %r13, %rdi
movl $0x11a, %edx            # imm = 0x11A
callq 0x362a0
xorl %eax, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3dd86
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x7598c
movq %rsp, %rsi
movq %r12, %rdi
movl %eax, %edx
callq 0x8388d
jmp 0x7598a
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3dd86
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x7598c
movq %rsp, %rsi
movq %r12, %rdi
movl %eax, %edx
callq 0x835ad
jmp 0x7598a
callq 0x1bea7
callq 0x1be6e
callq 0x1be35
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputc
void gt_file_xfputc(int c, GtFile *file)
{
  if (!file)
    return gt_xfputc(c, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputc(c, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputc(c, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputc(c, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x75a1d
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x75a35
cmpl $0x1, %eax
je 0x75a2c
testl %eax, %eax
jne 0x75a3e
movq 0x10(%rsi), %rsi
jmp 0x3dc12
movq 0xdb534(%rip), %rax     # 0x150f58
movq (%rax), %rsi
jmp 0x3dc12
movq 0x10(%rsi), %rsi
jmp 0x83838
movq 0x10(%rsi), %rsi
jmp 0x8354d
pushq %rax
callq 0x1bee0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputs
void gt_file_xfputs(const char *cstr, GtFile *file)
{
  if (!file)
    return gt_xfputs(cstr, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputs(cstr, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputs(cstr, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputs(cstr, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x75a62
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x75a7a
cmpl $0x1, %eax
je 0x75a71
testl %eax, %eax
jne 0x75a83
movq 0x10(%rsi), %rsi
jmp 0x3dc24
movq 0xdb4ef(%rip), %rax     # 0x150f58
movq (%rax), %rsi
jmp 0x3dc24
movq 0x10(%rsi), %rsi
jmp 0x83862
movq 0x10(%rsi), %rsi
jmp 0x83579
pushq %rax
callq 0x1bf19
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xread
int gt_file_xread(GtFile *file, void *buf, size_t nbytes)
{
  int rval = -1;
  if (file) {
    switch (file->mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        rval = gt_xfread(buf, 1, nbytes, file->fileptr.file);
        break;
      case GT_FILE_MODE_GZIP:
        rval = gt_xgzread(file->fileptr.gzfile, buf, nbytes);
        break;
      case GT_FILE_MODE_BZIP2:
        rval = gt_xbzread(file->fileptr.bzfile, buf, nbytes);
        break;
      default: gt_assert(0);
    }
  }
  else
    rval = gt_xfread(buf, 1, nbytes, stdin);
  return rval;
}

// Assembly:
pushq %rax
movq %rsi, %rax
testq %rdi, %rdi
je 0x75aa8
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x75ace
cmpl $0x1, %ecx
je 0x75ac1
testl %ecx, %ecx
jne 0x75adb
movq 0x10(%rdi), %rcx
jmp 0x75ab2
movq 0xdb4e1(%rip), %rcx     # 0x150f90
movq (%rcx), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0x3dc40
popq %rcx
retq
movq 0x10(%rdi), %rdi
movq %rax, %rsi
popq %rax
jmp 0x83813
movq 0x10(%rdi), %rdi
movq %rax, %rsi
popq %rax
jmp 0x8353b
callq 0x1bf52
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xwrite
void gt_file_xwrite(GtFile *file, void *buf, size_t nbytes)
{
  if (!file) {
    gt_xfwrite(buf, 1, nbytes, stdout);
    return;
  }
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfwrite(buf, 1, nbytes, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzwrite(file->fileptr.gzfile, buf, nbytes);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzwrite(file->fileptr.bzfile, buf, nbytes);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
movq %rsi, %rax
testq %rdi, %rdi
je 0x75afe
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x75b21
cmpl $0x1, %ecx
je 0x75b15
testl %ecx, %ecx
jne 0x75b2d
movq 0x10(%rdi), %rcx
jmp 0x75b08
movq 0xdb453(%rip), %rcx     # 0x150f58
movq (%rcx), %rcx
movl $0x1, %esi
movq %rax, %rdi
jmp 0x3dc94
movq 0x10(%rdi), %rdi
movq %rax, %rsi
jmp 0x8388d
movq 0x10(%rdi), %rdi
movq %rax, %rsi
jmp 0x835ad
pushq %rax
callq 0x1bf8b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_xrewind
void gt_file_xrewind(GtFile *file)
{
  gt_assert(file);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      rewind(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzrewind(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzrewind(&file->fileptr.bzfile, file->orig_path, file->orig_mode);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x75b72
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x75b5d
cmpl $0x1, %eax
je 0x75b53
testl %eax, %eax
jne 0x75b77
movq 0x10(%rdi), %rdi
popq %rax
jmp 0xb0c0
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x838bc
leaq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
movq %rax, %rdi
popq %rax
jmp 0x835ca
callq 0x1bffd
callq 0x1bfc4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/file.c
// Function: gt_file_delete
void gt_file_delete(GtFile *file)
{
  if (!file) return;
  if (file->reference_count) {
    file->reference_count--;
    return;
  }
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
        if (!file->is_stdin)
          gt_fa_fclose(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
        gt_fa_gzclose(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
        gt_fa_bzclose(file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
  gt_file_delete_without_handle(file);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x75b95
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x75b97
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x75bc3
cmpl $0x1, %eax
je 0x75bb8
testl %eax, %eax
jne 0x75bd5
cmpb $0x0, 0x29(%rbx)
jne 0x75bcc
movq 0x10(%rbx), %rdi
callq 0x73f1c
jmp 0x75bcc
movq 0x10(%rbx), %rdi
callq 0x7411d
jmp 0x75bcc
movq 0x10(%rbx), %rdi
callq 0x7421a
movq %rbx, %rdi
popq %rbx
jmp 0x75566
callq 0x1c036
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_exists_with_suffix
bool gt_file_exists_with_suffix(const char *path, const char *suffix)
{
  struct stat statbuf;
  GtStr *tmpfilename;

  gt_assert(path && suffix);

  tmpfilename = gt_str_new_cstr(path);
  gt_str_append_cstr(tmpfilename, suffix);

  if (stat(gt_str_get(tmpfilename), &statbuf) == 0) {
    gt_str_delete(tmpfilename);
    return true;
  }
  gt_str_delete(tmpfilename);
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x75c8a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x75c8a
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3c067
movq %r14, %rdi
callq 0x3c40b
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xbad0
testl %eax, %eax
sete %bl
movq %r14, %rdi
callq 0x3d1eb
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
callq 0x1c06f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_is_newer
bool gt_file_is_newer(const char *a, const char *b)
{
  struct stat stat_a, stat_b;
  gt_assert(a && b);
  gt_xstat(a, &stat_a);
  gt_xstat(b, &stat_b);
  if (stat_a.st_mtime > stat_b.st_mtime ||
      (stat_a.st_mtime == stat_b.st_mtime &&
       stat_a.st_mtime > stat_b.st_mtime)) {
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
testq %rdi, %rdi
je 0x75cde
movq %rsi, %rbx
testq %rsi, %rsi
je 0x75cde
leaq 0x90(%rsp), %r14
movq %r14, %rsi
callq 0x83711
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x83711
movq 0x58(%r14), %rax
cmpq 0x58(%r15), %rax
setg %al
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
callq 0x1c0a6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_number_of_lines
GtUword gt_file_number_of_lines(const char *path)
{
  GtUword number_of_lines = 0;
  GtFile *fp;
  int cc;
  gt_assert(path);
  fp = gt_file_xopen(path, "r");
  while ((cc = gt_file_xfgetc(fp)) != EOF)
    if (cc == '\n') number_of_lines++;
  gt_file_delete(fp);
  return number_of_lines;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x75d27
leaq 0x791b5(%rip), %rsi     # 0xeeea8
callq 0x756a8
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x75720
cmpl $-0x1, %eax
je 0x75d14
cmpl $0xa, %eax
jne 0x75cfd
incq %rbx
jmp 0x75cfd
movq %r14, %rdi
callq 0x75b7c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c0dd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_suffix
const char* gt_file_suffix(const char *path)
{
  const char *suffixptr;
  gt_assert(path);
  suffixptr = path + gt_file_basename_length(path) - 1;
  while (suffixptr > path) {
    if (*suffixptr == GT_PATH_SEPARATOR)
      return "";
    else if (*suffixptr == '.')
      break;
    suffixptr--;
  }
  return suffixptr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x75d5e
movq %rdi, %rbx
callq 0x7536b
addq %rbx, %rax
decq %rax
cmpq %rbx, %rax
jbe 0x75d5c
movzbl (%rax), %ecx
cmpl $0x2e, %ecx
je 0x75d5c
decq %rax
cmpl $0x2f, %ecx
jne 0x75d40
leaq 0x78e23(%rip), %rax     # 0xeeb7f
popq %rbx
retq
callq 0x1c114
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_dirname
void gt_file_dirname(GtStr *path, const char *file)
{
  GtWord i;
  gt_str_reset(path);
  for (i = (GtWord) (strlen(file) - 1); i >= 0; i--) {
    if (file[i] == GT_PATH_SEPARATOR)
      break;
  }
  if (i > 0)
    gt_str_append_cstr_nt(path, file, (GtUword) i);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3c49c
movq %rbx, %rdi
callq 0xb260
decq %rax
cmpq $-0x1, %rax
movq $-0x1, %rdx
cmovlq %rax, %rdx
testq %rax, %rax
js 0x75da4
leaq -0x1(%rax), %rcx
cmpb $0x2f, (%rbx,%rax)
movq %rcx, %rax
jne 0x75d8c
incq %rcx
movq %rcx, %rdx
testq %rdx, %rdx
jle 0x75dbb
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c185
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: file_exists_and_is_regular_executable
static bool file_exists_and_is_regular_executable(const char *path)
{
  bool is_exec = false;
  struct stat sb;
  FILE *file;
#ifdef _WIN32
  size_t len = strlen(path);
#endif
  if ((file = fopen(path, "r")) == NULL)
    return false;
  gt_xfstat(fileno(file), &sb);
  if (S_ISREG(sb.st_mode) &&
#ifndef _WIN32
      (sb.st_mode & S_IXUSR || sb.st_mode & S_IXGRP || sb.st_mode & S_IXOTH )
#else
      (len > 4 && !strcmp(path + len - 4, ".exe"))
#endif
     ) {
    is_exec = true;
  }
  gt_xfclose(file);
  return is_exec;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x78ec0(%rip), %rsi     # 0xeeea8
callq 0xb720
testq %rax, %rax
je 0x76032
movq %rax, %rbx
movq %rax, %rdi
callq 0xb6c0
movq %rsp, %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x83617
movl 0x18(%r14), %eax
movl %eax, %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x8000, %ecx           # imm = 0x8000
sete %cl
testb $0x49, %al
setne %bpl
andb %cl, %bpl
movq %rbx, %rdi
callq 0x3db69
jmp 0x76034
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_estimate_size
off_t gt_file_estimate_size(const char *file)
{
  off_t size;
  struct stat sb;
  GtFileMode gfm;
  int fd;

  gt_assert(file);

  fd = gt_xopen(file, O_RDONLY, 0);
  gt_xfstat(fd, &sb);
  gfm = gt_file_mode_determine(file);
  if (gfm == GT_FILE_MODE_UNCOMPRESSED)
    size = sb.st_size;
  else
    size = sb.st_size  * 4; /* expected compression rate for sequence is 0.25 */
  gt_xclose(fd);

  return size;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testq %rdi, %rdi
je 0x760ac
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x83681
movl %eax, %ebp
movq %rsp, %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x83617
movq %rbx, %rdi
callq 0x752e8
movq 0x30(%r14), %rcx
leaq (,%rcx,4), %rbx
testl %eax, %eax
cmoveq %rcx, %rbx
movl %ebp, %edi
callq 0x835f4
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1c1f6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size
off_t gt_file_size(const char *file)
{
  struct stat sb;
  int fd;
  gt_assert(file);
  fd = gt_xopen(file, O_RDONLY, 0);
  gt_xfstat(fd, &sb);
  gt_xclose(fd);
  return sb.st_size;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x760f0
xorl %esi, %esi
xorl %edx, %edx
callq 0x83681
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x83617
movl %ebx, %edi
callq 0x835f4
movq 0x30(%r14), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
callq 0x1c22f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_xfile_cmp
void gt_xfile_cmp(const char *file1,const char *file2)
{
  FILE *fp1, *fp2;
  off_t offset;
  int cc1, cc2;

  fp1 = fopen(file1, "rb");
  fp2 = fopen(file2, "rb");
  for (offset = 0; /* Nothing */; offset++)
  {
    cc1 = fgetc(fp1);
    cc2 = fgetc(fp2);
    if (cc1 != cc2)
    {
      fprintf(stderr,"files %s and %s differ in byte "GT_WU": %d != %d\n",
                      file1,file2,(GtUword) offset,cc1,cc2);
      exit(EXIT_FAILURE);
    }
    if (cc1 == EOF)
    {
      break;
    }
  }
  gt_xfclose(fp1);
  gt_xfclose(fp2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x77b31(%rip), %r15     # 0xedc3e
movq %r15, %rsi
callq 0xb720
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, %r13
movq %r12, %rdi
callq 0xb9e0
movl %eax, %ebp
movq %r13, %rdi
callq 0xb9e0
xorl %r15d, %r15d
cmpl %eax, %ebp
jne 0x76179
cmpl $-0x1, %ebp
je 0x7615b
incq %r15
movq %r12, %rdi
callq 0xb9e0
movl %eax, %ebp
movq %r13, %rdi
callq 0xb9e0
jmp 0x7613b
movq %r12, %rdi
callq 0x3db69
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3db69
movq 0xdae40(%rip), %rcx     # 0x150fc0
movq (%rcx), %rdi
movl %eax, (%rsp)
leaq 0x7affc(%rip), %rsi     # 0xf1189
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0xb8d0
movl $0x1, %edi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size_with_suffix
off_t gt_file_size_with_suffix(const char *path, const char *suffix)
{
  GtStr *tmpfilename;
  off_t tmpsize;

  gt_assert(path && suffix);

  tmpfilename = gt_str_new_cstr(path);
  gt_str_append_cstr(tmpfilename, suffix);
  tmpsize = gt_file_size(gt_str_get(tmpfilename));
  gt_str_delete(tmpfilename);
  return tmpsize;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x761f4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x761f4
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3c067
movq %r14, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x760b1
movq %rax, %rbx
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c268
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_estimate_total_size
off_t gt_files_estimate_total_size(const GtStrArray *filenames)
{
  GtUword filenum;
  off_t totalsize = 0;

  for (filenum = 0; filenum < gt_str_array_size(filenames); filenum++)
    totalsize += gt_file_estimate_size(gt_str_array_get(filenames, filenum));

  return totalsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3d560
xorl %r14d, %r14d
testq %rax, %rax
je 0x76237
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d3e2
movq %rax, %rdi
callq 0x76051
addq %rax, %r14
incq %r15
movq %rbx, %rdi
callq 0x3d560
cmpq %rax, %r15
jb 0x76211
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_guess_if_protein_sequences
int gt_files_guess_if_protein_sequences(const GtStrArray *filenames,
                                        GtError *err)
{
  unsigned int countnonbases = 0,
               currentposition;
  GtUchar currentchar;
  GtSequenceBuffer *fb;
  int retval;

  gt_error_check(err);
  fb = gt_sequence_buffer_new_guess_type(filenames, err);
  if (!fb) return -1;

  for (currentposition = 0; currentposition < 1000U;
       currentposition++)
  {
    retval = gt_sequence_buffer_next(fb,&currentchar,err);
    if (retval < 0)
    {
      gt_sequence_buffer_delete(fb);
      return -1;
    }
    if (retval == 0)
    {
      break;
    }
    switch (currentchar)
    {
      case 'L':
      case 'I':
      case 'F':
      case 'E':
      case 'Q':
      case 'P':
      case 'X':
      case 'Z': countnonbases++;
                break;
      default:  break;
    }
    if (countnonbases > 0)
    {
      break;
    }
  }
  gt_sequence_buffer_delete(fb);
  if (countnonbases > 0)
  {
    return 1; /* guess it is a protein sequence */
  }
  return 0; /* guess it is a dna sequence */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x76266
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x762e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7f21a
testq %rax, %rax
je 0x762cb
movq %rax, %r14
movl $0x3e8, %r12d           # imm = 0x3E8
leaq 0x7(%rsp), %r15
movl $0x281893, %r13d        # imm = 0x281893
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7f452
testl %eax, %eax
js 0x762e1
testl %eax, %eax
je 0x762c1
movzbl 0x7(%rsp), %eax
addl $-0x45, %eax
cmpl $0x15, %eax
ja 0x762b5
btl %eax, %r13d
jb 0x762bc
decl %r12d
jne 0x7628c
jmp 0x762c1
movl $0x1, %ebp
movq %r14, %rdi
callq 0x7f191
jmp 0x762d0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x762c1
callq 0x1c2a1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/grep.c
// Function: gt_grep_escape_extended
void gt_grep_escape_extended(GtStr *dest, const char *str, size_t len)
{
  size_t i;
  gt_assert(dest && str);
  gt_str_reset(dest);
  for (i= 0; i < len; i++) {
    switch (str[i]) {
      case '.':
      case '*':
      case '^':
      case '$':
      case '+':
      case '?':
      case '(':
      case ')':
      case '[':
      case '{':
      case '\\':
      case '|':
        gt_str_append_cstr(dest, "\\");
        break;
      default:
        break;
    }
    gt_str_append_char(dest, str[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7637a
movq %rsi, %r14
testq %rsi, %rsi
je 0x7637a
movq %rdx, %rbx
movq %rdi, %r15
callq 0x3c49c
testq %rbx, %rbx
je 0x7636b
xorl %r13d, %r13d
leaq 0x7af53(%rip), %r12     # 0xf1275
movabsq $0x5800000080004f1, %rbp # imm = 0x5800000080004F1
movzbl (%r14,%r13), %eax
leal -0x24(%rax), %ecx
cmpl $0x3a, %ecx
ja 0x76361
btq %rcx, %rbp
jae 0x76361
movq %r15, %rdi
movq %r12, %rsi
callq 0x3c067
movsbl (%r14,%r13), %esi
movq %r15, %rdi
callq 0x3c28d
incq %r13
cmpq %r13, %rbx
jne 0x7632c
jmp 0x7636b
addl $-0x7b, %eax
cmpl $0x2, %eax
jb 0x7633f
jmp 0x7634a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c2da