LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_bzopen_func
BZFILE* gt_fa_bzopen_func(const char *path, const char *mode,
                          const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_BZIP2, false, src_file,
                          src_line, err);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r8, %r8
je 0x7471d
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x74764
testq %r13, %r13
je 0x7475a
testq %r12, %r12
je 0x7475a
movq 0xde4a2(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x7475f
movq %r13, %rsi
movq %r12, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x742c4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1adc7
callq 0x1ae00
callq 0x1ad8e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_read_func
void* gt_fa_mmap_read_func(const char *path, size_t *len,
                           const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, false, false, src_file, src_line,
                                err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x74b9f
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x74bdf
testq %r13, %r13
je 0x74bd5
cmpq $0x0, 0xde024(%rip)     # 0x152bd0
je 0x74bda
movq %r12, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movl %ebx, %r9d
callq 0x74be4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1b0e5
callq 0x1b0ac
callq 0x1b073
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: mmap_generic_path_func
static void* mmap_generic_path_func(const char *path, size_t *len,
                                    bool mapwritable, bool hard_fail,
                                    const char *src_file, int src_line,
                                    GtError *err)
{
  int fd;
  void *map;
  size_t file_size;

  gt_error_check(err);
  gt_assert(fa && path);
  fd = open(path, mapwritable?O_RDWR:O_RDONLY, 0);
  if (fd == -1) {
    gt_error_set(err,"cannot open file \"%s\": %s", path, strerror(errno));
    return NULL;
  }
  file_size = fd_to_file_size(fd,path,hard_fail,err);
  if (file_size == -1)
  {
    return NULL;
  }
  map = gt_fa_mmap_generic_fd_func(fd, path, file_size, 0, mapwritable,
                                   hard_fail, src_file, src_line, err);
  if (map != NULL && len != NULL)
    *len = file_size;
  gt_xclose(fd);
  return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
movq 0xe0(%rsp), %r14
testq %r14, %r14
je 0x74c25
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x74d23
movq %r12, 0x8(%rsp)
cmpq $0x0, 0xddf9e(%rip)     # 0x152bd0
je 0x74d1e
movzbl %r15b, %r15d
leal (%r15,%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbae0
cmpl $-0x1, %eax
je 0x74c67
movl %eax, %r12d
leaq 0x18(%rsp), %rsi
movl %eax, %edi
testb %bpl, %bpl
je 0x74c7c
callq 0x831ff
jmp 0x74cad
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7c085(%rip), %rsi     # 0xf0cff
jmp 0x74c98
callq 0xbb90
testl %eax, %eax
je 0x74cad
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7c081(%rip), %rsi     # 0xf0d19
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
jmp 0x74d09
movq %r14, %rax
movq %r13, %r14
movq 0x48(%rsp), %r13
cmpq $-0x1, %r13
je 0x74d06
subq $0x8, %rsp
movzbl %bpl, %r9d
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
pushq %rax
pushq 0x20(%rsp)
pushq 0x20(%rsp)
callq 0x749fd
addq $0x20, %rsp
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x74cfc
movq %r13, (%r14)
movl %r12d, %edi
callq 0x831dc
jmp 0x74d09
xorl %r15d, %r15d
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b157
callq 0x1b11e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_read_func_range
void* gt_fa_mmap_read_func_range(const char *path, size_t len, size_t offset,
                                 const char *src_file, int src_line,
                                 GtError *err)
{
  gt_error_check(err);
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, false, false,
                                      src_file, src_line, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x74d56
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x74d97
testq %rbp, %rbp
je 0x74d8d
cmpq $0x0, 0xdde6d(%rip)     # 0x152bd0
je 0x74d92
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x74d9c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b202
callq 0x1b1c9
callq 0x1b190
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: mmap_generic_path_func_range
static void* mmap_generic_path_func_range(const char *path, size_t len,
                                          size_t offset,
                                          bool mapwritable, bool hard_fail,
                                          const char *src_file, int src_line,
                                          GtError *err)
{
  int fd;
  void *map;

  gt_error_check(err);
  gt_assert(fa && path);
  fd = open(path, mapwritable?O_RDWR:O_RDONLY, 0);
  if (fd == -1) {
    gt_error_set(err,"cannot open file \"%s\": %s", path, strerror(errno));
    return NULL;
  }
  map = gt_fa_mmap_generic_fd_func(fd, path, len, offset, mapwritable,
                                   hard_fail, src_file, src_line, err);
  gt_xclose(fd);
  return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x74dd0
callq 0x34fea
testb %al, %al
jne 0x74e70
cmpq $0x0, 0xdddf8(%rip)     # 0x152bd0
je 0x74e6b
movzbl %bl, %ebx
leal (%rbx,%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbae0
cmpl $-0x1, %eax
je 0x74e35
movl %eax, %r15d
movl 0x40(%rsp), %eax
subq $0x8, %rsp
movzbl %bpl, %r9d
movl %r15d, %edi
movq %r14, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movl %ebx, %r8d
pushq 0x50(%rsp)
pushq %rax
pushq %r12
callq 0x749fd
addq $0x20, %rsp
movq %rax, %rbx
movl %r15d, %edi
callq 0x831dc
movq %rbx, %rax
jmp 0x74e5c
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7beb7(%rip), %rsi     # 0xf0cff
movq 0x48(%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b274
callq 0x1b23b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_write_func
void* gt_fa_mmap_write_func(const char *path, size_t *len,
                            const char *src_file, int src_line, GtError *err)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, true, false, src_file, src_line,
                                err);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74ea0
cmpq $0x0, 0xddd4d(%rip)     # 0x152bd0
je 0x74ea5
movl %ecx, %r9d
movq %rdx, %rax
movq %r8, (%rsp)
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x74be4
popq %rcx
retq
callq 0x1b2e6
callq 0x1b2ad
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_write_func_range
void* gt_fa_mmap_write_func_range(const char *path, size_t len, size_t offset,
                                  const char *src_file, int src_line,
                                  GtError *err)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, true, false, src_file,
                                      src_line, err);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74ed9
cmpq $0x0, 0xddd18(%rip)     # 0x152bd0
je 0x74ede
movq %r9, %r10
movl %r8d, %eax
movq %rcx, %r9
movl $0x1, %ecx
xorl %r8d, %r8d
pushq %r10
pushq %rax
callq 0x74d9c
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b358
callq 0x1b31f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_read_func
void* gt_fa_xmmap_read_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, false, true, src_file, src_line,
                                NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74f0f
cmpq $0x0, 0xddcdf(%rip)     # 0x152bd0
je 0x74f14
movl %ecx, %r9d
movq %rdx, %r8
movq $0x0, (%rsp)
xorl %edx, %edx
movl $0x1, %ecx
callq 0x74be4
popq %rcx
retq
callq 0x1b3ca
callq 0x1b391
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_heap_read_func
void *gt_fa_heap_read_func(const char *path, size_t *len,
                           const char *src_file, int src_line, GtError *err)
{
  int fd;
  struct stat buf;
  bool haserr = false;

  gt_assert(path != NULL);
  fd = open(path,O_RDONLY); /* open file for read, get filedes */
  if (fd == -1) /* check for error code */
  {
    gt_error_set(err,"%s, line %d: cannot open \"%s\"",src_file,src_line,path);
    haserr = true;
  }
  if (!haserr && fstat(fd,&buf) == -1)  /* get status information of file */
  {
    gt_error_set(err,"%s, line %d: cannot access status of file \"%s\"",
                 src_file,src_line,path);
    close(fd);
    haserr = true;
  }
  if (!haserr)
  {
    void *ptr;

    *len = buf.st_size;
    ptr = gt_malloc(*len);
    gt_assert(fd > 0);
    if (read(fd,ptr,*len) == -1)
    {
      gt_error_set(err,"%s, line %d: read(%s) failed",src_file,src_line,path);
      haserr = true;
    }
    if (haserr)
    {
      gt_free(ptr);
      return NULL;
    }
    close(fd);
    return ptr;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x7503a
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0xbae0
cmpl $-0x1, %eax
je 0x74fe0
movl %eax, %r13d
movl %r12d, 0x4(%rsp)
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0xbb90
cmpl $-0x1, %eax
je 0x74fff
movq 0x38(%rsp), %rdi
movq %rdi, (%rbp)
leaq 0x7b904(%rip), %rsi     # 0xf0885
movl $0x262, %edx            # imm = 0x262
callq 0x35862
testl %r13d, %r13d
jle 0x7503f
movq %rax, %r12
movq (%rbp), %rdx
movl %r13d, %edi
movq %rax, %rsi
callq 0xb8e0
cmpq $-0x1, %rax
jne 0x7501d
leaq 0x7bb5d(%rip), %rsi     # 0xf0b10
movq %r15, %rdi
movq %r14, %rdx
movl 0x4(%rsp), %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
leaq 0x7b8b7(%rip), %rsi     # 0xf0885
movq %r12, %rdi
movl $0x26b, %edx            # imm = 0x26B
callq 0x35c27
xorl %r12d, %r12d
jmp 0x75025
leaq 0x7bad5(%rip), %rsi     # 0xf0abc
movl %r12d, %ecx
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
jmp 0x75025
leaq 0x7bad4(%rip), %rsi     # 0xf0ada
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rdx
movl 0x4(%rsp), %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
movl %r13d, %edi
callq 0xbcd0
movq %r12, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b43c
callq 0x1b403
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_read_func_range
void* gt_fa_xmmap_read_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, false, true,
                                      src_file, src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x75070
cmpq $0x0, 0xddb7e(%rip)     # 0x152bd0
je 0x75075
movl %r8d, %eax
movq %rcx, %r9
xorl %ecx, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x74d9c
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b4ae
callq 0x1b475
// File: /workspace/github_c_makefile_star2_O3/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 0x750a9
cmpq $0x0, 0xddb48(%rip)     # 0x152bd0
je 0x750ae
movl %ecx, %r9d
movq %rdx, %r8
movq $0x0, (%rsp)
movl $0x1, %edx
movl $0x1, %ecx
callq 0x74be4
popq %rcx
retq
callq 0x1b520
callq 0x1b4e7
// File: /workspace/github_c_makefile_star2_O3/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 0x750e2
cmpq $0x0, 0xddb0f(%rip)     # 0x152bd0
je 0x750e7
movl %r8d, %eax
movq %rcx, %r9
movl $0x1, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x74d9c
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b592
callq 0x1b559
// File: /workspace/github_c_makefile_star2_O3/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 0xddad9(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x7518b
movq %rdi, %rbx
testq %rdi, %rdi
je 0x75183
movq 0x8(%rax), %rdi
callq 0x3d043
movq 0xddab8(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x75190
movq %rax, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x832c4
movq 0xdda92(%rip), %rax     # 0x152bd0
movq 0x20(%rax), %rcx
movq (%r14), %rdi
subq %rdi, %rcx
jb 0x75195
movq %rcx, 0x20(%rax)
cmpb $0x1, 0x30(%rax)
jne 0x75160
callq 0x39e79
movq 0xdda70(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x77666
movq 0xdda5d(%rip), %rax     # 0x152bd0
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d05e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1b63d
callq 0x1b604
callq 0x1b5cb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_read_with_suffix_func
void* gt_fa_mmap_read_with_suffix_func(const char *path, const char *suffix,
                                       size_t *len, const char *src_file,
                                       int src_line, GtError *err)
{
  GtStr *tmpfilename;
  void *ptr;
  gt_error_check(err);
  tmpfilename = gt_str_new_cstr(path);
  gt_str_append_cstr(tmpfilename,suffix);
  ptr = gt_fa_mmap_read_func(gt_str_get(tmpfilename), len, src_file, src_line,
                             err);
  gt_str_delete(tmpfilename);
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r9, %r9
je 0x751c8
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x75216
movq %r13, %rdi
callq 0x3b785
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3b7af
movq %r13, %rdi
callq 0x3bb5d
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x74b73
movq %rax, %rbx
movq %r13, %rdi
callq 0x3c87b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b676
// File: /workspace/github_c_makefile_star2_O3/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 0x7b646(%rip), %rcx     # 0xf0885
leaq 0x10(%rsp), %rdx
movl $0x2dd, %r8d            # imm = 0x2DD
movq %r12, %r9
callq 0x7519a
testq %rax, %rax
je 0x752b3
movq %rax, %rbx
movq %rbp, 0x8(%rsp)
movq %r14, %rbp
movq 0x10(%rsp), %r14
testq %r12, %r12
je 0x75278
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x752c7
movq %r14, %rax
xorl %edx, %edx
divq %rbp
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x752b5
movq %rcx, (%rsp)
leaq 0x7bad3(%rip), %rsi     # 0xf0d68
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x34f1f
movq %rbx, %rdi
callq 0x750ec
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b6af
// File: /workspace/github_c_makefile_star2_O3/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 0xdd8fc(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x75300
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x10(%rax), %rdi
leaq 0x1e(%rip), %rsi        # 0x7530a
xorl %ecx, %ecx
callq 0x776d9
testl %eax, %eax
jne 0x75305
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0x1b721
callq 0x1b6e8
// File: /workspace/github_c_makefile_star2_O3/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 0x75330
testq %rsi, %rsi
je 0x75330
testq %rdx, %rdx
je 0x75330
cmpb $0x0, (%rdx)
je 0x75323
xorl %eax, %eax
popq %rcx
retq
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1b793
jmp 0x7531f
callq 0x1b75a
// File: /workspace/github_c_makefile_star2_O3/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 0xdd893(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x75369
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x18(%rax), %rdi
leaq 0x1e(%rip), %rsi        # 0x75373
xorl %ecx, %ecx
callq 0x776d9
testl %eax, %eax
jne 0x7536e
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0x1b7f6
callq 0x1b7bd
// File: /workspace/github_c_makefile_star2_O3/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 0x75399
testq %rsi, %rsi
je 0x75399
testq %rdx, %rdx
je 0x75399
cmpb $0x0, (%rdx)
je 0x7538c
xorl %eax, %eax
popq %rcx
retq
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1b868
jmp 0x75388
callq 0x1b82f
// File: /workspace/github_c_makefile_star2_O3/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 0xdd79e(%rip), %rax     # 0x152bd0
testq %rax, %rax
je 0x75497
pushq %rax
movq (%rax), %rdi
callq 0x3d021
movq 0xdd789(%rip), %rax     # 0x152bd0
movq 0x8(%rax), %rdi
callq 0x3d021
movq 0xdd779(%rip), %rax     # 0x152bd0
movq 0x10(%rax), %rdi
callq 0x77bab
movq 0xdd769(%rip), %rax     # 0x152bd0
movq 0x18(%rax), %rdi
callq 0x77bab
movq 0xdd759(%rip), %rdi     # 0x152bd0
leaq 0x7b407(%rip), %rsi     # 0xf0885
movl $0x340, %edx            # imm = 0x340
callq 0x35c27
movq $0x0, 0xdd73d(%rip) # 0x152bd0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testq %rdx, %rdx
je 0x756bb
movq %r9, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %r15
movl $0x3e, %edi
movq %r15, %rsi
callq 0x75f43
testq %r14, %r14
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x755e8
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
testl %edi, %edi
je 0x755e8
movq %r15, %rsi
callq 0x75f43
incq %r12
cmpq %r12, %rbp
jne 0x755cf
movl $0xa, %edi
movq %r15, %rsi
callq 0x75f43
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x7564d
xorl %ebp, %ebp
xorl %r14d, %r14d
movb (%r13,%rbp), %al
testb %al, %al
je 0x75650
testq %rbx, %rbx
setne %cl
cmpq %rbx, %r14
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x75635
movl $0xa, %edi
movq %r15, %rsi
callq 0x75f43
movb (%r13,%rbp), %al
xorl %r14d, %r14d
movsbl %al, %edi
movq %r15, %rsi
callq 0x75f43
incq %rbp
incq %r14
cmpq %rbp, %r12
jne 0x75604
jmp 0x75650
xorl %r14d, %r14d
movq 0x10(%rsp), %rbp
testq %rbp, %rbp
je 0x756a0
movq %rbp, %rdi
callq 0xb260
testq %rax, %rax
je 0x756a0
movq %rax, %r12
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x75687
cmpq %rbx, %r14
jne 0x75687
movl $0xa, %edi
movq %r15, %rsi
callq 0x75f43
xorl %r14d, %r14d
movsbl (%rbp,%r13), %edi
movq %r15, %rsi
callq 0x75f43
incq %r13
incq %r14
cmpq %r13, %r12
jne 0x7566d
movl $0xa, %edi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x75f43
callq 0x1b97a
// File: /workspace/github_c_makefile_star2_O3/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, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testq %rdx, %rdx
je 0x7581e
movq 0x50(%rsp), %r15
testq %r15, %r15
je 0x7581e
movq %r9, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %r15, %rdi
movl $0x3e, %esi
callq 0x3b9df
testq %r14, %r14
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x7574b
xorl %r12d, %r12d
movb (%r14,%r12), %al
testb %al, %al
je 0x7574b
movsbl %al, %esi
movq %r15, %rdi
callq 0x3b9df
incq %r12
cmpq %r12, %rbp
jne 0x75730
movq %r15, %rdi
movl $0xa, %esi
callq 0x3b9df
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x757b0
xorl %ebp, %ebp
xorl %r14d, %r14d
movb (%r13,%rbp), %al
testb %al, %al
je 0x757b3
testq %rbx, %rbx
setne %cl
cmpq %rbx, %r14
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x75798
movq %r15, %rdi
movl $0xa, %esi
callq 0x3b9df
movb (%r13,%rbp), %al
xorl %r14d, %r14d
movsbl %al, %esi
movq %r15, %rdi
callq 0x3b9df
incq %rbp
incq %r14
cmpq %rbp, %r12
jne 0x75767
jmp 0x757b3
xorl %r14d, %r14d
movq 0x10(%rsp), %rbp
testq %rbp, %rbp
je 0x75803
movq %rbp, %rdi
callq 0xb260
testq %rax, %rax
je 0x75803
movq %rax, %r12
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x757ea
cmpq %rbx, %r14
jne 0x757ea
movq %r15, %rdi
movl $0xa, %esi
callq 0x3b9df
xorl %r14d, %r14d
movsbl (%rbp,%r13), %esi
movq %r15, %rdi
callq 0x3b9df
incq %r13
incq %r14
cmpq %r13, %r12
jne 0x757d0
movq %r15, %rdi
movl $0xa, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b9df
callq 0x1b9b1
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x75885
movq %rdi, %r14
callq 0xb260
cmpq $0x4, %rax
jb 0x75885
movq %rax, %r15
leaq (%r14,%rax), %rsi
addq $-0x3, %rsi
leaq 0x7b696(%rip), %rdi     # 0xf0ee6
callq 0xb890
testl %eax, %eax
je 0x75880
cmpq $0x4, %r15
je 0x75885
addq %r15, %r14
addq $-0x4, %r14
leaq 0x7b67d(%rip), %rdi     # 0xf0eea
movq %r14, %rsi
callq 0xb890
testl %eax, %eax
jne 0x75885
movl $0x2, %ebx
jmp 0x75885
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75919
movq %rdi, %r14
callq 0xb260
cmpq $0x4, %rax
jb 0x75911
movq %rax, %rbx
leaq (%r14,%rax), %rsi
addq $-0x3, %rsi
leaq 0x7b614(%rip), %rdi     # 0xf0ee6
callq 0xb890
testl %eax, %eax
je 0x7590a
movl $0x4, %eax
cmpq $0x4, %rbx
je 0x75911
addq %rbx, %r14
addq $-0x4, %r14
leaq 0x7b5f6(%rip), %rdi     # 0xf0eea
movq %r14, %rsi
callq 0xb890
movl %eax, %ecx
leaq -0x4(%rbx), %rax
testl %ecx, %ecx
cmovneq %rbx, %rax
jmp 0x75911
addq $-0x3, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ba21
// File: /workspace/github_c_makefile_star2_O3/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 0x75991
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0x75a8e
testq %r12, %r12
je 0x75a89
leaq 0x7b562(%rip), %rdx     # 0xf0f03
movl $0x1, %edi
movl $0x30, %esi
movl $0x6b, %ecx
callq 0x359a6
movq %rax, %rbx
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
testq %r14, %r14
je 0x759f5
cmpl $0x2, %ebp
je 0x75a36
cmpl $0x1, %ebp
je 0x75a11
testl %ebp, %ebp
jne 0x75a98
leaq 0x7b523(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r12, %rsi
movl $0x71, %ecx
movq %r15, %r8
callq 0x74253
jmp 0x75a2b
testl %ebp, %ebp
jne 0x75a93
movq 0xdb58c(%rip), %rax     # 0x150f90
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x75a7d
leaq 0x7b4eb(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r12, %rsi
movl $0x78, %ecx
movq %r15, %r8
callq 0x745f8
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x75a7d
jmp 0x75a73
leaq 0x7b4c6(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r12, %rsi
movl $0x7f, %ecx
movq %r15, %r8
callq 0x746f5
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x75a73
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x20(%rbx)
jmp 0x75a7d
movq %rbx, %rdi
callq 0x75aaa
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1bb6f
callq 0x1bac6
callq 0x1bb36
callq 0x1bafd
// File: /workspace/github_c_makefile_star2_O3/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 0x75af6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x7b442(%rip), %r14     # 0xf0f03
movq %r14, %rsi
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x35c27
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1ac, %edx            # imm = 0x1AC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75bdd
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
leaq 0x7b3ed(%rip), %rdx     # 0xf0f03
movl $0x1, %edi
movl $0x30, %esi
movl $0x97, %ecx
callq 0x359a6
movq %rax, %rbx
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
testq %r14, %r14
je 0x75b67
cmpl $0x2, %ebp
je 0x75b9c
cmpl $0x1, %ebp
je 0x75b7f
testl %ebp, %ebp
jne 0x75be7
leaq 0x7b3ae(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r15, %rsi
movl $0x9d, %ecx
callq 0x743ed
jmp 0x75b96
testl %ebp, %ebp
jne 0x75be2
movq 0xdb41e(%rip), %rax     # 0x150f90
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x75bcf
leaq 0x7b37d(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r15, %rsi
movl $0xa0, %ecx
callq 0x7466c
movq %rax, 0x10(%rbx)
jmp 0x75bcf
leaq 0x7b360(%rip), %rdx     # 0xf0f03
movq %r14, %rdi
movq %r15, %rsi
movl $0xa3, %ecx
callq 0x74769
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1bc18
callq 0x1bbdf
callq 0x1bba6
// File: /workspace/github_c_makefile_star2_O3/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 0x75c51
movq %rdi, %rbx
leaq 0x7b2da(%rip), %rdx     # 0xf0f03
movl $0x1, %edi
movl $0x30, %esi
movl $0xbc, %ecx
callq 0x359a6
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
callq 0x1bc8a
// File: /workspace/github_c_makefile_star2_O3/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 0x75ccc
cmpb $0x1, 0x2a(%rdi)
je 0x75cdf
movb %sil, 0x28(%rdi)
movb $0x1, 0x2a(%rdi)
retq
movsbl %sil, %edi
movq 0xdb2b9(%rip), %rax     # 0x150f90
movq (%rax), %rsi
jmp 0x3d3eb
pushq %rax
callq 0x1bd35
// File: /workspace/github_c_makefile_star2_O3/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 0x75d4b
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 0x75db2
testl %eax, %eax
je 0x75d97
jle 0x75da8
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
movq %r12, 0x8(%rdx)
movq %r13, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %ecx
callq 0x75db2
testl %eax, %eax
jne 0x75dad
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1bd6e
callq 0x1bda7
// File: /workspace/github_c_makefile_star2_O3/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 0x75def
movl %ecx, %r14d
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x75e6a
cmpl $0x1, %eax
je 0x75e09
testl %eax, %eax
jne 0x75f34
movq 0x10(%rdi), %rdi
jmp 0x75df9
movq 0xdb162(%rip), %rax     # 0x150f58
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3d401
jmp 0x75ece
movq 0x10(%rdi), %r12
testl %r14d, %r14d
je 0x75ee2
leal 0x1(%r14), %ebp
leaq 0x7b0e2(%rip), %rsi     # 0xf0f03
movq %rbp, %rdi
movl $0xff, %edx
callq 0x35862
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3d412
cmpl %r14d, %eax
jne 0x75f39
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x83471
leaq 0x7b0a3(%rip), %rsi     # 0xf0f03
movq %r13, %rdi
movl $0x103, %edx            # imm = 0x103
jmp 0x75ec9
movq 0x10(%rdi), %r12
testl %r14d, %r14d
je 0x75f0b
leal 0x1(%r14), %ebp
leaq 0x7b081(%rip), %rsi     # 0xf0f03
movq %rbp, %rdi
movl $0x116, %edx            # imm = 0x116
callq 0x35862
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3d412
cmpl %r14d, %eax
jne 0x75f3e
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x83195
leaq 0x7b042(%rip), %rsi     # 0xf0f03
movq %r13, %rdi
movl $0x11a, %edx            # imm = 0x11A
callq 0x35c27
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 0x3d412
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x75ed0
movq %rsp, %rsi
movq %r12, %rdi
movl %eax, %edx
callq 0x83471
jmp 0x75ece
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3d412
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x75ed0
movq %rsp, %rsi
movq %r12, %rdi
movl %eax, %edx
callq 0x83195
jmp 0x75ece
callq 0x1be52
callq 0x1be19
callq 0x1bde0
// File: /workspace/github_c_makefile_star2_O3/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 0x75f61
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x75f79
cmpl $0x1, %eax
je 0x75f70
testl %eax, %eax
jne 0x75f82
movq 0x10(%rsi), %rsi
jmp 0x3d29e
movq 0xdaff0(%rip), %rax     # 0x150f58
movq (%rax), %rsi
jmp 0x3d29e
movq 0x10(%rsi), %rsi
jmp 0x8341c
movq 0x10(%rsi), %rsi
jmp 0x83135
pushq %rax
callq 0x1be8b
// File: /workspace/github_c_makefile_star2_O3/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 0x75fa6
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x75fbe
cmpl $0x1, %eax
je 0x75fb5
testl %eax, %eax
jne 0x75fc7
movq 0x10(%rsi), %rsi
jmp 0x3d2b0
movq 0xdafab(%rip), %rax     # 0x150f58
movq (%rax), %rsi
jmp 0x3d2b0
movq 0x10(%rsi), %rsi
jmp 0x83446
movq 0x10(%rsi), %rsi
jmp 0x83161
pushq %rax
callq 0x1bec4
// File: /workspace/github_c_makefile_star2_O3/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 0x75fec
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x76012
cmpl $0x1, %ecx
je 0x76005
testl %ecx, %ecx
jne 0x7601f
movq 0x10(%rdi), %rcx
jmp 0x75ff6
movq 0xdaf9d(%rip), %rcx     # 0x150f90
movq (%rcx), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0x3d2cc
popq %rcx
retq
movq 0x10(%rdi), %rdi
movq %rax, %rsi
popq %rax
jmp 0x833f7
movq 0x10(%rdi), %rdi
movq %rax, %rsi
popq %rax
jmp 0x83123
callq 0x1befd
// File: /workspace/github_c_makefile_star2_O3/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 0x76042
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x76065
cmpl $0x1, %ecx
je 0x76059
testl %ecx, %ecx
jne 0x76071
movq 0x10(%rdi), %rcx
jmp 0x7604c
movq 0xdaf0f(%rip), %rcx     # 0x150f58
movq (%rcx), %rcx
movl $0x1, %esi
movq %rax, %rdi
jmp 0x3d320
movq 0x10(%rdi), %rdi
movq %rax, %rsi
jmp 0x83471
movq 0x10(%rdi), %rdi
movq %rax, %rsi
jmp 0x83195
pushq %rax
callq 0x1bf36
// File: /workspace/github_c_makefile_star2_O3/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 0x760b6
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x760a1
cmpl $0x1, %eax
je 0x76097
testl %eax, %eax
jne 0x760bb
movq 0x10(%rdi), %rdi
popq %rax
jmp 0xb0c0
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x834a0
leaq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
movq %rax, %rdi
popq %rax
jmp 0x831b2
callq 0x1bfa8
callq 0x1bf6f
// File: /workspace/github_c_makefile_star2_O3/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 0x760d9
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x760db
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x76107
cmpl $0x1, %eax
je 0x760fc
testl %eax, %eax
jne 0x76119
cmpb $0x0, 0x29(%rbx)
jne 0x76110
movq 0x10(%rbx), %rdi
callq 0x744b0
jmp 0x76110
movq 0x10(%rbx), %rdi
callq 0x746b1
jmp 0x76110
movq 0x10(%rbx), %rdi
callq 0x747ae
movq %rbx, %rdi
popq %rbx
jmp 0x75aaa
callq 0x1bfe1
nop