LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: gt_diagonalbandalign_affinegapcost_compute_generic
void gt_diagonalbandalign_affinegapcost_compute_generic(GtLinspaceManagement
                                                        *spacemanager,
                                                        const GtScoreHandler
                                                        *scorehandler,
                                                        GtAlignment *align,
                                                        const GtUchar *useq,
                                                        GtUword ustart,
                                                        GtUword ulen,
                                                        const GtUchar *vseq,
                                                        GtUword vstart,
                                                        GtUword vlen,
                                                        GtWord left_dist,
                                                        GtWord right_dist)
{
  gt_assert(useq  && vseq && spacemanager && scorehandler && align);

  /* set new bounds, if left_dist or right_dist is out of sequence */
  left_dist = GT_MAX(-(GtWord) ulen,left_dist);
  right_dist = GT_MIN((GtWord) vlen,right_dist);
  gt_alignment_set_seqs(align, useq+ustart, ulen, vseq+vstart, vlen);
  gt_calc_diagonalbandaffinealign(spacemanager, scorehandler, align,
                                             useq, ustart, ulen,
                                             vseq, vstart, vlen,
                                             left_dist, right_dist);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq 0x50(%rsp), %rcx
movq %rcx, %xmm0
movq %r15, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rsi, 0x10(%rsp)
movq %rsi, %xmm0
movq %rdi, 0x8(%rsp)
movq %rdi, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x13b301
movq %rdx, %r12
testq %rdx, %rdx
je 0x13b301
movq %r9, %rbp
movq 0x70(%rsp), %r13
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r9, %rbx
negq %rbx
cmpq %rax, %rbx
cmovleq %rax, %rbx
cmpq %r13, %rsi
cmovlq %rsi, %r13
movq %rsi, %rax
leaq (%r15,%r8), %rsi
addq %rdx, %rcx
movq %r12, %rdi
movq %r9, %rdx
movq %r8, %r14
movq %rax, %r8
callq 0x126bf9
subq $0x8, %rsp
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbp, %r9
pushq %r13
pushq %rbx
pushq 0x78(%rsp)
pushq 0x78(%rsp)
pushq 0x78(%rsp)
callq 0x13b306
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3ff44
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: gt_diagonalbandalign_affinegapcost_compute
void gt_diagonalbandalign_affinegapcost_compute(GtLinspaceManagement
                                                *spacemanager,
                                                GtAlignment *align,
                                                const GtUchar *useq,
                                                GtUword ustart, GtUword ulen,
                                                const GtUchar *vseq,
                                                GtUword vstart, GtUword vlen,
                                                GtWord left_dist,
                                                GtWord right_dist,
                                                GtUword matchcost,
                                                GtUword mismatchcost,
                                                GtUword gap_opening,
                                                GtUword gap_extension)
{
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,
                                                     mismatchcost,
                                                     gap_opening,
                                                     gap_extension);

  gt_diagonalbandalign_affinegapcost_compute_generic(spacemanager, scorehandler,
                                                     align, useq, ustart, ulen,
                                                     vseq, vstart, vlen,
                                                     left_dist, right_dist);

  gt_scorehandler_delete(scorehandler);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movaps 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movaps 0xa0(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
callq 0x179740
movq %rax, %r14
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x28(%rsp), %r9
callq 0x13b210
movq %r14, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1797c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dot_visitor.c
// Function: dv_feature_node
static int dv_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                            GtError *err)
{
  GT_UNUSED GtDotVisitor *dv;
  int had_err = 0;
  GtUword pid;
  gt_error_check(err);
  dv = dv_cast(nv);

  if (!(pid = (GtUword) gt_hashmap_get(dv->ids, fn))) {
    pid = dv->idctr++;
    printf("subgraph "GT_WU" {\n", pid);
    gt_hashmap_add(dv->ids, fn, (void*) pid);
  }
  had_err = gt_feature_node_traverse_children(fn, dv,
                                              dv_output_edge,
                                              true, err);
  printf("}\n");
  gt_assert(!had_err);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x13d8cc
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x13d95c
callq 0x13d838
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x105a11
testq %rax, %rax
jne 0x13d91d
movq 0x18(%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x18(%r15)
leaq 0x246d5f(%rip), %rdi    # 0x384663
movq %r12, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x105a4c
leaq 0x9e(%rip), %rdx        # 0x13d9c2
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x149fca
movl %eax, %ebx
leaq 0x2929e5(%rip), %rdi    # 0x3d0325
callq 0x17bd0
testl %ebx, %ebx
jne 0x13d957
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x40536
callq 0x404ff
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dot_visitor.c
// Function: gt_dot_visitor_new
GtNodeVisitor* gt_dot_visitor_new()
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_dot_visitor_class());
  GtDotVisitor *dv = dv_cast(nv);

  dv->ids = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
  dv->idctr = 1;
  printf("\ndigraph nodes {\n");

  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x13d838
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x13d838
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x105830
movq %rax, 0x10(%r14)
movq $0x1, 0x18(%r14)
leaq 0x246cfc(%rip), %rdi    # 0x3846ae
callq 0x17bd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dot_visitor.c
// Function: dv_output_edge
static int dv_output_edge(GtFeatureNode *fn, void *data,
                          GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *curnode = NULL;
  GtUword pid, cid;
  int had_err = 0;
  GtDotVisitor *dv = (GtDotVisitor*) data;

  if (!(pid = (GtUword) gt_hashmap_get(dv->ids, fn))) {
    pid = dv->idctr++;
    gt_hashmap_add(dv->ids, fn, (void*) pid);
  }
  printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             pid, pid, gt_feature_node_get_type(fn), fn);

  fni = gt_feature_node_iterator_new_direct(fn);
  while ((curnode = gt_feature_node_iterator_next(fni))) {
    if (!(cid = (GtUword) gt_hashmap_get(dv->ids, curnode))) {
      cid = dv->idctr++;
      gt_hashmap_add(dv->ids, curnode, (void*) cid);
    }
    printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             cid, cid, gt_feature_node_get_type(curnode), curnode);
    printf(""GT_WU" -> "GT_WU"\n", pid, cid);
  }
  gt_feature_node_iterator_delete(fni);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
movq %r15, %rsi
callq 0x105a11
movq %rax, %r14
testq %rax, %rax
jne 0x13da02
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x105a4c
movq %r15, %rdi
callq 0x149bb2
leaq 0x246c62(%rip), %rdi    # 0x384673
movq %r14, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x17070
movq %r15, %rdi
callq 0x14b295
movq %rax, %r15
movq %rax, %rdi
callq 0x14b33e
testq %rax, %rax
je 0x13dab8
movq %rax, %rbp
leaq 0x246c5c(%rip), %r13    # 0x3846a2
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x105a11
movq %rax, %r12
testq %rax, %rax
jne 0x13da76
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x18(%rbx)
movq %rbp, %rsi
movq %r12, %rdx
callq 0x105a4c
movq %rbp, %rdi
callq 0x149bb2
leaq 0x246bee(%rip), %rdi    # 0x384673
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x17070
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x17070
movq %r15, %rdi
callq 0x14b33e
movq %rax, %rbp
testq %rax, %rax
jne 0x13da46
movq %r15, %rdi
callq 0x14b3d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dup_feature_stream.c
// Function: gt_dup_feature_stream_new
GtNodeStream* gt_dup_feature_stream_new(GtNodeStream *in_stream,
                                        const char *dest_type,
                                        const char *source_type)
{
  GtNodeVisitor *nv;
  gt_assert(in_stream);
  nv = gt_dup_feature_visitor_new(dest_type, source_type);
  return gt_visitor_stream_new(in_stream, nv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x13daf4
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x13dd8c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x18c917
callq 0x4056d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: gt_dup_feature_visitor_class
const GtNodeVisitorClass* gt_dup_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtDupFeatureVisitor),
                                    dup_feature_visitor_free,
                                    NULL,
                                    dup_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x38bbfe(%rip)    # 0x4c9708
jne 0x13db3b
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x13db49
leaq 0x71(%rip), %rcx        # 0x13db93
movl $0x20, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x38bbcd(%rip)    # 0x4c9708
callq 0xe6a19
movq 0x38bbc1(%rip), %rax    # 0x4c9708
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: dup_feature_visitor_feature_node
static int dup_feature_visitor_feature_node(GtNodeVisitor *nv,
                                            GtFeatureNode *fn,
                                            GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni, *child_iterator;
  GtFeatureNode *node, *child;
  GtDupFeatureVisitor *v;
  gt_error_check(err);
  v = gt_dup_feature_visitor_cast(nv);
  fni = gt_feature_node_iterator_new(fn);
  while ((node = gt_feature_node_iterator_next(fni))) {
    child_iterator = gt_feature_node_iterator_new_direct(node);
    while ((child = gt_feature_node_iterator_next(child_iterator))) {
      if (gt_feature_node_has_type(child, v->source_type))
        gt_feature_node_add_child(node, duplicate_feature(child,v->dest_type));
    }
    gt_feature_node_iterator_delete(child_iterator);
  }
  gt_feature_node_iterator_delete(fni);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x13dbbc
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x13dd87
callq 0x13dafc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq %r14, %rdi
callq 0x14b1a8
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x14b33e
testq %rax, %rax
je 0x13dd6d
movq %rax, %r14
movq %r14, %rdi
callq 0x14b295
movq %rax, %r15
movq %rax, %rdi
callq 0x14b33e
testq %rax, %rax
je 0x13dd50
movq %rax, %r13
movq %r14, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq 0x18(%rbx), %rsi
movq %r13, %rdi
callq 0x149d45
testb %al, %al
je 0x13dd3c
movq 0x10(%rbx), %r14
movq %r13, %rdi
callq 0x14b89b
movq %rax, %r15
movq %r13, %rdi
callq 0x14b8da
movq %rax, %rbp
movq %r13, %rdi
callq 0x14b8fd
movq %rax, %r12
movq %r13, %rdi
callq 0x14970e
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movl %eax, %r8d
callq 0x14952c
movq %rax, %rbp
movq %r13, %rdi
callq 0x149bc2
testb %al, %al
je 0x13dca2
movq %r13, %rdi
callq 0x149ce1
movq %rax, %rdi
callq 0x120955
movq %rax, %r14
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1491f1
movq %r14, %rdi
callq 0x121b03
movq %r13, %rdi
callq 0x149bf5
testb %al, %al
je 0x13dcbe
movq %r13, %rdi
callq 0x149ef0
movq %rbp, %rdi
callq 0x149c09
movq %r13, %rdi
callq 0x149f67
movq %rbp, %rdi
movl %eax, %esi
callq 0x149254
movq %r13, %rdi
callq 0x14919c
movq %rax, %r14
movq %rax, %rdi
callq 0x121e78
testq %rax, %rax
je 0x13dd22
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x121cfa
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x14918c
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x14a4d2
incq %r15
movq %r14, %rdi
callq 0x121e78
cmpq %rax, %r15
jb 0x13dceb
movq %r14, %rdi
callq 0x121e8b
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x149997
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x14b33e
movq %rax, %r13
testq %rax, %rax
jne 0x13dc18
movq %r15, %rdi
callq 0x14b3d0
movq (%rsp), %rdi
callq 0x14b33e
movq %rax, %r14
testq %rax, %rax
jne 0x13dbef
movq (%rsp), %rdi
callq 0x14b3d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x405a4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: gt_dup_feature_visitor_new
GtNodeVisitor* gt_dup_feature_visitor_new(const char *dest_type,
                                          const char *source_type)
{
  GtDupFeatureVisitor *aiv;
  GtNodeVisitor *nv;
  gt_assert(dest_type && source_type);
  nv = gt_node_visitor_create(gt_dup_feature_visitor_class());
  aiv = gt_dup_feature_visitor_cast(nv);
  aiv->dest_type = gt_cstr_dup(dest_type);
  aiv->source_type = gt_cstr_dup(source_type);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13ddf0
movq %rsi, %rbx
testq %rsi, %rsi
je 0x13ddf0
movq %rdi, %r14
callq 0x13dafc
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r15
callq 0x13dafc
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r12
movq %r14, %rdi
callq 0xe8760
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xe8760
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x405db
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_new
GtEditscript *gt_editscript_new(GtAlphabet *alphabet)
{
  uint32_t alphabet_size;
  GtEditscript *es;
  es = gt_calloc((size_t) 1, sizeof (*es));
  alphabet_size = gt_alphabet_size(alphabet);
  es->entry_size =
    gt_determinebitspervalue((GtUword) alphabet_size + 3);
  gt_assert(es->entry_size <= (uint8_t) (sizeof (uint8_t) * CHAR_BIT));
  es->size = 0U;
  es->space = NULL;
  es->del = (uint8_t) alphabet_size;
  es->num_elems = 0;
  return es;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x246a82(%rip), %rdx    # 0x384888
movl $0x1, %edi
movl $0x18, %esi
movl $0x52, %ecx
callq 0x1093ef
movq %rax, %rbx
movq %r14, %rdi
callq 0xd3724
movl %eax, %ebp
movl %eax, %edi
addq $0x3, %rdi
callq 0x10af48
movb %al, 0x15(%rbx)
movzbl %al, %eax
cmpl $0x9, %eax
jae 0x13de4f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x40612
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_reset
void gt_editscript_reset(GtEditscript *editscript)
{
  gt_assert(editscript);
  if (editscript->space != NULL) {
    editscript->space[0] = 0;
  }
  editscript->num_elems = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x13deab
movq (%rdi), %rax
testq %rax, %rax
je 0x13dea3
movq $0x0, (%rax)
movl $0x0, 0xc(%rdi)
retq
pushq %rax
callq 0x40649
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_reset
void gt_editscript_builder_reset(GtEditscriptBuilder *es_builder,
                                 GtEditscript *editscript)
{
  gt_assert(es_builder);
  gt_assert(editscript);
  gt_editscript_reset(editscript);
  editscript_pos_reset(&es_builder->fillpos);
  es_builder->es = editscript;
  es_builder->last_op = 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13e082
testq %rsi, %rsi
je 0x13e087
movq (%rsi), %rax
testq %rax, %rax
je 0x13e064
movq $0x0, (%rax)
movl $0x0, 0xc(%rsi)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x8(%rdi)
movq %rsi, (%rdi)
movb $0x0, 0x10(%rdi)
popq %rax
retq
callq 0x406f4
callq 0x406bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_add_match
void gt_editscript_builder_add_match(GtEditscriptBuilder *es_builder)
{
  gt_assert(es_builder);
  es_builder->last_op = 0;
  es_builder->es->trailing_matches++;
  gt_assert(es_builder->es->trailing_matches != 0 &&
            "trailing matches overflow");
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13e0a0
movb $0x0, 0x10(%rdi)
movq (%rdi), %rax
incl 0x10(%rax)
je 0x13e0a5
popq %rax
retq
callq 0x40766
callq 0x4072d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_add_mismatch
void gt_editscript_builder_add_mismatch(GtEditscriptBuilder *es_builder,
                                        GtUchar c)
{
  GtEditscript *es;
  gt_assert(es_builder != NULL);
  es = es_builder->es;
  gt_assert(c <= (GtUchar) es->del || c == (GtUchar) GT_WILDCARD);
  if (c == (GtUchar) GT_WILDCARD) {
    c = (GtUchar) es->del - 1;
  }
  if (es_builder->last_op != (uint8_t) GT_EDITSCRIPT_MISDEL_SYM(es)) {
    gt_editscript_builder_start_group(es_builder,
                                      (uint8_t) GT_EDITSCRIPT_MISDEL_SYM(es));
  }
  editscript_space_add_next(es, &es_builder->fillpos, (GtBitsequence) c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13e20c
movq %rdi, %rbx
movq (%rdi), %r14
movb 0x14(%r14), %al
cmpb %sil, %al
setae %cl
cmpb $-0x2, %sil
sete %dl
orb %cl, %dl
je 0x13e211
leal -0x1(%rax), %ecx
cmpb $-0x2, %sil
movzbl %sil, %edx
movzbl %cl, %ebp
cmovnel %edx, %ebp
incb %al
cmpb %al, 0x10(%rbx)
je 0x13e100
movzbl %al, %esi
movq %rbx, %rdi
callq 0x13fb1e
movzbl %bpl, %r15d
movl 0x8(%rbx), %r12d
movl 0xc(%rbx), %r13d
movzbl 0x15(%r14), %ebp
cmpl $0x0, 0x8(%r14)
jne 0x13e14a
movl $0x40, %eax
xorl %edx, %edx
divl %ebp
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
leal 0x8(,%rax,8), %edi
leaq 0x246752(%rip), %rsi    # 0x384888
movl $0x6f, %edx
callq 0x1092b2
movq %rax, (%r14)
movq $0x0, (%rax)
incl 0xc(%r14)
movl %r13d, %eax
subl %ebp, %eax
jbe 0x13e166
movl %eax, %ecx
shlq %cl, %r15
movq (%r14), %rcx
orq %r15, (%rcx,%r12,8)
jmp 0x13e1f6
movl %r13d, 0x4(%rsp)
movl %r12d, %r13d
incl %r13d
movl 0x8(%r14), %ecx
cmpl %ecx, %r13d
jb 0x13e1bd
movb $0x40, %al
movzbl %al, %eax
divb 0x15(%r14)
movzbl %al, %eax
addl %ecx, %eax
incl %eax
cvtsi2sd %rax, %xmm0
mulsd 0x212b81(%rip), %xmm0   # 0x350d18
cvttsd2si %xmm0, %rax
movl %eax, 0x8(%r14)
movq (%r14), %rdi
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x2466d8(%rip), %rdx    # 0x384888
movl $0x7b, %ecx
callq 0x1094e6
movq %rax, (%r14)
movl %ebp, %ecx
movl 0x4(%rsp), %edi
subl %edi, %ecx
movq %r15, %rax
shrq %cl, %rax
movq (%r14), %rdx
orq %rax, (%rdx,%r12,8)
movl %r13d, %esi
movq $0x0, (%rdx,%rsi,8)
movl $0x40, %eax
subl %edi, %ebp
je 0x13e1f3
subl %ebp, %eax
negl %ebp
movl %ebp, %ecx
shlq %cl, %r15
movq %r15, (%rdx,%rsi,8)
movl %r13d, %r12d
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x407d8
callq 0x4079f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: editscript_space_get_length
static inline GtBitsequence editscript_space_get_next(const GtEditscript *es,
                                                      GtEditscriptPos *pos)
{
  GtBitsequence elem = 0;
  uint32_t shift;

  if (pos->bitsleft == 0) {
    pos->cur_word++;
    pos->bitsleft = (uint32_t) GT_INTWORDSIZE;
  }
  shift = pos->bitsleft;

  elem = es->space[pos->cur_word] << (GT_INTWORDSIZE - shift);
  if (shift < es->entry_size) {
    pos->cur_word++;
    elem |= es->space[pos->cur_word] >> (GtBitsequence) shift;
    pos->bitsleft = (uint32_t) (GT_INTWORDSIZE - (es->entry_size - shift));
  }
  else {
    pos->bitsleft -= es->entry_size;
  }
  elem >>= GT_INTWORDSIZE - es->entry_size;
  return elem;
}

// Assembly:
cmpl $0x0, 0x4(%rsi)
jne 0x13e5b0
incl (%rsi)
movl $0x40, 0x4(%rsi)
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rsi), %r8d
movl 0x4(%rsi), %eax
movq (%rdi), %r10
movq (%r10,%r8,8), %r14
movl %eax, %ecx
negb %cl
shlq %cl, %r14
movzbl 0x15(%rdi), %r11d
cmpl %r11d, %eax
jae 0x13e5ec
incl %r8d
movl %r8d, (%rsi)
movq (%r10,%r8,8), %rdi
movl %eax, %ecx
shrq %cl, %rdi
orq %rdi, %r14
addl $0x40, %eax
subl %r11d, %eax
movl %r11d, %ecx
negl %ecx
shrq %cl, %r14
movl %eax, 0x4(%rsi)
incl (%rdx)
leal -0x1(%r11), %ecx
movl $0x1, %r15d
shlq %cl, %r15
movzbl %cl, %eax
btq %rax, %r14
jae 0x13e752
movl %r11d, %r8d
movl $0x40, %edi
movq $-0x1, %r9
movl %r8d, %ecx
shlq %cl, %r9
subl %r11d, %edi
movq %r14, %rax
xorq %r9, %rax
xorl %ebx, %ebx
cmpq $-0x1, %rax
jne 0x13e68e
cmpl $0x0, 0x4(%rsi)
jne 0x13e64b
incl (%rsi)
movl $0x40, 0x4(%rsi)
movl (%rsi), %r12d
movl 0x4(%rsi), %eax
movq (%r10,%r12,8), %r14
movl %eax, %ecx
negb %cl
shlq %cl, %r14
cmpl %r11d, %eax
jae 0x13e676
incl %r12d
movl %r12d, (%rsi)
movq (%r10,%r12,8), %r12
movl %eax, %ecx
shrq %cl, %r12
orq %r12, %r14
addl $0x40, %eax
subl %r11d, %eax
movl %edi, %ecx
shrq %cl, %r14
movl %eax, 0x4(%rsi)
incl (%rdx)
addq %r8, %rbx
movq %r14, %rax
xorq %r9, %rax
jmp 0x13e636
xorl %eax, %eax
testq %r15, %r14
je 0x13e74b
cmpl $0x0, 0x4(%rsi)
jne 0x13e6a8
incl (%rsi)
movl $0x40, 0x4(%rsi)
movl (%rsi), %r13d
movl 0x4(%rsi), %r9d
movq (%r10,%r13,8), %r12
movl %r9d, %ecx
negb %cl
shlq %cl, %r12
cmpl %r11d, %r9d
jae 0x13e6d7
incl %r13d
movl %r13d, (%rsi)
movq (%r10,%r13,8), %r13
movl %r9d, %ecx
shrq %cl, %r13
orq %r13, %r12
addl $0x40, %r9d
subl %r11d, %r9d
movl %edi, %ecx
shrq %cl, %r12
movl %r9d, 0x4(%rsi)
incl (%rdx)
movl %r8d, %ecx
shlq %cl, %rax
addq %r14, %r14
orq %r12, %rax
jmp 0x13e690
cmpl $0x0, 0x4(%rsi)
jne 0x13e702
incl (%rsi)
movl $0x40, 0x4(%rsi)
movl (%rsi), %r15d
movl 0x4(%rsi), %r9d
movq (%r10,%r15,8), %r14
movl %r9d, %ecx
negb %cl
shlq %cl, %r14
cmpl %r11d, %r9d
jae 0x13e731
incl %r15d
movl %r15d, (%rsi)
movq (%r10,%r15,8), %r15
movl %r9d, %ecx
shrq %cl, %r15
orq %r15, %r14
addl $0x40, %r9d
subl %r11d, %r9d
movl %edi, %ecx
shrq %cl, %r14
movl %r9d, 0x4(%rsi)
incl (%rdx)
movl %r8d, %ecx
shlq %cl, %rax
decq %rbx
orq %r14, %rax
testq %rbx, %rbx
jne 0x13e6f3
jmp 0x13e755
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_source_len
GtUword gt_editscript_get_source_len(const GtEditscript *editscript)
{
  GtEditscriptPos pos;
  GtBitsequence elem;
  GtUword length = 0;
  uint32_t served = 0;
  bool skip = false;

  gt_assert(editscript != NULL);
  editscript_pos_reset(&pos);
  if (editscript->num_elems != 0) {
    elem = editscript_space_get_next(editscript, &pos);
    served++;
    while (served < editscript->num_elems) {
      length += editscript_space_get_length(editscript, &pos, &served);
      if (elem == GT_EDITSCRIPT_INS_SYM(editscript))
        skip = true;
      else
        skip = false;

      while (served < editscript->num_elems) {
        elem = editscript_space_get_next(editscript, &pos);
        served++;
        if (elem > (GtBitsequence) editscript->del)
          break;
        if (!skip && elem <= (GtBitsequence) editscript->del)
          length++;
      }
    }
  }
  return length + editscript->trailing_matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x0, 0xc(%rsp)
testq %rdi, %rdi
je 0x13e8dc
movq %rdi, %r14
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x10(%rsp)
movl 0xc(%rdi), %ebx
testl %ebx, %ebx
je 0x13e7e2
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %eax
movq (%r14), %r13
movq (%r13,%rdx,8), %r12
movl %eax, %ecx
negb %cl
shlq %cl, %r12
movzbl 0x15(%r14), %r15d
cmpl %r15d, %eax
jae 0x13e7ce
incl %edx
movl %edx, 0x10(%rsp)
movq (%r13,%rdx,8), %rdx
movl %eax, %ecx
shrq %cl, %rdx
orq %rdx, %r12
addl $0x40, %eax
subl %r15d, %eax
movl %eax, 0x14(%rsp)
movl $0x1, 0xc(%rsp)
cmpl $0x1, %ebx
jne 0x13e7e9
xorl %eax, %eax
jmp 0x13e8c3
movl $0x40, %ecx
subl %r15d, %ecx
movq %rcx, 0x20(%rsp)
shrq %cl, %r12
movl %ebx, %eax
negl %eax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %ebx, %ebp
movq %rax, %rbx
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x13e5a1
addq %rbx, %rax
movl %ebp, %ebx
movl 0xc(%rsp), %r11d
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
cmpl %ebp, %r11d
jae 0x13e8ad
movzbl 0x14(%r14), %r8d
leaq 0x2(%r8), %rcx
xorl %r9d, %r9d
cmpq %rcx, %r12
setne %r9b
incl %r11d
movl $0x40, %ebp
movl %esi, %ecx
xorl %esi, %esi
testl %edx, %edx
sete %sil
cmovel %ebp, %edx
addl %ecx, %esi
movq (%r13,%rsi,8), %r12
movl %edx, %ecx
negb %cl
shlq %cl, %r12
cmpl %r15d, %edx
jae 0x13e87f
incl %esi
movq (%r13,%rsi,8), %r10
movl %edx, %ecx
shrq %cl, %r10
orq %r10, %r12
addl $0x40, %edx
subl %r15d, %edx
movq 0x20(%rsp), %rcx
shrq %cl, %r12
cmpq %r8, %r12
ja 0x13e8ad
addq %r9, %rax
movq 0x18(%rsp), %rcx
addl %r11d, %ecx
incl %ecx
movl %r11d, %r10d
incl %r10d
movl %r10d, %r11d
cmpl $0x1, %ecx
jne 0x13e84d
movl %ebx, %r11d
movl %r11d, 0xc(%rsp)
movl %edx, 0x14(%rsp)
movl %esi, 0x10(%rsp)
cmpl %ebx, %r11d
jb 0x13e804
movl 0x10(%r14), %ecx
addq %rax, %rcx
movq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4092e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_target_len
GtUword gt_editscript_get_target_len(const GtEditscript *editscript)
{
  GtEditscriptPos pos;
  GtBitsequence elem;
  GtUword length = 0;
  uint32_t served = 0;

  gt_assert(editscript != NULL);
  editscript_pos_reset(&pos);
  if (editscript->num_elems != 0) {
    (void) editscript_space_get_next(editscript, &pos);
    served++;
    while (served < editscript->num_elems) {
      /* add matches */
      length += editscript_space_get_length(editscript, &pos, &served);
      while (served < editscript->num_elems) {
        elem = editscript_space_get_next(editscript, &pos);
        served++;
        if (elem > (GtBitsequence) editscript->del)
          break;
        if (elem < (GtBitsequence) editscript->del)
          length++;
      }
    }
  }
  return length + editscript->trailing_matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0x13ea2f
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x8(%rsp)
movl 0xc(%rdi), %ebp
testl %ebp, %ebp
je 0x13e942
movl 0xc(%rsp), %eax
movzbl 0x15(%rdi), %r13d
cmpl %r13d, %eax
jae 0x13e92b
incl 0x8(%rsp)
addl $0x40, %eax
movq (%rdi), %r15
subl %r13d, %eax
movl %eax, 0xc(%rsp)
movl $0x1, 0x4(%rsp)
cmpl $0x1, %ebp
jne 0x13e949
xorl %eax, %eax
jmp 0x13ea17
movl $0x40, %r14d
subl %r13d, %r14d
movl %ebp, %r12d
negl %r12d
xorl %eax, %eax
movq %r12, 0x10(%rsp)
movl %ebp, %ebx
movq %rax, %rbp
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rdi, %r12
callq 0x13e5a1
addq %rbp, %rax
movl %ebx, %ebp
movl 0x4(%rsp), %r11d
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
cmpl %ebx, %r11d
jae 0x13e9fe
movzbl 0x14(%r12), %r8d
incl %r11d
movq %r12, %rdi
movl $0x40, %ebx
movq 0x10(%rsp), %r12
movl %esi, %ecx
xorl %esi, %esi
testl %edx, %edx
sete %sil
cmovel %ebx, %edx
addl %ecx, %esi
movq (%r15,%rsi,8), %r9
movl %edx, %ecx
negb %cl
shlq %cl, %r9
cmpl %r13d, %edx
jae 0x13e9d3
incl %esi
movq (%r15,%rsi,8), %r10
movl %edx, %ecx
shrq %cl, %r10
orq %r10, %r9
addl $0x40, %edx
subl %r13d, %edx
movl %r14d, %ecx
shrq %cl, %r9
cmpq %r8, %r9
ja 0x13ea01
adcq $0x0, %rax
leal (%r12,%r11), %ecx
incl %ecx
movl %r11d, %r9d
incl %r9d
movl %r9d, %r11d
cmpl $0x1, %ecx
jne 0x13e9a3
movl %ebp, %r11d
jmp 0x13ea01
movq %r12, %rdi
movl %r11d, 0x4(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
cmpl %ebp, %r11d
jb 0x13e95f
movl 0x10(%rdi), %ecx
addq %rax, %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40967
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_sequence
GtUword gt_editscript_get_sequence(const GtEditscript *editscript,
                                   const GtEncseq *encseq,
                                   GtUword start,
                                   GtReadmode dir,
                                   GtUchar **buffer,
                                   GtUword *bufsize)
{
  GtUword length = gt_editscript_get_target_len(editscript),
          written;
  if (*buffer == NULL || length > *bufsize) {
    *bufsize = length;
    gt_log_log("bufsize: " GT_WU, *bufsize);
    *buffer = gt_realloc(*buffer, sizeof (**buffer) * *bufsize);
  }
  written = gt_editscript_get_sub_sequence_v(editscript,
                                             encseq, start, dir,
                                             0, length -1,
                                             *buffer);
  gt_assert(written == length);
  return written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %rbp
movl %ecx, 0x14(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x13e8e1
movq %rax, %r14
cmpq $0x0, (%rbp)
je 0x13f521
cmpq (%rbx), %r14
jbe 0x13f551
movq %r14, (%rbx)
leaq 0x245679(%rip), %rdi    # 0x384ba4
movq %r14, %rsi
xorl %eax, %eax
callq 0x108e02
movq (%rbp), %rdi
movq (%rbx), %rsi
leaq 0x245345(%rip), %rdx    # 0x384888
movl $0x2b6, %ecx            # imm = 0x2B6
callq 0x1094e6
movq %rax, (%rbp)
leaq -0x1(%r14), %r9
movq (%rbp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl 0x14(%rsp), %ecx
xorl %r8d, %r8d
callq 0x13f227
cmpq %r14, %rax
jne 0x13f586
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40bda
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_io
GtEditscript *gt_editscript_io(GtEditscript *editscript, FILE *fp, GtError *err)
{
  if (editscript == NULL) {
    editscript = gt_calloc((size_t) 1, sizeof (GtEditscript));
    editscript = editscript_io_fp(editscript, fp, err, gt_io_error_fread);
  }
  else {
    editscript = editscript_io_fp(editscript, fp, err, gt_io_error_fwrite);
  }
  return editscript;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
testq %rdi, %rdi
je 0x13f6a2
movq %rdi, %rbx
addq $0x15, %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
testl %eax, %eax
jne 0x13f79c
leaq 0x10(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
testl %eax, %eax
jne 0x13f79c
leaq 0x14(%rbx), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
testl %eax, %eax
jne 0x13f79c
leaq 0xc(%rbx), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
testl %eax, %eax
jne 0x13f79c
movl (%r12), %eax
testq %rax, %rax
je 0x13f7a6
movzbl 0x15(%rbx), %ecx
imulq %rax, %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbl $-0x1, %esi
movl %esi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rsi
leaq 0x24520e(%rip), %rdx    # 0x384888
movl $0x2e0, %ecx            # imm = 0x2E0
callq 0x1094e6
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
movl $0x8, %esi
movq %rax, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
jmp 0x13f798
leaq 0x2451df(%rip), %rdx    # 0x384888
movl $0x1, %edi
movl $0x18, %esi
movl $0x2f1, %ecx            # imm = 0x2F1
callq 0x1093ef
movq %rax, %rbx
leaq 0x15(%rax), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
jne 0x13f79c
leaq 0x10(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
jne 0x13f79c
leaq 0x14(%rbx), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
jne 0x13f79c
movq %rbx, %r12
addq $0xc, %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
jne 0x13f79c
movl (%r12), %eax
testq %rax, %rax
je 0x13f7a6
movzbl 0x15(%rbx), %ecx
imulq %rax, %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbl $-0x1, %esi
movl %esi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rsi
leaq 0x245113(%rip), %rdx    # 0x384888
movl $0x2e0, %ecx            # imm = 0x2E0
callq 0x1094e6
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
movl $0x8, %esi
movq %rax, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
je 0x13f7a6
movq %rbx, %rdi
callq 0x13de54
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_new
GtEditscriptBuilder *gt_editscript_builder_new(GtEditscript *editscript)
{
  GtEditscriptBuilder *es_b = gt_malloc(sizeof (*es_b));
  editscript_pos_reset(&es_b->fillpos);
  es_b->es = editscript;
  es_b->last_op = 0;
  return es_b;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x244d90(%rip), %rsi    # 0x384888
movl $0x18, %edi
movl $0x344, %edx            # imm = 0x344
callq 0x1092b2
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movb $0x0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_start_group
static inline void gt_editscript_builder_start_group(GtEditscriptBuilder *es_b,
                                                     uint8_t type)
{
  GtEditscript *es = es_b->es;
  es_b->last_op = type;
  editscript_space_add_next(es, &es_b->fillpos, type);
  editscript_space_add_length(es, &es_b->fillpos,
                              (GtBitsequence) es->trailing_matches);
  es->trailing_matches = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
movb %sil, 0x10(%rdi)
movl %esi, %r12d
movl 0x8(%rdi), %r13d
movl 0xc(%rdi), %r15d
movzbl 0x15(%rbx), %ebp
cmpl $0x0, 0x8(%rbx)
jne 0x13fb7c
movl $0x40, %eax
xorl %edx, %edx
divl %ebp
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
leal 0x8(,%rax,8), %edi
leaq 0x244d20(%rip), %rsi    # 0x384888
movl $0x6f, %edx
callq 0x1092b2
movq %rax, (%rbx)
movq $0x0, (%rax)
incl 0xc(%rbx)
leaq 0x8(%r14), %r8
movl %r15d, %eax
subl %ebp, %eax
jbe 0x13fb9b
movl %eax, %ecx
shlq %cl, %r12
movq (%rbx), %rcx
orq %r12, (%rcx,%r13,8)
jmp 0x13fc32
movl %r15d, 0xc(%rsp)
movl %r13d, %r15d
incl %r15d
movl 0x8(%rbx), %ecx
cmpl %ecx, %r15d
jb 0x13fbf9
movb $0x40, %al
movzbl %al, %eax
divb 0x15(%rbx)
movzbl %al, %eax
addl %ecx, %eax
incl %eax
cvtsi2sd %rax, %xmm0
mulsd 0x21114e(%rip), %xmm0   # 0x350d18
cvttsd2si %xmm0, %rax
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x244ca6(%rip), %rdx    # 0x384888
movl $0x7b, %ecx
movq %r8, 0x10(%rsp)
callq 0x1094e6
movq 0x10(%rsp), %r8
movq %rax, (%rbx)
movl %ebp, %ecx
movl 0xc(%rsp), %edi
subl %edi, %ecx
movq %r12, %rax
shrq %cl, %rax
movq (%rbx), %rdx
orq %rax, (%rdx,%r13,8)
movl %r15d, %esi
movq $0x0, (%rdx,%rsi,8)
movl $0x40, %eax
subl %edi, %ebp
je 0x13fc2f
subl %ebp, %eax
negl %ebp
movl %ebp, %ecx
shlq %cl, %r12
movq %r12, (%rdx,%rsi,8)
movl %r15d, %r13d
movl %r13d, 0x8(%r14)
movl %eax, 0xc(%r14)
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %r8, %rsi
callq 0x140f28
movl $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_encode
GtBittab* gt_elias_gamma_encode(GtUword x)
{
  GtBittab* code = NULL;
  GtUword length_in_bits, idx;

  gt_assert(x > 0);
  length_in_bits = (GtUword) gt_determinebitspervalue(x);
  code = gt_bittab_new(length_in_bits + length_in_bits - 1UL);
  for (idx = 0; idx < length_in_bits; idx++)
    if (((x >> idx) & 1))
      gt_bittab_set_bit(code, idx);
  return code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1414da
movq %rdi, %rbx
callq 0x10af48
movl %eax, %ebp
movl %eax, %r12d
leaq -0x1(,%r12,2), %rdi
callq 0xd90d0
movq %rax, %r14
testl %ebp, %ebp
je 0x1414ce
xorl %r15d, %r15d
btq %r15, %rbx
jae 0x1414c6
movq %r14, %rdi
movq %r15, %rsi
callq 0xd913c
incq %r15
cmpq %r15, %r12
jne 0x1414b5
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x40cf7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_bitwise_decoder_new
GtEliasGammaBitwiseDecoder* gt_elias_gamma_bitwise_decoder_new(void)
{
  GtEliasGammaBitwiseDecoder *egbd = gt_malloc(sizeof (*egbd));
  egbd->status = LEADING_ZEROS;
  egbd->cur_bit = 0;
  egbd->length_in_bits = 0;
  egbd->x = 1UL;
  return egbd;
}

// Assembly:
pushq %rax
leaq 0x243b38(%rip), %rsi    # 0x38501f
movl $0x20, %edi
movl $0x33, %edx
callq 0x1092b2
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x1, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_bitwise_decoder_next
int gt_elias_gamma_bitwise_decoder_next(GtEliasGammaBitwiseDecoder *egbd,
                                        bool bit, GtUword *x)
{
  gt_assert(egbd);
  if (egbd->status == LEADING_ZEROS) {
    if (bit == false)
      egbd->length_in_bits += 1;
    else {
      if (egbd->length_in_bits == 0) {
        *x = 1UL;
        reset_decoder(egbd);
        return 0;
      }
      else
        egbd->status = REST;
    }
  }
  else {
    egbd->x = egbd->x << 1;
    if (bit)
      egbd->x = egbd->x | 1;
    egbd->cur_bit++;
    if (egbd->cur_bit == egbd->length_in_bits) {
      *x = egbd->x;
      reset_decoder(egbd);
      return 0;
    }
  }
  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x1415b0
cmpl $0x0, (%rdi)
je 0x141572
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movzbl %sil, %ecx
leaq (%rcx,%rax,2), %rcx
movq %rcx, 0x18(%rdi)
incq %r8
movq %r8, 0x8(%rdi)
movl $0x1, %eax
cmpq 0x10(%rdi), %r8
jne 0x141571
movq %rcx, (%rdx)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x1, 0x18(%rdi)
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
testb %sil, %sil
je 0x141588
testq %rax, %rax
je 0x141595
movl $0x1, (%rdi)
jmp 0x14158f
incq %rax
movq %rax, 0x10(%rdi)
movl $0x1, %eax
retq
movl $0x1, %eax
movq %rax, (%rdx)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
jmp 0x14156f
pushq %rax
callq 0x40d2e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_encoder_new
GtEncdescEncoder* gt_encdesc_encoder_new(void)
{
  GtEncdescEncoder *ee;

  ee = gt_calloc((size_t) 1, sizeof (GtEncdescEncoder));
  ee->timer = NULL;
  ee->page_sampling = false;
  ee->regular_sampling = false;
  ee->sampling_rate = 0;

  ee->encdesc = encdesc_new();
  return ee;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x24391d(%rip), %rbx    # 0x385098
movl $0x1, %edi
movl $0x20, %esi
movq %rbx, %rdx
movl $0x345, %ecx            # imm = 0x345
callq 0x1093ef
movq %rax, %r14
xorl %eax, %eax
movq %rax, (%r14)
movw $0x0, 0x18(%r14)
movq %rax, 0x10(%r14)
movl $0x1, %edi
movl $0x70, %esi
movq %rbx, %rdx
movl $0x33c, %ecx            # imm = 0x33C
callq 0x1093ef
movq %rax, %rbx
callq 0xe837d
movq %rax, 0x50(%rbx)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_load
GtEncdesc* gt_encdesc_load(const char *name,
                           GtError *err)
{
  int had_err = 0;
  GtEncdesc *encdesc = NULL;
  FILE *fp;
  GtStr *filename;
  int fd;
  GtUword const pages_to_map = 5UL;

  gt_assert(name);
  encdesc = encdesc_new();

  filename = gt_str_new_cstr(name);
  gt_str_append_cstr(filename, GT_ENCDESC_FILESUFFIX);
  fp = gt_fa_fopen_with_suffix(name, GT_ENCDESC_FILESUFFIX, "rb", err);
  if (fp == NULL) {
    gt_assert(gt_error_is_set(err));
    had_err = 1;
  }

  if (!had_err) {
    fd = open(gt_str_get(filename), O_RDONLY);
    if (fd == -1) {
      gt_error_set(err, "open(): cannot read file %s, error: %s",
                   gt_str_get(filename), strerror(errno));
      had_err = 1;
    }
  }
  if (!had_err)
    had_err = encdesc_read_header(encdesc, fp, err);

  if (!had_err) {
    encdesc_init_huffman(encdesc);

    encdesc_read_samplingtab(encdesc, fp);
    gt_fa_fclose(fp);

    encdesc->bitinstream =
      gt_bitinstream_new(gt_str_get(filename),
                         (size_t) encdesc->start_of_encoding, pages_to_map);
    gt_str_delete(filename);

  }
  else {
    gt_encdesc_delete(encdesc);
    encdesc = NULL;
  }
  return encdesc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x142e9d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x242345(%rip), %r13    # 0x385098
movl $0x1, %edi
movl $0x70, %esi
movq %r13, %rdx
movl $0x33c, %ecx            # imm = 0x33C
callq 0x1093ef
movq %rax, %rbx
callq 0xe837d
movq %rax, 0x50(%rbx)
movq %r12, %rdi
callq 0x120955
movq %rax, %r14
leaq 0x242496(%rip), %rbp    # 0x38521e
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12097f
leaq 0x26bf25(%rip), %rdx    # 0x3aecbf
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rcx
movl $0x46c, %r8d            # imm = 0x46C
movq %r15, %r9
callq 0x101dff
testq %rax, %rax
je 0x142e42
movq %rax, %r12
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17d60
cmpl $-0x1, %eax
je 0x142e53
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x145068
testl %eax, %eax
jne 0x142e81
movq %rbx, %rdi
callq 0x142b6d
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x142e13
movq %r12, %rdi
xorl %edx, %edx
callq 0x125636
movq %r12, %rdi
callq 0x179216
movq %rax, 0x28(%rbx)
movq %r12, %rdi
callq 0x101e80
movq %r14, %rdi
callq 0x120d23
movq 0x60(%rbx), %rsi
movl $0x5, %edx
movq %rax, %rdi
callq 0x304960
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x121b03
jmp 0x142e8b
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x142e81
callq 0x4132f
movq %r14, %rdi
callq 0x120d23
movq %rax, %r14
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x242530(%rip), %rsi    # 0x3853a1
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movq %rbx, %rdi
callq 0x142ea2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x41368
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_delete
void gt_encdesc_delete(GtEncdesc *encdesc)
{
  if (!encdesc) return;
  gt_bitinstream_delete(encdesc->bitinstream);
  GT_FREEARRAY(&encdesc->num_of_fields_tab, GtUword);
  encdesc_delete_desc_fields(encdesc->fields, encdesc->num_of_fields);
  gt_sampling_delete(encdesc->sampling);
  gt_free(encdesc);
}

// Assembly:
testq %rdi, %rdi
je 0x143038
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x304b3a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x142ee9
leaq 0x2421c7(%rip), %rsi    # 0x385098
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x14300d
movq %rbx, (%rsp)
movq 0x40(%rbx), %r13
testq %r13, %r13
je 0x142ff5
xorl %ebp, %ebp
leaq 0x242188(%rip), %r15    # 0x385098
imulq $0xc8, %rbp, %r12
leaq (%r14,%r12), %rbx
movq 0x8(%r14,%r12), %rdi
callq 0x15bc80
movq 0x10(%r14,%r12), %rdi
callq 0x15bc80
movq 0x40(%r14,%r12), %rdi
movq %r15, %rsi
movl $0x5d2, %edx            # imm = 0x5D2
callq 0x109670
cmpq $0x0, 0x30(%r14,%r12)
je 0x142f7a
cmpq $0x0, 0x68(%rbx)
je 0x142f69
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x106d10
incq %r12
cmpq 0x68(%rbx), %r12
jb 0x142f53
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movl $0x5d6, %edx            # imm = 0x5D6
callq 0x109670
movq 0x28(%rbx), %rdi
callq 0x106d10
movq 0x20(%rbx), %rdi
callq 0x106d10
movq 0x38(%rbx), %rdi
callq 0xe9ff6
cmpq $0x0, (%rbx)
je 0x142fe0
cmpq $0x0, 0x68(%rbx)
je 0x142fd0
xorl %r12d, %r12d
cmpq 0x50(%rbx), %r12
jae 0x142fbb
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xd94c7
testb %al, %al
jne 0x142fc7
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x15bc80
incq %r12
cmpq 0x68(%rbx), %r12
jb 0x142fa5
movq (%rbx), %rdi
movq %r15, %rsi
movl $0x5e2, %edx            # imm = 0x5E2
callq 0x109670
movq 0x18(%rbx), %rdi
callq 0xd97e0
incq %rbp
cmpq %r13, %rbp
jne 0x142f10
leaq 0x24209c(%rip), %rsi    # 0x385098
movq %r14, %rdi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x109670
movq (%rsp), %rbx
movq 0x28(%rbx), %rdi
callq 0x1796f3
leaq 0x24207b(%rip), %rsi    # 0x385098
movq %rbx, %rdi
movl $0x5f0, %edx            # imm = 0x5F0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109670
retq