LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_do_not_overlap
bool gt_ranges_do_not_overlap(const GtArray *ranges)
{
  GtUword i;

  gt_assert(ranges && gt_array_size(ranges));

  for (i = 1; i < gt_array_size(ranges); i++) {
    if (gt_range_overlap(gt_array_get(ranges, i-1), gt_array_get(ranges, i)))
      return false;
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x95711
movq 0x18(%rsp), %rdi
callq 0x76490
cmpq $0x0, %rax
jne 0x95749
movq 0x11e8c0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc8944(%rip), %rsi     # 0x15e066
leaq 0xdacc5(%rip), %rdx     # 0x1703ee
leaq 0xdacde(%rip), %rcx     # 0x17040e
leaq 0xda8d4(%rip), %r8      # 0x17000b
movl $0x159, %r9d            # imm = 0x159
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9574b
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x957c6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x75c80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x93c40
testb $0x1, %al
jne 0x957ad
jmp 0x957b4
movb $0x0, 0x27(%rsp)
jmp 0x957cb
jmp 0x957b6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x95754
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_equal
bool gt_ranges_are_equal(const GtArray *ranges_1, const GtArray *ranges_2)
{
  GtUword i;

  gt_assert(gt_ranges_are_sorted(ranges_1) && gt_ranges_are_sorted(ranges_2));

  if (gt_array_size(ranges_1) != gt_array_size(ranges_2))
    return false;

  for (i = 0; i < gt_array_size(ranges_1); i++) {
    if (gt_range_compare(gt_array_get(ranges_1, i), gt_array_get(ranges_2, i)))
      return false;
  }

  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x95610
testb $0x1, %al
jne 0x9583e
jmp 0x9584c
movq 0x20(%rsp), %rdi
callq 0x95610
testb $0x1, %al
jne 0x95884
movq 0x11e785(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc8809(%rip), %rsi     # 0x15e066
leaq 0xdabc3(%rip), %rdx     # 0x170427
leaq 0xdabfd(%rip), %rcx     # 0x170468
leaq 0xda799(%rip), %r8      # 0x17000b
movl $0x16b, %r9d            # imm = 0x16B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x95886
movq 0x28(%rsp), %rdi
callq 0x76490
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x958b3
movb $0x0, 0x37(%rsp)
jmp 0x9592e
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x95929
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x93850
cmpl $0x0, %eax
je 0x95917
movb $0x0, 0x37(%rsp)
jmp 0x9592e
jmp 0x95919
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x958bc
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: generic_ranges_uniq_in_place
static GtArray* generic_ranges_uniq_in_place(GtArray *ranges, bool count)
{
  GtArray *out_ranges, *count_array;
  gt_assert(ranges);
  out_ranges = gt_array_new(sizeof (GtRange));
  count_array = generic_ranges_uniq(out_ranges, ranges, count);
  gt_array_reset(ranges);
  gt_array_add_array(ranges, out_ranges); /* XXX: could be more efficient
                                               with something like
                                               gt_array_replace(ranges,
                                                             out_ranges) */
  gt_array_delete(out_ranges);
  return count_array;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x95bc2
movq 0x11e447(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc84cb(%rip), %rsi     # 0x15e066
leaq 0xe492f(%rip), %rdx     # 0x17a4d1
leaq 0xdab0b(%rip), %rcx     # 0x1706b4
leaq 0xda45b(%rip), %r8      # 0x17000b
movl $0x19f, %r9d            # imm = 0x19F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x95bc4
movl $0x10, %edi
callq 0x75ab0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x95940
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x765c0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x763b0
movq 0x10(%rsp), %rdi
callq 0x770a0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_consecutive
bool gt_ranges_are_consecutive(const GtArray *ranges)
{
  GtUword i;
  for (i = 0; i < gt_array_size(ranges); i++) {
    gt_assert(((GtRange*) gt_array_get(ranges, i))->start <=
              ((GtRange*) gt_array_get(ranges, i))->end);
    if (i) {
      /* check if ranges are consecutive */
      if (((GtRange*) gt_array_get(ranges, i-1))->end >=
          ((GtRange*) gt_array_get(ranges, i))->start) {
        return false;
      }
    }
  }
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x95d25
jmp 0x95c59
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x95cc5
movq 0x11e344(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc83c8(%rip), %rsi     # 0x15e066
leaq 0xda849(%rip), %rdx     # 0x1704ee
leaq 0xda89b(%rip), %rcx     # 0x170547
leaq 0xda358(%rip), %r8      # 0x17000b
movl $0x1c8, %r9d            # imm = 0x1C8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x95cc7
cmpq $0x0, 0x20(%rsp)
je 0x95d10
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
jb 0x95d0e
movb $0x0, 0x37(%rsp)
jmp 0x95d2a
jmp 0x95d10
jmp 0x95d12
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x95c32
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_total_length
GtUword gt_ranges_total_length(const GtArray *ranges)
{
  GtUword i, totallen = 0;
  GtRange *range;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    totallen += range->end - range->start + 1;
  }
  return totallen;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x95d92
movq 0x11e277(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc82fb(%rip), %rsi     # 0x15e066
leaq 0xe475f(%rip), %rdx     # 0x17a4d1
leaq 0xda7e8(%rip), %rcx     # 0x170561
leaq 0xda28b(%rip), %r8      # 0x17000b
movl $0x1d8, %r9d            # imm = 0x1D8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x95d94
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x95dff
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
subq (%rcx), %rax
addq $0x1, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x95d9d
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_spanned_length
GtUword gt_ranges_spanned_length(const GtArray *ranges)
{
  GtRange spanned_range;
  gt_assert(ranges);
  spanned_range.start = ((GtRange*) gt_array_get_first(ranges))->start;
  spanned_range.end   = ((GtRange*) gt_array_get_last(ranges))->end;
  return gt_range_length(&spanned_range);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x95e59
movq 0x11e1b0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc8234(%rip), %rsi     # 0x15e066
leaq 0xe4698(%rip), %rdx     # 0x17a4d1
leaq 0xda738(%rip), %rcx     # 0x170578
leaq 0xda1c4(%rip), %r8      # 0x17000b
movl $0x1e3, %r9d            # imm = 0x1E3
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x95e5b
movq 0x10(%rsp), %rdi
callq 0x75d00
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x75d20
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x93bd0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_borders_are_in_region
bool gt_ranges_borders_are_in_region(GtArray *ranges, const GtRange *region)
{
  gt_assert(ranges && region);

  /* check region start */
  if (((GtRange*) gt_array_get_first(ranges))->start < region->start)
    return false;

  /* check region end */
  if (((GtRange*) gt_array_get_last(ranges))->end > region->end)
    return false;

  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x960cc
cmpq $0x0, (%rsp)
jne 0x96104
movq 0x11df05(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc7f89(%rip), %rsi     # 0x15e066
leaq 0xda552(%rip), %rdx     # 0x170636
leaq 0xda55c(%rip), %rcx     # 0x170647
leaq 0xd9f19(%rip), %r8      # 0x17000b
movl $0x20a, %r9d            # imm = 0x20A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x96106
movq 0x8(%rsp), %rdi
callq 0x75d00
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0x96123
movb $0x0, 0x17(%rsp)
jmp 0x96147
movq 0x8(%rsp), %rdi
callq 0x75d20
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x96142
movb $0x0, 0x17(%rsp)
jmp 0x96147
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_show
void gt_ranges_show(GtArray *ranges, GtFile *outfp)
{
  GtRange *range;
  GtUword i;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    gt_file_xprintf(outfp, "("GT_WU","GT_WU")", range->start, range->end);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x961ae
movq 0x11de5b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc7edf(%rip), %rsi     # 0x15e066
leaq 0xe4343(%rip), %rdx     # 0x17a4d1
leaq 0xda4d2(%rip), %rcx     # 0x170667
leaq 0xd9e6f(%rip), %r8      # 0x17000b
movl $0x21b, %r9d            # imm = 0x21B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x961b0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x96220
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0xda46d(%rip), %rsi     # 0x170676
movb $0x0, %al
callq 0x837b0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x961b9
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0x83a70
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_abs_check_func
int gt_safe_abs_check_func(int j, const char *src_file, int src_line,
                      GtOverflowHandlerFunc handler_func, void *data)
{
  int rval = j < 0 ? -j : j;
  if (rval < 0) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return rval;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0x962ae
xorl %eax, %eax
subl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x962b6
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x962da
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_labs_check_func
GtWord gt_safe_labs_check_func(GtWord j, const char *src_file, int src_line,
                             GtOverflowHandlerFunc handler_func, void *data)
{
  GtWord rval = j < 0 ? -j : j;
  if (rval < 0) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return rval;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jge 0x96321
xorl %eax, %eax
subq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9632a
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x96350
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_llabs_check_func
GtInt64 gt_safe_llabs_check_func(GtInt64 j, const char *src_file, int src_line,
                                 GtOverflowHandlerFunc handler_func, void *data)
{
  GtInt64 rval = j < 0 ? -j : j;
  if (rval < 0) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return rval;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jge 0x96391
xorl %eax, %eax
subq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9639a
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x963c0
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_mult_u32_check_func
uint32_t gt_safe_mult_u32_check_func(uint32_t a, uint32_t b,
                                     const char *src_file, int src_line,
                                     GtOverflowHandlerFunc handler_func,
                                     void *data)
{
  GtUint64 x = (GtUint64) a * b;
  if (x > 0xffffffff) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return x;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movl 0x34(%rsp), %eax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x8(%rsp)
jbe 0x96421
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_mult_u64_check_func
uint64_t gt_safe_mult_u64_check_func(uint64_t a, uint64_t b,
                                     const char *src_file, int src_line,
                                     GtOverflowHandlerFunc handler_func,
                                     void *data)
{
  uint32_t a_hi = a >> 32,
           a_lo = a & 0xffffffff,
           b_hi = b >> 32,
           b_lo = b & 0xffffffff;
  /*
     x = 0xffffffff
     a = a_hi*x + a_lo
     b = b_hi*x + b_lo
     a * b = (a_hi*x + a_lo) * (b_hi*x + b_lo)
           = a_hi*x*b_hi*x + a_hi*x*b_lo + a_lo*b_hi*x + a_lo*b_lo
  */
  if (a_hi && b_hi) {    /* overflow */
    handler_func(src_file, src_line, data);
  }
  a = (uint64_t)(a_hi) * b_lo + (uint64_t)(a_lo) * b_hi;
  if (a > 0xffffffff) {  /* overflow */
    handler_func(src_file, src_line, data);
  }
  return (a << 32) + (uint64_t)(a_lo) * b_lo;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
shrq $0x20, %rax
movl %eax, 0x14(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq 0x40(%rsp), %rax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rax
shrq $0x20, %rax
movl %eax, 0xc(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq 0x38(%rsp), %rax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x964b4
cmpl $0x0, 0xc(%rsp)
je 0x964b4
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rdx
callq *%rax
movl 0x14(%rsp), %eax
movl 0x8(%rsp), %ecx
imulq %rcx, %rax
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x40(%rsp)
jbe 0x964f5
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x40(%rsp), %rax
shlq $0x20, %rax
movl 0x10(%rsp), %ecx
movl 0x8(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_mult_ulong_check_func
GtUword gt_safe_mult_ulong_check_func(GtUword a, GtUword b,
                                            const char *src_file, int src_line,
                                            GtOverflowHandlerFunc handler_func,
                                            void *data)
{
  gt_assert(sizeof (GtUword) == 4 || sizeof (GtUword) == 8);
  if (sizeof (GtUword) == 4) {
    return gt_safe_mult_u32_check_func(a, b, src_file, src_line, handler_func,
                                       data);
  } else { /* sizeof (GtUword) == 8 */
    return gt_safe_mult_u64_check_func(a, b, src_file, src_line, handler_func,
                                       data);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
jmp 0x96543
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x96430
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_create
GtSequenceBuffer*
gt_sequence_buffer_create(const GtSequenceBufferClass *sic)
{
  GtSequenceBuffer *si;
  gt_assert(sic && sic->size);
  si = gt_calloc(1, sic->size);
  si->c_class = sic;
  si->pvt = gt_calloc(1, sizeof (GtSequenceBufferMembers));
  return si;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9b4cc
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x9b504
movq 0x118b05(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc2b89(%rip), %rsi     # 0x15e066
leaq 0xd5946(%rip), %rdx     # 0x170e2a
leaq 0xd5950(%rip), %rcx     # 0x170e3b
leaq 0xd5963(%rip), %r8      # 0x170e55
movl $0x24, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9b506
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0xd593b(%rip), %rdx     # 0x170e55
movl $0x25, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x6088, %esi           # imm = 0x6088
leaq 0xd590e(%rip), %rdx     # 0x170e55
movl $0x27, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_delete
void gt_sequence_buffer_delete(GtSequenceBuffer *si)
{
  if (!si) return;
  if (si->pvt->reference_count) {
    si->pvt->reference_count--;
    return;
  }
  gt_assert(si->c_class && si->c_class->free);
  si->c_class->free(si);
  gt_free(si->pvt);
  gt_free(si);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x9b581
jmp 0x9b63c
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x9b5a9
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x9b63c
jmp 0x9b5ab
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x9b5c3
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x9b5fb
movq 0x118a0e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc2a92(%rip), %rsi     # 0x15e066
leaq 0xd5895(%rip), %rdx     # 0x170e70
leaq 0xd58af(%rip), %rcx     # 0x170e91
leaq 0xd586c(%rip), %r8      # 0x170e55
movl $0x32, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9b5fd
movq (%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xd5838(%rip), %rsi     # 0x170e55
movl $0x34, %edx
callq 0xdab0
movq (%rsp), %rdi
leaq 0xd5823(%rip), %rsi     # 0x170e55
movl $0x35, %edx
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_next
int gt_sequence_buffer_next(GtSequenceBuffer *sb, GtUchar *val,
                            GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread++];
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq (%rsp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x9bdfd
movq (%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x9bd99
movl $0x0, 0x24(%rsp)
jmp 0x9be2a
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9bdbc
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x9bdbc
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xe08d0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9bcc0
cmpl $0x0, %eax
je 0x9bdda
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x9be2a
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x9bdfb
movl $0x0, 0x24(%rsp)
jmp 0x9be2a
jmp 0x9bdfd
movq (%rsp), %rax
movq (%rsp), %rdx
movq 0x50(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rdx)
movb 0x2079(%rax,%rcx), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movl $0x1, 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/core/sequence_buffer.c
// Function: gt_sequence_buffer_next_with_original_raw
int gt_sequence_buffer_next_with_original_raw(GtSequenceBuffer *sb,
                                              GtUchar *val, char *orig,
                                              GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread];
  *orig = pvt->outbuforig[pvt->nextread];
  pvt->nextread++;
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x9beff
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x9be96
movl $0x0, 0x34(%rsp)
jmp 0x9bf50
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9bebc
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x9bebc
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xe08d0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9bcc0
cmpl $0x0, %eax
je 0x9beda
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x9bf50
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x9befd
movl $0x0, 0x34(%rsp)
jmp 0x9bf50
jmp 0x9beff
movq 0x8(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movb 0x2079(%rax,%rcx), %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movb 0x4079(%rax,%rcx), %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_new
static inline GtInl_Queue *gt_inl_queue_new(GtUword queuesize)
{
  GtInl_Queue *q;

  q = gt_malloc(sizeof (*q));
  gt_assert(queuesize > 0);
  q->queuespace = gt_malloc(sizeof (*q->queuespace) * queuesize);
  q->noofelements = 0;
  q->queuesize = queuesize;
  q->dequeueindex = q->enqueueindex = queuesize - 1;
  return q;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x28, %edi
leaq 0xd4e23(%rip), %rsi     # 0x171308
movl $0x33, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x9c534
movq 0x117ad5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc1b59(%rip), %rsi     # 0x15e066
leaq 0xd4e4d(%rip), %rdx     # 0x171361
leaq 0xd4e54(%rip), %rcx     # 0x17136f
leaq 0xd4de6(%rip), %r8      # 0x171308
movl $0x34, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9c536
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
leaq 0xd4dc2(%rip), %rsi     # 0x171308
movl $0x35, %edx
callq 0xd2e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: gt_dust_masker_delete
void gt_dust_masker_delete(GtDustMasker *dust_masker)
{
  if (dust_masker) {
    gt_free(dust_masker->buf);
    gt_inl_queue_delete(dust_masker->w_queue);
    GT_FREEARRAY(&dust_masker->masked_regions,GtDustRange);
    gt_free(dust_masker);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x9c646
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xd4cbe(%rip), %rsi     # 0x17127c
movl $0x8a, %edx
callq 0xdab0
movq (%rsp), %rax
movq 0x348(%rax), %rdi
callq 0x9c650
movq (%rsp), %rax
cmpq $0x0, 0x390(%rax)
je 0x9c62f
movq (%rsp), %rax
movq 0x390(%rax), %rdi
leaq 0xd4c84(%rip), %rsi     # 0x17127c
movl $0x8c, %edx
callq 0xdab0
movq (%rsp), %rax
movq $0x0, 0x398(%rax)
movq (%rsp), %rax
movq $0x0, 0x3a0(%rax)
movq (%rsp), %rax
movq $0x0, 0x390(%rax)
jmp 0x9c631
movq (%rsp), %rdi
leaq 0xd4c40(%rip), %rsi     # 0x17127c
movl $0x8d, %edx
callq 0xdab0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: nucleotide_value
static inline unsigned char nucleotide_value(char c)
{
  switch (c) {
    case ('a'):
    case ('A'): return 0;
    case ('c'):
    case ('C'): return 1;
    case ('g'):
    case ('G'): return 2;
    case ('t'):
    case ('T'): return 3;
#if GT_TREATNASRANDOM
    case ('n'):
    case ('N'): return rand() % 4;
#endif
    default: return 0;
  }
  return 0;
}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movsbl -0x2(%rsp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x33, %eax
ja 0x9d3cc
movq -0x10(%rsp), %rax
leaq 0xd3e05(%rip), %rcx     # 0x1711ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rsp)
jmp 0x9d3d1
movb $0x1, -0x1(%rsp)
jmp 0x9d3d1
movb $0x2, -0x1(%rsp)
jmp 0x9d3d1
movb $0x3, -0x1(%rsp)
jmp 0x9d3d1
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_get
static inline GtInl_Queueelem gt_inl_queue_get(GtInl_Queue *q)
{
  GtInl_Queueelem value;

  gt_assert(q != NULL && q->noofelements > 0);
  q->noofelements--;
  value = q->queuespace[q->dequeueindex];
  if (q->dequeueindex > 0)
  {
    q->dequeueindex--;
  } else
  {
    q->dequeueindex = q->queuesize - 1;  /* != enqueueindex, since at least
                                            one elem */
  }
  return value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9d3fd
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
ja 0x9d435
movq 0x116bd4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc0c58(%rip), %rsi     # 0x15e066
leaq 0xd3f6b(%rip), %rdx     # 0x171380
leaq 0xd3f85(%rip), %rcx     # 0x1713a1
leaq 0xd3ee5(%rip), %r8      # 0x171308
movl $0x97, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9d437
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x9d47f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x9d495
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_add
static inline void gt_inl_queue_add(GtInl_Queue *q, GtInl_Queueelem elem,
                                    bool doublesize)
{
  gt_assert(q != NULL);
  if (q->noofelements == q->queuesize)
  {
    extendqueuesize(q,doublesize);
  }
  q->noofelements++;
  q->queuespace[q->enqueueindex] = elem;
  if (q->enqueueindex > 0)
  {
    q->enqueueindex--;
  } else
  {
    q->enqueueindex = q->queuesize - 1; /* dequeuindex < queuesize-1 */
  }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x10(%rsp)
movb %cl, 0xf(%rsp)
andb $0x1, %al
movb %al, 0xe(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9d538
movq 0x116ad1(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc0b55(%rip), %rsi     # 0x15e066
leaq 0xe8881(%rip), %rdx     # 0x185d99
leaq 0xd3e93(%rip), %rcx     # 0x1713b2
leaq 0xd3de2(%rip), %r8      # 0x171308
movl $0x7e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9d53a
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x9d561
movq 0x10(%rsp), %rdi
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x9dcc0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movb 0xf(%rsp), %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x9d5a9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x9d5bf
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_get_at_index
static inline GtInl_Queueelem gt_inl_queue_get_at_index(GtInl_Queue *q,
                                                        GtUword n)
{
  GtUword idx;
  gt_assert(q != NULL && q->noofelements > 0 && n < q->noofelements);

  if (n <= q->dequeueindex)
  {
    idx = q->dequeueindex - n;
  } else
  {
    idx= q->queuesize + q->dequeueindex - n;
  }
  return q->queuespace[idx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9d642
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x9d642
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x9d67a
movq 0x11698f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc0a13(%rip), %rsi     # 0x15e066
leaq 0xd3da9(%rip), %rdx     # 0x171403
leaq 0xd3dda(%rip), %rcx     # 0x17143b
leaq 0xd3ca0(%rip), %r8      # 0x171308
movl $0xad, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9d67c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x9d6a0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
subq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9d6bb
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
addq 0x10(%rcx), %rax
subq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movb (%rax,%rcx), %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_free
static void gt_sequence_buffer_embl_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferEMBL *sbe = gt_sequence_buffer_embl_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x9deb0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x9b9e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x9e842
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x83f40
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1afc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_new
GtSequenceBuffer* gt_sequence_buffer_embl_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferEMBL *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_embl_class());
  sbe = gt_sequence_buffer_embl_cast(sb);
  sb->pvt->filenametab = sequences;
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sbe->firstoverallentry = true;
  sbe->firstentryinfile = true;
  sbe->desc_spacer_was_set = false;
  sbe->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x9deb0
movq %rax, %rdi
callq 0x9b4b0
movq %rax, 0x8(%rsp)
callq 0x9deb0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b9e0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, 0x21(%rax)
movq (%rsp), %rax
movb $0x1, 0x20(%rax)
movq (%rsp), %rax
movb $0x0, 0x24(%rax)
movq (%rsp), %rax
movb $0x1, 0x22(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_inline.h
// Function: process_char
static inline int process_char(GtSequenceBuffer *sb,
                                            GtUword currentoutpos,
                                            unsigned char cc,
                                            GtError *err)
{
  GtSequenceBufferMembers *pvt;
  unsigned char charcode;
  pvt = sb->pvt;
  if (pvt->symbolmap != NULL) {
    charcode = pvt->symbolmap[(unsigned int) cc];
    if (charcode == GT_UNDEFCHAR) {
      gt_error_set(err, "illegal character '%c': file \"%s\", line "GT_LLU"",
                        cc,
                        gt_str_array_get(pvt->filenametab,
                                         (GtUword) pvt->filenum),
                        (GtUint64) pvt->linenum);
      return -2;
    }
    if (GT_ISSPECIAL((GtUchar) charcode)) {
      pvt->lastspeciallength++;
    } else {
      if (pvt->lastspeciallength > 0)
        pvt->lastspeciallength = 0;
      if (pvt->chardisttab != NULL)
        pvt->chardisttab[(int) charcode]++;
    }
    pvt->outbuf[currentoutpos] = charcode;
  } else
    pvt->outbuf[currentoutpos] = cc;
  pvt->outbuforig[currentoutpos] = cc;
  pvt->counter++;
  return 0;
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x6080(%rax)
je 0x9eab4
movq 0x18(%rsp), %rax
movq 0x6080(%rax), %rax
movzbl 0x2f(%rsp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0xfd, %eax
jne 0x9ea3a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x2f(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x1b320
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %edx
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0xd2af1(%rip), %rsi     # 0x171517
movb $0x0, %al
callq 0xc0d0
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x9eaf7
movzbl 0x17(%rsp), %eax
cmpl $0xfe, %eax
jl 0x9ea59
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
jmp 0x9ea9d
movq 0x18(%rsp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x9ea72
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x9ea9b
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movzbl 0x17(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x9ea9d
movb 0x17(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movb %dl, 0x2079(%rax,%rcx)
jmp 0x9eac9
movb 0x2f(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movb %dl, 0x2079(%rax,%rcx)
movb 0x2f(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movb %dl, 0x4079(%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_inline.h
// Function: inlinebuf_getchar
static inline int inlinebuf_getchar(GtSequenceBuffer *sb,
                                                 GtFile *f)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->use_ungetchar) {
    pvt->use_ungetchar = false;
    return (int) pvt->ungetchar;
  } else {
    if (pvt->currentinpos >= pvt->currentfillpos) {
      pvt->currentfillpos = (GtUword) gt_file_xread(f, pvt->inbuf,
                                                          (size_t) INBUFSIZE);
      if (pvt->currentfillpos == 0)
         return EOF;
      pvt->currentinpos = 0;
    }
    pvt->ungetchar = pvt->inbuf[pvt->currentinpos++];
    return (int) pvt->ungetchar;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0x9f022
movq 0x8(%rsp), %rax
movb $0x0, 0x19(%rax)
movq 0x8(%rsp), %rax
movzbl 0x78(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x9f0af
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x9f07d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x79, %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x83c20
movslq %eax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x9f070
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x9f0af
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rsp), %rdx
movq 0x48(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x48(%rdx)
movb 0x79(%rax,%rcx), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x78(%rax)
movq 0x8(%rsp), %rax
movzbl 0x78(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_fasta.c
// Function: gt_sequence_buffer_fasta_new
GtSequenceBuffer* gt_sequence_buffer_fasta_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFasta *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fasta_class());
  sbf = gt_sequence_buffer_fasta_cast(sb);
  sb->pvt->filenametab = sequences;
  sbf->headerbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sbf->firstoverallseq = true;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x9f0e0
movq %rax, %rdi
callq 0x9b4b0
movq %rax, 0x8(%rsp)
callq 0x9f0e0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b9e0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movb $0x1, 0x1a(%rax)
movq (%rsp), %rax
movb $0x1, 0x19(%rax)
movq (%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_get_file_index
static GtUword
gt_sequence_buffer_fastq_get_file_index(GtSequenceBuffer *sb)
{
  GtSequenceBufferFastQ *sbfq;
  gt_assert(sb);
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  return gt_seq_iterator_fastq_get_file_index((GtSeqIteratorFastQ*)
                                              sbfq->seqit);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa0229
movq 0x113de0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xbde64(%rip), %rsi     # 0x15e066
leaq 0xd0ca2(%rip), %rdx     # 0x170eab
leaq 0xd14c9(%rip), %rcx     # 0x1716d9
leaq 0xd1478(%rip), %r8      # 0x17168f
movl $0xcc, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xa022b
callq 0x9f990
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x9b9e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xe3870
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_new
GtSequenceBuffer* gt_sequence_buffer_fastq_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFastQ *sbfq;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fastq_class());
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  sbfq->seqit = NULL;
  sbfq->sequences = sequences;
  sb->pvt->filenametab = sequences;
  sbfq->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x9f990
movq %rax, %rdi
callq 0x9b4b0
movq %rax, 0x8(%rsp)
callq 0x9f990
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b9e0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_free
static void gt_sequence_buffer_gb_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferGB *sbe = gt_sequence_buffer_gb_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
  gt_str_delete(sbe->keywordbuffer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xa0510
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x9b9e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xa1342
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x83f40
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1afc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_guess
bool gt_sequence_buffer_gb_guess(const char* txt)
{
  char *hit = NULL;
  if (!(hit = strstr(txt, "LOCUS ")))
    return false;
  /* LOCUS keyword must be at beginning of line */
  return (hit == txt || *(hit-1) == '\n');
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xd037a(%rip), %rsi     # 0x171718
callq 0xb110
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xa13b5
movb $0x0, 0x27(%rsp)
jmp 0xa13e4
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpq 0x18(%rsp), %rcx
movb %al, 0xf(%rsp)
je 0xa13da
movq 0x10(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0xa, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_new
GtSequenceBuffer* gt_sequence_buffer_gb_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferGB *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_gb_class());
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  sbe = gt_sequence_buffer_gb_cast(sb);
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sbe->keywordbuffer = gt_str_new();
  return sb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xa0510
movq %rax, %rdi
callq 0x9b4b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
callq 0xa0510
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b9e0
movq %rax, (%rsp)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x18f00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq