LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_schema.c
// Function: gt_anno_db_schema_get_feature_index
GtFeatureIndex* gt_anno_db_schema_get_feature_index(GtAnnoDBSchema *s,
                                                    GtRDB *rdb, GtError *err)
{
  gt_assert(s && s->c_class);
  if (s->c_class->build_func)
    return s->c_class->build_func(s, rdb, err);
  return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0xba6a1
movq (%rdi), %rax
testq %rax, %rax
je 0xba6a1
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xba69e
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x37d8bf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a960(%rip), %rsi    # 0x2e5013
leaq 0x25ccde(%rip), %rdx    # 0x317398
leaq 0x25cce7(%rip), %rcx    # 0x3173a8
leaq 0x25cc50(%rip), %r8     # 0x317318
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_in_stream.c
// Function: gt_array_in_stream_class
const GtNodeStreamClass* gt_array_in_stream_class(void)
{
  static const GtNodeStreamClass *gsc = NULL;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtArrayInStream),
                                   NULL,
                                   gt_array_in_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x382f7a(%rip)    # 0x43d660
jne 0xba700
leaq 0x1f(%rip), %rdx        # 0xba70e
pushq $0x28
popq %rdi
xorl %esi, %esi
callq 0x102838
movq %rax, 0x382f60(%rip)    # 0x43d660
callq 0x69ede
movq 0x382f54(%rip), %rax    # 0x43d660
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_in_stream.c
// Function: gt_array_in_stream_next
static int gt_array_in_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
                                   GT_UNUSED GtError *err)
{
  GtArrayInStream *ais;
  int had_err = 0;

  gt_error_check(err);
  ais = gt_array_in_stream_cast(gs);
  if (ais->next_index >= gt_array_size(ais->nodes))
    *gn = NULL;
  else {
    *gn = *(GtGenomeNode**) gt_array_get(ais->nodes, ais->next_index);
    ais->next_index++;
    if (ais->progress)
      *ais->progress = *ais->progress + 1;
  }

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xba72a
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xba780
callq 0xba6d8
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r14
movq 0x10(%rax), %rdi
movq 0x18(%rax), %r15
callq 0x586a4
cmpq %rax, %r15
jae 0xba774
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x581aa
movq (%rax), %rax
movq %rax, (%rbx)
incq 0x18(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xba778
incq (%rax)
jmp 0xba778
andq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x37d7e1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a882(%rip), %rsi    # 0x2e5013
leaq 0x22aa27(%rip), %rdx    # 0x2e51bf
leaq 0x25cc63(%rip), %rcx    # 0x317402
leaq 0x25cc3d(%rip), %r8     # 0x3173e3
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_in_stream.c
// Function: gt_array_in_stream_new
GtNodeStream* gt_array_in_stream_new(GtArray *nodes,
                                     GtUword *progress,
                                     GT_UNUSED GtError *err)
{
  GtNodeStream *gs;
  GtArrayInStream *ais;
  gt_assert(nodes);
  gs = gt_node_stream_create(gt_array_in_stream_class(), false);
  ais = gt_array_in_stream_cast(gs);
  ais->nodes = nodes;
  ais->progress = progress;
  ais->next_index = 0;

  return gs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xba7fe
movq %rsi, %rbx
movq %rdi, %r14
callq 0xba6d8
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %r15
callq 0xba6d8
movq %rax, %rdi
movq %r15, %rsi
callq 0x102c81
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
andq $0x0, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x37d763(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a804(%rip), %rsi    # 0x2e5013
leaq 0x25cc4a(%rip), %rdx    # 0x317460
leaq 0x25cbaf(%rip), %rcx    # 0x3173cc
leaq 0x25cbbf(%rip), %r8     # 0x3173e3
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_out_stream.c
// Function: gt_array_out_stream_class
const GtNodeStreamClass* gt_array_out_stream_class(void)
{
  static const GtNodeStreamClass *gsc = NULL;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtArrayOutStream),
                                   gt_array_out_stream_free,
                                   gt_array_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x382e26(%rip)    # 0x43d668
jne 0xba861
leaq 0x24(%rip), %rsi        # 0xba86f
leaq 0x3b(%rip), %rdx        # 0xba88d
pushq $0x28
popq %rdi
callq 0x102838
movq %rax, 0x382e07(%rip)    # 0x43d668
callq 0x69ede
movq 0x382dfb(%rip), %rax    # 0x43d668
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_out_stream.c
// Function: gt_array_out_stream_next
static int gt_array_out_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
                                    GtError *err)
{
  GtArrayOutStream *aos;
  GT_UNUSED GtFeatureNode *node;
  GtGenomeNode  *gn_ref;
  int had_err = 0;

  gt_error_check(err);
  aos = gt_array_out_stream_cast(gs);
  had_err = gt_node_stream_next(aos->in_stream, gn, err);

  if (!had_err && *gn) {
    if (aos->store_all || (node = gt_feature_node_try_cast(*gn))) {
      gn_ref = gt_genome_node_ref(*gn);
      gt_array_add(aos->nodes, gn_ref);
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xba8ae
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0xba916
callq 0xba834
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r14
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x102a22
movl %eax, %ebp
testl %eax, %eax
jne 0xba909
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xba909
cmpb $0x0, 0x20(%r14)
jne 0xba8f2
callq 0xdc2f0
testq %rax, %rax
je 0xba909
movq (%rbx), %rdi
callq 0xdccf8
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x18(%r14), %rdi
pushq $0x8
popq %rdx
callq 0x5851d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x37d64b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a6ec(%rip), %rsi    # 0x2e5013
leaq 0x22a891(%rip), %rdx    # 0x2e51bf
leaq 0x25cae5(%rip), %rcx    # 0x31741a
leaq 0x25caf7(%rip), %r8     # 0x317433
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/array_out_stream.c
// Function: gt_array_out_stream_new_generic
static GtNodeStream* gt_array_out_stream_new_generic(GtNodeStream *in_stream,
                                                     GtArray *nodes,
                                                     bool store_all,
                                                     GT_UNUSED GtError *err)
{
  GtNodeStream *gs;
  GtArrayOutStream *aos;
  gt_assert(in_stream && nodes);
  gs = gt_node_stream_create(gt_array_out_stream_class(), false);
  aos = gt_array_out_stream_cast(gs);
  aos->in_stream = gt_node_stream_ref(in_stream);
  aos->nodes = nodes;
  aos->store_all = store_all;
  return gs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xba9b1
movq %rsi, %r14
testq %rsi, %rsi
je 0xba9b1
movl %edx, %ebx
movq %rdi, %r15
callq 0xba834
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %r12
callq 0xba834
movq %rax, %rdi
movq %r12, %rsi
callq 0x102c81
movq %rax, %r13
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%r13)
movq %r14, 0x18(%r13)
movb %bl, 0x20(%r13)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x37d5b0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a651(%rip), %rsi    # 0x2e5013
leaq 0x25ca8a(%rip), %rdx    # 0x317453
leaq 0x25ca96(%rip), %rcx    # 0x317466
leaq 0x25ca5c(%rip), %r8     # 0x317433
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_new
GtAssemblyStatsCalculator *gt_assembly_stats_calculator_new(void)
{
  GtAssemblyStatsCalculator *asc;

  asc = gt_malloc(sizeof (GtAssemblyStatsCalculator));
  asc->lengths = gt_disc_distri_new();
  asc->numofseq = 0;
  asc->sumlength = 0;
  asc->minlength = 0;
  asc->maxlength = 0;
  asc->genome_length = 0;
  asc->nstats = gt_array_new(sizeof (GtUword));
  return asc;
}

// Assembly:
pushq %rbx
leaq 0x25caec(%rip), %rsi    # 0x3174e4
pushq $0x38
popq %rdi
pushq $0x28
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0x6d958
movq %rax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_delete
void gt_assembly_stats_calculator_delete(GtAssemblyStatsCalculator *asc)
{
  if (asc != NULL)
  {
    gt_disc_distri_delete(asc->lengths);
    gt_array_delete(asc->nstats);
    gt_free(asc);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xbaa5d
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x6e064
movq 0x30(%rbx), %rdi
callq 0x58eb9
leaq 0x25ca93(%rip), %rsi    # 0x3174e4
pushq $0x39
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_add
void gt_assembly_stats_calculator_add(GtAssemblyStatsCalculator *asc,
    GtUword length)
{
  gt_assert(asc != NULL);
  gt_assert(length != 0);
  gt_disc_distri_add(asc->lengths, length);
  (asc->numofseq)++;
  asc->sumlength += length;
  if (asc->minlength == 0 || length < asc->minlength)
    asc->minlength = length;
  if (length > asc->maxlength)
    asc->maxlength = length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbaabf
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbaae9
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq %rbx, %rsi
callq 0x6d96d
movdqu (%r14), %xmm0
movq %rbx, %xmm1
movdqa 0x25ca00(%rip), %xmm2   # 0x317490
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, (%r14)
movq 0x10(%r14), %rax
decq %rax
cmpq %rbx, %rax
jb 0xbaaad
movq %rbx, 0x10(%r14)
cmpq %rbx, 0x18(%r14)
jae 0xbaab7
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x37d4a2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a543(%rip), %rsi    # 0x2e5013
leaq 0x25ca36(%rip), %rdx    # 0x31750d
leaq 0x25ca3b(%rip), %rcx    # 0x317519
leaq 0x25c9ff(%rip), %r8     # 0x3174e4
pushq $0x40
jmp 0xbab11
movq 0x37d478(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a519(%rip), %rsi    # 0x2e5013
leaq 0x28d20f(%rip), %rdx    # 0x347d10
leaq 0x25ca11(%rip), %rcx    # 0x317519
leaq 0x25c9d5(%rip), %r8     # 0x3174e4
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_nstat
GtUword gt_assembly_stats_calculator_nstat(GtAssemblyStatsCalculator *asc,
    GtUword n)
{
  Nstats nstats;
  gt_assert(n > 0);
  gt_assert(n < (GtUword)100UL);
  nstats.min[0] = (GtUint64) (asc->sumlength * ((float)n / 100U));
  nstats.nvalue[0] = 0;
  nstats.lvalue[0] = 0;
  nstats.done[0] = false;
  nstats.nofstats = 1U;
  nstats.current_len = 0;
  nstats.current_num = 0;
  nstats.half_num = (GtUint64) (asc->numofseq >> 1);
  nstats.fourth_num = nstats.half_num >> 1;
  nstats.three_fourth_num = nstats.fourth_num + nstats.half_num;
  nstats.median = 0;
  nstats.first_quartile = 0;
  nstats.third_quartile = 0;
  gt_disc_distri_foreach_in_reverse_order(asc->lengths, calcNstats, &nstats);
  return nstats.nvalue[0];
}

// Assembly:
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
testq %rsi, %rsi
je 0xbac5b
cmpq $0x64, %rsi
jae 0xbac89
movq 0x8(%rdi), %rax
testq %rax, %rax
js 0xbab8b
cvtsi2ss %rax, %xmm0
jmp 0xbaba0
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rsi, %xmm1
divss 0x23971b(%rip), %xmm1   # 0x2f42c8
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
subss 0x25c91f(%rip), %xmm1   # 0x3174e0
cvttss2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
leaq 0x8(%rsp), %rbx
movq %rdx, 0xe0(%rbx)
andq $0x0, 0x140(%rbx)
andq $0x0, 0x190(%rbx)
movb $0x0, 0x50(%rbx)
movl $0x1, 0x230(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq (%rdi), %rax
movq %rax, %rcx
shrq %rcx
movq %rcx, 0x80(%rbx)
shrq $0x2, %rax
movq %rax, 0x78(%rbx)
addq %rcx, %rax
movq %rax, 0x138(%rbx)
andq $0x0, 0xd8(%rbx)
andq $0x0, 0x70(%rbx)
andq $0x0, 0x130(%rbx)
movq 0x28(%rdi), %rdi
leaq 0x7e(%rip), %rsi        # 0xbacc1
movq %rbx, %rdx
callq 0x6dd4f
movq 0x140(%rbx), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
retq
movq 0x37d306(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a3a7(%rip), %rsi    # 0x2e5013
leaq 0x25c93b(%rip), %rdx    # 0x3175ae
leaq 0x25c8ef(%rip), %rcx    # 0x317569
leaq 0x25c863(%rip), %r8     # 0x3174e4
movl $0x9f, %r9d
jmp 0xbacb5
movq 0x37d2d8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a379(%rip), %rsi    # 0x2e5013
leaq 0x25c8eb(%rip), %rdx    # 0x31758c
leaq 0x25c8c1(%rip), %rcx    # 0x317569
leaq 0x25c835(%rip), %r8     # 0x3174e4
movl $0xa0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: calcNstats
static void calcNstats(GtUword key, GtUint64 value,
                        void *data)
{
  Nstats *nstats = data;
  unsigned int i;
  nstats->current_len += (key * value);
  nstats->current_num += value;
  for (i = 0; i < (unsigned int) NOF_LIMITS; i++)
  {
    if ((GtUint64) key > nstats->limit[i])
      nstats->larger_than_limit[i] = nstats->current_num;
  }
  if (nstats->third_quartile == 0 && nstats->current_num >= nstats->fourth_num)
  {
    nstats->third_quartile = (GtUint64) key;
  }
  if (nstats->median == 0 && nstats->current_num >= nstats->half_num)
  {
    nstats->median = (GtUint64) key;
  }
  if (nstats->first_quartile == 0 && nstats->current_num >=
      nstats->three_fourth_num)
  {
    nstats->first_quartile = (GtUint64) key;
  }
  for (i = 0; i < nstats->nofstats; i++)
  {
    if (!nstats->done[i] && (nstats->current_len >= nstats->min[i]))
    {
      nstats->done[i] = true;
      nstats->nvalue[i] = key;
      nstats->lvalue[i] = (GtUword) nstats->current_num;
    }
  }
}

// Assembly:
movq %rsi, %rax
imulq %rdi, %rax
addq 0x60(%rdx), %rax
movq %rax, 0x60(%rdx)
addq 0x68(%rdx), %rsi
movq %rsi, 0x68(%rdx)
pushq $-0x28
popq %rcx
testq %rcx, %rcx
je 0xbacf8
cmpq %rdi, 0xd8(%rdx,%rcx)
jae 0xbacf2
movq %rsi, 0xb0(%rdx,%rcx)
addq $0x8, %rcx
jmp 0xbacdb
cmpq $0x0, 0x130(%rdx)
jne 0xbad0f
cmpq 0x78(%rdx), %rsi
jb 0xbad0f
movq %rdi, 0x130(%rdx)
cmpq $0x0, 0xd8(%rdx)
jne 0xbad29
cmpq 0x80(%rdx), %rsi
jb 0xbad29
movq %rdi, 0xd8(%rdx)
cmpq $0x0, 0x70(%rdx)
jne 0xbad3d
cmpq 0x138(%rdx), %rsi
jb 0xbad3d
movq %rdi, 0x70(%rdx)
movl 0x230(%rdx), %ecx
xorl %r8d, %r8d
cmpq %rcx, %r8
jae 0xbad78
cmpb $0x0, 0x50(%rdx,%r8)
jne 0xbad73
cmpq 0xe0(%rdx,%r8,8), %rax
jb 0xbad73
movb $0x1, 0x50(%rdx,%r8)
movq %rdi, 0x140(%rdx,%r8,8)
movq %rsi, 0x190(%rdx,%r8,8)
incq %r8
jmp 0xbad46
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_register_nstat
int gt_assembly_stats_calculator_register_nstat(GtAssemblyStatsCalculator *asc,
                                                GtUword n, GtError *err)
{
  GtUword i;
  bool present;
  gt_assert(asc != NULL && n > 0);

  if (n > 100) {
    gt_error_set(err, "invalid N value " GT_WU ", must be <= 100", n);
    return -1;
  }

  if (gt_array_size(asc->nstats) == MAX_NOF_NSTATS) {
    gt_error_set(err, "Limit of N statistics reached (%d)", MAX_NOF_NSTATS);
    return -1;
  }

  present = false;
  for (i = 0; i < gt_array_size(asc->nstats); i++) {
    if ((*(GtUword*) gt_array_get(asc->nstats, i)) == n) {
      present = true;
      break;
    }
  }
  if (!present) {
    gt_array_add(asc->nstats, n);
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0xbae26
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbae26
movq %rdx, %r15
cmpq $0x65, %rbx
jb 0xbadbb
leaq 0x25c834(%rip), %rsi    # 0x3175e0
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0xbade1
movq %rdi, %r14
movq 0x30(%rdi), %rdi
callq 0x586a4
cmpq $0xa, %rax
jne 0xbade6
leaq 0x25c830(%rip), %rsi    # 0x317604
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0xbae1c
xorl %r15d, %r15d
movq 0x30(%r14), %rdi
callq 0x586a4
movq 0x30(%r14), %rdi
cmpq %rax, %r15
jae 0xbae0d
movq %r15, %rsi
callq 0x581aa
incq %r15
cmpq %rbx, (%rax)
jne 0xbade9
jmp 0xbae1a
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x5851d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x37d13b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a1dc(%rip), %rsi    # 0x2e5013
leaq 0x25c761(%rip), %rdx    # 0x31759f
leaq 0x25c76f(%rip), %rcx    # 0x3175b4
leaq 0x25c698(%rip), %r8     # 0x3174e4
movl $0xb7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_in_stream.c
// Function: gt_bed_in_stream_class
const GtNodeStreamClass* gt_bed_in_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtBEDInStream),
                                   bed_in_stream_free,
                                   bed_in_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x3820a6(%rip)    # 0x43d670
jne 0xbb5e9
leaq 0x24(%rip), %rsi        # 0xbb5f7
leaq 0x77(%rip), %rdx        # 0xbb651
pushq $0x30
popq %rdi
callq 0x102838
movq %rax, 0x382087(%rip)    # 0x43d670
callq 0x69ede
movq 0x38207b(%rip), %rax    # 0x43d670
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_in_stream.c
// Function: bed_in_stream_free
static void bed_in_stream_free(GtNodeStream *ns)
{
  GtBEDInStream *bed_in_stream = bed_in_stream_cast(ns);
  gt_free(bed_in_stream->filename);
  while (gt_queue_size(bed_in_stream->genome_node_buffer))
    gt_genome_node_delete(gt_queue_get(bed_in_stream->genome_node_buffer));
  gt_queue_delete(bed_in_stream->genome_node_buffer);
  gt_bed_parser_delete(bed_in_stream->bed_parser);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbb5bc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x20(%rax), %rdi
leaq 0x25c2dd(%rip), %rsi    # 0x3178f6
pushq $0x4b
popq %rdx
callq 0x936f9
movq 0x18(%rbx), %rdi
callq 0x9e48b
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0xbb642
callq 0x9e411
movq %rax, %rdi
callq 0xde013
jmp 0xbb621
callq 0x9e9dd
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0xbb912
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_in_stream.c
// Function: bed_in_stream_next
static int bed_in_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                              GT_UNUSED GtError *err)
{
  GtBEDInStream *is;
  int had_err = 0;
  gt_error_check(err);
  is = bed_in_stream_cast(ns);
  if (!is->file_processed) {
    had_err = bed_in_stream_process_file(is, err);
    is->file_processed = true;
  }
  if (!had_err && gt_queue_size(is->genome_node_buffer)) {
    /* we still have a node in the buffer -> serve it from there */
    *gn = gt_queue_get(is->genome_node_buffer);
    return 0;
  }
  if (!had_err) {
    /* the buffer is empty */
    gt_assert(!gt_queue_size(is->genome_node_buffer));
    *gn = NULL;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xbb670
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbb6e7
callq 0xbb5bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x102c81
movq %rax, %r15
cmpb $0x0, 0x28(%rax)
jne 0xbb6b7
testq %r14, %r14
je 0xbb69a
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbb711
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %r14, %rcx
callq 0xbb9b9
movb $0x1, 0x28(%r15)
testl %eax, %eax
jne 0xbb6e1
movq 0x18(%r15), %rdi
callq 0x9e48b
movq 0x18(%r15), %rdi
testq %rax, %rax
je 0xbb6d0
callq 0x9e411
jmp 0xbb6dc
callq 0x9e48b
testq %rax, %rax
jne 0xbb73b
xorl %eax, %eax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x37c87a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22991b(%rip), %rsi    # 0x2e5013
leaq 0x229ac0(%rip), %rdx    # 0x2e51bf
leaq 0x25c255(%rip), %rcx    # 0x31795b
leaq 0x25c1e9(%rip), %r8     # 0x3178f6
pushq $0x35
jmp 0xbb763
movq 0x37c850(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2298f1(%rip), %rsi    # 0x2e5013
leaq 0x229a96(%rip), %rdx    # 0x2e51bf
leaq 0x25c265(%rip), %rcx    # 0x317995
leaq 0x25c1bf(%rip), %r8     # 0x3178f6
pushq $0x28
jmp 0xbb763
movq 0x37c826(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2298c7(%rip), %rsi    # 0x2e5013
leaq 0x25c21b(%rip), %rdx    # 0x31796e
leaq 0x25c201(%rip), %rcx    # 0x31795b
leaq 0x25c195(%rip), %r8     # 0x3178f6
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_in_stream.c
// Function: gt_bed_in_stream_new
GtNodeStream* gt_bed_in_stream_new(const char *filename)
{
  GtBEDInStream *bed_in_stream;
  GtNodeStream *ns = gt_node_stream_create(gt_bed_in_stream_class(), false);
  bed_in_stream = bed_in_stream_cast(ns);
  bed_in_stream->bed_parser = gt_bed_parser_new();
  bed_in_stream->genome_node_buffer = gt_queue_new();
  bed_in_stream->filename = filename ? gt_cstr_dup(filename) : NULL;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0xbb5bc
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %rbx
callq 0xbb5bc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %r12
callq 0xbb8bc
movq %rax, 0x10(%r12)
callq 0x9e2bc
movq %rax, 0x18(%r12)
testq %r15, %r15
je 0xbb7c8
movq %r15, %rdi
callq 0x6c2be
movq %rax, %r14
movq %r14, 0x20(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: gt_bed_parser_new
GtBEDParser* gt_bed_parser_new(void)
{
  GtBEDParser *bed_parser = gt_calloc(1, sizeof *bed_parser);
  bed_parser->region_node_builder = gt_region_node_builder_new();
  bed_parser->feature_nodes = gt_queue_new();
  bed_parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                    (GtFree) gt_str_delete);
  bed_parser->word = gt_str_new();
  bed_parser->another_word = gt_str_new();
  return bed_parser;
}

// Assembly:
pushq %rbx
leaq 0x25c0ec(%rip), %rdx    # 0x3179b0
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
pushq $0x37
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x1112c4
movq %rax, (%rbx)
callq 0x9e2bc
movq %rax, 0x8(%rbx)
leaq -0xd7ea(%rip), %rdx     # 0xae103
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x8f330
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: gt_bed_parser_delete
void gt_bed_parser_delete(GtBEDParser *bed_parser)
{
  if (!bed_parser) return;
  gt_free(bed_parser->block_type);
  gt_free(bed_parser->thick_feature_type);
  gt_free(bed_parser->feature_type);
  gt_str_delete(bed_parser->another_word);
  gt_str_delete(bed_parser->word);
  gt_hashmap_delete(bed_parser->seqid_to_str_mapping);
  while (gt_queue_size(bed_parser->feature_nodes))
    gt_genome_node_delete(gt_queue_get(bed_parser->feature_nodes));
  gt_queue_delete(bed_parser->feature_nodes);
  gt_region_node_builder_delete(bed_parser->region_node_builder);
  gt_free(bed_parser);
}

// Assembly:
testq %rdi, %rdi
je 0xbb9b8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
leaq 0x25c083(%rip), %r14    # 0x3179b0
pushq $0x44
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x30(%rbx), %rdi
pushq $0x45
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x28(%rbx), %rdi
pushq $0x46
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0x8f933
movq 0x8(%rbx), %rdi
callq 0x9e48b
movq 0x8(%rbx), %rdi
testq %rax, %rax
je 0xbb992
callq 0x9e411
movq %rax, %rdi
callq 0xde013
jmp 0xbb971
callq 0x9e9dd
movq (%rbx), %rdi
callq 0x1112f4
leaq 0x25c00a(%rip), %rsi    # 0x3179b0
pushq $0x4e
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: rest_line
static void rest_line(GtIO *bed_file)
{
  for (;;) {
    switch (gt_io_peek(bed_file)) {
      case GT_CARRIAGE_RETURN:
        gt_io_next(bed_file);
        if (gt_io_peek(bed_file) == GT_END_OF_LINE)
          gt_io_next(bed_file);
        return;
      case GT_END_OF_LINE:
        gt_io_next(bed_file);
        /*@fallthrough@*/
      case GT_END_OF_FILE:
        return;
      default:
        gt_io_next(bed_file);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x92771
cmpb $0xa, %al
je 0xbcc4d
movzbl %al, %eax
cmpl $0xff, %eax
je 0xbcc56
movq %rbx, %rdi
cmpl $0xd, %eax
je 0xbcc3c
callq 0x927d7
jmp 0xbcc17
callq 0x927d7
movq %rbx, %rdi
callq 0x92771
cmpb $0xa, %al
jne 0xbcc56
movq %rbx, %rdi
popq %rbx
jmp 0x927d7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: word
static void word(GtStr *word, GtIO *bed_file)
{
  gt_str_reset(word);
  for (;;) {
    switch (gt_io_peek(bed_file)) {
      case BLANK_CHAR:
      case TABULATOR_CHAR:
      case PAIR_SEPARATOR:
      case GT_CARRIAGE_RETURN:
      case GT_END_OF_LINE:
      case GT_END_OF_FILE:
        return;
      default:
        gt_str_append_char(word, gt_io_next(bed_file));
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xad357
movabsq $0x2000000100002600, %r15 # imm = 0x2000000100002600
movq %rbx, %rdi
callq 0x92771
movzbl %al, %eax
cmpb $0x3d, %al
ja 0xbcc87
btq %rax, %r15
jb 0xbcca3
cmpl $0xff, %eax
je 0xbcca3
movq %rbx, %rdi
callq 0x927d7
movsbl %al, %esi
movq %r14, %rdi
callq 0xaced9
jmp 0xbcc72
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: skip_blanks
static int skip_blanks(GtIO *bed_file, GtError *err)
{
  gt_error_check(err);
  if (!bed_separator(bed_file)) {
    gt_error_set(err,
                 "file \"%s\": line "GT_WU": expected blank or tabulator, got "
                 "'%c'", gt_io_get_filename(bed_file),
                 gt_io_get_line_number(bed_file), gt_io_peek(bed_file));
    return -1;
  }
  while (bed_separator(bed_file))
    gt_io_next(bed_file);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xbccdc
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbcd48
movq %rbx, %rdi
callq 0xbcca9
testb %al, %al
jne 0xbcd2e
movq %rbx, %rdi
callq 0x9286d
movq %rax, %r15
movq %rbx, %rdi
callq 0x9282c
movq %rax, %r12
movq %rbx, %rdi
callq 0x92771
movsbl %al, %r8d
leaq 0x25adf8(%rip), %rsi    # 0x317b09
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0xbcd3c
movq %rbx, %rdi
callq 0x927d7
movq %rbx, %rdi
callq 0xbcca9
testb %al, %al
jne 0xbcd26
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x37b219(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2282ba(%rip), %rsi    # 0x2e5013
leaq 0x22845f(%rip), %rdx    # 0x2e51bf
leaq 0x25ad96(%rip), %rcx    # 0x317afd
leaq 0x25ac42(%rip), %r8     # 0x3179b0
movl $0xc8, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/bed_parser.c
// Function: parse_bed_range
static int parse_bed_range(GtRange *range, GtStr *start, GtStr *end,
                           GtWord offset, GtIO *bed_file, bool thick,
                           GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_parse_range(range, gt_str_get(start), gt_str_get(end),
                           gt_io_get_line_number(bed_file),
                           gt_io_get_filename(bed_file), err);
  /* BED has a weird numbering scheme: positions are 0-based, but the end
     position is not part of the feature. Transform to 1-based coordinates. */
  range->start++;
  /* Ranges defining a 'thick' region sometimes come with length 0 to
     designate that there are no thick regions. So do not fail here and
     handle that case later. */
  if (!thick) {
    if (!had_err && range->start > range->end) {
      gt_error_set(err, "file \"%s\": line "GT_WU": BED feature has length 0",
                   gt_io_get_filename(bed_file),
                   gt_io_get_line_number(bed_file));
      had_err = -1;
    }
  }
  if (offset)
    *range = gt_range_offset(range, offset);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rsp), %rbp
testq %rbp, %rbp
je 0xbcdbe
movq %rbp, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbce78
movq %r15, %rdi
callq 0xad1fa
movq %rax, %r15
movq %r13, %rdi
callq 0xad1fa
movq %rax, %r13
movq %r12, %rdi
callq 0x9282c
movq %rax, %r14
movq %r12, %rdi
callq 0x9286d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %r14d, %ecx
movq %rax, %r8
movq %rbp, %r9
callq 0x9be68
movl %eax, %r13d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
testl %r13d, %r13d
setne %cl
orb 0xc(%rsp), %cl
jne 0xbce4d
xorl %r13d, %r13d
cmpq 0x8(%rbx), %rax
jbe 0xbce4d
movq %r12, %rdi
callq 0x9286d
movq %rax, %r14
movq %r12, %rdi
callq 0x9282c
leaq 0x25ad80(%rip), %rsi    # 0x317bb9
movq %rbp, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r13
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0xbce66
movq %rbx, %rdi
callq 0xa3459
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x37b0e9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22818a(%rip), %rsi    # 0x2e5013
leaq 0x22832f(%rip), %rdx    # 0x2e51bf
leaq 0x25ad12(%rip), %rcx    # 0x317ba9
leaq 0x25ab12(%rip), %r8     # 0x3179b0
movl $0x105, %r9d            # imm = 0x105
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new_all_nucl
GtBlastProcessCall *gt_blast_process_call_new_all_nucl(void)
{
  GtBlastProcessCall *call =
    gt_blast_process_call_new("blastall -p blastn");
  call->nucl = call->all = true;
  call->version_call = "blastall -";
  return call;
}

// Assembly:
pushq %rax
leaq 0x25af76(%rip), %rdi    # 0x317eb6
callq 0xbcf5a
movb $0x1, %cl
movb %cl, 0x10(%rax)
movb %cl, 0x15(%rax)
leaq 0x25af75(%rip), %rcx    # 0x317ec9
movq %rcx, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new
static
GtBlastProcessCall *gt_blast_process_call_new(const char *which)
{
  GtBlastProcessCall *call = gt_malloc(sizeof (*call));
  char *env;

  env = getenv("GT_BLAST_PATH");
  if (env != NULL) {
    call->str = gt_str_new_cstr(env);
    gt_str_append_cstr(call->str, "/");
    gt_str_append_cstr(call->str, which);
  }
  else
    call->str = gt_str_new_cstr(which);
  call->all = false;
  call->db = false;
  call->evalue = false;
  call->gapextend = false;
  call->gapopen = false;
  call->nucl = false;
  call->num_threads = false;
  call->outfmt = false;
  call->penalty = false;
  call->query = false;
  call->reward = false;
  call->word_size = false;
  call->xdrop_gap_final = false;
  return call;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x25afcc(%rip), %rsi    # 0x317f34
pushq $0x20
popq %rdi
pushq $0x36
popq %rdx
callq 0x93160
movq %rax, %rbx
leaq 0x25b39f(%rip), %rdi    # 0x31831c
callq 0x17900
testq %rax, %rax
je 0xbcfae
movq %rax, %rdi
callq 0xacbd1
movq %rax, (%rbx)
leaq 0x24216e(%rip), %rsi    # 0x2ff107
movq %rax, %rdi
callq 0xacbfb
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xacbfb
jmp 0xbcfb9
movq %r14, %rdi
callq 0xacbd1
movq %rax, (%rbx)
andq $0x0, 0x15(%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new_nucl
GtBlastProcessCall *gt_blast_process_call_new_nucl(void)
{
  GtBlastProcessCall *call =
    gt_blast_process_call_new("blastn");
  call->version_call = "blastn -version";
  call->nucl = true;
  call->all = false;
  return call;
}

// Assembly:
pushq %rax
leaq 0x25aeec(%rip), %rdi    # 0x317ec2
callq 0xbcf5a
leaq 0x25aef2(%rip), %rcx    # 0x317ed4
movq %rcx, 0x8(%rax)
movb $0x1, 0x15(%rax)
movb $0x0, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new_all_prot
GtBlastProcessCall *gt_blast_process_call_new_all_prot(void)
{
  GtBlastProcessCall *call =
    gt_blast_process_call_new("blastall -p blastp");
  call->version_call = "blastall -";
  call->nucl = false;
  call->all = true;
  return call;
}

// Assembly:
pushq %rax
leaq 0x25aeec(%rip), %rdi    # 0x317ee4
callq 0xbcf5a
leaq 0x25aec5(%rip), %rcx    # 0x317ec9
movq %rcx, 0x8(%rax)
movb $0x0, 0x15(%rax)
movb $0x1, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new_prot
GtBlastProcessCall *gt_blast_process_call_new_prot(void)
{
  GtBlastProcessCall *call =
    gt_blast_process_call_new("blastp");
  call->version_call = "blastp -version";
  call->nucl = call->all = false;
  return call;
}

// Assembly:
pushq %rax
leaq 0x25aed6(%rip), %rdi    # 0x317ef0
callq 0xbcf5a
leaq 0x25aed1(%rip), %rcx    # 0x317ef7
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
movb %cl, 0x15(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_query
void gt_blast_process_call_set_query(GtBlastProcessCall *call,
                                     const char *query)
{
  gt_assert(!call->query);
  call->query = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -i ");
  else
    gt_str_append_cstr(call->str, " -query ");
  gt_str_append_cstr(call->str, query);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x19(%rdi)
je 0xbd079
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x19(%rdi)
movq (%rdi), %rdi
leaq 0x25af04(%rip), %rax    # 0x317f56
leaq 0x25af02(%rip), %rsi    # 0x317f5b
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xacbfb
movq 0x37aee8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227f89(%rip), %rsi    # 0x2e5013
leaq 0x25ae76(%rip), %rdx    # 0x317f07
leaq 0x25ae7c(%rip), %rcx    # 0x317f14
leaq 0x25ae95(%rip), %r8     # 0x317f34
pushq $0x7a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_db
void gt_blast_process_call_set_db(GtBlastProcessCall *call, const char *db)
{
  gt_assert(!call->db);
  call->db = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -d ");
  else
    gt_str_append_cstr(call->str, " -db ");
  gt_str_append_cstr(call->str, db);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x11(%rdi)
je 0xbd0f4
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x11(%rdi)
movq (%rdi), %rdi
leaq 0x25aebe(%rip), %rax    # 0x317f8b
leaq 0x25aebc(%rip), %rsi    # 0x317f90
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xacbfb
movq 0x37ae6d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227f0e(%rip), %rsi    # 0x2e5013
leaq 0x25ae58(%rip), %rdx    # 0x317f64
leaq 0x25ae5b(%rip), %rcx    # 0x317f6e
leaq 0x25ae1a(%rip), %r8     # 0x317f34
movl $0x85, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_evalue
void gt_blast_process_call_set_evalue(GtBlastProcessCall *call, double evalue)
{
  gt_assert(!call->evalue);
  call->evalue = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -e ");
  else
    gt_str_append_cstr(call->str, " -evalue ");
  gt_str_append_sci_double(call->str, evalue, 6);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x12(%rdi)
je 0xbd178
movq %rdi, %rbx
movb $0x1, 0x12(%rdi)
movq (%rdi), %rdi
leaq 0x25ae77(%rip), %rax    # 0x317fc5
leaq 0x25ae75(%rip), %rsi    # 0x317fca
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%rbx), %rdi
pushq $0x6
popq %rsi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
jmp 0xacf56
movq 0x37ade9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227e8a(%rip), %rsi    # 0x2e5013
leaq 0x25ae06(%rip), %rdx    # 0x317f96
leaq 0x25ae0d(%rip), %rcx    # 0x317fa4
leaq 0x25ad96(%rip), %r8     # 0x317f34
movl $0x90, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_wordsize
void gt_blast_process_call_set_wordsize(GtBlastProcessCall *call, int word_size)
{
  gt_assert(!call->word_size);
  call->word_size = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -W ");
  else
    gt_str_append_cstr(call->str, " -word_size ");
  gt_str_append_int(call->str, word_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x1b(%rdi)
je 0xbd1f3
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, 0x1b(%rdi)
movq (%rdi), %rdi
leaq 0x25ae3b(%rip), %rax    # 0x318008
leaq 0x25ae39(%rip), %rsi    # 0x31800d
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37ad6e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227e0f(%rip), %rsi    # 0x2e5013
leaq 0x25adc9(%rip), %rdx    # 0x317fd4
leaq 0x25add3(%rip), %rcx    # 0x317fe5
leaq 0x25ad1b(%rip), %r8     # 0x317f34
movl $0x9b, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_gapopen
void gt_blast_process_call_set_gapopen(GtBlastProcessCall *call, int gapopen)
{
  gt_assert(!call->gapopen);
  call->gapopen = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -G ");
  else
    gt_str_append_cstr(call->str, " -gapopen ");
  gt_str_append_int(call->str, gapopen);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x14(%rdi)
je 0xbd26e
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, 0x14(%rdi)
movq (%rdi), %rdi
leaq 0x25ae03(%rip), %rax    # 0x31804b
leaq 0x25ae01(%rip), %rsi    # 0x318050
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37acf3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227d94(%rip), %rsi    # 0x2e5013
leaq 0x25ad94(%rip), %rdx    # 0x31801a
leaq 0x25ad9c(%rip), %rcx    # 0x318029
leaq 0x25aca0(%rip), %r8     # 0x317f34
movl $0xa6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_gapextend
void gt_blast_process_call_set_gapextend(GtBlastProcessCall *call,
                                         int gapextend)
{
  gt_assert(!call->gapextend);
  call->gapextend = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -E ");
  else
    gt_str_append_cstr(call->str, " -gapextend ");
  gt_str_append_int(call->str, gapextend);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x13(%rdi)
je 0xbd2e9
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, 0x13(%rdi)
movq (%rdi), %rdi
leaq 0x25adcd(%rip), %rax    # 0x318090
leaq 0x25adcb(%rip), %rsi    # 0x318095
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37ac78(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227d19(%rip), %rsi    # 0x2e5013
leaq 0x25ad5a(%rip), %rdx    # 0x31805b
leaq 0x25ad64(%rip), %rcx    # 0x31806c
leaq 0x25ac25(%rip), %r8     # 0x317f34
movl $0xb2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_penalty
void gt_blast_process_call_set_penalty(GtBlastProcessCall *call, int penalty)
{
  gt_assert(!call->penalty);
  call->penalty = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -q ");
  else
    gt_str_append_cstr(call->str, " -penalty ");
  gt_str_append_int(call->str, penalty);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x18(%rdi)
je 0xbd36a
movq %rdi, %r14
movb $0x1, 0x18(%rdi)
cmpb $0x0, 0x15(%rdi)
je 0xbd398
movl %esi, %ebx
movq (%r14), %rdi
leaq 0x25ad9a(%rip), %rax    # 0x3180de
leaq 0x25ad98(%rip), %rsi    # 0x3180e3
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37abf7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227c98(%rip), %rsi    # 0x2e5013
leaq 0x25ad20(%rip), %rdx    # 0x3180a2
leaq 0x25ad28(%rip), %rcx    # 0x3180b1
leaq 0x25aba4(%rip), %r8     # 0x317f34
movl $0xbd, %r9d
jmp 0xbd3c4
movq 0x37abc9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227c6a(%rip), %rsi    # 0x2e5013
leaq 0x25ad23(%rip), %rdx    # 0x3180d3
leaq 0x25acfa(%rip), %rcx    # 0x3180b1
leaq 0x25ab76(%rip), %r8     # 0x317f34
movl $0xbf, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_reward
void gt_blast_process_call_set_reward(GtBlastProcessCall *call, int reward)
{
  gt_assert(!call->reward);
  call->reward = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -r ");
  else
    gt_str_append_cstr(call->str, " -reward ");
  gt_str_append_int(call->str, reward);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x1a(%rdi)
je 0xbd419
movq %rdi, %r14
movb $0x1, 0x1a(%rdi)
cmpb $0x0, 0x15(%rdi)
je 0xbd447
movl %esi, %ebx
movq (%r14), %rdi
leaq 0x25ad2a(%rip), %rax    # 0x31811d
leaq 0x25ad28(%rip), %rsi    # 0x318122
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37ab48(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227be9(%rip), %rsi    # 0x2e5013
leaq 0x25acbd(%rip), %rdx    # 0x3180ee
leaq 0x25acc4(%rip), %rcx    # 0x3180fc
leaq 0x25aaf5(%rip), %r8     # 0x317f34
movl $0xc9, %r9d
jmp 0xbd473
movq 0x37ab1a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227bbb(%rip), %rsi    # 0x2e5013
leaq 0x25ac74(%rip), %rdx    # 0x3180d3
leaq 0x25ac96(%rip), %rcx    # 0x3180fc
leaq 0x25aac7(%rip), %r8     # 0x317f34
movl $0xcb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_num_threads
void gt_blast_process_call_set_num_threads(GtBlastProcessCall *call,
                                           int num_threads)
{
  gt_assert(!call->num_threads);
  call->num_threads = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -a ");
  else
    gt_str_append_cstr(call->str, " -num_threads ");
  gt_str_append_int(call->str, num_threads);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x16(%rdi)
je 0xbd4c2
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, 0x16(%rdi)
movq (%rdi), %rdi
leaq 0x25acc9(%rip), %rax    # 0x318165
leaq 0x25acc7(%rip), %rsi    # 0x31816a
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37aa9f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227b40(%rip), %rsi    # 0x2e5013
leaq 0x25ac52(%rip), %rdx    # 0x31812c
leaq 0x25ac5e(%rip), %rcx    # 0x31813f
leaq 0x25aa4c(%rip), %r8     # 0x317f34
movl $0xd6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_xdrop_gap_final
void gt_blast_process_call_set_xdrop_gap_final(GtBlastProcessCall *call,
                                               double xdrop_gap_final)
{
  gt_assert(!call->xdrop_gap_final);
  call->xdrop_gap_final = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -Z ");
  else
    gt_str_append_cstr(call->str, " -xdrop_gap_final ");
  gt_str_append_double(call->str, xdrop_gap_final, 2);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x1c(%rdi)
je 0xbd54c
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movb $0x1, 0x1c(%rdi)
cmpb $0x0, 0x15(%rdi)
je 0xbd57a
movq (%rbx), %rdi
leaq 0x25ac98(%rip), %rax    # 0x3181ba
leaq 0x25ac96(%rip), %rsi    # 0x3181bf
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%rbx), %rdi
pushq $0x2
popq %rsi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
jmp 0xacfff
movq 0x37aa15(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227ab6(%rip), %rsi    # 0x2e5013
leaq 0x25ac15(%rip), %rdx    # 0x318179
leaq 0x25ac25(%rip), %rcx    # 0x318190
leaq 0x25a9c2(%rip), %r8     # 0x317f34
movl $0xe2, %r9d
jmp 0xbd5a6
movq 0x37a9e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227a88(%rip), %rsi    # 0x2e5013
leaq 0x25ab41(%rip), %rdx    # 0x3180d3
leaq 0x25abf7(%rip), %rcx    # 0x318190
leaq 0x25a994(%rip), %r8     # 0x317f34
movl $0xe4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_outfmt
void gt_blast_process_call_set_outfmt(GtBlastProcessCall *call,
                                      int outfmt)
{
  gt_assert(!call->outfmt);
  call->outfmt = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -m ");
  else
    gt_str_append_cstr(call->str, " -outfmt ");
  gt_str_append_int(call->str, outfmt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x17(%rdi)
je 0xbd5f5
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, 0x17(%rdi)
movq (%rdi), %rdi
leaq 0x25ac32(%rip), %rax    # 0x318201
leaq 0x25ac30(%rip), %rsi    # 0x318206
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %rsi
callq 0xacbfb
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad0a8
movq 0x37a96c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x227a0d(%rip), %rsi    # 0x2e5013
leaq 0x25abc5(%rip), %rdx    # 0x3181d2
leaq 0x25abcc(%rip), %rcx    # 0x3181e0
leaq 0x25a919(%rip), %r8     # 0x317f34
movl $0xef, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390