LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x132dc3
movq 0x50920e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e3277(%rip), %rsi    # 0x516013
leaq 0x416652(%rip), %rdx    # 0x5493f5
leaq 0x4165b7(%rip), %rcx    # 0x549361
leaq 0x4165c7(%rip), %r8     # 0x549378
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x132dc5
callq 0x132c00
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x8(%rsp)
callq 0x132c00
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b20f0
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x9f220
cmpq $0x0, 0x50feea(%rip)    # 0x642d18
jne 0x132e4f
movl $0x28, %edi
leaq 0x24(%rip), %rsi        # 0x132e60
leaq 0x5d(%rip), %rdx        # 0x132ea0
callq 0x1b1ae0
movq %rax, 0x50fec9(%rip)    # 0x642d18
callq 0x9f280
movq 0x50febd(%rip), %rax    # 0x642d18
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x132f0b
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x132ed3
jmp 0x132f0b
movq 0x5090c6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e312f(%rip), %rsi    # 0x516013
leaq 0x3e32d4(%rip), %rdx    # 0x5161bf
leaq 0x4164bd(%rip), %rcx    # 0x5493af
leaq 0x4164cf(%rip), %r8     # 0x5493c8
movl $0x2c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x132f0d
callq 0x132e20
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1b1d90
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x132fa1
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x132fa1
movq 0x18(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0x132f75
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x170450
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x132f9f
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x171410
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
jmp 0x132fa1
movl 0x4(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x13300b
cmpq $0x0, 0x28(%rsp)
jne 0x133043
movq 0x508f8e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e2ff7(%rip), %rsi    # 0x516013
leaq 0x4163c5(%rip), %rdx    # 0x5493e8
leaq 0x4163d1(%rip), %rcx    # 0x5493fb
leaq 0x416397(%rip), %r8     # 0x5493c8
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x133045
callq 0x132e20
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x10(%rsp)
callq 0x132e20
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1b1c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movb 0x27(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x38, %edi
leaq 0x416333(%rip), %rsi    # 0x549420
movl $0x28, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0xa5080
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movl $0x8, %edi
callq 0x80990
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1331ab
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x81f80
movq (%rsp), %rdi
leaq 0x41627f(%rip), %rsi    # 0x549420
movl $0x39, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1331fe
movq 0x508dd3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e2e3c(%rip), %rsi    # 0x516013
leaq 0x41626b(%rip), %rdx    # 0x549449
leaq 0x416270(%rip), %rcx    # 0x549455
leaq 0x416234(%rip), %r8     # 0x549420
movl $0x40, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x133200
jmp 0x133202
cmpq $0x0, 0x8(%rsp)
jne 0x133242
movq 0x508d8f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e2df8(%rip), %rsi    # 0x516013
leaq 0x446fc7(%rip), %rdx    # 0x57a1e9
leaq 0x41622c(%rip), %rcx    # 0x549455
leaq 0x4161f0(%rip), %r8     # 0x549420
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x133244
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa50a0
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x133294
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1332a2
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x1332c0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x133793
cmpq $0x0, 0x20(%rsp)
ja 0x1337cb
movq 0x508806(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e286f(%rip), %rsi    # 0x516013
leaq 0x415d30(%rip), %rdx    # 0x5494db
leaq 0x415d3e(%rip), %rcx    # 0x5494f0
leaq 0x415c67(%rip), %r8     # 0x549420
movl $0xb7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1337cd
cmpq $0x64, 0x20(%rsp)
jbe 0x1337fa
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x415d36(%rip), %rsi    # 0x54951c
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1338c1
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x81370
cmpq $0xa, %rax
jne 0x133833
movq 0x18(%rsp), %rdi
leaq 0x415d26(%rip), %rsi    # 0x549540
movl $0xa, %edx
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1338c1
movb $0x0, 0xf(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x81370
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x13389a
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x133888
movb $0x1, 0xf(%rsp)
jmp 0x13389a
jmp 0x13388a
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x133841
testb $0x1, 0xf(%rsp)
jne 0x1338b9
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/assembly_stats_calculator.c
// Function: gt_assembly_stats_calculator_cmp_nstat
static int gt_assembly_stats_calculator_cmp_nstat(const void *v1,
                                                  const void *v2) {
  GtUword u1 = *(GtUword*) v1;
  GtUword u2 = *(GtUword*) v2;
  if (u1 < u2)
    return -1;
  if (u1 == u2)
    return 0;
  return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x13442a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x134448
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x134440
movl $0x0, -0x4(%rsp)
jmp 0x134448
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x9f220
cmpq $0x0, 0x50e8c2(%rip)    # 0x642d20
jne 0x13447f
movl $0x30, %edi
leaq 0x24(%rip), %rsi        # 0x134490
leaq 0xad(%rip), %rdx        # 0x134520
callq 0x1b1ae0
movq %rax, 0x50e8a1(%rip)    # 0x642d20
callq 0x9f280
movq 0x50e895(%rip), %rax    # 0x642d20
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x134450
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x415372(%rip), %rsi    # 0x549832
movl $0x4b, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfd4d0
cmpq $0x0, %rax
je 0x1344f6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfd3f0
movq %rax, %rdi
callq 0x173180
jmp 0x1344ca
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfdf10
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1349d0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x13458b
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x134553
jmp 0x13458b
movq 0x507a46(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e1aaf(%rip), %rsi    # 0x516013
leaq 0x3e1c54(%rip), %rdx    # 0x5161bf
leaq 0x415325(%rip), %rcx    # 0x549897
leaq 0x4152b9(%rip), %r8     # 0x549832
movl $0x35, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13458d
callq 0x134450
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
jne 0x1345cb
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x134860
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movb $0x1, 0x28(%rax)
cmpl $0x0, 0xc(%rsp)
jne 0x134609
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfd4d0
cmpq $0x0, %rax
je 0x134609
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfd3f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x134674
cmpl $0x0, 0xc(%rsp)
jne 0x13466c
jmp 0x134612
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xfd4d0
cmpq $0x0, %rax
je 0x13465e
movq 0x507973(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e19dc(%rip), %rsi    # 0x516013
leaq 0x41526c(%rip), %rdx    # 0x5498aa
leaq 0x415252(%rip), %rcx    # 0x549897
leaq 0x4151e6(%rip), %r8     # 0x549832
movl $0x42, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134660
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x134450
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x10(%rsp)
callq 0x134450
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x18(%rsp)
callq 0x134940
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0xfd150
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x20(%rsp)
je 0x1346ef
movq 0x20(%rsp), %rdi
callq 0xa2db0
movq %rax, 0x8(%rsp)
jmp 0x1346f8
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x1346f8
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_in_stream.c
// Function: bed_in_stream_process_file
static int bed_in_stream_process_file(GtBEDInStream *bed_in_stream,
                                      GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(bed_in_stream);
  had_err = gt_bed_parser_parse(bed_in_stream->bed_parser,
                                bed_in_stream->genome_node_buffer,
                                bed_in_stream->filename, err);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1348be
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x134886
jmp 0x1348be
movq 0x507713(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e177c(%rip), %rsi    # 0x516013
leaq 0x3e1921(%rip), %rdx    # 0x5161bf
leaq 0x41502c(%rip), %rcx    # 0x5498d1
leaq 0x414f86(%rip), %r8     # 0x549832
movl $0x28, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1348c0
jmp 0x1348c2
cmpq $0x0, 0x10(%rsp)
jne 0x134902
movq 0x5076cf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e1738(%rip), %rsi    # 0x516013
leaq 0x41500a(%rip), %rdx    # 0x5498ec
leaq 0x414fe8(%rip), %rcx    # 0x5498d1
leaq 0x414f42(%rip), %r8     # 0x549832
movl $0x29, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134904
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rcx
callq 0x134ab0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x48, %esi
leaq 0x415012(%rip), %rdx    # 0x549964
movl $0x37, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x1ca8e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0xfd150
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
leaq -0x1542f(%rip), %rdx    # 0x11f560
callq 0xe0c40
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1349e1
jmp 0x134aab
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x414f74(%rip), %rsi    # 0x549964
movl $0x44, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x414f5b(%rip), %rsi    # 0x549964
movl $0x45, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x414f42(%rip), %rsi    # 0x549964
movl $0x46, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xe1770
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xfd4d0
cmpq $0x0, %rax
je 0x134a7d
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xfd3f0
movq %rax, %rdi
callq 0x173180
jmp 0x134a53
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xfdf10
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1ca920
movq (%rsp), %rdi
leaq 0x414ec3(%rip), %rsi    # 0x549964
movl $0x4e, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: gt_bed_parser_parse
int gt_bed_parser_parse(GtBEDParser *bed_parser, GtQueue *genome_nodes,
                        const char *filename, GtError *err)
{
  GtIO *bed_file;
  int had_err;
  gt_error_check(err);
  gt_assert(bed_parser && genome_nodes);
  bed_file = gt_io_new(filename, "r");
  /* parse BED file */
  had_err = parse_bed_file(bed_parser, bed_file, err);
  /* process created region and feature nodes */
  gt_region_node_builder_build(bed_parser->region_node_builder, genome_nodes);
  gt_region_node_builder_reset(bed_parser->region_node_builder);
  while (gt_queue_size(bed_parser->feature_nodes))
    gt_queue_add(genome_nodes, gt_queue_get(bed_parser->feature_nodes));
  gt_io_delete(bed_file);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x134b18
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x134ae0
jmp 0x134b18
movq 0x5074b9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e1522(%rip), %rsi    # 0x516013
leaq 0x3e16c7(%rip), %rdx    # 0x5161bf
leaq 0x414e7f(%rip), %rcx    # 0x54997e
leaq 0x414e5e(%rip), %r8     # 0x549964
movl $0x278, %r9d            # imm = 0x278
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134b1a
jmp 0x134b1c
cmpq $0x0, 0x30(%rsp)
je 0x134b2c
cmpq $0x0, 0x28(%rsp)
jne 0x134b64
movq 0x50746d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e14d6(%rip), %rsi    # 0x516013
leaq 0x414e4e(%rip), %rdx    # 0x549992
leaq 0x414e33(%rip), %rcx    # 0x54997e
leaq 0x414e12(%rip), %r8     # 0x549964
movl $0x279, %r9d            # imm = 0x279
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134b66
movq 0x20(%rsp), %rdi
leaq 0x3f7468(%rip), %rsi    # 0x52bfda
callq 0xe6f60
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x134c00
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x1caa80
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x1cac70
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xfd4d0
cmpq $0x0, %rax
je 0x134bec
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xfd3f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xfd170
jmp 0x134bb3
movq 0x10(%rsp), %rdi
callq 0xe7090
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: parse_bed_file
static int parse_bed_file(GtBEDParser *bed_parser, GtIO *bed_file, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  gt_assert(bed_file);
  while (!had_err && gt_io_has_char(bed_file)) {
    switch (gt_io_peek(bed_file)) {
      case BLANK_CHAR:
        had_err = bed_parser_blank_line(bed_file, err);
        break;
      case COMMENT_CHAR:
        had_err = bed_parser_comment_line(bed_file, err);
        break;
      case GT_CARRIAGE_RETURN:
        gt_io_next(bed_file);
        if (gt_io_peek(bed_file) == GT_END_OF_LINE)
          gt_io_next(bed_file);
        break;
      case GT_END_OF_LINE:
        gt_io_next(bed_file);
        break;
      default:
        had_err = bed_line(bed_parser, bed_file, err);
    }
  }
  if (!had_err)
    had_err = gt_io_expect(bed_file, GT_END_OF_FILE, err);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x134c6b
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x134c33
jmp 0x134c6b
movq 0x507366(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e13cf(%rip), %rsi    # 0x516013
leaq 0x3e1574(%rip), %rdx    # 0x5161bf
leaq 0x414dcf(%rip), %rcx    # 0x549a21
leaq 0x414d0b(%rip), %r8     # 0x549964
movl $0x258, %r9d            # imm = 0x258
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134c6d
jmp 0x134c6f
cmpq $0x0, 0x18(%rsp)
jne 0x134caf
movq 0x507322(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e138b(%rip), %rsi    # 0x516013
leaq 0x414d98(%rip), %rdx    # 0x549a27
leaq 0x414d8b(%rip), %rcx    # 0x549a21
leaq 0x414cc7(%rip), %r8     # 0x549964
movl $0x259, %r9d            # imm = 0x259
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134cb1
jmp 0x134cb3
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
jne 0x134cce
movq 0x18(%rsp), %rdi
callq 0xe7270
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x134cdb
jmp 0x134d85
movq 0x18(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x19, %eax
ja 0x134d68
movq (%rsp), %rax
leaq 0x414bfb(%rip), %rcx    # 0x5498fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x134f60
movl %eax, 0xc(%rsp)
jmp 0x134d80
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x135080
movl %eax, 0xc(%rsp)
jmp 0x134d80
movq 0x18(%rsp), %rdi
callq 0xe7380
movq 0x18(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x134d5a
movq 0x18(%rsp), %rdi
callq 0xe7380
jmp 0x134d80
movq 0x18(%rsp), %rdi
callq 0xe7380
jmp 0x134d80
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x135120
movl %eax, 0xc(%rsp)
jmp 0x134cb3
cmpl $0x0, 0xc(%rsp)
jne 0x134da4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe7500
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: bed_parser_blank_line
static int bed_parser_blank_line(GtIO *bed_file, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  had_err = gt_io_expect(bed_file, BLANK_CHAR, err);
  while (!had_err) {
    char cc = gt_io_peek(bed_file);
    if (cc == GT_CARRIAGE_RETURN) {
      gt_io_next(bed_file);
      if (gt_io_peek(bed_file) == GT_END_OF_LINE)
        gt_io_next(bed_file);
      break;
    }
    else if ((cc == GT_END_OF_LINE) || (cc == GT_END_OF_FILE)) {
      gt_io_next(bed_file);
      break;
    }
    else
      had_err = gt_io_expect(bed_file, BLANK_CHAR, err);
  }
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x134fc6
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x134f8e
jmp 0x134fc6
movq 0x50700b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e1074(%rip), %rsi    # 0x516013
leaq 0x3e1219(%rip), %rdx    # 0x5161bf
leaq 0x414a83(%rip), %rcx    # 0x549a30
leaq 0x4149b0(%rip), %r8     # 0x549964
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x134fc8
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x20, %esi
callq 0xe7500
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x134ff0
jmp 0x13506f
movq 0x10(%rsp), %rdi
callq 0xe7300
movb %al, 0x3(%rsp)
movsbl 0x3(%rsp), %eax
cmpl $0xd, %eax
jne 0x135030
movq 0x10(%rsp), %rdi
callq 0xe7380
movq 0x10(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x13502e
movq 0x10(%rsp), %rdi
callq 0xe7380
jmp 0x13506f
movsbl 0x3(%rsp), %eax
cmpl $0xa, %eax
je 0x135044
movsbl 0x3(%rsp), %eax
cmpl $-0x1, %eax
jne 0x135050
movq 0x10(%rsp), %rdi
callq 0xe7380
jmp 0x13506f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x20, %esi
callq 0xe7500
movl %eax, 0x4(%rsp)
jmp 0x13506a
jmp 0x134fe0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: bed_parser_comment_line
static int bed_parser_comment_line(GtIO *bed_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_io_expect(bed_file, COMMENT_CHAR, err);
  if (!had_err)
    rest_line(bed_file);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1350de
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1350a6
jmp 0x1350de
movq 0x506ef3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e0f5c(%rip), %rsi    # 0x516013
leaq 0x3e1101(%rip), %rdx    # 0x5161bf
leaq 0x414981(%rip), %rcx    # 0x549a46
leaq 0x414898(%rip), %r8     # 0x549964
movl $0x7f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1350e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x23, %esi
callq 0xe7500
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x135109
movq 0x10(%rsp), %rdi
callq 0x135230
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: bed_line
static int bed_line(GtBEDParser *bed_parser, GtIO *bed_file, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  word(bed_parser->word, bed_file);
  if (!strcmp(gt_str_get(bed_parser->word), BROWSER_KEYWORD))
    rest_line(bed_file); /* ignore browser lines completely */
  else if (!strcmp(gt_str_get(bed_parser->word), TRACK_KEYWORD))
    had_err = track_rest(bed_parser, bed_file, err);
  else
    had_err = bed_rest(bed_parser, bed_file, err);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x13518b
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x135153
jmp 0x13518b
movq 0x506e46(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e0eaf(%rip), %rsi    # 0x516013
leaq 0x3e1054(%rip), %rdx    # 0x5161bf
leaq 0x4148ec(%rip), %rcx    # 0x549a5e
leaq 0x4147eb(%rip), %r8     # 0x549964
movl $0x24a, %r9d            # imm = 0x24A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13518d
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1352b0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
leaq 0x4148af(%rip), %rsi    # 0x549a67
callq 0x19980
cmpl $0x0, %eax
jne 0x1351ce
movq 0x18(%rsp), %rdi
callq 0x135230
jmp 0x135224
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
leaq 0x463cdf(%rip), %rsi    # 0x598ec5
callq 0x19980
cmpl $0x0, %eax
jne 0x13520a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x135340
movl %eax, 0xc(%rsp)
jmp 0x135222
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1355b0
movl %eax, 0xc(%rsp)
jmp 0x135224
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
movl %eax, 0xc(%rsp)
subl $-0x1, %eax
je 0x135299
jmp 0x135251
movl 0xc(%rsp), %eax
subl $0xa, %eax
je 0x13528f
jmp 0x13525c
movl 0xc(%rsp), %eax
subl $0xd, %eax
jne 0x13529b
jmp 0x135267
movq 0x10(%rsp), %rdi
callq 0xe7380
movq 0x10(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x13528d
movq 0x10(%rsp), %rdi
callq 0xe7380
jmp 0x1352a7
movq 0x10(%rsp), %rdi
callq 0xe7380
jmp 0x1352a7
movq 0x10(%rsp), %rdi
callq 0xe7380
jmp 0x135239
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11e110
movq 0x18(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
movl %eax, 0x14(%rsp)
subl $-0x1, %eax
je 0x13530f
jmp 0x1352e0
movl 0x14(%rsp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x13530f
jmp 0x1352ee
movl 0x14(%rsp), %eax
subl $0xd, %eax
je 0x13530f
jmp 0x1352f9
movl 0x14(%rsp), %eax
subl $0x20, %eax
je 0x13530f
jmp 0x135304
movl 0x14(%rsp), %eax
subl $0x3d, %eax
jne 0x135314
jmp 0x13530f
addq $0x28, %rsp
retq
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe7380
movq 0x8(%rsp), %rdi
movsbl %al, %esi
callq 0x11da70
jmp 0x1352c8
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: bed_separator
static bool bed_separator(GtIO *bed_file)
{
  char cc = gt_io_peek(bed_file);
  if (cc == BLANK_CHAR || cc == TABULATOR_CHAR)
    return true;
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xe7300
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x20, %eax
je 0x135eab
movsbl 0x7(%rsp), %eax
cmpl $0x9, %eax
jne 0x135eb2
movb $0x1, 0x17(%rsp)
jmp 0x135eb7
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x135f2e
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x135ef6
jmp 0x135f2e
movq 0x5060a3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e010c(%rip), %rsi    # 0x516013
leaq 0x3e02b1(%rip), %rdx    # 0x5161bf
leaq 0x413b9c(%rip), %rcx    # 0x549ab1
leaq 0x413a48(%rip), %r8     # 0x549964
movl $0xc8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x135f30
movq 0x28(%rsp), %rdi
callq 0x135e80
testb $0x1, %al
jne 0x135f9b
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe7440
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe73f0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe7300
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movsbl %al, %r8d
leaq 0x413b33(%rip), %rsi    # 0x549abd
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x135fc1
jmp 0x135f9d
movq 0x28(%rsp), %rdi
callq 0x135e80
testb $0x1, %al
jne 0x135fad
jmp 0x135fb9
movq 0x28(%rsp), %rdi
callq 0xe7380
jmp 0x135f9d
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: quoted_word
static int quoted_word(GtStr *word, GtIO *bed_file, GtError *err)
{
  bool break_while = false;
  int had_err;
  gt_error_check(err);
  gt_str_reset(word);
  had_err = gt_io_expect(bed_file, QUOTE_CHAR, err);
  while (!had_err) {
    switch (gt_io_peek(bed_file)) {
      case QUOTE_CHAR:
      case GT_CARRIAGE_RETURN:
      case GT_END_OF_LINE:
      case GT_END_OF_FILE:
        break_while = true;
        break;
      default:
        gt_str_append_char(word, gt_io_next(bed_file));
    }
    if (break_while)
      break;
  }
  if (!had_err)
    had_err = gt_io_expect(bed_file, QUOTE_CHAR, err);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x136038
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x136000
jmp 0x136038
movq 0x505f99(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e0002(%rip), %rsi    # 0x516013
leaq 0x3e01a7(%rip), %rdx    # 0x5161bf
leaq 0x413ad9(%rip), %rcx    # 0x549af8
leaq 0x41393e(%rip), %r8     # 0x549964
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13603a
movq 0x30(%rsp), %rdi
callq 0x11e110
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x22, %esi
callq 0xe7500
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13606c
jmp 0x1360d8
movq 0x28(%rsp), %rdi
callq 0xe7300
movsbl %al, %eax
movl %eax, 0x14(%rsp)
subl $-0x1, %eax
je 0x1360a5
jmp 0x136084
movl 0x14(%rsp), %eax
subl $0xa, %eax
je 0x1360a5
jmp 0x13608f
movl 0x14(%rsp), %eax
subl $0xd, %eax
je 0x1360a5
jmp 0x13609a
movl 0x14(%rsp), %eax
subl $0x22, %eax
jne 0x1360ac
jmp 0x1360a5
movb $0x1, 0x1f(%rsp)
jmp 0x1360cd
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe7380
movq 0x8(%rsp), %rdi
movsbl %al, %esi
callq 0x11da70
testb $0x1, 0x1f(%rsp)
je 0x1360d6
jmp 0x1360d8
jmp 0x13605c
cmpl $0x0, 0x18(%rsp)
jne 0x1360f7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x22, %esi
callq 0xe7500
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: get_seqid
static GtStr* get_seqid(GtBEDParser *bed_parser)
{
  GtStr *seqid = gt_hashmap_get(bed_parser->seqid_to_str_mapping,
                                gt_str_get(bed_parser->word));
  if (!seqid) {
    seqid = gt_str_new_cstr(gt_str_get(bed_parser->word));
    gt_hashmap_add(bed_parser->seqid_to_str_mapping, gt_str_get(seqid), seqid);
  }
  gt_assert(seqid);
  return seqid;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xe0f20
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x136184
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0x11d510
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0xe0fc0
jmp 0x136186
cmpq $0x0, 0x18(%rsp)
jne 0x1361c6
movq 0x505e0b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dfe74(%rip), %rsi    # 0x516013
leaq 0x3faa5e(%rip), %rdx    # 0x530c04
leaq 0x41af17(%rip), %rcx    # 0x5510c4
leaq 0x4137b0(%rip), %r8     # 0x549964
movl $0xba, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1361c8
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bed_parser.c
// Function: construct_thick_feature
static void construct_thick_feature(GtBEDParser *bed_parser, GtFeatureNode *fn,
                                    GtRange range)
{
  GtGenomeNode *thick_feature;
  const char *name;
  gt_assert(fn);
  thick_feature = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*)
                                                               fn),
                                      bed_parser->thick_feature_type
                                      ? bed_parser->thick_feature_type
                                      : BED_THICK_FEATURE_TYPE,
                                      range.start, range.end,
                                      gt_feature_node_get_strand(fn));
  if ((name = gt_feature_node_get_attribute(fn, GT_GFF_NAME))) {
    gt_feature_node_add_attribute((GtFeatureNode*) thick_feature, GT_GFF_NAME,
                                  name);
  }
  gt_feature_node_set_score((GtFeatureNode*) thick_feature,
                            gt_feature_node_get_score(fn));
  gt_feature_node_set_strand((GtFeatureNode*) thick_feature,
                             gt_feature_node_get_strand(fn));
  gt_feature_node_add_child(fn, (GtFeatureNode*) thick_feature);
}

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x58(%rsp)
movq %rcx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x1363f8
movq 0x505bd9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dfc42(%rip), %rsi    # 0x516013
leaq 0x47cb18(%rip), %rdx    # 0x5b2ef0
leaq 0x4137bc(%rip), %rcx    # 0x549b9b
leaq 0x41357e(%rip), %r8     # 0x549964
movl $0x121, %r9d            # imm = 0x121
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1363fa
movq 0x48(%rsp), %rdi
callq 0x171b70
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x136425
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x136433
leaq 0x3e0bf6(%rip), %rax    # 0x517022
movq %rax, 0x28(%rsp)
jmp 0x136433
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16cc70
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl %eax, %r8d
callq 0x16c7e0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x43e226(%rip), %rsi    # 0x5746ae
callq 0x16c040
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x1364ae
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x43e205(%rip), %rsi    # 0x5746ae
callq 0x16edb0
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x16df90
movq (%rsp), %rdi
callq 0x16d590
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16cc70
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x16e0f0
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x16d010
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x412ff2(%rip), %rdi    # 0x549e6a
callq 0x136eb0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
movq (%rsp), %rax
movb $0x1, 0x15(%rax)
movq (%rsp), %rax
leaq 0x412fe1(%rip), %rcx    # 0x549e7d
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
leaq 0x413023(%rip), %rsi    # 0x549ee8
movl $0x36, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
leaq 0x4133f5(%rip), %rdi    # 0x54a2d0
callq 0x198a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x136f27
movq (%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x3f51d8(%rip), %rsi    # 0x52c0e6
callq 0x11d550
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11d550
jmp 0x136f3c
movq 0x10(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x11(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x12(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x13(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x14(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x15(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x16(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x17(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x19(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x1a(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x1b(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x1c(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x412eae(%rip), %rdi    # 0x549e76
callq 0x136eb0
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x412eac(%rip), %rcx    # 0x549e88
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, 0x15(%rax)
movq (%rsp), %rax
movb $0x0, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x412e90(%rip), %rdi    # 0x549e98
callq 0x136eb0
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x412e61(%rip), %rcx    # 0x549e7d
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x15(%rax)
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)