LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: add_fingerprints
static void add_fingerprints(char **md5_fingerprints, void *seqs,
                             GtGetSeqFunc get_seq, GtGetSeqLenFunc get_seq_len,
                             GtUword num_of_seqs)
{
  GtUword i;
  gt_assert(md5_fingerprints && seqs && get_seq && get_seq_len);
  for (i = 0; i < num_of_seqs; i++) {
    md5_fingerprints[i] = gt_md5_fingerprint(get_seq(seqs, i),
                                             get_seq_len(seqs, i));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x14931d
cmpq $0x0, 0x28(%rsp)
je 0x14931d
cmpq $0x0, 0x20(%rsp)
je 0x14931d
cmpq $0x0, 0x18(%rsp)
jne 0x149355
movq 0x6acb4(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14d38(%rip), %rsi     # 0x15e066
leaq 0x43727(%rip), %rdx     # 0x18ca5c
leaq 0x43753(%rip), %rcx     # 0x18ca8f
leaq 0x435dc(%rip), %r8      # 0x18c91f
movl $0x43, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149357
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x1493bf
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x159c10
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x149360
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: write_fingerprints
static void write_fingerprints(char **md5_fingerprints,
                               GtUword num_of_md5s,
                               GtStr *fingerprints_filename,
                               bool use_file_locking)
{
  FILE *fingerprints_file;
  gt_assert(md5_fingerprints && num_of_md5s && fingerprints_filename);
  fingerprints_file = gt_fa_xfopen(gt_str_get(fingerprints_filename), "w");
  if (use_file_locking)
    gt_fa_lock_exclusive(fingerprints_file);
  dump_md5_fingerprints(md5_fingerprints, num_of_md5s, fingerprints_file);
  if (use_file_locking)
    gt_fa_unlock(fingerprints_file);
  gt_fa_xfclose(fingerprints_file);
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x149403
cmpq $0x0, 0x18(%rsp)
je 0x149403
cmpq $0x0, 0x10(%rsp)
jne 0x14943b
movq 0x6abce(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14c52(%rip), %rsi     # 0x15e066
leaq 0x43685(%rip), %rdx     # 0x18caa0
leaq 0x436b7(%rip), %rcx     # 0x18cad9
leaq 0x434f6(%rip), %r8      # 0x18c91f
movl $0x5b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14943d
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
leaq 0x41e46(%rip), %rsi     # 0x18b297
leaq 0x434c7(%rip), %rdx     # 0x18c91f
movl $0x5c, %ecx
callq 0x7f9b0
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
je 0x149476
movq (%rsp), %rdi
callq 0x7ff90
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
callq 0x149a30
testb $0x1, 0xf(%rsp)
je 0x149499
movq (%rsp), %rdi
callq 0x7fff0
movq (%rsp), %rdi
callq 0x7fd50
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_new_from_cache_file
GtMD5Tab* gt_md5_tab_new_from_cache_file(const char *cache_file,
                                         GtUword num_of_seqs,
                                         bool use_file_locking,
                                         GtError *err)
{
  GtMD5Tab *md5_tab;
  bool reading_succeeded = false;
  gt_assert(cache_file);
  gt_error_check(err);

  md5_tab = gt_calloc(1, sizeof *md5_tab);
  md5_tab->num_of_md5s = num_of_seqs;
  if (gt_file_exists(cache_file)) {
    reading_succeeded = read_fingerprints(md5_tab,
                                          cache_file,
                                          use_file_locking);
  }
  if (!reading_succeeded) {
    gt_free(md5_tab);
    gt_error_set(err, "could not read fingerprints file \"%s\" or "
                      "invalid file contents", cache_file);
    return NULL;
  }
  md5_tab->owns_md5s = false;
  return md5_tab;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rcx, 0x10(%rsp)
movb $0x0, 0x7(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x149510
movq 0x6aaf9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14b7d(%rip), %rsi     # 0x15e066
leaq 0x43456(%rip), %rdx     # 0x18c946
leaq 0x4343b(%rip), %rcx     # 0x18c932
leaq 0x43421(%rip), %r8      # 0x18c91f
movl $0x8f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149512
jmp 0x149514
cmpq $0x0, 0x10(%rsp)
je 0x149564
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x14952c
jmp 0x149564
movq 0x6aaa5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14b29(%rip), %rsi     # 0x15e066
leaq 0x15104(%rip), %rdx     # 0x15e648
leaq 0x433e7(%rip), %rcx     # 0x18c932
leaq 0x433cd(%rip), %r8      # 0x18c91f
movl $0x90, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149566
movl $0x1, %edi
movl $0x38, %esi
leaq 0x433a8(%rip), %rdx     # 0x18c91f
movl $0x92, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
callq 0x84330
testb $0x1, %al
jne 0x1495a4
jmp 0x1495c2
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x149160
andb $0x1, %al
movb %al, 0x7(%rsp)
testb $0x1, 0x7(%rsp)
jne 0x149602
movq 0x8(%rsp), %rdi
leaq 0x4334a(%rip), %rsi     # 0x18c91f
movl $0x9a, %edx
callq 0xdab0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x43361(%rip), %rsi     # 0x18c951
movb $0x0, %al
callq 0xc0d0
movq $0x0, 0x30(%rsp)
jmp 0x149615
movq 0x8(%rsp), %rax
movb $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_delete
void gt_md5_tab_delete(GtMD5Tab *md5_tab)
{
  GtUword i;
  if (!md5_tab) return;
  if (md5_tab->reference_count) {
    md5_tab->reference_count--;
    return;
  }
  gt_fa_xmunmap(md5_tab->fingerprints);
  gt_fa_unlock(md5_tab->fingerprints_file);
  gt_fa_xfclose(md5_tab->fingerprints_file);
  gt_hashmap_delete(md5_tab->md5map);
  if (md5_tab->owns_md5s) {
    for (i = 0; i < md5_tab->num_of_md5s; i++)
      gt_free(md5_tab->md5_fingerprints[i]);
    gt_free(md5_tab->md5_fingerprints);
  }
  gt_free(md5_tab);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x149676
jmp 0x149755
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x149698
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x149755
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81a80
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7fff0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7fd50
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x86cc0
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0x14973f
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x149725
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x43214(%rip), %rsi     # 0x18c91f
movl $0xb8, %edx
callq 0xdab0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1496e2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x431ea(%rip), %rsi     # 0x18c91f
movl $0xb9, %edx
callq 0xdab0
movq 0x10(%rsp), %rdi
leaq 0x431d4(%rip), %rsi     # 0x18c91f
movl $0xbb, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_get
const char* gt_md5_tab_get(const GtMD5Tab *md5_tab, GtUword idx)
{
  gt_assert(md5_tab && idx < md5_tab->num_of_md5s);
  if (md5_tab->owns_md5s)
    return md5_tab->md5_fingerprints[idx];
 return md5_tab->fingerprints + idx * 33;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x149784
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x1497bc
movq 0x6a84d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x148d1(%rip), %rsi     # 0x15e066
leaq 0x431f4(%rip), %rdx     # 0x18c990
leaq 0x43213(%rip), %rcx     # 0x18c9b6
leaq 0x43175(%rip), %r8      # 0x18c91f
movl $0xc0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1497be
movq 0x8(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0x1497e1
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x1497f7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
imulq $0x21, (%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_map
GtUword gt_md5_tab_map(GtMD5Tab *md5_tab, const char *md5)
{
  const char *value;
  gt_assert(md5_tab && md5);
  if (!md5_tab->md5map)
    build_md5map(md5_tab);
  gt_assert(md5_tab->md5map);
  value = gt_hashmap_get(md5_tab->md5map, md5);
  if (value)
    return ((GtUword) value) - 1;
  return GT_UNDEF_UWORD;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14982e
cmpq $0x0, 0x10(%rsp)
jne 0x149866
movq 0x6a7a3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14827(%rip), %rsi     # 0x15e066
leaq 0x4317f(%rip), %rdx     # 0x18c9c5
leaq 0x43187(%rip), %rcx     # 0x18c9d4
leaq 0x430cb(%rip), %r8      # 0x18c91f
movl $0xd4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149868
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x14987e
movq 0x18(%rsp), %rdi
callq 0x149910
jmp 0x149880
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1498c4
movq 0x6a745(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x147c9(%rip), %rsi     # 0x15e066
leaq 0x4313f(%rip), %rdx     # 0x18c9e3
leaq 0x43129(%rip), %rcx     # 0x18c9d4
leaq 0x4306d(%rip), %r8      # 0x18c91f
movl $0xd7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1498c6
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x86470
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1498f6
movq 0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1498ff
movq $-0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: build_md5map
static void build_md5map(GtMD5Tab *md5_tab)
{
  GtUword i;
  gt_assert(md5_tab);
  md5_tab->md5map = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  for (i = 0; i < md5_tab->num_of_md5s; i++) {
    gt_hashmap_add(md5_tab->md5map, (void*) gt_md5_tab_get(md5_tab, i),
                   (void*) (i + 1));
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x149959
movq 0x6a6b0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14734(%rip), %rsi     # 0x15e066
leaq 0x415e5(%rip), %rdx     # 0x18af1e
leaq 0x431eb(%rip), %rcx     # 0x18cb2b
leaq 0x42fd8(%rip), %r8      # 0x18c91f
movl $0xc9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14995b
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x86190
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1499d2
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x149760
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rdx
addq $0x1, %rdx
callq 0x86510
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x149981
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_tab.c
// Function: dump_md5_fingerprints
static void dump_md5_fingerprints(char **md5_fingerprints,
                                  GtUword num_of_md5s, FILE *outfp)
{
  GtUword i;
  gt_assert(md5_fingerprints && num_of_md5s && outfp);
  for (i = 0; i < num_of_md5s; i++) {
    gt_xfputs(md5_fingerprints[i], outfp);
    gt_xfputc('\0', outfp);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x149a5b
cmpq $0x0, 0x18(%rsp)
je 0x149a5b
cmpq $0x0, 0x10(%rsp)
jne 0x149a93
movq 0x6a576(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x145fa(%rip), %rsi     # 0x15e066
leaq 0x43079(%rip), %rdx     # 0x18caec
leaq 0x4309b(%rip), %rcx     # 0x18cb15
leaq 0x42e9e(%rip), %r8      # 0x18c91f
movl $0x4e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149a95
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x149ade
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x1c930
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x1c8f0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x149a9e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/readmode.c
// Function: gt_readmode_parse
int gt_readmode_parse(const char *string, GtError *err)
{
  size_t i;

  gt_error_check(err);
  for (i=0; i<sizeof (readmodes)/sizeof (readmodes[0]); i++)
  {
    if (strcmp(string,readmodes[i]) == 0)
    {
      return (int) i;
    }
  }
  gt_error_set(err,"unknown readmode, must be fwd or rev or cpl or rcl");
  return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x149b6e
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x149b36
jmp 0x149b6e
movq 0x6a49b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1451f(%rip), %rsi     # 0x15e066
leaq 0x14afa(%rip), %rdx     # 0x15e648
leaq 0x42fe3(%rip), %rcx     # 0x18cb38
leaq 0x42fee(%rip), %r8      # 0x18cb4a
movl $0x24, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149b70
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x149bbd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x6c2ee(%rip), %rax     # 0x1b5e80
movq (%rax,%rcx,8), %rsi
callq 0xb850
cmpl $0x0, %eax
jne 0x149bab
movq 0x8(%rsp), %rax
movl %eax, 0x24(%rsp)
jmp 0x149bd8
jmp 0x149bad
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x149b79
movq 0x10(%rsp), %rdi
leaq 0x42f95(%rip), %rsi     # 0x18cb5e
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_new
GtSeq* gt_seq_new(const char *seq, GtUword seqlen, GtAlphabet *seqalpha)
{
  GtSeq *s;
  gt_assert(seq && seqalpha);
  s = gt_calloc(1, sizeof (GtSeq));
  s->seq = (char*) seq;
  s->seqlen = seqlen;
  s->seqalpha = gt_alphabet_ref(seqalpha);
  return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x149c53
cmpq $0x0, 0x10(%rsp)
jne 0x149c8b
movq 0x6a37e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14402(%rip), %rsi     # 0x15e066
leaq 0x42f2a(%rip), %rdx     # 0x18cb95
leaq 0x42f33(%rip), %rcx     # 0x18cba5
leaq 0x42f37(%rip), %r8      # 0x18cbb0
movl $0x21, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149c8d
movl $0x1, %edi
movl $0x30, %esi
leaq 0x42f12(%rip), %rdx     # 0x18cbb0
movl $0x22, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x109130
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_set_description_own
void gt_seq_set_description_own(GtSeq *s, char *desc)
{
  gt_assert(s);
  if (s->description && s->own_description)
    gt_free(s->description);
  s->description = desc;
  s->own_description = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x149dee
movq 0x6a21b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1429f(%rip), %rsi     # 0x15e066
leaq 0x220e0(%rip), %rdx     # 0x16beae
leaq 0x42e01(%rip), %rcx     # 0x18cbd6
leaq 0x42dd4(%rip), %r8      # 0x18cbb0
movl $0x38, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149df0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x149e21
movq 0x10(%rsp), %rax
testb $0x1, 0x21(%rax)
je 0x149e21
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x42d99(%rip), %rsi     # 0x18cbb0
movl $0x3a, %edx
callq 0xdab0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x21(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_get_encoded
const GtUchar* gt_seq_get_encoded(GtSeq *s)
{
  gt_assert(s);
  if (!s->encoded_seq) {
    s->encoded_seq = gt_malloc(sizeof (char) * (s->seqlen+1));
    gt_alphabet_encode_seq(s->seqalpha, s->encoded_seq, (char*) s->seq,
                           s->seqlen);
    s->encoded_seq[s->seqlen] = '\0';
  }
  return s->encoded_seq;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x149f24
movq 0x6a0e5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14169(%rip), %rsi     # 0x15e066
leaq 0x21faa(%rip), %rdx     # 0x16beae
leaq 0x42d0d(%rip), %rcx     # 0x18cc18
leaq 0x42c9e(%rip), %r8      # 0x18cbb0
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149f26
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x149f95
movq (%rsp), %rax
movq 0x18(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x42c68(%rip), %rsi     # 0x18cbb0
movl $0x4f, %edx
callq 0xd2e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq (%rsp), %rax
movq (%rax), %rdx
movq (%rsp), %rax
movq 0x18(%rax), %rcx
callq 0x10ad30
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
movq 0x10(%rax), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_delete
void gt_seq_delete(GtSeq *s)
{
  if (!s) return;
  if (s->own_seq)
    gt_free(s->seq);
  if (s->own_description)
    gt_free(s->description);
  gt_free(s->encoded_seq);
  gt_alphabet_delete(s->seqalpha);
  gt_free(s);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x14a051
jmp 0x14a0d1
movq (%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x14a073
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x42b47(%rip), %rsi     # 0x18cbb0
movl $0x67, %edx
callq 0xdab0
movq (%rsp), %rax
testb $0x1, 0x21(%rax)
je 0x14a096
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x42b24(%rip), %rsi     # 0x18cbb0
movl $0x69, %edx
callq 0xdab0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x42b0b(%rip), %rsi     # 0x18cbb0
movl $0x6a, %edx
callq 0xdab0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1098b0
movq (%rsp), %rdi
leaq 0x42ae9(%rip), %rsi     # 0x18cbb0
movl $0x6c, %edx
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_create
GtSeqCol* gt_seq_col_create(const GtSeqColClass *cc)
{
  GtSeqCol *c;
  gt_assert(cc && cc->size);
  c = gt_calloc(1, cc->size);
  c->c_class = cc;
  return c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14a24c
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x14a284
movq 0x69d85(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13e09(%rip), %rsi     # 0x15e066
leaq 0x1d3b1(%rip), %rdx     # 0x167615
leaq 0x429e2(%rip), %rcx     # 0x18cc4d
leaq 0x429ed(%rip), %r8      # 0x18cc5f
movl $0x44, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a286
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x429c5(%rip), %rdx     # 0x18cc5f
movl $0x45, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_delete
void gt_seq_col_delete(GtSeqCol *sc)
{
  if (!sc) return;
  gt_assert(sc->c_class);
  if (sc->c_class->free)
    sc->c_class->free(sc);
  gt_free(sc);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x14a2ce
jmp 0x14a348
jmp 0x14a2d0
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x14a312
movq 0x69cf7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13d7b(%rip), %rsi     # 0x15e066
leaq 0x42980(%rip), %rdx     # 0x18cc72
leaq 0x42985(%rip), %rcx     # 0x18cc7e
leaq 0x4295f(%rip), %r8      # 0x18cc5f
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a314
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x14a333
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rdi
leaq 0x42921(%rip), %rsi     # 0x18cc5f
movl $0x50, %edx
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc
int gt_seq_col_grep_desc(GtSeqCol *sc, char **seq, GtUword start,
                         GtUword end, GtStr *seqid, GtError *err)
{
  gt_assert(sc && seq && seqid);
  if (sc->c_class->grep_desc)
    return sc->c_class->grep_desc(sc, seq, start, end, seqid, err);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x14a479
cmpq $0x0, 0x20(%rsp)
je 0x14a479
cmpq $0x0, 0x8(%rsp)
jne 0x14a4b1
movq 0x69b58(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13bdc(%rip), %rsi     # 0x15e066
leaq 0x3a3d4(%rip), %rdx     # 0x184865
leaq 0x4284b(%rip), %rcx     # 0x18cce3
leaq 0x427c0(%rip), %r8      # 0x18cc5f
movl $0x63, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a4b3
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x14a4f3
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x14a4fb
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_md5
int gt_seq_col_grep_desc_md5(GtSeqCol *sc, const char **md5, GtStr *seqid,
                             GtError *err)
{
  gt_assert(sc && md5 && seqid);
  if (sc->c_class->grep_desc_md5)
    return sc->c_class->grep_desc_md5(sc, md5, seqid, err);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14a53f
cmpq $0x0, 0x10(%rsp)
je 0x14a53f
cmpq $0x0, 0x8(%rsp)
jne 0x14a577
movq 0x69a92(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13b16(%rip), %rsi     # 0x15e066
leaq 0x3a40c(%rip), %rdx     # 0x184963
leaq 0x4279a(%rip), %rcx     # 0x18ccf8
leaq 0x426fa(%rip), %r8      # 0x18cc5f
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a579
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x14a5af
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x14a5b7
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_description
int gt_seq_col_grep_desc_description(GtSeqCol *sc, GtStr *desc, GtStr *seqid,
                                     GtError *err)
{
  gt_assert(sc && desc && seqid);
  if (sc->c_class->grep_desc_desc)
    return sc->c_class->grep_desc_desc(sc, desc, seqid, err);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14a5ef
cmpq $0x0, 0x10(%rsp)
je 0x14a5ef
cmpq $0x0, 0x8(%rsp)
jne 0x14a627
movq 0x699e2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13a66(%rip), %rsi     # 0x15e066
leaq 0x3a32b(%rip), %rdx     # 0x184932
leaq 0x42703(%rip), %rcx     # 0x18cd11
leaq 0x4264a(%rip), %r8      # 0x18cc5f
movl $0x75, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a629
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x14a65f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x14a667
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_sequence_length
int gt_seq_col_grep_desc_sequence_length(GtSeqCol *sc, GtUword *length,
                                         GtStr *seqid, GtError *err)
{
  gt_assert(sc && length && seqid);
  if (sc->c_class->grep_desc_seqlen)
    return sc->c_class->grep_desc_seqlen(sc, length, seqid, err);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14a69f
cmpq $0x0, 0x10(%rsp)
je 0x14a69f
cmpq $0x0, 0x8(%rsp)
jne 0x14a6d7
movq 0x69932(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x139b6(%rip), %rsi     # 0x15e066
leaq 0x3a2e8(%rip), %rdx     # 0x18499f
leaq 0x42674(%rip), %rcx     # 0x18cd32
leaq 0x4259a(%rip), %r8      # 0x18cc5f
movl $0x7e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a6d9
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x14a70f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x14a717
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_seq
int gt_seq_col_md5_to_seq(GtSeqCol *sc, char **seq,
                          GtUword start, GtUword end,
                          GtStr *md5_seqid, GtError *err)
{
  gt_assert(sc && seq && md5_seqid);
  if (sc->c_class->md5_to_seq)
    return sc->c_class->md5_to_seq(sc, seq, start, end, md5_seqid, err);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x14a759
cmpq $0x0, 0x20(%rsp)
je 0x14a759
cmpq $0x0, 0x8(%rsp)
jne 0x14a791
movq 0x69878(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x138fc(%rip), %rsi     # 0x15e066
leaq 0x425e6(%rip), %rdx     # 0x18cd57
leaq 0x425f6(%rip), %rcx     # 0x18cd6e
leaq 0x424e0(%rip), %r8      # 0x18cc5f
movl $0x88, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a793
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x14a7d3
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x14a7db
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_description
int gt_seq_col_md5_to_description(GtSeqCol *sc, GtStr *desc, GtStr *md5_seqid,
                                  GtError *err)
{
  gt_assert(sc && desc && md5_seqid);
  if (sc->c_class->md5_to_desc)
    return sc->c_class->md5_to_desc(sc, desc, md5_seqid, err);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14a81f
cmpq $0x0, 0x10(%rsp)
je 0x14a81f
cmpq $0x0, 0x8(%rsp)
jne 0x14a857
movq 0x697b2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13836(%rip), %rsi     # 0x15e066
leaq 0x4254d(%rip), %rdx     # 0x18cd84
leaq 0x4255e(%rip), %rcx     # 0x18cd9c
leaq 0x4241a(%rip), %r8      # 0x18cc5f
movl $0x91, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a859
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0x14a88f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x14a897
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_sequence_length
int gt_seq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                      GtStr *md5_seqid, GtError *err)
{
  gt_assert(sc && len && md5_seqid);
  if (sc->c_class->md5_to_seqlen)
    return sc->c_class->md5_to_seqlen(sc, len, md5_seqid, err);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x14a8cf
cmpq $0x0, 0x10(%rsp)
je 0x14a8cf
cmpq $0x0, 0x8(%rsp)
jne 0x14a907
movq 0x69702(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13786(%rip), %rsi     # 0x15e066
leaq 0x424d3(%rip), %rdx     # 0x18cdba
leaq 0x424e3(%rip), %rcx     # 0x18cdd1
leaq 0x4236a(%rip), %r8      # 0x18cc5f
movl $0x9a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a909
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x14a93f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x14a947
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_files
GtUword gt_seq_col_num_of_files(const GtSeqCol *sc)
{
  gt_assert(sc);
  if (sc->c_class->num_files)
    return sc->c_class->num_files(sc);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x14a999
movq 0x69670(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x136f4(%rip), %rsi     # 0x15e066
leaq 0x3a0b6(%rip), %rdx     # 0x184a2f
leaq 0x42473(%rip), %rcx     # 0x18cdf3
leaq 0x422d8(%rip), %r8      # 0x18cc5f
movl $0xa2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14a99b
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x50(%rax)
je 0x14a9c4
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x14a9cd
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_seqs
GtUword gt_seq_col_num_of_seqs(const GtSeqCol *sc, GtUword filenum)
{
 gt_assert(sc);
  if (sc->c_class->num_seqs)
    return sc->c_class->num_seqs(sc, filenum);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x14aa2d
movq 0x695dc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13660(%rip), %rsi     # 0x15e066
leaq 0x3a022(%rip), %rdx     # 0x184a2f
leaq 0x423f7(%rip), %rcx     # 0x18ce0b
leaq 0x42244(%rip), %r8      # 0x18cc5f
movl $0xaa, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14aa2f
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x14aa5c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x14aa65
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_md5_fingerprint
const char* gt_seq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_md5)
    return sc->c_class->get_md5(sc, filenum, seqnum);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x14aac3
movq 0x69546(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x135ca(%rip), %rsi     # 0x15e066
leaq 0x39f8c(%rip), %rdx     # 0x184a2f
leaq 0x42378(%rip), %rcx     # 0x18ce22
leaq 0x421ae(%rip), %r8      # 0x18cc5f
movl $0xb4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14aac5
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x14aaf8
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x14ab01
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence
char* gt_seq_col_get_sequence(const GtSeqCol *sc, GtUword filenum,
                              GtUword seqnum,GtUword start,
                              GtUword end)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_seq(sc, filenum, seqnum, start, end);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x14ab6d
movq 0x6949c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13520(%rip), %rsi     # 0x15e066
leaq 0x39ee2(%rip), %rdx     # 0x184a2f
leaq 0x422ed(%rip), %rcx     # 0x18ce41
leaq 0x42104(%rip), %r8      # 0x18cc5f
movl $0xbe, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14ab6f
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
je 0x14abac
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x68(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x14abb5
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_description
char* gt_seq_col_get_description(const GtSeqCol *sc, GtUword filenum,
                                 GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_desc(sc, filenum, seqnum);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x14ac13
movq 0x693f6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1347a(%rip), %rsi     # 0x15e066
leaq 0x39e3c(%rip), %rdx     # 0x184a2f
leaq 0x4225f(%rip), %rcx     # 0x18ce59
leaq 0x4205e(%rip), %r8      # 0x18cc5f
movl $0xc7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14ac15
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
je 0x14ac48
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x14ac51
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence_length
GtUword gt_seq_col_get_sequence_length(const GtSeqCol *sc,
                                             GtUword filenum,
                                             GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seqlen)
    return sc->c_class->get_seqlen(sc, filenum, seqnum);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x14acb3
movq 0x69356(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x133da(%rip), %rsi     # 0x15e066
leaq 0x39d9c(%rip), %rdx     # 0x184a2f
leaq 0x421da(%rip), %rcx     # 0x18ce74
leaq 0x41fbe(%rip), %r8      # 0x18cc5f
movl $0xd1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14acb5
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x14ace8
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x14acf1
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/seq_info_cache.c
// Function: gt_seq_info_cache_add
void gt_seq_info_cache_add(GtSeqInfoCache *sic, const char *key,
                           const GtSeqInfo *si)
{
  GtSeqInfo *si_dup;
  gt_assert(sic && key && si);
  gt_assert(!gt_seq_info_cache_get(sic, key));
  si_dup = gt_malloc(sizeof *si_dup);
  si_dup->filenum = si->filenum;
  si_dup->seqnum = si->seqnum;
  gt_hashmap_add(sic->cache, gt_cstr_dup(key), si_dup);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x14ae1b
cmpq $0x0, 0x18(%rsp)
je 0x14ae1b
cmpq $0x0, 0x10(%rsp)
jne 0x14ae53
movq 0x691b6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1323a(%rip), %rsi     # 0x15e066
leaq 0x42090(%rip), %rdx     # 0x18cec3
leaq 0x4209a(%rip), %rcx     # 0x18ced4
leaq 0x42052(%rip), %r8      # 0x18ce93
movl $0x32, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14ae55
jmp 0x14ae57
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14ad80
cmpq $0x0, %rax
je 0x14aea4
movq 0x69165(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x131e9(%rip), %rsi     # 0x15e066
leaq 0x42066(%rip), %rdx     # 0x18ceea
leaq 0x42049(%rip), %rcx     # 0x18ced4
leaq 0x42001(%rip), %r8      # 0x18ce93
movl $0x33, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14aea6
movl $0x10, %edi
leaq 0x41fe1(%rip), %rsi     # 0x18ce93
movl $0x34, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7c400
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rdx
callq 0x86510
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_plain.c
// Function: gt_sequence_buffer_plain_new
GtSequenceBuffer* gt_sequence_buffer_plain_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferPlain *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_plain_class());
  sbf = gt_sequence_buffer_plain_cast(sb);
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x14af20
movq %rax, %rdi
callq 0x9b4b0
movq %rax, 0x8(%rsp)
callq 0x14af20
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b9e0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movb $0x1, 0x11(%rax)
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_register_all
void gt_sig_register_all(void (*func)(int sigraised))
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, func);
  (void) gt_xsignal(SIGFPE, func);
  (void) gt_xsignal(SIGILL, func);
  (void) gt_xsignal(SIGINT, func);
  (void) gt_xsignal(SIGSEGV, func);
  (void) gt_xsignal(SIGTERM, func);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, func);
  (void) gt_xsignal(SIGHUP, func);
  (void) gt_xsignal(SIGPIPE, func);
  (void) gt_xsignal(SIGQUIT, func);
  (void) gt_xsignal(SIGTSTP, func);
  (void) gt_xsignal(SIGTTIN, func);
  (void) gt_xsignal(SIGTTOU, func);
  (void) gt_xsignal(SIGUSR1, func);
  (void) gt_xsignal(SIGUSR2, func);
  (void) gt_xsignal(SIGSYS, func);
  (void) gt_xsignal(SIGXCPU, func);
  (void) gt_xsignal(SIGXFSZ, func);
#endif

  /* OpenBSD */
#ifdef SIGEMT
  (void) gt_xsignal(SIGEMT, func);
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rsi
movl $0x6, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x8, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x4, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x2, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0xb, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0xf, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x7, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x1, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0xd, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x3, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x14, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x15, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x16, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0xa, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0xc, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x1f, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x18, %edi
callq 0xa2fd0
movq (%rsp), %rsi
movl $0x19, %edi
callq 0xa2fd0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_unregister_all
void gt_sig_unregister_all(void)
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, SIG_DFL);
  (void) gt_xsignal(SIGFPE, SIG_DFL);
  (void) gt_xsignal(SIGILL, SIG_DFL);
  (void) gt_xsignal(SIGINT, SIG_DFL);
  (void) gt_xsignal(SIGSEGV, SIG_DFL);
  (void) gt_xsignal(SIGTERM, SIG_DFL);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, SIG_DFL);
  (void) gt_xsignal(SIGHUP, SIG_DFL);
  (void) gt_xsignal(SIGPIPE, SIG_DFL);
  (void) gt_xsignal(SIGQUIT, SIG_DFL);
  (void) gt_xsignal(SIGTSTP, SIG_DFL);
  (void) gt_xsignal(SIGTTIN, SIG_DFL);
  (void) gt_xsignal(SIGTTOU, SIG_DFL);
  (void) gt_xsignal(SIGUSR1, SIG_DFL);
  (void) gt_xsignal(SIGUSR2, SIG_DFL);
  (void) gt_xsignal(SIGSYS, SIG_DFL);
  (void) gt_xsignal(SIGXCPU, SIG_DFL);
  (void) gt_xsignal(SIGXFSZ, SIG_DFL);
#endif

  /* OpenBSD */
#ifdef SIGEMT
  (void) gt_xsignal(SIGEMT, SIG_DFL);
#endif
}

// Assembly:
pushq %rax
movl $0x6, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0xf, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x7, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0xd, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x14, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x15, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x16, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0xa, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0xc, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x1f, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x19, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_new
GtTimer* gt_timer_new(void)
{
  GtTimer *t = gt_malloc(sizeof *t);
  t->state = TIMER_RUNNING;
  t->statedesc = NULL;
  t->has_desc = false;
  t->omit_last_stage = false;
  t->show_cpu_time = false;
  return t;
}

// Assembly:
pushq %rax
movl $0x1f8, %edi            # imm = 0x1F8
leaq 0x41910(%rip), %rsi     # 0x18cfbd
movl $0x33, %edx
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, 0x1e0(%rax)
movq (%rsp), %rax
movq $0x0, 0x1e8(%rax)
movq (%rsp), %rax
movb $0x0, 0x1f0(%rax)
movq (%rsp), %rax
movb $0x0, 0x1f1(%rax)
movq (%rsp), %rax
movb $0x0, 0x1f2(%rax)
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_new_with_progress_description
GtTimer* gt_timer_new_with_progress_description(const char* desc)
{
  GtTimer *t = gt_timer_new();
  t->statedesc = gt_cstr_dup(desc);
  t->has_desc = true;
  return t;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x14b6a0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1e8(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x1f0(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_start
void gt_timer_start(GT_WIN32_UNUSED GtTimer *t)
{
#ifndef _WIN32
  gt_assert(t);
  gettimeofday(&t->gstart_tv, NULL);
  gettimeofday(&t->start_tv, NULL);
  gt_xgetrusage(RUSAGE_SELF, &t->start_ru);
  gt_xgetrusage(RUSAGE_SELF, &t->gstart_ru);
  t->state = TIMER_RUNNING;
#else
  /* XXX */
  fprintf(stderr, "gt_timer_start() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x14b794
movq 0x68875(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x128f9(%rip), %rsi     # 0x15e066
leaq 0x1c70a(%rip), %rdx     # 0x167e7e
leaq 0x41853(%rip), %rcx     # 0x18cfce
leaq 0x4183b(%rip), %r8      # 0x18cfbd
movl $0x47, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14b796
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb9e0
movq (%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb9e0
movq (%rsp), %rsi
addq $0xc0, %rsi
xorl %edi, %edi
callq 0xa2c40
movq (%rsp), %rsi
addq $0x30, %rsi
xorl %edi, %edi
callq 0xa2c40
movq (%rsp), %rax
movl $0x0, 0x1e0(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_stop
void gt_timer_stop(GT_WIN32_UNUSED GtTimer *t)
{
  gt_assert(t);
#ifndef _WIN32
  if (t->state == TIMER_RUNNING) {
    gettimeofday(&t->stop_tv, NULL);
    gt_xgetrusage(RUSAGE_SELF, &t->stop_ru);
    t->state = TIMER_STOPPED;
  }
#else
  /* XXX */
  fprintf(stderr, "gt_timer_stop() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x14b834
movq 0x687d5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x12859(%rip), %rsi     # 0x15e066
leaq 0x1c66a(%rip), %rdx     # 0x167e7e
leaq 0x417c2(%rip), %rcx     # 0x18cfdd
leaq 0x4179b(%rip), %r8      # 0x18cfbd
movl $0x56, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14b836
movq (%rsp), %rax
cmpl $0x0, 0x1e0(%rax)
jne 0x14b874
movq (%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb9e0
movq (%rsp), %rsi
addq $0x150, %rsi            # imm = 0x150
xorl %edi, %edi
callq 0xa2c40
movq (%rsp), %rax
movl $0x1, 0x1e0(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)