LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_fopen_func
FILE* gt_fa_fopen_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_UNCOMPRESSED, 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 0x51866
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x518fa
testq %r13, %r13
je 0x5189e
testq %r12, %r12
je 0x5189e
movq 0xde349(%rip), %rdi     # 0x12fbc0
testq %rdi, %rdi
je 0x518cc
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x51932
popq %rcx
popq %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdc713(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x787b7(%rip), %rsi     # 0xca066
leaq 0x87f9e(%rip), %rdx     # 0xd9854
leaq 0x87f86(%rip), %rcx     # 0xd9843
leaq 0x87f71(%rip), %r8      # 0xd9835
movl $0xb6, %r9d
jmp 0x51926
movq 0xdc6e5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78789(%rip), %rsi     # 0xca066
leaq 0x87f43(%rip), %rdx     # 0xd9827
leaq 0x87f58(%rip), %rcx     # 0xd9843
leaq 0x87f43(%rip), %r8      # 0xd9835
movl $0xb7, %r9d
jmp 0x51926
movq 0xdc6b7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7875b(%rip), %rsi     # 0xca066
leaq 0x78d47(%rip), %rdx     # 0xca659
leaq 0x87f2a(%rip), %rcx     # 0xd9843
leaq 0x87f15(%rip), %r8      # 0xd9835
movl $0xb5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: fileopen_generic
static void* fileopen_generic(FA *fa, const char *path, const char *mode,
                              GtFileMode file_mode, bool x,
                              const char *src_file, int src_line, GtError *err)
{
  void  *fp = NULL;
  FAFileInfo *fileinfo;
  gt_error_check(err);
  gt_assert(fa && path && mode);
  fileinfo = gt_malloc(sizeof (FAFileInfo));
  fileinfo->src_file = src_file;
  fileinfo->src_line = src_line;
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      fp = x ? gt_xfopen(path, mode) : gt_efopen(path, mode, err);
      break;
    case GT_FILE_MODE_GZIP:
      fp = x ? gt_xgzopen(path, mode) : gt_egzopen(path, mode, err);
      break;
    case GT_FILE_MODE_BZIP2:
      fp = x ? gt_xbzopen(path, mode) : gt_ebzopen(path, mode, err);
      break;
    default: gt_assert(0);
  }
  if (fp) {
    gt_mutex_lock(fa->file_mutex);
    gt_hashmap_add(fa->file_pointer, fp, fileinfo);
    gt_mutex_unlock(fa->file_mutex);
  }
  else
    gt_free(fileinfo);
  return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x5196d
callq 0xc103
testb %al, %al
jne 0x51a55
movl 0x50(%rsp), %r15d
leaq 0x87ebc(%rip), %rsi     # 0xd9835
pushq $0x10
popq %rdi
pushq $0x6b
popq %rdx
callq 0xccb0
movq %rax, %r14
movq %rbx, (%rax)
movl %r15d, 0x8(%rax)
movq %r12, %rdi
cmpl $0x2, %r13d
je 0x519ae
cmpl $0x1, %r13d
jne 0x519bf
testb %bpl, %bpl
je 0x519d0
movq 0x8(%rsp), %rsi
callq 0x626f8
jmp 0x51a01
testb %bpl, %bpl
je 0x519e1
movq 0x8(%rsp), %rsi
callq 0x62150
jmp 0x51a01
testb %bpl, %bpl
je 0x519f2
movq 0x8(%rsp), %rsi
callq 0x163c0
jmp 0x51a01
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x843a8
jmp 0x51a01
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x84314
jmp 0x51a01
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x84280
movq %rax, %r15
testq %rax, %rax
je 0x51a2f
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0x16028
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x55f31
movq (%rbx), %rdi
callq 0x1609f
jmp 0x51a43
leaq 0x87dff(%rip), %rsi     # 0xd9835
movq %r14, %rdi
movl $0x80, %edx
callq 0xd249
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdc55c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78600(%rip), %rsi     # 0xca066
leaq 0x78bec(%rip), %rdx     # 0xca659
leaq 0x881cf(%rip), %rcx     # 0xd9c43
leaq 0x87dba(%rip), %r8      # 0xd9835
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xfopen_func
FILE* gt_fa_xfopen_func(const char *path, const char *mode,
                        const char *src_file, int src_line)
{
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_UNCOMPRESSED, true,
                          src_file, src_line, NULL);
}

// Assembly:
subq $0x18, %rsp
testq %rdi, %rdi
je 0x51ac7
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x51ac7
movq %rdi, %rsi
movq 0xde117(%rip), %rdi     # 0x12fbc0
testq %rdi, %rdi
je 0x51af5
andq $0x0, 0x8(%rsp)
movl %ecx, (%rsp)
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x51932
addq $0x18, %rsp
retq
movq 0xdc4ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7858e(%rip), %rsi     # 0xca066
leaq 0x87d75(%rip), %rdx     # 0xd9854
leaq 0x87d7b(%rip), %rcx     # 0xd9861
leaq 0x87d48(%rip), %r8      # 0xd9835
movl $0xbf, %r9d
jmp 0x51b21
movq 0xdc4bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78560(%rip), %rsi     # 0xca066
leaq 0x87d1a(%rip), %rdx     # 0xd9827
leaq 0x87d4d(%rip), %rcx     # 0xd9861
leaq 0x87d1a(%rip), %r8      # 0xd9835
movl $0xc0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_fopen_with_suffix_func
FILE* gt_fa_fopen_with_suffix_func(const char *path, const char *suffix,
                                   const char *mode, const char *src_file,
                                   int src_line, GtError *err)
{
  GtStr *tmpfilename;
  FILE *fp;
  gt_error_check(err);
  tmpfilename = gt_str_new_cstr(path);
  gt_str_append_cstr(tmpfilename, suffix);
  fp = gt_fa_fopen_func(gt_str_get(tmpfilename), mode, src_file, src_line, err);
  gt_str_delete(tmpfilename);
  return fp;
}

// 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 0x51b5b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x51ba9
movq %r13, %rdi
callq 0x13da9
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x13dd3
movq %r13, %rdi
callq 0x143d2
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x5183a
movq %rax, %rbx
movq %r13, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdc408(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x784ac(%rip), %rsi     # 0xca066
leaq 0x78a98(%rip), %rdx     # 0xca659
leaq 0x87cab(%rip), %rcx     # 0xd9873
leaq 0x87c66(%rip), %r8      # 0xd9835
movl $0xcb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: fclose_generic
static void fclose_generic(void *stream, GtFileMode file_mode, FA *fa)
{
  /*FAFileInfo *fileinfo;*/
  gt_assert(stream && fa);
  gt_mutex_lock(fa->file_mutex);
  /*fileinfo = gt_hashmap_get(fa->file_pointer, stream);*/
  gt_assert(gt_hashmap_get(fa->file_pointer, stream));
  gt_hashmap_remove(fa->file_pointer, stream);
  gt_mutex_unlock(fa->file_mutex);
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      fclose(stream);
      break;
    case GT_FILE_MODE_GZIP:
      gzclose(stream);
      break;
    case GT_FILE_MODE_BZIP2:
      BZ2_bzclose(stream);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x16028
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x51c91
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x55f6f
movq (%r14), %rdi
callq 0x1609f
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x51c7f
cmpl $0x1, %ebp
jne 0x51c88
popq %rbx
popq %r14
popq %rbp
jmp 0x7a054
popq %rbx
popq %r14
popq %rbp
jmp 0x79e9e
popq %rbx
popq %r14
popq %rbp
jmp 0xb690
movq 0xdc320(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x783c4(%rip), %rsi     # 0xca066
leaq 0x87fab(%rip), %rdx     # 0xd9c54
leaq 0x87fce(%rip), %rcx     # 0xd9c7e
leaq 0x87b7e(%rip), %r8      # 0xd9835
movl $0x8a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: xfclose_generic
static void xfclose_generic(void *stream, GtFileMode file_mode, FA *fa)
{
  /*FAFileInfo *fileinfo;*/
  gt_assert(stream && fa);
  gt_mutex_lock(fa->file_mutex);
  /*fileinfo = gt_hashmap_get(fa->file_pointer, stream);*/
  gt_assert(gt_hashmap_get(fa->file_pointer, stream));
  gt_hashmap_remove(fa->file_pointer, stream);
  gt_mutex_unlock(fa->file_mutex);
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfclose(stream);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzclose(stream);
      break;
    case GT_FILE_MODE_BZIP2:
      BZ2_bzclose(stream);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x16028
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x51d79
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x55f6f
movq (%r14), %rdi
callq 0x1609f
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x51d67
cmpl $0x1, %ebp
jne 0x51d70
popq %rbx
popq %r14
popq %rbp
jmp 0x6291c
popq %rbx
popq %r14
popq %rbp
jmp 0x79e9e
popq %rbx
popq %r14
popq %rbp
jmp 0x162e4
movq 0xdc238(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x782dc(%rip), %rsi     # 0xca066
leaq 0x87ec3(%rip), %rdx     # 0xd9c54
leaq 0x87ee5(%rip), %rcx     # 0xd9c7d
leaq 0x87a96(%rip), %r8      # 0xd9835
movl $0xa1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_gzopen_func
gzFile gt_fa_gzopen_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_GZIP, 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 0x51e87
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x51f1c
testq %r13, %r13
je 0x51ec0
testq %r12, %r12
je 0x51ec0
movq 0xddd28(%rip), %rdi     # 0x12fbc0
testq %rdi, %rdi
je 0x51eee
pushq $0x1
popq %rcx
movq %r13, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x51932
popq %rcx
popq %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdc0f1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78195(%rip), %rsi     # 0xca066
leaq 0x8797c(%rip), %rdx     # 0xd9854
leaq 0x879f3(%rip), %rcx     # 0xd98d2
leaq 0x8794f(%rip), %r8      # 0xd9835
movl $0xf7, %r9d
jmp 0x51f48
movq 0xdc0c3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78167(%rip), %rsi     # 0xca066
leaq 0x87921(%rip), %rdx     # 0xd9827
leaq 0x879c5(%rip), %rcx     # 0xd98d2
leaq 0x87921(%rip), %r8      # 0xd9835
movl $0xf8, %r9d
jmp 0x51f48
movq 0xdc095(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78139(%rip), %rsi     # 0xca066
leaq 0x78725(%rip), %rdx     # 0xca659
leaq 0x87997(%rip), %rcx     # 0xd98d2
leaq 0x878f3(%rip), %r8      # 0xd9835
movl $0xf6, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xgzopen_func
gzFile gt_fa_xgzopen_func(const char *path, const char *mode,
                          const char *src_file, int src_line)
{
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_GZIP, true, src_file,
                          src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x51f88
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x51f88
movq %rdi, %rsi
movq 0xddc51(%rip), %rdi     # 0x12fbc0
testq %rdi, %rdi
je 0x51fb6
movl %ecx, %eax
pushq $0x1
popq %rcx
movl %ecx, %r8d
pushq $0x0
pushq %rax
callq 0x51932
popq %rcx
popq %rdx
popq %rcx
retq
movq 0xdc029(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x780cd(%rip), %rsi     # 0xca066
leaq 0x878b4(%rip), %rdx     # 0xd9854
leaq 0x8793d(%rip), %rcx     # 0xd98e4
leaq 0x87887(%rip), %r8      # 0xd9835
movl $0x100, %r9d            # imm = 0x100
jmp 0x51fe2
movq 0xdbffb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7809f(%rip), %rsi     # 0xca066
leaq 0x87859(%rip), %rdx     # 0xd9827
leaq 0x8790f(%rip), %rcx     # 0xd98e4
leaq 0x87859(%rip), %r8      # 0xd9835
movl $0x101, %r9d            # imm = 0x101
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x520c0
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x52155
testq %r13, %r13
je 0x520f9
testq %r12, %r12
je 0x520f9
movq 0xddaef(%rip), %rdi     # 0x12fbc0
testq %rdi, %rdi
je 0x52127
pushq $0x2
popq %rcx
movq %r13, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x51932
popq %rcx
popq %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdbeb8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77f5c(%rip), %rsi     # 0xca066
leaq 0x87743(%rip), %rdx     # 0xd9854
leaq 0x877fc(%rip), %rcx     # 0xd9914
leaq 0x87716(%rip), %r8      # 0xd9835
movl $0x118, %r9d            # imm = 0x118
jmp 0x52181
movq 0xdbe8a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77f2e(%rip), %rsi     # 0xca066
leaq 0x876e8(%rip), %rdx     # 0xd9827
leaq 0x877ce(%rip), %rcx     # 0xd9914
leaq 0x876e8(%rip), %r8      # 0xd9835
movl $0x119, %r9d            # imm = 0x119
jmp 0x52181
movq 0xdbe5c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77f00(%rip), %rsi     # 0xca066
leaq 0x784ec(%rip), %rdx     # 0xca659
leaq 0x877a0(%rip), %rcx     # 0xd9914
leaq 0x876ba(%rip), %r8      # 0xd9835
movl $0x117, %r9d            # imm = 0x117
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5275d
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x527ef
testq %r13, %r13
je 0x52793
cmpq $0x0, 0xdd456(%rip)     # 0x12fbc0
je 0x527c1
movq %r12, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movl %ebx, %r9d
callq 0x52827
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdb81e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x778c2(%rip), %rsi     # 0xca066
leaq 0x874ff(%rip), %rdx     # 0xd9caa
leaq 0x87220(%rip), %rcx     # 0xd99d2
leaq 0x8707c(%rip), %r8      # 0xd9835
movl $0x21b, %r9d            # imm = 0x21B
jmp 0x5281b
movq 0xdb7f0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77894(%rip), %rsi     # 0xca066
leaq 0x8704e(%rip), %rdx     # 0xd9827
leaq 0x871f2(%rip), %rcx     # 0xd99d2
leaq 0x8704e(%rip), %r8      # 0xd9835
movl $0x21c, %r9d            # imm = 0x21C
jmp 0x5281b
movq 0xdb7c2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77866(%rip), %rsi     # 0xca066
leaq 0x77e52(%rip), %rdx     # 0xca659
leaq 0x871c4(%rip), %rcx     # 0xd99d2
leaq 0x87020(%rip), %r8      # 0xd9835
movl $0x21a, %r9d            # imm = 0x21A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52868
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x5298f
movq %r12, 0x8(%rsp)
cmpq $0x0, 0xdd34b(%rip)     # 0x12fbc0
je 0x52961
movzbl %r15b, %r15d
leal (%r15,%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbad0
cmpl $-0x1, %eax
je 0x528aa
movl %eax, %r12d
leaq 0x18(%rsp), %rsi
movl %eax, %edi
testb %bpl, %bpl
je 0x528bf
callq 0x6236d
jmp 0x528f0
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x873f2(%rip), %rsi     # 0xd9caf
jmp 0x528db
callq 0xbb80
testl %eax, %eax
je 0x528f0
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x873ee(%rip), %rsi     # 0xd9cc9
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
jmp 0x5294c
movq %r14, %rax
movq %r13, %r14
movq 0x48(%rsp), %r13
cmpq $-0x1, %r13
je 0x52949
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 0x52564
addq $0x20, %rsp
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5293f
movq %r13, (%r14)
movl %r12d, %edi
callq 0x6232c
jmp 0x5294c
xorl %r15d, %r15d
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb650(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x776f4(%rip), %rsi     # 0xca066
leaq 0x8732b(%rip), %rdx     # 0xd9ca4
leaq 0x8730d(%rip), %rcx     # 0xd9c8d
leaq 0x86eae(%rip), %r8      # 0xd9835
movl $0x1ee, %r9d            # imm = 0x1EE
jmp 0x529bb
movq 0xdb622(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x776c6(%rip), %rsi     # 0xca066
leaq 0x77cb2(%rip), %rdx     # 0xca659
leaq 0x872df(%rip), %rcx     # 0xd9c8d
leaq 0x86e80(%rip), %r8      # 0xd9835
movl $0x1ed, %r9d            # imm = 0x1ED
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x529f9
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x52a8c
testq %rbp, %rbp
je 0x52a30
cmpq $0x0, 0xdd1ba(%rip)     # 0x12fbc0
je 0x52a5e
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x52ac4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb581(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77625(%rip), %rsi     # 0xca066
leaq 0x87262(%rip), %rdx     # 0xd9caa
leaq 0x86f98(%rip), %rcx     # 0xd99e7
leaq 0x86ddf(%rip), %r8      # 0xd9835
movl $0x226, %r9d            # imm = 0x226
jmp 0x52ab8
movq 0xdb553(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x775f7(%rip), %rsi     # 0xca066
leaq 0x86db1(%rip), %rdx     # 0xd9827
leaq 0x86f6a(%rip), %rcx     # 0xd99e7
leaq 0x86db1(%rip), %r8      # 0xd9835
movl $0x227, %r9d            # imm = 0x227
jmp 0x52ab8
movq 0xdb525(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x775c9(%rip), %rsi     # 0xca066
leaq 0x77bb5(%rip), %rdx     # 0xca659
leaq 0x86f3c(%rip), %rcx     # 0xd99e7
leaq 0x86d83(%rip), %r8      # 0xd9835
movl $0x225, %r9d            # imm = 0x225
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52af8
callq 0xc103
testb %al, %al
jne 0x52bc1
cmpq $0x0, 0xdd0c0(%rip)     # 0x12fbc0
je 0x52b93
movzbl %bl, %ebx
leal (%rbx,%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbad0
cmpl $-0x1, %eax
je 0x52b5d
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 0x52564
addq $0x20, %rsp
movq %rax, %rbx
movl %r15d, %edi
callq 0x6232c
movq %rbx, %rax
jmp 0x52b84
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x8713f(%rip), %rsi     # 0xd9caf
movq 0x48(%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb41e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x774c2(%rip), %rsi     # 0xca066
leaq 0x870f9(%rip), %rdx     # 0xd9ca4
leaq 0x87132(%rip), %rcx     # 0xd9ce4
leaq 0x86c7c(%rip), %r8      # 0xd9835
movl $0x20b, %r9d            # imm = 0x20B
jmp 0x52bed
movq 0xdb3f0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77494(%rip), %rsi     # 0xca066
leaq 0x77a80(%rip), %rdx     # 0xca659
leaq 0x87104(%rip), %rcx     # 0xd9ce4
leaq 0x86c4e(%rip), %r8      # 0xd9835
movl $0x20a, %r9d            # imm = 0x20A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52c22
cmpq $0x0, 0xdcfb9(%rip)     # 0x12fbc0
je 0x52c50
movl %ecx, %r9d
movq %rdx, %rax
movq %r8, (%rsp)
pushq $0x1
popq %rdx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x52827
popq %rcx
retq
movq 0xdb38f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77433(%rip), %rsi     # 0xca066
leaq 0x87070(%rip), %rdx     # 0xd9caa
leaq 0x86dc1(%rip), %rcx     # 0xd9a02
leaq 0x86bed(%rip), %r8      # 0xd9835
movl $0x22f, %r9d            # imm = 0x22F
jmp 0x52c7c
movq 0xdb361(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77405(%rip), %rsi     # 0xca066
leaq 0x86bbf(%rip), %rdx     # 0xd9827
leaq 0x86d93(%rip), %rcx     # 0xd9a02
leaq 0x86bbf(%rip), %r8      # 0xd9835
movl $0x230, %r9d            # imm = 0x230
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52cb3
cmpq $0x0, 0xdcf2a(%rip)     # 0x12fbc0
je 0x52ce1
movq %r9, %r10
movl %r8d, %eax
movq %rcx, %r9
pushq $0x1
popq %rcx
xorl %r8d, %r8d
pushq %r10
pushq %rax
callq 0x52ac4
popq %rcx
popq %rdx
popq %rcx
retq
movq 0xdb2fe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x773a2(%rip), %rsi     # 0xca066
leaq 0x86fdf(%rip), %rdx     # 0xd9caa
leaq 0x86d46(%rip), %rcx     # 0xd9a18
leaq 0x86b5c(%rip), %r8      # 0xd9835
movl $0x239, %r9d            # imm = 0x239
jmp 0x52d0d
movq 0xdb2d0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77374(%rip), %rsi     # 0xca066
leaq 0x86b2e(%rip), %rdx     # 0xd9827
leaq 0x86d18(%rip), %rcx     # 0xd9a18
leaq 0x86b2e(%rip), %r8      # 0xd9835
movl $0x23a, %r9d            # imm = 0x23A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52d40
cmpq $0x0, 0xdce99(%rip)     # 0x12fbc0
je 0x52d6e
movl %ecx, %r9d
movq %rdx, %r8
andq $0x0, (%rsp)
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x52827
popq %rcx
retq
movq 0xdb271(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77315(%rip), %rsi     # 0xca066
leaq 0x86f52(%rip), %rdx     # 0xd9caa
leaq 0x86cd5(%rip), %rcx     # 0xd9a34
leaq 0x86acf(%rip), %r8      # 0xd9835
movl $0x242, %r9d            # imm = 0x242
jmp 0x52d9a
movq 0xdb243(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x772e7(%rip), %rsi     # 0xca066
leaq 0x86aa1(%rip), %rdx     # 0xd9827
leaq 0x86ca7(%rip), %rcx     # 0xd9a34
leaq 0x86aa1(%rip), %r8      # 0xd9835
movl $0x243, %r9d            # imm = 0x243
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52ec7
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0xbad0
cmpl $-0x1, %eax
je 0x52e6d
movl %eax, %r13d
movl %r12d, 0x4(%rsp)
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0xbb80
cmpl $-0x1, %eax
je 0x52e8c
movq 0x38(%rsp), %rdi
movq %rdi, (%rbp)
leaq 0x86a27(%rip), %rsi     # 0xd9835
movl $0x262, %edx            # imm = 0x262
callq 0xccb0
testl %r13d, %r13d
jle 0x52ef5
movq %rax, %r12
movq (%rbp), %rdx
movl %r13d, %edi
movq %rax, %rsi
callq 0xb8d0
cmpq $-0x1, %rax
jne 0x52eaa
leaq 0x86c80(%rip), %rsi     # 0xd9ac0
movq %r15, %rdi
movq %r14, %rdx
movl 0x4(%rsp), %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
leaq 0x869da(%rip), %rsi     # 0xd9835
movq %r12, %rdi
movl $0x26b, %edx            # imm = 0x26B
callq 0xd249
xorl %r12d, %r12d
jmp 0x52eb2
leaq 0x86bf8(%rip), %rsi     # 0xd9a6c
movl %r12d, %ecx
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
jmp 0x52eb2
leaq 0x86bf7(%rip), %rsi     # 0xd9a8a
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rdx
movl 0x4(%rsp), %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
movl %r13d, %edi
callq 0xbcc0
movq %r12, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb0ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7718e(%rip), %rsi     # 0xca066
leaq 0x86b6b(%rip), %rdx     # 0xd9a4a
leaq 0x86b71(%rip), %rcx     # 0xd9a57
leaq 0x86948(%rip), %r8      # 0xd9835
movl $0x24f, %r9d            # imm = 0x24F
jmp 0x52f21
movq 0xdb0bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x77160(%rip), %rsi     # 0xca066
leaq 0x86bac(%rip), %rdx     # 0xd9ab9
leaq 0x86b43(%rip), %rcx     # 0xd9a57
leaq 0x8691a(%rip), %r8      # 0xd9835
movl $0x263, %r9d            # imm = 0x263
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
testq %rdi, %rdi
je 0x52f5d
cmpq $0x0, 0xdcc82(%rip)     # 0x12fbc0
je 0x52f8b
movq %rcx, %r9
andq $0x0, 0x8(%rsp)
movl %r8d, (%rsp)
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x52ac4
addq $0x18, %rsp
retq
movq 0xdb054(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x770f8(%rip), %rsi     # 0xca066
leaq 0x86d35(%rip), %rdx     # 0xd9caa
leaq 0x86b61(%rip), %rcx     # 0xd9add
leaq 0x868b2(%rip), %r8      # 0xd9835
movl $0x277, %r9d            # imm = 0x277
jmp 0x52fb7
movq 0xdb026(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x770ca(%rip), %rsi     # 0xca066
leaq 0x86884(%rip), %rdx     # 0xd9827
leaq 0x86b33(%rip), %rcx     # 0xd9add
leaq 0x86884(%rip), %r8      # 0xd9835
movl $0x278, %r9d            # imm = 0x278
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x52fea
cmpq $0x0, 0xdcbef(%rip)     # 0x12fbc0
je 0x53018
movl %ecx, %r9d
movq %rdx, %r8
andq $0x0, (%rsp)
pushq $0x1
popq %rcx
movl %ecx, %edx
callq 0x52827
popq %rcx
retq
movq 0xdafc7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7706b(%rip), %rsi     # 0xca066
leaq 0x86ca8(%rip), %rdx     # 0xd9caa
leaq 0x86af0(%rip), %rcx     # 0xd9af9
leaq 0x86825(%rip), %r8      # 0xd9835
movl $0x280, %r9d            # imm = 0x280
jmp 0x53044
movq 0xdaf99(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7703d(%rip), %rsi     # 0xca066
leaq 0x867f7(%rip), %rdx     # 0xd9827
leaq 0x86ac2(%rip), %rcx     # 0xd9af9
leaq 0x867f7(%rip), %r8      # 0xd9835
movl $0x281, %r9d            # imm = 0x281
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53078
cmpq $0x0, 0xdcb62(%rip)     # 0x12fbc0
je 0x530a6
movl %r8d, %eax
movq %rcx, %r9
pushq $0x1
popq %rcx
movl %ecx, %r8d
pushq $0x0
pushq %rax
callq 0x52ac4
popq %rcx
popq %rdx
popq %rcx
retq
movq 0xdaf39(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76fdd(%rip), %rsi     # 0xca066
leaq 0x86c1a(%rip), %rdx     # 0xd9caa
leaq 0x86a79(%rip), %rcx     # 0xd9b10
leaq 0x86797(%rip), %r8      # 0xd9835
movl $0x289, %r9d            # imm = 0x289
jmp 0x530d2
movq 0xdaf0b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76faf(%rip), %rsi     # 0xca066
leaq 0x86769(%rip), %rdx     # 0xd9827
leaq 0x86a4b(%rip), %rcx     # 0xd9b10
leaq 0x86769(%rip), %r8      # 0xd9835
movl $0x28a, %r9d            # imm = 0x28A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xdcad7(%rip), %rax     # 0x12fbc0
testq %rax, %rax
je 0x53189
movq %rdi, %rbx
testq %rdi, %rdi
je 0x53181
movq 0x8(%rax), %rdi
callq 0x16028
movq 0xdcab2(%rip), %rax     # 0x12fbc0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x531b7
movq %rax, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x62557
movq 0xdca88(%rip), %rax     # 0x12fbc0
movq 0x20(%rax), %rcx
movq (%r14), %rdi
subq %rdi, %rcx
jb 0x531e5
movq %rcx, 0x20(%rax)
cmpb $0x1, 0x30(%rax)
jne 0x5315e
callq 0x1237e
movq 0xdca62(%rip), %rax     # 0x12fbc0
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x55f6f
movq 0xdca4f(%rip), %rax     # 0x12fbc0
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1609f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdae28(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76ecc(%rip), %rsi     # 0xca066
leaq 0x86686(%rip), %rdx     # 0xd9827
leaq 0x86985(%rip), %rcx     # 0xd9b2d
leaq 0x86686(%rip), %r8      # 0xd9835
movl $0x292, %r9d            # imm = 0x292
jmp 0x53211
movq 0xdadfa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76e9e(%rip), %rsi     # 0xca066
leaq 0x8696c(%rip), %rdx     # 0xd9b3b
leaq 0x86957(%rip), %rcx     # 0xd9b2d
leaq 0x86658(%rip), %r8      # 0xd9835
movl $0x296, %r9d            # imm = 0x296
jmp 0x53211
movq 0xdadcc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76e70(%rip), %rsi     # 0xca066
leaq 0x86946(%rip), %rdx     # 0xd9b43
leaq 0x86929(%rip), %rcx     # 0xd9b2d
leaq 0x8662a(%rip), %r8      # 0xd9835
movl $0x2aa, %r9d            # imm = 0x2AA
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5324b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x53299
movq %r13, %rdi
callq 0x13da9
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x13dd3
movq %r13, %rdi
callq 0x143d2
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x5272d
movq %rax, %rbx
movq %r13, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdad18(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76dbc(%rip), %rsi     # 0xca066
leaq 0x773a8(%rip), %rdx     # 0xca659
leaq 0x868ac(%rip), %rcx     # 0xd9b64
leaq 0x86576(%rip), %r8      # 0xd9835
movl $0x2b8, %r9d            # imm = 0x2B8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x86540(%rip), %rcx     # 0xd9835
leaq 0x10(%rsp), %rdx
movl $0x2dd, %r8d            # imm = 0x2DD
movq %r12, %r9
callq 0x5321d
testq %rax, %rax
je 0x53369
movq %rax, %rbx
movq %rbp, 0x8(%rsp)
movq %r14, %rbp
movq 0x10(%rsp), %r14
testq %r12, %r12
je 0x5332e
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x5337d
movq %r14, %rax
xorl %edx, %edx
divq %rbp
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x5336b
movq %rcx, (%rsp)
leaq 0x869cd(%rip), %rsi     # 0xd9d18
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0xc007
movq %rbx, %rdi
callq 0x530de
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdac34(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76cd8(%rip), %rsi     # 0xca066
leaq 0x772c4(%rip), %rdx     # 0xca659
leaq 0x86965(%rip), %rcx     # 0xd9d01
leaq 0x86492(%rip), %r8      # 0xd9835
movl $0x2c8, %r9d            # imm = 0x2C8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xdc803(%rip), %rax     # 0x12fbc0
testq %rax, %rax
je 0x533e9
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x10(%rax), %rdi
leaq 0x7a(%rip), %rsi        # 0x5344f
xorl %ecx, %ecx
callq 0x55fe2
testl %eax, %eax
jne 0x53417
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
movq 0xdabc8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76c6c(%rip), %rsi     # 0xca066
leaq 0x86426(%rip), %rdx     # 0xd9827
leaq 0x8677d(%rip), %rcx     # 0xd9b85
leaq 0x86426(%rip), %r8      # 0xd9835
movl $0x30a, %r9d            # imm = 0x30A
jmp 0x53443
movq 0xdab9a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76c3e(%rip), %rsi     # 0xca066
leaq 0x771e4(%rip), %rdx     # 0xca613
leaq 0x8674f(%rip), %rcx     # 0xd9b85
leaq 0x863f8(%rip), %r8      # 0xd9835
movl $0x30d, %r9d            # imm = 0x30D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x5348e
testq %rsi, %rsi
je 0x5348e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x5348e
cmpb $0x0, (%rbx)
je 0x5346b
xorl %eax, %eax
popq %rbx
retq
movq 0xdab46(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
movl 0x8(%rsi), %edx
movq (%rsi), %rcx
leaq 0x868fd(%rip), %rsi     # 0xd9d7f
xorl %eax, %eax
callq 0xb8c0
movb $0x1, (%rbx)
jmp 0x53467
movq 0xdab23(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76bc7(%rip), %rsi     # 0xca066
leaq 0x7728d(%rip), %rdx     # 0xca733
leaq 0x866de(%rip), %rcx     # 0xd9b8b
leaq 0x86381(%rip), %r8      # 0xd9835
movl $0x2ec, %r9d            # imm = 0x2EC
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xdc6f2(%rip), %rax     # 0x12fbc0
testq %rax, %rax
je 0x534fa
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x18(%rax), %rdi
leaq 0x7a(%rip), %rsi        # 0x53560
xorl %ecx, %ecx
callq 0x55fe2
testl %eax, %eax
jne 0x53528
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
movq 0xdaab7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76b5b(%rip), %rsi     # 0xca066
leaq 0x86315(%rip), %rdx     # 0xd9827
leaq 0x86682(%rip), %rcx     # 0xd9b9b
leaq 0x86315(%rip), %r8      # 0xd9835
movl $0x317, %r9d            # imm = 0x317
jmp 0x53554
movq 0xdaa89(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76b2d(%rip), %rsi     # 0xca066
leaq 0x770d3(%rip), %rdx     # 0xca613
leaq 0x86654(%rip), %rcx     # 0xd9b9b
leaq 0x862e7(%rip), %r8      # 0xd9835
movl $0x31a, %r9d            # imm = 0x31A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x535a3
testq %rsi, %rsi
je 0x535a3
movq %rdx, %rbx
testq %rdx, %rdx
je 0x535a3
cmpb $0x0, (%rbx)
je 0x5357c
xorl %eax, %eax
popq %rbx
retq
movq 0xdaa35(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
movl 0x10(%rsi), %ecx
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
leaq 0x86823(%rip), %rsi     # 0xd9dba
xorl %eax, %eax
callq 0xb8c0
movb $0x1, (%rbx)
jmp 0x53578
movq 0xdaa0e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x76ab2(%rip), %rsi     # 0xca066
leaq 0x77178(%rip), %rdx     # 0xca733
leaq 0x865df(%rip), %rcx     # 0xd9ba1
leaq 0x8626c(%rip), %r8      # 0xd9835
movl $0x2fb, %r9d            # imm = 0x2FB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xdc485(%rip), %rax     # 0x12fbc0
testq %rax, %rax
je 0x5379d
pushq %rax
movq (%rax), %rdi
callq 0x15fd3
movq 0xdc470(%rip), %rax     # 0x12fbc0
movq 0x8(%rax), %rdi
callq 0x15fd3
movq 0xdc460(%rip), %rax     # 0x12fbc0
movq 0x10(%rax), %rdi
callq 0x563a7
movq 0xdc450(%rip), %rax     # 0x12fbc0
movq 0x18(%rax), %rdi
callq 0x563a7
movq 0xdc440(%rip), %rdi     # 0x12fbc0
leaq 0x860ae(%rip), %rsi     # 0xd9835
movl $0x340, %edx            # imm = 0x340
callq 0xd249
andq $0x0, 0xdc427(%rip)     # 0x12fbc0
addq $0x8, %rsp
retq
nop