LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: querycap
static int querycap (CapState *cs) {
  int idx = cs->cap->idx;
  int n = pushallvalues(cs, 0);
  if (n > 1)  /* extra captures? */
    lua_pop(cs->L, n - 1);  /* throw them away */
  updatecache(cs, idx);
  lua_gettable(cs->L, subscache(cs));
  if (!lua_isnil(cs->L, -1))
    return 1;
  else {
    lua_pop(cs->L, 1);  /* remove value */
    return 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x363d90
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jle 0x364a09
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl (%rsp), %eax
subl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
subl $0x1, %esi
callq 0x333ed0
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
je 0x364a25
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x364be0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x1, %esi
callq 0x336210
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
cmpl $0x0, %eax
je 0x364a60
movl $0x1, 0x14(%rsp)
jmp 0x364a7b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
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/lpeg-0.10.2/lpeg.c
// Function: foldcap
static int foldcap (CapState *cs) {
  int n;
  lua_State *L = cs->L;
  int idx = cs->cap->idx;
  if (isfullcap(cs->cap++) || isclosecap(cs->cap) || (n = pushcapture(cs)) == 0)
    return luaL_error(L, "no initial value for fold capture");
  if (n > 1)
    lua_pop(L, n - 1);  /* leave only one result */
  while (!isclosecap(cs->cap)) {
    updatecache(cs, idx);
    lua_pushvalue(L, subscache(cs));  /* get folding function */
    lua_insert(L, -2);  /* put it before accumulator */
    n = pushcapture(cs);  /* get other captures */
    lua_call(L, n + 1, 1);  /* call folding function */
  }
  cs->cap++;  /* skip close entry */
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rcx)
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x364af6
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
je 0x364af6
movq 0x18(%rsp), %rdi
callq 0x363ea0
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
jne 0x364b12
movq 0x8(%rsp), %rdi
leaq 0x238879(%rip), %rsi    # 0x59d37b
movb $0x0, %al
callq 0x33a320
movl %eax, 0x24(%rsp)
jmp 0x364bca
cmpl $0x1, 0x14(%rsp)
jle 0x364b31
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
subl $0x1, %esi
callq 0x333ed0
jmp 0x364b33
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x364b4d
jmp 0x364bb3
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x28(%rcx), %eax
je 0x364b69
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x364be0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x1, %esi
callq 0x334560
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x3341a0
movq 0x18(%rsp), %rdi
callq 0x363ea0
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
movl $0x1, %edx
callq 0x337460
jmp 0x364b33
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%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/external/lpeg-0.10.2/lpeg.c
// Function: getstrcaps
static int getstrcaps (CapState *cs, StrAux *cps, int n) {
  int k = n++;
  cps[k].isstring = 1;
  cps[k].u.s.s = cs->cap->s;
  if (!isfullcap(cs->cap++)) {
    while (!isclosecap(cs->cap)) {
      if (n >= MAXSTRCAPS)  /* too many captures? */
        cs->cap = nextcap(cs->cap);  /* skip it */
      else if (captype(cs->cap) == Csimple)
        n = getstrcaps(cs, cps, n);
      else {
        cps[n].isstring = 0;
        cps[n].u.cp = cs->cap;
        cs->cap = nextcap(cs->cap);
        n++;
      }
    }
    cs->cap++;  /* skip close */
  }
  cps[k].u.s.e = closeaddr(cs->cap - 1);
  return n;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rsp)
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movslq (%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rcx)
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x364d90
jmp 0x364cb8
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x364cd5
jmp 0x364d81
cmpl $0xa, 0x4(%rsp)
jl 0x364cf9
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x364690
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x364d7c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x5, %eax
jne 0x364d23
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x364c40
movl %eax, 0x4(%rsp)
jmp 0x364d7a
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x364690
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x364d7c
jmp 0x364cb8
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl -0x5(%rax), %eax
cltq
addq %rax, %rcx
addq $-0x1, %rcx
movq 0x8(%rsp), %rax
movslq (%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: addonestring
static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) {
  switch (captype(cs->cap)) {
    case Cstring:
      stringcap(b, cs);  /* add capture directly to buffer */
      return 1;
    case Csubst:
      substcap(b, cs);  /* add capture directly to buffer */
      return 1;
    default: {
      lua_State *L = cs->L;
      int n = pushcapture(cs);
      if (n > 0) {
        if (n > 1) lua_pop(L, n - 1);  /* only one result */
        if (!lua_isstring(L, -1))
          luaL_error(L, "invalid %s value (a %s)", what, luaL_typename(L, -1));
        luaL_addvalue(b);
      }
      return n;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
movl %eax, 0x18(%rsp)
subl $0x9, %eax
je 0x364e05
jmp 0x364dfa
movl 0x18(%rsp), %eax
subl $0xa, %eax
je 0x364e21
jmp 0x364e3d
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3642a0
movl $0x1, 0x44(%rsp)
jmp 0x364efb
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x364550
movl $0x1, 0x44(%rsp)
jmp 0x364efb
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x363ea0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x364ef3
cmpl $0x1, 0x1c(%rsp)
jle 0x364e83
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
subl $0x1, %esi
callq 0x333ed0
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3347b0
cmpl $0x0, %eax
jne 0x364ee9
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x334620
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x238463(%rip), %rsi    # 0x59d345
movb $0x0, %al
callq 0x33a320
movq 0x38(%rsp), %rdi
callq 0x33b3a0
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: findback
static Capture *findback (CapState *cs, Capture *cap) {
  lua_State *L = cs->L;
  for (;;) {
    if (cap == cs->ocap) {  /* not found */
      const char *s = lua_tostring(L, -1);
      if (s == NULL) s = lua_pushfstring(L, "(a %s)", luaL_typename(L, -1));
      luaL_error(L, "back reference '%s' not found", s);
    }
    cap--;
    if (isclosecap(cap))
      cap = findopen(cap);
    else if (!isfullcap(cap))
      continue; /* opening an enclosing capture: skip and get previous */
    if (captype(cap) == Cgroup) {
      getfromenv(cs, cap->idx);  /* get group name */
      if (lua_equal(L, -2, -1)) {  /* right group? */
        lua_pop(L, 2);  /* remove reference name and group name */
        return cap;
      }
      else lua_pop(L, 1);  /* remove group name */
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x364fc2
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x364faa
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x334620
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x2383b8(%rip), %rsi    # 0x59d356
movb $0x0, %al
callq 0x335df0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2383a2(%rip), %rsi    # 0x59d35d
movb $0x0, %al
callq 0x33a320
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x364fef
movq 0x28(%rsp), %rdi
callq 0x363d20
movq %rax, 0x28(%rsp)
jmp 0x365004
movq 0x28(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x365002
jmp 0x364f2c
jmp 0x365004
movq 0x28(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0xd, %eax
jne 0x365077
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x30(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x3, %esi
movq 0x28(%rsp), %rax
movswl 0x8(%rax), %edx
callq 0x336650
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3349b0
cmpl $0x0, %eax
je 0x365066
movq 0x20(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
jmp 0x365077
jmp 0x364f2c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: printpatt
static void printpatt (Instruction *p) {
  Instruction *op = p;
  for (;;) {
    printinst(op, p);
    if ((Opcode)p->i.code == IEnd) break;
    p += sizei(p);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3650e0
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x3650b1
jmp 0x3650d3
movq 0x10(%rsp), %rdi
callq 0x35f7b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x365093
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: printcharset
static void printcharset (const Charset st) {
  int i;
  printf("[");
  for (i = 0; i <= UCHAR_MAX; i++) {
    int first = i;
    while (testchar(st, i) && i <= UCHAR_MAX) i++;
    if (i - 1 == first)  /* unary range? */
      printf("(%02x)", first);
    else if (i - 1 > first)  /* non-empty range? */
      printf("(%02x-%02x)", first, i - 1);
  }
  printf("]");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x22ee5a(%rip), %rdi    # 0x5941fa
movb $0x0, %al
callq 0x19070
movl $0x0, 0xc(%rsp)
cmpl $0xff, 0xc(%rsp)
jg 0x36547a
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, (%rsp)
movl 0xc(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %eax
shll %cl, %eax
movl (%rsp), %ecx
andl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x365408
cmpl $0xff, 0xc(%rsp)
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x365412
jmp 0x36541f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3653c5
movl 0xc(%rsp), %eax
subl $0x1, %eax
cmpl 0x8(%rsp), %eax
jne 0x365440
movl 0x8(%rsp), %esi
leaq 0x2380a8(%rip), %rdi    # 0x59d4df
movb $0x0, %al
callq 0x19070
jmp 0x365468
movl 0xc(%rsp), %eax
subl $0x1, %eax
cmpl 0x8(%rsp), %eax
jle 0x365466
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
subl $0x1, %edx
leaq 0x238087(%rip), %rdi    # 0x59d4e6
movb $0x0, %al
callq 0x19070
jmp 0x365468
jmp 0x36546a
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3653af
leaq 0x235ede(%rip), %rdi    # 0x59b35f
movb $0x0, %al
callq 0x19070
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: createcat
static void createcat (lua_State *L, const char *catname, int (catf) (int)) {
  Instruction *p = newcharset(L);
  int i;
  for (i = 0; i < CHAR_MAX; i++)
    if (catf(i)) setchar(p[1].buff, i);
  lua_setfield(L, -2, catname);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x361700
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x7f, 0x4(%rsp)
jge 0x365508
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %edi
callq *%rax
cmpl $0x0, %eax
je 0x3654f9
movl 0x4(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x8(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0x8(%rax,%rcx)
jmp 0x3654fb
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3654ba
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x336d90
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_calend
uint32_t bam_calend(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k, end;
	end = c->pos;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CDEL || op == BAM_CREF_SKIP)
			end += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return end;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
cmpl %ecx, %eax
jae 0x365651
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0x36562b
cmpl $0x2, -0x1c(%rsp)
je 0x36562b
cmpl $0x3, -0x1c(%rsp)
jne 0x365642
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x365644
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3655ee
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_cigar2qlen
int32_t bam_cigar2qlen(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k;
	int32_t l = 0;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CINS || op == BAM_CSOFT_CLIP || op == BAM_CEQUAL || op == BAM_CDIFF)
			l += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return l;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
cmpl %ecx, %eax
jae 0x3656eb
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0x3656c5
cmpl $0x1, -0x1c(%rsp)
je 0x3656c5
cmpl $0x4, -0x1c(%rsp)
je 0x3656c5
cmpl $0x7, -0x1c(%rsp)
je 0x3656c5
cmpl $0x8, -0x1c(%rsp)
jne 0x3656dc
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x3656de
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x36567a
movl -0x18(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_write1_core
inline int bam_write1_core(bamFile fp, const bam1_core_t *c, int data_len, uint8_t *data)
{
	uint32_t x[8], block_len = data_len + BAM_CORE_SIZE, y;
	int i;
	assert(BAM_CORE_SIZE == 32);
	x[0] = c->tid;
	x[1] = c->pos;
	x[2] = (uint32_t)c->bin<<16 | c->qual<<8 | c->l_qname;
	x[3] = (uint32_t)c->flag<<16 | c->n_cigar;
	x[4] = c->l_qseq;
	x[5] = c->mtid;
	x[6] = c->mpos;
	x[7] = c->isize;
	bgzf_flush_try(fp, 4 + block_len);
	if (bam_is_be) {
		for (i = 0; i < 8; ++i) bam_swap_endian_4p(x + i);
		y = block_len;
		bam_write(fp, bam_swap_endian_4p(&y), 4);
		swap_endian_data(c, data_len, data);
	} else bam_write(fp, &block_len, 4);
	bam_write(fp, x, BAM_CORE_SIZE);
	bam_write(fp, data, data_len);
	if (bam_is_be) swap_endian_data(c, data_len, data);
	return 4 + block_len;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movslq 0x54(%rsp), %rax
addq $0x20, %rax
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
andq $0xffff, %rax           # imm = 0xFFFF
shll $0x10, %eax
movq 0x58(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x10, %rcx
andq $0xff, %rcx
shll $0x8, %ecx
orl %ecx, %eax
movq 0x58(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
orl %ecx, %eax
movl %eax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
shll $0x10, %eax
movq 0x58(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
orl %ecx, %eax
movl %eax, 0x2c(%rsp)
movq 0x58(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x60(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x4, %esi
callq 0x4f7d80
leaq 0x2dcb77(%rip), %rax    # 0x643048
cmpl $0x0, (%rax)
je 0x36654b
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x366508
leaq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x365aa0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3664de
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x365aa0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x4f7dd0
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
callq 0x3660e0
jmp 0x36655f
movq 0x60(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
movl $0x4, %edx
callq 0x4f7dd0
movq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x4f7dd0
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x54(%rsp), %edx
callq 0x4f7dd0
leaq 0x2dcabb(%rip), %rax    # 0x643048
cmpl $0x0, (%rax)
je 0x3665a5
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
callq 0x3660e0
movl 0x1c(%rsp), %eax
addl $0x4, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_validate1
int bam_validate1(const bam_header_t *header, const bam1_t *b)
{
	char *s;

	if (b->core.tid < -1 || b->core.mtid < -1) return 0;
	if (header && (b->core.tid >= header->n_targets || b->core.mtid >= header->n_targets)) return 0;

	if (b->data_len < b->core.l_qname) return 0;
	s = memchr(bam1_qname(b), '\0', b->core.l_qname);
	if (s != &bam1_qname(b)[b->core.l_qname-1]) return 0;

	// FIXME: Other fields could also be checked, especially the auxiliary data

	return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, (%rax)
jl 0x367953
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x14(%rax)
jge 0x367960
movl $0x0, 0x24(%rsp)
jmp 0x367a2e
cmpq $0x0, 0x18(%rsp)
je 0x367996
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x367989
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jl 0x367996
movl $0x0, 0x24(%rsp)
jmp 0x367a2e
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
cmpl %ecx, %eax
jge 0x3679c0
movl $0x0, 0x24(%rsp)
jmp 0x367a2e
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
shrq $0x18, %rax
andq $0xff, %rax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x197f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rdx
shrq $0x18, %rdx
andq $0xff, %rdx
subl $0x1, %edx
movslq %edx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x367a26
movl $0x0, 0x24(%rsp)
jmp 0x367a2e
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_get_library
const char *bam_get_library(bam_header_t *h, const bam1_t *b)
{
	const uint8_t *rg;
	if (h->dict == 0) h->dict = sam_header_parse2(h->text);
	if (h->rg2lib == 0) h->rg2lib = sam_header2tbl(h->dict, "RG", "ID", "LB");
	rg = bam_aux_get(b, "RG");
	return (rg == 0)? 0 : sam_tbl_get(h->rg2lib, (const char*)(rg + 1));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x367a74
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x370630
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x367aaf
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x2336b4(%rip), %rsi    # 0x59b144
leaq 0x248016(%rip), %rdx    # 0x5afaad
leaq 0x235bfa(%rip), %rcx    # 0x59d698
callq 0x370f60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rdi
leaq 0x233689(%rip), %rsi    # 0x59b144
callq 0x4f9d20
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x367ad6
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x367af2
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x3718f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/sam.c
// Function: samwrite
int samwrite(samfile_t *fp, const bam1_t *b)
{
	if (fp == 0 || (fp->type & TYPE_READ)) return -1; // not open for writing
	if (fp->type & TYPE_BAM) return bam_write1(fp->x.bam, b);
	else {
		char *s = bam_format1_core(fp->header, b, fp->type>>2&3);
		int l = strlen(s);
		fputs(s, fp->x.tamw); fputc('\n', fp->x.tamw);
		free(s);
		return l + 1;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x36c335
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x36c342
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x36c3d8
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x36c36a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x3665c0
movl %eax, 0x24(%rsp)
jmp 0x36c3d8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %edx
sarl $0x2, %edx
andl $0x3, %edx
callq 0x366600
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x192b0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x19810
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movl $0xa, %edi
callq 0x198d0
movq 0x8(%rsp), %rdi
callq 0x19ef0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 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/external/samtools-0.1.18/sam.c
// Function: sampileup
int sampileup(samfile_t *fp, int mask, bam_pileup_f func, void *func_data)
{
	bam_plbuf_t *buf;
	int ret;
	bam1_t *b;
	b = bam_init1();
	buf = bam_plbuf_init(func, func_data);
	bam_plbuf_set_mask(buf, mask);
	while ((ret = samread(fp, b)) >= 0)
		bam_plbuf_push(b, buf);
	bam_plbuf_push(0, buf);
	bam_plbuf_destroy(buf);
	bam_destroy1(b);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x194a0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x36db60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x36dbc0
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0x36c290
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jl 0x36c463
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x36dbf0
jmp 0x36c43c
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x36dbf0
movq 0x10(%rsp), %rdi
callq 0x36dc90
cmpq $0x0, (%rsp)
je 0x36c498
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x19ef0
movq (%rsp), %rdi
callq 0x19ef0
jmp 0x36c49a
xorl %eax, %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/sam.c
// Function: samfaipath
char *samfaipath(const char *fn_ref)
{
	char *fn_list = 0;
	if (fn_ref == 0) return 0;
	fn_list = calloc(strlen(fn_ref) + 5, 1);
	strcat(strcpy(fn_list, fn_ref), ".fai");
	if (access(fn_list, R_OK) == -1) { // fn_list is unreadable
		if (access(fn_ref, R_OK) == -1) {
			fprintf(stderr, "[samfaipath] fail to read file %s.\n", fn_ref);
		} else {
			if (bam_verbose >= 3) fprintf(stderr, "[samfaipath] build FASTA index...\n");
			if (fai_build(fn_ref) == -1) {
				fprintf(stderr, "[samfaipath] fail to build FASTA index.\n");
				free(fn_list); fn_list = 0;
			}
		}
	}
	return fn_list;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x36c4d7
movq $0x0, 0x10(%rsp)
jmp 0x36c5c6
movq 0x8(%rsp), %rdi
callq 0x192b0
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x194a0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19700
movq %rax, %rdi
leaq 0x2318ac(%rip), %rsi    # 0x59ddba
callq 0x19cf0
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x19c50
cmpl $-0x1, %eax
jne 0x36c5bd
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x19c50
cmpl $-0x1, %eax
jne 0x36c55d
movq 0x2cfa5b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x2315a0(%rip), %rsi    # 0x59daf4
movb $0x0, %al
callq 0x199f0
jmp 0x36c5bb
leaq 0x2d2bfc(%rip), %rax    # 0x63f160
cmpl $0x3, (%rax)
jl 0x36c581
movq 0x2cfa30(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23159e(%rip), %rsi    # 0x59db18
movb $0x0, %al
callq 0x199f0
movq 0x8(%rsp), %rdi
callq 0x36ebb0
cmpl $-0x1, %eax
jne 0x36c5b9
movq 0x2cfa09(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23159a(%rip), %rsi    # 0x59db3b
movb $0x0, %al
callq 0x199f0
movq (%rsp), %rdi
callq 0x19ef0
movq $0x0, (%rsp)
jmp 0x36c5bb
jmp 0x36c5bd
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bam_pileup.c
// Function: bam_plp_init
bam_plp_t bam_plp_init(bam_plp_auto_f func, void *data)
{
	bam_plp_t iter;
	iter = calloc(1, sizeof(struct __bam_plp_t));
	iter->mp = mp_init();
	iter->head = iter->tail = mp_alloc(iter->mp);
	iter->dummy = mp_alloc(iter->mp);
	iter->max_tid = iter->max_pos = -1;
	iter->flag_mask = BAM_DEF_MASK;
	iter->maxcnt = 8000;
	if (func) {
		iter->func = func;
		iter->data = data;
		iter->b = bam_init1();
	}
	return iter;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x194a0
movq %rax, (%rsp)
callq 0x36e0f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x36c6b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x36c6b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0x704, 0x34(%rax)      # imm = 0x704
movq (%rsp), %rax
movl $0x1f40, 0x40(%rax)     # imm = 0x1F40
cmpq $0x0, 0x10(%rsp)
je 0x36c69e
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x60(%rax)
movl $0x1, %edi
movl $0x38, %esi
callq 0x194a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movq (%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_pileup.c
// Function: bam_pileup_file
int bam_pileup_file(bamFile fp, int mask, bam_pileup_f func, void *func_data)
{
	bam_plbuf_t *buf;
	int ret;
	bam1_t *b;
	b = bam_init1();
	buf = bam_plbuf_init(func, func_data);
	bam_plbuf_set_mask(buf, mask);
	while ((ret = bam_read1(fp, b)) >= 0)
		bam_plbuf_push(b, buf);
	bam_plbuf_push(0, buf);
	bam_plbuf_destroy(buf);
	bam_destroy1(b);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x194a0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x36db60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x36dbc0
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0x365d30
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jl 0x36db13
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x36dbf0
jmp 0x36daec
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x36dbf0
movq 0x10(%rsp), %rdi
callq 0x36dc90
cmpq $0x0, (%rsp)
je 0x36db48
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x19ef0
movq (%rsp), %rdi
callq 0x19ef0
jmp 0x36db4a
xorl %eax, %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_pileup.c
// Function: bam_plbuf_init
bam_plbuf_t *bam_plbuf_init(bam_pileup_f func, void *data)
{
	bam_plbuf_t *buf;
	buf = calloc(1, sizeof(bam_plbuf_t));
	buf->iter = bam_plp_init(0, 0);
	buf->func = func;
	buf->data = data;
	return buf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x194a0
movq %rax, (%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x36c5d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%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_pileup.c
// Function: bam_plbuf_push
int bam_plbuf_push(const bam1_t *b, bam_plbuf_t *buf)
{
	int ret, n_plp, tid, pos;
	const bam_pileup1_t *plp;
	ret = bam_plp_push(buf->iter, b);
	if (ret < 0) return ret;
	while ((plp = bam_plp_next(buf->iter, &tid, &pos, &n_plp)) != 0)
		buf->func(tid, pos, n_plp, plp, buf->data);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x36d460
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x36dc25
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x36dc7d
jmp 0x36dc27
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x36c920
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x36dc75
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x10(%r8), %r8
callq *%rax
jmp 0x36dc27
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_pileup.c
// Function: bam_mplp_init
bam_mplp_t bam_mplp_init(int n, bam_plp_auto_f func, void **data)
{
	int i;
	bam_mplp_t iter;
	iter = calloc(1, sizeof(struct __bam_mplp_t));
	iter->pos = calloc(n, 8);
	iter->n_plp = calloc(n, sizeof(int));
	iter->plp = calloc(n, sizeof(void*));
	iter->iter = calloc(n, sizeof(void*));
	iter->n = n;
	iter->min = (uint64_t)-1;
	for (i = 0; i < n; ++i) {
		iter->iter[i] = bam_plp_init(func, data[i]);
		iter->pos[i] = iter->min;
	}
	return iter;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x194a0
movq %rax, (%rsp)
movslq 0x24(%rsp), %rdi
movl $0x8, %esi
callq 0x194a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movslq 0x24(%rsp), %rdi
movl $0x4, %esi
callq 0x194a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movslq 0x24(%rsp), %rdi
movl $0x8, %esi
callq 0x194a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movslq 0x24(%rsp), %rdi
movl $0x8, %esi
callq 0x194a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x24(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movq $-0x1, 0x8(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x36ddd7
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x36c5d0
movq %rax, %rdx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x36dd7b
movq (%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/faidx.c
// Function: fai_insert_index
static inline void fai_insert_index(faidx_t *idx, const char *name, int len, int line_len, int line_blen, uint64_t offset)
{
	khint_t k;
	int ret;
	faidx1_t t;
	if (idx->n == idx->m) {
		idx->m = idx->m? idx->m<<1 : 16;
		idx->name = (char**)realloc(idx->name, sizeof(void*) * idx->m);
	}
	idx->name[idx->n] = strdup(name);
	k = kh_put(s, idx->hash, idx->name[idx->n], &ret);
	t.len = len; t.line_len = line_len; t.line_blen = line_blen; t.offset = offset;
	kh_value(idx->hash, k) = t;
	++idx->n;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movq %r9, 0x30(%rsp)
movq 0x50(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x50(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x36e64b
movq 0x50(%rsp), %rax
cmpl $0x0, 0xc(%rax)
je 0x36e60d
movq 0x50(%rsp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, 0xc(%rsp)
jmp 0x36e618
movl $0x10, %eax
movl %eax, 0xc(%rsp)
jmp 0x36e618
movl 0xc(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x50(%rsp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x19f00
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rdi
callq 0x19d90
movq %rax, %rdx
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x28(%rsp), %rdx
callq 0x36f770
movl %eax, 0x2c(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movl 0x2c(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/faidx.c
// Function: fai_destroy
void fai_destroy(faidx_t *fai)
{
	int i;
	for (i = 0; i < fai->n; ++i) free(fai->name[i]);
	free(fai->name);
	kh_destroy(s, fai->hash);
	if (fai->rz) razf_close(fai->rz);
	free(fai);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x36e753
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x19ef0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x36e721
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x19ef0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x36eb70
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x36e787
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x4fd1a0
movq 0x10(%rsp), %rdi
callq 0x19ef0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/faidx.c
// Function: fai_save
void fai_save(const faidx_t *fai, FILE *fp)
{
	khint_t k;
	int i;
	for (i = 0; i < fai->n; ++i) {
		faidx1_t x;
		k = kh_get(s, fai->hash, fai->name[i]);
		x = kh_value(fai->hash, k);
#ifdef _WIN32
		fprintf(fp, "%s\t%d\t%ld\t%d\t%d\n", fai->name[i], (int)x.len, (long)x.offset, (int)x.line_blen, (int)x.line_len);
#else
		fprintf(fp, "%s\t%d\t%lld\t%d\t%d\n", fai->name[i], (int)x.len, (long long)x.offset, (int)x.line_blen, (int)x.line_len);
#endif
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x36e86b
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x36e870
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movl 0x24(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x18(%rsp), %r8
movl 0xc(%rsp), %r9d
movl 0x8(%rsp), %eax
leaq 0x22f54a(%rip), %rsi    # 0x59dd9b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x199f0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x36e7b6
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/faidx.c
// Function: fai_read
faidx_t *fai_read(FILE *fp)
{
	faidx_t *fai;
	char *buf, *p;
	int len, line_len, line_blen;
#ifdef _WIN32
	long offset;
#else
	long long offset;
#endif
	fai = (faidx_t*)calloc(1, sizeof(faidx_t));
	fai->hash = kh_init(s);
	buf = (char*)calloc(0x10000, 1);
	while (!feof(fp) && fgets(buf, 0x10000, fp)) {
		for (p = buf; *p && isgraph(*p); ++p);
		*p = 0; ++p;
#ifdef _WIN32
		sscanf(p, "%d%ld%d%d", &len, &offset, &line_blen, &line_len);
#else
		sscanf(p, "%d%lld%d%d", &len, &offset, &line_blen, &line_len);
#endif
		fai_insert_index(fai, buf, len, line_len, line_blen, offset);
	}
	free(buf);
	return fai;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x194a0
movq %rax, 0x38(%rsp)
callq 0x36f750
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
movl $0x1, %esi
callq 0x194a0
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x19b10
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x36ea88
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rdx
movl $0x10000, %esi          # imm = 0x10000
callq 0x19b60
cmpq $0x0, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x36ea95
jmp 0x36eb57
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xe(%rsp)
je 0x36ead8
callq 0x197c0
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x36eae2
jmp 0x36eaf4
jmp 0x36eae4
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x36ea9f
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x22f297(%rip), %rsi    # 0x59ddad
leaq 0x24(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x1c(%rsp), %r8
leaq 0x20(%rsp), %r9
movb $0x0, %al
callq 0x19770
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x36e5c0
jmp 0x36ea52
movq 0x30(%rsp), %rdi
callq 0x19ef0
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/faidx.c
// Function: fai_build
int fai_build(const char *fn)
{
	char *str;
	RAZF *rz;
	FILE *fp;
	faidx_t *fai;
	str = (char*)calloc(strlen(fn) + 5, 1);
	sprintf(str, "%s.fai", fn);
	rz = razf_open(fn, "r");
	if (rz == 0) {
		fprintf(stderr, "[fai_build] fail to open the FASTA file %s\n",fn);
		free(str);
		return -1;
	}
	fai = fai_build_core(rz);
	razf_close(rz);
	fp = fopen(str, "wb");
	if (fp == 0) {
		fprintf(stderr, "[fai_build] fail to write FASTA index %s\n",str);
		fai_destroy(fai); free(str);
		return -1;
	}
	fai_save(fai, fp);
	fclose(fp);
	free(str);
	fai_destroy(fai);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x192b0
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x194a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x22f1ce(%rip), %rsi    # 0x59ddb8
movb $0x0, %al
callq 0x19100
movq 0x28(%rsp), %rdi
leaq 0x1bd3dd(%rip), %rsi    # 0x52bfda
callq 0x4fc270
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x36ec43
movq 0x2cd38a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x22f19a(%rip), %rsi    # 0x59ddbf
movb $0x0, %al
callq 0x199f0
movq 0x20(%rsp), %rdi
callq 0x19ef0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x36ecea
movq 0x18(%rsp), %rdi
callq 0x36e110
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4fd1a0
movq 0x20(%rsp), %rdi
leaq 0x1b7f35(%rip), %rsi    # 0x526b9d
callq 0x19800
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x36ecb5
movq 0x2cd31f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x22f15b(%rip), %rsi    # 0x59ddeb
movb $0x0, %al
callq 0x199f0
movq 0x8(%rsp), %rdi
callq 0x36e710
movq 0x20(%rsp), %rdi
callq 0x19ef0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x36ecea
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x36e7a0
movq 0x10(%rsp), %rdi
callq 0x19780
movq 0x20(%rsp), %rdi
callq 0x19ef0
movq 0x8(%rsp), %rdi
callq 0x36e710
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/faidx.c
// Function: fai_load
faidx_t *fai_load(const char *fn)
{
	char *str;
	FILE *fp;
	faidx_t *fai;
	str = (char*)calloc(strlen(fn) + 5, 1);
	sprintf(str, "%s.fai", fn);

#ifdef _USE_KNETFILE
    if (strstr(fn, "ftp://") == fn || strstr(fn, "http://") == fn)
    {
        fp = download_and_open(str);
        if ( !fp )
        {
            fprintf(stderr, "[fai_load] failed to open remote FASTA index %s\n", str);
            free(str);
            return 0;
        }
    }
    else
#endif
        fp = fopen(str, "rb");
	if (fp == 0) {
		fprintf(stderr, "[fai_load] build FASTA index.\n");
		fai_build(fn);
		fp = fopen(str, "rb");
		if (fp == 0) {
			fprintf(stderr, "[fai_load] fail to open FASTA index.\n");
			free(str);
			return 0;
		}
	}

	fai = fai_read(fp);
	fclose(fp);

	fai->rz = razf_open(fn, "rb");
	free(str);
	if (fai->rz == 0) {
		fprintf(stderr, "[fai_load] fail to open FASTA file.\n");
		return 0;
	}
	return fai;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x192b0
movq %rax, %rdi
addq $0x5, %rdi
movl $0x1, %esi
callq 0x194a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x22f07e(%rip), %rsi    # 0x59ddb8
movb $0x0, %al
callq 0x19100
movq 0x10(%rsp), %rdi
leaq 0x209198(%rip), %rsi    # 0x577ee5
callq 0x19800
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x36edce
movq 0x2cd23a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22f0a5(%rip), %rsi    # 0x59de15
movb $0x0, %al
callq 0x199f0
movq 0x18(%rsp), %rdi
callq 0x36ebb0
movq 0x10(%rsp), %rdi
leaq 0x209158(%rip), %rsi    # 0x577ee5
callq 0x19800
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x36edcc
movq 0x2cd1fa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22f084(%rip), %rsi    # 0x59de34
movb $0x0, %al
callq 0x199f0
movq 0x10(%rsp), %rdi
callq 0x19ef0
movq $0x0, 0x20(%rsp)
jmp 0x36ee41
jmp 0x36edce
movq 0x8(%rsp), %rdi
callq 0x36ea10
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x19780
movq 0x18(%rsp), %rdi
leaq 0x2090f3(%rip), %rsi    # 0x577ee5
callq 0x4fc270
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x19ef0
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x36ee38
movq 0x2cd184(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22f034(%rip), %rsi    # 0x59de5a
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x20(%rsp)
jmp 0x36ee41
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)