LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_save_exon
static int csa_visitor_save_exon(GtFeatureNode *fn, void *data,
                                 GT_UNUSED GtError *err)
{
  GtArray *exon_ranges = (GtArray*) data;
  GtRange range;
  gt_error_check(err);
  gt_assert(fn && exon_ranges);
  if (gt_feature_node_has_type(fn, gt_ft_exon)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_array_add(exon_ranges, range);
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x14f97d
movq 0x30(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x14f945
jmp 0x14f97d
movq 0x6468c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe710(%rip), %rsi      # 0x15e066
leaq 0xeceb(%rip), %rdx      # 0x15e648
leaq 0x3e9e7(%rip), %rcx     # 0x18e34b
leaq 0x3e880(%rip), %r8      # 0x18e1eb
movl $0xd3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14f97f
jmp 0x14f981
cmpq $0x0, 0x40(%rsp)
je 0x14f991
cmpq $0x0, 0x28(%rsp)
jne 0x14f9c9
movq 0x64640(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe6c4(%rip), %rsi      # 0x15e066
leaq 0x3e9b8(%rip), %rdx     # 0x18e361
leaq 0x3e99b(%rip), %rcx     # 0x18e34b
leaq 0x3e834(%rip), %r8      # 0x18e1eb
movl $0xd4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14f9cb
movq 0x40(%rsp), %rdi
leaq 0x2b3df(%rip), %rsi     # 0x17adb6
callq 0x21700
testb $0x1, %al
jne 0x14f9e2
jmp 0x14fa1e
movq 0x40(%rsp), %rdi
callq 0x259f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x10, %edx
callq 0x76220
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_visitor.c
// Function: create_gene_feature
static GtFeatureNode* create_gene_feature(GtCSAGene *csa_gene,
                                          GtStr *gt_csa_source_str)
{
  GtFeatureNode *gene_feature, *mRNA_feature;
  GtRange range;
  GtUword i;
  gt_assert(csa_gene && gt_csa_source_str);

  /* create top-level gene feature */
  range = gt_csa_gene_genomic_range(csa_gene),
  gene_feature = (GtFeatureNode*)
    gt_feature_node_new(gt_genome_node_get_seqid(*(GtGenomeNode**)
                                      gt_csa_gene_get_representative(csa_gene)),
                        gt_ft_gene, range.start, range.end,
                        gt_csa_gene_strand(csa_gene));
  gt_feature_node_set_source(gene_feature, gt_csa_source_str);

  /* create mRNA features representing the splice forms */
  for (i = 0; i < gt_csa_gene_num_of_splice_forms(csa_gene); i++) {
    GtCSASpliceForm *csa_splice_form = gt_csa_gene_get_splice_form(csa_gene, i);
    mRNA_feature = create_mRNA_feature(csa_splice_form, gt_csa_source_str);
    gt_feature_node_add_child(gene_feature, mRNA_feature);
  }

  return gene_feature;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x14fa4e
cmpq $0x0, 0x68(%rsp)
jne 0x14fa86
movq 0x64583(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe607(%rip), %rsi      # 0x15e066
leaq 0x3e91f(%rip), %rdx     # 0x18e385
leaq 0x3e936(%rip), %rcx     # 0x18e3a3
leaq 0x3e777(%rip), %r8      # 0x18e1eb
movl $0x1b5, %r9d            # imm = 0x1B5
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14fa88
movq 0x70(%rsp), %rdi
callq 0x15a300
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x15a470
movq (%rax), %rdi
callq 0x258a0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
callq 0x15a410
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl %eax, %r8d
leaq 0x3fa12(%rip), %rsi     # 0x18f510
callq 0x20580
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1ff10
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x15a2a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x14fb88
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x15a230
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x14fba0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x20db0
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x14fb20
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_visitor.c
// Function: mRNA_set_target_attribute
static void mRNA_set_target_attribute(GtFeatureNode *mRNA_feature,
                                      const GtCSASpliceForm *csa_splice_form)
{
  GtUword i;
  GtStr *targets;
  gt_assert(mRNA_feature && csa_splice_form);
  targets = gt_str_new();
  for (i = 0; i < gt_csa_splice_form_num_of_sas(csa_splice_form); i++) {
    GtFeatureNode *sa = *(GtFeatureNode**)
                        gt_csa_splice_form_get_sa(csa_splice_form, i);
    if (gt_feature_node_get_attribute(sa, GT_GFF_TARGET)) {
      if (gt_str_length(targets))
        gt_str_append_char(targets, ',');
      gt_str_append_cstr(targets,
                         gt_feature_node_get_attribute(sa, GT_GFF_TARGET));
    }
  }
  if (gt_str_length(targets)) {
    gt_feature_node_add_attribute(mRNA_feature, GT_GFF_TARGET,
                                  gt_str_get(targets));
  }
  gt_str_delete(targets);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x14fdee
cmpq $0x0, 0x38(%rsp)
jne 0x14fe26
movq 0x641e3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe267(%rip), %rsi      # 0x15e066
leaq 0x3e621(%rip), %rdx     # 0x18e427
leaq 0x3e63a(%rip), %rcx     # 0x18e447
leaq 0x3e3d7(%rip), %r8      # 0x18e1eb
movl $0x170, %r9d            # imm = 0x170
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x14fe28
callq 0x18f00
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x15a870
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x14feea
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x15a800
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x14a2e(%rip), %rsi     # 0x1648b1
callq 0x1fde0
cmpq $0x0, %rax
je 0x14fed5
movq 0x28(%rsp), %rdi
callq 0x19a00
cmpq $0x0, %rax
je 0x14fead
movq 0x28(%rsp), %rdi
movl $0x2c, %esi
callq 0x194d0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x149ee(%rip), %rsi     # 0x1648b1
callq 0x1fde0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x18fb0
jmp 0x14fed7
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x14fe3b
movq 0x28(%rsp), %rdi
callq 0x19a00
cmpq $0x0, %rax
je 0x14ff22
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x19940
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x14994(%rip), %rsi     # 0x1648b1
callq 0x22b50
movq 0x28(%rsp), %rdi
callq 0x1afc0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_visitor.c
// Function: genome_nodes_are_sorted_and_do_not_overlap
static bool genome_nodes_are_sorted_and_do_not_overlap(GtArray *exon_nodes)
{
  GtArray *ranges = gt_array_new(sizeof (GtRange));
  GtUword i;
  GtRange range;
  bool rval;
  gt_assert(exon_nodes);
  for (i = 0; i < gt_array_size(exon_nodes); i++) {
    range = gt_genome_node_get_range(*(GtGenomeNode**)
                                     gt_array_get(exon_nodes, i));
    gt_array_add(ranges, range);
  }
  rval = gt_ranges_are_sorted_and_do_not_overlap(ranges);
  gt_array_delete(ranges);
  return rval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x10, %edi
callq 0x75ab0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x1507b8
movq 0x63851(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd8d5(%rip), %rsi      # 0x15e066
leaq 0x3de40(%rip), %rdx     # 0x18e5d8
leaq 0x3de44(%rip), %rcx     # 0x18e5e3
leaq 0x3da45(%rip), %r8      # 0x18e1eb
movl $0x15f, %r9d            # imm = 0x15F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1507ba
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x15083b
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x259f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x10, %edx
callq 0x76220
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1507c3
movq 0x38(%rsp), %rdi
callq 0x957e0
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x38(%rsp), %rdi
callq 0x770a0
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_sensitivity
double gt_evaluator_get_sensitivity(const GtEvaluator *evaluator)
{
  double sensitivity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->A);
  if (evaluator->A)
    sensitivity = (double) evaluator->T / evaluator->A;
  gt_assert(sensitivity >= 0.0 && sensitivity <= 1.0);
  return sensitivity;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd 0xddd7(%rip), %xmm0     # 0x15e808
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x150a77
movq 0x63592(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd616(%rip), %rsi      # 0x15e066
leaq 0x23432(%rip), %rdx     # 0x173e89
leaq 0x3dc5f(%rip), %rcx     # 0x18e6bd
leaq 0x3dbbb(%rip), %r8      # 0x18e620
movl $0x39, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150a79
jmp 0x150a7b
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x150ac6
movq 0x63543(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd5c7(%rip), %rsi      # 0x15e066
leaq 0x3dc34(%rip), %rdx     # 0x18e6da
leaq 0x3dc10(%rip), %rcx     # 0x18e6bd
leaq 0x3db6c(%rip), %r8      # 0x18e620
movl $0x3a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150ac8
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x150b21
movq 0x10(%rsp), %rax
movq (%rax), %xmm0
movaps 0xd99c(%rip), %xmm3     # 0x15e480
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xd9a0(%rip), %xmm2     # 0x15e490
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x8(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x150b23
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x150b42
movsd 0xdcce(%rip), %xmm0     # 0x15e808
ucomisd 0x8(%rsp), %xmm0
jae 0x150b7a
movq 0x6348f(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd513(%rip), %rsi      # 0x15e066
leaq 0x3db9d(%rip), %rdx     # 0x18e6f7
leaq 0x3db5c(%rip), %rcx     # 0x18e6bd
leaq 0x3dab8(%rip), %r8      # 0x18e620
movl $0x3d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150b7c
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_specificity
double gt_evaluator_get_specificity(const GtEvaluator *evaluator)
{
  double specificity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->P);
  if (evaluator->P)
    specificity = (double) evaluator->T / evaluator->P;
  gt_assert(specificity >= 0.0 && specificity <= 1.0);
  return specificity;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd 0xdc67(%rip), %xmm0     # 0x15e808
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x150be7
movq 0x63422(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd4a6(%rip), %rsi      # 0x15e066
leaq 0x232c2(%rip), %rdx     # 0x173e89
leaq 0x3db52(%rip), %rcx     # 0x18e720
leaq 0x3da4b(%rip), %r8      # 0x18e620
movl $0x44, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150be9
jmp 0x150beb
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x150c36
movq 0x633d3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd457(%rip), %rsi      # 0x15e066
leaq 0x3db27(%rip), %rdx     # 0x18e73d
leaq 0x3db03(%rip), %rcx     # 0x18e720
leaq 0x3d9fc(%rip), %r8      # 0x18e620
movl $0x45, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150c38
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x150c91
movq 0x10(%rsp), %rax
movq (%rax), %xmm0
movaps 0xd82c(%rip), %xmm3     # 0x15e480
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xd830(%rip), %xmm2     # 0x15e490
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x150c93
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x150cb2
movsd 0xdb5e(%rip), %xmm0     # 0x15e808
ucomisd 0x8(%rsp), %xmm0
jae 0x150cea
movq 0x6331f(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd3a3(%rip), %rsi      # 0x15e066
leaq 0x3da90(%rip), %rdx     # 0x18e75a
leaq 0x3da4f(%rip), %rcx     # 0x18e720
leaq 0x3d948(%rip), %r8      # 0x18e620
movl $0x48, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150cec
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_sensitivity
void gt_evaluator_show_sensitivity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_sensitivity(evaluator) * 100.0,
                  evaluator->T, evaluator->A);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x150d4e
movq 0x632bb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd33f(%rip), %rsi      # 0x15e066
leaq 0x2315b(%rip), %rdx     # 0x173e89
leaq 0x3da4e(%rip), %rcx     # 0x18e783
leaq 0x3d8e4(%rip), %r8      # 0x18e620
movl $0x4e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150d50
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x150a20
movq (%rsp), %rdi
movsd 0x17c31(%rip), %xmm1    # 0x1689a0
mulsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x3da16(%rip), %rsi     # 0x18e7a1
movb $0x1, %al
callq 0x837b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_specificity
void gt_evaluator_show_specificity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_specificity(evaluator) * 100.0,
                  evaluator->T, evaluator->P);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x150dee
movq 0x6321b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd29f(%rip), %rsi      # 0x15e066
leaq 0x230bb(%rip), %rdx     # 0x173e89
leaq 0x3d9de(%rip), %rcx     # 0x18e7b3
leaq 0x3d844(%rip), %r8      # 0x18e620
movl $0x56, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x150df0
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x150b90
movq (%rsp), %rdi
movsd 0x17b91(%rip), %xmm1    # 0x1689a0
mulsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x3d976(%rip), %rsi     # 0x18e7a1
movb $0x1, %al
callq 0x837b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_class
const GtNodeStreamClass* gt_gff3_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3OutStream),
                                   gff3_out_stream_free,
                                   gff3_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x7b730
cmpq $0x0, 0x64cb2(%rip)     # 0x1b6690
jne 0x1519ff
movl $0x20, %edi
leaq 0x24(%rip), %rsi        # 0x151a10
leaq 0x6d(%rip), %rdx        # 0x151a60
callq 0x344e0
movq %rax, 0x64c91(%rip)     # 0x1b6690
callq 0x7b790
movq 0x64c85(%rip), %rax     # 0x1b6690
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gff3_out_stream_next
static int gff3_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                GtError *err)
{
  GtGFF3OutStream *gff3_out_stream;
  int had_err;
  gt_error_check(err);
  gff3_out_stream = gff3_out_stream_cast(ns);
  had_err = gt_node_stream_next(gff3_out_stream->in_stream, gn, err);
  if (!had_err && *gn)
    had_err = gt_genome_node_accept(*gn, gff3_out_stream->gff3_visitor, err);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x151ac3
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x151a8b
jmp 0x151ac3
movq 0x62546(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc5ca(%rip), %rsi      # 0x15e066
leaq 0xcba5(%rip), %rdx      # 0x15e648
leaq 0x3cfa5(%rip), %rcx     # 0x18ea4f
leaq 0x3cf57(%rip), %r8      # 0x18ea08
movl $0x27, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x151ac5
callq 0x1519d0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x34af0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x34790
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x151b29
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x151b29
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x25cc0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_new
GtNodeStream* gt_gff3_out_stream_new(GtNodeStream *in_stream, GtFile *outfp)
{
  GtNodeStream *ns = gt_node_stream_create(gt_gff3_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtGFF3OutStream *gff3_out_stream = gff3_out_stream_cast(ns);
  gff3_out_stream->in_stream = gt_node_stream_ref(in_stream);
  gff3_out_stream->gff3_visitor = gt_gff3_visitor_new(outfp);
  return ns;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
callq 0x1519d0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x34a90
movq (%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x34580
movq %rax, 0x10(%rsp)
callq 0x1519d0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x34af0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x34650
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
callq 0x31e50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_new
Splicedseq* gt_splicedseq_new(void)
{
  Splicedseq *ss = gt_malloc(sizeof (Splicedseq));
  ss->splicedseq = gt_str_new();
  ss->positionmapping = gt_array_new(sizeof (GtUword));
  ss->forward = true;
  return ss;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x3cdb7(%rip), %rsi     # 0x18ea64
movl $0x22, %edx
callq 0xd2e0
movq %rax, (%rsp)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_add
void gt_splicedseq_add(Splicedseq *ss, GtUword start, GtUword end,
                       const char *original_sequence)
{
  GtUword i;
  gt_assert(ss && start <= end && original_sequence);
  gt_str_append_cstr_nt(ss->splicedseq, original_sequence,
                        end - start + 1);
  /* make sure elements are added in ascending order */
  gt_assert(!gt_array_size(ss->positionmapping) ||
            start > *(GtUword*) gt_array_get_last(ss->positionmapping));
  for (i = start; i <= end; i++)
    gt_array_add(ss->positionmapping, i);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x151d24
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x151d24
cmpq $0x0, 0x18(%rsp)
jne 0x151d5c
movq 0x622ad(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc331(%rip), %rsi      # 0x15e066
leaq 0x3cd42(%rip), %rdx     # 0x18ea7e
leaq 0x3cd63(%rip), %rcx     # 0x18eaa6
leaq 0x3cd1a(%rip), %r8      # 0x18ea64
movl $0x2d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x151d5e
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
subq 0x28(%rsp), %rdx
addq $0x1, %rdx
callq 0x19290
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
cmpq $0x0, %rax
je 0x151def
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x75d20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
ja 0x151def
movq 0x6221a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc29e(%rip), %rsi      # 0x15e066
leaq 0x3cce9(%rip), %rdx     # 0x18eab8
leaq 0x3ccd0(%rip), %rcx     # 0x18eaa6
leaq 0x3cc87(%rip), %r8      # 0x18ea64
movl $0x32, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x151df1
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x151e2f
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x151dfb
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_pos_is_border
bool gt_splicedseq_pos_is_border(const Splicedseq *ss, GtUword pos)
{
  gt_assert(ss &&
         gt_str_length(ss->splicedseq) == gt_array_size(ss->positionmapping));
  gt_assert(pos < gt_str_length(ss->splicedseq)); /* legal position */
  if (ss->forward && pos + 1 < gt_array_size(ss->positionmapping) &&
      *(GtUword*) gt_array_get(ss->positionmapping, pos) + 1 !=
      *(GtUword*) gt_array_get(ss->positionmapping, pos+1)) {
    return true;
  }
  if (!ss->forward && pos &&
      *(GtUword*) gt_array_get(ss->positionmapping, pos-1) - 1 !=
      *(GtUword*) gt_array_get(ss->positionmapping, pos)) {
    return true;
  }
  return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x151ea3
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x19a00
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
je 0x151edb
movq 0x6212e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc1b2(%rip), %rsi      # 0x15e066
leaq 0x3cc5f(%rip), %rdx     # 0x18eb1a
leaq 0x3cca2(%rip), %rcx     # 0x18eb64
leaq 0x3cb9b(%rip), %r8      # 0x18ea64
movl $0x3f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x151edd
jmp 0x151edf
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x19a00
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jb 0x151f3b
movq 0x620ce(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc152(%rip), %rsi      # 0x15e066
leaq 0x3cc65(%rip), %rdx     # 0x18eb80
leaq 0x3cc42(%rip), %rcx     # 0x18eb64
leaq 0x3cb3b(%rip), %r8      # 0x18ea64
movl $0x40, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x151f3d
movq 0x38(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x151fbb
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x151fbb
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
je 0x151fbb
movb $0x1, 0x47(%rsp)
jmp 0x15201d
movq 0x38(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x152018
cmpq $0x0, 0x30(%rsp)
je 0x152018
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
je 0x152018
movb $0x1, 0x47(%rsp)
jmp 0x15201d
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_reverse
int gt_splicedseq_reverse(Splicedseq *ss, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(ss);
  had_err = gt_reverse_complement(gt_str_get(ss->splicedseq),
                               gt_str_length(ss->splicedseq), err);
  if (!had_err) {
    gt_array_reverse(ss->positionmapping);
    ss->forward = !ss->forward;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1521ee
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x1521b6
jmp 0x1521ee
movq 0x61e1b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xbe9f(%rip), %rsi      # 0x15e066
leaq 0xc47a(%rip), %rdx      # 0x15e648
leaq 0x3c9f6(%rip), %rcx     # 0x18ebcb
leaq 0x3c888(%rip), %r8      # 0x18ea64
movl $0x5f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1521f0
jmp 0x1521f2
cmpq $0x0, 0x20(%rsp)
jne 0x152232
movq 0x61dd7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xbe5b(%rip), %rsi      # 0x15e066
leaq 0x11f55(%rip), %rdx     # 0x164167
leaq 0x3c9b2(%rip), %rcx     # 0x18ebcb
leaq 0x3c844(%rip), %r8      # 0x18ea64
movl $0x60, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x152234
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x19940
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x19a00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0xeaf70
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x152294
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76060
movq 0x20(%rsp), %rax
movb 0x10(%rax), %cl
xorb $-0x1, %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_reset
void gt_splicedseq_reset(Splicedseq *ss)
{
  gt_assert(ss);
  gt_str_reset(ss->splicedseq);
  gt_array_reset(ss->positionmapping);
  ss->forward = true;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1522e4
movq 0x61d25(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xbda9(%rip), %rsi      # 0x15e066
leaq 0x11ea3(%rip), %rdx     # 0x164167
leaq 0x3c916(%rip), %rcx     # 0x18ebe1
leaq 0x3c792(%rip), %r8      # 0x18ea64
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1522e6
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x19b70
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x765c0
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_unit_test
int gt_splicedseq_unit_test(GtError *err)
{
  Splicedseq *ss;
  int had_err = 0;
  gt_error_check(err);
  ss = gt_splicedseq_new();
  had_err = check_splicedseq(ss, err);
  if (!had_err) {
    gt_splicedseq_reset(ss);
    had_err = check_splicedseq(ss, err);
  }
  gt_splicedseq_delete(ss);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x152371
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x152339
jmp 0x152371
movq 0x61c98(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xbd1c(%rip), %rsi      # 0x15e066
leaq 0xc2f7(%rip), %rdx      # 0x15e648
leaq 0x3c89d(%rip), %rcx     # 0x18ebf5
leaq 0x3c705(%rip), %r8      # 0x18ea64
movl $0x86, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x152373
callq 0x151ca0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1523d0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1523b4
movq 0x8(%rsp), %rdi
callq 0x1522a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1523d0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1526a0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_delete
void gt_splicedseq_delete(Splicedseq *ss)
{
  if (!ss) return;
  gt_str_delete(ss->splicedseq);
  gt_array_delete(ss->positionmapping);
  gt_free(ss);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1526ae
jmp 0x1526dc
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x770a0
movq (%rsp), %rdi
leaq 0x3c392(%rip), %rsi     # 0x18ea64
movl $0x96, %edx
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/blocksort.c
// Function: mmed3
static 
__inline__
UChar mmed3 ( UChar a, UChar b, UChar c )
{
   UChar t;
   if (a > b) { t = a; a = b; b = t; };
   if (b > c) { 
      b = c;
      if (a > b) b = a;
   }
   return b;
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rsp)
movb %cl, -0x2(%rsp)
movb %al, -0x3(%rsp)
movzbl -0x1(%rsp), %eax
movzbl -0x2(%rsp), %ecx
cmpl %ecx, %eax
jle 0x1556ea
movb -0x1(%rsp), %al
movb %al, -0x4(%rsp)
movb -0x2(%rsp), %al
movb %al, -0x1(%rsp)
movb -0x4(%rsp), %al
movb %al, -0x2(%rsp)
movzbl -0x2(%rsp), %eax
movzbl -0x3(%rsp), %ecx
cmpl %ecx, %eax
jle 0x155718
movb -0x3(%rsp), %al
movb %al, -0x2(%rsp)
movzbl -0x1(%rsp), %eax
movzbl -0x2(%rsp), %ecx
cmpl %ecx, %eax
jle 0x155716
movb -0x1(%rsp), %al
movb %al, -0x2(%rsp)
jmp 0x155718
movb -0x2(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/huffman.c
// Function: BZ2_hbAssignCodes
void BZ2_hbAssignCodes ( Int32 *code,
                         UChar *length,
                         Int32 minLen,
                         Int32 maxLen,
                         Int32 alphaSize )
{
   Int32 n, vec, i;

   vec = 0;
   for (n = minLen; n <= maxLen; n++) {
      for (i = 0; i < alphaSize; i++)
         if (length[i] == n) { code[i] = vec; vec++; };
      vec <<= 1;
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x18(%rsp), %eax
jg 0x156949
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x156932
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x20(%rsp), %eax
jne 0x156923
movl -0x24(%rsp), %edx
movq -0x8(%rsp), %rax
movslq -0x28(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x156925
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x1568e9
movl -0x24(%rsp), %eax
shll %eax
movl %eax, -0x24(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x1568d7
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_fingerprint.c
// Function: gt_md5_fingerprint
char* gt_md5_fingerprint(const char *sequence, GtUword seqlen)
{
  unsigned char output[16];
  char buf[64];
  char *fingerprint;
  GtMD5Encoder *enc;
  GtUword i, pos = 0;

  enc = gt_md5_encoder_new();
  for (i = 0; i < seqlen; i++) {
    if (pos == 64) {
      gt_md5_encoder_add_block(enc, buf, 64);
      pos = 0;
    }
    buf[pos++] = toupper(sequence[i]);
  }
  gt_md5_encoder_add_block(enc, buf, pos);
  fingerprint = gt_calloc(33, sizeof (char));
  gt_md5_encoder_finish(enc, output, fingerprint);

  gt_md5_encoder_delete(enc);
  return fingerprint;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq $0x0, (%rsp)
callq 0x147c80
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x159ca9
cmpq $0x40, (%rsp)
jne 0x159c6e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x40, %edx
callq 0x147dc0
movq $0x0, (%rsp)
movq 0x80(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xbbb0
movb %al, %cl
movq (%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rsp)
movb %cl, 0x20(%rsp,%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x159c3f
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq 0x147dc0
movl $0x21, %edi
movl $0x1, %esi
leaq 0x35395(%rip), %rdx     # 0x18f062
movl $0x2b, %ecx
callq 0xd5b0
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x148940
movq 0x10(%rsp), %rdi
callq 0x148e70
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_new
GtCSAGene* gt_csa_gene_new(GtCSASpliceForm *splice_form)
{
  GtCSAGene *gene;
  gt_assert(splice_form);
  gene = gt_malloc(sizeof *gene);
  gene->splice_forms = gt_array_new(sizeof (GtCSASpliceForm*));
  gt_array_add(gene->splice_forms, splice_form);
  return gene;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x15a059
movq 0x59fb0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4034(%rip), %rsi      # 0x15e066
leaq 0x350bd(%rip), %rdx     # 0x18f0f6
leaq 0x35086(%rip), %rcx     # 0x18f0c6
leaq 0x3508f(%rip), %r8      # 0x18f0d6
movl $0x1c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a05b
movl $0x8, %edi
leaq 0x3506f(%rip), %rsi     # 0x18f0d6
movl $0x1d, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_delete
void gt_csa_gene_delete(GtCSAGene *gene)
{
  GtUword i;
  if (!gene) return;
  for (i = 0; i < gt_array_size(gene->splice_forms); i++) {
    gt_csa_splice_form_delete(*(GtCSASpliceForm**)
                              gt_array_get(gene->splice_forms, i));
  }
  gt_array_delete(gene->splice_forms);
  gt_free(gene);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x15a0c3
jmp 0x15a13b
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x15a118
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x15a5a0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x15a0cc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rdi
leaq 0x34fa5(%rip), %rsi     # 0x18f0d6
movl $0x2c, %edx
callq 0xdab0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_genomic_range
GtRange gt_csa_gene_genomic_range(const GtCSAGene *gene)
{
  GtRange gene_range, tmp_range;
  GtUword i;
  gt_assert(gene);
  gene_range.start = ~0UL;
  gene_range.end = 0UL;
  for (i = 0; i < gt_array_size(gene->splice_forms); i++) {
    tmp_range = gt_csa_splice_form_genomic_range(*(GtCSASpliceForm**)
                                              gt_array_get(gene->splice_forms,
                                                           i));
    if (tmp_range.start < gene_range.start)
      gene_range.start = tmp_range.start;
    if (tmp_range.end > gene_range.end)
      gene_range.end = tmp_range.end;
  }
  return gene_range;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15a349
movq 0x59cc0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3d44(%rip), %rsi      # 0x15e066
leaq 0x351e7(%rip), %rdx     # 0x18f510
leaq 0x34ea8(%rip), %rcx     # 0x18f1d8
leaq 0x34d9f(%rip), %r8      # 0x18f0d6
movl $0x49, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a34b
movq $-0x1, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x15a401
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x15a8d0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x15a3d6
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x40(%rsp), %rax
jbe 0x15a3ec
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x15a3ee
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x15a366
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_new
GtCSASpliceForm* gt_csa_splice_form_new(void *spliced_alignment,
                                   GtGetGenomicRangeFunc get_genomic_range,
                                   GtGetStrandFunc get_strand)
{
  GtCSASpliceForm *splice_form;
  gt_assert(spliced_alignment && get_strand);
  splice_form = gt_malloc(sizeof (*splice_form));
  splice_form->spliced_alignments = gt_array_new(sizeof (void*));
  gt_array_add(splice_form->spliced_alignments, spliced_alignment);
  splice_form->get_genomic_range = get_genomic_range;
  splice_form->get_strand = get_strand;
  return splice_form;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x15a4f3
cmpq $0x0, 0x10(%rsp)
jne 0x15a52b
movq 0x59ade(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3b62(%rip), %rsi      # 0x15e066
leaq 0x34d19(%rip), %rdx     # 0x18f224
leaq 0x34d32(%rip), %rcx     # 0x18f244
leaq 0x34d42(%rip), %r8      # 0x18f25b
movl $0x21, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a52d
movl $0x18, %edi
leaq 0x34d22(%rip), %rsi     # 0x18f25b
movl $0x22, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_add_sa
void gt_csa_splice_form_add_sa(GtCSASpliceForm *splice_form,
                               void *spliced_alignment)
{
  gt_assert(splice_form);
  gt_assert(csa_splice_form_start(splice_form) <=
         splice_form->get_genomic_range(spliced_alignment).start);
  gt_assert(gt_csa_splice_form_strand(splice_form) ==
         splice_form->get_strand(spliced_alignment));
  gt_array_add(splice_form->spliced_alignments, spliced_alignment);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15a62e
movq 0x599db(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3a5f(%rip), %rsi      # 0x15e066
leaq 0x34ae8(%rip), %rdx     # 0x18f0f6
leaq 0x34c65(%rip), %rcx     # 0x18f27a
leaq 0x34c3f(%rip), %r8      # 0x18f25b
movl $0x3e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a630
jmp 0x15a632
movq 0x30(%rsp), %rdi
callq 0x15a730
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
cmpq 0x18(%rsp), %rax
jbe 0x15a6a2
movq 0x59967(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x39eb(%rip), %rsi      # 0x15e066
leaq 0x34c12(%rip), %rdx     # 0x18f294
leaq 0x34bf1(%rip), %rcx     # 0x18f27a
leaq 0x34bcb(%rip), %r8      # 0x18f25b
movl $0x40, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a6a4
jmp 0x15a6a6
movq 0x30(%rsp), %rdi
callq 0x15a780
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
je 0x15a706
movq 0x59903(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3987(%rip), %rsi      # 0x15e066
leaq 0x34c0c(%rip), %rdx     # 0x18f2f2
leaq 0x34b8d(%rip), %rcx     # 0x18f27a
leaq 0x34b67(%rip), %r8      # 0x18f25b
movl $0x42, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a708
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: csa_splice_form_start
static GtUword csa_splice_form_start(const GtCSASpliceForm *splice_form)
{
  return splice_form
         ->get_genomic_range(*(void**)
                             gt_array_get(splice_form->spliced_alignments, 0))
         .start;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_strand
GtStrand gt_csa_splice_form_strand(const GtCSASpliceForm *splice_form)
{
  gt_assert(splice_form);
  return splice_form->get_strand(*(void**)
                                 gt_array_get(splice_form->spliced_alignments,
                                              0));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x15a7c9
movq 0x59840(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x38c4(%rip), %rsi      # 0x15e066
leaq 0x3494d(%rip), %rdx     # 0x18f0f6
leaq 0x34bf0(%rip), %rcx     # 0x18f3a0
leaq 0x34aa4(%rip), %r8      # 0x18f25b
movl $0x69, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a7cb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_genomic_range
GtRange gt_csa_splice_form_genomic_range(const GtCSASpliceForm *splice_form)
{
  GtRange splice_form_range, tmp_range;
  GtUword i;
  gt_assert(splice_form);
  splice_form_range.start = ~0UL;
  splice_form_range.end = 0UL;
  for (i = 0; i < gt_array_size(splice_form->spliced_alignments); i++) {
    tmp_range = splice_form->get_genomic_range(*(void**)
                                               gt_array_get(splice_form
                                                         ->spliced_alignments,
                                                         i));
    if (tmp_range.start < splice_form_range.start)
      splice_form_range.start = tmp_range.start;
    if (tmp_range.end > splice_form_range.end)
      splice_form_range.end = tmp_range.end;
  }
  return splice_form_range;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x15a919
movq 0x596f0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3774(%rip), %rsi      # 0x15e066
leaq 0x347fd(%rip), %rdx     # 0x18f0f6
leaq 0x34a7f(%rip), %rcx     # 0x18f37f
leaq 0x34954(%rip), %r8      # 0x18f25b
movl $0x57, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15a91b
movq $-0x1, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x15a9ea
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
callq *%rax
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x15a9bf
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x50(%rsp), %rax
jbe 0x15a9d5
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x15a9d7
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x15a936
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/csa_variable_strands.c
// Function: gt_csa_variable_strands
GtArray* gt_csa_variable_strands(const void *set_of_sas,
                                 GtUword number_of_sas,
                                 size_t size_of_sa,
                                 GtGetGenomicRangeFunc get_genomic_range,
                                 GtGetStrandFunc get_strand,
                                 GtGetExonsFunc get_exons)
{
  StoreSpliceFormInfo info;
  GtArray *genes;
  gt_assert(set_of_sas && number_of_sas && size_of_sa);
  gt_assert(get_genomic_range && get_strand && get_exons);

  genes = gt_array_new(sizeof (GtCSAGene*));

  info.splice_forms = gt_array_new(sizeof (GtCSASpliceForm*));
  info.get_genomic_range = get_genomic_range;
  info.get_strand = get_strand;

  gt_consensus_sa(set_of_sas, number_of_sas, size_of_sa, get_genomic_range,
                  get_strand, get_exons, store_splice_form, &info);

  process_splice_forms(genes, info.splice_forms);

  gt_array_delete(info.splice_forms);

  return genes;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x15aa9a
cmpq $0x0, 0x58(%rsp)
je 0x15aa9a
cmpq $0x0, 0x50(%rsp)
jne 0x15aad2
movq 0x59537(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x35bb(%rip), %rsi      # 0x15e066
leaq 0x3492e(%rip), %rdx     # 0x18f3e0
leaq 0x34951(%rip), %rcx     # 0x18f40a
leaq 0x34962(%rip), %r8      # 0x18f422
movl $0x6b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15aad4
jmp 0x15aad6
cmpq $0x0, 0x48(%rsp)
je 0x15aaee
cmpq $0x0, 0x40(%rsp)
je 0x15aaee
cmpq $0x0, 0x38(%rsp)
jne 0x15ab26
movq 0x594e3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3567(%rip), %rsi      # 0x15e066
leaq 0x34940(%rip), %rdx     # 0x18f446
leaq 0x348fd(%rip), %rcx     # 0x18f40a
leaq 0x3490e(%rip), %r8      # 0x18f422
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x15ab28
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x18(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
leaq 0x41(%rip), %r10        # 0x15abc0
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x15b040
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15ad50
movq 0x20(%rsp), %rdi
callq 0x770a0
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)