LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_get
GtToolfunc gt_toolbox_get(const GtToolbox *tb, const char *toolname)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_hashmap_get(tb->tools, toolname);
  if (toolinfo)
    return toolinfo->toolfunc;
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x123921
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x123959
movq 0x518678(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f26e1(%rip), %rsi    # 0x516013
leaq 0x42114b(%rip), %rdx    # 0x544a84
leaq 0x4211ba(%rip), %rcx    # 0x544afa
leaq 0x42112a(%rip), %r8     # 0x544a71
movl $0x6a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12395b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe0f20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12398a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x123993
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_show
int gt_toolbox_show(GT_UNUSED const char *progname, void *toolbox,
                    GT_UNUSED GtError *err)
{
  GtToolbox *tb;
  GT_UNUSED int had_err = 0;
  gt_error_check(err);
  gt_assert(toolbox);
  tb = (GtToolbox*) toolbox;
  printf("\nTools:\n\n");
  had_err = gt_hashmap_foreach_in_key_order(tb->tools, show_tool_name, NULL,
                                            NULL);
  gt_assert(!had_err); /* show_tool_name() is sane */
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x123a0b
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1239d3
jmp 0x123a0b
movq 0x5185c6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f262f(%rip), %rsi    # 0x516013
leaq 0x3f27d4(%rip), %rdx    # 0x5161bf
leaq 0x421117(%rip), %rcx    # 0x544b09
leaq 0x421078(%rip), %r8     # 0x544a71
movl $0x87, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123a0d
jmp 0x123a0f
cmpq $0x0, 0x18(%rsp)
jne 0x123a4f
movq 0x518582(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f25eb(%rip), %rsi    # 0x516013
leaq 0x40b4b2(%rip), %rdx    # 0x52eee1
leaq 0x4210d3(%rip), %rcx    # 0x544b09
leaq 0x421034(%rip), %r8     # 0x544a71
movl $0x88, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123a51
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4210b7(%rip), %rdi    # 0x544b19
movb $0x0, %al
callq 0x19070
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x58(%rip), %rsi        # 0x123ad0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xe1200
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x123ac7
movq 0x51850a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2573(%rip), %rsi    # 0x516013
leaq 0x429160(%rip), %rdx    # 0x54cc07
leaq 0x42105b(%rip), %rcx    # 0x544b09
leaq 0x420fbc(%rip), %r8     # 0x544a71
movl $0x8d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123ac9
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: show_tool_name
static int show_tool_name(void *key, void *value, GT_UNUSED void *data,
                          GT_UNUSED GtError *err)
{
  GtToolinfo *toolinfo = value;
  gt_error_check(err);
  gt_assert(key && value);
  if (!toolinfo->hidden) {
    if (gt_createman)
      printf("- *%s*\n", (const char*) key);
    else
      gt_xputs(key);
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x123b41
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x123b09
jmp 0x123b41
movq 0x518490(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f24f9(%rip), %rsi    # 0x516013
leaq 0x3f269e(%rip), %rdx    # 0x5161bf
leaq 0x421019(%rip), %rcx    # 0x544b41
leaq 0x420f42(%rip), %r8     # 0x544a71
movl $0x77, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123b43
jmp 0x123b45
cmpq $0x0, 0x20(%rsp)
je 0x123b55
cmpq $0x0, 0x18(%rsp)
jne 0x123b8d
movq 0x518444(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f24ad(%rip), %rsi    # 0x516013
leaq 0x475a81(%rip), %rdx    # 0x5995ee
leaq 0x420fcd(%rip), %rcx    # 0x544b41
leaq 0x420ef6(%rip), %r8     # 0x544a71
movl $0x78, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123b8f
movq (%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x123bc6
leaq 0x51f040(%rip), %rax    # 0x642be0
testb $0x1, (%rax)
je 0x123bba
movq 0x20(%rsp), %rsi
leaq 0x420f9f(%rip), %rdi    # 0x544b50
movb $0x0, %al
callq 0x19070
jmp 0x123bc4
movq 0x20(%rsp), %rdi
callq 0x126e60
jmp 0x123bc6
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_iterate
void gt_toolbox_iterate(const GtToolbox *tb, GtToolboxIterator func, void *data)
{
  IterateInfo info;
  GT_UNUSED int had_err = 0;
  gt_assert(tb && func);
  info.func = func;
  info.data = data;
  had_err = gt_hashmap_foreach_in_key_order(tb->tools, toolbox_iterate, &info,
                                            NULL);
  gt_assert(!had_err); /* func() is sane */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x123bfb
cmpq $0x0, 0x28(%rsp)
jne 0x123c33
movq 0x51839e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2407(%rip), %rsi    # 0x516013
leaq 0x420f10(%rip), %rdx    # 0x544b23
leaq 0x420f14(%rip), %rcx    # 0x544b2e
leaq 0x420e50(%rip), %r8     # 0x544a71
movl $0xab, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123c35
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x58(%rip), %rsi        # 0x123cb0
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xe1200
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x123ca9
movq 0x518328(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2391(%rip), %rsi    # 0x516013
leaq 0x428f7e(%rip), %rdx    # 0x54cc07
leaq 0x420e9e(%rip), %rcx    # 0x544b2e
leaq 0x420dda(%rip), %r8     # 0x544a71
movl $0xb0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123cab
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: toolbox_iterate
static int toolbox_iterate(void *key, void *value, void *data,
                           GT_UNUSED GtError *err)
{
  const char *name = key;
  GtToolinfo *toolinfo = value;
  IterateInfo *info = data;
  gt_error_check(err);
  gt_assert(key && value && data);
  if (!toolinfo->hidden) {
    if (toolinfo->tool)
      info->func(name, toolinfo->tool, info->data);
    else
      gt_warning("skipping tool '%s' in iterator (not a GtTool object)", name);
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x123d35
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x123cfd
jmp 0x123d35
movq 0x51829c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2305(%rip), %rsi    # 0x516013
leaq 0x3f24aa(%rip), %rdx    # 0x5161bf
leaq 0x420e15(%rip), %rcx    # 0x544b31
leaq 0x420d4e(%rip), %r8     # 0x544a71
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123d37
jmp 0x123d39
cmpq $0x0, 0x30(%rsp)
je 0x123d51
cmpq $0x0, 0x28(%rsp)
je 0x123d51
cmpq $0x0, 0x20(%rsp)
jne 0x123d89
movq 0x518248(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f22b1(%rip), %rsi    # 0x516013
leaq 0x417b71(%rip), %rdx    # 0x53b8da
leaq 0x420dc1(%rip), %rcx    # 0x544b31
leaq 0x420cfa(%rip), %r8     # 0x544a71
movl $0x9d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123d8b
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x123dd6
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x123dc1
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq (%rsp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
jmp 0x123dd4
movq 0x10(%rsp), %rsi
leaq 0x420d8b(%rip), %rdi    # 0x544b58
movb $0x0, %al
callq 0x1267d0
jmp 0x123dd6
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/unit_testing.c
// Function: gt_unit_test_run
int gt_unit_test_run(void *key, void *value, void *data, GtError *err)
{
  int had_err, *had_errp;
  char *testname = key;
  GtUnitTestFunc test = value;
  gt_error_check(err);
  gt_assert(testname && test && data);
  had_errp = (int*) data;
  printf("%s...", testname);
  gt_xfflush(stdout);
  had_err = test(err);
  if (had_err) {
    gt_xputs("error");
    *had_errp = had_err;
    fprintf(stderr, "first error: %s\n", gt_error_get(err));
    gt_error_unset(err);
    gt_xfflush(stderr);
  }
  else
    gt_xputs("ok");
  gt_xfflush(stdout);
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x12660c
movq 0x28(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1265d4
jmp 0x12660c
movq 0x5159c5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3efa2e(%rip), %rsi    # 0x516013
leaq 0x3efbd3(%rip), %rdx    # 0x5161bf
leaq 0x41f9c6(%rip), %rcx    # 0x545fb9
leaq 0x41f9d0(%rip), %r8     # 0x545fca
movl $0x1a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12660e
jmp 0x126610
cmpq $0x0, 0x10(%rsp)
je 0x126628
cmpq $0x0, 0x8(%rsp)
je 0x126628
cmpq $0x0, 0x30(%rsp)
jne 0x126660
movq 0x515971(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ef9da(%rip), %rsi    # 0x516013
leaq 0x41f9a2(%rip), %rdx    # 0x545fe2
leaq 0x41f972(%rip), %rcx    # 0x545fb9
leaq 0x41f97c(%rip), %r8     # 0x545fca
movl $0x1b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x126662
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x472e6c(%rip), %rdi    # 0x5994e4
movb $0x0, %al
callq 0x19070
movq 0x5158b2(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
callq 0x1269c0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x126704
leaq 0x489184(%rip), %rdi    # 0x5af830
callq 0x126e60
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x5158dd(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xd8b20
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x41f919(%rip), %rsi    # 0x545ffb
movb $0x0, %al
callq 0x199f0
movq 0x28(%rsp), %rdi
callq 0xd8ac0
movq 0x5158a6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
callq 0x1269c0
jmp 0x126710
leaq 0x46d800(%rip), %rdi    # 0x593f0b
callq 0x126e60
movq 0x515821(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
callq 0x1269c0
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_new
GtAlignedSegmentsPile *gt_aligned_segments_pile_new(GtSamfileIterator *sfi,
    GtSamfileEncseqMapping *sem)
{
  GtAlignedSegmentsPile *asp;
  gt_assert(sfi != NULL);
  gt_assert(sem != NULL);
  asp = gt_malloc(sizeof (GtAlignedSegmentsPile));
  asp->sfi = sfi;
  asp->sem = sem;
  asp->set = gt_dlist_new(gt_aligned_segments_pile_compare_as);
  asp->all_consumed = false;
  asp->next_as = NULL;
  asp->process_complete = NULL;
  asp->process_complete_data = NULL;
  asp->process_unmapped = NULL;
  asp->process_unmapped_data = NULL;
  asp->process_skipped = NULL;
  asp->process_skipped_data = NULL;
  asp->position = GT_UNDEF_UWORD;
  asp->enable_edit_tracking = false;
  asp->delete_processed_segments = true;
  return asp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12930e
movq 0x512cc3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ecd2c(%rip), %rsi    # 0x516013
leaq 0x41d8b7(%rip), %rdx    # 0x546ba5
leaq 0x41d8bc(%rip), %rcx    # 0x546bb1
leaq 0x41d8d2(%rip), %r8     # 0x546bce
movl $0x36, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129310
jmp 0x129312
cmpq $0x0, 0x8(%rsp)
jne 0x129352
movq 0x512c7f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ecce8(%rip), %rsi    # 0x516013
leaq 0x41d8c1(%rip), %rdx    # 0x546bf3
leaq 0x41d878(%rip), %rcx    # 0x546bb1
leaq 0x41d88e(%rip), %r8     # 0x546bce
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129354
movl $0x68, %edi
leaq 0x41d86e(%rip), %rsi    # 0x546bce
movl $0x38, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
leaq -0x12e(%rip), %rdi      # 0x129260
callq 0xa5e50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $-0x1, 0x58(%rax)
movq (%rsp), %rax
movb $0x0, 0x60(%rax)
movq (%rsp), %rax
movb $0x1, 0x61(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_disable_segment_deletion
void gt_aligned_segments_pile_disable_segment_deletion(
    GtAlignedSegmentsPile *asp)
{
  gt_assert(asp != NULL);
  gt_assert(asp->process_skipped != NULL);
  gt_assert(asp->process_complete != NULL);
  gt_assert(asp->process_unmapped != NULL);
  asp->delete_processed_segments = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1295e4
movq 0x5129ed(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3eca56(%rip), %rsi    # 0x516013
leaq 0x41d63b(%rip), %rdx    # 0x546bff
leaq 0x41d6d8(%rip), %rcx    # 0x546ca3
leaq 0x41d5fc(%rip), %r8     # 0x546bce
movl $0xae, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1295e6
jmp 0x1295e8
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x12962b
movq 0x5129a6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3eca0f(%rip), %rsi    # 0x516013
leaq 0x41d6ca(%rip), %rdx    # 0x546cd5
leaq 0x41d691(%rip), %rcx    # 0x546ca3
leaq 0x41d5b5(%rip), %r8     # 0x546bce
movl $0xaf, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12962d
jmp 0x12962f
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x129672
movq 0x51295f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec9c8(%rip), %rsi    # 0x516013
leaq 0x41d6a0(%rip), %rdx    # 0x546cf2
leaq 0x41d64a(%rip), %rcx    # 0x546ca3
leaq 0x41d56e(%rip), %r8     # 0x546bce
movl $0xb0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129674
jmp 0x129676
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1296b9
movq 0x512918(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec981(%rip), %rsi    # 0x516013
leaq 0x41d677(%rip), %rdx    # 0x546d10
leaq 0x41d603(%rip), %rcx    # 0x546ca3
leaq 0x41d527(%rip), %r8     # 0x546bce
movl $0xb1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1296bb
movq (%rsp), %rax
movb $0x0, 0x61(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_delete_finishing_before
static void gt_aligned_segments_pile_delete_finishing_before(
    GtAlignedSegmentsPile *asp, GtUword position)
{
  GtDlistelem *dlistelem, *dlistelem_to_remove = NULL;
  for (dlistelem = gt_dlist_first(asp->set); dlistelem != NULL;
       dlistelem = gt_dlistelem_next(dlistelem))
  {
    GtAlignedSegment *as;
    if (dlistelem_to_remove != NULL)
    {
      gt_dlist_remove(asp->set, dlistelem_to_remove);
      dlistelem_to_remove = NULL;
    }
    as = gt_dlistelem_get_data(dlistelem);
    if (gt_aligned_segment_refregion_endpos(as) < position)
    {
      if (asp->process_complete != NULL)
      {
        asp->process_complete(as, asp->process_complete_data);
      }
      if (asp->delete_processed_segments)
        gt_aligned_segment_delete(as);
      /* delay elem removal to avoid disrupting list traversal */
      dlistelem_to_remove = dlistelem;
    }
    else
    {
      break;
    }
  }
  if (dlistelem_to_remove != NULL)
  {
    gt_dlist_remove(asp->set, dlistelem_to_remove);
    dlistelem_to_remove = NULL;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa5f40
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x129a24
cmpq $0x0, 0x8(%rsp)
je 0x1299aa
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa6660
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa60d0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x4883a0
cmpq 0x18(%rsp), %rax
jae 0x129a0c
movq 0x20(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1299ec
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x30(%rcx), %rsi
callq *%rax
movq 0x20(%rsp), %rax
testb $0x1, 0x61(%rax)
je 0x129a00
movq (%rsp), %rdi
callq 0x488de0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x129a0e
jmp 0x129a24
jmp 0x129a10
movq 0x10(%rsp), %rdi
callq 0xa6120
movq %rax, 0x10(%rsp)
jmp 0x12997a
cmpq $0x0, 0x8(%rsp)
je 0x129a48
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa6660
movq $0x0, 0x8(%rsp)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_fetch_sa
static int gt_aligned_segments_pile_fetch_sa(GtAlignedSegmentsPile *asp)
{
  int retvalue;
  GtSamAlignment *sa;
  gt_assert(asp != NULL);
  gt_assert(asp->next_as == NULL);
  while (true)
  {
    retvalue = gt_samfile_iterator_next(asp->sfi, &sa);
    if (retvalue == -1 || !gt_sam_alignment_is_unmapped(sa))
      break;
    if (!gt_sam_alignment_is_secondary(sa))
    {
      if (asp->process_unmapped != NULL)
      {
        GtAlignedSegment *as = gt_aligned_segment_new_from_sa(sa, asp->sem);
        if (asp->enable_edit_tracking)
          gt_aligned_segment_enable_edit_tracking(as);
        asp->process_unmapped(as, asp->process_unmapped_data);
        if (asp->delete_processed_segments)
          gt_aligned_segment_delete(as);
      }
    }
  }
  if (retvalue != -1)
  {
    asp->next_as = gt_aligned_segment_new_from_sa(sa, asp->sem);
    if (asp->enable_edit_tracking)
      gt_aligned_segment_enable_edit_tracking(asp->next_as);
  }
  return retvalue;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x129a99
movq 0x512538(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec5a1(%rip), %rsi    # 0x516013
leaq 0x41d186(%rip), %rdx    # 0x546bff
leaq 0x41d390(%rip), %rcx    # 0x546e10
leaq 0x41d147(%rip), %r8     # 0x546bce
movl $0x69, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129a9b
jmp 0x129a9d
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x129ae1
movq 0x5124f0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec559(%rip), %rsi    # 0x516013
leaq 0x41d2fe(%rip), %rdx    # 0x546dbf
leaq 0x41d348(%rip), %rcx    # 0x546e10
leaq 0x41d0ff(%rip), %r8     # 0x546bce
movl $0x6a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129ae3
jmp 0x129ae5
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1cfa30
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x129b10
movq 0x10(%rsp), %rdi
callq 0x1ceb90
testb $0x1, %al
jne 0x129b12
jmp 0x129b90
movq 0x10(%rsp), %rdi
callq 0x1ceea0
testb $0x1, %al
jne 0x129b8b
movq 0x20(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x129b89
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x487c70
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x60(%rax)
je 0x129b59
movq 0x8(%rsp), %rdi
callq 0x488090
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x40(%rcx), %rsi
callq *%rax
movq 0x20(%rsp), %rax
testb $0x1, 0x61(%rax)
je 0x129b87
movq 0x8(%rsp), %rdi
callq 0x488de0
jmp 0x129b89
jmp 0x129b8b
jmp 0x129ae5
cmpl $-0x1, 0x1c(%rsp)
je 0x129bd1
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x487c70
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
testb $0x1, 0x60(%rax)
je 0x129bcf
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x488090
jmp 0x129bd1
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_flush
void gt_aligned_segments_pile_flush(GtAlignedSegmentsPile *asp,
    bool skip_remaining)
{
  gt_assert(asp != NULL);
  gt_aligned_segments_pile_delete_finishing_before(asp, ULONG_MAX);
  if (asp->next_as != NULL)
  {
    if (skip_remaining && asp->process_skipped != NULL)
    {
      asp->process_skipped(asp->next_as, asp->process_skipped_data);
    }
    if (asp->delete_processed_segments)
      gt_aligned_segment_delete(asp->next_as);
    asp->next_as = NULL;
  }
  if (skip_remaining && asp->process_skipped != NULL)
  {
    int retvalue = 0;
    while (retvalue != -1)
    {
      retvalue = gt_aligned_segments_pile_fetch_sa(asp);
      if (asp->next_as != NULL)
      {
        asp->process_skipped(asp->next_as, asp->process_skipped_data);
      }
      if (asp->delete_processed_segments)
        gt_aligned_segment_delete(asp->next_as);
      asp->next_as = NULL;
    }
  }
  gt_assert(asp->next_as == NULL);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x129c82
movq 0x51234f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec3b8(%rip), %rsi    # 0x516013
leaq 0x41cf9d(%rip), %rdx    # 0x546bff
leaq 0x41d188(%rip), %rcx    # 0x546df1
leaq 0x41cf5e(%rip), %r8     # 0x546bce
movl $0xff, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129c84
movq 0x10(%rsp), %rdi
movq $-0x1, %rsi
callq 0x129950
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x129cf7
testb $0x1, 0xf(%rsp)
je 0x129cd1
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x129cd1
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rsi
callq *%rax
movq 0x10(%rsp), %rax
testb $0x1, 0x61(%rax)
je 0x129cea
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x488de0
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
testb $0x1, 0xf(%rsp)
je 0x129d7a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x129d7a
movl $0x0, 0x8(%rsp)
cmpl $-0x1, 0x8(%rsp)
je 0x129d78
movq 0x10(%rsp), %rdi
callq 0x129a50
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x129d50
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rsi
callq *%rax
movq 0x10(%rsp), %rax
testb $0x1, 0x61(%rax)
je 0x129d69
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x488de0
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x129d12
jmp 0x129d7a
jmp 0x129d7c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x129dc0
movq 0x512211(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec27a(%rip), %rsi    # 0x516013
leaq 0x41d01f(%rip), %rdx    # 0x546dbf
leaq 0x41d04a(%rip), %rcx    # 0x546df1
leaq 0x41ce20(%rip), %r8     # 0x546bce
movl $0x11a, %r9d            # imm = 0x11A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129dc2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segments_pile.c
// Function: gt_aligned_segments_pile_delete
void gt_aligned_segments_pile_delete(GtAlignedSegmentsPile *asp)
{
  if (asp != NULL)
  {
    gt_aligned_segments_pile_flush(asp, true);
    gt_dlist_delete(asp->set);
    gt_free(asp);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x129e0c
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x129c30
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa6910
movq (%rsp), %rdi
leaq 0x41cdcc(%rip), %rsi    # 0x546bce
movl $0x123, %edx            # imm = 0x123
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_new
GtAlignment* gt_alignment_new(void)
{
  GtAlignment *alignment;
  alignment = gt_calloc((size_t) 1, sizeof (GtAlignment));
  alignment->aligned_range_u.start = 0;
  alignment->aligned_range_u.end = 0;
  alignment->aligned_range_v.start = 0;
  alignment->aligned_range_v.end = 0;
  alignment->eops = gt_multieoplist_new();
  alignment->u = alignment->v = NULL;
  alignment->alilen = alignment->ulen = alignment->vlen = 0;
  return alignment;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x50, %esi
leaq 0x41d026(%rip), %rdx    # 0x546e48
movl $0x38, %ecx
callq 0xe83c0
movq %rax, (%rsp)
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)
callq 0x1af960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_new_with_seqs
GtAlignment* gt_alignment_new_with_seqs(const GtUchar *u, GtUword ulen,
                                        const GtUchar *v, GtUword vlen)
{
  GtAlignment *alignment;

  gt_assert(u != NULL && v != NULL);
  alignment = gt_alignment_new();
  gt_alignment_set_seqs(alignment, u, ulen, v, vlen);
  return alignment;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x129ee8
cmpq $0x0, 0x10(%rsp)
jne 0x129f20
movq 0x5120b1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec11a(%rip), %rsi    # 0x516013
leaq 0x41cf91(%rip), %rdx    # 0x546e91
leaq 0x41cf5a(%rip), %rcx    # 0x546e61
leaq 0x41cf3a(%rip), %r8     # 0x546e48
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129f22
callq 0x129e10
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x129f60
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_set_seqs
void gt_alignment_set_seqs(GtAlignment *alignment, const GtUchar *u,
                           GtUword ulen, const GtUchar *v,
                           GtUword vlen)
{
  gt_assert(alignment != NULL && u != NULL && v != NULL);
  alignment->u = u;
  alignment->v = v;
  alignment->ulen = ulen;
  alignment->vlen = vlen;
  alignment->aligned_range_u.start = alignment->aligned_range_v.start = 0;
  alignment->aligned_range_u.end = ulen - 1;
  alignment->aligned_range_v.end = vlen - 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x129f94
cmpq $0x0, 0x18(%rsp)
je 0x129f94
cmpq $0x0, 0x8(%rsp)
jne 0x129fcc
movq 0x512005(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ec06e(%rip), %rsi    # 0x516013
leaq 0x41ced0(%rip), %rdx    # 0x546e7c
leaq 0x41cef5(%rip), %rcx    # 0x546ea8
leaq 0x41ce8e(%rip), %r8     # 0x546e48
movl $0x52, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x129fce
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
subq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_set_multieop_list
void gt_alignment_set_multieop_list(GtAlignment *alignment,
                                    GtMultieoplist *eoplist)
{
  gt_assert(alignment != NULL && eoplist != NULL);
  gt_multieoplist_delete(alignment->eops);
  alignment->eops = gt_multieoplist_ref(eoplist);
  alignment->alilen = gt_multieoplist_get_num_entries(eoplist);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12a06e
cmpq $0x0, 0x8(%rsp)
jne 0x12a0a6
movq 0x511f2b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ebf94(%rip), %rsi    # 0x516013
leaq 0x41ce38(%rip), %rdx    # 0x546ebe
leaq 0x41ce56(%rip), %rcx    # 0x546ee3
leaq 0x41cdb4(%rip), %r8     # 0x546e48
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12a0a8
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1afba0
movq 0x8(%rsp), %rdi
callq 0x1afb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rdi
callq 0x1b0390
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_is_valid
static bool gt_alignment_is_valid(const GtAlignment *alignment)
{
  GtUword len;
  /* check ulen */
  len = gt_multieoplist_get_repdel_length(alignment->eops);
  if (len != alignment->ulen) {
    printf("ulen: " GT_WU ", repdel: " GT_WU "\n", alignment->ulen, len);
    return false;
  }
  /* check vlen */
  len = gt_multieoplist_get_repins_length(alignment->eops);
  if (len != alignment->vlen) {
    printf("vlen: " GT_WU ", repins: " GT_WU "\n", alignment->vlen, len);
    return false;
  }
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1b0130
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
je 0x12a95c
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq (%rsp), %rdx
leaq 0x41c969(%rip), %rdi    # 0x5472b7
movb $0x0, %al
callq 0x19070
movb $0x0, 0x17(%rsp)
jmp 0x12a9a4
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1b0200
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x40(%rcx), %rax
je 0x12a99f
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq (%rsp), %rdx
leaq 0x41c93e(%rip), %rdi    # 0x5472cf
movb $0x0, %al
callq 0x19070
movb $0x0, 0x17(%rsp)
jmp 0x12a9a4
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_eval_with_mapped_score
GtWord gt_alignment_eval_with_mapped_score(const GtUchar *characters,
                                           const GtAlignment *alignment,
                                           GtWord matchscore,
                                           GtWord mismatchscore,
                                           GtWord gapscore)
{
  return gt_alignment_eval_generic_with_score(true, false, characters,
                                              alignment,
                                              NULL, matchscore, mismatchscore,
                                              gapscore);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %rax
movl $0x1, %edi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x12aa30
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_eval_with_scorematrix
GtWord gt_alignment_eval_with_scorematrix(const GtUchar *characters,
                                          const GtAlignment *alignment,
                                          const GtScoreMatrix *scorematrix,
                                          GtWord gapscore)
{
  return gt_alignment_eval_generic_with_score(true,
                                              false,
                                              characters,
                                              alignment,
                                              scorematrix,
                                              GT_WORD_MAX,
                                              GT_WORD_MAX,
                                              gapscore);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rax
movl $0x1, %edi
xorl %esi, %esi
movabsq $0x7fffffffffffffff, %r10 # imm = 0x7FFFFFFFFFFFFFFF
movq %r10, %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x12aa30
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_eval_with_affine_score
GtWord gt_alignment_eval_with_affine_score(const GtAlignment *alignment,
                                           bool downcase,
                                           GtWord matchscore,
                                           GtWord mismatchscore,
                                           GtWord gap_opening,
                                           GtWord gap_extension)
{
  return gt_alignment_eval_generic_with_affine_score(false,
                                                     downcase,
                                                     NULL,
                                                     alignment,
                                                     NULL,
                                                     matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movb 0x3f(%rsp), %dl
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %rax
xorl %edi, %edi
xorl %esi, %esi
movl %esi, %r8d
andb $0x1, %dl
movzbl %dl, %esi
movq %r8, %rdx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x12af20
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_eval_with_mapped_affine_score
GtWord gt_alignment_eval_with_mapped_affine_score(const GtUchar *characters,
                                                  const GtAlignment *alignment,
                                                  GtWord matchscore,
                                                  GtWord mismatchscore,
                                                  GtWord gap_opening,
                                                  GtWord gap_extension)
{
  return gt_alignment_eval_generic_with_affine_score(true,
                                                     false,
                                                     characters,
                                                     alignment,
                                                     NULL,
                                                     matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %rax
movl $0x1, %edi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x12af20
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_eval_with_affine_scorematrix
GtWord gt_alignment_eval_with_affine_scorematrix(
                                      const GtUchar *characters,
                                      const GtAlignment *alignment,
                                      const GtScoreMatrix *scorematrix,
                                      GtWord gap_opening,
                                      GtWord gap_extension)
{
  return gt_alignment_eval_generic_with_affine_score(true,
                                                     false,
                                                     characters,
                                                     alignment,
                                                     scorematrix,
                                                     GT_WORD_MAX,
                                                     GT_WORD_MAX,
                                                     gap_opening,
                                                     gap_extension);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %rax
movl $0x1, %edi
xorl %esi, %esi
movabsq $0x7fffffffffffffff, %r11 # imm = 0x7FFFFFFFFFFFFFFF
movq %r11, %r9
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x12af20
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_show_advance
static unsigned int gt_alignment_show_advance(unsigned int pos,
                                              unsigned int width,
                                              const GtUchar *topbuf,
                                              FILE *fp)
{
  gt_assert(width > 0);
  if (pos < width - 1)
  {
    return pos + 1;
  }
  gt_assert(pos == width - 1);
  fwrite(topbuf,sizeof *topbuf,3 * (width+1),fp);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
ja 0x12bc45
movq 0x51038c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ea3f5(%rip), %rsi    # 0x516013
leaq 0x48bba7(%rip), %rdx    # 0x5b77cc
leaq 0x41b70c(%rip), %rcx    # 0x547338
leaq 0x41b215(%rip), %r8     # 0x546e48
movl $0x206, %r9d            # imm = 0x206
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12bc47
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x12bc63
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x12bcd8
jmp 0x12bc65
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x12bcac
movq 0x510325(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ea38e(%rip), %rsi    # 0x516013
leaq 0x41b6c6(%rip), %rdx    # 0x547352
leaq 0x41b6a5(%rip), %rcx    # 0x547338
leaq 0x41b1ae(%rip), %r8     # 0x546e48
movl $0x20b, %r9d            # imm = 0x20B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12bcae
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
imull $0x3, %eax, %eax
movl %eax, %eax
movl %eax, %edx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x19ea0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_check_match
static int gt_alignment_check_match(const GtAlignment *alignment,GtError *err)
{
  GtUword idx;

  gt_assert(alignment->u != NULL && alignment->v != NULL &&
            alignment->ulen == alignment->vlen);
  for (idx = 0; idx < alignment->ulen; idx++)
  {
    GtUchar cc_u = alignment->u[idx];
    GtUchar cc_v = alignment->v[idx];
    if (GT_ISSPECIAL(cc_u) || GT_ISSPECIAL(cc_v) || cc_u != cc_v)
    {
      if (err == NULL)
      {
        fprintf(stderr,"mismatch at position " GT_WU ": cc_u = %c != %c"
                         " = cc_v\n",idx,cc_u,cc_v);
        exit(GT_EXIT_PROGRAMMING_ERROR);
      } else
      {
        gt_error_set(err,"mismatch at position " GT_WU ": cc_u = %c != %c"
                         " = cc_v",idx,cc_u,cc_v);
        return -1;
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x12c18a
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x12c18a
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x40(%rcx), %rax
je 0x12c1c2
movq 0x50fe0f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e9e78(%rip), %rsi    # 0x516013
leaq 0x41b1c1(%rip), %rdx    # 0x547363
leaq 0x41b20d(%rip), %rcx    # 0x5473b6
leaq 0x41ac98(%rip), %r8     # 0x546e48
movl $0x2cb, %r9d            # imm = 0x2CB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12c1c4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x12c2ad
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jge 0x12c231
movzbl 0x6(%rsp), %eax
cmpl $0xfe, %eax
jge 0x12c231
movzbl 0x7(%rsp), %eax
movzbl 0x6(%rsp), %ecx
cmpl %ecx, %eax
je 0x12c298
cmpq $0x0, 0x10(%rsp)
jne 0x12c26b
movq 0x50fd60(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movzbl 0x7(%rsp), %ecx
movzbl 0x6(%rsp), %r8d
leaq 0x41b175(%rip), %rsi    # 0x5473cf
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movzbl 0x7(%rsp), %ecx
movzbl 0x6(%rsp), %r8d
leaq 0x41b17a(%rip), %rsi    # 0x547401
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x12c2b5
jmp 0x12c29a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x12c1cd
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_show_with_mapped_chars
void gt_alignment_show_with_mapped_chars(const GtAlignment *alignment,
                                         const GtUchar *characters,
                                         GtUchar wildcardshow,
                                         FILE *fp,
                                         unsigned int width)
{
  GtUchar *buffer = gt_alignment_buffer_new(width);

  gt_assert(characters != NULL);
  gt_alignment_show_generic(buffer,false,alignment, fp, width, characters,
                            wildcardshow);
  gt_alignment_buffer_delete(buffer);
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x12bf20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x12c32c
movq 0x50fca5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e9d0e(%rip), %rsi    # 0x516013
leaq 0x41aed6(%rip), %rdx    # 0x5471e2
leaq 0x41aee2(%rip), %rcx    # 0x5471f5
leaq 0x41ab2e(%rip), %r8     # 0x546e48
movl $0x31a, %r9d            # imm = 0x31A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12c32e
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
movq 0x28(%rsp), %r9
xorl %esi, %esi
movzbl 0x27(%rsp), %eax
movl %eax, (%rsp)
callq 0x12b440
movq 0x8(%rsp), %rdi
callq 0x12bf60
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_clone
void gt_alignment_clone(const GtAlignment *alignment_from,
                        GtAlignment *alignment_to)
{
  gt_assert(alignment_from != NULL && alignment_to != NULL);

  alignment_to->u = alignment_from->u;
  alignment_to->v = alignment_from->v;
  alignment_to->ulen = alignment_from->ulen;
  alignment_to->vlen = alignment_from->vlen;
  alignment_to->aligned_range_u = alignment_from->aligned_range_u;
  alignment_to->aligned_range_v = alignment_from->aligned_range_v;
  gt_multieoplist_clone(alignment_to->eops,alignment_from->eops);
  alignment_to->alilen = alignment_from->alilen;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12c43e
cmpq $0x0, 0x8(%rsp)
jne 0x12c476
movq 0x50fb5b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3e9bc4(%rip), %rsi    # 0x516013
leaq 0x41ade3(%rip), %rdx    # 0x547239
leaq 0x41ae0b(%rip), %rcx    # 0x547268
leaq 0x41a9e4(%rip), %r8     # 0x546e48
movl $0x330, %r9d            # imm = 0x330
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12c478
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x1afa50
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq