LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_same_rext_letters
static inline bool gt_randomcodes_hpcorrect_same_rext_letters(
    GtRandomcodesHpcorrectData *sdata, GtUword u_kmerpos, int u_offset,
    GtUword t_kmerpos, int t_offset)
{
  GtCommonunits commonunits;
  return (u_kmerpos + u_offset == t_kmerpos + t_offset) ||
      (gt_encseq_compare_viatwobitencoding(&commonunits,
        sdata->encseq, sdata->encseq, GT_READMODE_FORWARD, sdata->esr1,
        sdata->esr2, u_kmerpos + u_offset + sdata->k,
        t_kmerpos + t_offset + sdata->k, 0, (GtUword)sdata->r) == 0);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movq 0x50(%rsp), %rcx
movslq 0x4c(%rsp), %rax
addq %rax, %rcx
movq 0x40(%rsp), %rdx
movslq 0x3c(%rsp), %rax
addq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0x27(%rsp)
je 0x3451a4
movq 0x58(%rsp), %rax
movq (%rax), %rsi
movq 0x58(%rsp), %rax
movq (%rax), %rdx
movq 0x58(%rsp), %rax
movq 0x118(%rax), %r8
movq 0x58(%rsp), %rax
movq 0x120(%rax), %r9
movq 0x50(%rsp), %r11
movslq 0x4c(%rsp), %rax
addq %rax, %r11
movq 0x58(%rsp), %rax
addq 0x20(%rax), %r11
movq 0x40(%rsp), %r10
movslq 0x3c(%rsp), %rax
addq %rax, %r10
movq 0x58(%rsp), %rax
addq 0x20(%rax), %r10
movq 0x58(%rsp), %rax
movl 0xcc(%rax), %eax
leaq 0x28(%rsp), %rdi
xorl %ecx, %ecx
xorl %ebx, %ebx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x12f460
cmpl $0x0, %eax
sete %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_compute_hscore_manhattan
static inline gt_rchc_score_t gt_randomcodes_hpcorrect_compute_hscore_manhattan(
    bool *identical, const uint8_t *hmer1, const uint8_t *hmer2,
    GtUword k)
{
  GtUword i;
  gt_rchc_score_t total_score = 0;
  if (identical != NULL)
    *identical = true;
  for (i = 0; i < k; i++)
  {
    uint8_t h1 = hmer1[i], h2 = hmer2[i];
    if (h1!=h2)
    {
      if (identical != NULL)
        *identical = false;
      total_score -= (h1 > h2 ? h1 - h2 : h2 - h1);
    }
  }
  return total_score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x3451dd
movq -0x8(%rsp), %rax
movb $0x1, (%rax)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x34528f
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rsp)
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rsp)
movzbl -0x31(%rsp), %eax
movzbl -0x32(%rsp), %ecx
cmpl %ecx, %eax
je 0x34527a
cmpq $0x0, -0x8(%rsp)
je 0x345236
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movzbl -0x31(%rsp), %eax
movzbl -0x32(%rsp), %ecx
cmpl %ecx, %eax
jle 0x345256
movzbl -0x31(%rsp), %eax
movzbl -0x32(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x38(%rsp)
jmp 0x345266
movzbl -0x32(%rsp), %eax
movzbl -0x31(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x38(%rsp)
movl -0x38(%rsp), %eax
movslq %eax, %rcx
movq -0x30(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rsp)
jmp 0x34527c
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x3451e6
movq -0x30(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_complement
static char gt_randomcodes_complement(char dna_char)
{
  switch (dna_char) {
    case 'a': case 'A': return 'T';
    case 'c': case 'C': return 'G';
    case 'g': case 'G': return 'C';
    case 't': case 'T': return 'A';
  }
  return 'n';
}

// 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 0x3452ec
movq -0x10(%rsp), %rax
leaq 0x212045(%rip), %rcx    # 0x55730c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x54, -0x1(%rsp)
jmp 0x3452f1
movb $0x47, -0x1(%rsp)
jmp 0x3452f1
movb $0x43, -0x1(%rsp)
jmp 0x3452f1
movb $0x41, -0x1(%rsp)
jmp 0x3452f1
movb $0x6e, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_detect_double_insertion
static inline bool gt_randomcodes_hpcorrect_detect_double_insertion(
    GtRandomcodesHpcorrectData *sdata, GtUword u_sfx,
    GtUword u_kmerpos, GtUword t_sfx, GtUword t_kmerpos,
    gt_rchc_score_t r_minscore, GtUword l_width,
    gt_rchc_score_t l_minscore)
{
  return (gt_randomcodes_hpcorrect_same_rext_letters(sdata, u_kmerpos, -1,
        t_kmerpos, 1)) &&
    (gt_randomcodes_hpcorrect_compute_hscore_manhattan(NULL,
     GT_RANDOMCODES_HPCORRECT_HMER(sdata, u_sfx) + sdata->k,
     GT_RANDOMCODES_HPCORRECT_HMER(sdata, t_sfx) + sdata->k + 2UL,
     (GtUword)sdata->r - 1UL) >= r_minscore) &&
    (gt_randomcodes_hpcorrect_compute_hscore_manhattan(NULL,
     GT_RANDOMCODES_HPCORRECT_HMER(sdata, u_sfx) + sdata->k - l_width - 1UL,
     GT_RANDOMCODES_HPCORRECT_HMER(sdata, t_sfx) + sdata->k - l_width - 1UL,
     l_width) >= l_minscore);
}

// Assembly:
subq $0x38, %rsp
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x3450d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x34535d
jmp 0x345451
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rsi
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rdx
addq $0x2, %rdx
movq 0x30(%rsp), %rax
movl 0xcc(%rax), %eax
movl %eax, %ecx
subq $0x1, %rcx
xorl %eax, %eax
movl %eax, %edi
callq 0x3451b0
movq %rax, %rcx
xorl %eax, %eax
cmpq 0x8(%rsp), %rcx
movb %al, 0x7(%rsp)
jl 0x345451
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rsi
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rsi
xorl %eax, %eax
subq 0x40(%rsp), %rax
addq %rax, %rsi
addq $-0x1, %rsi
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rdx
xorl %eax, %eax
subq 0x40(%rsp), %rax
addq %rax, %rdx
addq $-0x1, %rdx
movq 0x40(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edi
callq 0x3451b0
cmpq 0x48(%rsp), %rax
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/specialrank.c
// Function: gt_fillrankbounds
Rankedbounds *gt_fillrankbounds(const GtEncseq *encseq,
                             GtReadmode readmode)
{
  if (gt_encseq_has_specialranges(encseq))
  {
    GtSpecialrangeiterator *sri;
    GtRange range;
    GtUword currentrank = 0, realspecialranges;
    Rankedbounds *rankedbounds, *rbptr;

    realspecialranges = gt_encseq_realspecialranges(encseq);
    rankedbounds = gt_malloc(sizeof (Rankedbounds) * realspecialranges);
    sri = gt_specialrangeiterator_new(encseq,
                                      GT_ISDIRREVERSE(readmode)
                                      ? false : true);
    for (rbptr = rankedbounds;
         gt_specialrangeiterator_next(sri,&range);
         rbptr++)
    {
      rbptr->lowerbound = range.start;
      rbptr->upperbound = range.end;
      rbptr->rank = currentrank;
      currentrank += rbptr->upperbound - rbptr->lowerbound;
    }
    gt_assert(rbptr == rankedbounds + realspecialranges);
    gt_specialrangeiterator_delete(sri);
    return rankedbounds;
  }
  return NULL;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1293d0
testb $0x1, %al
jne 0x3d9940
jmp 0x3d9aa0
movq $0x0, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0x12c820
movq %rax, 0x28(%rsp)
imulq $0x18, 0x28(%rsp), %rdi
leaq 0x18f6cc(%rip), %rsi    # 0x569031
movl $0x2c, %edx
callq 0x2f600
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x1, 0x54(%rsp)
movb %al, 0x17(%rsp)
je 0x3d9997
cmpl $0x3, 0x54(%rsp)
sete %al
movb %al, 0x17(%rsp)
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x1296c0
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1297e0
testb $0x1, %al
jne 0x3d99e2
jmp 0x3d9a36
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
subq (%rcx), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
jmp 0x3d99cd
jmp 0x3d9a38
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq $0x18, 0x28(%rsp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x3d9a88
movq 0x222571(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x121b3c(%rip), %rsi    # 0x4fb59d
leaq 0x18f5e1(%rip), %rdx    # 0x569049
leaq 0x18f604(%rip), %rcx    # 0x569073
leaq 0x18f5bb(%rip), %r8     # 0x569031
movl $0x39, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3d9a8a
movq 0x48(%rsp), %rdi
callq 0x129cf0
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x3d9aa9
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/specialrank.c
// Function: gt_frompos2rank
GtUword gt_frompos2rank(const Rankedbounds *leftptr,
                              const Rankedbounds *rightptr,
                              GtUword specialpos)
{
  const Rankedbounds *midptr;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (specialpos < midptr->lowerbound)
    {
      rightptr = midptr-1;
    } else
    {
      if (specialpos >= midptr->upperbound)
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr->rank + specialpos - midptr->lowerbound;
      }
    }
  }
  fprintf(stderr,"frompos2rank: cannot find pos "GT_WU""
                 " in ranges",specialpos);
  exit(GT_EXIT_PROGRAMMING_ERROR);
  /*@ignore@*/
  return 0;
  /*@end@*/
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x3d9b7a
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
shrq %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x3d9b38
movq 0x8(%rsp), %rax
addq $-0x18, %rax
movq %rax, 0x18(%rsp)
jmp 0x3d9b75
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x3d9b58
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
jmp 0x3d9b73
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq (%rcx), %rax
addq $0x28, %rsp
retq
jmp 0x3d9b75
jmp 0x3d9ad3
movq 0x222447(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x18f4f5(%rip), %rsi    # 0x569085
movb $0x0, %al
callq 0x33960
movl $0x2, %edi
callq 0x2fd60
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/specialrank.c
// Function: gt_fromrank2pos
GtUword gt_fromrank2pos(const Rankedbounds *leftptr,
                              const Rankedbounds *rightptr,
                              GtUword rank)
{
  const Rankedbounds *midptr;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (rank < midptr->rank)
    {
      rightptr = midptr-1;
    } else
    {
      if (rank >= midptr->rank + (midptr->upperbound - midptr->lowerbound))
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr->lowerbound + (rank - midptr->rank);
      }
    }
  }
  fprintf(stderr,"fromrank2rank: cannot find rank "GT_WU""
                 " in ranges",rank);
  exit(GT_EXIT_PROGRAMMING_ERROR);
  /*@ignore@*/
  return 0;
  /*@end@*/
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x3d9c85
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
shrq %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3d9c29
movq 0x8(%rsp), %rax
addq $-0x18, %rax
movq %rax, 0x18(%rsp)
jmp 0x3d9c80
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
movq 0x8(%rsp), %rsi
subq (%rsi), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x3d9c60
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
jmp 0x3d9c7e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
subq 0x10(%rdx), %rcx
addq %rcx, %rax
addq $0x28, %rsp
retq
jmp 0x3d9c80
jmp 0x3d9bc3
movq 0x22233c(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x18f416(%rip), %rsi    # 0x5690b1
movb $0x0, %al
callq 0x33960
movl $0x2, %edi
callq 0x2fd60
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/specialrank.c
// Function: compareSpecialrank
static int compareSpecialrank(const void *a,const void *b)
{
  const Specialrank *aptr = (const Specialrank *) a,
                    *bptr = (const Specialrank *) b;

  if (aptr->key < bptr->key)
  {
    return -1;
  }
  if (aptr->key > bptr->key)
  {
    return 1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3d9f5e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x3d9fb5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x3d9f7b
movl $0x1, 0x24(%rsp)
jmp 0x3d9fb5
jmp 0x3d9f7d
movq 0x222044(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x12160f(%rip), %rsi    # 0x4fb59d
leaq 0x150a1a(%rip), %rdx    # 0x52a9af
leaq 0x18f1ca(%rip), %rcx    # 0x569166
leaq 0x18f08e(%rip), %r8     # 0x569031
movl $0x91, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/substriter.c
// Function: gt_substriter_new
Substriter *gt_substriter_new(const GtAlphabet *alphabet,unsigned int qvalue)
{
  Substriter *substriter;

  substriter = gt_malloc(sizeof *substriter);
  substriter->qvalue = qvalue;
  substriter->numofchars = gt_alphabet_num_of_chars(alphabet);
  substriter->multimappower = gt_initmultimappower(substriter->numofchars,
                                                   qvalue);
  return substriter;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x30, %edi
leaq 0x18edf5(%rip), %rsi    # 0x56924e
movl $0x2a, %edx
callq 0x2f600
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rdi
callq 0x30b10
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x24(%rax)
movq (%rsp), %rax
movl 0x24(%rax), %edi
movl 0xc(%rsp), %esi
callq 0x32da30
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/substriter.c
// Function: gt_substriter_next
int gt_substriter_next(Substriter *substriter)
{
  unsigned int firstspecial;

  while (true)
  {
    if (substriter->remaining >= (GtUword) substriter->qvalue)
    {
      firstspecial = qgram2code(&substriter->currentcode,
                                (const GtCodetype **) substriter->multimappower,
                                substriter->qvalue,
                                substriter->currentptr);
      if (firstspecial == substriter->qvalue)
      {
        substriter->remaining--;
        substriter->currentptr++;
        break;
      }
      substriter->remaining -= firstspecial + 1;
      substriter->currentptr += firstspecial + 1;
    } else
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x20(%rcx), %ecx
cmpq %rcx, %rax
jb 0x3da5e2
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %edx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
callq 0x3da610
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3da5ae
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3da5f1
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x3da5ec
movl $0x0, 0x14(%rsp)
jmp 0x3da5f9
jmp 0x3da539
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: gt_ltr_orf_annotator_stream_class
const GtNodeStreamClass* gt_ltr_orf_annotator_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLTRORFAnnotatorStream),
                                   ltr_orf_annotator_stream_free,
                                   ltr_orf_annotator_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x117bf0
cmpq $0x0, 0x216f1a(%rip)    # 0x605618
jne 0x3ee71f
movl $0x28, %edi
leaq 0x24(%rip), %rsi        # 0x3ee730
leaq 0x6d(%rip), %rdx        # 0x3ee780
callq 0x30700
movq %rax, 0x216ef9(%rip)    # 0x605618
callq 0x117c50
movq 0x216eed(%rip), %rax    # 0x605618
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: ltr_orf_annotator_stream_next
static int ltr_orf_annotator_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                         GtError *err)
{
  GtLTRORFAnnotatorStream *bs;
  gt_error_check(err);
  bs = ltr_orf_annotator_stream_cast(ns);
  if (bs->progress_loc != NULL)
    (*bs->progress_loc)++;
  return gt_node_stream_next(bs->orf_stream, gn, err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3ee7e3
movq 0x10(%rsp), %rdi
callq 0x33160
testb $0x1, %al
jne 0x3ee7ab
jmp 0x3ee7e3
movq 0x20d816(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x10cde1(%rip), %rsi    # 0x4fb59d
leaq 0x10cfad(%rip), %rdx    # 0x4fb770
leaq 0x17ef1a(%rip), %rcx    # 0x56d6e4
leaq 0x17eebe(%rip), %r8     # 0x56d68f
movl $0x29, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3ee7e5
callq 0x3ee6f0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x30f90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3ee81b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x314d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: gt_ltr_orf_annotator_stream_new
GtNodeStream* gt_ltr_orf_annotator_stream_new(GtNodeStream *in_stream,
                                              GtEncseq *encseq,
                                              unsigned int min,
                                              unsigned int max,
                                              bool all,
                                              GtError *err)
{
  GtLTRORFAnnotatorStream *bs;
  GtNodeStream *ns;
  GtRegionMapping *rmap;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_ltr_orf_annotator_stream_class(), false);
  bs = ltr_orf_annotator_stream_cast(ns);
  bs->types = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  bs->progress_loc = NULL;
  gt_hashmap_add(bs->types, gt_ft_LTR_retrotransposon, (void*) 1);
  rmap = gt_region_mapping_new_encseq_seqno(encseq);
  gt_assert(rmap);
  bs->orf_stream = gt_orf_finder_stream_new(in_stream, rmap, bs->types, min,
                                            max, all, err);
  return ns;
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %r9, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x3ee8a4
movq 0x20d755(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x10cd20(%rip), %rsi    # 0x4fb59d
leaq 0x12a254(%rip), %rdx    # 0x518ad8
leaq 0x17ede4(%rip), %rcx    # 0x56d66f
leaq 0x17edfd(%rip), %r8     # 0x56d68f
movl $0x4e, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3ee8a6
callq 0x3ee6f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x322b0
movq %rax, 0x10(%rsp)
callq 0x3ee6f0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x30f90
movq %rax, 0x18(%rsp)
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x32570
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x14aed2(%rip), %rsi    # 0x5397dd
movl $0x1, %edx
callq 0x327b0
movq 0x38(%rsp), %rdi
callq 0x25d4f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3ee964
movq 0x20d695(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x10cc60(%rip), %rsi    # 0x4fb59d
leaq 0x17fa24(%rip), %rdx    # 0x56e368
leaq 0x17ed24(%rip), %rcx    # 0x56d66f
leaq 0x17ed3d(%rip), %r8     # 0x56d68f
movl $0x55, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3ee966
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
movb 0x2f(%rsp), %r9b
movq 0x20(%rsp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x248110
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_example.c
// Function: gt_custom_track_example_class
const GtCustomTrackClass* gt_custom_track_example_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackExample),
                                    gt_custom_track_example_sketch,
                                    gt_custom_track_example_get_height,
                                    gt_custom_track_example_get_title,
                                    gt_custom_track_example_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0x117bf0
cmpq $0x0, 0x1ed8da(%rip)    # 0x605688
jne 0x417ddd
movl $0x20, %edi
leaq -0x41c(%rip), %rsi      # 0x4179a0
leaq 0x2d(%rip), %rdx        # 0x417df0
leaq 0x56(%rip), %rcx        # 0x417e20
leaq 0x8f(%rip), %r8         # 0x417e60
callq 0x417490
movq %rax, 0x1ed8ab(%rip)    # 0x605688
callq 0x117c50
movq 0x1ed89f(%rip), %rax    # 0x605688
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_example.c
// Function: gt_custom_track_example_new
GtCustomTrack* gt_custom_track_example_new()
{
  GtCustomTrackExample *cte;
  GtCustomTrack *ct;
  ct = gt_custom_track_create(gt_custom_track_example_class());
  cte = gt_custom_track_example_cast(ct);
  cte->title = gt_str_new_cstr("Example custom track for AnnotationSketch");
  cte->height = 40;
  return ct;
}

// Assembly:
subq $0x18, %rsp
callq 0x417da0
movq %rax, %rdi
callq 0x417510
movq %rax, 0x8(%rsp)
callq 0x417da0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x417920
movq %rax, 0x10(%rsp)
leaq 0x15b1dd(%rip), %rdi    # 0x5730b1
callq 0x310f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x28, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_class
const GtCustomTrackClass* gt_custom_track_script_wrapper_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackScriptWrapper),
                                    gt_custom_track_script_wrapper_sketch,
                                    gt_custom_track_script_wrapper_get_height,
                                    gt_custom_track_script_wrapper_get_title,
                                    gt_custom_track_script_wrapper_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0x117bf0
cmpq $0x0, 0x1ec8ba(%rip)    # 0x605698
jne 0x418e0d
movl $0x38, %edi
leaq -0x8c(%rip), %rsi       # 0x418d60
leaq 0x2d(%rip), %rdx        # 0x418e20
leaq 0x66(%rip), %rcx        # 0x418e60
leaq 0xbf(%rip), %r8         # 0x418ec0
callq 0x417490
movq %rax, 0x1ec88b(%rip)    # 0x605698
callq 0x117c50
movq 0x1ec87f(%rip), %rax    # 0x605698
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_get_title
const char* gt_custom_track_script_wrapper_get_title(GtCustomTrack *ct)
{
  GtCustomTrackScriptWrapper *cte;
  cte = gt_custom_track_script_wrapper_cast(ct);
  gt_str_reset(cte->title_buffer);
  cte->get_title_func(NULL, cte->title_buffer);
  return gt_str_get(cte->title_buffer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x418dd0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x417920
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x33720
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x30(%rcx), %rsi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x33b70
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_delete
void gt_custom_track_script_wrapper_delete(GtCustomTrack *ct)
{
  GtCustomTrackScriptWrapper *cte;
  if (!ct) return;
  cte = gt_custom_track_script_wrapper_cast(ct);
  cte->free_func(NULL);
  gt_str_delete(cte->title_buffer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x418ed3
jmp 0x418f04
callq 0x418dd0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x417920
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
callq *0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x34040
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_new
GtCustomTrack* gt_custom_track_script_wrapper_new(GtCtScriptRenderFunc
                                                             render_func,
                                                  GtCtScriptGetHeightFunc
                                                             get_height_func,
                                                  GtCtScriptGetTitleFunc
                                                             get_title_func,
                                                  GtCtScriptFreeFunc
                                                             free_func)
{
  GtCustomTrackScriptWrapper *cte;
  GtCustomTrack *ct;
  ct = gt_custom_track_create(gt_custom_track_script_wrapper_class());
  cte = gt_custom_track_script_wrapper_cast(ct);
  cte->render_func = render_func;
  cte->get_height_func = get_height_func;
  cte->get_title_func = get_title_func;
  cte->free_func = free_func;
  cte->title_buffer = gt_str_new();
  return ct;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
callq 0x418dd0
movq %rax, %rdi
callq 0x417510
movq %rax, 0x8(%rsp)
callq 0x418dd0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x417920
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x32680
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: insert_offset
static inline void insert_offset(khash_t(i) *h, int bin, uint64_t beg, uint64_t end)
{
	khint_t k;
	bam_binlist_t *l;
	int ret;
	k = kh_put(i, h, bin, &ret);
	l = &kh_value(h, k);
	if (ret) { // not present
		l->m = 1; l->n = 0;
		l->list = (pair64_t*)calloc(l->m, 16);
	}
	if (l->n == l->m) {
		l->m <<= 1;
		l->list = (pair64_t*)realloc(l->list, l->m * 16);
	}
	l->list[l->n].u = beg; l->list[l->n++].v = end;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x4(%rsp), %rdx
callq 0x474150
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x471d04
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
movl $0x10, %esi
callq 0x32f50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x471d48
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
shll $0x4, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x340d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rdx
movl 0x4(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rsi
movl 0x4(%rsi), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: merge_chunks
static void merge_chunks(bam_index_t *idx)
{
#if defined(BAM_TRUE_OFFSET) || defined(BAM_VIRTUAL_OFFSET16)
	khash_t(i) *index;
	int i, l, m;
	khint_t k;
	for (i = 0; i < idx->n; ++i) {
		index = idx->index[i];
		for (k = kh_begin(index); k != kh_end(index); ++k) {
			bam_binlist_t *p;
			if (!kh_exist(index, k) || kh_key(index, k) == BAM_MAX_BIN) continue;
			p = &kh_value(index, k);
			m = 0;
			for (l = 1; l < p->n; ++l) {
#ifdef BAM_TRUE_OFFSET
				if (p->list[m].v + BAM_MIN_CHUNK_GAP > p->list[l].u) p->list[m].v = p->list[l].v;
#else
				if (p->list[m].v>>16 == p->list[l].u>>16) p->list[m].v = p->list[l].v;
#endif
				else p->list[++m] = p->list[l];
			} // ~for(l)
			p->n = m + 1;
		} // ~for(k)
	} // ~for(i)
#endif // defined(BAM_TRUE_OFFSET) || defined(BAM_BGZF)
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x471f62
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0x471f50
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x20(%rsp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x20(%rsp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x471e2c
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rsp), %ecx
cmpl $0x924a, (%rax,%rcx,4)  # imm = 0x924A
jne 0x471e31
jmp 0x471f40
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x1, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x28(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x471f31
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
shrq $0x10, %rax
movq -0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x18(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x10, %rcx
cmpq %rcx, %rax
jne 0x471ede
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x471f1f
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rsp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x18(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x471f21
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x471e5a
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movq -0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x471ddd
jmp 0x471f52
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x471dad
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: fill_missing
static void fill_missing(bam_index_t *idx)
{
	int i, j;
	for (i = 0; i < idx->n; ++i) {
		bam_lidx_t *idx2 = &idx->index2[i];
		for (j = 1; j < idx2->n; ++j)
			if (idx2->offset[j] == 0)
				idx2->offset[j] = idx2->offset[j-1];
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x47201c
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x47200a
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x471ffb
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x471ffd
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x471fb0
jmp 0x47200c
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x471f7d
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_index_destroy
void bam_index_destroy(bam_index_t *idx)
{
	khint_t k;
	int i;
	if (idx == 0) return;
	for (i = 0; i < idx->n; ++i) {
		khash_t(i) *index = idx->index[i];
		bam_lidx_t *index2 = idx->index2 + i;
		for (k = kh_begin(index); k != kh_end(index); ++k) {
			if (kh_exist(index, k))
				free(kh_value(index, k).list);
		}
		kh_destroy(i, index);
		free(index2->offset);
	}
	free(idx->index); free(idx->index2);
	free(idx);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x472036
jmp 0x472137
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x472111
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0x4720e9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl 0x1c(%rsp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x4720da
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x34078
jmp 0x4720dc
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x472088
movq 0x10(%rsp), %rdi
callq 0x472140
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34078
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x47203e
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x34078
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x34078
movq 0x20(%rsp), %rdi
callq 0x34078
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_index_load_local
bam_index_t *bam_index_load_local(const char *_fn)
{
	FILE *fp;
	char *fnidx, *fn;

	if (strstr(_fn, "ftp://") == _fn || strstr(_fn, "http://") == _fn) {
		const char *p;
		int l = strlen(_fn);
		for (p = _fn + l - 1; p >= _fn; --p)
			if (*p == '/') break;
		fn = strdup(p + 1);
	} else fn = strdup(_fn);
	fnidx = (char*)calloc(strlen(fn) + 5, 1);
	strcpy(fnidx, fn); strcat(fnidx, ".bai");
	fp = fopen(fnidx, "rb");
	if (fp == 0) { // try "{base}.bai"
		char *s = strstr(fn, "bam");
		if (s == fn + strlen(fn) - 3) {
			strcpy(fnidx, fn);
			fnidx[strlen(fn)-1] = 'i';
			fp = fopen(fnidx, "rb");
		}
	}
	free(fnidx); free(fn);
	if (fp) {
		bam_index_t *idx = bam_index_load_core(fp);
		fclose(fp);
		return idx;
	} else return 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x107ba5(%rip), %rsi    # 0x57a24a
callq 0x31a20
cmpq 0x58(%rsp), %rax
je 0x4726c9
movq 0x58(%rsp), %rdi
leaq 0x107b94(%rip), %rsi    # 0x57a251
callq 0x31a20
cmpq 0x58(%rsp), %rax
jne 0x47272f
movq 0x58(%rsp), %rdi
callq 0x30e70
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rax
movslq 0x34(%rsp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x58(%rsp), %rax
jb 0x47271a
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x472708
jmp 0x47271a
jmp 0x47270a
movq 0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x4726ed
movq 0x38(%rsp), %rdi
addq $0x1, %rdi
callq 0x326e0
movq %rax, 0x40(%rsp)
jmp 0x47273e
movq 0x58(%rsp), %rdi
callq 0x326e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30e70
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x32f50
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x32b70
movq 0x48(%rsp), %rdi
leaq 0x107ae0(%rip), %rsi    # 0x57a259
callq 0x31b00
movq 0x48(%rsp), %rdi
leaq 0xdaf48(%rip), %rsi     # 0x54d6d2
callq 0x33670
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x472838
movq 0x40(%rsp), %rdi
leaq 0x108f9e(%rip), %rsi    # 0x57b74a
callq 0x31a20
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30e70
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x472836
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x32b70
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movb $0x69, (%rax,%rcx)
movq 0x48(%rsp), %rdi
leaq 0xdaea6(%rip), %rsi     # 0x54d6d2
callq 0x33670
movq %rax, 0x50(%rsp)
jmp 0x472838
movq 0x48(%rsp), %rdi
callq 0x34078
movq 0x40(%rsp), %rdi
callq 0x34078
cmpq $0x0, 0x50(%rsp)
je 0x472879
movq 0x50(%rsp), %rdi
callq 0x472890
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x330b0
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x472882
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_index_load
bam_index_t *bam_index_load(const char *fn)
{
	bam_index_t *idx;
	idx = bam_index_load_local(fn);
	if (idx == 0 && (strstr(fn, "ftp://") == fn || strstr(fn, "http://") == fn)) {
		char *fnidx = calloc(strlen(fn) + 5, 1);
		strcat(strcpy(fnidx, fn), ".bai");
		fprintf(stderr, "[bam_index_load] attempting to download the remote index file.\n");
		download_from_remote(fnidx);
		idx = bam_index_load_local(fn);
	}
	if (idx == 0) fprintf(stderr, "[bam_index_load] fail to load BAM index.\n");
	return idx;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x472690
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x472da0
movq 0x10(%rsp), %rdi
leaq 0x10753a(%rip), %rsi    # 0x57a24a
callq 0x31a20
cmpq 0x10(%rsp), %rax
je 0x472d34
movq 0x10(%rsp), %rdi
leaq 0x107529(%rip), %rsi    # 0x57a251
callq 0x31a20
cmpq 0x10(%rsp), %rax
jne 0x472da0
movq 0x10(%rsp), %rdi
callq 0x30e70
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x32f50
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x32b70
movq %rax, %rdi
leaq 0x1074ee(%rip), %rsi    # 0x57a259
callq 0x31b00
movq 0x189251(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1074dd(%rip), %rsi    # 0x57a25e
movb $0x0, %al
callq 0x33960
movq (%rsp), %rdi
callq 0x472dd0
movq 0x10(%rsp), %rdi
callq 0x472690
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x472dc0
movq 0x189219(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1074e5(%rip), %rsi    # 0x57a29e
movb $0x0, %al
callq 0x33960
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_index_build2
int bam_index_build2(const char *fn, const char *_fnidx)
{
	char *fnidx;
	FILE *fpidx;
	bamFile fp;
	bam_index_t *idx;
	if ((fp = bam_open(fn, "r")) == 0) {
		fprintf(stderr, "[bam_index_build2] fail to open the BAM file.\n");
		return -1;
	}
	idx = bam_index_core(fp);
	bam_close(fp);
	if(idx == 0) {
		fprintf(stderr, "[bam_index_build2] fail to index the BAM file.\n");
		return -1;
	}
	if (_fnidx == 0) {
		fnidx = (char*)calloc(strlen(fn) + 5, 1);
		strcpy(fnidx, fn); strcat(fnidx, ".bai");
	} else fnidx = strdup(_fnidx);
	fpidx = fopen(fnidx, "wb");
	if (fpidx == 0) {
		fprintf(stderr, "[bam_index_build2] fail to create the index file.\n");
		free(fnidx);
		return -1;
	}
	bam_index_save(idx, fpidx);
	bam_index_destroy(idx);
	fclose(fpidx);
	free(fnidx);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x8c541(%rip), %rsi     # 0x4ff33b
callq 0x464500
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x472e2f
movq 0x1891b7(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1074ad(%rip), %rsi    # 0x57a2c8
movb $0x0, %al
callq 0x33960
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x472f49
movq 0x8(%rsp), %rdi
callq 0x471420
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x4646c0
cmpq $0x0, (%rsp)
jne 0x472e73
movq 0x189173(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x107498(%rip), %rsi    # 0x57a2f7
movb $0x0, %al
callq 0x33960
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x472f49
cmpq $0x0, 0x20(%rsp)
jne 0x472ebd
movq 0x28(%rsp), %rdi
callq 0x30e70
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x32f50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x32b70
movq 0x18(%rsp), %rdi
leaq 0x1073a3(%rip), %rsi    # 0x57a259
callq 0x31b00
jmp 0x472ecc
movq 0x20(%rsp), %rdi
callq 0x326e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x88c25(%rip), %rsi     # 0x4fbafd
callq 0x33670
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x472f16
movq 0x1890d7(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x10742c(%rip), %rsi    # 0x57a327
movb $0x0, %al
callq 0x33960
movq 0x18(%rsp), %rdi
callq 0x34078
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x472f49
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x472180
movq (%rsp), %rdi
callq 0x472020
movq 0x10(%rsp), %rdi
callq 0x330b0
movq 0x18(%rsp), %rdi
callq 0x34078
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_index
int bam_index(int argc, char *argv[])
{
	if (argc < 2) {
		fprintf(stderr, "Usage: samtools index <in.bam> [out.index]\n");
		return 1;
	}
	if (argc >= 3) bam_index_build2(argv[1], argv[2]);
	else bam_index_build(argv[1]);
	return 0;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x472fb6
movq 0x18902d(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1073b5(%rip), %rsi    # 0x57a35a
movb $0x0, %al
callq 0x33960
movl $0x1, 0x14(%rsp)
jmp 0x472fec
cmpl $0x3, 0x10(%rsp)
jl 0x472fd6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x472de0
jmp 0x472fe4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x472f60
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: get_chunk_coordinates
pair64_t *get_chunk_coordinates(const bam_index_t *idx, int tid, int beg, int end, int *cnt_off)
{ // for pysam compatibility
	bam_iter_t iter;
	pair64_t *off;
	iter = bam_iter_query(idx, tid, beg, end);
	off = iter->off; *cnt_off = iter->n_off;
	free(iter);
	return off;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
callq 0x4733a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x34078
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_index.c
// Function: bam_fetch
int bam_fetch(bamFile fp, const bam_index_t *idx, int tid, int beg, int end, void *data, bam_fetch_f func)
{
	int ret;
	bam_iter_t iter;
	bam1_t *b;
	b = bam_init1();
	iter = bam_iter_query(idx, tid, beg, end);
	while ((ret = bam_iter_read(fp, iter, b)) >= 0) func(b, data);
	bam_iter_destroy(iter);
	bam_destroy1(b);
	return (ret == -1)? 0 : ret;
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x32f50
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0x4733a0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x473cd0
movl %eax, 0x1c(%rsp)
cmpl $0x0, %eax
jl 0x4740e4
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq *%rax
jmp 0x4740b4
movq 0x10(%rsp), %rdi
callq 0x473ca0
cmpq $0x0, 0x8(%rsp)
je 0x47410e
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x34078
movq 0x8(%rsp), %rdi
callq 0x34078
jmp 0x474110
cmpl $-0x1, 0x1c(%rsp)
jne 0x47411f
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x474127
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x48, %rsp
retq