LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]n64graphics_ci/n64graphics_ci.c
// Function: getPaletteFilename
char* getPaletteFilename(char* ci_filename)
{
    int bin_filename_len;
    int extension_len;
    char* pal_bin_filename;
    char* extension_loc;
    char* extension;

    // Write Palette file
    bin_filename_len = strlen(ci_filename);
    extension_loc = strrchr(ci_filename, '.');
    extension_len = (int)(extension_loc - ci_filename);
    extension = malloc(extension_len);
    memcpy(extension, extension_loc, extension_len);
    pal_bin_filename = malloc(bin_filename_len + 4); // +4 to include ".pal"
    if (!pal_bin_filename) {
        ERROR("Error allocating bytes for palette filename\n");
    }
    memcpy(pal_bin_filename, ci_filename, bin_filename_len);
    strcpy(pal_bin_filename + bin_filename_len, ".pal");
    //strcpy(pal_bin_filename + bin_filename_len, extension);

    free(extension);

    return pal_bin_filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
callq 0x11d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x11b0
movl -0xc(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rdi
callq 0x11d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa127
movq 0x1deda(%rip), %rax     # 0x27ff0
movq (%rax), %rdi
leaq 0x18e63(%rip), %rsi     # 0x22f83
movb $0x0, %al
callq 0x1170
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x11b0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
leaq 0x18e66(%rip), %rsi     # 0x22fb0
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]n64graphics_ci/./stb/stb_image.h
// Function: stbi__gif_load
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   stbi_uc *u = 0;
   stbi__gif g;
   memset(&g, 0, sizeof(g));

   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
   if (u) {
      *x = g.w;
      *y = g.h;

      // moved conversion to after successful load so that the same
      // can be done for multiple frames. 
      if (req_comp && req_comp != 4)
         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
   }

   // free buffers needed for multiple frame loading; 
   STBI_FREE(g.history);
   STBI_FREE(g.background); 

   return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x88b0, %rsp           # imm = 0x88B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x88a8(%rbp), %rdi
xorl %esi, %esi
movl $0x8870, %edx           # imm = 0x8870
callq 0x1110
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x88a8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
callq 0x1bf60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0xbee0
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xbf2f
movl -0x88a8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x88a4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0xbf2d
cmpl $0x4, -0x24(%rbp)
je 0xbf2d
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x88a8(%rbp), %ecx
movl -0x88a4(%rbp), %r8d
movl $0x4, %esi
callq 0x18a80
movq %rax, -0x38(%rbp)
jmp 0xbf2f
movq -0x8890(%rbp), %rdi
callq 0x1040
movq -0x8898(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rax
addq $0x88b0, %rsp           # imm = 0x88B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]n64graphics_ci/n64graphics_ci.c
// Function: parse_format
static int parse_format(graphics_config *config, const char *str)
{
    for (unsigned i = 0; i < DIM(format_table); i++) {
        if (!strcasecmp(str, format_table[i].name)) {
            config->format = format_table[i].format;
            config->depth = format_table[i].depth;
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x2, %rax
jae 0x206f4
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x7720(%rip), %rax      # 0x27db0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1050
cmpl $0x0, %eax
jne 0x206e7
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x7700(%rip), %rax      # 0x27db0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x76e3(%rip), %rax      # 0x27db0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x206fb
jmp 0x206e9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20677
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]n64graphics_ci/n64graphics_ci.c
// Function: format2str
static const char *format2str(img_format format, int depth)
{
    for (unsigned i = 0; i < DIM(format_table); i++) {
        if (format == format_table[i].format && depth == format_table[i].depth) {
            return format_table[i].name;
        }
    }
    return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x2, %rax
jae 0x207d9
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leaq 0x7627(%rip), %rcx      # 0x27db0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0x207cc
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leaq 0x760c(%rip), %rcx      # 0x27db0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jne 0x207cc
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x75f4(%rip), %rax      # 0x27db0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x207e4
jmp 0x207ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x20771
leaq 0x3728(%rip), %rax      # 0x23f08
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sysendian/main.c
// Function: perftest
static int
perftest(void)
{
	struct tests tests_actual;
	struct tests * tests = &tests_actual;

	/* Copy the tests into the volatile variables. */
	fill_testcases(tests);

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, NULL, perftest_func, NULL, tests)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
leaq -0x108(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rdi
callq 0x2030
movq -0x110(%rbp), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
leaq 0x3d48(%rip), %rsi      # 0x51d0
movl $0x2, %edx
movl $0x1, %r8d
xorl %edi, %edi
movl %edi, %r9d
leaq 0xd51(%rip), %r10       # 0x21f0
movq %rcx, %rdi
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x3640
cmpl $0x0, %eax
je 0x14db
jmp 0x14c0
leaq 0x3b43(%rip), %rdi      # 0x500a
movb $0x0, %al
callq 0x3ea0
callq 0x1070
movl $0x0, (%rax)
jmp 0x14e4
movl $0x0, -0x4(%rbp)
jmp 0x14eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sysendian/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct tests * tests = cookie;
	size_t nreps_i;

	(void)buf; /* UNUSED */

	if (buflen == 32) {
		for (nreps_i = 0; nreps_i < nreps; nreps_i++)
			PERFTEST_FULL(tests, 32);
	} else if (buflen == 64) {
		for (nreps_i = 0; nreps_i < nreps; nreps_i++)
			PERFTEST_FULL(tests, 64);
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x20, -0x18(%rbp)
jne 0x22cd
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x22c8
jmp 0x2233
movq $0x0, -0x48(%rbp)
cmpq $0x4, -0x48(%rbp)
jae 0x22b3
leaq -0x3c(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %esi
callq 0x23b0
leaq -0x3c(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %esi
callq 0x2420
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movl 0x1c(%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2490
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movl 0x2c(%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x24d0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x223b
jmp 0x22b5
jmp 0x22b7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2223
jmp 0x239f
cmpq $0x40, -0x18(%rbp)
jne 0x239d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x239b
jmp 0x22f0
movq $0x0, -0x68(%rbp)
cmpq $0x8, -0x68(%rbp)
jae 0x2386
leaq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x68(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rsi
callq 0x2510
leaq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x68(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rsi
callq 0x25e0
movq -0x28(%rbp), %rax
movq -0x68(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x26b0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq -0x68(%rbp), %rcx
movq 0xc0(%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2740
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x22f8
jmp 0x2388
jmp 0x238a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x22e0
jmp 0x239d
jmp 0x239f
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sysendian/main.c
// Function: print_arr
static void
print_arr(const char * str, const uint8_t * arr, size_t n)
{
	size_t i;

	printf("%s", str);
	for (i = 0; i < n; i++)
		printf("%02x ", arr[i]);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x2bb3(%rip), %rdi      # 0x53e2
movb $0x0, %al
callq 0x10c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2870
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x292d(%rip), %rdi      # 0x5188
movb $0x0, %al
callq 0x10c0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x283e
leaq 0x2d40(%rip), %rdi      # 0x55b7
movb $0x0, %al
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/main.c
// Function: example_outfn
static void example_outfn(const char *buf,int len,void *context) // {{{
{
  FILE *f=(FILE *)context;
  if (fwrite(buf,1,len,f)!=len) {
    perror("Short write");
    assert(0);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x2290
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
je 0x27d5
leaq 0xa9e1(%rip), %rdi      # 0xd192
callq 0x2130
leaq 0xb3f3(%rip), %rdi      # 0xdbb0
leaq 0xa845(%rip), %rsi      # 0xd009
movl $0x2a, %edx
leaq 0xa9ce(%rip), %rcx      # 0xd19e
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/main.c
// Function: main
int main(int argc,char **argv)
{
  const char *fn=TESTFONT;
  if (argc==2) {
    fn=argv[1];
  }
  OTF_FILE *otf=otf_load(fn);
  assert(otf);
  printf("width(4): %d\n",otf_get_width(otf,4));


  if (strcmp(fn,"test.ttf")!=0) {
    example_write_fontdescr(otf,"test.ttf");
  } else {
    example_write_fontdescr(otf,NULL);
  }

  // show_post(otf);

  // show_name(otf);

  // show_cmap(otf);
  // printf("%d %d\n",otf_from_unicode(otf,'A'),0);

  // ... name 6 -> FontName  /20(cid)
  // ? StemV Flags(?) from FontName

  otf_close(otf);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xa92f(%rip), %rax      # 0xd12c
movq %rax, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x2813
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3830
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2829
jmp 0x2848
leaq 0xa930(%rip), %rdi      # 0xd160
leaq 0xa7d2(%rip), %rsi      # 0xd009
movl $0x94, %edx
leaq 0xa921(%rip), %rcx      # 0xd164
callq 0x2100
movq -0x20(%rbp), %rdi
movl $0x4, %esi
callq 0x4770
movl %eax, %esi
leaq 0xa91c(%rip), %rdi      # 0xd17b
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rdi
leaq 0xa918(%rip), %rsi      # 0xd189
callq 0x21f0
cmpl $0x0, %eax
je 0x288d
movq -0x20(%rbp), %rdi
leaq 0xa903(%rip), %rsi      # 0xd189
callq 0x23a0
jmp 0x289a
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23a0
movq -0x20(%rbp), %rdi
callq 0x2f10
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/run_hmmannot.c
// Function: parse_fheader
static inline int parse_fheader(char *s)
{
    char *c = s;
    while (*c != 0 && !isspace(*c))
        ++c;
    *c = 0;
    if (c - s == 1) // empty
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3d4b
callq 0x23e0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3d54
jmp 0x3d62
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d14
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0x3d83
movl $0x1, -0x4(%rbp)
jmp 0x3d8a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/run_hmmannot.c
// Function: parse_gseq
static inline int parse_gseq(char *s, char **seg, char **seq)
{
    if (*s != 'S') return 4;
    
    int i;
    char *p, *q;
    int c;
    for (i = 0, p = q = s + 2;; ++p) {
        if (*p == 0 || *p == '\t') {
            c = *p;
            *p = 0;
            if (i == 0)
                *seg = q;
            else if (i == 1)
                *seq = q;
            ++i, q = p + 1;
            if (i == 2 || c == 0)
                break;
        }
    }

    if (i != 2) return 5;
    if (**seq == '*') return 6;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
je 0x3dc8
movl $0x4, -0x4(%rbp)
jmp 0x3e94
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3df7
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3e53
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x3e1b
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3e2e
cmpl $0x1, -0x24(%rbp)
jne 0x3e2c
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3e2e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x24(%rbp)
je 0x3e4f
cmpl $0x0, -0x3c(%rbp)
jne 0x3e51
jmp 0x3e66
jmp 0x3e53
jmp 0x3e55
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3ddf
cmpl $0x2, -0x24(%rbp)
je 0x3e75
movl $0x5, -0x4(%rbp)
jmp 0x3e94
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x3e8d
movl $0x6, -0x4(%rbp)
jmp 0x3e94
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/run_hmmannot.c
// Function: annot_worker_for
static void annot_worker_for(void *_data, long i, int tid) // kt_for() callback
{
    annot_step_t *annot_s = (annot_step_t *) _data;
    int exit_code, wexit_st;

    char cmd[4096];
    sprintf(cmd, "%s --noali --cpu 1 -o /dev/null --tblout %s %s %s", annot_s->shared->nhmmscan, annot_s->temp_out[i], annot_s->shared->nhmmdb, annot_s->temp_in[i]);

    exit_code = run_system_cmd(cmd, 3);
    if (exit_code == -1) {
        fprintf(stderr, "[E::%s] failed to execute command: %s\n", __func__, cmd);
        exit(EXIT_FAILURE);
    }
    
    wexit_st = WEXITSTATUS(exit_code);
    if (wexit_st) {
        fprintf(stderr, "[E::%s] command with non-zero exit code: %d\n", __func__, wexit_st);
        exit(EXIT_FAILURE);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x1030(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rsi
movq (%rax,%rsi,8), %r9
leaq 0x55e5(%rip), %rsi      # 0x94e7
movb $0x0, %al
callq 0x2360
leaq -0x1030(%rbp), %rdi
movl $0x3, %esi
callq 0x6e00
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x3f53
movq 0x80ce(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq -0x1030(%rbp), %rcx
leaq 0x55de(%rip), %rsi      # 0x9519
leaq 0x55fe(%rip), %rdx      # 0x9540
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
movl -0x24(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x3f93
movq 0x808a(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movl -0x28(%rbp), %ecx
leaq 0x55d6(%rip), %rsi      # 0x9551
leaq 0x55be(%rip), %rdx      # 0x9540
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_destroy
void hmm_annot_db_destroy(hmm_annot_db_t *annot_db)
{
    if (!annot_db) return;
    size_t i;
    kh_str_t *h_gnames = (kh_str_t *) annot_db->h_gnames;
    kh_str_destroy(h_gnames);
    for (i = 0; i < annot_db->n_gene; ++i)
        free(annot_db->gnames[i]);
    free(annot_db->gnames);
    kh_str_t *h_snames = (kh_str_t *) annot_db->h_snames;
    kh_str_destroy(h_snames);
    for (i = 0; i < annot_db->n_seg; ++i)
        free(annot_db->snames[i]);
    free(annot_db->snames);
    free(annot_db->a);
    free(annot_db->index);
    free(annot_db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x44c8
jmp 0x45a5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45b0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
cmpq %rcx, %rax
jae 0x4518
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x44e5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45b0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
cmpq %rcx, %rax
jae 0x4575
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4542
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_bed6_db_destroy
void hmm_annot_bed6_db_destroy(hmm_annot_bed6_db_t *annot_db)
{
    size_t i;
    for (i = 0; i < annot_db->n_seg; ++i)
        free(annot_db->snames[i]);
    free(annot_db->snames);
    free(annot_db->a);
    free(annot_db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4645
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4614
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: is_empty_line
static int is_empty_line(char *line)
{
    char *c;
    c = line;
    while (isspace((unsigned char) *c))
        c++;
    if(*c == 0)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x23e0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x4c72
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4c44
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4c87
movl $0x1, -0x4(%rbp)
jmp 0x4c8e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_gname2id
uint32_t hmm_annot_gname2id(hmm_annot_db_t *annot_db, char *gname)
{
    kh_str_t *h_gnames;
    khint32_t k;
    h_gnames = (kh_str_t *) annot_db->h_gnames;
    k = kh_str_get(h_gnames, gname);
    return k < kh_end(h_gnames)? kh_val(h_gnames, k) : UINT32_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4ef0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4eaf
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
jmp 0x4eb6
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x4eb6
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jae 0x4eda
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x4ee4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x4ee4
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_sname2id
uint32_t hmm_annot_sname2id(hmm_annot_db_t *annot_db, char *sname)
{
    kh_str_t *h_snames;
    khint32_t k;
    h_snames = (kh_str_t *) annot_db->h_snames;
    k = kh_str_get(h_snames, sname);
    return k < kh_end(h_snames)? kh_val(h_snames, k) : UINT32_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4ef0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4f6f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f76
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f76
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jae 0x4f9a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x4fa4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x4fa4
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_print_all_fields
static inline void hmm_annot_print_all_fields(hmm_annot_t *annot, FILE *fo)
{
    fprintf(fo, "%s [%u] %s [%u] %u %u %u %u %u %u %u %c %e %.1f %.1f\n",
            annot->gname, annot->gid, annot->sname, (uint32_t) annot->sid, 
            annot->hmmfrom, annot->hmmto, annot->alifrom, annot->alito,
            annot->envfrom, annot->envto, annot->modlen, annot->strand? '-' : '+', 
            annot->evalue, annot->score, annot->bias);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rax
movl 0x48(%rax), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x30(%rbp), %rax
movl 0x4c(%rax), %r9d
movq -0x30(%rbp), %rax
movl 0x10(%rax), %r13d
movq -0x30(%rbp), %rax
movl 0x14(%rax), %r12d
movq -0x30(%rbp), %rax
movl 0x18(%rax), %r15d
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %r14d
movq -0x30(%rbp), %rax
movl 0x20(%rax), %ebx
movq -0x30(%rbp), %rax
movl 0x24(%rax), %r11d
movq -0x30(%rbp), %rax
movl 0x28(%rax), %r10d
movq -0x30(%rbp), %rax
movl 0x48(%rax), %eax
shrl $0x1f, %eax
movl $0x2b, %esi
movl %esi, -0x3c(%rbp)
movl $0x2d, %esi
cmpl $0x0, %eax
movl -0x3c(%rbp), %eax
cmovnel %esi, %eax
movq -0x30(%rbp), %rsi
movsd 0x30(%rsi), %xmm0
movq -0x30(%rbp), %rsi
movsd 0x38(%rsi), %xmm1
movq -0x30(%rbp), %rsi
movsd 0x40(%rsi), %xmm2
leaq 0x45c2(%rip), %rsi      # 0x967c
movl %r13d, (%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movb $0x3, %al
callq 0x2220
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_sort
void hmm_annot_db_sort(hmm_annot_db_t *annot_db, hmm_annot_so_t so)
{
    if (so == annot_db->so) return;
    switch(so) {
        case ORDER_GNAME:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc1);
            break;
        case ORDER_GID:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc2);
            break;
        case ORDER_SNAME:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc3);
            break;
        case ORDER_SID:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc4);
            break;
        case ORDER_SID_OG:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc5);
            break;
        case ORDER_SID_CO:
            qsort(annot_db->a, annot_db->n, sizeof(hmm_annot_t), hmm_annot_cmpfunc6);
            break;
        default:
            fprintf(stderr, "[E::%s] undefined sorting: %d\n", __func__, so);
            exit(EXIT_FAILURE);
    }
    annot_db->so = so;
    hmm_annot_db_sort_index(annot_db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0x5150
jmp 0x528c
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x524d
movq -0x18(%rbp), %rax
leaq 0x442d(%rip), %rcx      # 0x959c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x10d(%rip), %rcx       # 0x52a0
callq 0x20d0
jmp 0x5279
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x118(%rip), %rcx       # 0x52d0
callq 0x20d0
jmp 0x5279
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x143(%rip), %rcx       # 0x5320
callq 0x20d0
jmp 0x5279
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x14e(%rip), %rcx       # 0x5350
callq 0x20d0
jmp 0x5279
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x17c(%rip), %rcx       # 0x53a0
callq 0x20d0
jmp 0x5279
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x50, %edx
leaq 0x2ea(%rip), %rcx       # 0x5530
callq 0x20d0
jmp 0x5279
movq 0x6da4(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movl -0xc(%rbp), %ecx
leaq 0x43cf(%rip), %rsi      # 0x9630
leaq 0x43e7(%rip), %rdx      # 0x964f
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x5610
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_cmpfunc5
static int hmm_annot_cmpfunc5(const void *a, const void *b)
{
    hmm_annot_t *x, *y;
    x = (hmm_annot_t *) a;
    y = (hmm_annot_t *) b;

    if (x->sid != y->sid)
        return (x->sid > y->sid) - (x->sid < y->sid);
    if (x->og_type != y->og_type)
        return (x->og_type > y->og_type) - (x->og_type < y->og_type);
    if (x->gid != y->gid)
        return (x->gid > y->gid) - (x->gid < y->gid);
    return (x->score < y->score) - (x->score > y->score);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
je 0x5403
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x4c(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x4c(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x551e
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
shrl $0x1d, %eax
andl $0x3, %eax
movq -0x28(%rbp), %rcx
movl 0x48(%rcx), %ecx
shrl $0x1d, %ecx
andl $0x3, %ecx
cmpl %ecx, %eax
je 0x5474
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
shrl $0x1d, %eax
andl $0x3, %eax
movq -0x28(%rbp), %rcx
movl 0x48(%rcx), %ecx
shrl $0x1d, %ecx
andl $0x3, %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x48(%rcx), %ecx
shrl $0x1d, %ecx
andl $0x3, %ecx
movq -0x28(%rbp), %rdx
movl 0x48(%rdx), %edx
shrl $0x1d, %edx
andl $0x3, %edx
cmpl %edx, %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x551e
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movq -0x28(%rbp), %rcx
movl 0x48(%rcx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
cmpl %ecx, %eax
je 0x54e0
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movq -0x28(%rbp), %rcx
movl 0x48(%rcx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x48(%rcx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movq -0x28(%rbp), %rdx
movl 0x48(%rdx), %edx
andl $0x1fffffff, %edx       # imm = 0x1FFFFFFF
cmpl %edx, %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x551e
movq -0x20(%rbp), %rax
movsd 0x38(%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movsd 0x38(%rcx), %xmm0
movq -0x28(%rbp), %rcx
ucomisd 0x38(%rcx), %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_cmpfunc6
static int hmm_annot_cmpfunc6(const void *a, const void *b)
{
    hmm_annot_t *x, *y;
    x = (hmm_annot_t *) a;
    y = (hmm_annot_t *) b;
    if (x->sid != y->sid)
        return (x->sid > y->sid) - (x->sid < y->sid);
    if (x->alifrom != y->alifrom)
        return (x->alifrom > y->alifrom) - (x->alifrom < y->alifrom);
    return (x->alito > y->alito) - (x->alito < y->alito);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
je 0x5590
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x4c(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x4c(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5606
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x55d4
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x18(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5606
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x1c(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_sort_index
static void hmm_annot_db_sort_index(hmm_annot_db_t *annot_db)
{
    if (annot_db->index) free(annot_db->index);
    annot_db->index = 0;
    hmm_annot_so_t so = annot_db->so;
    if (so == ORDER_UNKNOWN || so == ORDER_UNSORTED ||
            so == ORDER_GNAME || so == ORDER_SNAME)
        return;
    switch(so) {
        case ORDER_GID:
            annot_db->index = hmm_annot_db_sort_index_gid(annot_db);
            annot_db->n_idx = annot_db->n_gene;
            break;
        case ORDER_SID:
        case ORDER_SID_OG:
        case ORDER_SID_CO:
            annot_db->index = hmm_annot_db_sort_index_sid(annot_db);
            annot_db->n_idx = annot_db->n_seg;
            break;
        default:
            fprintf(stderr, "[E::%s] undefined sorting: %d\n", __func__, so);
            exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x5634
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x5662
cmpl $0x0, -0xc(%rbp)
je 0x5662
cmpl $0x1, -0xc(%rbp)
je 0x5662
cmpl $0x3, -0xc(%rbp)
jne 0x5667
jmp 0x56f5
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x5681
jmp 0x5674
movl -0x10(%rbp), %eax
addl $-0x4, %eax
subl $0x3, %eax
jb 0x56a5
jmp 0x56c9
movq -0x8(%rbp), %rdi
callq 0x6a30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
jmp 0x56f5
movq -0x8(%rbp), %rdi
callq 0x6b20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
jmp 0x56f5
movq 0x6928(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movl -0xc(%rbp), %ecx
leaq 0x3f53(%rip), %rsi      # 0x9630
leaq 0x3fce(%rip), %rdx      # 0x96b2
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_index_query
hmm_annot_t *hmm_annot_db_index_query(hmm_annot_db_t *annot_db, uint32_t id, uint32_t *n)
{
    hmm_annot_t *q = 0;
    *n = 0;
    if (id < annot_db->n_idx) {
        q = &annot_db->a[annot_db->index[id] >> 32];
        *n = (uint32_t) annot_db->index[id];
    }
    return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jae 0x576a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_print_bed6
void hmm_annot_print_bed6(hmm_annot_bed6_db_t *annots, FILE *fo, int header)
{
    if (!annots->n) return;

    if (header)
        print_hmm_annot_bed6_header(fo);
    size_t i;
    hmm_annot_bed6_t *bed6;
    
    qsort(annots->a, annots->n, sizeof(hmm_annot_bed6_t), annot_bed6_cmpfunc);
    
    for (i = 0; i < annots->n; ++i) {
        bed6 = &annots->a[i];
        fprintf(fo, "%s\t%u\t%u\t%s\t%d\t%c\n", bed6->sname, bed6->alifrom,
                bed6->alito, bed6->gname, bed6->score, bed6->strand);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5ed2
jmp 0x5f83
cmpl $0x0, -0x14(%rbp)
je 0x5ee1
movq -0x10(%rbp), %rdi
callq 0x59a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x20, %edx
leaq 0x94(%rip), %rcx        # 0x5f90
callq 0x20d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5f83
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x28(%rbp), %rax
movl 0x18(%rax), %r8d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %r9
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x28(%rbp), %rax
movsbl 0x10(%rax), %eax
leaq 0x36fb(%rip), %rsi      # 0x9661
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2220
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5f09
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: annot_bed6_cmpfunc
static int annot_bed6_cmpfunc(const void *a, const void *b)
{
    hmm_annot_bed6_t *x, *y;
    x = (hmm_annot_bed6_t *) a;
    y = (hmm_annot_bed6_t *) b;
    int c;
    c = strcmp(x->sname, y->sname);
    if (c) return c;
    c = (x->alifrom > y->alifrom) - (x->alifrom < y->alifrom);
    if (c) return c;
    return (x->alito > y->alito) - (x->alito < y->alito);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x2200
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x5fd4
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6046
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x14(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x6014
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6046
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
movq -0x28(%rbp), %rdx
cmpl 0x18(%rdx), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_sort_index_gid
static uint64_t *hmm_annot_db_sort_index_gid(hmm_annot_db_t *annot_db)
{
    // index annotation for fast access to list of a given gene
    uint32_t i, j, n_gene, gid;
    hmm_annot_t *annots;
    annots = annot_db->a;
    n_gene = annot_db->n_gene;
    uint64_t *index;
    MYCALLOC(index, n_gene);
    gid = annots[0].gid;
    for (i = 1, j = 0; i < annot_db->n; ++i) {
        if (gid != annots[i].gid) {
            index[gid] = (uint64_t) j << 32 | (i - j);
            j = i;
            gid = annots[i].gid;
        }
    }
    index[gid] = (uint64_t) j << 32 | (i - j);
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x21f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movl %eax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6af7
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %edx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
movl 0x48(%rcx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
cmpl %ecx, %eax
je 0x6aea
movl -0x10(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x48(%rax), %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x6aec
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a82
movl -0x10(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/hmmannot.c
// Function: hmm_annot_db_sort_index_sid
static uint64_t *hmm_annot_db_sort_index_sid(hmm_annot_db_t *annot_db)
{
    // index annotation for fast access to gene list of seqs
    uint32_t i, j, n_seg, sid;
    hmm_annot_t *annots;
    annots = annot_db->a;
    n_seg = annot_db->n_seg;
    uint64_t *index;
    MYCALLOC(index, n_seg);
    sid = annots[0].sid;
    for (i = 1, j = 0; i < annot_db->n; ++i) {
        if (sid != annots[i].sid) {
            index[sid] = (uint64_t) j << 32 | (i - j);
            j = i;
            sid = annots[i].sid;
        }
    }
    index[sid] = (uint64_t) j << 32 | (i - j);
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x21f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6bd5
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %edx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4c(%rcx), %eax
je 0x6bc8
movl -0x10(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x4c(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x6bca
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6b6d
movl -0x10(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: sleep_ms
void sleep_ms(int milliseconds) {
#ifdef WIN32
    Sleep(milliseconds);
#elif _POSIX_C_SOURCE >= 199309L
    struct timespec ts;
    ts.tv_sec = milliseconds / 1000;
    ts.tv_nsec = (milliseconds % 1000) * 1000000;
    nanosleep(&ts, NULL);
#else
    if (milliseconds >= 1000)
        sleep(milliseconds / 1000);
    usleep((milliseconds % 1000) * 1000);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: make_tempfile
char *make_tempfile(char *temp_dir, char *file_template, const char *suffix)
{
    sprintf(file_template, "%s/tmpXXXXXXXXXX%s", temp_dir, suffix);
    int ret = mkstemps(file_template, strlen(suffix));
    if (ret >= 0) {
        // need to close the file descriptor
        close(ret);
        return strdup(file_template);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2971(%rip), %rsi      # 0x9718
movb $0x0, %al
callq 0x2360
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2130
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2030
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6dea
movl -0x24(%rbp), %edi
callq 0x21c0
movq -0x18(%rbp), %rdi
callq 0x23a0
movq %rax, -0x8(%rbp)
jmp 0x6df2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: run_system_cmd
int run_system_cmd(char *cmd, int retry)
{
    int exit_code = system(cmd);
    --retry;
    if ((exit_code != -1 && !WEXITSTATUS(exit_code)) || !retry)
        return exit_code;
    return run_system_cmd(cmd, retry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x6e3a
movl -0x18(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x6e40
cmpl $0x0, -0x14(%rbp)
jne 0x6e48
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e57
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6e00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq