LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: print_codes
static int print_codes(GtUword symbol,
                       GtUint64 freq,
                       const GtBitsequence code,
                       unsigned int code_len,
                       GT_UNUSED void *unused)
{
#ifndef S_SPLINT_S /* for GT_LLU which splint does not know */
  printf("control symbol " GT_WU ", freq "GT_LLU ", codelength %u: ",
         symbol,
         freq,
         code_len);
#else
  printf("control symbol " GT_WU ", freq " GT_WU ", codelength %u: ",
         symbol,
         (GtUword) freq,
         code_len);
#endif /* S_SPLINT_S */
  print_huff_code(code_len, code);

  printf("\n");
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x230389(%rip), %rdi    # 0x384830
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
je 0x1544e3
decb %bpl
movl $0x1, %r14d
movl %ebp, %ecx
shll %cl, %r14d
movl %r14d, %ebp
movl %r14d, %eax
andl %ebx, %eax
cmpl $0x1, %eax
movl $0x31, %edi
sbbl $0x0, %edi
callq 0x17a20
shrl %ebp
cmpl $0x1, %r14d
movl %ebp, %r14d
ja 0x1544c3
movl $0xa, %edi
callq 0x17a20
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_encode
void gt_huffman_encode(const GtHuffman *huffman,
                       GtUword symbol,
                       GtBitsequence *code,
                       unsigned int *codelength)
{
  gt_assert(huffman != NULL);
  gt_assert(symbol < huffman->num_of_symbols);
  *code = huffman->code_tab[symbol].code;
  *codelength = huffman->code_tab[symbol].numofbits;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x154517
cmpq %rsi, 0x30(%rdi)
jbe 0x15451c
movq 0x20(%rdi), %rax
shlq $0x4, %rsi
movq (%rax,%rsi), %rdi
movq %rdi, (%rdx)
movl 0x8(%rax,%rsi), %eax
movl %eax, (%rcx)
popq %rax
retq
callq 0x49010
callq 0x48fd7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_new
GtHuffmanDecoder *gt_huffman_decoder_new(GtHuffman *huffman,
                                         GtBitsequence *bitsequence,
                                         GtUword length,
                                         GtUword bit_offset,
                                         GtUword pad_length)
{
  GtHuffmanDecoder *huff_decoder = gt_malloc(sizeof (*huff_decoder));

  gt_assert(huffman != NULL);

  huff_decoder->huffman = huffman;
  huff_decoder->cur_node = huff_decoder->huffman->root_huffman_tree;
  huff_decoder->bitsequence = bitsequence;
  huff_decoder->cur_bit = bit_offset;
  huff_decoder->pad_length = pad_length;
  huff_decoder->length = length;
  huff_decoder->mem_func = NULL;
  huff_decoder->info = NULL;
  huff_decoder->cur_bitseq = 0;
  huff_decoder->mem_func_stat = 0;
  return huff_decoder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x22fd8a(%rip), %rsi    # 0x3842ea
movl $0x50, %edi
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x104226
testq %r13, %r13
je 0x1545af
movq %r13, 0x8(%rax)
movq 0x10(%r13), %rcx
movq %rcx, 0x18(%rax)
movq %r12, (%rax)
movq %r15, 0x30(%rax)
movq %rbx, 0x38(%rax)
movq %r14, 0x40(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x490bb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_new_from_memory
GtHuffmanDecoder *gt_huffman_decoder_new_from_memory(
                                     GtHuffman *huffman,
                                     GtHuffmanDecoderGetMemFunc mem_func,
                                     void *info,
                                     GtError *err)
{
  GtHuffmanDecoder *huff_decoder = gt_malloc(sizeof (*huff_decoder));

  gt_assert(huffman != NULL);

  huff_decoder->huffman = huffman;
  huff_decoder->cur_node = huff_decoder->huffman->root_huffman_tree;
  huff_decoder->mem_func = mem_func;
  huff_decoder->info = info;
  huff_decoder->cur_bitseq = 0;
  huff_decoder->mem_func_stat =
    huff_decoder->mem_func(&huff_decoder->bitsequence,
                           &huff_decoder->length,
                           &huff_decoder->cur_bit,
                           &huff_decoder->pad_length,
                           huff_decoder->info);
  if (huff_decoder->mem_func_stat == -1) {
    gt_error_set(err, "error calling mem_func");
    return NULL;
  }
  gt_assert(huff_decoder->mem_func_stat == 1);
  return huff_decoder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
leaq 0x22fd1a(%rip), %rsi    # 0x3842ea
movl $0x50, %edi
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x104226
testq %r13, %r13
je 0x15464a
movq %rax, %r14
movq %r13, 0x8(%rax)
movq 0x10(%r13), %rax
movq %rax, 0x18(%r14)
movq %r15, 0x10(%r14)
movq %r12, 0x20(%r14)
movq $0x0, 0x28(%r14)
leaq 0x40(%r14), %rsi
leaq 0x30(%r14), %rdx
movq %r14, %rcx
addq $0x38, %rcx
movq %r14, %rdi
movq %r12, %r8
callq *%r15
movl %eax, 0x48(%r14)
cmpl $0x1, %eax
je 0x15463d
cmpl $-0x1, %eax
jne 0x15464f
leaq 0x22fdd5(%rip), %rsi    # 0x384405
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4912d
callq 0x490f4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_get_new_mem_chunk
int gt_huffman_decoder_get_new_mem_chunk(GtHuffmanDecoder *huff_decoder,
                                         GtError *err)
{
  int had_err = 0;
  gt_assert(huff_decoder != NULL);
  gt_assert(huff_decoder->mem_func != NULL);

  huff_decoder->mem_func_stat =
    huff_decoder->mem_func(&huff_decoder->bitsequence,
                           &huff_decoder->length,
                           &huff_decoder->cur_bit,
                           &huff_decoder->pad_length,
                           huff_decoder->info);
  if (huff_decoder->mem_func_stat == -1) {
    gt_error_set(err, "GtHuffmanDecoder error: error calling callback "
                      "function to get new memory chunk!");
    return huff_decoder->mem_func_stat;
  }
  huff_decoder->cur_bitseq = 0;
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1546b1
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1546b6
movq %rsi, %r14
leaq 0x40(%rbx), %rsi
leaq 0x30(%rbx), %rdx
leaq 0x38(%rbx), %rcx
movq 0x20(%rbx), %r8
movq %rbx, %rdi
callq *%rax
movl %eax, 0x48(%rbx)
cmpl $-0x1, %eax
je 0x154695
movq $0x0, 0x28(%rbx)
xorl %eax, %eax
jmp 0x1546a9
leaq 0x22fdfa(%rip), %rsi    # 0x384496
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl 0x48(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4919f
callq 0x49166
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_bitwise_decoder_new
GtHuffmanBitwiseDecoder *gt_huffman_bitwise_decoder_new(GtHuffman *huffman,
                                                        GT_UNUSED GtError *err)
{
  GtHuffmanBitwiseDecoder *hbwd;
  gt_assert(huffman != NULL);
  hbwd = gt_calloc((size_t) 1, sizeof (*hbwd));
  hbwd->huffman = huffman;
  hbwd->cur_node = huffman->root_huffman_tree;
  return hbwd;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x154964
movq %rdi, %rbx
leaq 0x22f9a7(%rip), %rdx    # 0x3842ea
movl $0x1, %edi
movl $0x10, %esi
movl $0x25e, %ecx            # imm = 0x25E
callq 0x10436a
movq %rbx, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
callq 0x492a4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_bitwise_decoder_next
int gt_huffman_bitwise_decoder_next(GtHuffmanBitwiseDecoder *hbwd,
                                    bool bit, GtUword *symbol,
                                    GT_UNUSED GtError *err)
{
  int status = 0;
  gt_assert(hbwd != NULL);

  gt_assert(hbwd->cur_node != NULL);
  if (hbwd->cur_node->leftchild == NULL) {
    *symbol = hbwd->cur_node->symbol.symbol;
    hbwd->cur_node = hbwd->huffman->root_huffman_tree;
  }
  else {
    if (bit)
      hbwd->cur_node = hbwd->cur_node->rightchild;
    else
      hbwd->cur_node = hbwd->cur_node->leftchild;

    if (hbwd->cur_node->leftchild == NULL) {
      *symbol = hbwd->cur_node->symbol.symbol;
      hbwd->cur_node = hbwd->huffman->root_huffman_tree;
    }
    else
      status = 1;
  }
  return status;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1549b3
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x1549b8
movq 0x20(%rcx), %r8
testq %r8, %r8
je 0x15499d
testb %sil, %sil
je 0x15498a
movq 0x28(%rcx), %r8
movq %r8, 0x8(%rdi)
movl $0x1, %eax
cmpq $0x0, 0x20(%r8)
movq %r8, %rcx
jne 0x1549b1
movq 0x18(%rcx), %rax
movq %rax, (%rdx)
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
popq %rcx
retq
callq 0x49316
callq 0x492dd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_unit_get_next_block
static int huffman_unit_get_next_block(GtBitsequence **bits,
                                       GtUword *length,
                                       GtUword *offset,
                                       GtUword *pad_length,
                                       void *meminfo)
{
  HuffmanUnitTestMeminfo *info = (HuffmanUnitTestMeminfo*) meminfo;
  if (info->chunk == info->chunks)
    return 0;
  *offset = 0;
  if (info->chunk == info->chunks - 1) {
    *bits = info->data + (info->chunk * info->size);
    *length = info->lastchunk_size;
    *pad_length = info->padding;
  }
  else {
    *bits = info->data + (info->chunk * info->size);
    *length = info->size;
    *pad_length = 0;
  }
  info->chunk++;
  return 1;
}

// Assembly:
movq 0x8(%r8), %r9
xorl %eax, %eax
cmpq 0x10(%r8), %r9
je 0x1553fc
movq $0x0, (%rdx)
movq 0x8(%r8), %r9
movq 0x10(%r8), %r10
decq %r10
movq 0x18(%r8), %rdx
movq %rdx, %rax
imulq %r9, %rax
shlq $0x3, %rax
addq (%r8), %rax
cmpq %r10, %r9
jne 0x1553e8
movq 0x20(%r8), %rdx
movq %rdx, (%rsi)
movq 0x28(%r8), %rdx
jmp 0x1553ed
movq %rdx, (%rsi)
xorl %edx, %edx
movq %rax, (%rdi)
movq %rdx, (%rcx)
incq 0x8(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_cmp
static int huffman_tree_cmp(const void *tree1, const void *tree2,
                            GT_UNUSED void *unused)
{
  GtHuffmanTree *h1 = (GtHuffmanTree*) tree1,
                *h2 = (GtHuffmanTree*) tree2;

  gt_assert(h1 && h2);

  if (h1->symbol.freq < h2->symbol.freq)
     return (int) -1;
  if (h1->symbol.freq > h2->symbol.freq)
    return (int) 1;
  if (h1->symbol.symbol < h2->symbol.symbol)
    return (int) -1;
  if (h1->symbol.symbol > h2->symbol.symbol)
    return (int) 1;

  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x155cb8
testq %rsi, %rsi
je 0x155cb8
movq 0x10(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x10(%rdi)
jb 0x155cb7
movl $0x1, %eax
ja 0x155cb7
movq 0x18(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x18(%rdi)
jb 0x155cb7
seta %al
movzbl %al, %eax
retq
pushq %rax
callq 0x493b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_delete
static void huffman_tree_delete(void *tree)
{
  if (tree != NULL) {
    GtHuffmanTree *h_tree = (GtHuffmanTree*) tree;
    if (h_tree->reference_count > 0) {
      h_tree->reference_count--;
    }
    else {
      if (h_tree->leftchild != NULL)
        huffman_tree_delete(h_tree->leftchild);
      if (h_tree->rightchild != NULL)
        huffman_tree_delete(h_tree->rightchild);
      gt_free(h_tree);
    }
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x155cd3
movq %rdi, %rbx
movl 0x30(%rdi), %eax
testl %eax, %eax
je 0x155cd5
decl %eax
movl %eax, 0x30(%rbx)
popq %rbx
retq
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x155ce3
callq 0x155cbe
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x155cf1
callq 0x155cbe
leaq 0x22e5f2(%rip), %rsi    # 0x3842ea
movq %rbx, %rdi
movl $0x71, %edx
popq %rbx
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_stream.c
// Function: gt_id_to_md5_stream_new
GtNodeStream* gt_id_to_md5_stream_new(GtNodeStream *in_stream,
                                      GtRegionMapping *rm,
                                      bool substitute_target_ids)
{
  gt_assert(in_stream && rm);
  return gt_visitor_stream_new(in_stream,
                               gt_id_to_md5_visitor_new(rm,
                                                        substitute_target_ids));
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x155d3f
testq %rsi, %rsi
je 0x155d3f
movq %rdi, %rbx
movzbl %dl, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x155e7a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1841d5
callq 0x49420
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: gt_id_to_md5_visitor_class
const GtNodeVisitorClass* gt_id_to_md5_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSeqidsToMD5Visitor),
                                    id_to_md5_visitor_free,
                                    NULL,
                                    id_to_md5_visitor_feature_node,
                                    id_to_md5_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x368a26(%rip)    # 0x4be778
jne 0x155d87
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x155d95
leaq 0x53(%rip), %rcx        # 0x155dbd
leaq 0xac(%rip), %r8         # 0x155e1d
movl $0x20, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x3689f1(%rip)    # 0x4be778
callq 0xe2545
movq 0x3689e5(%rip), %rax    # 0x4be778
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_free
static void id_to_md5_visitor_free(GtNodeVisitor *nv)
{
  GtSeqidsToMD5Visitor *id_to_md5_visitor =
    id_to_md5_visitor_cast(nv);
  gt_assert(id_to_md5_visitor);
  gt_region_mapping_delete(id_to_md5_visitor->region_mapping);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x155d44
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x155db8
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x16d652
callq 0x49457
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_feature_node
static int id_to_md5_visitor_feature_node(GtNodeVisitor *nv,
                                              GtFeatureNode *fn,
                                              GtError *err)
{
  GtSeqidsToMD5Visitor *v = id_to_md5_visitor_cast(nv);
  gt_error_check(err);
  return seqid_to_md5((GtGenomeNode*) fn, v->region_mapping,
                      v->substitute_target_ids, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x155d44
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
testq %r14, %r14
je 0x155e00
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x155e18
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x155e0e
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x155eb4
callq 0x4948e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_region_node
static int id_to_md5_visitor_region_node(GtNodeVisitor *nv,
                                             GtRegionNode *rn,
                                             GtError *err)
{
  GtSeqidsToMD5Visitor *v = id_to_md5_visitor_cast(nv);
  gt_error_check(err);
  return seqid_to_md5((GtGenomeNode*) rn, v->region_mapping,
                      v->substitute_target_ids, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x155d44
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
testq %r14, %r14
je 0x155e60
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x155e75
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x155e6e
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x155eb4
callq 0x494c7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: gt_id_to_md5_visitor_new
GtNodeVisitor* gt_id_to_md5_visitor_new(GtRegionMapping *region_mapping,
                                        bool substitute_target_ids)
{
  GtNodeVisitor *nv;
  GtSeqidsToMD5Visitor *id_to_md5_visitor;
  nv = gt_node_visitor_create(gt_id_to_md5_visitor_class());
  id_to_md5_visitor = id_to_md5_visitor_cast(nv);
  id_to_md5_visitor->region_mapping = region_mapping;
  id_to_md5_visitor->substitute_target_ids = substitute_target_ids;
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x155d44
movq %rax, %rdi
callq 0x163080
movq %rax, %r15
callq 0x155d44
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %r14, 0x10(%rax)
movb %bl, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: gt_inter_feature_visitor_class
const GtNodeVisitorClass* gt_inter_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtInterFeatureVisitor),
                                    inter_feature_visitor_free,
                                    NULL,
                                    inter_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x368482(%rip)    # 0x4be780
jne 0x15632f
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x15633d
leaq 0x71(%rip), %rcx        # 0x156387
movl $0x30, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x368451(%rip)    # 0x4be780
callq 0xe2545
movq 0x368445(%rip), %rax    # 0x4be780
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: inter_feature_visitor_feature_node
static int inter_feature_visitor_feature_node(GtNodeVisitor *nv,
                                              GtFeatureNode *fn, GtError *err)
{
  GtInterFeatureVisitor *v;
  gt_error_check(err);
  int had_err = 0;
  v = gt_inter_feature_visitor_cast(nv);
  /* gt_feature_node_traverse_children() ignores pseudo-nodes, therefore we have
     to process the direct children of a pseudo-node separately. */
  if (gt_feature_node_is_pseudo(fn)) {
    v->parent_feature = fn;
    v->previous_feature = NULL;
    had_err = gt_feature_node_traverse_direct_children(fn, v,
                                                      inter_feature_in_children,
                                                       err);
  }
  if (!had_err) {
    had_err = gt_feature_node_traverse_children(fn, v,
                                                inter_feature_if_necessary,
                                                false, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1563a6
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x15640c
callq 0x1562f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
movq %r14, %rdi
callq 0x142b68
testb %al, %al
je 0x1563f0
movq %r14, 0x20(%r15)
movq $0x0, 0x28(%r15)
leaq 0xa2(%rip), %rdx        # 0x15647a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1438a5
testl %eax, %eax
je 0x1563f0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23b(%rip), %rdx       # 0x156632
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x142d9d
callq 0x496be
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: gt_inter_feature_visitor_new
GtNodeVisitor* gt_inter_feature_visitor_new(const char *outside_type,
                                            const char *inter_type)
{
  GtInterFeatureVisitor *aiv;
  GtNodeVisitor *nv;
  gt_assert(outside_type && inter_type);
  nv = gt_node_visitor_create(gt_inter_feature_visitor_class());
  aiv = gt_inter_feature_visitor_cast(nv);
  aiv->outside_type = gt_cstr_dup(outside_type);
  aiv->inter_type = gt_cstr_dup(inter_type);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x156475
movq %rsi, %rbx
testq %rsi, %rsi
je 0x156475
movq %rdi, %r14
callq 0x1562f0
movq %rax, %rdi
callq 0x163080
movq %rax, %r15
callq 0x1562f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r12
movq %r14, %rdi
callq 0xe4290
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xe4290
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x496f7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: inter_feature_if_necessary
static int inter_feature_if_necessary(GtFeatureNode *fn, void *data,
                                      GtError *err)
{
  GtInterFeatureVisitor *aiv = (GtInterFeatureVisitor*) data;
  gt_error_check(err);
  gt_assert(fn);
  aiv->parent_feature = fn;
  aiv->previous_feature = NULL;
  return gt_feature_node_traverse_direct_children(fn, aiv,
                                                  inter_feature_in_children,
                                                  err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x156651
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x156681
testq %r15, %r15
je 0x15667c
movq %r15, 0x20(%r14)
movq $0x0, 0x28(%r14)
leaq -0x1ef(%rip), %rdx      # 0x15647a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1438a5
callq 0x49843
callq 0x4980c
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_create
GtIntset *gt_intset_create(const GtIntsetClass *intset_c)
{
  GtIntset *intset;
  gt_assert(intset_c && intset_c->size);
  intset = gt_calloc((size_t) 1, intset_c->size);
  intset->c_class = intset_c;
  intset->members = gt_calloc((size_t) 1, sizeof (GtIntsetMembers));
  return intset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1566e0
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1566e0
leaq 0x22e606(%rip), %r14    # 0x384caa
movl $0x1, %edi
movq %r14, %rdx
movl $0x1e, %ecx
callq 0x10436a
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x48, %esi
movq %r14, %rdx
movl $0x20, %ecx
callq 0x10436a
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x4987a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_add
void gt_intset_add(GtIntset *intset, GtUword elem)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->add_func != NULL)
    intset->c_class->add_func(intset, elem);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x156731
movq (%rdi), %rax
testq %rax, %rax
je 0x156736
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x15672f
popq %rcx
jmpq *%rax
popq %rax
retq
callq 0x49956
callq 0x4991f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get
GtUword gt_intset_get(GtIntset *intset, GtUword idx)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->get_func != NULL)
    return intset->c_class->get_func(intset, idx);
  return intset->members->num_of_elems;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15675f
movq (%rdi), %rax
testq %rax, %rax
je 0x156764
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x156755
popq %rcx
jmpq *%rax
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
popq %rcx
retq
callq 0x499c4
callq 0x4998d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size
GtUword gt_intset_size(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->size_func(intset);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x156787
movq (%rdi), %rax
testq %rax, %rax
je 0x15678c
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x156783
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x49a32
callq 0x499fb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_is_member
bool gt_intset_is_member(GtIntset *intset, GtUword elem)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->is_member_func != NULL)
    return intset->c_class->is_member_func(intset, elem);
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1567af
movq (%rdi), %rax
testq %rax, %rax
je 0x1567b4
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x1567ab
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x49aa0
callq 0x49a69
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get_idx_smallest_geq
GtUword gt_intset_get_idx_smallest_geq(GtIntset *intset, GtUword pos)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->idx_sm_geq_func != NULL)
    return intset->c_class->idx_sm_geq_func(intset, pos);
  return GT_UWORD_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1567dc
movq (%rdi), %rax
testq %rax, %rax
je 0x1567e1
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1567d3
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x49b0e
callq 0x49ad7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_write
GtIntset *gt_intset_write(GtIntset *intset, FILE *fp, GtError *err)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->write_func(intset, fp, err);
  return intset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x156807
movq (%rdi), %rax
testq %rax, %rax
je 0x15680c
cmpq $0x0, 0x40(%rax)
je 0x156802
movq 0x50(%rax), %rax
popq %rcx
jmpq *%rax
movq %rdi, %rax
popq %rcx
retq
callq 0x49b7c
callq 0x49b45
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_rep
size_t gt_intset_size_of_rep(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->rep_size_func(intset->members->maxelement,
                                          intset->members->num_of_elems);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15683b
movq (%rdi), %rax
testq %rax, %rax
je 0x156840
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x156837
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x28(%rcx), %rsi
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x49bea
callq 0x49bb3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_struct
size_t gt_intset_size_of_struct(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->struct_size_func();
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x156862
movq (%rdi), %rax
testq %rax, %rax
je 0x156867
cmpq $0x0, 0x38(%rax)
je 0x15685e
popq %rcx
jmpq *0x48(%rax)
xorl %eax, %eax
popq %rcx
retq
callq 0x49c58
callq 0x49c21
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_delete
void gt_intset_delete(GtIntset *intset)
{
  if (intset != NULL) {
    if (intset->members->refcount) {
      intset->members->refcount--;
      return;
    }
    gt_assert(intset->c_class);
    if (intset->c_class->delete_func != NULL)
      intset->c_class->delete_func(intset);
    gt_free(intset->members->sectionstart);
    gt_free(intset->members);
    gt_free(intset);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1568f4
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x1568fc
decq %rcx
movq %rcx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x156955
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
je 0x156916
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq (%rax), %rdi
leaq 0x22e38a(%rip), %r14    # 0x384caa
movq %r14, %rsi
movl $0xa3, %edx
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0xa4, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x49c8f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_unit_test_notinset
int gt_intset_unit_test_notinset(GtIntset *intset, GtUword start,
                                 GtUword end, GtError *err)
{
  int had_err = 0;
  GtUword test;
  for (test = start; test <= end; ++test) {
    gt_ensure(gt_intset_is_member(intset, test) == false);
  }
  return had_err;
}

// Assembly:
xorl %eax, %eax
cmpq %rdx, %rsi
ja 0x1569e9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x22e4a3(%rip), %r13    # 0x384e26
leaq 0x22e320(%rip), %rbp    # 0x384caa
xorl %eax, %eax
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1569d3
movq %r12, %rdi
movq %r15, %rsi
callq 0x156791
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x1569d3
movq %rbx, %rdi
leaq 0x207a8a(%rip), %rsi    # 0x35e43e
leaq 0x22e440(%rip), %rdx    # 0x384dfb
movq %r13, %rcx
movq %rbp, %r8
movl $0xaf, %r9d
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %r15
cmpq %r14, %r15
jbe 0x15698c
addq $0x8, %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/intset.c
// Function: gt_intset_unit_test_check_seqnum
int gt_intset_unit_test_check_seqnum(GtIntset *intset, GtUword start,
                                     GtUword end, GtUword num, GtError *err)
{
  int had_err = 0;
  GtUword test;
  for (test = start; test <= end; ++test) {
    gt_ensure(gt_intset_get_idx_smallest_geq(intset, test) == num);
  }
  return had_err;
}

// Assembly:
xorl %eax, %eax
cmpq %rdx, %rsi
ja 0x156a7b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x22e294(%rip), %rbp    # 0x384caa
xorl %eax, %eax
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x156a65
movq %r13, %rdi
movq %r12, %rsi
callq 0x1567b9
movq %rax, %rcx
xorl %eax, %eax
cmpq %r14, %rcx
je 0x156a65
movq %rbx, %rdi
leaq 0x2079fc(%rip), %rsi    # 0x35e43e
leaq 0x22e3fa(%rip), %rdx    # 0x384e43
leaq 0x22e427(%rip), %rcx    # 0x384e77
movq %rbp, %r8
movl $0xba, %r9d
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %r12
cmpq %r15, %r12
jbe 0x156a18
addq $0x8, %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/intset_combined.c
// Function: gt_intset_best_new
GtIntset *gt_intset_best_new(GtUword maxelement, GtUword num_of_elems)
{
  size_t s8, s16, s32;
  gt_assert(GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t));
  s8 = gt_intset_8_size_of_rep(maxelement, num_of_elems);
  s16 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t) ?
    gt_intset_16_size_of_rep(maxelement, num_of_elems) :
    s8;
  s32 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t) ?
    gt_intset_32_size_of_rep(maxelement, num_of_elems) :
    s8;
  if (s8 <= s16) {
    if (s8 <= s32)
      return gt_intset_8_new(maxelement, num_of_elems);
  }
  else {
    if (s16 <= s32)
      return gt_intset_16_new(maxelement, num_of_elems);
  }
  return gt_intset_32_new(maxelement, num_of_elems);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3022c3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ffe40
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x301097
cmpq %r12, %r15
jbe 0x156acb
cmpq %rax, %r12
ja 0x156ad0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ff32c
cmpq %rax, %r15
jbe 0x156ae6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x300580
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3017d4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_best_memory_size
size_t gt_intset_best_memory_size(GtUword maxelement, GtUword num_of_elems)
{
  size_t s8, s16, s32;
  gt_assert(GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t));
  s8 = gt_intset_8_size_of_rep(maxelement, num_of_elems);
  s16 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t) ?
    gt_intset_16_size_of_rep(maxelement, num_of_elems) :
    s8;
  s32 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t) ?
    gt_intset_32_size_of_rep(maxelement, num_of_elems) :
    s8;
  if (s8 <= s16) {
    if (s8 <= s32)
      return s8;
  }
  else {
    if (s16 <= s32)
      return s16;
  }
  return s32;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x3022c3
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2ffe40
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x301097
cmpq %r14, %rbx
jbe 0x156b3a
cmpq %rax, %r14
ja 0x156b42
movq %r14, %rax
jmp 0x156b42
cmpq %rax, %rbx
ja 0x156b42
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_io
GtIntset *gt_intset_io(GtIntset *intset, FILE *fp, GtError *err)
{
  int had_err = 0;
  GtUword type;
  if (intset == NULL) {
    had_err = gt_intset_read_type_rewind(fp, &type, err);
    if (!had_err && gt_intset_8_file_is_type(type))
      intset = gt_intset_8_io(intset, fp, err);
    else {
      if (!had_err && gt_intset_16_file_is_type(type))
        intset = gt_intset_16_io(intset, fp, err);
      else {
        if (!had_err && gt_intset_32_file_is_type(type))
          intset = gt_intset_32_io(intset, fp, err);
        else {
          if (!gt_error_is_set(err))
            gt_error_set(err, "could not identify intset type from file");
        }
      }
    }
  }
  else {
    gt_assert(intset->c_class != NULL);
    gt_assert(intset->c_class->io_func != NULL);
    intset = intset->c_class->io_func(intset, fp, err);
  }
  return intset;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x156b95
movq (%rdi), %rax
testq %rax, %rax
je 0x156c7a
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x156c7f
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17640
testl %eax, %eax
je 0x156bb9
leaq 0x22e375(%rip), %rsi    # 0x384f22
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0x156bd5
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x156d03
testl %eax, %eax
je 0x156c05
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
je 0x156be6
xorl %r14d, %r14d
jmp 0x156bfa
leaq 0x22e2ab(%rip), %rsi    # 0x384e98
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17420
testl %eax, %eax
je 0x156c1f
leaq 0x22e314(%rip), %rsi    # 0x384f31
jmp 0x156bad
movq (%rsp), %rdi
callq 0x3022d6
testb %al, %al
je 0x156c3b
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x301b4b
jmp 0x156c75
movq (%rsp), %rdi
callq 0x2ffe56
testb %al, %al
je 0x156c57
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ff6a7
jmp 0x156c75
movq (%rsp), %rdi
callq 0x3010ae
testb %al, %al
je 0x156bd5
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x300900
movq %rax, %r14
jmp 0x156bfa
callq 0x49cff
callq 0x49cc8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_unit_test
int gt_intset_unit_test(GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  if (GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t))
    had_err = gt_intset_8_unit_test(err);
  if (!had_err && GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t))
    had_err = gt_intset_16_unit_test(err);
  if (!had_err && GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t))
    had_err = gt_intset_32_unit_test(err);
  return had_err;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x156c99
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x156cbc
movq %rbx, %rdi
callq 0x3022de
testl %eax, %eax
jne 0x156cb1
movq %rbx, %rdi
callq 0x2ffe5e
testl %eax, %eax
je 0x156cb3
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x3010b6
callq 0x49d36
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_delete
void gt_kmer_database_delete(GtKmerDatabase *kdb)
{
  if (kdb != NULL) {
    gt_free(kdb->offset);
    gt_free(kdb->seen_kmer_counts);
    gt_free(kdb->positions);
    gt_free(kdb->unique_ids);
    gt_free(kdb->sb.kmers);
    gt_bittab_delete(kdb->deleted_positions);
    GT_FREEARRAY(kdb->sb.intervals, GtRange);
    gt_free(kdb->sb.intervals);
    GT_FREEARRAY(kdb->sb.ids, GtUword);
    gt_free(kdb->sb.ids);
    gt_encseq_delete(kdb->sb.es);
    gt_kmercodeiterator_delete(kdb->sb.kmer_iter);
    gt_free(kdb);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x157065
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x22e09c(%rip), %r14    # 0x384fe0
movq %r14, %rsi
movl $0x86, %edx
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x87, %edx
callq 0x1045eb
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x89, %edx
callq 0x1045eb
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x8a, %edx
callq 0x1045eb
movq 0x20(%rbx), %rdi
callq 0xd7151
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x156fd9
leaq 0x22e029(%rip), %rsi    # 0x384fe0
movq %rax, %rdi
movl $0x8c, %edx
callq 0x1045eb
movq 0x80(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x22e000(%rip), %rsi    # 0x384fe0
movl $0x8d, %edx
callq 0x1045eb
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x157022
leaq 0x22dfe0(%rip), %rsi    # 0x384fe0
movq %rax, %rdi
movl $0x8e, %edx
callq 0x1045eb
movq 0x88(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x22dfb7(%rip), %r14    # 0x384fe0
movq %r14, %rsi
movl $0x8f, %edx
callq 0x1045eb
movq 0x90(%rbx), %rdi
callq 0xea375
movq 0x98(%rbx), %rdi
callq 0x1eeaa9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x92, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_flush
void gt_kmer_database_flush(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->sb.intervals->nextfreeGtRange ==
            kdb->sb.ids->nextfreeGtUword);

  if (kdb->sb.intervals->nextfreeGtRange != 0) {
    GtUword interval_idx;
    kdb->sb.kmer_count = 0;
    kdb->sb.offset = kdb->sb.intervals->spaceGtRange[0].start;

    for (interval_idx = 0;
         interval_idx < kdb->sb.intervals->nextfreeGtRange;
         interval_idx++) {
      GtUword startpos = kdb->sb.intervals->spaceGtRange[interval_idx].start,
              endpos = kdb->sb.intervals->spaceGtRange[interval_idx].end,
              id = kdb->sb.ids->spaceGtUword[interval_idx];
      const GtKmercode *kmercode = NULL;

      gt_kmercodeiterator_reset(kdb->sb.kmer_iter, GT_READMODE_FORWARD,
                                startpos);
      gt_assert(!gt_kmercodeiterator_inputexhausted(kdb->sb.kmer_iter));

      while ((kmercode =
              gt_kmercodeiterator_encseq_next(kdb->sb.kmer_iter)) != NULL &&
             startpos <= endpos - (kdb->sb.kmer_size - 1)) {
        if (!kmercode->definedspecialposition) {
          gt_kmer_database_add_kmer_to_sb(kdb, kmercode->code, startpos, id);
        }
        startpos++;
      }
    }
    gt_kmer_database_intervals_reset(kdb);
    gt_kmer_database_sort_sb(kdb);
    gt_kmer_database_merge(kdb);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x15719d
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rdx
movq 0x10(%rax), %rcx
cmpq 0x10(%rdx), %rcx
jne 0x1571a2
testq %rcx, %rcx
je 0x15718e
movq $0x0, 0xb0(%rbx)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc0(%rbx)
xorl %r12d, %r12d
movq (%rax), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r13
movq 0x88(%rbx), %rax
movq 0x98(%rbx), %rdi
movq (%rax), %rax
movq (%rax,%r12,8), %r15
xorl %esi, %esi
movq %r14, %rdx
callq 0x1ee34c
movq 0x98(%rbx), %rdi
callq 0x1eebc2
testb %al, %al
jne 0x157198
movq 0x98(%rbx), %rdi
callq 0x1ee7e3
testq %rax, %rax
je 0x157141
movl 0xd0(%rbx), %ecx
decl %ecx
movq %r13, %rdx
subq %rcx, %rdx
cmpq %rdx, %r14
ja 0x157141
cmpb $0x0, (%rax)
jne 0x15713c
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1571a7
incq %r14
jmp 0x157101
incq %r12
movq 0x80(%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x1570bb
movq 0x88(%rbx), %rcx
movq 0xb0(%rbx), %rsi
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rdx, 0x10(%rcx)
movq %rdx, 0xc8(%rbx)
movq 0xa0(%rbx), %rdi
callq 0x10fd8b
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1571f8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x49e14
callq 0x49e4d
callq 0x49ddb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_add_kmer_to_sb
static void gt_kmer_database_add_kmer_to_sb(GtKmerDatabase *kdb,
                                            GtCodetype kmercode,
                                            GtUword startpos,
                                            GtUword id)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->sb.kmer_count <= kdb->sb.max_nu_kmers);

  startpos -= kdb->sb.offset;
  kdb->sb.kmers[kdb->sb.kmer_count].a = gt_kmer_database_encode_kmer(kmercode,
                                                                     startpos);
  kdb->sb.kmers[kdb->sb.kmer_count].b = id;
  kdb->sb.kmer_count++;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1571ee
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
ja 0x1571f3
subq 0xc0(%rdi), %rdx
shlq $0x20, %rsi
orq %rdx, %rsi
movq 0xa0(%rdi), %rdx
movq %rax, %r8
shlq $0x4, %r8
movq %rsi, (%rdx,%r8)
movq %rcx, 0x8(%rdx,%r8)
incq %rax
movq %rax, 0xb0(%rdi)
popq %rax
retq
callq 0x49ebf
callq 0x49e86
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_startpos
GtKmerStartpos gt_kmer_database_get_startpos(GtKmerDatabase *kdb,
                                             GtCodetype kmercode)
{
  GtKmerStartpos sp;

  gt_assert(kdb != NULL);
  gt_assert(kmercode < kdb->nu_kmer_codes);
  gt_assert(kdb->positions != NULL);
  gt_assert(kdb->unique_ids != NULL);

  sp.startpos = kdb->positions + kdb->offset[kmercode];
  sp.unique_ids = kdb->unique_ids + kdb->offset[kmercode];
  sp.no_positions = kdb->offset[kmercode + 1] - kdb->offset[kmercode];
  if (kdb->mean_cutoff &&
      sp.no_positions > kdb->min_cutoff &&
      sp.no_positions > (kdb->cutoff / GT_KMER_DATABASE_DELETE_BUFFFER))
    sp.no_positions = 0;
  else if (kdb->cutoff_is_set && sp.no_positions > kdb->cutoff)
    sp.no_positions = 0;

  return sp;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x157bdb
cmpq %rdx, 0x28(%rsi)
jbe 0x157be0
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x157be5
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x157bea
movq (%rsi), %r8
movq (%r8,%rdx,8), %r9
leaq (%rax,%r9,8), %rax
movq %rax, (%rdi)
leaq (%rcx,%r9,8), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%r8,%rdx,8), %rax
subq %r9, %rax
movq %rax, 0x10(%rdi)
cmpb $0x1, 0x79(%rsi)
jne 0x157bc2
cmpq 0x50(%rsi), %rax
jbe 0x157bc2
cmpq 0x48(%rsi), %rax
ja 0x157bce
cmpb $0x1, 0x78(%rsi)
jne 0x157bd6
cmpq 0x48(%rsi), %rax
jbe 0x157bd6
movq $0x0, 0x10(%rdi)
movq %rdi, %rax
popq %rcx
retq
callq 0x4a288
callq 0x4a1dd
callq 0x4a24f
callq 0x4a216
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_set_cutoff
void gt_kmer_database_set_cutoff(GtKmerDatabase *kdb, GtUword cutoff)
{
  gt_assert(kdb != NULL);
  gt_assert(cutoff != 0);

  kdb->cutoff = cutoff;
  kdb->cutoff_is_set = true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x157c04
testq %rsi, %rsi
je 0x157c09
movq %rsi, 0x48(%rdi)
movb $0x1, 0x78(%rdi)
popq %rax
retq
callq 0x4a2fa
callq 0x4a2c1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_use_mean_cutoff
void gt_kmer_database_use_mean_cutoff(GtKmerDatabase *kdb,
                                      GtUword mean_fraction, GtUword min_cutoff)
{
  gt_assert(kdb != NULL);
  gt_assert(mean_fraction != 0);
  gt_assert(min_cutoff != 0);

  kdb->cutoff_is_set = true;
  kdb->mean_cutoff = true;
  kdb->mean_fraction = mean_fraction;
  kdb->min_cutoff = min_cutoff;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x157c3e
testq %rsi, %rsi
je 0x157c43
testq %rdx, %rdx
je 0x157c48
movw $0x101, 0x78(%rdi)      # imm = 0x101
movq %rsi, 0x58(%rdi)
movq %rdx, 0x50(%rdi)
popq %rax
retq
callq 0x4a3de
callq 0x4a3a5
callq 0x4a36c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_mean_nu_of_occ
GtUword gt_kmer_database_get_mean_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->seen_kmers <= kdb->nu_kmer_codes);

  if (kdb->seen_kmers == 0)
    return 0;
  return kdb->seen_kmer_counts[kdb->nu_kmer_codes] / kdb->seen_kmers;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x157cbb
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rax, %rcx
ja 0x157cc0
testq %rcx, %rcx
je 0x157cb7
movq 0x8(%rdi), %rdx
movq (%rdx,%rax,8), %rax
xorl %edx, %edx
divq %rcx
jmp 0x157cb9
xorl %eax, %eax
popq %rcx
retq
callq 0x4a534
callq 0x4a4fb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_min_nu_of_occ
GtUword gt_kmer_database_get_min_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->min_nu_occ <= kdb->seen_kmer_counts[kdb->nu_kmer_codes]);

  if (kdb->offset[kdb->nu_kmer_codes] == 0)
    return 0;
  return kdb->min_nu_occ;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x157ced
movq 0x60(%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
cmpq (%rdx,%rcx,8), %rax
ja 0x157cf2
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
cmoveq %rcx, %rax
popq %rcx
retq
callq 0x4a5a6
callq 0x4a56d