LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_new_from_fileptr
GtFile* gt_file_new_from_fileptr(FILE *fp)
{
  GtFile *file;
  gt_assert(fp);
  file = gt_calloc(1, sizeof (GtFile));
  file->reference_count = 0;
  file->mode = GT_FILE_MODE_UNCOMPRESSED;
  file->fileptr.file = fp;
  return file;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x83579
movq 0x130a90(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdab14(%rip), %rsi     # 0x15e066
leaq 0xf5598(%rip), %rdx     # 0x178af1
leaq 0xeae21(%rip), %rcx     # 0x16e381
leaq 0xead8c(%rip), %r8      # 0x16e2f3
movl $0xbb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8357b
movl $0x1, %edi
movl $0x30, %esi
leaq 0xead67(%rip), %rdx     # 0x16e2f3
movl $0xbc, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfgetc
int gt_file_xfgetc(GtFile *file)
{
  int c = -1;
  if (file) {
    if (file->unget_used) {
      c = file->unget_char;
      file->unget_used = false;
    }
    else {
      switch (file->mode) {
        case GT_FILE_MODE_UNCOMPRESSED:
          c = gt_xfgetc(file->fileptr.file);
          break;
        case GT_FILE_MODE_GZIP:
          c = gt_xgzfgetc(file->fileptr.gzfile);
          break;
        case GT_FILE_MODE_BZIP2:
          c = gt_xbzfgetc(file->fileptr.bzfile);
          break;
        default: gt_assert(0);
      }
    }
  }
  else
    c = gt_xfgetc(stdin);
  return c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x10(%rsp)
je 0x83704
movq 0x10(%rsp), %rax
testb $0x1, 0x2a(%rax)
je 0x83663
movq 0x10(%rsp), %rax
movsbl 0x28(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0x2a(%rax)
jmp 0x83702
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x8368a
jmp 0x83674
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x8369e
jmp 0x8367f
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x836b2
jmp 0x836c6
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1c770
movl %eax, 0xc(%rsp)
jmp 0x83700
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa32c0
movl %eax, 0xc(%rsp)
jmp 0x83700
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa28b0
movl %eax, 0xc(%rsp)
jmp 0x83700
jmp 0x836c8
movq 0x130909(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda98d(%rip), %rsi     # 0x15e066
leaq 0xec7db(%rip), %rdx     # 0x16febb
leaq 0xeacc0(%rip), %rcx     # 0x16e3a7
leaq 0xeac05(%rip), %r8      # 0x16e2f3
movl $0xdc, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x83702
jmp 0x83717
movq 0x1308bd(%rip), %rax    # 0x1b3fc8
movq (%rax), %rdi
callq 0x1c770
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_unget_char
void gt_file_unget_char(GtFile *file, char c)
{
  if (file) {
    gt_assert(!file->unget_used); /* only one char can be unget at a time */
    file->unget_char = c;
    file->unget_used = true;
  }
  else
    gt_xungetc(c, stdin);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x83796
jmp 0x8373a
movq 0x10(%rsp), %rax
testb $0x1, 0x2a(%rax)
je 0x8377d
movq 0x13088c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda910(%rip), %rsi     # 0x15e066
leaq 0xeac59(%rip), %rdx     # 0x16e3b6
leaq 0xeac64(%rip), %rcx     # 0x16e3c8
leaq 0xeab88(%rip), %r8      # 0x16e2f3
movl $0xe8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8377f
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x28(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x2a(%rax)
jmp 0x837aa
movsbl 0xf(%rsp), %edi
movq 0x130826(%rip), %rax    # 0x1b3fc8
movq (%rax), %rsi
callq 0x1cc80
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xprintf
void gt_file_xprintf(GtFile *file, const char *format, ...)
{
  va_list va;
  int rval;
  va_start(va, format);
  if ((rval = xvprintf(file, format, va, 0))) {
    gt_assert(rval > 0); /* negative return is not possible, rval should denote
                            the necessary buffer length -> try again with it */
    /* reset variable arguments */
    va_end(va);
    va_start(va, format);
    /* try again */
    rval = xvprintf(file, format, va, rval);
    gt_assert(!rval); /* xvprintf() should not fail with given buffer length */
  }
  va_end(va);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x837ec
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
xorl %ecx, %ecx
callq 0x83960
movl %eax, 0xbc(%rsp)
cmpl $0x0, %eax
je 0x8394e
jmp 0x83869
cmpl $0x0, 0xbc(%rsp)
jg 0x838ab
movq 0x13075e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda7e2(%rip), %rsi     # 0x15e066
leaq 0xeab50(%rip), %rdx     # 0x16e3db
leaq 0xeab52(%rip), %rcx     # 0x16e3e4
leaq 0xeaa5a(%rip), %r8      # 0x16e2f3
movl $0x13c, %r9d            # imm = 0x13C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x838ad
leaq 0xc0(%rsp), %rax
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
movl 0xbc(%rsp), %ecx
callq 0x83960
movl %eax, 0xbc(%rsp)
cmpl $0x0, 0xbc(%rsp)
je 0x8394a
movq 0x1306bf(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda743(%rip), %rsi     # 0x15e066
leaq 0xdb14f(%rip), %rdx     # 0x15ea79
leaq 0xeaab3(%rip), %rcx     # 0x16e3e4
leaq 0xea9bb(%rip), %r8      # 0x16e2f3
movl $0x143, %r9d            # imm = 0x143
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8394c
jmp 0x8394e
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: xvprintf
static int xvprintf(GtFile *file, const char *format, va_list va, int buflen)
{
  int rval = 0;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x839a5
movq 0x130622(%rip), %rax    # 0x1b3fb0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1ccd0
jmp 0x83a66
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x839cc
jmp 0x839b6
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x839e6
jmp 0x839c1
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x83a08
jmp 0x83a2a
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1ccd0
jmp 0x83a64
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x84030
movl %eax, 0x8(%rsp)
jmp 0x83a64
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x841b0
movl %eax, 0x8(%rsp)
jmp 0x83a64
jmp 0x83a2c
movq 0x1305a5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda629(%rip), %rsi     # 0x15e066
leaq 0xec477(%rip), %rdx     # 0x16febb
leaq 0xeaa03(%rip), %rcx     # 0x16e44e
leaq 0xea8a1(%rip), %r8      # 0x16e2f3
movl $0x130, %r9d            # imm = 0x130
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x83a66
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputc
void gt_file_xfputc(int c, GtFile *file)
{
  if (!file)
    return gt_xfputc(c, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputc(c, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputc(c, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputc(c, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x83a9d
movl 0x14(%rsp), %edi
movq 0x130520(%rip), %rax    # 0x1b3fb0
movq (%rax), %rsi
callq 0x1c8f0
jmp 0x83b3a
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x83ac4
jmp 0x83aae
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x83ad8
jmp 0x83ab9
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x83aec
jmp 0x83b00
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1c8f0
jmp 0x83b3a
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa3390
jmp 0x83b3a
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa2960
jmp 0x83b3a
jmp 0x83b02
movq 0x1304cf(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda553(%rip), %rsi     # 0x15e066
leaq 0xec3a1(%rip), %rdx     # 0x16febb
leaq 0xea8d3(%rip), %rcx     # 0x16e3f4
leaq 0xea7cb(%rip), %r8      # 0x16e2f3
movl $0x156, %r9d            # imm = 0x156
movb $0x0, %al
callq 0xb890
callq 0xb2e0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputs
void gt_file_xfputs(const char *cstr, GtFile *file)
{
  if (!file)
    return gt_xfputs(cstr, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputs(cstr, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputs(cstr, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputs(cstr, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x83b6f
movq 0x10(%rsp), %rdi
movq 0x13044e(%rip), %rax    # 0x1b3fb0
movq (%rax), %rsi
callq 0x1c930
jmp 0x83c0f
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x83b96
jmp 0x83b80
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x83bab
jmp 0x83b8b
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x83bc0
jmp 0x83bd5
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1c930
jmp 0x83c0f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa3400
jmp 0x83c0f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa2a00
jmp 0x83c0f
jmp 0x83bd7
movq 0x1303fa(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda47e(%rip), %rsi     # 0x15e066
leaq 0xec2cc(%rip), %rdx     # 0x16febb
leaq 0xea80d(%rip), %rcx     # 0x16e403
leaq 0xea6f6(%rip), %r8      # 0x16e2f3
movl $0x168, %r9d            # imm = 0x168
movb $0x0, %al
callq 0xb890
callq 0xb2e0
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_xread
int gt_file_xread(GtFile *file, void *buf, size_t nbytes)
{
  int rval = -1;
  if (file) {
    switch (file->mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        rval = gt_xfread(buf, 1, nbytes, file->fileptr.file);
        break;
      case GT_FILE_MODE_GZIP:
        rval = gt_xgzread(file->fileptr.gzfile, buf, nbytes);
        break;
      case GT_FILE_MODE_BZIP2:
        rval = gt_xbzread(file->fileptr.bzfile, buf, nbytes);
        break;
      default: gt_assert(0);
    }
  }
  else
    rval = gt_xfread(buf, 1, nbytes, stdin);
  return rval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x20(%rsp)
je 0x83d0d
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x83c6e
jmp 0x83c58
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x83c91
jmp 0x83c63
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x83cb1
jmp 0x83cd1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
callq 0x1c9b0
movl %eax, 0xc(%rsp)
jmp 0x83d0b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xa3310
movl %eax, 0xc(%rsp)
jmp 0x83d0b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xa2900
movl %eax, 0xc(%rsp)
jmp 0x83d0b
jmp 0x83cd3
movq 0x1302fe(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda382(%rip), %rsi     # 0x15e066
leaq 0xec1d0(%rip), %rdx     # 0x16febb
leaq 0xea720(%rip), %rcx     # 0x16e412
leaq 0xea5fa(%rip), %r8      # 0x16e2f3
movl $0x17a, %r9d            # imm = 0x17A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x83d2f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x1302aa(%rip), %rax    # 0x1b3fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1c9b0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xwrite
void gt_file_xwrite(GtFile *file, void *buf, size_t nbytes)
{
  if (!file) {
    gt_xfwrite(buf, 1, nbytes, stdout);
    return;
  }
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfwrite(buf, 1, nbytes, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzwrite(file->fileptr.gzfile, buf, nbytes);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzwrite(file->fileptr.bzfile, buf, nbytes);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x83d7e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x130244(%rip), %rax    # 0x1b3fb0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1cab0
jmp 0x83e36
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x83da5
jmp 0x83d8f
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x83dc4
jmp 0x83d9a
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x83de0
jmp 0x83dfc
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
callq 0x1cab0
jmp 0x83e36
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xa3470
jmp 0x83e36
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xa2aa0
jmp 0x83e36
jmp 0x83dfe
movq 0x1301d3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda257(%rip), %rsi     # 0x15e066
leaq 0xec0a5(%rip), %rdx     # 0x16febb
leaq 0xea603(%rip), %rcx     # 0x16e420
leaq 0xea4cf(%rip), %r8      # 0x16e2f3
movl $0x192, %r9d            # imm = 0x192
movb $0x0, %al
callq 0xb890
callq 0xb2e0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: gt_file_xrewind
void gt_file_xrewind(GtFile *file)
{
  gt_assert(file);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      rewind(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzrewind(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzrewind(&file->fileptr.bzfile, file->orig_path, file->orig_mode);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x83e89
movq 0x130180(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda204(%rip), %rsi     # 0x15e066
leaq 0xe7e40(%rip), %rdx     # 0x16bca9
leaq 0xea5bf(%rip), %rcx     # 0x16e42f
leaq 0xea47c(%rip), %r8      # 0x16e2f3
movl $0x198, %r9d            # imm = 0x198
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x83e8b
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x83eb2
jmp 0x83e9c
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x83ec2
jmp 0x83ea7
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x83ed2
jmp 0x83ef4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xb0b0
jmp 0x83f2e
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa3520
jmp 0x83f2e
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
callq 0xa2b40
jmp 0x83f2e
jmp 0x83ef6
movq 0x1300db(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda15f(%rip), %rsi     # 0x15e066
leaq 0xebfad(%rip), %rdx     # 0x16febb
leaq 0xea51a(%rip), %rcx     # 0x16e42f
leaq 0xea3d7(%rip), %r8      # 0x16e2f3
movl $0x1a3, %r9d            # imm = 0x1A3
movb $0x0, %al
callq 0xb890
callq 0xb2e0
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
void gt_file_delete(GtFile *file)
{
  if (!file) return;
  if (file->reference_count) {
    file->reference_count--;
    return;
  }
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
        if (!file->is_stdin)
          gt_fa_fclose(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
        gt_fa_gzclose(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
        gt_fa_bzclose(file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
  gt_file_delete_without_handle(file);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x83f56
jmp 0x8401e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x83f78
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x8401e
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x83f9f
jmp 0x83f89
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x83fba
jmp 0x83f94
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x83fca
jmp 0x83fda
movq 0x10(%rsp), %rax
testb $0x1, 0x29(%rax)
jne 0x83fb8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7fb70
jmp 0x84014
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x80240
jmp 0x84014
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x80550
jmp 0x84014
jmp 0x83fdc
movq 0x12fff5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xda079(%rip), %rsi     # 0x15e066
leaq 0xebec7(%rip), %rdx     # 0x16febb
leaq 0xea444(%rip), %rcx     # 0x16e43f
leaq 0xea2f1(%rip), %r8      # 0x16e2f3
movl $0x1c1, %r9d            # imm = 0x1C1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movq 0x10(%rsp), %rdi
callq 0x83240
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/file.c
// Function: vgzprintf
static int vgzprintf(gzFile file, const char *format, va_list va, int buflen)
{
  int len;
  if (!buflen) {
    char buf[BUFSIZ];
    /* no buffer length given -> try static buffer */
    len = gt_xvsnprintf(buf, sizeof (buf), format, va);
    if (len >= BUFSIZ) {
      return len; /* unsuccessful trial -> return buffer length for next call */
    }
    gt_xgzwrite(file, buf, len);
  }
  else {
    char *dynbuf;
    /* buffer length given -> use dynamic buffer */
    dynbuf = gt_malloc((buflen + 1) * sizeof (char));
    len = gt_xvsnprintf(dynbuf, (buflen + 1) * sizeof (char), format, va);
    gt_assert(len == buflen);
    gt_xgzwrite(file, dynbuf, buflen);
    gt_free(dynbuf);
  }
  return 0; /* success */
}

// Assembly:
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, 0x2028(%rsp)
movq %rsi, 0x2020(%rsp)
movq %rdx, 0x2018(%rsp)
movl %ecx, 0x2014(%rsp)
cmpl $0x0, 0x2014(%rsp)
jne 0x840c4
leaq 0x10(%rsp), %rdi
movq 0x2020(%rsp), %rdx
movq 0x2018(%rsp), %rcx
movl $0x2000, %esi           # imm = 0x2000
callq 0x1cd20
movl %eax, 0x2010(%rsp)
cmpl $0x2000, 0x2010(%rsp) # imm = 0x2000
jl 0x840a6
movl 0x2010(%rsp), %eax
movl %eax, 0x2034(%rsp)
jmp 0x841a1
movq 0x2028(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl 0x2010(%rsp), %edx
callq 0xa3470
jmp 0x84196
movl 0x2014(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
leaq 0xea217(%rip), %rsi     # 0x16e2f3
movl $0xff, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2014(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
movq 0x2020(%rsp), %rdx
movq 0x2018(%rsp), %rcx
callq 0x1cd20
movl %eax, 0x2010(%rsp)
movl 0x2010(%rsp), %eax
cmpl 0x2014(%rsp), %eax
je 0x84165
movq 0x12fea4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd9f28(%rip), %rsi     # 0x15e066
leaq 0xea312(%rip), %rdx     # 0x16e457
leaq 0xea319(%rip), %rcx     # 0x16e465
leaq 0xea1a0(%rip), %r8      # 0x16e2f3
movl $0x101, %r9d            # imm = 0x101
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84167
movq 0x2028(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x2014(%rsp), %edx
callq 0xa3470
movq 0x8(%rsp), %rdi
leaq 0xea167(%rip), %rsi     # 0x16e2f3
movl $0x103, %edx            # imm = 0x103
callq 0xdab0
movl $0x0, 0x2034(%rsp)
movl 0x2034(%rsp), %eax
addq $0x2038, %rsp           # imm = 0x2038
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_exists
bool gt_file_exists(const char *path)
{
  FILE *file;
  if ((file = fopen(path, "r")) == NULL)
    return false;
  gt_xfclose(file);
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xe7ec7(%rip), %rsi     # 0x16c20c
callq 0xb6f0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x8435b
movb $0x0, 0x17(%rsp)
jmp 0x84369
movq (%rsp), %rdi
callq 0x1c710
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_exists_and_is_dir
bool gt_file_exists_and_is_dir(const char *path)
{
  struct stat sb;
  if (stat(path, &sb))
    return false;
  if (S_ISDIR(sb.st_mode))
    return true;
  return false;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xba90
cmpl $0x0, %eax
je 0x843b0
movb $0x0, 0xa7(%rsp)
jmp 0x843d2
movl 0x20(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x843ca
movb $0x1, 0xa7(%rsp)
jmp 0x843d2
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_exists_with_suffix
bool gt_file_exists_with_suffix(const char *path, const char *suffix)
{
  struct stat statbuf;
  GtStr *tmpfilename;

  gt_assert(path && suffix);

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

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

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
cmpq $0x0, 0xa8(%rsp)
je 0x8441d
cmpq $0x0, 0xa0(%rsp)
jne 0x84455
movq 0x12fbb4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd9c38(%rip), %rsi     # 0x15e066
leaq 0xea044(%rip), %rdx     # 0x16e479
leaq 0xea04c(%rip), %rcx     # 0x16e488
leaq 0xea060(%rip), %r8      # 0x16e4a3
movl $0x52, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84457
movq 0xa8(%rsp), %rdi
callq 0x18f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x18fb0
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xba90
cmpl $0x0, %eax
jne 0x844ab
movq 0x8(%rsp), %rdi
callq 0x1afc0
movb $0x1, 0xb7(%rsp)
jmp 0x844bd
movq 0x8(%rsp), %rdi
callq 0x1afc0
movb $0x0, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_is_newer
bool gt_file_is_newer(const char *a, const char *b)
{
  struct stat stat_a, stat_b;
  gt_assert(a && b);
  gt_xstat(a, &stat_a);
  gt_xstat(b, &stat_b);
  if (stat_a.st_mtime > stat_b.st_mtime ||
      (stat_a.st_mtime == stat_b.st_mtime &&
       stat_a.st_mtime > stat_b.st_mtime)) {
    return true;
  }
  return false;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
cmpq $0x0, 0x128(%rsp)
je 0x844fd
cmpq $0x0, 0x120(%rsp)
jne 0x84535
movq 0x12fad4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd9b58(%rip), %rsi     # 0x15e066
leaq 0xe9fa3(%rip), %rdx     # 0x16e4b8
leaq 0xe9fa3(%rip), %rcx     # 0x16e4bf
leaq 0xe9f80(%rip), %r8      # 0x16e4a3
movl $0x62, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84537
movq 0x128(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xa3020
movq 0x120(%rsp), %rdi
movq %rsp, %rsi
callq 0xa3020
movq 0xe8(%rsp), %rax
cmpq 0x58(%rsp), %rax
jg 0x84589
movq 0xe8(%rsp), %rax
cmpq 0x58(%rsp), %rax
jne 0x84593
movq 0xe8(%rsp), %rax
cmpq 0x58(%rsp), %rax
jle 0x84593
movb $0x1, 0x137(%rsp)
jmp 0x8459b
movb $0x0, 0x137(%rsp)
movb 0x137(%rsp), %al
andb $0x1, %al
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_number_of_lines
GtUword gt_file_number_of_lines(const char *path)
{
  GtUword number_of_lines = 0;
  GtFile *fp;
  int cc;
  gt_assert(path);
  fp = gt_file_xopen(path, "r");
  while ((cc = gt_file_xfgetc(fp)) != EOF)
    if (cc == '\n') number_of_lines++;
  gt_file_delete(fp);
  return number_of_lines;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x84602
movq 0x12fa07(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd9a8b(%rip), %rsi     # 0x15e066
leaq 0xe9b12(%rip), %rdx     # 0x16e0f4
leaq 0xe9ee7(%rip), %rcx     # 0x16e4d0
leaq 0xe9eb3(%rip), %r8      # 0x16e4a3
movl $0x72, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84604
movq 0x20(%rsp), %rdi
leaq 0xe7bfc(%rip), %rsi     # 0x16c20c
callq 0x834c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x83620
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x84644
cmpl $0xa, 0xc(%rsp)
jne 0x84642
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x8461a
movq 0x10(%rsp), %rdi
callq 0x83f40
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_suffix
const char* gt_file_suffix(const char *path)
{
  const char *suffixptr;
  gt_assert(path);
  suffixptr = path + gt_file_basename_length(path) - 1;
  while (suffixptr > path) {
    if (*suffixptr == GT_PATH_SEPARATOR)
      return "";
    else if (*suffixptr == '.')
      break;
    suffixptr--;
  }
  return suffixptr;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x846a9
movq 0x12f960(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd99e4(%rip), %rsi     # 0x15e066
leaq 0xe9a6b(%rip), %rdx     # 0x16e0f4
leaq 0xe9e58(%rip), %rcx     # 0x16e4e8
leaq 0xe9e0c(%rip), %r8      # 0x16e4a3
movl $0x7d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x846ab
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x82d50
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x8471b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x846fa
leaq 0xe77f0(%rip), %rax     # 0x16bee3
movq %rax, 0x20(%rsp)
jmp 0x84725
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x84709
jmp 0x8471b
jmp 0x8470b
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x846d3
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_dirname
void gt_file_dirname(GtStr *path, const char *file)
{
  GtWord i;
  gt_str_reset(path);
  for (i = (GtWord) (strlen(file) - 1); i >= 0; i--) {
    if (file[i] == GT_PATH_SEPARATOR)
      break;
  }
  if (i > 0)
    gt_str_append_cstr_nt(path, file, (GtUword) i);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x19b70
movq 0x8(%rsp), %rdi
callq 0xb240
subq $0x1, %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jl 0x84785
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x84775
jmp 0x84785
jmp 0x84777
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x8475a
cmpq $0x0, (%rsp)
jle 0x8479f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x19290
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: file_exists_and_is_regular_executable
static bool file_exists_and_is_regular_executable(const char *path)
{
  bool is_exec = false;
  struct stat sb;
  FILE *file;
#ifdef _WIN32
  size_t len = strlen(path);
#endif
  if ((file = fopen(path, "r")) == NULL)
    return false;
  gt_xfstat(fileno(file), &sb);
  if (S_ISREG(sb.st_mode) &&
#ifndef _WIN32
      (sb.st_mode & S_IXUSR || sb.st_mode & S_IXGRP || sb.st_mode & S_IXOTH )
#else
      (len > 4 && !strcmp(path + len - 4, ".exe"))
#endif
     ) {
    is_exec = true;
  }
  gt_xfclose(file);
  return is_exec;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0xe7606(%rip), %rsi     # 0x16c20c
callq 0xb6f0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x84c20
movb $0x0, 0xb7(%rsp)
jmp 0x84c8c
movq 0x8(%rsp), %rdi
callq 0xb690
movl %eax, %edi
leaq 0x10(%rsp), %rsi
callq 0xa2c00
movl 0x28(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x84c72
movl 0x28(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x84c6a
movl 0x28(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x84c6a
movl 0x28(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x84c72
movb $0x1, 0xa7(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c710
movb 0xa7(%rsp), %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_estimate_size
off_t gt_file_estimate_size(const char *file)
{
  off_t size;
  struct stat sb;
  GtFileMode gfm;
  int fd;

  gt_assert(file);

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

  return size;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
jne 0x84d32
movq 0x12f2d7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd935b(%rip), %rsi     # 0x15e066
leaq 0xe6f97(%rip), %rdx     # 0x16bca9
leaq 0xe97de(%rip), %rcx     # 0x16e4f7
leaq 0xe9783(%rip), %r8      # 0x16e4a3
movl $0x111, %r9d            # imm = 0x111
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84d34
movq 0xa0(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa2db0
movl %eax, (%rsp)
movl (%rsp), %edi
leaq 0x8(%rsp), %rsi
callq 0xa2c00
movq 0xa0(%rsp), %rdi
callq 0x82c10
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x84d7c
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
jmp 0x84d8d
movq 0x38(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x98(%rsp)
movl (%rsp), %edi
callq 0xa2b80
movq 0x98(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size
off_t gt_file_size(const char *file)
{
  struct stat sb;
  int fd;
  gt_assert(file);
  fd = gt_xopen(file, O_RDONLY, 0);
  gt_xfstat(fd, &sb);
  gt_xclose(fd);
  return sb.st_size;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
jne 0x84e02
movq 0x12f207(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd928b(%rip), %rsi     # 0x15e066
leaq 0xe6ec7(%rip), %rdx     # 0x16bca9
leaq 0xe9724(%rip), %rcx     # 0x16e50d
leaq 0xe96b3(%rip), %r8      # 0x16e4a3
movl $0x123, %r9d            # imm = 0x123
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84e04
movq 0xa0(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa2db0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0xa2c00
movl 0xc(%rsp), %edi
callq 0xa2b80
movq 0x40(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_xfile_cmp
void gt_xfile_cmp(const char *file1,const char *file2)
{
  FILE *fp1, *fp2;
  off_t offset;
  int cc1, cc2;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0xe6151(%rip), %rsi     # 0x16afab
callq 0xb6f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xe613b(%rip), %rsi     # 0x16afab
callq 0xb6f0
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb9a0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0xb9a0
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x84ee6
movq 0x12f128(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %r9d
movl 0x8(%rsp), %eax
leaq 0xe9648(%rip), %rsi     # 0x16e51a
movl %eax, (%rsp)
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
cmpl $-0x1, 0xc(%rsp)
jne 0x84eef
jmp 0x84f01
jmp 0x84ef1
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x84e83
movq 0x20(%rsp), %rdi
callq 0x1c710
movq 0x18(%rsp), %rdi
callq 0x1c710
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size_with_suffix
off_t gt_file_size_with_suffix(const char *path, const char *suffix)
{
  GtStr *tmpfilename;
  off_t tmpsize;

  gt_assert(path && suffix);

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x84f3e
cmpq $0x0, 0x18(%rsp)
jne 0x84f76
movq 0x12f093(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd9117(%rip), %rsi     # 0x15e066
leaq 0xe9523(%rip), %rdx     # 0x16e479
leaq 0xe95eb(%rip), %rcx     # 0x16e548
leaq 0xe953f(%rip), %r8      # 0x16e4a3
movl $0x14a, %r9d            # imm = 0x14A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x84f78
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18fb0
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
callq 0x84db0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_estimate_total_size
off_t gt_files_estimate_total_size(const GtStrArray *filenames)
{
  GtUword filenum;
  off_t totalsize = 0;

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

  return totalsize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b720
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x8503d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1b320
movq %rax, %rdi
callq 0x84ce0
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x84feb
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_guess_if_protein_sequences
int gt_files_guess_if_protein_sequences(const GtStrArray *filenames,
                                        GtError *err)
{
  unsigned int countnonbases = 0,
               currentposition;
  GtUchar currentchar;
  GtSequenceBuffer *fb;
  int retval;

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

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x850b6
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x8507e
jmp 0x850b6
movq 0x12ef53(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8fd7(%rip), %rsi     # 0x15e066
leaq 0xd95b2(%rip), %rdx     # 0x15e648
leaq 0xe94c4(%rip), %rcx     # 0x16e561
leaq 0xe93ff(%rip), %r8      # 0x16e4a3
movl $0x167, %r9d            # imm = 0x167
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x850b8
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9b6a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x850e1
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x851ca
movl $0x0, 0x18(%rsp)
cmpl $0x3e8, 0x18(%rsp)      # imm = 0x3E8
jae 0x851a7
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x17(%rsp), %rsi
callq 0x9bd50
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x8512d
movq 0x8(%rsp), %rdi
callq 0x9b570
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x851ca
cmpl $0x0, 0x4(%rsp)
jne 0x85136
jmp 0x851a7
movzbl 0x17(%rsp), %eax
movl %eax, (%rsp)
addl $-0x45, %eax
subl $0x2, %eax
jb 0x8517d
jmp 0x85148
movl (%rsp), %eax
subl $0x49, %eax
je 0x8517d
jmp 0x85152
movl (%rsp), %eax
subl $0x4c, %eax
je 0x8517d
jmp 0x8515c
movl (%rsp), %eax
addl $-0x50, %eax
subl $0x2, %eax
jb 0x8517d
jmp 0x85169
movl (%rsp), %eax
subl $0x58, %eax
je 0x8517d
jmp 0x85173
movl (%rsp), %eax
subl $0x5a, %eax
jne 0x8518a
jmp 0x8517d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x8518c
jmp 0x8518c
cmpl $0x0, 0x1c(%rsp)
jbe 0x85195
jmp 0x851a7
jmp 0x85197
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x850e9
movq 0x8(%rsp), %rdi
callq 0x9b570
cmpl $0x0, 0x1c(%rsp)
jbe 0x851c2
movl $0x1, 0x34(%rsp)
jmp 0x851ca
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/grep.c
// Function: gt_grep_escape_extended
void gt_grep_escape_extended(GtStr *dest, const char *str, size_t len)
{
  size_t i;
  gt_assert(dest && str);
  gt_str_reset(dest);
  for (i= 0; i < len; i++) {
    switch (str[i]) {
      case '.':
      case '*':
      case '^':
      case '$':
      case '+':
      case '?':
      case '(':
      case ')':
      case '[':
      case '{':
      case '\\':
      case '|':
        gt_str_append_cstr(dest, "\\");
        break;
      default:
        break;
    }
    gt_str_append_char(dest, str[i]);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x85203
cmpq $0x0, 0x18(%rsp)
jne 0x8523b
movq 0x12edce(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8e52(%rip), %rsi     # 0x15e066
leaq 0xe951d(%rip), %rdx     # 0x16e738
leaq 0xe9522(%rip), %rcx     # 0x16e744
leaq 0xe9533(%rip), %r8      # 0x16e75c
movl $0x2c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8523d
movq 0x20(%rsp), %rdi
callq 0x19b70
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x852c9
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x58, %eax
ja 0x8529f
movq (%rsp), %rax
leaq 0xe9351(%rip), %rcx     # 0x16e5d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
leaq 0xe94d4(%rip), %rsi     # 0x16e76c
callq 0x18fb0
jmp 0x852a1
jmp 0x852a1
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x194d0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x85250
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/grep.c
// Function: gt_grep_nt
int gt_grep_nt(GT_UNUSED bool *match, GT_UNUSED const char *pattern,
               GT_UNUSED const char *line, size_t len, GtError *err)
{
  regex_t matcher;
  int rval, had_err = 0;
  gt_error_check(err);
  gt_assert(pattern && line);
  if ((rval = tre_regcomp(&matcher, pattern, REG_EXTENDED | REG_NOSUB))) {
    grep_error(rval, &matcher, err);
    had_err = -1;
  }
  if (!had_err) {
    rval = tre_regnexec(&matcher, line, len, 0, NULL, 0);
    if (rval && rval != REG_NOMATCH) {
      grep_error(rval, &matcher, err);
      had_err = -1;
    }
  }
  tre_regfree(&matcher);
  if (!had_err) {
    if (rval)
      *match = false;
    else
      *match = true;
  }
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x85345
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x8530d
jmp 0x85345
movq 0x12ecc4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8d48(%rip), %rsi     # 0x15e066
leaq 0xd9323(%rip), %rdx     # 0x15e648
leaq 0xe9442(%rip), %rcx     # 0x16e76e
leaq 0xe9429(%rip), %r8      # 0x16e75c
movl $0x4a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x85347
jmp 0x85349
cmpq $0x0, 0x38(%rsp)
je 0x85359
cmpq $0x0, 0x30(%rsp)
jne 0x85391
movq 0x12ec78(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8cfc(%rip), %rsi     # 0x15e066
leaq 0xe9408(%rip), %rdx     # 0x16e779
leaq 0xe93f6(%rip), %rcx     # 0x16e76e
leaq 0xe93dd(%rip), %r8      # 0x16e75c
movl $0x4b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x85393
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x9, %edx
callq 0xb8ca0
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x853cb
movl 0xc(%rsp), %edi
movq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x85460
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0x8(%rsp)
jne 0x85420
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movq %r8, %rcx
callq 0xb9170
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x8541e
cmpl $0x1, 0xc(%rsp)
je 0x8541e
movl 0xc(%rsp), %edi
movq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x85460
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
jmp 0x85420
leaq 0x10(%rsp), %rdi
callq 0xb8d10
cmpl $0x0, 0x8(%rsp)
jne 0x8544c
cmpl $0x0, 0xc(%rsp)
je 0x85442
movq 0x40(%rsp), %rax
movb $0x0, (%rax)
jmp 0x8544a
movq 0x40(%rsp), %rax
movb $0x1, (%rax)
jmp 0x8544c
movl 0x8(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/grep.c
// Function: grep_error
static void grep_error(int errcode, regex_t *matcher, GtError *err)
{
  char sbuf[BUFSIZ], *buf;
  size_t bufsize;
  gt_error_check(err);
  bufsize = tre_regerror(errcode, matcher, NULL, 0);
  buf = gt_malloc(bufsize);
  (void) tre_regerror(errcode, matcher, buf ? buf : sbuf,
                      buf ? bufsize : BUFSIZ);
  gt_error_set(err, "grep(): %s", buf ? buf : sbuf);
  gt_free(buf);
}

// Assembly:
subq $0x2068, %rsp           # imm = 0x2068
movl %edi, 0x2064(%rsp)
movq %rsi, 0x2058(%rsp)
movq %rdx, 0x2050(%rsp)
cmpq $0x0, 0x2050(%rsp)
je 0x854d4
movq 0x2050(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x8549c
jmp 0x854d4
movq 0x12eb35(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8bb9(%rip), %rsi     # 0x15e066
leaq 0xd9194(%rip), %rdx     # 0x15e648
leaq 0xe939a(%rip), %rcx     # 0x16e855
leaq 0xe929a(%rip), %r8      # 0x16e75c
movl $0x20, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x854d6
movl 0x2064(%rsp), %edi
movq 0x2058(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xb8d20
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xe925a(%rip), %rsi     # 0x16e75c
movl $0x22, %edx
callq 0xd2e0
movq %rax, 0x48(%rsp)
movl 0x2064(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x2058(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x8553d
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x85547
leaq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x85565
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x85571
movl $0x2000, %eax           # imm = 0x2000
movq %rax, 0x18(%rsp)
jmp 0x85571
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edi
movq 0x18(%rsp), %rcx
callq 0xb8d20
movq 0x2050(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x855aa
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x855b4
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xe929b(%rip), %rsi     # 0x16e860
movb $0x0, %al
callq 0xc0d0
movq 0x48(%rsp), %rdi
leaq 0xe9184(%rip), %rsi     # 0x16e75c
movl $0x26, %edx
callq 0xdab0
addq $0x2068, %rsp           # imm = 0x2068
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_add
void gt_hashmap_add(GtHashmap *hm, void *key, void *value)
{
  struct map_entry keyvalpair = { key, value };
  if (!gt_hashtable_add((GtHashtable*) hm, &keyvalpair)) {
    ((struct map_entry *)gt_hashtable_get((GtHashtable*) hm, &keyvalpair))
      ->value = value;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x872d0
cmpl $0x0, %eax
jne 0x8656d
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x87110
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_cmp
static int
gt_hashmap_cmp(const void *elemA, const void *elemB, void *data)
{
  const struct map_entry *entryA = elemA,
    *entryB = elemB;
  struct hashiteration_state *dip = data;
  return ((GtCompareWithData)dip->keycmp)(entryA->key, entryB->key,
                                        dip->data);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdi
movq 0x10(%rsp), %rcx
movq (%rcx), %rsi
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)