LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: compareGtRange
static int compareGtRange(const void *a, const void *b)
{
  const GtRange *vala, *valb;

  vala = (GtRange *) a;
  valb = (GtRange *) b;
  if (vala->start < valb->start) {
    makeerrormsg(vala, valb, "<");
    return -1;
  }
  if (vala->start > valb->start) {
    makeerrormsg(vala, valb, ">");
    return 1;
  }
  if (vala->end < valb->end) {
    makeerrormsg(vala, valb, "<");
    return -1;
  }
  if (vala->end > valb->end) {
    makeerrormsg(vala, valb, ">");
    return 1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0x1221c4
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x67bee(%rip), %rdx     # 0x189da0
callq 0x134210
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x122260
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x1221f4
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x54039(%rip), %rdx     # 0x17621e
callq 0x134210
movl $0x1, 0x24(%rsp)
jmp 0x122260
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x122226
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x67b89(%rip), %rdx     # 0x189da0
callq 0x134210
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x122260
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x122258
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x53fd5(%rip), %rdx     # 0x17621e
callq 0x134210
movl $0x1, 0x24(%rsp)
jmp 0x122260
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_new
GtEncseqEncoder* gt_encseq_encoder_new()
{
  GtEncseqEncoder *ee = gt_calloc((size_t) 1, sizeof (GtEncseqEncoder));
  gt_encseq_encoder_enable_multiseq_support(ee);
  gt_encseq_encoder_enable_description_support(ee);
  gt_encseq_encoder_enable_md5_support(ee);
  gt_encseq_encoder_disable_lossless_support(ee);
  ee->esq_no_header = false;
  ee->isdna = ee->isprotein = ee->isplain = false;
  ee->sat = gt_str_new();
  ee->smapfile = gt_str_new();
  return ee;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x48, %esi
leaq 0x633dc(%rip), %rdx     # 0x18565e
movl $0x1ffa, %ecx           # imm = 0x1FFA
callq 0xd5b0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x122300
movq (%rsp), %rdi
callq 0x122360
movq (%rsp), %rdi
callq 0x1223c0
movq (%rsp), %rdi
callq 0x122420
movq (%rsp), %rax
movb $0x0, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x7(%rax)
movq (%rsp), %rax
movb $0x0, 0x6(%rax)
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_set_input_dna
void gt_encseq_encoder_set_input_dna(GtEncseqEncoder *ee)
{
  gt_assert(ee);
  ee->isdna = true;
  ee->isprotein = false;
  ee->isplain = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x122984
movq 0x91685(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b709(%rip), %rsi     # 0x15e066
leaq 0x3d99c(%rip), %rdx     # 0x160300
leaq 0x64864(%rip), %rcx     # 0x1871cf
leaq 0x62cec(%rip), %r8      # 0x18565e
movl $0x20e1, %r9d           # imm = 0x20E1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x122986
movq (%rsp), %rax
movb $0x1, 0x5(%rax)
movq (%rsp), %rax
movb $0x0, 0x6(%rax)
movq (%rsp), %rax
movb $0x0, 0x7(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_set_input_protein
void gt_encseq_encoder_set_input_protein(GtEncseqEncoder *ee)
{
  gt_assert(ee);
  ee->isdna = false;
  ee->isprotein = true;
  ee->isplain = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1229e4
movq 0x91625(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b6a9(%rip), %rsi     # 0x15e066
leaq 0x3d93c(%rip), %rdx     # 0x160300
leaq 0x64843(%rip), %rcx     # 0x18720e
leaq 0x62c8c(%rip), %r8      # 0x18565e
movl $0x20ef, %r9d           # imm = 0x20EF
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1229e6
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
movq (%rsp), %rax
movb $0x1, 0x6(%rax)
movq (%rsp), %rax
movb $0x0, 0x7(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_set_input_preencoded
void gt_encseq_encoder_set_input_preencoded(GtEncseqEncoder *ee)
{
  gt_assert(ee);
  ee->isdna = false;
  ee->isprotein = false;
  ee->isplain = true;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x122a44
movq 0x915c5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b649(%rip), %rsi     # 0x15e066
leaq 0x3d8dc(%rip), %rdx     # 0x160300
leaq 0x6482a(%rip), %rcx     # 0x187255
leaq 0x62c2c(%rip), %r8      # 0x18565e
movl $0x20fd, %r9d           # imm = 0x20FD
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x122a46
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
movq (%rsp), %rax
movb $0x0, 0x6(%rax)
movq (%rsp), %rax
movb $0x1, 0x7(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_enable_dust
void gt_encseq_encoder_enable_dust(GtEncseqEncoder *ee, bool echo, GtUword ws,
                                   double thresh, GtUword linker)
{
  gt_assert(ee);
  ee->dust = true;
  ee->dust_echo = echo;
  ee->dust_windowsize = ws;
  ee->dust_threshold = thresh;
  ee->dust_linker = linker;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x122b71
movq 0x91498(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b51c(%rip), %rsi     # 0x15e066
leaq 0x3d7af(%rip), %rdx     # 0x160300
leaq 0x64764(%rip), %rcx     # 0x1872bc
leaq 0x62aff(%rip), %r8      # 0x18565e
movl $0x2112, %r9d           # imm = 0x2112
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x122b73
movq 0x20(%rsp), %rax
movb $0x1, 0xa(%rax)
movb 0x1f(%rsp), %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xb(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_use_symbolmap_file
int gt_encseq_encoder_use_symbolmap_file(GtEncseqEncoder *ee, const char *smap,
                                         GT_UNUSED GtError *err)
{
  gt_assert(ee && smap);
  if (ee->smapfile != NULL)
    gt_str_delete(ee->smapfile);
  ee->smapfile = gt_str_new_cstr(smap);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x122be2
cmpq $0x0, 0x8(%rsp)
jne 0x122c1a
movq 0x913ef(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b473(%rip), %rsi     # 0x15e066
leaq 0x64772(%rip), %rdx     # 0x18736c
leaq 0x64776(%rip), %rcx     # 0x187377
leaq 0x62a56(%rip), %r8      # 0x18565e
movl $0x2138, %r9d           # imm = 0x2138
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x122c1c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x122c36
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rdi
callq 0x18f70
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_use_representation
int gt_encseq_encoder_use_representation(GtEncseqEncoder *ee, const char *sat,
                                         GtError *err)
{
  gt_assert(ee && sat);
  if (sat && strlen(sat) > 0
        && gt_encseq_access_type_get(sat) == GT_ACCESS_TYPE_UNDEFINED) {
    gt_error_set(err, "undefined access type: '%s'", sat);
    return -1;
  }
  if (ee->sat != NULL)
    gt_str_delete(ee->sat);
  ee->sat = gt_str_new_cstr(sat);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x122c83
cmpq $0x0, 0x10(%rsp)
jne 0x122cbb
movq 0x9134e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b3d2(%rip), %rsi     # 0x15e066
leaq 0x64665(%rip), %rdx     # 0x187300
leaq 0x64668(%rip), %rcx     # 0x18730a
leaq 0x629b5(%rip), %r8      # 0x18565e
movl $0x2123, %r9d           # imm = 0x2123
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x122cbd
cmpq $0x0, 0x10(%rsp)
je 0x122d06
movq 0x10(%rsp), %rdi
callq 0xb240
cmpq $0x0, %rax
jbe 0x122d06
movq 0x10(%rsp), %rdi
callq 0x13e840
cmpl $0x7, %eax
jne 0x122d06
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x6463a(%rip), %rsi     # 0x18732f
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x122d3e
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x122d20
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rdi
callq 0x18f70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_encoder_delete
void gt_encseq_encoder_delete(GtEncseqEncoder *ee)
{
  if (!ee) return;
  gt_str_delete(ee->sat);
  gt_str_delete(ee->smapfile);
  gt_free(ee);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x122d5e
jmp 0x122d8d
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rdi
leaq 0x628db(%rip), %rsi     # 0x18565e
movl $0x2171, %edx           # imm = 0x2171
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_loader_new_from_options
GtEncseqLoader* gt_encseq_loader_new_from_options(GtEncseqOptions *opts,
                                                  GT_UNUSED GtError *err)
{
  GtEncseqLoader *el = NULL;
  gt_assert(opts);

  el = gt_encseq_loader_new();
  /* set options according to option object */
  if (gt_encseq_options_lossless_value(opts))
    gt_encseq_loader_require_lossless_support(el);
  if (gt_encseq_options_md5_value(opts))
    gt_encseq_loader_require_md5_support(el);
  if (gt_encseq_options_mirrored_value(opts))
    gt_encseq_loader_mirror(el);
  return el;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x124866
movq 0x8f7a3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x39827(%rip), %rsi     # 0x15e066
leaq 0x625b7(%rip), %rdx     # 0x186dfd
leaq 0x62bc2(%rip), %rcx     # 0x18740f
leaq 0x60e0a(%rip), %r8      # 0x18565e
movl $0x218f, %r9d           # imm = 0x218F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x124868
callq 0x121c20
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x1439f0
testb $0x1, %al
jne 0x124881
jmp 0x12488a
movq (%rsp), %rdi
callq 0x1248d0
movq 0x10(%rsp), %rdi
callq 0x143aa0
testb $0x1, %al
jne 0x12489a
jmp 0x1248a3
movq (%rsp), %rdi
callq 0x1248e0
movq 0x10(%rsp), %rdi
callq 0x143b60
testb $0x1, %al
jne 0x1248b3
jmp 0x1248bc
movq (%rsp), %rdi
callq 0x1248f0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_builder_new
GtEncseqBuilder* gt_encseq_builder_new(GtAlphabet *alpha)
{
  GtEncseqBuilder *eb;
  gt_assert(alpha);
  eb = gt_calloc((size_t) 1, sizeof (GtEncseqBuilder));
  eb->own = false;
  eb->alpha = gt_alphabet_ref(alpha);
  GT_INITARRAY(&eb->ssptab, GtUword);
  GT_INITARRAY(&eb->sdstab, GtUword);
  eb->destab = gt_str_new();
  eb->firstdesc = true;
  eb->firstseq = true;
  eb->minseqlen = eb->maxseqlen = GT_UNDEF_UWORD;
  return eb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1260e9
movq 0x8df20(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x37fa4(%rip), %rsi     # 0x15e066
leaq 0x555fb(%rip), %rdx     # 0x17b6c4
leaq 0x61687(%rip), %rcx     # 0x187757
leaq 0x5f587(%rip), %r8      # 0x18565e
movl $0x2294, %r9d           # imm = 0x2294
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1260eb
movl $0x1, %edi
movl $0x80, %esi
leaq 0x5f562(%rip), %rdx     # 0x18565e
movl $0x2295, %ecx           # imm = 0x2295
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, 0x68(%rax)
movq 0x10(%rsp), %rdi
callq 0x109130
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
jmp 0x126153
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
callq 0x18f00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x6d(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x6e(%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x18(%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/encseq.c
// Function: gt_encseq_builder_add_multiple_encoded
void gt_encseq_builder_add_multiple_encoded(GtEncseqBuilder *eb,
                                            const GtUchar *str,
                                            GtUword strlen)
{
  GtUword idx, laststart = 0;

  for (idx = 0; idx < strlen; idx++)
  {
    if (str[idx] == GT_SEPARATOR)
    {
      gt_assert(laststart < idx);
      gt_encseq_builder_add_encoded(eb, str + laststart, idx - laststart, NULL);
      laststart = idx + 1;
    }
  }
  gt_assert(laststart < idx);
  gt_encseq_builder_add_encoded(eb, str + laststart, idx - laststart, NULL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x127592
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x12757d
jmp 0x12750b
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x12754e
movq 0x8cabb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x36b3f(%rip), %rsi     # 0x15e066
leaq 0x604f6(%rip), %rdx     # 0x187a24
leaq 0x604ff(%rip), %rcx     # 0x187a34
leaq 0x5e122(%rip), %r8      # 0x18565e
movl $0x238a, %r9d           # imm = 0x238A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x127550
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq (%rsp), %rsi
movq 0x8(%rsp), %rdx
subq (%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x126bb0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x12757f
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1274e4
jmp 0x127594
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x1275d7
movq 0x8ca32(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x36ab6(%rip), %rsi     # 0x15e066
leaq 0x6046d(%rip), %rdx     # 0x187a24
leaq 0x60476(%rip), %rcx     # 0x187a34
leaq 0x5e099(%rip), %r8      # 0x18565e
movl $0x238f, %r9d           # imm = 0x238F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1275d9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq (%rsp), %rsi
movq 0x8(%rsp), %rdx
subq (%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x126bb0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_builder_reset
void gt_encseq_builder_reset(GtEncseqBuilder *eb)
{
  gt_assert(eb);
  /* if ownership was not transferred to new encoded sequence, clean up
     intermediate buffer */
  if (!eb->created_encseq && eb->own) {
    gt_free(eb->plainseq);
  }
  if (!eb->created_encseq) {
    GT_FREEARRAY(&eb->sdstab, GtUword);
  }
  GT_INITARRAY(&eb->sdstab, GtUword);
  GT_INITARRAY(&eb->ssptab, GtUword);
  gt_str_reset(eb->destab);
  eb->own = false;
  eb->nof_seqs = 0;
  eb->minseqlen = eb->maxseqlen = GT_UNDEF_UWORD;
  eb->seqlen = 0;
  eb->allocated = 0;
  eb->firstdesc = true;
  eb->firstseq = true;
  eb->created_encseq = false;
  eb->plainseq = NULL;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1276b4
movq 0x8c955(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x369d9(%rip), %rsi     # 0x15e066
leaq 0x600d9(%rip), %rdx     # 0x18776d
leaq 0x603dd(%rip), %rcx     # 0x187a78
leaq 0x5dfbc(%rip), %r8      # 0x18565e
movl $0x239b, %r9d           # imm = 0x239B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1276b6
movq (%rsp), %rax
testb $0x1, 0x69(%rax)
jne 0x1276e2
movq (%rsp), %rax
testb $0x1, 0x68(%rax)
je 0x1276e2
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x5df86(%rip), %rsi     # 0x18565e
movl $0x239f, %edx           # imm = 0x239F
callq 0xdab0
movq (%rsp), %rax
testb $0x1, 0x69(%rax)
jne 0x12773a
jmp 0x1276ee
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x127736
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x5df56(%rip), %rsi     # 0x18565e
movl $0x23a2, %edx           # imm = 0x23A2
callq 0xdab0
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
jmp 0x127738
jmp 0x12773a
jmp 0x12773c
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
jmp 0x127762
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x19b70
movq (%rsp), %rax
movb $0x0, 0x68(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $-0x1, 0x20(%rax)
movq (%rsp), %rax
movq $-0x1, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movb $0x1, 0x6d(%rax)
movq (%rsp), %rax
movb $0x1, 0x6e(%rax)
movq (%rsp), %rax
movb $0x0, 0x69(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: initcharacterdistribution
static GtUword *initcharacterdistribution(const GtAlphabet *alpha)
{
  GtUword *characterdistribution;
  unsigned int numofchars, idx;

  numofchars = gt_alphabet_num_of_chars(alpha);
  characterdistribution = gt_malloc(sizeof (*characterdistribution) *
                                    numofchars);
  for (idx=0; idx<numofchars; idx++)
    characterdistribution[idx] = 0;
  return characterdistribution;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x109da0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x5cf96(%rip), %rsi     # 0x18565e
movl $0x1d53, %edx           # imm = 0x1D53
callq 0xd2e0
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x128702
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1286de
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_builder_delete
void gt_encseq_builder_delete(GtEncseqBuilder *eb)
{
  if (!eb) return;
  gt_encseq_builder_reset(eb);
  gt_alphabet_delete(eb->alpha);
  gt_str_delete(eb->destab);
  gt_free(eb);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x12cb8e
jmp 0x12cbc6
movq (%rsp), %rdi
callq 0x127670
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x1098b0
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rdi
leaq 0x58aa2(%rip), %rsi     # 0x18565e
movl $0x252a, %edx           # imm = 0x252A
callq 0xdab0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_effective_filelength
GtUint64 gt_encseq_effective_filelength(const GtEncseq *encseq,
                                        GtUword filenum)
{
  if (encseq->numofdbfiles == 1UL)
    return (GtUint64) encseq->totallength;
  gt_assert(encseq != NULL && encseq->headerptr.filelengthtab != NULL);
  gt_assert(filenum < encseq->numofdbfiles);
  return (GtUint64) encseq->headerptr.filelengthtab[filenum].effectivelength;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x1, 0x50(%rax)
jne 0x12cbfc
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x12ccba
jmp 0x12cbfe
cmpq $0x0, 0x8(%rsp)
je 0x12cc15
movq 0x8(%rsp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0x12cc4d
movq 0x873bc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x31440(%rip), %rsi     # 0x15e066
leaq 0x5bb58(%rip), %rdx     # 0x188785
leaq 0x5bb8b(%rip), %rcx     # 0x1887bf
leaq 0x58a23(%rip), %r8      # 0x18565e
movl $0x2538, %r9d           # imm = 0x2538
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12cc4f
jmp 0x12cc51
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jb 0x12cc98
movq 0x87371(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x313f5(%rip), %rsi     # 0x15e066
leaq 0x5bb66(%rip), %rdx     # 0x1887de
leaq 0x5bb40(%rip), %rcx     # 0x1887bf
leaq 0x589d8(%rip), %r8      # 0x18565e
movl $0x2539, %r9d           # imm = 0x2539
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12cc9a
movq 0x8(%rsp), %rax
movq 0xf0(%rax), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %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/encseq.c
// Function: gt_encseq_filenum
GtUword gt_encseq_filenum(const GtEncseq *encseq,
                                GtUword position)
{
  gt_assert(encseq->numofdbfiles == 1UL || encseq->fsptab != NULL);

  /* handle virtual coordinates */
  if (encseq->hasmirror) {
    if (position > encseq->totallength) {
      /* invert coordinates */
      position = GT_REVERSEPOS(encseq->totallength,
                               position - encseq->totallength - 1);
    }
  }
  gt_assert(position < encseq->totallength);
  return gt_encseq_sep2seqnum(encseq->fsptab,
                              encseq->numofdbfiles,
                              encseq->totallength,
                              position);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x1, 0x50(%rax)
je 0x12cd31
movq 0x10(%rsp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x12cd31
movq 0x872d8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3135c(%rip), %rsi     # 0x15e066
leaq 0x5baec(%rip), %rdx     # 0x1887fd
leaq 0x5bb1b(%rip), %rcx     # 0x188833
leaq 0x5893f(%rip), %r8      # 0x18565e
movl $0x2540, %r9d           # imm = 0x2540
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12cd33
movq 0x10(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x12cd7a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x12cd78
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq 0x30(%rdx), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x12cd7a
jmp 0x12cd7c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x12cdc4
movq 0x87245(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x312c9(%rip), %rsi     # 0x15e066
leaq 0x5dbad(%rip), %rdx     # 0x18a951
leaq 0x5ba88(%rip), %rcx     # 0x188833
leaq 0x588ac(%rip), %r8      # 0x18565e
movl $0x254a, %r9d           # imm = 0x254A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12cdc6
movq 0x10(%rsp), %rax
movq 0x278(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x8(%rsp), %rcx
callq 0x119e90
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_filestartpos
GtUword gt_encseq_filestartpos(const GtEncseq *encseq,
                                     GtUword filenum)
{
  gt_assert(encseq->numofdbfiles == 1UL || encseq->fsptab != NULL);
  if (filenum > 0)
    return encseq->fsptab[filenum-1] + 1;
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x1, 0x50(%rax)
je 0x12ce60
movq 0x8(%rsp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x12ce60
movq 0x871a9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3122d(%rip), %rsi     # 0x15e066
leaq 0x5b9bd(%rip), %rdx     # 0x1887fd
leaq 0x5b9fe(%rip), %rcx     # 0x188845
leaq 0x58810(%rip), %r8      # 0x18565e
movl $0x2554, %r9d           # imm = 0x2554
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12ce62
cmpq $0x0, (%rsp)
jbe 0x12ce8c
movq 0x8(%rsp), %rax
movq 0x278(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x12ce95
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/encseq.c
// Function: gt_encseq_filenum_first_seqnum
GtUword gt_encseq_filenum_first_seqnum(const GtEncseq *encseq,
                                             GtUword filenum)
{
  gt_assert(encseq->numofdbfiles == 1UL || encseq->fsptab != NULL);
  if (filenum > 0)
    return gt_encseq_seqnum(encseq, encseq->fsptab[filenum-1] + 1);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x1, 0x50(%rax)
je 0x12cf00
movq 0x8(%rsp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x12cf00
movq 0x87109(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3118d(%rip), %rsi     # 0x15e066
leaq 0x5b91d(%rip), %rdx     # 0x1887fd
leaq 0x5b975(%rip), %rcx     # 0x18885c
leaq 0x58770(%rip), %r8      # 0x18565e
movl $0x255d, %r9d           # imm = 0x255D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12cf02
cmpq $0x0, (%rsp)
jbe 0x12cf36
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x278(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
addq $0x1, %rsi
callq 0x11a580
movq %rax, 0x10(%rsp)
jmp 0x12cf3f
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_unmirror
void gt_encseq_unmirror(GtEncseq *encseq)
{
  gt_assert(encseq && encseq->hasmirror);
  encseq->hasmirror = false;
  encseq->logicalnumofdbsequences = encseq->numofdbsequences;
  encseq->logicaltotallength = encseq->totallength;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x12d039
movq (%rsp), %rax
testb $0x1, 0x3a8(%rax)
jne 0x12d071
movq 0x86f98(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3101c(%rip), %rsi     # 0x15e066
leaq 0x5b8c8(%rip), %rdx     # 0x188919
leaq 0x5b8dd(%rip), %rcx     # 0x188935
leaq 0x585ff(%rip), %r8      # 0x18565e
movl $0x25a1, %r9d           # imm = 0x25A1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12d073
movq (%rsp), %rax
movb $0x0, 0x3a8(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rax
movq 0x30(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_new
static inline BitPackArray *
bitpackarray_new(unsigned bits, BitOffset numValues, bool withstorealloc)
{
  BitPackArray *newBPA = gt_malloc(sizeof (*newBPA));
  if (newBPA) {
    if (withstorealloc) {
      if (!(newBPA->store = gt_calloc(bitElemsAllocSize(bits*numValues),
                                      sizeof (BitElem)))) {
        gt_free(newBPA);
        return NULL;
      }
    } else {
      newBPA->store = NULL;
    }
    newBPA->bitsPerElem = bits;
    newBPA->numElems = numValues;
  }
  return newBPA;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movl $0x18, %edi
leaq 0x5af49(%rip), %rsi     # 0x1889fa
movl $0x48, %edx
callq 0xd2e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x12db4d
testb $0x1, 0xf(%rsp)
je 0x12db2a
movl 0x1c(%rsp), %eax
movl %eax, %edi
imulq 0x10(%rsp), %rdi
callq 0x12ddd0
movq %rax, %rdi
movl $0x1, %esi
leaq 0x5af09(%rip), %rdx     # 0x1889fa
movl $0x4c, %ecx
callq 0xd5b0
movq (%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x12db28
movq (%rsp), %rdi
leaq 0x5aee7(%rip), %rsi     # 0x1889fa
movl $0x4d, %edx
callq 0xdab0
movq $0x0, 0x20(%rsp)
jmp 0x12db56
jmp 0x12db35
movq (%rsp), %rax
movq $0x0, (%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_viautables_specialrangeiterator_next_withkind
static bool gt_viautables_specialrangeiterator_next_withkind(
                                                    GtRange *range,
                                                    GtEncseqReader *esr,
                                                    KindofSWtable kindsw)
{
  GtEncseqReaderViatablesinfo *swstate = assignSWstate(esr, kindsw);

  gt_assert(esr->encseq->accesstype_via_utables);
  if (swstate->exhausted)
    return false;
  gt_assert(swstate->hasprevious);
  *range = swstate->previousrange;
  if (swstate->hasmore)
    advancerangeGtEncseqReader(esr, kindsw);
  else
    swstate->exhausted = true;
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x130e70
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x3a9(%rax)
jne 0x130dbd
movq 0x8324c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2d2d0(%rip), %rsi     # 0x15e066
leaq 0x583f7(%rip), %rdx     # 0x189194
leaq 0x58414(%rip), %rcx     # 0x1891b8
leaq 0x548b3(%rip), %r8      # 0x18565e
movl $0xdf8, %r9d            # imm = 0xDF8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x130dbf
movq (%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0x130dd3
movb $0x0, 0x27(%rsp)
jmp 0x130e58
jmp 0x130dd5
movq (%rsp), %rax
testb $0x1, 0x3a(%rax)
jne 0x130e17
movq 0x831f2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2d276(%rip), %rsi     # 0x15e066
leaq 0x583f2(%rip), %rdx     # 0x1891e9
leaq 0x583ba(%rip), %rcx     # 0x1891b8
leaq 0x54859(%rip), %r8      # 0x18565e
movl $0xdfb, %r9d            # imm = 0xDFB
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x130e19
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, (%rax)
movq 0x20(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
testb $0x1, 0x39(%rax)
je 0x130e4b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x115520
jmp 0x130e53
movq (%rsp), %rax
movb $0x1, 0x3c(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_addmarkpos
static void gt_addmarkpos(GtArrayGtUword *asp,
                          GtEncseqReader *esr,
                          const GtRange *seqrange)
{
  GtUword pos;
  GtUchar currentchar;

  for (pos=seqrange->start; pos<seqrange->end; pos++) {
    currentchar = gt_encseq_reader_next_encoded_char(esr);
    gt_assert(GT_ISSPECIAL(currentchar));
    if (currentchar == (GtUchar) GT_SEPARATOR) {
      gt_assert(asp->nextfreeGtUword < asp->allocatedGtUword);
      asp->spaceGtUword[asp->nextfreeGtUword++] = pos;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1318de
movq 0x18(%rsp), %rdi
callq 0x115010
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jge 0x131846
movq 0x827c3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2c847(%rip), %rsi     # 0x15e066
leaq 0x57b49(%rip), %rdx     # 0x18936f
leaq 0x57b5c(%rip), %rcx     # 0x189389
leaq 0x53e2a(%rip), %r8      # 0x18565e
movl $0xefb, %r9d            # imm = 0xEFB
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x131848
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
jne 0x1318c9
jmp 0x131856
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1318a2
movq 0x82767(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2c7eb(%rip), %rsi     # 0x15e066
leaq 0x57b15(%rip), %rdx     # 0x189397
leaq 0x57b00(%rip), %rcx     # 0x189389
leaq 0x53dce(%rip), %r8      # 0x18565e
movl $0xefd, %r9d            # imm = 0xEFD
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1318a4
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x1318cb
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1317e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: ssptaboutinfo_setendidx
static void ssptaboutinfo_setendidx(Gtssptaboutinfo *ssptaboutinfo)
{
  switch (ssptaboutinfo->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      ssptaboutinfo->ssptabptr->st_uchar.endidxinpage[
                                            ssptaboutinfo->pagenumber++]
        = ssptaboutinfo->fillpos;
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      ssptaboutinfo->ssptabptr->st_uint16.endidxinpage[
                                             ssptaboutinfo->pagenumber++]
        = ssptaboutinfo->fillpos;
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      ssptaboutinfo->ssptabptr->st_uint32.endidxinpage[
                                             ssptaboutinfo->pagenumber++]
        = ssptaboutinfo->fillpos;
      break;
    default:
      fprintf(stderr, "ssptaboutinfo_setendidx(sat = %d is undefined)\n",
                     (int) ssptaboutinfo->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x4, %eax
je 0x131985
jmp 0x13196c
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x1319b7
jmp 0x131977
movl 0xc(%rsp), %eax
subl $0x6, %eax
je 0x1319e6
jmp 0x131a15
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x131a3f
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x131a3f
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x131a3f
movq 0x825bc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x57b17(%rip), %rsi     # 0x189545
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: assignssptabmapspecification
static void assignssptabmapspecification(GtMapspec *mapspec,
                                         void *voidinfo,
                                         GT_UNUSED bool writemode)
{
  Gtssptransferinfo *ssptransferinfo = (Gtssptransferinfo *) voidinfo;

  addswtabletomapspectable(mapspec,
                           ssptransferinfo->ssptabptr,
                           false,
                           false,
                           ssptransferinfo->totallength,
                           ssptransferinfo->satsep);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %r8
movq 0x8(%rsp), %rax
movl 0x10(%rax), %r9d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x12db60
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdgetnexttwobitencodingstopposViaequallength
static GtUword fwdgetnexttwobitencodingstopposViaequallength(
                                                     const GtEncseq *encseq,
                                                     GtUword pos)
{
  if (!issinglepositioninspecialrangeViaequallength(encseq, pos)) {
    GtUword seqnum = gt_encseq_seqnum_Viaequallength(encseq, pos);

    return seqnum * (encseq->equallength.valueunsignedlong + 1) +
                     encseq->equallength.valueunsignedlong;
  }
  return pos;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1144a0
testb $0x1, %al
jne 0x131b01
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11a690
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x1f0(%rcx), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq 0x18(%rsp), %rcx
addq 0x1f0(%rcx), %rax
movq %rax, 0x20(%rsp)
jmp 0x131b0b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdgetnexttwobitencodingstopposSW
static GtUword fwdgetnexttwobitencodingstopposSW(GtEncseqReader *esr,
                                      KindofSWtable kindsw)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    GtEncseqAccessType sat = (kindsw == SWtable_ssptab)
                                ? esr->encseq->satsep
                                : esr->encseq->sat;
    switch (sat) {
      case GT_ACCESS_TYPE_UCHARTABLES:
        return fwdgetnexttwobitencodingstopposSW_uchar(esr, kindsw);
      case GT_ACCESS_TYPE_USHORTTABLES:
        return fwdgetnexttwobitencodingstopposSW_uint16(esr, kindsw);
      case GT_ACCESS_TYPE_UINT32TABLES:
        return fwdgetnexttwobitencodingstopposSW_uint32(esr, kindsw);
      default:
       fprintf(stderr, "%s(%d) undefined\n", __func__, (int) sat);
       exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
  else
   return esr->encseq->totallength;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x119540
testb $0x1, %al
jne 0x131b43
jmp 0x131c02
cmpl $0x1, 0x14(%rsp)
jne 0x131b5b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x131b69
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x4, %eax
je 0x131b96
jmp 0x131b80
movl 0x8(%rsp), %eax
subl $0x5, %eax
je 0x131bab
jmp 0x131b8b
movl 0x8(%rsp), %eax
subl $0x6, %eax
je 0x131bc0
jmp 0x131bd5
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x131c20
movq %rax, 0x20(%rsp)
jmp 0x131c13
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x131d70
movq %rax, 0x20(%rsp)
jmp 0x131c13
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x131ec0
movq %rax, 0x20(%rsp)
jmp 0x131c13
movq 0x823fc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movl 0x10(%rsp), %ecx
leaq 0x54439(%rip), %rsi     # 0x186023
leaq 0x579c3(%rip), %rdx     # 0x1895b4
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: revgetnexttwobitencodingstopposViaequallength
static GtUword revgetnexttwobitencodingstopposViaequallength(
                                                     const GtEncseq *encseq,
                                                     GtUword pos)
{
  if (!issinglepositioninspecialrangeViaequallength(encseq, pos)) {
    GtUword seqnum = gt_encseq_seqnum_Viaequallength(encseq, pos);

    return seqnum * (encseq->equallength.valueunsignedlong + 1);
  }
  return pos+1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1144a0
testb $0x1, %al
jne 0x132065
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11a690
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x1f0(%rcx), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x132073
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: revgetnexttwobitencodingstopposSW
static GtUword revgetnexttwobitencodingstopposSW(GtEncseqReader *esr,
                                      KindofSWtable kindsw)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    GtEncseqAccessType sat = (kindsw == SWtable_ssptab)
                                ? esr->encseq->satsep
                                : esr->encseq->sat;
    switch (sat) {
      case GT_ACCESS_TYPE_UCHARTABLES:
        return revgetnexttwobitencodingstopposSW_uchar(esr, kindsw);
      case GT_ACCESS_TYPE_USHORTTABLES:
        return revgetnexttwobitencodingstopposSW_uint16(esr, kindsw);
      case GT_ACCESS_TYPE_UINT32TABLES:
        return revgetnexttwobitencodingstopposSW_uint32(esr, kindsw);
      default:
       fprintf(stderr, "%s(%d) undefined\n", __func__, (int) sat);
       exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
  else {
    return 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x119540
testb $0x1, %al
jne 0x1320a3
jmp 0x132162
cmpl $0x1, 0x14(%rsp)
jne 0x1320bb
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x1320c9
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x4, %eax
je 0x1320f6
jmp 0x1320e0
movl 0x8(%rsp), %eax
subl $0x5, %eax
je 0x13210b
jmp 0x1320eb
movl 0x8(%rsp), %eax
subl $0x6, %eax
je 0x132120
jmp 0x132135
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x132180
movq %rax, 0x20(%rsp)
jmp 0x13216b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1322d0
movq %rax, 0x20(%rsp)
jmp 0x13216b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x132420
movq %rax, 0x20(%rsp)
jmp 0x13216b
movq 0x81e9c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movl 0x10(%rsp), %ecx
leaq 0x53ed9(%rip), %rsi     # 0x186023
leaq 0x57542(%rip), %rdx     # 0x189693
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/intbits.h
// Function: gt_intbits_reverse_unitwise
static inline GtBitsequence gt_intbits_reverse_unitwise(GtBitsequence bs)
{
#if defined (_LP64) || defined (_WIN64)
  /* 10 shifts, 10 &, 5 |, 4 assignments = 29 ops */
  bs = (bs & 0xFFFFFFFF00000000) >> 32 | (bs & 0x00000000FFFFFFFF) << 32;
  bs = (bs & 0xFFFF0000FFFF0000) >> 16 | (bs & 0x0000FFFF0000FFFF) << 16;
  bs = (bs & 0xFF00FF00FF00FF00) >> 8 |  (bs & 0x00FF00FF00FF00FF) << 8;
  bs = (bs & 0XF0F0F0F0F0F0F0F0) >> 4 |  (bs & 0x0F0F0F0F0F0F0F0F) << 4;
  return (bs & 0xCCCCCCCCCCCCCCCC) >> 2 |  (bs & 0x3333333333333333) << 2;
#else
  /* 8 shifts, 8 &, 4 |, 3 assignments = 23 ops */
  bs = (bs & 0xFFFF0000) >> 16 | (bs & 0x0000FFFF) << 16;
  bs = (bs & 0xFF00FF00) >> 8 |  (bs & 0x00FF00FF) << 8;
  bs = (bs & 0XF0F0F0F0) >> 4 |  (bs & 0x0F0F0F0F) << 4;
  return (bs & 0xCCCCCCCC) >> 2 |  (bs & 0x33333333) << 2;
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq -0x8(%rsp), %rax
shrq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x8(%rsp), %rcx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $-0xffff00010000, %rax  # imm = 0xFFFF0000FFFF0000
andq -0x8(%rsp), %rax
shrq $0x10, %rax
movabsq $0xffff0000ffff, %rcx   # imm = 0xFFFF0000FFFF
andq -0x8(%rsp), %rcx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $-0xff00ff00ff0100, %rax # imm = 0xFF00FF00FF00FF00
andq -0x8(%rsp), %rax
shrq $0x8, %rax
movabsq $0xff00ff00ff00ff, %rcx # imm = 0xFF00FF00FF00FF
andq -0x8(%rsp), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $-0xf0f0f0f0f0f0f10, %rax # imm = 0xF0F0F0F0F0F0F0F0
andq -0x8(%rsp), %rax
shrq $0x4, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq -0x8(%rsp), %rcx
shlq $0x4, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $-0x3333333333333334, %rax # imm = 0xCCCCCCCCCCCCCCCC
andq -0x8(%rsp), %rax
shrq $0x2, %rax
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
andq -0x8(%rsp), %rcx
shlq $0x2, %rcx
orq %rcx, %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: calctbeforward
static inline GtTwobitencoding calctbeforward(const GtTwobitencoding *tbe,
                                              GtUword startpos)
{
  GtUword remain = GT_MODBYUNITSIN2BITENC(startpos);

  if (remain > 0) {
    GtUword unit = GT_DIVBYUNITSIN2BITENC(startpos);
    return (GtTwobitencoding)
           ((tbe[unit] << GT_MULT2(remain)) |
            (tbe[unit+1] >> GT_MULT2(GT_UNITSIN2BITENC - remain)));
  }
  return tbe[GT_DIVBYUNITSIN2BITENC(startpos)];
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x1f, %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jbe 0x132a33
movq -0x18(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
shlq %rcx
shlq %cl, %rax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movl $0x20, %ecx
subq -0x20(%rsp), %rcx
shlq %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x132a4a
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shrq $0x5, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdextractspecialbits
static inline GtBitsequence fwdextractspecialbits(
                                               const GtBitsequence *specialbits,
                                               GtUword startpos)
{
  GtUword remain, unit;

  remain = GT_MODWORDSIZE(startpos);
  unit = GT_DIVWORDSIZE(startpos);
  if (remain <= (GtUword) GT_DIV2(GT_INTWORDSIZE))
    return (GtBitsequence) ((specialbits[unit] << remain) & GT_FIRSTHALVEBITS);
  else {
    return (GtBitsequence) (((specialbits[unit] << remain) |
                           (specialbits[unit+1] >> (GT_INTWORDSIZE - remain))) &
                           GT_FIRSTHALVEBITS);
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x3f, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
shrq $0x6, %rax
movq %rax, -0x28(%rsp)
cmpq $0x20, -0x20(%rsp)
ja 0x132aa8
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
shlq %cl, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x132af2
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
shlq %cl, %rax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movl $0x40, %ecx
subq -0x20(%rsp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)