LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/view.c
// Function: parse_tbf_fname_list
static void parse_tbf_fname_list(
  char *tbk_fname_list,
  tbf_t **tbfs, int *n_tbfs) {
  
  if (tbk_fname_list == NULL) return;
  
  gzFile fh = wzopen(tbk_fname_list);
  if (!fh) { wzfatal("Cannot read tbk file name list."); }
  char *line = NULL; char **fields; int nfields; char *sname;
  while(gzFile_read_line(fh, &line)) {
    line_get_fields(line, "\t", &fields, &nfields);
    if (nfields > 0) {
      (*tbfs) = realloc((*tbfs), (++(*n_tbfs)) * sizeof(tbf_t));
      if (nfields > 1) sname = fields[1]; else sname = NULL;
      tbf_open1(fields[0], &(*tbfs)[*n_tbfs-1], sname);
    }
    free_fields(fields, nfields);
  }
  free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x53c0
jmp 0x54a5
movq -0x8(%rbp), %rdi
callq 0x5e40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x53e2
leaq 0x704c3(%rip), %rdi     # 0x7589e
movb $0x0, %al
callq 0x4270
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5ef0
cmpl $0x0, %eax
je 0x549c
movq -0x28(%rbp), %rdi
leaq 0x74a98(%rip), %rsi     # 0x79ea3
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x6060
cmpl $0x0, -0x34(%rbp)
jle 0x548b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movslq %eax, %rsi
shlq $0x5, %rsi
callq 0x37c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x1, -0x34(%rbp)
jle 0x545a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x5462
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0x5da0
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x6170
jmp 0x53ea
movq -0x28(%rbp), %rdi
callq 0x3370
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/view.c
// Function: infer_idx
static void infer_idx(tbk_t *tbks, int n_tbks, char **idx_fname) {

  if (*idx_fname != NULL) return;
  
  /* look at the message box for idx_fname */
  int i;
  for(i=0; i<min(n_tbks, 500); ++i) {
    char *res = clean_path(tbks[i].extra, tbks[i].tbf->fname);
    if (res) {
      DIR *d = opendir(res);
      if (d) {               /* exclude the possibility that it's a folder */
        closedir(d);
      } else {
        /* FILE *fp = fopen(res,"r"); */
        htsFile *fp = hts_open(res,"r");
        if(fp) {
          *idx_fname = res;
          hts_close(fp);
          break;
        }
      }
    }
  }

  /* Last resort:
     look at the parent folder for the first tbk file idx.gz */
  if (*idx_fname == NULL) {
    char *tmp = strdup(tbks[0].tbf->fname); /* search first tbk */
    char *dir = dirname(tmp);
    *idx_fname = calloc(strlen(dir) + 10, sizeof(char));
    strcpy(*idx_fname, dir);
    strcat(*idx_fname, "/idx.gz");
    free(tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54d2
jmp 0x5634
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x1f4, -0x24(%rbp)     # imm = 0x1F4
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x54fc
movl -0x24(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x5502
movl -0x20(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x54(%rbp), %eax
movl -0x58(%rbp), %ecx
movl %ecx, -0x28(%rbp)
cmpl -0x28(%rbp), %eax
jge 0x55b8
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x2028, %rax, %rax     # imm = 0x2028
addq %rax, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x2028, %rcx, %rcx     # imm = 0x2028
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x61c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x55a8
movq -0x30(%rbp), %rdi
callq 0x33c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5573
movq -0x38(%rbp), %rdi
callq 0x3730
jmp 0x55a6
movq -0x30(%rbp), %rdi
leaq 0x73ea5(%rip), %rsi     # 0x79423
callq 0xeba0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x55a4
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rdi
callq 0xf950
jmp 0x55b8
jmp 0x55a6
jmp 0x55a8
jmp 0x55aa
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x54d9
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5634
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x35f0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3060
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3380
movq %rax, %rdi
addq $0xa, %rdi
movl $0x1, %esi
callq 0x36b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x3660
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x702ff(%rip), %rsi     # 0x75925
callq 0x3500
movq -0x48(%rbp), %rdi
callq 0x3370
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: unit_size
static inline int unit_size(uint64_t d) {
  int nu = unit_base[DATA_TYPE(d)];
  if (DATA_TYPE(d) == DT_STRINGF) {
    nu += STRING_MAX(d);
  }
  return nu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
andq $0xff, %rcx
leaq 0x6f326(%rip), %rax     # 0x75010
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
cmpq $0x7, %rax
jne 0x5d12
movq -0x8(%rbp), %rcx
shrq $0x8, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbf_open1
static inline void tbf_open1(char *fname, tbf_t *tbf, char *sname) {
  memset(tbf, 0, sizeof(tbf_t));
  tbf->offset = 0;
  tbf->fname = strdup(fname);
  tbf->fh = fopen(fname, "rb");
  if (!tbf->fh) wzfatal("Cannot open %s to read.\n", tbf->fname);
  if (sname != NULL) {tbf->sname_first = strdup(sname);}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3090
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x35f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
leaq 0x6fa93(%rip), %rsi     # 0x75882
callq 0x3260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5e1e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6fa6e(%rip), %rdi     # 0x75885
movb $0x0, %al
callq 0x4270
cmpq $0x0, -0x18(%rbp)
je 0x5e39
movq -0x18(%rbp), %rdi
callq 0x35f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzio.h
// Function: wzopen
static inline gzFile wzopen(char *path) {
  gzFile fh;
  if (strcmp(path, "-") == 0) {
    fh = gzdopen(fileno(stdin), "r");
  } else {
    fh = gzopen(path, "r");
    if (!fh) {
      fprintf(stderr, "[%s:%d] Fatal, cannot open file: %s\n",
              __func__, __LINE__, path);
      fflush(stderr);
      exit(1);
    }
  }
  return fh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6fa67(%rip), %rsi     # 0x758be
callq 0x3620
cmpl $0x0, %eax
jne 0x5e84
movq 0x7f170(%rip), %rax     # 0x84fd8
movq (%rax), %rdi
callq 0x3040
movl %eax, %edi
leaq 0x735aa(%rip), %rsi     # 0x79423
callq 0x3420
movq %rax, -0x10(%rbp)
jmp 0x5ee2
movq -0x8(%rbp), %rdi
leaq 0x73594(%rip), %rsi     # 0x79423
callq 0x3170
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5ee0
movq 0x7f142(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movq -0x8(%rbp), %r8
leaq 0x6fa0c(%rip), %rsi     # 0x758c0
leaq 0x6fa2a(%rip), %rdx     # 0x758e5
movl $0x14, %ecx
movb $0x0, %al
callq 0x37f0
movq 0x7f11a(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
callq 0x38c0
movl $0x1, %edi
callq 0x3180
jmp 0x5ee2
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzio.h
// Function: gzFile_read_line
static inline int gzFile_read_line(gzFile fh, char **s) {

  if (s == NULL) {
    fprintf(stderr, "[%s:%d] Fatal, empty string construct.\n", __func__, __LINE__);
    fflush(stderr);
    exit(1);
  }
  
  /* reset s */
  int m = 10, l = 0;            /* memory and string length */
  *s = realloc(*s, m);

  /* read until '\n' or EOF */
  while (1) {
    int c = gzgetc(fh);
    if (l > m-2) { m <<= 1; *s = realloc(*s, m); }
    if (c == '\n') {(*s)[l] = '\0'; return 1;}
    if (c == EOF) {(*s)[l] = '\0'; return 0;}
    (*s)[l++] = c;
  }
  return 0;                     /* should not come here */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f44
movq 0x7f0da(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6f9d4(%rip), %rsi     # 0x758ec
leaq 0x6f9f5(%rip), %rdx     # 0x75914
movl $0x3c, %ecx
movb $0x0, %al
callq 0x37f0
movq 0x7f0b6(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
callq 0x38c0
movl $0x1, %edi
callq 0x3180
movl $0xa, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x37c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fab
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x5fb7
movq -0x10(%rbp), %rdi
callq 0x3740
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jle 0x5fec
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x37c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0xa, -0x24(%rbp)
jne 0x600a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x4(%rbp)
jmp 0x604a
cmpl $-0x1, -0x24(%rbp)
jne 0x6028
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x604a
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x5f6c
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzio.h
// Function: line_get_fields
static inline void line_get_fields(const char *line, const char *sep, char ***fields, int *nfields) {

  *nfields = 1;
  const char *s = line;
  while ((s = strpbrk(s, sep)) != NULL) { (*nfields)++; s++; }

  *fields = calloc(*nfields, sizeof(char *));
  char *working = calloc(strlen(line) + 1, sizeof(char));
  strcpy(working, line);
  char *tok; int i;

  tok = strtok(working, sep);
  for (i=0; tok != NULL; ++i) {
    (*fields)[i] = strdup(tok);
    tok = strtok(NULL, sep);
  }
  free(working);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3220
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x60ba
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x608a
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x36b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3380
movq %rax, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x36b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3660
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3670
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6156
movq -0x38(%rbp), %rdi
callq 0x35f0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3670
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6118
movq -0x30(%rbp), %rdi
callq 0x3370
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzmisc.h
// Function: free_char_array
static inline void free_char_array(char **char_array, int n) {
  int i;
  for (i=0; i<n; ++i)
    free(char_array[i]);
  free(char_array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x61aa
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3370
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6186
movq -0x8(%rbp), %rdi
callq 0x3370
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: clean_path
static inline char* clean_path(char *path, char *fname) {
  /* expand POSIX */
  wordexp_t result;
  wordexp(path, &result, 0);
  strcpy(path, result.we_wordv[0]);
  wordfree(&result);

  /* append current directory */
  char buf[PATH_MAX];
  if (path[0] == '/') {
    strcpy(buf, path);
  } else {
    char *tmp = strdup(fname);
    strcpy(buf, dirname(tmp));
    free(tmp);
    strcat(buf, "/");
    strcat(buf, path);
  }

  return realpath(buf, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x3470
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x3660
leaq -0x28(%rbp), %rdi
callq 0x37a0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x6219
leaq -0x1030(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3660
jmp 0x6281
movq -0x10(%rbp), %rdi
callq 0x35f0
movq %rax, -0x1038(%rbp)
leaq -0x1030(%rbp), %rax
movq %rax, -0x1040(%rbp)
movq -0x1038(%rbp), %rdi
callq 0x3060
movq -0x1040(%rbp), %rdi
movq %rax, %rsi
callq 0x3660
movq -0x1038(%rbp), %rdi
callq 0x3370
leaq -0x1030(%rbp), %rdi
leaq 0x729d8(%rip), %rsi     # 0x78c44
callq 0x3500
leaq -0x1030(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3500
leaq -0x1030(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/view.c
// Function: error
static void error(const char *format, ...) {
  va_list ap;
  va_start(ap, format);
  vfprintf(stderr, format, ap);
  va_end(ap);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x62d5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x7ecc1(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3310
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x3180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzio.h
// Function: line_get_fields2
static inline void line_get_fields2(
  const char *line, const char *sep, char ***fields, int *nfields, char **aux) {

  int nfields_ = 1;
  const char *s = line;
  while ((s = strpbrk(s, sep)) != NULL) { nfields_++; s++; }

  if (*nfields < 0) {
    *nfields = nfields_;
    *fields = calloc(*nfields, sizeof(char*));
  } else if (*nfields != nfields_) {
    fprintf(stderr, "Wrong field number %d (expecting %d).\n", nfields_, *nfields);
    fflush(stderr);
    exit(1);
  }

  *aux = realloc(*aux, (strlen(line) + 1) * sizeof(char));
  strcpy(*aux, line);
  char *tok; int i;

  tok = strtok(*aux, sep);
  for (i=0; tok != NULL; ++i) {
    (*fields)[i] = realloc((*fields)[i], strlen(tok)+1);
    strcpy((*fields)[i], tok);
    tok = strtok(NULL, sep);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3220
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x63a9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x637b
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x63d8
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x36b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x641f
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
je 0x641d
movq 0x7ebfe(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
leaq 0x6f600(%rip), %rsi     # 0x759fd
movb $0x0, %al
callq 0x37f0
movq 0x7ebdd(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
callq 0x38c0
movl $0x1, %edi
callq 0x3180
jmp 0x641f
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3380
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
shlq $0x0, %rsi
callq 0x37c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3660
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3670
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x64f5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3380
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x37c0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rsi
callq 0x3660
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3670
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x647c
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbk_print_columnnames
static inline void tbk_print_columnnames(
  tbk_t *tbks, int n_tbks, int nfields, FILE *out_fh, view_conf_t *conf) {

  int ii;
  fputs("seqname\tstart\tend", out_fh);
  if (conf->print_all) {
    fputs("\toffset", out_fh);
    for(ii=4; ii<nfields; ++ii)
      fprintf(out_fh, "\tField_%d", ii+1);
  }

  for(ii=0; ii<n_tbks; ++ii) {
    fprintf(out_fh, "\t%s", tbks[ii].sname);
    if (conf->print_all_units) {
      char *tmp = malloc(strlen(tbks[ii].sname) + 5);
      strcpy(tmp, tbks[ii].sname);
      strcat(tmp, "_sig2");
      fprintf(out_fh, "\t%s", tmp);
      free(tmp);
    }
  }

  fputc('\n', out_fh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x6f4ff(%rip), %rdi     # 0x75a24
callq 0x3520
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6578
movq -0x18(%rbp), %rsi
leaq 0x6f4f7(%rip), %rdi     # 0x75a36
callq 0x3520
movl $0x4, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6576
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %edx
addl $0x1, %edx
leaq 0x6f4da(%rip), %rsi     # 0x75a3e
movb $0x0, %al
callq 0x37f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x654b
jmp 0x6578
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6643
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2028, %rcx, %rcx     # imm = 0x2028
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x6f426(%rip), %rsi     # 0x759d1
movb $0x0, %al
callq 0x37f0
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x6633
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2028, %rcx, %rcx     # imm = 0x2028
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3380
movq %rax, %rdi
addq $0x5, %rdi
callq 0x3250
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2028, %rcx, %rcx     # imm = 0x2028
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3660
movq -0x30(%rbp), %rdi
leaq 0x6f439(%rip), %rsi     # 0x75a48
callq 0x3500
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x6f3ae(%rip), %rsi     # 0x759d1
movb $0x0, %al
callq 0x37f0
movq -0x30(%rbp), %rdi
callq 0x3370
jmp 0x6635
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x657f
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x3350
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzmisc.h
// Function: ensure_number2
static inline void ensure_number2(char *s) {
  int i;
  for (i=0;s[i];++i) {
    if (i==0 && s[0] == '-') continue;
    if (!isdigit(s[i]) && s[i]!='.') {
      fprintf(stderr, "[%s:%d] Trying to convert nondigit string to number: %s\n", __func__, __LINE__, s);
      fflush(stderr);
      exit(1);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x6720
cmpl $0x0, -0xc(%rbp)
jne 0x6699
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6699
jmp 0x6712
callq 0x3410
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x6710
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x6710
movq 0x7e912(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movq -0x8(%rbp), %r8
leaq 0x6f36a(%rip), %rsi     # 0x75a4e
leaq 0x6f39c(%rip), %rdx     # 0x75a87
movl $0x48, %ecx
movb $0x0, %al
callq 0x37f0
movq 0x7e8ea(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
callq 0x38c0
movl $0x1, %edi
callq 0x3180
jmp 0x6712
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6673
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/pack.c
// Function: free_data
void free_data(void *bd0) {
  int i;
  beddata_t *bd = (beddata_t*) bd0;
  for (i=0; i<bd->n; ++i) {
    free(bd->s[i]);
    bd->s[i] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x8303
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3370
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x82cb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/pack.c
// Function: parse_data
void parse_data(bed1_t *b, char **fields, int nfields) {
  if (nfields < 4) wzfatal("No data in column 4.\n");
  int i; beddata_t *bd = (beddata_t*) b->data;
  for (i=0; i<bd->n; ++i) {
    bd->s[i] = strdup(fields[3+i]);
  }
  /* b->data = strdup(fields[3]); */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x8337
leaq 0x6da7c(%rip), %rdi     # 0x75dac
movb $0x0, %al
callq 0x8390
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x8386
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x35f0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x834a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/pack.c
// Function: usage
static int usage(conf_pack_t *conf) {
  fprintf(stderr, "\n");
  fprintf(stderr, "Usage: tbmate pack [options] <in.bed> <out.tbk>\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "    -s        int1, int2, int32, int, float, double, stringf, stringd, ones ([-1,1] up to 3e-5 precision)\n");
  fprintf(stderr, "    -x        optional output of an index file containing address for each record.\n");
  fprintf(stderr, "    -n        integer number for nan or '.' [%f]. \n", conf->nan),
  fprintf(stderr, "    -m        optional message, it will also be used to locate index file.\n");
  fprintf(stderr, "    -h        This help\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Note, in.bed is an index-ordered bed file. Column 4 will be made a .tbk file.\n");
  fprintf(stderr, "\n");

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7bba5(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6bd10(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x7bb8d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6ca99(%rip), %rsi     # 0x75efe
movb $0x0, %al
callq 0x37f0
movq 0x7bb75(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6bce0(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x7bb5d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6c000(%rip), %rsi     # 0x75495
movb $0x0, %al
callq 0x37f0
movq 0x7bb45(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6ca82(%rip), %rsi     # 0x75f2f
movb $0x0, %al
callq 0x37f0
movq 0x7bb2d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6cad5(%rip), %rsi     # 0x75f9a
movb $0x0, %al
callq 0x37f0
movq 0x7bb15(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x6cb05(%rip), %rsi     # 0x75fee
movb $0x1, %al
callq 0x37f0
movq 0x7baf1(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6cb21(%rip), %rsi     # 0x76022
movb $0x0, %al
callq 0x37f0
movq 0x7bad9(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6c34b(%rip), %rsi     # 0x75864
movb $0x0, %al
callq 0x37f0
movq 0x7bac1(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6bc2c(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x7baa9(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6cb25(%rip), %rsi     # 0x7606e
movb $0x0, %al
callq 0x37f0
movq 0x7ba91(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6bbfc(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzbed.h
// Function: init_bed_file
static inline bed_file_t *init_bed_file(char *file_path) {
  bed_file_t *bed = calloc(1, sizeof(bed_file_t));
  bed->file_path = strdup(file_path);
  bed->fh = wzopen(bed->file_path);
  bed->targets = 0;
  bed->line = NULL;
  bed->seqname = NULL;
  return bed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x36b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9980
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzbed.h
// Function: init_bed1
static inline bed1_t *init_bed1(init_data_f init_data, void *aux_data) {
  bed1_t *b = calloc(1, sizeof(bed1_t));
  if (init_data != NULL)
    init_data(b, aux_data);
  return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x36b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9638
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzbed.h
// Function: bed_read1
static inline int bed_read1(bed_file_t *bed, bed1_t *b, parse_data_f parse_data) {
  if (bed->fh == NULL) return 0;
  if (gzFile_read_line(bed->fh, &bed->line) == 0) return 0;

  char **fields; int nfields;
  line_get_fields(bed->line, "\t", &fields, &nfields);
  if (nfields < 3)
    wzfatal("[%s:%d] Bed file has fewer than 3 columns.\n", __func__, __LINE__);

  if (bed->seqname==NULL || strcmp(fields[0], bed->seqname) != 0) {
    free(bed->seqname); bed->seqname = strdup(fields[0]);
  }
  b->seqname = bed->seqname;
  /* b->tid = get_tid(bed->targets, fields[0], 1); */
  /* locate_or_insert_target_v(bed->targets, fields[0]); */

  ensure_number(fields[1]);
  b->beg = atoi(fields[1]);

  ensure_number(fields[2]);
  b->end = atoi(fields[2]);

  if (parse_data != NULL) parse_data(b, fields, nfields);
  else b->data = NULL;
  free_fields(fields, nfields);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x967b
movl $0x0, -0x4(%rbp)
jmp 0x97b7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x9a30
cmpl $0x0, %eax
jne 0x96a1
movl $0x0, -0x4(%rbp)
jmp 0x97b7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x707f3(%rip), %rsi     # 0x79ea3
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x9ba0
cmpl $0x3, -0x2c(%rbp)
jge 0x96dd
leaq 0x6c2cd(%rip), %rdi     # 0x75997
leaq 0x6c9ec(%rip), %rsi     # 0x760bd
movl $0x6f, %edx
movb $0x0, %al
callq 0x8390
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9701
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3620
cmpl $0x0, %eax
je 0x9725
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3370
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x35f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9cb0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3550
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9cb0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3550
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x9798
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq *%rax
jmp 0x97a4
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x9d70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbk_write_hdr
static inline void tbk_write_hdr(int32_t version, uint64_t dtype, int64_t n, char *msg, FILE*tbk_out) {
  char id[3] = {'t','b','k'};
  fwrite(&id,      HDR_ID,         1, tbk_out);
  fwrite(&version, HDR_VERSION,    1, tbk_out);
  fwrite(&dtype,   HDR_DATA_TYPE,  1, tbk_out);
  fwrite(&n,       HDR_NMAX,       1, tbk_out);
  fwrite(msg,      HDR_EXTRA,      1, tbk_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movw 0x6c562(%rip), %ax      # 0x75da4
movw %ax, -0x2b(%rbp)
movb 0x6c55a(%rip), %al      # 0x75da6
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rcx
leaq -0x2b(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x3780
movq -0x28(%rbp), %rcx
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x3780
movq -0x28(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x3780
movq -0x28(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x3780
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x1fe9, %esi           # imm = 0x1FE9
movl $0x1, %edx
callq 0x3780
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzbed.h
// Function: free_bed_file
static inline void free_bed_file(bed_file_t *bed) {
  wzclose(bed->fh);
  /* destroy_target_v(bed->targets); */
  if (bed->targets) destroy_targets(bed->targets);
  free(bed->file_path);
  free(bed->line);
  free(bed->seqname);
  free(bed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9941
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9f90
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rdi
callq 0x3370
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./wzmisc.h
// Function: ensure_number
static inline void ensure_number(char *s) {
  int i;
  for (i=0;s[i];++i) {
    if (!isdigit(s[i]) && s[i]!='.') {
      fprintf(stderr, "[%s:%d] Trying to convert nondigit string to number: %s\n", __func__, __LINE__, s);
      fflush(stderr);
      exit(1);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x9d5c
callq 0x3410
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x9d4c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x9d4c
movq 0x7b2d6(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movq -0x8(%rbp), %r8
leaq 0x6bd2e(%rip), %rsi     # 0x75a4e
leaq 0x6c3a0(%rip), %rdx     # 0x760c7
movl $0x3b, %ecx
movb $0x0, %al
callq 0x37f0
movq 0x7b2ae(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
callq 0x38c0
movl $0x1, %edi
callq 0x3180
jmp 0x9d4e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9cc3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/pack.c
// Function: is_float
static int is_float(beddata_t *samples, int n_samples) {
  int i, j;
  for (j=0; j<n_samples; ++j) {
    for (i=0;samples[j].s[0][i];++i) {
      if (!isdigit(samples[j].s[0][i]) &&
          samples[j].s[0][i] != '.' &&
          samples[j].s[0][i] != '-') return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9ea3
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x9e93
callq 0x3410
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x9e83
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x9e83
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x9e83
movl $0x0, -0x4(%rbp)
jmp 0x9eaa
jmp 0x9e85
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9de9
jmp 0x9e95
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9dd6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/pack.c
// Function: is_integer
static int is_integer(beddata_t *samples, int n_samples) {
  int i, j;
  for (j=0;j<n_samples;++j) {
    for (i=0;samples[j].s[0][i];++i) {
      if (!isdigit(samples[j].s[0][i]) &&
          samples[j].s[0][i] != '-') return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9f80
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x9f70
callq 0x3410
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x9f60
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x9f60
movl $0x0, -0x4(%rbp)
jmp 0x9f87
jmp 0x9f62
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9ee9
jmp 0x9f72
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9ed6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbf_open_update
static inline tbf_t *tbf_open_update(char *fname) {
  tbf_t *tbf = calloc(1, sizeof(tbf_t));
  tbf->offset = 0;
  tbf->fname = strdup(fname);
  tbf->fh = fopen(fname, "r+b");
  if (!tbf->fh) wzfatal("Cannot open %s to update.\n", tbf->fname);
  return tbf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x36b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x35f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
leaq 0x6bd46(%rip), %rsi     # 0x762e0
callq 0x3260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa5c9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6bd22(%rip), %rdi     # 0x762e4
movb $0x0, %al
callq 0xa490
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbf_num_samples
static inline int tbf_num_samples(char *fname) {
  tbf_t *tbf = tbf_open(fname);
  tbk_t tbk = {0};
  int n = 0;
  while(1) {
    tbf_next(tbf, &tbk);
    tbf_skip_data(&tbk);
    n++;
    if (tbk.version < 100) break;
  }
  tbf_close(tbf);
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa630
movq %rax, -0x10(%rbp)
leaq -0x2038(%rbp), %rdi
xorl %esi, %esi
movl $0x2028, %edx           # imm = 0x2028
callq 0x3090
movl $0x0, -0x203c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2038(%rbp), %rsi
callq 0xa700
leaq -0x2038(%rbp), %rdi
callq 0xa810
movl -0x203c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x203c(%rbp)
cmpl $0x64, -0x2028(%rbp)
jge 0xa6df
jmp 0xa6e1
jmp 0xa6a9
movq -0x10(%rbp), %rdi
callq 0xa5e0
movl -0x203c(%rbp), %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/header.c
// Function: usage
static int usage() {
  fprintf(stderr, "\n");
  fprintf(stderr, "Usage: tbmate header [options] [.tbk [...]]\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "    -m        set message for the first tbk (index path)\n");
  fprintf(stderr, "    -h        This help\n");
  fprintf(stderr, "\n");

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x7a73d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6a8a8(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x7a725(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6b9ac(%rip), %rsi     # 0x76279
movb $0x0, %al
callq 0x37f0
movq 0x7a70d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6a878(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x7a6f5(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6ab98(%rip), %rsi     # 0x75495
movb $0x0, %al
callq 0x37f0
movq 0x7a6dd(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6b991(%rip), %rsi     # 0x762a6
movb $0x0, %al
callq 0x37f0
movq 0x7a6c5(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6af37(%rip), %rsi     # 0x75864
movb $0x0, %al
callq 0x37f0
movq 0x7a6ad(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6a818(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/./tbmate.h
// Function: tbk_close
static inline void tbk_close(tbk_t *tbk) {
  char *sname = tbk->sname;
  /* reset everything except fname and sname */
  memset(tbk, 0, sizeof(tbk_t));
  tbk->sname = sname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2028, %edx           # imm = 0x2028
callq 0x3090
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/bundle.c
// Function: usage
static int usage() {
  fprintf(stderr, "\n");
  fprintf(stderr, "Usage: tbmate bundle [options] <out.tbk> <in1.tbk> <in2.tbk> ...\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "    -h        This help\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Note, the first tbk maybe multiple tbk.\n");
  fprintf(stderr, "\n");

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x79c7d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x69de8(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x79c65(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6afbf(%rip), %rsi     # 0x7634c
movb $0x0, %al
callq 0x37f0
movq 0x79c4d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x69db8(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x79c35(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6a0d8(%rip), %rsi     # 0x75495
movb $0x0, %al
callq 0x37f0
movq 0x79c1d(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6a48f(%rip), %rsi     # 0x75864
movb $0x0, %al
callq 0x37f0
movq 0x79c05(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x69d70(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movq 0x79bed(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x6af89(%rip), %rsi     # 0x7638e
movb $0x0, %al
callq 0x37f0
movq 0x79bd5(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
leaq 0x69d40(%rip), %rsi     # 0x7515d
movb $0x0, %al
callq 0x37f0
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/hts.c
// Function: hts_idx_save_as
int hts_idx_save_as(const hts_idx_t *idx, const char *fn, const char *fnidx, int fmt)
{
    BGZF *fp;

    #define check(ret) if ((ret) < 0) goto fail

    if (fnidx == NULL) return hts_idx_save(idx, fn, fmt);

    fp = bgzf_open(fnidx, (fmt == HTS_FMT_BAI)? "wu" : "w");
    if (fp == NULL) return -1;

    if (fmt == HTS_FMT_CSI) {
        check(bgzf_write(fp, "CSI\1", 4));
        check(idx_write_int32(fp, idx->min_shift));
        check(idx_write_int32(fp, idx->n_lvls));
        check(idx_write_uint32(fp, idx->l_meta));
        if (idx->l_meta) check(bgzf_write(fp, idx->meta, idx->l_meta));
    } else if (fmt == HTS_FMT_TBI) {
        check(bgzf_write(fp, "TBI\1", 4));
    } else if (fmt == HTS_FMT_BAI) {
        check(bgzf_write(fp, "BAI\1", 4));
    } else abort();

    check(hts_idx_save_core(idx, fp, fmt));

    return bgzf_close(fp);
    #undef check

fail:
    bgzf_close(fp);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12ca6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x12b70
movl %eax, -0x4(%rbp)
jmp 0x12e11
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %ecx
leaq 0x62404(%rip), %rsi     # 0x750b8
leaq 0x63ced(%rip), %rax     # 0x769a8
cmpl $0x1, %ecx
cmoveq %rax, %rsi
callq 0x39540
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x12cde
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e11
cmpl $0x0, -0x24(%rbp)
jne 0x12d89
movq -0x30(%rbp), %rdi
leaq 0x63930(%rip), %rsi     # 0x76623
movl $0x4, %edx
callq 0x3bef0
cmpq $0x0, %rax
jge 0x12d08
jmp 0x12e01
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x12e20
cmpq $0x0, %rax
jge 0x12d23
jmp 0x12e01
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x12e20
cmpq $0x0, %rax
jge 0x12d3e
jmp 0x12e01
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x12e60
cmpq $0x0, %rax
jge 0x12d59
jmp 0x12e01
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x12d87
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x3bef0
cmpq $0x0, %rax
jge 0x12d85
jmp 0x12e01
jmp 0x12d87
jmp 0x12ddc
cmpl $0x2, -0x24(%rbp)
jne 0x12dae
movq -0x30(%rbp), %rdi
leaq 0x6388e(%rip), %rsi     # 0x76628
movl $0x4, %edx
callq 0x3bef0
cmpq $0x0, %rax
jge 0x12dac
jmp 0x12e01
jmp 0x12dda
cmpl $0x1, -0x24(%rbp)
jne 0x12dd3
movq -0x30(%rbp), %rdi
leaq 0x63855(%rip), %rsi     # 0x76614
movl $0x4, %edx
callq 0x3bef0
cmpq $0x0, %rax
jge 0x12dd1
jmp 0x12e01
jmp 0x12dd8
callq 0x3100
jmp 0x12dda
jmp 0x12ddc
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x12ea0
cmpl $0x0, %eax
jge 0x12df3
jmp 0x12e01
movq -0x30(%rbp), %rdi
callq 0x3c070
movl %eax, -0x4(%rbp)
jmp 0x12e11
movq -0x30(%rbp), %rdi
callq 0x3c070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)