LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_graph.c
// Function: gt_type_graph_delete
void gt_type_graph_delete(GtTypeGraph *type_graph)
{
  GtUword i;
  if (!type_graph) return;
  gt_bool_matrix_delete(type_graph->part_of_in_edges);
  gt_bool_matrix_delete(type_graph->part_of_out_edges);
  for (i = 0; i < gt_array_size(type_graph->nodes); i++)
    gt_type_node_delete(*(GtTypeNode**) gt_array_get(type_graph->nodes, i));
  gt_array_delete(type_graph->nodes);
  gt_hashmap_delete(type_graph->nodemap);
  gt_hashmap_delete(type_graph->id2name);
  gt_hashmap_delete(type_graph->name2id);
  gt_free(type_graph);
}

// Assembly:
testq %rdi, %rdi
je 0x302df5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x33f907
movq 0x20(%rbx), %rdi
callq 0x33f907
movq 0x18(%rbx), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x302db7
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x303398
incq %r14
movq 0x18(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x302d92
movq 0x18(%rbx), %rdi
callq 0xd2938
movq 0x10(%rbx), %rdi
callq 0x10109b
movq 0x8(%rbx), %rdi
callq 0x10109b
movq (%rbx), %rdi
callq 0x10109b
leaq 0xdc27c(%rip), %rsi     # 0x3df05d
movq %rbx, %rdi
movl $0x42, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_graph.c
// Function: gt_type_graph_is_partof
bool gt_type_graph_is_partof(GtTypeGraph *type_graph, const char *parent_type,
                             const char *child_type)
{
  const char *parent_id, *child_id;
  GtTypeNode *parent_node, *child_node;
  gt_assert(type_graph && parent_type && child_type);
  /* make sure graph is built */
  if (!type_graph->ready) {
    create_vertices(type_graph);
    type_graph->ready = true;
  }
  /* get parent ID, if the type is not mappable to an ID, assume it is the ID */
  if (!(parent_id = gt_hashmap_get(type_graph->name2id, parent_type)))
    parent_id = parent_type;
  /* get child ID, if the type is not mappable to an ID, assmue it is the ID */
  if (!(child_id = gt_hashmap_get(type_graph->name2id, child_type)))
    child_id = child_type;
  /* get parent node */
  parent_node = gt_hashmap_get(type_graph->nodemap, parent_id);
  gt_assert(parent_node);
  /* get child node */
  child_node = gt_hashmap_get(type_graph->nodemap, child_id);
  gt_assert(child_node);
  /* check for parent */
  return gt_type_node_has_parent(child_node, parent_node,
                                 type_graph->part_of_out_edges,
                                 type_graph->part_of_in_edges,
                                 type_graph->nodes, type_graph->id2name, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x303166
movq %rsi, %r15
testq %rsi, %rsi
je 0x303166
movq %rdx, %r14
testq %rdx, %rdx
je 0x303166
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x3030ec
movq %rbx, %rdi
callq 0x303175
movb $0x1, 0x30(%rbx)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x100add
testq %rax, %rax
cmovneq %rax, %r15
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x100add
movq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x100add
testq %rax, %rax
je 0x30316b
movq %rax, %r15
testq %r12, %r12
cmovneq %r12, %r14
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x100add
testq %rax, %rax
je 0x303170
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq 0x8(%rbx), %r9
movq 0x18(%rbx), %r8
movl $0x0, (%rsp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x30357d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8d05a
callq 0x8d0cc
callq 0x8d093
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_graph.c
// Function: create_vertices
static void create_vertices(GtTypeGraph *type_graph)
{
  GtUword i, j;
  GtTypeNode *parent;
  const char *id;
  gt_assert(type_graph && !type_graph->ready);
  /* iterate over nodes */
  for (i = 0; i < gt_array_size(type_graph->nodes); i++) {
    GtTypeNode *node = *(GtTypeNode**) gt_array_get(type_graph->nodes, i);
    /* process is_a parents */
    for (j = 0; j < gt_type_node_is_a_size(node); j++) {
      id = gt_type_node_is_a_get(node, j);
      parent = gt_hashmap_get(type_graph->nodemap, id);
      gt_assert(parent);
      gt_type_node_add_is_a_vertex(node, parent);
    }
    /* process part_of parents */
    for (j = 0; j < gt_type_node_part_of_size(node); j++) {
      id = gt_type_node_part_of_get(node, j);
      parent = gt_hashmap_get(type_graph->nodemap, id);
      gt_assert(parent);
      gt_bool_matrix_set(type_graph->part_of_out_edges, gt_type_node_num(node),
                         gt_type_node_num(parent), true);
      gt_bool_matrix_set(type_graph->part_of_in_edges, gt_type_node_num(parent),
                         gt_type_node_num(node), true);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0x30(%rdi)
jne 0x3032d1
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x3032b8
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %r15
movq %r15, %rdi
callq 0x303473
testq %rax, %rax
je 0x3031fc
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x303435
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x100add
testq %rax, %rax
je 0x3032c7
movq %r15, %rdi
movq %rax, %rsi
callq 0x303532
incq %r12
movq %r15, %rdi
callq 0x303473
cmpq %rax, %r12
jb 0x3031c1
movq %r14, (%rsp)
movq %r15, %rdi
callq 0x303517
testq %rax, %rax
je 0x30329f
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3034d9
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x100add
testq %rax, %rax
je 0x3032cc
movq %rax, %r13
movq 0x20(%rbx), %rbp
movq %r15, %rdi
callq 0x3033db
movq %rax, %r14
movq %r13, %rdi
callq 0x3033db
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x33f754
movq 0x28(%rbx), %r14
movq %r13, %rdi
callq 0x3033db
movq %rax, %r13
movq %r15, %rdi
callq 0x3033db
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x33f754
incq %r12
movq %r15, %rdi
callq 0x303517
cmpq %rax, %r12
jb 0x303214
movq (%rsp), %r14
incq %r14
movq 0x18(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x3031a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8d105
callq 0x8d13e
callq 0x8d177
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_graph.c
// Function: gt_type_graph_is_a
bool gt_type_graph_is_a(GtTypeGraph *type_graph, const char *parent_type,
                        const char *child_type)
{
  const char *parent_id, *child_id;
  GtTypeNode *child_node;
  gt_assert(type_graph && parent_type && child_type);
  /* make sure graph is built */
  if (!type_graph->ready) {
    create_vertices(type_graph);
    type_graph->ready = true;
  }
  /* get parent ID, if the type is not mappable to an ID, assume it is the ID */
  if (!(parent_id = gt_hashmap_get(type_graph->name2id, parent_type)))
    parent_id = parent_type;
  /* get child ID, if the type is not mappable to an ID, assume it is the ID */
  if (!(child_id = gt_hashmap_get(type_graph->name2id, child_type)))
    child_id = child_type;
  /* get child node */
  child_node = gt_hashmap_get(type_graph->nodemap, child_id);
  gt_assert(child_node);
  /* check for parent */
  return gt_type_node_is_a(child_node, parent_id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x303357
movq %rsi, %rbx
testq %rsi, %rsi
je 0x303357
movq %rdx, %r14
testq %rdx, %rdx
je 0x303357
movq %rdi, %r15
cmpb $0x0, 0x30(%rdi)
jne 0x303309
movq %r15, %rdi
callq 0x303175
movb $0x1, 0x30(%r15)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x100add
movq %rax, %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x100add
testq %rax, %rax
cmovneq %rax, %r14
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x100add
testq %rax, %rax
je 0x30335c
testq %r12, %r12
cmovneq %r12, %rbx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3039ab
callq 0x8d1b0
callq 0x8d1e9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_new
GtTypeNode* gt_type_node_new(GtUword num, const char *id)
{
  GtTypeNode *node = gt_calloc(1, sizeof *node);
  node->num = num;
  node->id = id;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdbe7f(%rip), %rdx     # 0x3df1f4
movl $0x1, %edi
movl $0x38, %esi
movl $0x24, %ecx
callq 0x10436a
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_delete
void  gt_type_node_delete(GtTypeNode *type_node)
{
  if (!type_node) return;
  gt_hashmap_delete(type_node->cache);
  gt_array_delete(type_node->is_a_out_edges);
  gt_array_delete(type_node->part_of_list);
  gt_array_delete(type_node->is_a_list);
  gt_free(type_node);
}

// Assembly:
testq %rdi, %rdi
je 0x3033da
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x10109b
movq 0x20(%rbx), %rdi
callq 0xd2938
movq 0x18(%rbx), %rdi
callq 0xd2938
movq 0x10(%rbx), %rdi
callq 0xd2938
leaq 0xdbe28(%rip), %rsi     # 0x3df1f4
movq %rbx, %rdi
movl $0x31, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_is_a_add
void gt_type_node_is_a_add(GtTypeNode *type_node, const char *id)
{
  gt_assert(type_node && id);
  if (!type_node->is_a_list)
    type_node->is_a_list = gt_array_new(sizeof (const char*));
  gt_array_add(type_node->is_a_list, id);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x303430
testq %rsi, %rsi
je 0x303430
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x30341b
movl $0x8, %edi
callq 0xd214c
movq %rax, %rdi
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0xd2410
addq $0x10, %rsp
popq %rbx
retq
callq 0x8d259
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_part_of_add
void gt_type_node_part_of_add(GtTypeNode *type_node, const char *id)
{
  gt_assert(type_node && id);
  if (!type_node->part_of_list)
    type_node->part_of_list = gt_array_new(sizeof (const char*));
  gt_array_add(type_node->part_of_list, id);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x3034d4
testq %rsi, %rsi
je 0x3034d4
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x3034bf
movl $0x8, %edi
callq 0xd214c
movq %rax, %rdi
movq %rax, 0x18(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0xd2410
addq $0x10, %rsp
popq %rbx
retq
callq 0x8d2fe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_add_is_a_vertex
void gt_type_node_add_is_a_vertex(GtTypeNode *src, const GtTypeNode *dst)
{
  gt_assert(src && dst);
  if (!src->is_a_out_edges)
    src->is_a_out_edges = gt_array_new(sizeof (GtTypeNode*));
  gt_array_add(src->is_a_out_edges, dst);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x303578
testq %rsi, %rsi
je 0x303578
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x303563
movl $0x8, %edi
callq 0xd214c
movq %rax, %rdi
movq %rax, 0x20(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0xd2410
addq $0x10, %rsp
popq %rbx
retq
callq 0x8d3a3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: create_transitive_part_of_edges
static void create_transitive_part_of_edges(GtTypeNode *node,
                                            GtBoolMatrix *part_of_out_edges,
                                            GtBoolMatrix *part_of_in_edges,
                                            GtArray *node_stack)
{
  GtUword i, j;
  /* For every incoming part_of edge of the current node add a corresponding
     part_of edge to all nodes in the stack. Note that the current node is not
     part of the stack yet, therefore this is skipped on the first invocation.
   */
  if (gt_array_size(node_stack)) {
    for (i  = gt_bool_matrix_get_first_column(part_of_in_edges, node->num);
         i != gt_bool_matrix_get_last_column(part_of_in_edges, node->num);
         i  = gt_bool_matrix_get_next_column(part_of_in_edges, node->num, i)) {
      for (j = 0; j < gt_array_size(node_stack); j++) {
        GtTypeNode *child = *(GtTypeNode**) gt_array_get(node_stack, j);
        gt_bool_matrix_set(part_of_out_edges, i, child->num, true);
        gt_bool_matrix_set(part_of_in_edges, child->num, i, true);
      }
    }
  }
  /* add node to stack */
  gt_array_add(node_stack, node);
  /* call method recursively for all is_a edges of the current node */
  for (i = 0; i < gt_array_size(node->is_a_out_edges); i++) {
    GtTypeNode *parent = *(GtTypeNode**) gt_array_get(node->is_a_out_edges, i);
    create_transitive_part_of_edges(parent, part_of_out_edges, part_of_in_edges,
                                    node_stack);
  }
  /* pop node from stack */
  gt_array_pop(node_stack);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rcx, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x303932
movq 0x10(%rsp), %r12
movq (%r12), %rsi
movq %r14, %rdi
callq 0x33f817
movq %rax, %r13
movq (%r12), %rsi
movq %r14, %rdi
callq 0x33f866
cmpq %rax, %r13
je 0x303932
movq %rbx, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x30391c
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xd2207
movq (%rax), %r12
movq (%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %ecx
callq 0x33f754
movq (%r12), %rsi
movq %r14, %rdi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x33f754
incq %rbp
movq %rbx, %rdi
callq 0xd24e0
cmpq %rax, %rbp
jb 0x3038d6
movq 0x10(%rsp), %r12
movq (%r12), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x33f8b5
jmp 0x3038b3
leaq 0x8(%rsp), %r12
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2410
movq (%r12), %rax
movq 0x20(%rax), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x303994
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0xd2207
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x303870
incq %r12
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xd24e0
cmpq %rax, %r12
jb 0x30395c
movq %rbx, %rdi
callq 0xd2242
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_is_a
bool gt_type_node_is_a(GtTypeNode *child_node, const char *parent_id)
{
  GtUword i;
  gt_assert(child_node && parent_id);

  /* XXX: do path compression */
  if (!strcmp(child_node->id, parent_id))
    return true;
  for (i = 0; i < gt_array_size(child_node->is_a_out_edges); i++) {
    GtTypeNode *node = *(GtTypeNode**) gt_array_get(child_node->is_a_out_edges,
                                                    i);
    if (gt_type_node_is_a(node, parent_id))
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x303a27
movq %rsi, %rbx
testq %rsi, %rsi
je 0x303a27
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x17a40
testl %eax, %eax
je 0x303a13
movq 0x20(%r14), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x303a18
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3039ab
movl %eax, %ebp
testb %al, %al
jne 0x303a1a
incq %r15
movq 0x20(%r14), %rdi
callq 0xd24e0
cmpq %rax, %r15
jb 0x3039e3
jmp 0x303a1a
movb $0x1, %bpl
jmp 0x303a1a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x8d44c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/apmeoveridx.c
// Function: apme_initdfsconstinfo
static void apme_initdfsconstinfo(Limdfsconstinfo *mt,
                                  unsigned int alphasize,
                                  ...)
                                 /* Variable argument list is as follows:
                                    unsigned int alphasize
                                    const GtUchar *pattern,
                                    GtUword patternlength,
                                    GtUword maxdistance,
                                    GtUword maxintervalwidth,
                                    bool skpp
                                 */
{
  va_list ap;
  const GtUchar *pattern;
  ApmeoveridxLimdfsconstinfo *mti = (ApmeoveridxLimdfsconstinfo *) mt;

  va_start(ap,alphasize);
  pattern = va_arg(ap, const GtUchar *);
  mti->patternlength = va_arg(ap, GtUword);
  mti->maxdistance = va_arg(ap, GtUword);
  mti->maxintervalwidth = va_arg(ap, GtUword);
  mti->skpp = (bool) va_arg(ap, int);
  va_end(ap);
  gt_assert(mti->maxdistance < mti->patternlength);
  gt_initeqsvector(mti->eqsvector,(GtUword) alphasize,
                pattern,mti->patternlength);
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x307a5e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x10, %eax
cmpq $0x29, %rax
jae 0x307b03
movq 0x10(%rsp), %rdx
leaq 0x8(%rax), %rcx
movl %ecx, (%rsp)
movq (%rdx,%rax), %rdx
cmpl $0x21, %eax
jae 0x307b14
movq 0x10(%rsp), %r8
leal 0x10(%rax), %r9d
movl %r9d, (%rsp)
movq (%r8,%rcx), %rcx
movq %rcx, 0x10(%rdi)
cmpl $0x19, %eax
jae 0x307b29
movq 0x10(%rsp), %r8
leaq 0x18(%rax), %rcx
movl %ecx, (%rsp)
movq 0x10(%r8,%rax), %r8
movq %r8, 0x18(%rdi)
cmpl $0x11, %eax
jae 0x307b3e
movq 0x10(%rsp), %r9
movl $0x10, %r8d
orl $0x20, %r8d
movl %r8d, (%rsp)
movq (%r9,%rcx), %rcx
movq %rcx, 0x8(%rdi)
cmpl $0x28, %r8d
ja 0x307b53
movl %r8d, %ecx
addq 0x10(%rsp), %rcx
addl $0x28, %eax
movl %eax, (%rsp)
jmp 0x307b61
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rdi)
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rcx)
setne (%rdi)
movq 0x10(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
jae 0x307b84
movq 0x20(%rdi), %rdi
movl %esi, %esi
callq 0x31f8e4
addq $0xd8, %rsp
retq
callq 0x8edc0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_new
GtDiagbandStruct *gt_diagband_struct_new(GtUword amaxlen,GtUword bmaxlen,
                                         GtUword logdiagbandwidth)
{
  GtDiagbandStruct *diagband_struct = gt_malloc(sizeof *diagband_struct);

  diagband_struct->used_diagbands = 0;
  diagband_struct->num_diagbands
    = gt_diagband_struct_num_diagbands(amaxlen,bmaxlen,logdiagbandwidth);
  diagband_struct->amaxlen = amaxlen;
  diagband_struct->logdiagbandwidth = logdiagbandwidth;
  /* diagband_score[0] and diagband_score[num_diagbands+1] remain zero as
     boundaries */
  diagband_struct->score = gt_calloc(diagband_struct->num_diagbands + 2,
                                     sizeof *diagband_struct->score);
  diagband_struct->score++; /* so we need not increment the index when
                               accessing score */
  diagband_struct->lastpos
    = gt_calloc(diagband_struct->num_diagbands,
                sizeof *diagband_struct->lastpos);
  diagband_struct->reset_from_matches = 0;
  diagband_struct->reset_with_memset = 0;
  return diagband_struct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0xd87c5(%rip), %r14     # 0x3e0681
movl $0x40, %edi
movq %r14, %rsi
movl $0x37, %edx
callq 0x104226
movq %rax, %rbx
movq $0x0, 0x18(%rax)
addq %r13, %r12
movl %r15d, %ecx
shrq %cl, %r12
leaq 0x1(%r12), %rax
movq %rax, 0x10(%rbx)
movq %r13, (%rbx)
movq %r15, 0x8(%rbx)
addq $0x3, %r12
movl $0x4, %esi
movq %r12, %rdi
movq %r14, %rdx
movl $0x41, %ecx
callq 0x10436a
addq $0x4, %rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rdx
movl $0x46, %ecx
callq 0x10436a
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_reset_counts
void gt_diagband_struct_reset_counts(const GtDiagbandStruct *diagband_struct,
                                     FILE *stream)
{
  fprintf(stream,"# number of resets of all used diagonal bands: " GT_WU,
          diagband_struct->reset_with_memset +
          diagband_struct->reset_from_matches);
  if (diagband_struct->reset_with_memset > 0)
  {
    fprintf(stream,"; simple resets: " GT_WU,
            diagband_struct->reset_with_memset);
  }
  if (diagband_struct->reset_from_matches > 0)
  {
    fprintf(stream,"; resets from matches: " GT_WU,
            diagband_struct->reset_from_matches);
  }
  fprintf(stream,"\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdx
addq 0x28(%rdi), %rdx
leaq 0xd8743(%rip), %rsi     # 0x3e069d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x307f7e
leaq 0xd875c(%rip), %rsi     # 0x3e06d0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x307f98
leaq 0xd8757(%rip), %rsi     # 0x3e06e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17980
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_delete
void gt_diagband_struct_delete(GtDiagbandStruct *diagband_struct)
{
  if (diagband_struct != NULL)
  {
    diagband_struct->score--; /* need to recover original base adress */
    gt_free(diagband_struct->score);
    gt_free(diagband_struct->lastpos);
    gt_free(diagband_struct);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x308000
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $-0x4, %rdi
movq %rdi, 0x30(%rbx)
leaq 0xd86b6(%rip), %r14     # 0x3e0681
movq %r14, %rsi
movl $0x64, %edx
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x65, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x66, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_single_update
void gt_diagband_struct_single_update(GtDiagbandStruct *diagband_struct,
                                      GtDiagbandseedPosition apos,
                                      GtDiagbandseedPosition bpos,
                                      GtDiagbandseedPosition matchlength)
{
  GtUword diagband_idx;

  gt_assert(diagband_struct != NULL);
  diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND(diagband_struct->amaxlen,
                                              diagband_struct->logdiagbandwidth,
                                              apos,
                                              bpos);
  gt_assert(diagband_idx < diagband_struct->num_diagbands);
  if (diagband_struct->lastpos[diagband_idx] == 0 /* first matches */||
      /* match with end position bpos begins strictly after previous match */
      diagband_struct->lastpos[diagband_idx] + matchlength <= bpos)
  {
    /* no overlap */
    diagband_struct->lastpos[diagband_idx] = bpos;
    if (diagband_struct->score[diagband_idx] == 0)
    {
      diagband_struct->used_diagbands++;
    }
    diagband_struct->score[diagband_idx] += matchlength;
  } else
  {
    /* overlap: add positions after last counted position */
    if (diagband_struct->lastpos[diagband_idx] < bpos)
    {
      const GtUword addlength = bpos - diagband_struct->lastpos[diagband_idx];

      diagband_struct->lastpos[diagband_idx] = bpos;
      if (diagband_struct->score[diagband_idx] == 0)
      {
        diagband_struct->used_diagbands++;
      }
      diagband_struct->score[diagband_idx] += addlength;
    }
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x30807c
movl %ecx, %eax
movl %edx, %r8d
movl %esi, %ecx
subq %rcx, %r8
addq (%rdi), %r8
movb 0x8(%rdi), %cl
shrq %cl, %r8
cmpq 0x10(%rdi), %r8
jae 0x308081
movq 0x38(%rdi), %rcx
movl (%rcx,%r8,4), %esi
testl %esi, %esi
setne %r9b
leal (%rsi,%rax), %r10d
cmpl %edx, %r10d
seta %r10b
testb %r10b, %r9b
je 0x308060
movl %edx, %eax
subl %esi, %eax
jbe 0x30807a
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x308058
incq 0x18(%rdi)
addl %edx, %eax
movl %eax, (%rcx,%r8,4)
jmp 0x30807a
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x308074
incq 0x18(%rdi)
addl %eax, %edx
movl %edx, (%rcx,%r8,4)
popq %rax
retq
callq 0x8ef86
callq 0x8ef4f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_multi_update
void gt_diagband_struct_multi_update(GtDiagbandStruct *diagband_struct,
                                     const GtDiagbandseedMaximalmatch *memstore,
                                     GtUword numofmatches)
{
  GtUword idx;

  gt_assert(memstore != NULL);
  for (idx = 0; idx < numofmatches; idx++)
  {
    gt_diagband_struct_single_update(diagband_struct,
                                     memstore[idx].apos,
                                     memstore[idx].bpos,
                                     memstore[idx].len);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x3080f7
movq %rdx, %rbx
testq %rdx, %rdx
je 0x3080f1
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
movl -0x8(%r14), %esi
movl -0x4(%r14), %edx
movl (%r14), %ecx
movq %r15, %rdi
callq 0x308001
addq $0xc, %r14
decq %rbx
jne 0x3080d5
popq %rbx
popq %r14
popq %r15
retq
callq 0x8eff6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_statistics_new
GtDiagbandStatistics *gt_diagband_statistics_new(const GtStr
                                                   *diagband_distance_arg,
                                                 bool forward)
{
  const char *arg = gt_str_get(diagband_distance_arg);
  GtDiagbandStatistics *diagband_statistics
    = gt_malloc(sizeof *diagband_statistics);

  diagband_statistics->forward = forward;
  diagband_statistics->compute_sum = false;
  if (strcmp(arg,"sum") == 0)
  {
    diagband_statistics->compute_sum = true;
  } else
  {
    gt_assert(false);
  }
  diagband_statistics->sumscore = 0;
  diagband_statistics->track = NULL;
  return diagband_statistics;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
callq 0x11b0a1
movq %rax, %r14
leaq 0xd8475(%rip), %rsi     # 0x3e0681
movl $0x18, %edi
movl $0xf8, %edx
callq 0x104226
movq %rax, %rbx
movb %bpl, 0x1(%rax)
movb $0x0, (%rax)
leaq 0x4df1b(%rip), %rsi     # 0x356147
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
jne 0x30824a
movb $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x8f0a1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_statistics_display
void gt_diagband_statistics_display(const GtDiagbandStatistics
                                           *diagband_statistics)
{
  gt_assert(diagband_statistics != NULL);
  if (diagband_statistics->compute_sum)
  {
    printf("# forward=%s, sum_diagband_score=" GT_WU "\n",
            diagband_statistics->forward ? "true" : "false",
            diagband_statistics->sumscore);
  } else
  {
    gt_assert(false);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3082bf
cmpb $0x1, (%rdi)
jne 0x3082c4
leaq 0x99a38(%rip), %rax     # 0x3a1cd5
leaq 0x7e348(%rip), %rsi     # 0x3865ec
cmpb $0x0, 0x1(%rdi)
cmovneq %rax, %rsi
movq 0x8(%rdi), %rdx
leaq 0xd856c(%rip), %rdi     # 0x3e0823
xorl %eax, %eax
popq %rcx
jmp 0x17070
callq 0x8f113
callq 0x8f0da
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/dist-short.c
// Function: gt_distanceofshortstringsbytearray
GtUword gt_distanceofshortstringsbytearray(GtUword *eqsvector,
                                              unsigned int alphasize,
                                              const GtUchar *useq,
                                              GtUword ulen,
                                              const GtUchar *vseq,
                                              GtUword vlen)
{
  DECLARELOCALVARS;
  const GtUchar *vptr;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  for (vptr = vseq; vptr < vseq + vlen; vptr++)
  {
    COMPUTENEWDIST(*vptr);
  }
  return distval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r12
decl %ecx
movl $0x1, %r13d
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %rbx, %rcx
callq 0x31f8e4
testq %r14, %r14
jle 0x3084ce
addq %r15, %r14
movq $-0x1, %rax
xorl %ecx, %ecx
movzbl (%r15), %edx
cmpl $0xfe, %edx
je 0x308468
cmpl $0xff, %edx
je 0x3084e0
movq (%r12,%rdx,8), %rdi
jmp 0x30846a
xorl %edi, %edi
movq %rdi, %rdx
orq %rcx, %rdx
movq %rdi, %rsi
andq %rax, %rsi
addq %rax, %rsi
xorq %rax, %rsi
orq %rdi, %rsi
movq %rsi, %rdi
orq %rax, %rdi
notq %rdi
orq %rcx, %rdi
andq %rax, %rsi
movq %rsi, %rax
andq %rbp, %rax
negq %rax
movl $0x0, %eax
sbbq %rax, %rax
testq %rbp, %rdi
cmovneq %r13, %rax
addq %rax, %rbx
leaq 0x1(,%rdi,2), %rcx
addq %rsi, %rsi
movq %rcx, %rax
orq %rdx, %rax
notq %rax
orq %rsi, %rax
andq %rcx, %rdx
incq %r15
movq %rdx, %rcx
cmpq %r14, %r15
jb 0x30844e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8f185
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/dist-short.c
// Function: gt_distanceofshortstringsencseq
GtUword gt_distanceofshortstringsencseq(GtUword *eqsvector,
                                           unsigned int alphasize,
                                           const GtUchar *useq,
                                           GtUword ulen,
                                           const GtEncseq *encseq,
                                           GtUword vstartpos,
                                           GtUword vlen)
{
  DECLARELOCALVARS;
  GtUchar cc;
  GtUword pos;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  for (pos = vstartpos; pos < vstartpos + vlen; pos++)
  {
    cc = gt_encseq_get_encoded_char(encseq,pos,GT_READMODE_FORWARD);
    COMPUTENEWDIST(cc);
  }
  return distval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, %rbx
movq 0x50(%rsp), %r13
decl %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %rdi, 0x8(%rsp)
movq %rbx, %rcx
callq 0x31f8e4
leaq (%r14,%r13), %rax
cmpq %r14, %rax
jbe 0x3085ce
movq $-0x1, %r12
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe7bbc
cmpb $-0x2, %al
je 0x30855f
movzbl %al, %eax
cmpl $0xff, %eax
je 0x3085e0
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rdx
jmp 0x308561
xorl %edx, %edx
movq %rdx, %rax
orq %r15, %rax
movq %rdx, %rcx
andq %r12, %rcx
addq %r12, %rcx
xorq %r12, %rcx
orq %rdx, %rcx
movq %rcx, %rdx
orq %r12, %rdx
notq %rdx
orq %r15, %rdx
andq %r12, %rcx
movq %rcx, %rsi
andq %rbp, %rsi
negq %rsi
movl $0x0, %esi
sbbq %rsi, %rsi
testq %rbp, %rdx
movl $0x1, %edi
cmovneq %rdi, %rsi
addq %rsi, %rbx
leaq 0x1(,%rdx,2), %rdx
addq %rcx, %rcx
movq %rdx, %r12
orq %rax, %r12
notq %r12
orq %rcx, %r12
andq %rdx, %rax
incq %r14
movq %rax, %r15
decq %r13
jne 0x308533
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8f1bc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/dist-short.c
// Function: gt_reversesuffixmatch
GtUword gt_reversesuffixmatch(GtUword *eqsvector,
                                 unsigned int alphasize,
                                 const GtUchar *useq,
                                 GtUword ulen,
                                 const GtUchar *vseq,
                                 GtUword vlen,
                                 GtUword maxdistance)
{
  DECLARELOCALVARS;
  const GtUchar *vptr;

  gt_initeqsvectorrev(eqsvector,(GtUword) alphasize,useq,ulen);
  gt_assert(maxdistance > 0);
  for (vptr = vseq + vlen - 1; vptr >= vseq; vptr--)
  {
    COMPUTENEWDIST(*vptr);
    if (distval <= maxdistance)
    {
      break;
    }
  }
  /* gt_assert(distval <= maxdistance); */
  return (GtUword) (vseq + vlen - vptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r12
movq 0x40(%rsp), %r13
decl %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %r15, %rcx
callq 0x31f970
testq %r13, %r13
je 0x3086e2
leaq (%rbx,%r14), %rax
decq %rax
cmpq %rbx, %rax
jb 0x3086c5
movq $-0x1, %rdi
xorl %ecx, %ecx
movl $0x1, %edx
movzbl (%rax), %esi
cmpl $0xfe, %esi
je 0x308659
cmpl $0xff, %esi
je 0x3086dd
movq (%r12,%rsi,8), %rsi
jmp 0x30865b
xorl %esi, %esi
movq %rsi, %r8
andq %rdi, %r8
addq %rdi, %r8
xorq %rdi, %r8
orq %rsi, %r8
movq %r8, %r9
orq %rdi, %r9
notq %r9
orq %rcx, %r9
andq %rdi, %r8
movq %r8, %rdi
andq %rbp, %rdi
negq %rdi
movl $0x0, %edi
sbbq %rdi, %rdi
testq %rbp, %r9
cmovneq %rdx, %rdi
addq %rdi, %r15
cmpq %r13, %r15
jbe 0x3086c5
orq %rcx, %rsi
leaq 0x1(,%r9,2), %rdi
movq %rdi, %rcx
andq %rsi, %rcx
addq %r8, %r8
orq %rdi, %rsi
notq %rsi
orq %r8, %rsi
decq %rax
movq %rsi, %rdi
cmpq %rbx, %rax
jae 0x30863c
addq %r14, %rbx
subq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8f1f3
callq 0x8f22a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/dist-short.c
// Function: gt_forwardprefixmatch
Definedunsignedlong gt_forwardprefixmatch(const GtEncseq *encseq,
                                       unsigned int alphasize,
                                       GtUword startpos,
                                       bool nowildcards,
                                       GtUword *eqsvector,
                                       const GtUchar *useq,
                                       GtUword ulen,
                                       GtUword maxdistance)
{
  DECLARELOCALVARS;
  GtUword pos, totallength = gt_encseq_total_length(encseq);
  GtUchar cc;
  Definedunsignedlong result;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  gt_assert(maxdistance > 0);
  for (pos = startpos; /* Nothing */; pos++)
  {
    gt_assert(pos - startpos <= (GtUword) (ulen + maxdistance));
    cc = gt_encseq_get_encoded_char(encseq,pos,GT_READMODE_FORWARD);
    if (nowildcards && cc == (GtUchar) GT_WILDCARD)
    {
      result.defined = false;
      result.valueunsignedlong = 0;
      return result;
    }
    COMPUTENEWDIST(cc);
    if (distval <= maxdistance || pos == totallength-1)
    {
      break;
    }
  }
  result.defined = true;
  result.valueunsignedlong = (GtUword) (pos - startpos + 1);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movl %ecx, 0x14(%rsp)
movq %rdx, %r15
movl %esi, %r13d
movq 0x70(%rsp), %r12
leal -0x1(%r12), %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movq %rdi, 0x30(%rsp)
callq 0xe7b9c
movq %rax, %rbx
movl %r13d, %esi
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
callq 0x31f8e4
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x308864
addq %r12, %rax
movq %rax, 0x20(%rsp)
movq %r15, 0x8(%rsp)
subq %rbx, %r15
incq %r15
movq %r15, 0x28(%rsp)
movq $-0x1, %r15
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
leaq (%rax,%r13), %rsi
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0xe7bbc
cmpb $-0x2, %al
sete %cl
testb %cl, 0x14(%rsp)
jne 0x308841
cmpb $-0x2, %al
je 0x3087b9
movzbl %al, %eax
cmpl $0xff, %eax
movq 0x78(%rsp), %rdi
je 0x30885f
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rax
jmp 0x3087c0
xorl %eax, %eax
movq 0x78(%rsp), %rdi
movq %rax, %rcx
andq %r15, %rcx
addq %r15, %rcx
xorq %r15, %rcx
orq %rax, %rcx
movq %rcx, %rdx
orq %r15, %rdx
notq %rdx
orq %r14, %rdx
andq %r15, %rcx
movq %rcx, %rsi
andq %rbp, %rsi
negq %rsi
movl $0x0, %esi
sbbq %rsi, %rsi
testq %rbp, %rdx
movl $0x1, %r8d
cmovneq %r8, %rsi
addq %rsi, %r12
cmpq %rdi, %r12
jbe 0x308846
movq 0x28(%rsp), %rsi
addq %r13, %rsi
je 0x308846
orq %r14, %rax
leaq 0x1(,%rdx,2), %rdx
movq %rdx, %r14
andq %rax, %r14
addq %rcx, %rcx
orq %rdx, %rax
notq %rax
orq %rcx, %rax
incq %r13
movq %rax, %r15
cmpq 0x20(%rsp), %r13
jbe 0x308771
callq 0x8f29a
xorl %r13d, %r13d
jmp 0x30884b
incq %r13
movb $0x1, %bl
movl %ebx, %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8f261
callq 0x8f2d3
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp-param.c
// Function: gt_registerBlockEncOptions
void
gt_registerBlockEncOptions(GtOptionParser *op,
                           struct blockEncParams *paramOutput)
{
  GtOption *option;

  option = gt_option_new_uint_min("bsize", "specify size of blocks",
                                  &paramOutput->blockSize, 8U, 1U);
  gt_option_parser_add_option(op, option);
  option = gt_option_new_uint_min("blbuck", "specify number of blocks per "
                                            "bucket",
                                  &paramOutput->bucketBlocks, 8U, 1U);
  gt_option_parser_add_option(op, option);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7d966(%rip), %rdi     # 0x3861e3
leaq 0xd80e8(%rip), %rsi     # 0x3e096c
movq %r14, %rdx
movl $0x8, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x4, %r14
leaq 0xd80d6(%rip), %rdi     # 0x3e0983
leaq 0xd80d6(%rip), %rsi     # 0x3e098a
movq %r14, %rdx
movl $0x8, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x107cc0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: destructOnDiskBlockCompIdx
static void
destructOnDiskBlockCompIdx(struct onDiskBlockCompIdx *idx)
{
  if (idx->idxMMap)
    gt_fa_xmunmap(idx->idxMMap);
  if (idx->idxFP)
    gt_fa_xfclose(idx->idxFP);
  if (idx->idxFN)
    gt_str_delete(idx->idxFN);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x30a06a
callq 0xfdc54
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30a077
callq 0xfd09a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x30a086
popq %rbx
jmp 0x11bdbf
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: openOnDiskData
static int
openOnDiskData(const char *projectName, struct onDiskBlockCompIdx *idx,
               char *mode,GtError *err)
{
  GtStr *bdxName = gt_str_new_cstr(projectName);
  gt_str_append_cstr(bdxName, ".bdx");
  idx->idxFP = gt_fa_fopen(gt_str_get(bdxName), mode, err);
  idx->idxFN = gt_str_ref(bdxName);
  gt_str_delete(bdxName);
  if (!idx->idxFP)
    return 0;
  else
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
callq 0x11acc9
movq %rax, %r12
leaq 0xd6f8b(%rip), %rsi     # 0x3e1033
movq %rax, %rdi
callq 0x11acf3
movq %r12, %rdi
callq 0x11b0a1
leaq 0xd6911(%rip), %rdx     # 0x3e09d0
movq %rax, %rdi
movq %r15, %rsi
movl $0x6a4, %ecx            # imm = 0x6A4
movq %r14, %r8
callq 0xfcdbb
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x11b1f3
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x11bdbf
xorl %eax, %eax
cmpq $0x0, (%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockEncIdxSeq
static void
deleteBlockEncIdxSeq(struct encIdxSeq *seq)
{
  struct blockCompositionSeq *bseq;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  bseq = encIdxSeq2blockCompositionSeq(seq);
  gt_free(bseq->extHeaderPos);
  gt_free(bseq->partialSymSumBits);
  destructOnDiskBlockCompIdx(&bseq->externalData);
  gt_destructCompositionList(&bseq->compositionTable);
  gt_MRAEncDelete(bseq->baseClass.alphabet);
  gt_MRAEncDelete(bseq->rangeMapAlphabet);
  gt_MRAEncDelete(bseq->blockMapAlphabet);
  gt_deleteSeqRangeList(bseq->rangeEncs);
  gt_free(bseq->modes);
  gt_free(bseq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30b6a2
movq %rdi, %rbx
leaq 0x1ad5aa(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30b6a2
movq 0x78(%rbx), %rdi
leaq 0xd53b6(%rip), %r14     # 0x3e09d0
movq %r14, %rsi
movl $0x297, %edx            # imm = 0x297
callq 0x1045eb
movq 0xd0(%rbx), %rdi
movq %r14, %rsi
movl $0x298, %edx            # imm = 0x298
callq 0x1045eb
leaq 0x18(%rbx), %rdi
callq 0x30a058
leaq 0x48(%rbx), %rdi
callq 0x30e1e8
movq 0x8(%rbx), %rdi
callq 0x19e389
movq 0xa0(%rbx), %rdi
callq 0x19e389
movq 0x98(%rbx), %rdi
callq 0x19e389
movq 0x70(%rbx), %rdi
callq 0x30e6b8
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
movl $0x29f, %edx            # imm = 0x29F
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2a0, %edx            # imm = 0x2A0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x8faa2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: blockCompSeqGet
static Symbol
blockCompSeqGet(struct encIdxSeq *seq, GtUword pos, union EISHint *hint)
{
  Symbol sym;
  struct blockCompositionSeq *seqIdx;
  unsigned blockSize;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  if (pos >= seq->seqLen)
    return ~(Symbol)0;
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  blockSize = seqIdx->blockSize;
  {
    Symbol block[blockSize];
    blockCompSeqGetBlock(seqIdx, pos/blockSize, &(hint->bcHint), 1, NULL,
                         block);
    sym = block[pos%blockSize];
  }
  return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x30c560
movq %rdi, %r14
leaq 0x1ac800(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30c560
movb $-0x1, %al
cmpq %rsi, 0x10(%r14)
jbe 0x30c551
movq %rdx, %r8
movq %rsp, %rdi
movl 0xb4(%r14), %ecx
movq %rsp, %rbx
leaq 0xf(%rcx), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r13
movl 0xb4(%r14), %eax
movq %r13, %rcx
imulq %rax, %rcx
cmpq 0x10(%r14), %rcx
jae 0x30c54b
movq %rcx, -0x38(%rbp)
movq %rax, -0x60(%rbp)
movq %rdx, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movl 0xb0(%r14), %ecx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r8, -0x58(%rbp)
movq %r8, %rdx
callq 0x30cc26
movq %rax, %rsi
movl (%rax), %ebx
movl 0x4(%rax), %eax
movl 0xc0(%r14), %ecx
movl 0xe0(%r14), %edx
addq %rcx, %rdx
movl 0xb8(%r14), %r12d
addq %rdx, %r12
addq %rax, %r12
movl 0x68(%r14), %r15d
movq %r14, %rdi
movl 0xb0(%r14), %ecx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x30c4bf
movq %rdx, %r13
movq %rdi, -0x30(%rbp)
movq 0x10(%rsi), %rdi
movq %rsi, %r14
movq %r12, %rsi
movl %r15d, %edx
callq 0x2f2688
movq %r14, %rsi
movq -0x30(%rbp), %rcx
movq 0x50(%rcx), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,8), %eax
addq %rax, %rbx
addq %r15, %r12
decl %r13d
jne 0x30c483
movq -0x30(%rbp), %r13
movl 0x68(%r13), %r15d
jmp 0x30c4c2
movq %rdi, %r13
movq 0x10(%rsi), %rdi
movq %rsi, %r14
movq %r12, %rsi
movl %r15d, %edx
callq 0x2f2688
movq 0x50(%r13), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %r15
movl 0x8(%rcx,%r15,8), %edx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2f2688
movl 0xb4(%r13), %esi
movq -0x60(%rbp), %r12
cmpl %r12d, %esi
jb 0x30c565
movl 0x64(%r13), %edx
movq 0x50(%r13), %rcx
movq 0x58(%r13), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r15,8), %rsi
movq %r12, %rcx
movq -0x48(%rbp), %rbx
movq %rbx, %r8
callq 0x2f4ac5
movq 0x70(%r13), %rdi
movq -0x58(%rbp), %r9
addq $0x20, %r9
movq %rbx, %rsi
movq -0x38(%rbp), %rdx
movq %r12, %rcx
movq %rdx, %r8
callq 0x30f8be
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rdi, %rsp
movb (%rbx,%rdx), %al
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8fe6b
callq 0x8fe32
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: newBlockCompSeqHint
static union EISHint *
newBlockCompSeqHint(const struct encIdxSeq *seq)
{
  union EISHint *hintret;
  const struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  hintret = gt_malloc(sizeof (union EISHint));
  gt_SRLInitListSearchHint(seqIdx->rangeEncs, &hintret->bcHint.rangeHint);
  /* FIXME: make cache size user-configurable */
  initSuperBlockSeqCache(&hintret->bcHint.sBlockCache, seqIdx, 32);
  return hintret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x30c753
movq %rdi, %rbx
leaq 0x1ac62a(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30c753
leaq 0xd443a(%rip), %rsi     # 0x3e09d0
movl $0x28, %edi
movl $0x9c1, %edx            # imm = 0x9C1
callq 0x104226
movq %rax, %r14
movq 0x70(%rbx), %rdi
leaq 0x20(%rax), %rsi
callq 0x30ebc2
testq %r14, %r14
je 0x30c758
movabsq $0x7ffffffffffffffc, %r15 # imm = 0x7FFFFFFFFFFFFFFC
movl $0x18, %r12d
cmpq $0x0, 0x28(%rbx)
jne 0x30c667
movl 0xc0(%rbx), %ecx
addl 0xe0(%rbx), %ecx
addl 0xb8(%rbx), %ecx
movl 0xb0(%rbx), %eax
movl 0x68(%rbx), %edx
imull %eax, %edx
addl %ecx, %edx
movq 0x88(%rbx), %rcx
movq 0x90(%rbx), %rsi
addq %rsi, %rdx
addq $0x7, %rdx
movq %rdx, %rsi
shrq $0x3, %rsi
andl $0x7, %edx
cmpq $0x1, %rdx
sbbq $-0x1, %rsi
leaq 0x18(%rsi), %rdx
xorl %edi, %edi
testb $0x3, %sil
setne %dil
imull 0x6c(%rbx), %eax
andq %r15, %rdx
addq %rcx, %rax
addq $0x7, %rax
movq %rax, %rcx
shrq $0x3, %rcx
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rcx
addq %rdx, %rcx
leaq (%rcx,%rdi,4), %rax
xorl %ecx, %ecx
testb $0x7, %al
setne %cl
leaq -0x4(%r15), %rdx
andq %rax, %rdx
leaq (%rdx,%rcx,8), %r12
movq $0x20, (%r14)
movq %r12, %rdi
shlq $0x5, %rdi
movl $0x200, %r13d           # imm = 0x200
addq %r13, %rdi
leaq 0xd434b(%rip), %rsi     # 0x3e09d0
movl $0x3de, %edx            # imm = 0x3DE
callq 0x104226
movq %rax, 0x8(%r14)
leaq 0x100(%rax), %rcx
movq %rcx, 0x10(%r14)
addq %r13, %rax
movq %rax, 0x18(%r14)
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x18(%r14), %rdx
addq %rax, %rdx
movq 0x10(%r14), %rsi
movq %rdx, (%rsi,%rcx,8)
cmpq $0x0, 0x28(%rbx)
jne 0x30c72a
movq 0x10(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
leaq 0x18(%rdx), %rsi
movq %rsi, 0x10(%rdx)
movl 0xc0(%rbx), %esi
addl 0xe0(%rbx), %esi
addl 0xb8(%rbx), %esi
movl 0xb0(%rbx), %edi
imull 0x68(%rbx), %edi
addl %esi, %edi
movq 0x90(%rbx), %rsi
addq %rdi, %rsi
addq $0x7, %rsi
movq %rsi, %rdi
shrq $0x3, %rdi
andl $0x7, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %rdi
leaq 0x18(%rdi), %rsi
xorl %r8d, %r8d
testb $0x3, %dil
setne %r8b
andq %r15, %rsi
addq %rdx, %rsi
leaq (%rsi,%r8,4), %rsi
movq %rsi, 0x8(%rdx)
movq 0x8(%r14), %rdx
movq $-0x1, (%rdx,%rcx,8)
incq %rcx
addq %r12, %rax
cmpq $0x20, %rcx
jne 0x30c6a9
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x8fedd
callq 0x8fea4