LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7fc02
cmpq $0x0, 0x10(%rsp)
jne 0x7fc3a
movq 0x1343cf(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde453(%rip), %rsi     # 0x15e066
leaq 0xee477(%rip), %rdx     # 0x16e091
leaq 0xee4a7(%rip), %rcx     # 0x16e0c8
leaq 0xee044(%rip), %r8      # 0x16dc6c
movl $0x87, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fc3c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1c340
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86470
cmpq $0x0, %rax
jne 0x7fc9a
movq 0x13436f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde3f3(%rip), %rsi     # 0x15e066
leaq 0xee424(%rip), %rdx     # 0x16e09e
leaq 0xee447(%rip), %rcx     # 0x16e0c8
leaq 0xedfe4(%rip), %r8      # 0x16dc6c
movl $0x8a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fc9c
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86580
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1c3e0
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x7fce0
jmp 0x7fcca
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x7fcec
jmp 0x7fcd5
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x7fcf8
jmp 0x7fd04
movq 0x20(%rsp), %rdi
callq 0xb670
jmp 0x7fd3e
movq 0x20(%rsp), %rdi
callq 0xcc720
jmp 0x7fd3e
movq 0x20(%rsp), %rdi
callq 0xcbed0
jmp 0x7fd3e
jmp 0x7fd06
movq 0x1342cb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde34f(%rip), %rsi     # 0x15e066
leaq 0xf019d(%rip), %rdx     # 0x16febb
leaq 0xee3a3(%rip), %rcx     # 0x16e0c8
leaq 0xedf40(%rip), %r8      # 0x16dc6c
movl $0x97, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7fde2
cmpq $0x0, 0x10(%rsp)
jne 0x7fe1a
movq 0x1341ef(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde273(%rip), %rsi     # 0x15e066
leaq 0xee297(%rip), %rdx     # 0x16e091
leaq 0xee2c6(%rip), %rcx     # 0x16e0c7
leaq 0xede64(%rip), %r8      # 0x16dc6c
movl $0x9e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fe1c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1c340
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86470
cmpq $0x0, %rax
jne 0x7fe7a
movq 0x13418f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde213(%rip), %rsi     # 0x15e066
leaq 0xee244(%rip), %rdx     # 0x16e09e
leaq 0xee266(%rip), %rcx     # 0x16e0c7
leaq 0xede04(%rip), %r8      # 0x16dc6c
movl $0xa1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fe7c
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86580
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1c3e0
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x7fec0
jmp 0x7feaa
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x7fecc
jmp 0x7feb5
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x7fed8
jmp 0x7fee4
movq 0x20(%rsp), %rdi
callq 0x1c710
jmp 0x7ff1e
movq 0x20(%rsp), %rdi
callq 0xa3560
jmp 0x7ff1e
movq 0x20(%rsp), %rdi
callq 0xcbed0
jmp 0x7ff1e
jmp 0x7fee6
movq 0x1340eb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde16f(%rip), %rsi     # 0x15e066
leaq 0xeffbd(%rip), %rdx     # 0x16febb
leaq 0xee1c2(%rip), %rcx     # 0x16e0c7
leaq 0xedd60(%rip), %r8      # 0x16dc6c
movl $0xae, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8007c
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x80044
jmp 0x8007c
movq 0x133f8d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde011(%rip), %rsi     # 0x15e066
leaq 0xde5ec(%rip), %rdx     # 0x15e648
leaq 0xedc99(%rip), %rcx     # 0x16dcfc
leaq 0xedc02(%rip), %r8      # 0x16dc6c
movl $0xf6, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8007e
jmp 0x80080
cmpq $0x0, 0x30(%rsp)
je 0x80090
cmpq $0x0, 0x28(%rsp)
jne 0x800c8
movq 0x133f41(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddfc5(%rip), %rsi     # 0x15e066
leaq 0xedfdc(%rip), %rdx     # 0x16e084
leaq 0xedc4d(%rip), %rcx     # 0x16dcfc
leaq 0xedbb6(%rip), %r8      # 0x16dc6c
movl $0xf7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x800ca
jmp 0x800cc
cmpq $0x0, 0x1363dc(%rip)    # 0x1b64b0
jne 0x8010e
movq 0x133efb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddf7f(%rip), %rsi     # 0x15e066
leaq 0xedfad(%rip), %rdx     # 0x16e09b
leaq 0xedc07(%rip), %rcx     # 0x16dcfc
leaq 0xedb70(%rip), %r8      # 0x16dc6c
movl $0xf8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x80110
movq 0x136399(%rip), %rdi    # 0x1b64b0
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
movl 0x1c(%rsp), %r10d
movq 0x10(%rsp), %rax
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x7f710
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x80177
cmpq $0x0, 0x28(%rsp)
jne 0x801af
movq 0x133e5a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddede(%rip), %rsi     # 0x15e066
leaq 0xedef5(%rip), %rdx     # 0x16e084
leaq 0xedb78(%rip), %rcx     # 0x16dd0e
leaq 0xedacf(%rip), %r8      # 0x16dc6c
movl $0x100, %r9d            # imm = 0x100
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x801b1
jmp 0x801b3
cmpq $0x0, 0x1362f5(%rip)    # 0x1b64b0
jne 0x801f5
movq 0x133e14(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdde98(%rip), %rsi     # 0x15e066
leaq 0xedec6(%rip), %rdx     # 0x16e09b
leaq 0xedb32(%rip), %rcx     # 0x16dd0e
leaq 0xeda89(%rip), %r8      # 0x16dc6c
movl $0x101, %r9d            # imm = 0x101
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x801f7
movq 0x1362b2(%rip), %rdi    # 0x1b64b0
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
movl 0x1c(%rsp), %eax
movl $0x1, %r8d
xorl %ecx, %ecx
movl %r8d, %ecx
movl %eax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x7f710
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8038c
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x80354
jmp 0x8038c
movq 0x133c7d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddd01(%rip), %rsi     # 0x15e066
leaq 0xde2dc(%rip), %rdx     # 0x15e648
leaq 0xed9cb(%rip), %rcx     # 0x16dd3e
leaq 0xed8f2(%rip), %r8      # 0x16dc6c
movl $0x117, %r9d            # imm = 0x117
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8038e
jmp 0x80390
cmpq $0x0, 0x30(%rsp)
je 0x803a0
cmpq $0x0, 0x28(%rsp)
jne 0x803d8
movq 0x133c31(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddcb5(%rip), %rsi     # 0x15e066
leaq 0xedccc(%rip), %rdx     # 0x16e084
leaq 0xed97f(%rip), %rcx     # 0x16dd3e
leaq 0xed8a6(%rip), %r8      # 0x16dc6c
movl $0x118, %r9d            # imm = 0x118
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x803da
jmp 0x803dc
cmpq $0x0, 0x1360cc(%rip)    # 0x1b64b0
jne 0x8041e
movq 0x133beb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xddc6f(%rip), %rsi     # 0x15e066
leaq 0xedc9d(%rip), %rdx     # 0x16e09b
leaq 0xed939(%rip), %rcx     # 0x16dd3e
leaq 0xed860(%rip), %r8      # 0x16dc6c
movl $0x119, %r9d            # imm = 0x119
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x80420
movq 0x136089(%rip), %rdi    # 0x1b64b0
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
movl 0x1c(%rsp), %r10d
movq 0x10(%rsp), %rax
movl $0x2, %ecx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x7f710
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_try_tmpdir
static inline const char* gt_fa_try_tmpdir(const char *dirname)
{
  if (!dirname)
    return NULL;
  if (access(dirname, R_OK | W_OK | X_OK) == 0)
    return dirname;
  return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8098c
movq $0x0, 0x10(%rsp)
jmp 0x809b5
movq 0x8(%rsp), %rdi
movl $0x7, %esi
callq 0xba70
cmpl $0x0, %eax
jne 0x809ac
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x809b5
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x80d1c
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x80ce4
jmp 0x80d1c
movq 0x1332ed(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdd371(%rip), %rsi     # 0x15e066
leaq 0xdd94c(%rip), %rdx     # 0x15e648
leaq 0xed0f9(%rip), %rcx     # 0x16ddfc
leaq 0xecf62(%rip), %r8      # 0x16dc6c
movl $0x21a, %r9d            # imm = 0x21A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x80d1e
jmp 0x80d20
cmpq $0x0, 0x30(%rsp)
jne 0x80d60
movq 0x1332a9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdd32d(%rip), %rsi     # 0x15e066
leaq 0xed3b4(%rip), %rdx     # 0x16e0f4
leaq 0xed0b5(%rip), %rcx     # 0x16ddfc
leaq 0xecf1e(%rip), %r8      # 0x16dc6c
movl $0x21b, %r9d            # imm = 0x21B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x80d62
jmp 0x80d64
cmpq $0x0, 0x135744(%rip)    # 0x1b64b0
jne 0x80da6
movq 0x133263(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdd2e7(%rip), %rsi     # 0x15e066
leaq 0xed315(%rip), %rdx     # 0x16e09b
leaq 0xed06f(%rip), %rcx     # 0x16ddfc
leaq 0xeced8(%rip), %r8      # 0x16dc6c
movl $0x21c, %r9d            # imm = 0x21C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x80da8
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %r8
movl 0x1c(%rsp), %r9d
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movq %rax, (%rsp)
callq 0x80de0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x81062
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x8102a
jmp 0x81062
movq 0x132fa7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdd02b(%rip), %rsi     # 0x15e066
leaq 0xdd606(%rip), %rdx     # 0x15e648
leaq 0xecdc8(%rip), %rcx     # 0x16de11
leaq 0xecc1c(%rip), %r8      # 0x16dc6c
movl $0x225, %r9d            # imm = 0x225
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81064
jmp 0x81066
cmpq $0x0, 0x40(%rsp)
jne 0x810a6
movq 0x132f63(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcfe7(%rip), %rsi     # 0x15e066
leaq 0xed06e(%rip), %rdx     # 0x16e0f4
leaq 0xecd84(%rip), %rcx     # 0x16de11
leaq 0xecbd8(%rip), %r8      # 0x16dc6c
movl $0x226, %r9d            # imm = 0x226
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x810a8
jmp 0x810aa
cmpq $0x0, 0x1353fe(%rip)    # 0x1b64b0
jne 0x810ec
movq 0x132f1d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcfa1(%rip), %rsi     # 0x15e066
leaq 0xecfcf(%rip), %rdx     # 0x16e09b
leaq 0xecd3e(%rip), %rcx     # 0x16de11
leaq 0xecb92(%rip), %r8      # 0x16dc6c
movl $0x227, %r9d            # imm = 0x227
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x810ee
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %r9
movl 0x24(%rsp), %r10d
movq 0x18(%rsp), %rax
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x81130
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movb %r8b, %al
movq 0x78(%rsp), %r8
movl 0x70(%rsp), %r8d
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andb $0x1, %cl
movb %cl, 0x47(%rsp)
andb $0x1, %al
movb %al, 0x46(%rsp)
movq %r9, 0x38(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x811b2
movq 0x78(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x8117a
jmp 0x811b2
movq 0x132e57(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcedb(%rip), %rsi     # 0x15e066
leaq 0xdd4b6(%rip), %rdx     # 0x15e648
leaq 0xecf95(%rip), %rcx     # 0x16e12e
leaq 0xecacc(%rip), %r8      # 0x16dc6c
movl $0x20a, %r9d            # imm = 0x20A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x811b4
jmp 0x811b6
cmpq $0x0, 0x1352f2(%rip)    # 0x1b64b0
je 0x811c8
cmpq $0x0, 0x58(%rsp)
jne 0x81200
movq 0x132e09(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdce8d(%rip), %rsi     # 0x15e066
leaq 0xecf0e(%rip), %rdx     # 0x16e0ee
leaq 0xecf47(%rip), %rcx     # 0x16e12e
leaq 0xeca7e(%rip), %r8      # 0x16dc6c
movl $0x20b, %r9d            # imm = 0x20B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81202
movq 0x58(%rsp), %rdi
movb 0x47(%rsp), %cl
xorl %esi, %esi
movl $0x2, %eax
testb $0x1, %cl
cmovnel %eax, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0xbaa0
movl %eax, 0x34(%rsp)
cmpl $-0x1, 0x34(%rsp)
jne 0x81272
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq %rax, %rcx
leaq 0xece99(%rip), %rsi     # 0x16e0f9
movb $0x0, %al
callq 0xc0d0
movq $0x0, 0x60(%rsp)
jmp 0x812d9
movl 0x34(%rsp), %edi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movb 0x47(%rsp), %r8b
movb 0x46(%rsp), %r9b
movq 0x38(%rsp), %r11
movl 0x70(%rsp), %r10d
movq 0x78(%rsp), %rax
andb $0x1, %r8b
andb $0x1, %r9b
movzbl %r8b, %r8d
movzbl %r9b, %r9d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x809c0
movq %rax, 0x28(%rsp)
movl 0x34(%rsp), %edi
callq 0xa2b80
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x8134c
movq 0x132cbd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcd41(%rip), %rsi     # 0x15e066
leaq 0xecdc8(%rip), %rdx     # 0x16e0f4
leaq 0xecaf9(%rip), %rcx     # 0x16de2c
leaq 0xec932(%rip), %r8      # 0x16dc6c
movl $0x22f, %r9d            # imm = 0x22F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8134e
jmp 0x81350
cmpq $0x0, 0x135158(%rip)    # 0x1b64b0
jne 0x81392
movq 0x132c77(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdccfb(%rip), %rsi     # 0x15e066
leaq 0xecd29(%rip), %rdx     # 0x16e09b
leaq 0xecab3(%rip), %rcx     # 0x16de2c
leaq 0xec8ec(%rip), %r8      # 0x16dc6c
movl $0x230, %r9d            # imm = 0x230
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81394
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %r8
movl 0x1c(%rsp), %r9d
movq 0x10(%rsp), %rax
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x80de0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x81432
movq 0x132bd7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcc5b(%rip), %rsi     # 0x15e066
leaq 0xecce2(%rip), %rdx     # 0x16e0f4
leaq 0xeca29(%rip), %rcx     # 0x16de42
leaq 0xec84c(%rip), %r8      # 0x16dc6c
movl $0x239, %r9d            # imm = 0x239
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81434
jmp 0x81436
cmpq $0x0, 0x135072(%rip)    # 0x1b64b0
jne 0x81478
movq 0x132b91(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdcc15(%rip), %rsi     # 0x15e066
leaq 0xecc43(%rip), %rdx     # 0x16e09b
leaq 0xec9e3(%rip), %rcx     # 0x16de42
leaq 0xec806(%rip), %r8      # 0x16dc6c
movl $0x23a, %r9d            # imm = 0x23A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8147a
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %r9
movl 0x24(%rsp), %r10d
movq 0x18(%rsp), %rax
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x81130
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x8184d
movq 0x1327bc(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc840(%rip), %rsi     # 0x15e066
leaq 0xec8c7(%rip), %rdx     # 0x16e0f4
leaq 0xec6d3(%rip), %rcx     # 0x16df07
leaq 0xec431(%rip), %r8      # 0x16dc6c
movl $0x277, %r9d            # imm = 0x277
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8184f
jmp 0x81851
cmpq $0x0, 0x134c57(%rip)    # 0x1b64b0
jne 0x81893
movq 0x132776(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc7fa(%rip), %rsi     # 0x15e066
leaq 0xec828(%rip), %rdx     # 0x16e09b
leaq 0xec68d(%rip), %rcx     # 0x16df07
leaq 0xec3eb(%rip), %r8      # 0x16dc6c
movl $0x278, %r9d            # imm = 0x278
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81895
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r9
movl 0x14(%rsp), %eax
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r10d, %r10d
movl %eax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x81130
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x819fd
movq 0x13260c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc690(%rip), %rsi     # 0x15e066
leaq 0xec717(%rip), %rdx     # 0x16e0f4
leaq 0xec556(%rip), %rcx     # 0x16df3a
leaq 0xec281(%rip), %r8      # 0x16dc6c
movl $0x289, %r9d            # imm = 0x289
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x819ff
jmp 0x81a01
cmpq $0x0, 0x134aa7(%rip)    # 0x1b64b0
jne 0x81a43
movq 0x1325c6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc64a(%rip), %rsi     # 0x15e066
leaq 0xec678(%rip), %rdx     # 0x16e09b
leaq 0xec510(%rip), %rcx     # 0x16df3a
leaq 0xec23b(%rip), %r8      # 0x16dc6c
movl $0x28a, %r9d            # imm = 0x28A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81a45
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r9
movl 0x14(%rsp), %eax
movl $0x1, %r8d
xorl %ecx, %ecx
movl %r8d, %ecx
movl %eax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x81130
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x134a1f(%rip)    # 0x1b64b0
jne 0x81acb
movq 0x13253e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc5c2(%rip), %rsi     # 0x15e066
leaq 0xec5f0(%rip), %rdx     # 0x16e09b
leaq 0xec4a5(%rip), %rcx     # 0x16df57
leaq 0xec1b3(%rip), %r8      # 0x16dc6c
movl $0x292, %r9d            # imm = 0x292
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81acd
cmpq $0x0, 0x10(%rsp)
jne 0x81ada
jmp 0x81c00
movq 0x1349cf(%rip), %rax    # 0x1b64b0
movq 0x8(%rax), %rdi
callq 0x1c340
movq 0x1349bf(%rip), %rax    # 0x1b64b0
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x86470
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x81b44
movq 0x1324c5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc549(%rip), %rsi     # 0x15e066
leaq 0xec441(%rip), %rdx     # 0x16df65
leaq 0xec42c(%rip), %rcx     # 0x16df57
leaq 0xec13a(%rip), %r8      # 0x16dc6c
movl $0x296, %r9d            # imm = 0x296
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81b46
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xa2f60
movq 0x134951(%rip), %rax    # 0x1b64b0
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x81ba5
movq 0x132464(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc4e8(%rip), %rsi     # 0x15e066
leaq 0xec3e8(%rip), %rdx     # 0x16df6d
leaq 0xec3cb(%rip), %rcx     # 0x16df57
leaq 0xec0d9(%rip), %r8      # 0x16dc6c
movl $0x2aa, %r9d            # imm = 0x2AA
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81ba7
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x1348fa(%rip), %rax    # 0x1b64b0
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq 0x1348e8(%rip), %rax    # 0x1b64b0
testb $0x1, 0x30(%rax)
je 0x81bdb
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x16850
movq 0x1348ce(%rip), %rax    # 0x1b64b0
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x86580
movq 0x1348b9(%rip), %rax    # 0x1b64b0
movq 0x8(%rax), %rdi
callq 0x1c3e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x81c82
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x81c4a
jmp 0x81c82
movq 0x132387(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc40b(%rip), %rsi     # 0x15e066
leaq 0xdc9e6(%rip), %rdx     # 0x15e648
leaq 0xec325(%rip), %rcx     # 0x16df8e
leaq 0xebffc(%rip), %r8      # 0x16dc6c
movl $0x2b8, %r9d            # imm = 0x2B8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81c84
movq 0x40(%rsp), %rdi
callq 0x18f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x18fb0
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %r8
callq 0x80cb0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %r9
leaq 0x10(%rsp), %rdx
leaq 0xebf54(%rip), %rcx     # 0x16dc6c
movl $0x2dd, %r8d            # imm = 0x2DD
callq 0x81c10
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x81d39
movq $0x0, 0x40(%rsp)
jmp 0x81d80
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x81d90
cmpl $0x0, %eax
je 0x81d76
movq 0x8(%rsp), %rdi
callq 0x81a80
movq $0x0, 0x40(%rsp)
jmp 0x81d80
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fa.c
// Function: check_mapped_file_size
static int check_mapped_file_size(const char *path,
                                  const char *suffix,
                                  size_t numofbytes,
                                  GtUword expectedunits,
                                  size_t sizeofunit,
                                  GtError *err)
{
  gt_error_check(err);
  if (expectedunits != (GtUword) (numofbytes/sizeofunit))
  {
    gt_error_set(err,"mapping file %s%s: number of mapped units (of size %u) "
                     " = "GT_WU" != "GT_WU" = expected number of mapped units",
                      path,
                      suffix,
                      (unsigned int) sizeofunit,
                      (GtUword) (numofbytes/sizeofunit),
                      expectedunits);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x81e02
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x81dca
jmp 0x81e02
movq 0x132207(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc28b(%rip), %rsi     # 0x15e066
leaq 0xdc866(%rip), %rdx     # 0x15e648
leaq 0xec362(%rip), %rcx     # 0x16e14b
leaq 0xebe7c(%rip), %r8      # 0x16dc6c
movl $0x2c8, %r9d            # imm = 0x2C8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81e04
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x28(%rsp)
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x81e7a
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %rax
movl %eax, %r8d
movq 0x38(%rsp), %rax
xorl %edx, %edx
divq 0x28(%rsp)
movq 0x10(%rsp), %rdx
movq %rax, %r9
movq 0x30(%rsp), %rax
leaq 0xec2fd(%rip), %rsi     # 0x16e162
movq %rax, (%rsp)
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x81e82
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpq $0x0, 0x134614(%rip)    # 0x1b64b0
jne 0x81ed6
movq 0x132133(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc1b7(%rip), %rsi     # 0x15e066
leaq 0xec1e5(%rip), %rdx     # 0x16e09b
leaq 0xec0f2(%rip), %rcx     # 0x16dfaf
leaq 0xebda8(%rip), %r8      # 0x16dc6c
movl $0x30a, %r9d            # imm = 0x30A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81ed8
movb $0x0, 0x13(%rsp)
movq 0x1345cc(%rip), %rax    # 0x1b64b0
movq 0x10(%rax), %rdi
leaq 0x81(%rip), %rsi        # 0x81f70
leaq 0x13(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x866f0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x81f40
movq 0x1320c9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc14d(%rip), %rsi     # 0x15e066
leaq 0xe509e(%rip), %rdx     # 0x166fbe
leaq 0xec088(%rip), %rcx     # 0x16dfaf
leaq 0xebd3e(%rip), %r8      # 0x16dc6c
movl $0x30d, %r9d            # imm = 0x30D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81f42
testb $0x1, 0x13(%rsp)
je 0x81f53
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x81f5b
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x81fb4
cmpq $0x0, 0x28(%rsp)
je 0x81fb4
cmpq $0x0, 0x20(%rsp)
jne 0x81fec
movq 0x13201d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc0a1(%rip), %rsi     # 0x15e066
leaq 0xdc756(%rip), %rdx     # 0x15e722
leaq 0xebfe2(%rip), %rcx     # 0x16dfb5
leaq 0xebc92(%rip), %r8      # 0x16dc6c
movl $0x2ec, %r9d            # imm = 0x2EC
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x81fee
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x82028
movq 0x131fd9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
leaq 0xec1b0(%rip), %rsi     # 0x16e1c9
movb $0x0, %al
callq 0xb890
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpq $0x0, 0x134474(%rip)    # 0x1b64b0
jne 0x82076
movq 0x131f93(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdc017(%rip), %rsi     # 0x15e066
leaq 0xec045(%rip), %rdx     # 0x16e09b
leaq 0xebf68(%rip), %rcx     # 0x16dfc5
leaq 0xebc08(%rip), %r8      # 0x16dc6c
movl $0x317, %r9d            # imm = 0x317
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x82078
movb $0x0, 0x13(%rsp)
movq 0x13442c(%rip), %rax    # 0x1b64b0
movq 0x18(%rax), %rdi
leaq 0x81(%rip), %rsi        # 0x82110
leaq 0x13(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x866f0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x820e0
movq 0x131f29(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdbfad(%rip), %rsi     # 0x15e066
leaq 0xe4efe(%rip), %rdx     # 0x166fbe
leaq 0xebefe(%rip), %rcx     # 0x16dfc5
leaq 0xebb9e(%rip), %r8      # 0x16dc6c
movl $0x31a, %r9d            # imm = 0x31A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x820e2
testb $0x1, 0x13(%rsp)
je 0x820f3
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x820fb
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x82154
cmpq $0x0, 0x28(%rsp)
je 0x82154
cmpq $0x0, 0x20(%rsp)
jne 0x8218c
movq 0x131e7d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdbf01(%rip), %rsi     # 0x15e066
leaq 0xdc5b6(%rip), %rdx     # 0x15e722
leaq 0xebe58(%rip), %rcx     # 0x16dfcb
leaq 0xebaf2(%rip), %r8      # 0x16dc6c
movl $0x2fb, %r9d            # imm = 0x2FB
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8218e
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x821d1
movq 0x131e39(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0xec042(%rip), %rsi     # 0x16e204
movb $0x0, %al
callq 0xb890
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
cmpq $0x0, 0x134107(%rip)    # 0x1b64b0
jne 0x823ad
jmp 0x8240f
movq 0x1340fc(%rip), %rax    # 0x1b64b0
movq (%rax), %rdi
callq 0x1c2c0
movq 0x1340ed(%rip), %rax    # 0x1b64b0
movq 0x8(%rax), %rdi
callq 0x1c2c0
movq 0x1340dd(%rip), %rax    # 0x1b64b0
movq 0x10(%rax), %rdi
callq 0x86cc0
movq 0x1340cd(%rip), %rax    # 0x1b64b0
movq 0x18(%rax), %rdi
callq 0x86cc0
movq 0x1340bd(%rip), %rdi    # 0x1b64b0
leaq 0xeb872(%rip), %rsi     # 0x16dc6c
movl $0x340, %edx            # imm = 0x340
callq 0xdab0
movq $0x0, 0x1340a1(%rip) # 0x1b64b0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fa.c
// Function: fd_to_file_size
static size_t fd_to_file_size(int fd,const char *path,bool hard_fail,
                              GtError *err)
{
  struct stat sb;

  if (hard_fail)
    gt_xfstat(fd, &sb);
  else if (fstat(fd, &sb)) {
    gt_error_set(err,"cannot fstat file \"%s\": %s", path, strerror(errno));
    return -1;
  }
  if (sizeof (off_t) > sizeof (size_t) && sb.st_size > SIZE_MAX) {
    gt_error_set(err,"file \"%s\" of size "GT_LLU" is too large to map",
                 path, (GtUint64) sb.st_size);
    return -1;
  }
  return sb.st_size;
}

// Assembly:
subq $0xc8, %rsp
movb %dl, %al
movl %edi, 0xbc(%rsp)
movq %rsi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
movq %rcx, 0xa0(%rsp)
testb $0x1, 0xaf(%rsp)
je 0x82466
movl 0xbc(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0xa2c00
jmp 0x824cb
movl 0xbc(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0xbb50
cmpl $0x0, %eax
je 0x824c9
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0xebc5f(%rip), %rsi     # 0x16e113
movb $0x0, %al
callq 0xc0d0
movq $-0x1, 0xc0(%rsp)
jmp 0x824d8
jmp 0x824cb
movq 0x40(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta.c
// Function: gt_fasta_show_entry_with_suffix
void gt_fasta_show_entry_with_suffix(const char *description,
                                     const char *sequence,
                                     GtUword sequence_length,
                                     const char *suffix, GtUword width,
                                     GtFile *outfp)
{
  GtUword description_length = description ? strlen(description) : 0;
  gt_fasta_show_entry_nt_with_suffix(description, description_length,
                                     sequence, sequence_length,
                                     suffix, width, outfp);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x8257b
movq 0x40(%rsp), %rdi
callq 0xb240
movq %rax, 0x8(%rsp)
jmp 0x82584
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x82584
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x826f0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta.c
// Function: gt_fasta_show_entry_with_suffix_str
void gt_fasta_show_entry_with_suffix_str(const char *description,
                                         const char *sequence,
                                         GtUword sequence_length,
                                         const char *suffix, GtUword width,
                                         GtStr *outstr)
{
  GtUword description_length = description ? strlen(description) : 0;
  gt_fasta_show_entry_nt_with_suffix_str(description, description_length,
                                         sequence, sequence_length,
                                         suffix, width, outstr);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x8264b
movq 0x40(%rsp), %rdi
callq 0xb240
movq %rax, 0x8(%rsp)
jmp 0x82654
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x82654
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x829b0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x82c2b
movl $0x0, 0x14(%rsp)
jmp 0x82c9f
movq 0x8(%rsp), %rdi
callq 0xb240
movq %rax, (%rsp)
cmpq $0x4, (%rsp)
jb 0x82c68
movq 0x8(%rsp), %rsi
addq (%rsp), %rsi
addq $-0x3, %rsi
leaq 0xeb682(%rip), %rdi     # 0x16e2d6
callq 0xb850
cmpl $0x0, %eax
jne 0x82c68
movl $0x1, 0x14(%rsp)
jmp 0x82c9f
cmpq $0x5, (%rsp)
jb 0x82c97
movq 0x8(%rsp), %rsi
addq (%rsp), %rsi
addq $-0x4, %rsi
leaq 0xeb657(%rip), %rdi     # 0x16e2da
callq 0xb850
cmpl $0x0, %eax
jne 0x82c97
movl $0x2, 0x14(%rsp)
jmp 0x82c9f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_mode_suffix
const char* gt_file_mode_suffix(GtFileMode mode)
{
  switch (mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      return "";
    case GT_FILE_MODE_GZIP:
      return ".gz";
    case GT_FILE_MODE_BZIP2:
      return ".bz2";
    default:
      gt_assert(0);
      return "";
  }
  /* due do warning on solaris:
     warning: control reaches end of non-void function */
  return "";
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x82cdc
jmp 0x82cc6
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x82cea
jmp 0x82cd1
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x82cf8
jmp 0x82d06
leaq 0xe9200(%rip), %rax     # 0x16bee3
movq %rax, 0x10(%rsp)
jmp 0x82d40
leaq 0xeb5e5(%rip), %rax     # 0x16e2d6
movq %rax, 0x10(%rsp)
jmp 0x82d40
leaq 0xeb5db(%rip), %rax     # 0x16e2da
movq %rax, 0x10(%rsp)
jmp 0x82d40
jmp 0x82d08
movq 0x1312c9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdb34d(%rip), %rsi     # 0x15e066
leaq 0xed19b(%rip), %rdx     # 0x16febb
leaq 0xeb5b8(%rip), %rcx     # 0x16e2df
leaq 0xeb5c5(%rip), %r8      # 0x16e2f3
movl $0x41, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x82d99
movq 0x131270(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdb2f4(%rip), %rsi     # 0x15e066
leaq 0xeb37b(%rip), %rdx     # 0x16e0f4
leaq 0xeb583(%rip), %rcx     # 0x16e303
leaq 0xeb56c(%rip), %r8      # 0x16e2f3
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x82d9b
movq 0x8(%rsp), %rdi
callq 0xb240
movq %rax, (%rsp)
cmpq $0x4, (%rsp)
jb 0x82ddd
movq 0x8(%rsp), %rsi
addq (%rsp), %rsi
addq $-0x3, %rsi
leaq 0xeb512(%rip), %rdi     # 0x16e2d6
callq 0xb850
cmpl $0x0, %eax
jne 0x82ddd
movq (%rsp), %rax
subq $0x3, %rax
movq %rax, 0x10(%rsp)
jmp 0x82e1a
cmpq $0x5, (%rsp)
jb 0x82e11
movq 0x8(%rsp), %rsi
addq (%rsp), %rsi
addq $-0x4, %rsi
leaq 0xeb4e2(%rip), %rdi     # 0x16e2da
callq 0xb850
cmpl $0x0, %eax
jne 0x82e11
movq (%rsp), %rax
subq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0x82e1a
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x8324e
jmp 0x83295
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xeb096(%rip), %rsi     # 0x16e2f3
movl $0x1aa, %edx            # imm = 0x1AA
callq 0xdab0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xeb07d(%rip), %rsi     # 0x16e2f3
movl $0x1ab, %edx            # imm = 0x1AB
callq 0xdab0
movq (%rsp), %rdi
leaq 0xeb068(%rip), %rsi     # 0x16e2f3
movl $0x1ac, %edx            # imm = 0x1AC
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)