LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta.c
// Function: gt_fasta_show_entry_nt_with_suffix
void gt_fasta_show_entry_nt_with_suffix(const char *description,
                                        GtUword description_length,
                                        const char *sequence,
                                        GtUword sequence_length,
                                        const char *suffix,
                                        GtUword width,
                                        GtFile *outfp)
{
  GtUword i, current_length, suffix_length;
  gt_assert(sequence);
  gt_file_xfputc(GT_FASTA_SEPARATOR, outfp);
  if (description != NULL) {
    for (i = 0;
         i < description_length && description[i] != '\0';
         ++i) {
      gt_file_xfputc(description[i], outfp);
    }
  }
  gt_file_xfputc('\n', outfp);
  for (i = 0, current_length = 0;
       i < sequence_length && sequence[i] != '\0';
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(sequence[i], outfp);
  }
  suffix_length = suffix ? strlen(suffix) : 0;
  for (i = 0;
       i < suffix_length;
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(suffix[i], outfp);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0x539a3
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r13
movq %rdi, %r12
movq 0x50(%rsp), %r15
pushq $0x3e
popq %rdi
movq %r15, %rsi
callq 0x54619
testq %r12, %r12
je 0x538e0
xorl %ebp, %ebp
cmpq %rbp, 0x8(%rsp)
je 0x538e0
movsbl (%r12,%rbp), %edi
testl %edi, %edi
je 0x538e0
movq %r15, %rsi
callq 0x54619
incq %rbp
jmp 0x538c3
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x54619
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %r12, 0x10(%rsp)
je 0x53938
movb (%r13,%r12), %al
testb %al, %al
je 0x53938
testq %rbx, %rbx
setne %cl
cmpq %rbx, %rbp
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x53925
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x54619
movb (%r13,%r12), %al
xorl %ebp, %ebp
movsbl %al, %edi
movq %r15, %rsi
callq 0x54619
incq %r12
incq %rbp
jmp 0x538f0
testq %r14, %r14
je 0x5394a
movq %r14, %rdi
callq 0xb260
movq %rax, %r12
jmp 0x5394d
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x5398a
testq %rbx, %rbx
setne %al
cmpq %rbx, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x53975
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x54619
xorl %ebp, %ebp
movsbl (%r14,%r13), %edi
movq %r15, %rsi
callq 0x54619
incq %r13
incq %rbp
jmp 0x53950
pushq $0xa
popq %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x54619
movq 0xda60e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x766b2(%rip), %rsi     # 0xca066
leaq 0x7e9d3(%rip), %rdx     # 0xd238e
leaq 0x86466(%rip), %rcx     # 0xd9e28
leaq 0x86482(%rip), %r8      # 0xd9e4b
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_mode_determine
GtFileMode gt_file_mode_determine(const char *path)
{
  size_t path_length;
  if (!path)
    return GT_FILE_MODE_UNCOMPRESSED;
  path_length = strlen(path);
  if (path_length >= 4 && strcmp(".gz", path + path_length - 3) == 0)
    return GT_FILE_MODE_GZIP;
  if (path_length >= 5 && strcmp(".bz2", path + path_length - 4) == 0)
    return GT_FILE_MODE_BZIP2;
  return GT_FILE_MODE_UNCOMPRESSED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x53bb4
movq %rdi, %r14
callq 0xb260
cmpq $0x4, %rax
jb 0x53bb4
movq %rax, %r15
leaq (%r14,%rax), %rsi
addq $-0x3, %rsi
leaq 0x86312(%rip), %rdi     # 0xd9e96
callq 0xb880
testl %eax, %eax
je 0x53bb1
cmpq $0x4, %r15
je 0x53bb4
addq %r15, %r14
addq $-0x4, %r14
leaq 0x862f9(%rip), %rdi     # 0xd9e9a
movq %r14, %rsi
callq 0xb880
testl %eax, %eax
jne 0x53bb4
pushq $0x2
jmp 0x53bb3
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_basename_length
size_t gt_file_basename_length(const char *path)
{
  size_t path_length;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x53c77
movq %rdi, %r14
callq 0xb260
movq %rax, %rbx
cmpq $0x4, %rax
jb 0x53c6c
leaq (%r14,%rbx), %rsi
addq $-0x3, %rsi
leaq 0x86264(%rip), %rdi     # 0xd9e96
callq 0xb880
testl %eax, %eax
je 0x53c46
cmpq $0x4, %rbx
jne 0x53c4c
pushq $0x4
popq %rbx
jmp 0x53c6c
addq $-0x3, %rbx
jmp 0x53c6c
addq %rbx, %r14
addq $-0x4, %r14
leaq 0x86240(%rip), %rdi     # 0xd9e9a
movq %r14, %rsi
callq 0xb880
leaq -0x4(%rbx), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xda33a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x763de(%rip), %rsi     # 0xca066
leaq 0x8601b(%rip), %rdx     # 0xd9caa
leaq 0x8622d(%rip), %rcx     # 0xd9ec3
leaq 0x86216(%rip), %r8      # 0xd9eb3
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_delete_without_handle
void gt_file_delete_without_handle(GtFile *file)
{
  if (!file) return;
  gt_free(file->orig_path);
  gt_free(file->orig_mode);
  gt_free(file);
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x54058
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
leaq 0x85f1f(%rip), %rdx     # 0xd9eb3
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
movl $0x97, %ecx
callq 0xce9a
movq %rax, %rbx
movl %ebp, (%rax)
andq $0x0, 0x8(%rax)
testq %r14, %r14
je 0x53fde
cmpl $0x2, %ebp
je 0x54017
cmpl $0x1, %ebp
je 0x53ffa
testl %ebp, %ebp
jne 0x540b4
leaq 0x85ee7(%rip), %rdx     # 0xd9eb3
movq %r14, %rdi
movq %r15, %rsi
movl $0x9d, %ecx
callq 0x51a8b
jmp 0x54011
testl %ebp, %ebp
jne 0x54086
movq 0xd9f93(%rip), %rax     # 0x12df80
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x5404a
leaq 0x85eb2(%rip), %rdx     # 0xd9eb3
movq %r14, %rdi
movq %r15, %rsi
movl $0xa0, %ecx
callq 0x51f54
movq %rax, 0x10(%rbx)
jmp 0x5404a
leaq 0x85e95(%rip), %rdx     # 0xd9eb3
movq %r14, %rdi
movq %r15, %rsi
movl $0xa3, %ecx
callq 0x5218d
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x4f8ae
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x4f8ae
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd9f59(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75ffd(%rip), %rsi     # 0xca066
leaq 0x857ec(%rip), %rdx     # 0xd985c
leaq 0x85ea4(%rip), %rcx     # 0xd9f1b
leaq 0x85e35(%rip), %r8      # 0xd9eb3
movl $0x96, %r9d
jmp 0x540e0
movq 0xd9f2b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75fcf(%rip), %rsi     # 0xca066
leaq 0x85e56(%rip), %rdx     # 0xd9ef4
leaq 0x85e76(%rip), %rcx     # 0xd9f1b
leaq 0x85e07(%rip), %r8      # 0xd9eb3
movl $0xab, %r9d
jmp 0x540e0
movq 0xd9efd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75fa1(%rip), %rsi     # 0xca066
leaq 0x87575(%rip), %rdx     # 0xdb641
leaq 0x85e48(%rip), %rcx     # 0xd9f1b
leaq 0x85dd9(%rip), %r8      # 0xd9eb3
movl $0xa7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_new_from_fileptr
GtFile* gt_file_new_from_fileptr(FILE *fp)
{
  GtFile *file;
  gt_assert(fp);
  file = gt_calloc(1, sizeof (GtFile));
  file->reference_count = 0;
  file->mode = GT_FILE_MODE_UNCOMPRESSED;
  file->fileptr.file = fp;
  return file;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x5417a
movq %rdi, %rbx
leaq 0x85d57(%rip), %rdx     # 0xd9eb3
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
movl $0xbc, %ecx
callq 0xce9a
andq $0x0, 0x8(%rax)
andl $0x0, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
movq 0xd9e37(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75edb(%rip), %rsi     # 0xca066
leaq 0x8f82f(%rip), %rdx     # 0xe39c1
leaq 0x85da8(%rip), %rcx     # 0xd9f41
leaq 0x85d13(%rip), %r8      # 0xd9eb3
movl $0xbb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x54207
cmpb $0x1, 0x2a(%rdi)
jne 0x54216
movsbl 0x28(%rdi), %eax
movb $0x0, 0x2a(%rdi)
retq
movq 0xd9d72(%rip), %rax     # 0x12df80
movq (%rax), %rdi
jmp 0x16324
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x54238
cmpl $0x1, %eax
je 0x5422f
testl %eax, %eax
jne 0x54241
movq 0x10(%rdi), %rdi
jmp 0x16324
movq 0x10(%rdi), %rdi
jmp 0x62746
movq 0x10(%rdi), %rdi
jmp 0x6219e
pushq %rax
movq 0xd9d6f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75e13(%rip), %rsi     # 0xca066
leaq 0x873e7(%rip), %rdx     # 0xdb641
leaq 0x85d06(%rip), %rcx     # 0xd9f67
leaq 0x85c4b(%rip), %r8      # 0xd9eb3
movl $0xdc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_unget_char
void gt_file_unget_char(GtFile *file, char c)
{
  if (file) {
    gt_assert(!file->unget_used); /* only one char can be unget at a time */
    file->unget_char = c;
    file->unget_used = true;
  }
  else
    gt_xungetc(c, stdin);
}

// Assembly:
testq %rdi, %rdi
je 0x5428e
cmpb $0x1, 0x2a(%rdi)
je 0x542a1
movb %sil, 0x28(%rdi)
movb $0x1, 0x2a(%rdi)
retq
movsbl %sil, %edi
movq 0xd9ce7(%rip), %rax     # 0x12df80
movq (%rax), %rsi
jmp 0x16636
pushq %rax
movq 0xd9d0f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75db3(%rip), %rsi     # 0xca066
leaq 0x85cbc(%rip), %rdx     # 0xd9f76
leaq 0x85cc7(%rip), %rcx     # 0xd9f88
leaq 0x85beb(%rip), %r8      # 0xd9eb3
movl $0xe8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_xprintf
void gt_file_xprintf(GtFile *file, const char *format, ...)
{
  va_list va;
  int rval;
  va_start(va, format);
  if ((rval = xvprintf(file, format, va, 0))) {
    gt_assert(rval > 0); /* negative return is not possible, rval should denote
                            the necessary buffer length -> try again with it */
    /* reset variable arguments */
    va_end(va);
    va_start(va, format);
    /* try again */
    rval = xvprintf(file, format, va, rval);
    gt_assert(!rval); /* xvprintf() should not fail with given buffer length */
  }
  va_end(va);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x54340
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
leaq 0x100(%rsp), %r12
movq %r12, 0x8(%rdx)
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %r13, (%rdx)
xorl %ecx, %ecx
callq 0x54403
testl %eax, %eax
je 0x5438c
jle 0x5439d
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
movq %r12, 0x8(%rdx)
movq %r13, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %ecx
callq 0x54403
testl %eax, %eax
jne 0x543cb
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xd9c14(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75cb8(%rip), %rsi     # 0xca066
leaq 0x85be6(%rip), %rdx     # 0xd9f9b
leaq 0x85be8(%rip), %rcx     # 0xd9fa4
leaq 0x85af0(%rip), %r8      # 0xd9eb3
movl $0x13c, %r9d            # imm = 0x13C
jmp 0x543f7
movq 0xd9be6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75c8a(%rip), %rsi     # 0xca066
leaq 0x76704(%rip), %rdx     # 0xcaae7
leaq 0x85bba(%rip), %rcx     # 0xd9fa4
leaq 0x85ac2(%rip), %r8      # 0xd9eb3
movl $0x143, %r9d            # imm = 0x143
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputc
void gt_file_xfputc(int c, GtFile *file)
{
  if (!file)
    return gt_xfputc(c, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputc(c, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputc(c, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputc(c, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x54637
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x5464f
cmpl $0x1, %eax
je 0x54646
testl %eax, %eax
jne 0x54658
movq 0x10(%rsi), %rsi
jmp 0x1640e
movq 0xd990a(%rip), %rax     # 0x12df48
movq (%rax), %rsi
jmp 0x1640e
movq 0x10(%rsi), %rsi
jmp 0x627bb
movq 0x10(%rsi), %rsi
jmp 0x621f8
pushq %rax
movq 0xd9958(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x759fc(%rip), %rsi     # 0xca066
leaq 0x86fd0(%rip), %rdx     # 0xdb641
leaq 0x8593c(%rip), %rcx     # 0xd9fb4
leaq 0x85834(%rip), %r8      # 0xd9eb3
movl $0x156, %r9d            # imm = 0x156
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_xfputs
void gt_file_xfputs(const char *cstr, GtFile *file)
{
  if (!file)
    return gt_xfputs(cstr, stdout);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfputs(cstr, file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzfputs(cstr, file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzfputs(cstr, file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x546af
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x546c7
cmpl $0x1, %eax
je 0x546be
testl %eax, %eax
jne 0x546d0
movq 0x10(%rsi), %rsi
jmp 0x1642f
movq 0xd9892(%rip), %rax     # 0x12df48
movq (%rax), %rsi
jmp 0x1642f
movq 0x10(%rsi), %rsi
jmp 0x6280c
movq 0x10(%rsi), %rsi
jmp 0x62241
pushq %rax
movq 0xd98e0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75984(%rip), %rsi     # 0xca066
leaq 0x86f58(%rip), %rdx     # 0xdb641
leaq 0x858d3(%rip), %rcx     # 0xd9fc3
leaq 0x857bc(%rip), %r8      # 0xd9eb3
movl $0x168, %r9d            # imm = 0x168
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_xread
int gt_file_xread(GtFile *file, void *buf, size_t nbytes)
{
  int rval = -1;
  if (file) {
    switch (file->mode) {
      case GT_FILE_MODE_UNCOMPRESSED:
        rval = gt_xfread(buf, 1, nbytes, file->fileptr.file);
        break;
      case GT_FILE_MODE_GZIP:
        rval = gt_xgzread(file->fileptr.gzfile, buf, nbytes);
        break;
      case GT_FILE_MODE_BZIP2:
        rval = gt_xbzread(file->fileptr.bzfile, buf, nbytes);
        break;
      default: gt_assert(0);
    }
  }
  else
    rval = gt_xfread(buf, 1, nbytes, stdin);
  return rval;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x54725
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x54749
cmpl $0x1, %eax
je 0x5473f
testl %eax, %eax
jne 0x54753
movq 0x10(%rdi), %rcx
jmp 0x5472f
movq 0xd9854(%rip), %rax     # 0x12df80
movq (%rax), %rcx
pushq $0x1
popq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1648b
popq %rcx
retq
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x6276f
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x621c7
movq 0xd985e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75902(%rip), %rsi     # 0xca066
leaq 0x86ed6(%rip), %rdx     # 0xdb641
leaq 0x85860(%rip), %rcx     # 0xd9fd2
leaq 0x8573a(%rip), %r8      # 0xd9eb3
movl $0x17a, %r9d            # imm = 0x17A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x547a6
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x547c7
cmpl $0x1, %eax
je 0x547be
testl %eax, %eax
jne 0x547d0
movq 0x10(%rdi), %rcx
jmp 0x547b0
movq 0xd979b(%rip), %rax     # 0x12df48
movq (%rax), %rcx
pushq $0x1
popq %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x1650c
movq 0x10(%rdi), %rdi
jmp 0x6285e
movq 0x10(%rdi), %rdi
jmp 0x62294
pushq %rax
movq 0xd97e0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75884(%rip), %rsi     # 0xca066
leaq 0x86e58(%rip), %rdx     # 0xdb641
leaq 0x857f0(%rip), %rcx     # 0xd9fe0
leaq 0x856bc(%rip), %r8      # 0xd9eb3
movl $0x192, %r9d            # imm = 0x192
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_xrewind
void gt_file_xrewind(GtFile *file)
{
  gt_assert(file);
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      rewind(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzrewind(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
      gt_xbzrewind(&file->fileptr.bzfile, file->orig_path, file->orig_mode);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x54848
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x54833
cmpl $0x1, %eax
je 0x54829
testl %eax, %eax
jne 0x54876
movq 0x10(%rdi), %rdi
popq %rax
jmp 0xb0c0
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x628eb
leaq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
movq %rax, %rdi
popq %rax
jmp 0x62301
movq 0xd9769(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7580d(%rip), %rsi     # 0xca066
leaq 0x83045(%rip), %rdx     # 0xd78a5
leaq 0x85788(%rip), %rcx     # 0xd9fef
leaq 0x85645(%rip), %r8      # 0xd9eb3
movl $0x198, %r9d            # imm = 0x198
jmp 0x548a2
movq 0xd973b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x757df(%rip), %rsi     # 0xca066
leaq 0x86db3(%rip), %rdx     # 0xdb641
leaq 0x8575a(%rip), %rcx     # 0xd9fef
leaq 0x85617(%rip), %r8      # 0xd9eb3
movl $0x1a3, %r9d            # imm = 0x1A3
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/file.c
// Function: gt_file_delete
void gt_file_delete(GtFile *file)
{
  if (!file) return;
  if (file->reference_count) {
    file->reference_count--;
    return;
  }
  switch (file->mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
        if (!file->is_stdin)
          gt_fa_fclose(file->fileptr.file);
      break;
    case GT_FILE_MODE_GZIP:
        gt_fa_gzclose(file->fileptr.gzfile);
      break;
    case GT_FILE_MODE_BZIP2:
        gt_fa_bzclose(file->fileptr.bzfile);
      break;
    default: gt_assert(0);
  }
  gt_file_delete_without_handle(file);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x548c7
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x548c9
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x548f5
cmpl $0x1, %eax
je 0x548ea
testl %eax, %eax
jne 0x54907
cmpb $0x0, 0x29(%rbx)
jne 0x548fe
movq 0x10(%rbx), %rdi
callq 0x51be1
jmp 0x548fe
movq 0x10(%rbx), %rdi
callq 0x51fee
jmp 0x548fe
movq 0x10(%rbx), %rdi
callq 0x52228
movq %rbx, %rdi
popq %rbx
jmp 0x53f28
movq 0xd96aa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7574e(%rip), %rsi     # 0xca066
leaq 0x86d22(%rip), %rdx     # 0xdb641
leaq 0x856d9(%rip), %rcx     # 0xd9fff
leaq 0x85586(%rip), %r8      # 0xd9eb3
movl $0x1c1, %r9d            # imm = 0x1C1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_exists_with_suffix
bool gt_file_exists_with_suffix(const char *path, const char *suffix)
{
  struct stat statbuf;
  GtStr *tmpfilename;

  gt_assert(path && suffix);

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x549ee
movq %rsi, %rbx
testq %rsi, %rsi
je 0x549ee
callq 0x13da9
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13dd3
movq %r14, %rdi
callq 0x143d2
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xbac0
testl %eax, %eax
sete %bl
movq %r14, %rdi
callq 0x152db
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq 0xd95c3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75667(%rip), %rsi     # 0xca066
leaq 0x85642(%rip), %rdx     # 0xda048
leaq 0x8564a(%rip), %rcx     # 0xda057
leaq 0x8565e(%rip), %r8      # 0xda072
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_is_newer
bool gt_file_is_newer(const char *a, const char *b)
{
  struct stat stat_a, stat_b;
  gt_assert(a && b);
  gt_xstat(a, &stat_a);
  gt_xstat(b, &stat_b);
  if (stat_a.st_mtime > stat_b.st_mtime ||
      (stat_a.st_mtime == stat_b.st_mtime &&
       stat_a.st_mtime > stat_b.st_mtime)) {
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
testq %rdi, %rdi
je 0x54a73
movq %rsi, %rbx
testq %rsi, %rsi
je 0x54a73
leaq 0x90(%rsp), %r14
movq %r14, %rsi
callq 0x625b9
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x625b9
movq 0x58(%r14), %rax
cmpq 0x58(%r15), %rax
setg %al
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq 0xd953e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x755e2(%rip), %rsi     # 0xca066
leaq 0x855fc(%rip), %rdx     # 0xda087
leaq 0x855fc(%rip), %rcx     # 0xda08e
leaq 0x855d9(%rip), %r8      # 0xda072
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_number_of_lines
GtUword gt_file_number_of_lines(const char *path)
{
  GtUword number_of_lines = 0;
  GtFile *fp;
  int cc;
  gt_assert(path);
  fp = gt_file_xopen(path, "r");
  while ((cc = gt_file_xfgetc(fp)) != EOF)
    if (cc == '\n') number_of_lines++;
  gt_file_delete(fp);
  return number_of_lines;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x54aed
leaq 0x8334c(%rip), %rsi     # 0xd7e05
callq 0x540ec
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x541f3
cmpl $-0x1, %eax
je 0x54ada
cmpl $0xa, %eax
jne 0x54ac3
incq %rbx
jmp 0x54ac3
movq %r14, %rdi
callq 0x548ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd94c4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75568(%rip), %rsi     # 0xca066
leaq 0x851a5(%rip), %rdx     # 0xd9caa
leaq 0x85593(%rip), %rcx     # 0xda09f
leaq 0x8555f(%rip), %r8      # 0xda072
pushq $0x72
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_suffix
const char* gt_file_suffix(const char *path)
{
  const char *suffixptr;
  gt_assert(path);
  suffixptr = path + gt_file_basename_length(path) - 1;
  while (suffixptr > path) {
    if (*suffixptr == GT_PATH_SEPARATOR)
      return "";
    else if (*suffixptr == '.')
      break;
    suffixptr--;
  }
  return suffixptr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x54b55
movq %rdi, %rbx
callq 0x53c09
addq %rbx, %rax
decq %rax
cmpq %rbx, %rax
jbe 0x54b53
movzbl (%rax), %ecx
cmpl $0x2e, %ecx
je 0x54b53
decq %rax
cmpl $0x2f, %ecx
jne 0x54b37
leaq 0x82f8c(%rip), %rax     # 0xd7adf
popq %rbx
retq
movq 0xd945c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x75500(%rip), %rsi     # 0xca066
leaq 0x8513d(%rip), %rdx     # 0xd9caa
leaq 0x85543(%rip), %rcx     # 0xda0b7
leaq 0x854f7(%rip), %r8      # 0xda072
pushq $0x7d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_dirname
void gt_file_dirname(GtStr *path, const char *file)
{
  GtWord i;
  gt_str_reset(path);
  for (i = (GtWord) (strlen(file) - 1); i >= 0; i--) {
    if (file[i] == GT_PATH_SEPARATOR)
      break;
  }
  if (i > 0)
    gt_str_append_cstr_nt(path, file, (GtUword) i);
}

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

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

  gt_assert(file);

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

  return size;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testq %rdi, %rdi
je 0x54f16
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x62472
movl %eax, %ebp
movq %rsp, %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x6236d
movq %rbx, %rdi
callq 0x53b58
movq 0x30(%r14), %rcx
leaq (,%rcx,4), %rbx
testl %eax, %eax
cmoveq %rcx, %rbx
movl %ebp, %edi
callq 0x6232c
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd909b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7513f(%rip), %rsi     # 0xca066
leaq 0x82977(%rip), %rdx     # 0xd78a5
leaq 0x85191(%rip), %rcx     # 0xda0c6
leaq 0x85136(%rip), %r8      # 0xda072
movl $0x111, %r9d            # imm = 0x111
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size
off_t gt_file_size(const char *file)
{
  struct stat sb;
  int fd;
  gt_assert(file);
  fd = gt_xopen(file, O_RDONLY, 0);
  gt_xfstat(fd, &sb);
  gt_xclose(fd);
  return sb.st_size;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x54f8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x62472
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x6236d
movl %ebx, %edi
callq 0x6232c
movq 0x30(%r14), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq 0xd9024(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x750c8(%rip), %rsi     # 0xca066
leaq 0x82900(%rip), %rdx     # 0xd78a5
leaq 0x85130(%rip), %rcx     # 0xda0dc
leaq 0x850bf(%rip), %r8      # 0xda072
movl $0x123, %r9d            # imm = 0x123
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_xfile_cmp
void gt_xfile_cmp(const char *file1,const char *file2)
{
  FILE *fp1, *fp2;
  off_t offset;
  int cc1, cc2;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x81bc1(%rip), %r15     # 0xd6b9e
movq %r15, %rsi
callq 0xb720
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, %r13
xorl %r15d, %r15d
movq %r12, %rdi
callq 0xb9d0
movl %eax, %ebp
movq %r13, %rdi
callq 0xb9d0
cmpl %eax, %ebp
jne 0x55037
cmpl $-0x1, %ebp
je 0x55019
incq %r15
jmp 0x54ff9
movq %r12, %rdi
callq 0x162e4
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x162e4
movq 0xd8f7a(%rip), %rcx     # 0x12dfb8
movq (%rcx), %rdi
movl %eax, (%rsp)
leaq 0x8509e(%rip), %rsi     # 0xda0e9
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_file_size_with_suffix
off_t gt_file_size_with_suffix(const char *path, const char *suffix)
{
  GtStr *tmpfilename;
  off_t tmpsize;

  gt_assert(path && suffix);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x550b0
movq %rsi, %rbx
testq %rsi, %rsi
je 0x550b0
callq 0x13da9
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13dd3
movq %r14, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x54f4e
movq %rax, %rbx
movq %r14, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd8f01(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74fa5(%rip), %rsi     # 0xca066
leaq 0x84f80(%rip), %rdx     # 0xda048
leaq 0x85048(%rip), %rcx     # 0xda117
leaq 0x84f9c(%rip), %r8      # 0xda072
movl $0x14a, %r9d            # imm = 0x14A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_estimate_total_size
off_t gt_files_estimate_total_size(const GtStrArray *filenames)
{
  GtUword filenum;
  off_t totalsize = 0;

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

  return totalsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x157f4
cmpq %rax, %r14
jae 0x5511e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1555e
movq %rax, %rdi
callq 0x54ebb
addq %rax, %r15
incq %r14
jmp 0x550f6
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fileutils.c
// Function: gt_files_guess_if_protein_sequences
int gt_files_guess_if_protein_sequences(const GtStrArray *filenames,
                                        GtError *err)
{
  unsigned int countnonbases = 0,
               currentposition;
  GtUchar currentchar;
  GtSequenceBuffer *fb;
  int retval;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x55149
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x551c1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e76b
testq %rax, %rax
je 0x551a9
movq %rax, %r14
movl $0x3e8, %r12d           # imm = 0x3E8
leaq 0x7(%rsp), %r15
movl $0x281893, %r13d        # imm = 0x281893
xorl %ebp, %ebp
subl $0x1, %r12d
jb 0x5519f
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5eb89
testl %eax, %eax
js 0x551bd
je 0x5519f
movzbl 0x7(%rsp), %eax
addl $-0x45, %eax
cmpl $0x15, %eax
ja 0x5516f
btl %eax, %r13d
jae 0x5516f
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x5e684
jmp 0x551ac
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
jmp 0x5519e
movq 0xd8df0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74e94(%rip), %rsi     # 0xca066
leaq 0x75480(%rip), %rdx     # 0xca659
leaq 0x84f50(%rip), %rcx     # 0xda130
leaq 0x84e8b(%rip), %r8      # 0xda072
movl $0x167, %r9d            # imm = 0x167
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/grep.c
// Function: gt_grep_escape_extended
void gt_grep_escape_extended(GtStr *dest, const char *str, size_t len)
{
  size_t i;
  gt_assert(dest && str);
  gt_str_reset(dest);
  for (i= 0; i < len; i++) {
    switch (str[i]) {
      case '.':
      case '*':
      case '^':
      case '$':
      case '+':
      case '?':
      case '(':
      case ')':
      case '[':
      case '{':
      case '\\':
      case '|':
        gt_str_append_cstr(dest, "\\");
        break;
      default:
        break;
    }
    gt_str_append_char(dest, str[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55285
movq %rsi, %r14
testq %rsi, %rsi
je 0x55285
movq %rdx, %rbx
movq %rdi, %r15
callq 0x1452f
xorl %r13d, %r13d
leaq 0x84fac(%rip), %r12     # 0xda1d5
movabsq $0x5800000080004f1, %rbp # imm = 0x5800000080004F1
cmpq %r13, %rbx
je 0x55276
movb (%r14,%r13), %al
movzbl %al, %ecx
leal -0x24(%rcx), %edx
cmpl $0x3a, %edx
ja 0x5526c
btq %rdx, %rbp
jae 0x5526c
movq %r15, %rdi
movq %r12, %rsi
callq 0x13dd3
movb (%r14,%r13), %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x140b1
incq %r13
jmp 0x55233
addl $-0x7b, %ecx
cmpl $0x2, %ecx
jb 0x5524d
jmp 0x5525c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8d2c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74dd0(%rip), %rsi     # 0xca066
leaq 0x84f04(%rip), %rdx     # 0xda1a1
leaq 0x84f09(%rip), %rcx     # 0xda1ad
leaq 0x84f1a(%rip), %r8      # 0xda1c5
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
testq %r8, %r8
je 0x552ed
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x553a1
testq %r12, %r12
je 0x55377
testq %r13, %r13
je 0x55377
leaq 0x8(%rsp), %rdi
pushq $0x9
popq %rdx
movq %r12, %rsi
callq 0x70b99
movl %eax, %ebp
testl %eax, %eax
jne 0x55336
xorl %r12d, %r12d
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x70da9
movl %eax, %ebp
movb $0x1, %r15b
cmpl $0x2, %eax
jb 0x5534f
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
movq %r14, %rdx
callq 0x553d7
pushq $-0x1
popq %r12
pushq $0x1
popq %rbp
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
callq 0x70bcc
testb %r15b, %r15b
je 0x55365
xorb $0x1, %bpl
movb %bpl, (%rbx)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8c3a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74cde(%rip), %rsi     # 0xca066
leaq 0x84e53(%rip), %rdx     # 0xda1e2
leaq 0x84e41(%rip), %rcx     # 0xda1d7
leaq 0x84e28(%rip), %r8      # 0xda1c5
pushq $0x4b
jmp 0x553c9
movq 0xd8c10(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74cb4(%rip), %rsi     # 0xca066
leaq 0x752a0(%rip), %rdx     # 0xca659
leaq 0x84e17(%rip), %rcx     # 0xda1d7
leaq 0x84dfe(%rip), %r8      # 0xda1c5
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x55401
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x5547f
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x70bd4
movq %rax, %r12
leaq 0x84dac(%rip), %rsi     # 0xda1c5
pushq $0x22
popq %rdx
movq %rax, %rdi
callq 0xccb0
movq %rax, %r13
testq %rax, %rax
movq %rsp, %r15
cmovneq %rax, %r15
movl $0x2000, %ecx           # imm = 0x2000
cmovneq %r12, %rcx
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x70bd4
leaq 0x84e7b(%rip), %rsi     # 0xda2c9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc007
pushq $0x26
popq %rdx
movq %r13, %rdi
leaq 0x84d5d(%rip), %rsi     # 0xda1c5
callq 0xd249
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8b32(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x74bd6(%rip), %rsi     # 0xca066
leaq 0x751c2(%rip), %rdx     # 0xca659
leaq 0x84e20(%rip), %rcx     # 0xda2be
leaq 0x84d20(%rip), %r8      # 0xda1c5
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_new_g
static GtHashmap* gt_hashmap_new_g(GtHashType keyhashtype, GtFree keyfree,
                                   GtFree valuefree, void* (*alloc)(size_t))
{
  struct hm_freefuncs *ff = alloc(sizeof (*ff));
  ff->keyfree = keyfree;
  ff->valuefree = valuefree;
  switch (keyhashtype) {
    case GT_HASH_DIRECT:
      {
        HashElemInfo hm_directkey_eleminfo = {
          gt_ht_ptr_elem_hash, { .free_elem_with_data = hm_elem_free },
          sizeof (struct map_entry), gt_ht_ptr_elem_cmp, ff, gt_free_func
        };
        if (alloc != gt_hashmap_malloc)
          return (GtHashmap*) gt_hashtable_new_no_ma(hm_directkey_eleminfo);
        else
          return (GtHashmap*) gt_hashtable_new(hm_directkey_eleminfo);
      }
    case GT_HASH_STRING:
      {
        HashElemInfo hm_strkey_eleminfo = {
          gt_ht_cstr_elem_hash, { .free_elem_with_data = hm_elem_free },
          sizeof (struct map_entry), gt_ht_cstr_elem_cmp, ff, gt_free_func
        };
        if (alloc != gt_hashmap_malloc)
          return (GtHashmap*) gt_hashtable_new_no_ma(hm_strkey_eleminfo);
        else
          return (GtHashmap*) gt_hashtable_new(hm_strkey_eleminfo);
      }
    default: gt_assert(0);
  }
  return NULL; /* for stupid compilers nagging too much */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
pushq $0x10
popq %rdi
callq *%rcx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
cmpl $0x1, %ebp
je 0x55e05
testl %ebp, %ebp
jne 0x55ea0
leaq 0x1625(%rip), %rcx      # 0x57407
movq %rcx, 0x38(%rsp)
leaq 0x5be(%rip), %rcx       # 0x563ac
movq %rcx, 0x40(%rsp)
movq $0x10, 0x48(%rsp)
leaq 0x1800(%rip), %rcx      # 0x57603
jmp 0x55e2d
leaq 0x17d2(%rip), %rcx      # 0x575de
movq %rcx, 0x38(%rsp)
leaq 0x594(%rip), %rcx       # 0x563ac
movq %rcx, 0x40(%rsp)
movq $0x10, 0x48(%rsp)
leaq 0x17f4(%rip), %rcx      # 0x57621
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
leaq -0x48aaf(%rip), %rax    # 0xd38f
movq %rax, 0x60(%rsp)
leaq 0x8c(%rip), %rax        # 0x55ed6
cmpq %rax, %rbx
je 0x55e73
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5654a
jmp 0x55e95
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5653b
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8111(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x741b5(%rip), %rsi     # 0xca066
leaq 0x85789(%rip), %rdx     # 0xdb641
leaq 0x8446b(%rip), %rcx     # 0xda32a
leaq 0x84423(%rip), %r8      # 0xda2e9
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rax, %rsi
callq 0x56680
testl %eax, %eax
jne 0x55f67
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x565c1
movq %rbx, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_unit_test
int
gt_hashmap_unit_test(GtError *err)
{
  int had_err;
  gt_error_check(err);

  /* direct hash */
  had_err = gt_hashmap_test(GT_HASH_DIRECT);

  /* string hash */
  if (!had_err)
    had_err = gt_hashmap_test(GT_HASH_STRING);

  if (had_err)
  {
    gt_error_set(err, "hashmap operation created inconsistent state.");
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5604c
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x56082
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x560ba
testl %eax, %eax
jne 0x56065
pushq $0x1
popq %rdi
callq 0x560ba
testl %eax, %eax
je 0x56079
leaq 0x84290(%rip), %rsi     # 0xda2fc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xd7f2f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73fd3(%rip), %rsi     # 0xca066
leaq 0x745bf(%rip), %rdx     # 0xca659
leaq 0x84233(%rip), %rcx     # 0xda2d4
leaq 0x84241(%rip), %r8      # 0xda2e9
movl $0x115, %r9d            # imm = 0x115
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashmap.c
// Function: hm_elem_free
static void
hm_elem_free(void *elem, void *table_data)
{
  struct hm_freefuncs *ff = table_data;
  gt_assert(elem && ff);
  if (ff->keyfree)
    ff->keyfree(((struct map_entry *)elem)->key);
  if (ff->valuefree)
    ff->valuefree(((struct map_entry *)elem)->value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x563eb
movq %rsi, %r14
testq %rsi, %rsi
je 0x563eb
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x563cd
movq (%rbx), %rdi
callq *%rax
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x563e3
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd7bc6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73c6a(%rip), %rsi     # 0xca066
leaq 0x83f38(%rip), %rdx     # 0xda33b
leaq 0x83f3c(%rip), %rcx     # 0xda346
leaq 0x83ed8(%rip), %r8      # 0xda2e9
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300