LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_composite.c
// Function: parse_composite
static error_t parse_composite(int key, char* arg, struct argp_state* state) {
  struct arg_composite* composite = state->input;
  assert( composite );
  assert( composite->global );
  switch(key)
  {
  case 'b':
  {
   composite_opt.b = 1;
   break;
  }
  case 'i':
  {
    composite_opt.i = 1;
    break;
  }
  case 's':
  {
    composite_opt.s = atoi(arg);
    break;
  }
  case 'd':
  {
   composite_opt.d = 1;
   break;
  }
  case 'p':
  {
   composite_opt.p = atoi(arg);
   break;
  }
  case 'r':
  {
   strcpy(composite_opt.refdir, arg);
   break;
  }
  case 'q':
  {
   strcpy(composite_opt.qrydir, arg);
   break;
  }
  case 'o':
  {
   strcpy(composite_opt.outdir, arg);
   break;
  }
  case ARGP_KEY_ARGS:
  {
   composite_opt.num_remaining_args = state->argc - state->next;
   composite_opt.remaining_args = state->argv + state->next;
   break;
  }
    case ARGP_KEY_NO_ARGS:
    {
   if(state->argc<2)
   {
       printf("\v");
    argp_state_help(state,stdout,ARGP_HELP_SHORT_USAGE);
    printf("\v");
       argp_state_help(state,stdout,ARGP_HELP_LONG);
       printf("\v");
       return EINVAL;
   }
    }
  break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x6569
cmpq $0x0, (%rax)
je 0x6588
movl $0x7, %eax
leal -0x62(%rdi), %ecx
cmpl $0x11, %ecx
ja 0x647e
leaq 0xedba(%rip), %rdx      # 0x15220
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, 0x15e07(%rip)     # 0x1c280
jmp 0x650b
movq %rdx, %rbx
cmpl $0x1000002, %edi        # imm = 0x1000002
je 0x6515
cmpl $0x1000006, %edi        # imm = 0x1000006
jne 0x650d
movl 0x8(%rbx), %eax
movslq 0x18(%rbx), %rcx
subl %ecx, %eax
movl %eax, 0x160f0(%rip)     # 0x1c594
shlq $0x3, %rcx
addq 0x10(%rbx), %rcx
movq %rcx, 0x160e5(%rip)     # 0x1c598
jmp 0x650b
leaq 0x15ed8(%rip), %rdi     # 0x1c394
jmp 0x6506
leaq 0x15dcf(%rip), %rdi     # 0x1c294
jmp 0x6506
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x15db3(%rip)     # 0x1c288
jmp 0x650b
movl $0x1, 0x15dab(%rip)     # 0x1c28c
jmp 0x650b
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x15d9f(%rip)     # 0x1c290
jmp 0x650b
movl $0x1, 0x15d87(%rip)     # 0x1c284
jmp 0x650b
leaq 0x15f8e(%rip), %rdi     # 0x1c494
callq 0x3080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
cmpl $0x1, 0x8(%rbx)
jg 0x650d
movl $0xb, %edi
callq 0x3050
movq 0x15aaa(%rip), %r14     # 0x1bfd8
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movl $0x16, %eax
jmp 0x650d
leaq 0xed20(%rip), %rdi      # 0x15290
leaq 0xf102(%rip), %rsi      # 0x15679
leaq 0xf10f(%rip), %rcx      # 0x1568d
movl $0x49, %edx
callq 0x3200
leaq 0xf138(%rip), %rdi      # 0x156c7
leaq 0xf0e3(%rip), %rsi      # 0x15679
leaq 0xf0f0(%rip), %rcx      # 0x1568d
movl $0x4a, %edx
callq 0x3200
nop
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: test_get_fullpath
const char* test_get_fullpath(const char *parent_path, const char *dstat_f)
{
 struct stat path_stat;
  if( stat(parent_path, &path_stat) < 0 )
  err(errno,"test_get_fullpath()::%s",parent_path);
  if( S_ISDIR(path_stat.st_mode) ){
  char* fullpath = malloc(PATHLEN+1);
  sprintf((char *)fullpath,"%s/%s", parent_path, dstat_f);
  FILE *fp;
  if ( (fp = fopen(fullpath,"rb")) != NULL ){
   fclose(fp);
   return fullpath;
  }
  else{
   free((char*)fullpath);
   return NULL;
  }
 }
 else
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x32e0
testl %eax, %eax
js 0x6c57
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x6c44
movl $0x101, %edi            # imm = 0x101
callq 0x3340
movq %rax, %r14
leaq 0xe785(%rip), %rsi      # 0x15393
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3430
leaq 0xe442(%rip), %rsi      # 0x15067
movq %r14, %rdi
callq 0x33a0
testq %rax, %rax
je 0x6c3c
movq %rax, %rdi
callq 0x3100
jmp 0x6c47
movq %r14, %rdi
callq 0x3040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0xf099(%rip), %rsi      # 0x15cfe
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: dist_organize_refpath
infile_tab_t* dist_organize_refpath( dist_opt_val_t *opt_val){
 struct stat path_stat;
 if( stat(opt_val->refpath, &path_stat) < 0)
  err(errno,"dist_organize_refpath():%s",opt_val->refpath);
 if( S_ISDIR(path_stat.st_mode) || isOK_fmt_infile(opt_val->refpath, acpt_infile_fmt,ACPT_FMT_SZ) ){
  char * tmp_arg[] = {opt_val->refpath};
  return organize_infile_frm_arg(1, tmp_arg,1);
 }
 else if(S_ISREG(path_stat.st_mode))
  return organize_infile_list(opt_val->refpath,1);
 else
  return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
addq $0x122, %rbx            # imm = 0x122
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
js 0x6cfd
movl $0xf000, %ebp           # imm = 0xF000
andl 0x20(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
je 0x6cbc
leaq 0x172d5(%rip), %rsi     # 0x1df80
movq %rbx, %rdi
movl $0x7, %edx
callq 0x8e80
testl %eax, %eax
je 0x6cdb
movq %rsp, %rsi
movq %rbx, (%rsi)
movl $0x1, %edi
movl $0x1, %edx
callq 0x1171a
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x8000, %ebp           # imm = 0x8000
jne 0x6cf9
movq %rbx, %rdi
movl $0x1, %esi
addq $0x98, %rsp
popq %rbx
popq %rbp
jmp 0x11287
xorl %eax, %eax
jmp 0x6cd1
callq 0x3060
movl (%rax), %edi
leaq 0xf6cf(%rip), %rsi      # 0x163da
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: get_dim_shuffle
dim_shuffle_t *get_dim_shuffle( dist_opt_val_t *opt_val_in )
{
 char shuf_infile_name_prefix[PATHLEN+9];
  char shuf_infile_name[PATHLEN];
  strcpy(shuf_infile_name, opt_val_in->dr_file);
  if( strcmp( shuf_infile_name, "" ) == 0 )
  {
    srand ( time(NULL) );
    dim_shuffle_stat_t dim_shuffle_stat =
    {
      rand(),
      opt_val_in->k,
      opt_val_in->dr_level + add_len_drlevel2subk(),
      opt_val_in->dr_level,
    };
  struct stat outd;
  if( (stat(opt_val_in->outdir, &outd) != 0 ) || (! S_ISDIR(outd.st_mode) ) )
   mkdir(opt_val_in->outdir,0777);
  sprintf(shuf_infile_name_prefix, "%s/default",opt_val_in->outdir);
    write_dim_shuffle_file( &dim_shuffle_stat,shuf_infile_name_prefix);
    sprintf(shuf_infile_name,"%s.shuf",shuf_infile_name_prefix);
  };
  return read_dim_shuffle_file(shuf_infile_name);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x3080
cmpb $0x0, (%r14)
jne 0x6de7
xorl %edi, %edi
callq 0x3310
movl %eax, %edi
callq 0x3270
callq 0x34c0
movl %eax, (%rsp)
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rbx), %ebp
callq 0x10eef
addl %ebp, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rbx), %eax
movl %eax, 0xc(%rsp)
addq $0x322, %rbx            # imm = 0x322
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
jne 0x6d9a
movl $0xf000, %eax           # imm = 0xF000
andl 0x28(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x6da7
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
leaq 0xeded(%rip), %rsi      # 0x15b9b
leaq 0x1a0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
movq %rsp, %rdi
movq %r14, %rsi
callq 0x10c73
leaq 0xedd1(%rip), %rsi      # 0x15ba6
leaq 0xa0(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3430
leaq 0xa0(%rsp), %rdi
callq 0x10ef5
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: get_hashsz
int get_hashsz(dim_shuffle_t *dim_shuffle_in )
{
 llong ctx_space_sz = 1LLU << 4*( dim_shuffle_in->dim_shuffle_stat.k - dim_shuffle_in->dim_shuffle_stat.drlevel );
  int primer_ind = 4*( dim_shuffle_in->dim_shuffle_stat.k - dim_shuffle_in->dim_shuffle_stat.drlevel ) - CTX_SPC_USE_L - 7;
  if(primer_ind < 0 || primer_ind > 24 ){
    int k_add = primer_ind < 0 ? (1 + (0-primer_ind)/4) : - (1 + ( primer_ind - 24 )/4) ;
    err(errno,"get_hashsz(): primer_ind: %d out of range(0 ~ 24), by formula:\n"
    "int primer_ind = 4*(opt_val->k - dim_shuffle->dim_shuffle_stat.drlevel) - CTX_SPC_USE_L - 7\n"
    "this might caused by too small or too large k\n"
    "kmer length = %d\n"
    "dim reduction level = %d\n"
    "ctx_space size = %llu\n"
    "CTX space usage limit = %lf\n\n"
    "try rerun the program with option -k = %d",
    primer_ind, dim_shuffle_in->dim_shuffle_stat.k, dim_shuffle_in->dim_shuffle_stat.drlevel,ctx_space_sz,
       (double)1/(1 << CTX_SPC_USE_L),dim_shuffle_in->dim_shuffle_stat.k + k_add );
  };
  int hashsize_get = primer[primer_ind];
 return hashsize_get ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %ebx
movl 0xc(%rdi), %ebp
movl %ebx, %eax
subl %ebp, %eax
leal -0xf(,%rax,4), %r14d
leal -0xa(%rax), %ecx
cmpl $-0x7, %ecx
jbe 0x6e41
movl %r14d, %eax
leaq 0x10eb1(%rip), %rcx     # 0x17ce0
movl (%rcx,%rax,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal (,%rax,4), %ecx
cmpl $0x3, %eax
jg 0x6e62
movl $0xc, %r12d
subl %ecx, %r12d
shrl $0x2, %r12d
movl $0x1, %r13d
jmp 0x6e7c
leal -0x27(%rcx), %eax
leal -0x24(%rcx), %r12d
testl %eax, %eax
cmovnsl %eax, %r12d
sarl $0x2, %r12d
negl %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0x1, %r15d
shlq %cl, %r15
callq 0x3060
movl (%rax), %edi
addl %ebx, %r13d
addl %r12d, %r13d
movl %r13d, (%rsp)
leaq 0xed11(%rip), %rsi      # 0x15bae
movsd 0xe863(%rip), %xmm0     # 0x15708
movl %r14d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
movq %r15, %r9
movb $0x1, %al
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: dist_organize_infiles
infile_tab_t* dist_organize_infiles (dist_opt_val_t *opt_val)
{
 int fmt_ck;
 if(opt_val->pipecmd[0]=='\0')
  fmt_ck = 1;
 else
  fmt_ck = 0;
 if( strcmp( opt_val->fpath, "" ) !=0 )
 {
  return organize_infile_list(opt_val->fpath,fmt_ck);
 }
 else if( opt_val->num_remaining_args > 0 )
 {
  return organize_infile_frm_arg(opt_val->num_remaining_args, opt_val->remaining_args,fmt_ck);
 }
 else
 {
  perror("please specify the input/query files");
    return NULL;
 }
}

// Assembly:
xorl %edx, %edx
cmpb $0x0, 0x44b(%rdi)
sete %dl
cmpb $0x0, 0x222(%rdi)
je 0x8481
addq $0x222, %rdi            # imm = 0x222
movl %edx, %esi
jmp 0x11287
movl 0x650(%rdi), %eax
testl %eax, %eax
jle 0x8499
movq 0x658(%rdi), %rsi
movl %eax, %edi
jmp 0x1171a
pushq %rax
leaq 0xdf14(%rip), %rdi      # 0x163b5
callq 0x33b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/./global_basic.h
// Function: isOK_fmt_infile
static inline int isOK_fmt_infile (char* fname, const char *test_fmt[], int test_fmt_arr_sz)
{
  int ret = 0 ;
  char suftmp[10];
 for(int i=0; i < CMPRESS_FMT_SZ;i++ ){
   int basename_len = strlen(fname) - strlen(compress_fmt[i]);
   if( strcmp( ( fname + basename_len ),compress_fmt[i]) == 0 ){
     char cp_fname[PATHLEN];
     strcpy(cp_fname, fname);
     *(cp_fname + basename_len) = '\0';
     fname = cp_fname;
   break;
   };
 };
  for(int i=0; i< test_fmt_arr_sz; i++){
    sprintf(suftmp,".%s",test_fmt[i]);
    if ( strcmp((char *)(fname+strlen(fname) - strlen(suftmp)), suftmp) == 0 ){
      return 1;
    }
  };
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x1515a(%rip), %rbx     # 0x1e000
movq %r14, %rdi
callq 0x3130
movq %rax, %r12
movq (%rbx,%rbp,8), %r13
movq %r13, %rdi
callq 0x3130
subl %eax, %r12d
movslq %r12d, %r15
leaq (%r14,%r15), %rdi
movq %r13, %rsi
callq 0x32b0
movl %eax, %r12d
testl %eax, %eax
jne 0x8eef
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3080
movb $0x0, 0x10(%rsp,%r15)
movq %r13, %r14
testl %r12d, %r12d
je 0x8f00
leaq 0x1(%rbp), %rax
testq %rbp, %rbp
movq %rax, %rbp
je 0x8ea6
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
setg %bl
jle 0x8fb4
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0xc45e(%rip), %rsi      # 0x1537c
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3430
movq %r14, %rdi
callq 0x3130
leaq (%rax,%r14), %r12
movq %r15, %rdi
callq 0x3130
subq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
testl %eax, %eax
je 0x8fb4
movl %ebp, %ebx
movl $0x1, %ecx
leaq 0xc41b(%rip), %r15      # 0x1537c
leaq 0x10(%rsp), %r12
movq %rcx, %rbp
cmpq %rcx, %rbx
je 0x8fae
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3430
movq %r14, %rdi
callq 0x3130
leaq (%rax,%r14), %r13
movq %r12, %rdi
callq 0x3130
subq %rax, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x32b0
leaq 0x1(%rbp), %rcx
testl %eax, %eax
jne 0x8f66
cmpq %rbx, %rbp
setb %bl
movzbl %bl, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist.c
// Function: dist_print
void dist_print( const char *distf, FILE *dist_fp )
{
 ctx_obj_ct_t *ctx_obj_ct;
 int fd;
 struct stat s;
 fd = open (distf, O_RDONLY);
 check (fd < 0, "open %s failed: %s", distf, strerror (errno));
 fstat (fd, & s);
 ctx_obj_ct = mmap(0, s.st_size , PROT_READ, MAP_PRIVATE, fd, 0);
 check ( ctx_obj_ct == MAP_FAILED, "mmap %s failed: %s", distf, strerror (errno));
  fprintf(dist_fp,"output %s\n",distf);
 close(fd);
 munmap(ctx_obj_ct, s.st_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, (%rsp)
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x3380
movl %eax, %ebp
movl %eax, %r15d
shrl $0x1f, %r15d
callq 0x3060
movq %rax, %r12
movl (%rax), %edi
callq 0x3470
leaq 0x95b1(%rip), %rsi      # 0x151af
movl %r15d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xbca1
leaq 0x8(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x34a0
movq 0x30(%r15), %r15
xorl %edi, %edi
movq %r15, %rsi
movl $0x1, %edx
movl $0x2, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3150
movq %rax, %r13
xorl %r14d, %r14d
cmpq $-0x1, %rax
sete %r14b
movl (%r12), %edi
callq 0x3470
leaq 0x9569(%rip), %rsi      # 0x151c2
movl %r14d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xbca1
leaq 0xa609(%rip), %rsi      # 0x16279
movq (%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32c0
movl %ebp, %edi
callq 0x3220
movq %r13, %rdi
movq %r15, %rsi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3360
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist_wrapper.c
// Function: cmd_dist
int cmd_dist(struct argp_state* state)
{
  struct arg_dist dist = { 0, };
  int argc = state->argc - state->next + 1;
  char** argv = &state->argv[state->next - 1];
  char* argv0 = argv[0];
  dist.global = state->input;
  argv[0] = malloc(strlen(state->name) + strlen(" dist") + 1);
  if(!argv[0])
    argp_failure(state, 1, ENOMEM, 0);
  sprintf(argv[0], "%s dist", state->name);
  argp_parse(&argp_dist, argc, argv, ARGP_IN_ORDER, &argc, &dist);
  free(argv[0]);
  argv[0] = argv0;
  state->next += argc - 1;
 return dist_dispatch(&dist_opt_val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x8(%rdi), %eax
movslq 0x18(%rdi), %rcx
subl %ecx, %eax
incl %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rdi), %rax
movq 0x28(%rdi), %rdx
leaq (%rax,%rcx,8), %r14
addq $-0x8, %r14
movq (%r14), %r12
movq %rdx, 0x10(%rsp)
movq 0x40(%rdi), %rdi
callq 0x3130
leaq 0x6(%rax), %rdi
callq 0x3340
movq %rax, (%r14)
testq %rax, %rax
jne 0xccd1
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rdi
movq 0x40(%rbx), %rdx
leaq 0x9973(%rip), %rsi      # 0x16652
xorl %eax, %eax
callq 0x3430
leaq 0xc(%rsp), %r15
movl (%r15), %esi
leaq 0x1016b(%rip), %rdi     # 0x1ce60
leaq 0x10(%rsp), %r9
movq %r14, %rdx
movl $0x8, %ecx
movq %r15, %r8
callq 0x3280
movq (%r14), %rdi
callq 0x3040
movq %r12, (%r14)
movl (%r15), %eax
movl 0x18(%rbx), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x18(%rbx)
leaq 0xfad7(%rip), %rdi      # 0x1c800
callq 0x65a8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_dist_wrapper.c
// Function: mk_dist_rslt_dir
const char *mk_dist_rslt_dir (const char *parentdirpath, const char * outdirpath )
{
  struct stat dstat;
  const char *outfullpath = malloc(PATHLEN *sizeof(char));
  sprintf((char *)outfullpath,"%s/%s",parentdirpath,outdirpath);
  if(stat(parentdirpath, &dstat) == 0 && S_ISDIR(dstat.st_mode)){
    if( stat(outfullpath, &dstat) == 0 ){
   errno = EEXIST;
      err(errno,"%s",outfullpath);
  }
    else{
      mkdir(outfullpath,0777);
    }
  }
  else {
    mkdir(parentdirpath,0777);
    mkdir(outfullpath,0777);
  }
  return outfullpath;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x3340
movq %rax, %rbx
leaq 0x8633(%rip), %rsi      # 0x15393
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3430
movq %rsp, %rsi
movq %r14, %rdi
callq 0x32e0
testl %eax, %eax
jne 0xcdbf
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xcdbf
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
jne 0xcdcc
callq 0x3060
movl $0x11, (%rax)
leaq 0x95c6(%rip), %rsi      # 0x16376
movl $0x11, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_reverse.c
// Function: cmd_reverse
int cmd_reverse(struct argp_state* state)
{
  int argc = state->argc - state->next + 1;
  char** argv = &state->argv[state->next - 1];
  char* argv0 = argv[0];
 argv[0] = malloc(strlen(state->name) + strlen(" reverse") + 1);
  if(!argv[0])
    argp_failure(state, 1, ENOMEM, 0);
 sprintf(argv[0], "%s reverse", state->name);
  argp_parse(&argp_reverse, argc, argv, ARGP_IN_ORDER, &argc, &shuffle);
  free(argv[0]);
  argv[0] = argv0;
  state->next += argc - 1;
 if(reverse_opt_val.byreads)
  return co_rvs2kmer_byreads(&reverse_opt_val );
 else
   return co_reverse2kmer(&reverse_opt_val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq 0x18(%rdi), %rcx
subl %ecx, %eax
incl %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rdi), %rax
movq 0x40(%rdi), %rdi
leaq (%rax,%rcx,8), %r14
addq $-0x8, %r14
movq (%r14), %r12
callq 0x3130
leaq 0x9(%rax), %rdi
callq 0x3340
movq %rax, (%r14)
testq %rax, %rax
jne 0xd2d1
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rdi
movq 0x40(%rbx), %rdx
leaq 0x9a6f(%rip), %rsi      # 0x16d4e
xorl %eax, %eax
callq 0x3430
leaq 0x4(%rsp), %r15
movl (%r15), %esi
leaq 0x10213(%rip), %rdi     # 0x1d508
leaq 0x3b45(%rip), %r9       # 0x10e41
movq %r14, %rdx
movl $0x8, %ecx
movq %r15, %r8
callq 0x3280
movq (%r14), %rdi
callq 0x3040
movq %r12, (%r14)
movl (%r15), %eax
movl 0x18(%rbx), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x18(%rbx)
cmpb $0x1, 0x101c9(%rip)     # 0x1d4f4
jne 0xd340
leaq 0xffbc(%rip), %rdi      # 0x1d2f0
callq 0xd358
movl $0x1, %eax
jmp 0xd34c
leaq 0xffa9(%rip), %rdi      # 0x1d2f0
callq 0xd89f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_reverse.c
// Function: core_reverse2unituple
llong core_reverse2unituple(unsigned int kid, int compid, int compbit, int pf_bits, int inner_ctx_bits, int half_outer_ctx_bits, unsigned int *rev_shuf_arr)
{
 llong drtuple = ( ((llong)kid) << compbit ) + compid ;
 unsigned int ind = rev_shuf_arr[drtuple % MIN_SUBCTX_DIM_SMP_SZ];
 llong tuple = ((drtuple >> pf_bits) << inner_ctx_bits) + (llong)ind;
 llong half_outer_ctx_mask = ( (1LLU << half_outer_ctx_bits) - 1 ) << inner_ctx_bits ;
  llong unituple = (tuple & (half_outer_ctx_mask << half_outer_ctx_bits))
   + ((tuple & half_outer_ctx_mask) >> inner_ctx_bits )
  + ( (tuple & ( (1LLU << inner_ctx_bits) - 1 )) << half_outer_ctx_bits );
 return unituple;
}

// Assembly:
movl %ecx, %eax
movl %edx, %ecx
movl %edi, %edi
shlq %cl, %rdi
movq 0x8(%rsp), %r10
movslq %esi, %rdx
addq %rdi, %rdx
movl %edx, %esi
movl %eax, %ecx
shrq %cl, %rdx
movl %r8d, %ecx
shlq %cl, %rdx
andl $0xfff, %esi            # imm = 0xFFF
movl (%r10,%rsi,4), %eax
movq $-0x1, %rsi
movl %r9d, %ecx
shlq %cl, %rsi
notq %rsi
movl %r8d, %ecx
shlq %cl, %rsi
addq %rax, %rdx
movq $-0x1, %rax
movq %rdx, %rdi
andq %rsi, %rdi
movl %r9d, %ecx
shlq %cl, %rsi
movl %r8d, %ecx
shrq %cl, %rdi
shlq %cl, %rax
notq %rax
andq %rdx, %rax
movl %r9d, %ecx
shlq %cl, %rax
andq %rdx, %rsi
addq %rsi, %rdi
addq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_set.c
// Function: cmd_set
int cmd_set(struct argp_state* state)
{
  struct arg_set set = { 0, };
  int argc = state->argc - state->next + 1;
  char** argv = &state->argv[state->next - 1];
  char* argv0 = argv[0];
  set.global = state->input;
 argv[0] = malloc(strlen(state->name) + strlen(" set") + 1);
  if(!argv[0])
    argp_failure(state, 1, ENOMEM, 0);
 sprintf(argv[0], "%s set", state->name);
  argp_parse(&argp_set, argc, argv, ARGP_IN_ORDER, &argc, &set);
 free(argv[0]);
  argv[0] = argv0;
  state->next += argc - 1;
 if(argc >1){
  if(set_opt.operation == 2)
   return sketch_union() ;
   if(set_opt.operation == 3)
   return uniq_sketch_union() ;
  if(set_opt.operation == 4)
   return combin_pans();
  if(set_opt.operation == 0 || set_opt.operation == 1 )
   return sketch_operate() ;
  else {
   if(set_opt.P) print_gnames();
   else if (set_opt.subsetf[0]!='\0') return grouping_genomes(set_opt.subsetf);
   else printf("set operation use : -u, -q, -i or -s\n");
   return -1 ;
  }
 }
 else
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x8(%rdi), %eax
movslq 0x18(%rdi), %rcx
subl %ecx, %eax
incl %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rdi), %rax
movq 0x28(%rdi), %rdx
leaq (%rax,%rcx,8), %r14
addq $-0x8, %r14
movq (%r14), %r12
movq %rdx, 0x10(%rsp)
movq 0x40(%rdi), %rdi
callq 0x3130
leaq 0x5(%rax), %rdi
callq 0x3340
movq %rax, (%r14)
testq %rax, %rax
jne 0xe1f5
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rdi
movq 0x40(%rbx), %rdx
leaq 0x8d9a(%rip), %rsi      # 0x16f9d
xorl %eax, %eax
callq 0x3430
leaq 0xc(%rsp), %r15
movl (%r15), %esi
leaq 0xf86f(%rip), %rdi      # 0x1da88
leaq 0x10(%rsp), %r9
movq %r14, %rdx
movl $0x8, %ecx
movq %r15, %r8
callq 0x3280
movq (%r14), %rdi
callq 0x3040
movq %r12, (%r14)
movl (%r15), %eax
movl 0x18(%rbx), %ecx
addl %eax, %ecx
decl %ecx
movl %ecx, 0x18(%rbx)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jl 0xe27d
movl 0xf41a(%rip), %eax      # 0x1d670
cmpl $0x4, %eax
je 0xe273
cmpl $0x3, %eax
je 0xe26c
cmpl $0x2, %eax
jne 0xe28b
callq 0xeb28
jmp 0xe278
callq 0xf4dc
jmp 0xe278
callq 0xf90b
movl $0x1, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jae 0xe296
callq 0xef03
xorl %ebx, %ebx
jmp 0xe27d
cmpl $0x0, 0xf3db(%rip)      # 0x1d678
je 0xe2a6
callq 0xfe3a
jmp 0xe27d
cmpb $0x0, 0xf5db(%rip)      # 0x1d888
je 0xe2bd
leaq 0xf5d2(%rip), %rdi      # 0x1d888
callq 0xe2cb
jmp 0xe292
leaq 0x91de(%rip), %rdi      # 0x174a2
callq 0x30a0
jmp 0xe27d
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_set.c
// Function: print_gnames
void print_gnames(){
  const char* co_dstat_fpath = NULL;
  co_dstat_fpath = test_get_fullpath(set_opt.insketchpath,co_dstat);
  if(co_dstat_fpath == NULL ) err(errno,"cannot find %s under %s ",co_dstat,set_opt.insketchpath);
  FILE *co_stat_fp;
  if( ( co_stat_fp = fopen(co_dstat_fpath,"rb")) == NULL ) err(errno,"sketch_union():%s",co_dstat_fpath);
  co_dstat_t co_dstat_readin;
  fread( &co_dstat_readin, sizeof(co_dstat_t),1,co_stat_fp );
 ctx_obj_ct_t *tmp_ctx_ct = malloc(sizeof(ctx_obj_ct_t)*co_dstat_readin.infile_num);
 fread(tmp_ctx_ct,sizeof(ctx_obj_ct_t),co_dstat_readin.infile_num,co_stat_fp);
 char (*tmpname)[PATHLEN] = malloc( PATHLEN * co_dstat_readin.infile_num );
 fread(tmpname,PATHLEN,co_dstat_readin.infile_num,co_stat_fp);
 for(int i=0; i<co_dstat_readin.infile_num; i++ ){
  printf("%s\n",tmpname[i]);
 }
 free(tmp_ctx_ct);
  free(tmpname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xd83c(%rip), %rdi      # 0x1d688
leaq 0x590d(%rip), %rsi      # 0x15760
callq 0x6bcc
testq %rax, %rax
je 0xff19
movq %rax, %rbx
leaq 0x51fc(%rip), %rsi      # 0x15067
movq %rax, %rdi
callq 0x33a0
testq %rax, %rax
je 0xff3c
movq %rax, %r15
leaq 0x8(%rsp), %rbx
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x30c0
movslq 0x14(%rbx), %rbx
leaq (,%rbx,4), %rdi
callq 0x3340
movq %rax, %r14
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x30c0
movq %rbx, %rdi
shlq $0x8, %rdi
callq 0x3340
movq %rax, %r12
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x30c0
testq %rbx, %rbx
jle 0xfefe
movq %r12, %r15
movq %r15, %rdi
callq 0x30a0
addq $0x100, %r15            # imm = 0x100
decq %rbx
jne 0xfeea
movq %r14, %rdi
callq 0x3040
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3040
callq 0x3060
movl (%rax), %edi
leaq 0x54a6(%rip), %rsi      # 0x153cd
leaq 0x5832(%rip), %rdx      # 0x15760
leaq 0xd753(%rip), %rcx      # 0x1d688
xorl %eax, %eax
callq 0x3330
callq 0x3060
movl (%rax), %edi
leaq 0x7100(%rip), %rsi      # 0x1704a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_shuffle.c
// Function: cmd_shuffle
int cmd_shuffle(struct argp_state* state)
{
  struct arg_shuffle shuffle = { 0, };
  int argc = state->argc - state->next + 1;
  char** argv = &state->argv[state->next - 1];
  char* argv0 = argv[0];
  shuffle.global = state->input;
 argv[0] = malloc(strlen(state->name) + strlen(" shuffle") + 1);
  if(!argv[0])
    argp_failure(state, 1, ENOMEM, 0);
 sprintf(argv[0], "%s shuffle", state->name);
  argp_parse(&argp_shuffle, argc, argv, ARGP_IN_ORDER, &argc, &shuffle);
  free(argv[0]);
  argv[0] = argv0;
  state->next += argc - 1;
 if(argc >1)
   return write_dim_shuffle_file(&dim_shuffle_stat, shuf_out_file_prefix) ;
 else
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x8(%rdi), %eax
movslq 0x18(%rdi), %rcx
subl %ecx, %eax
incl %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rdi), %rax
movq 0x28(%rdi), %rdx
leaq (%rax,%rcx,8), %r14
addq $-0x8, %r14
movq (%r14), %r12
movq %rdx, 0x10(%rsp)
movq 0x40(%rdi), %rdi
callq 0x3130
leaq 0x9(%rax), %rdi
callq 0x3340
movq %rax, (%r14)
testq %rax, %rax
jne 0x10bf9
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rdi
movq 0x40(%rbx), %rdx
leaq 0x69c5(%rip), %rsi      # 0x175cc
xorl %eax, %eax
callq 0x3430
leaq 0xc(%rsp), %r15
movl (%r15), %esi
leaq 0xd1c3(%rip), %rdi      # 0x1dde0
leaq 0x10(%rsp), %r9
movq %r14, %rdx
movl $0x8, %ecx
movq %r15, %r8
callq 0x3280
movq (%r14), %rdi
callq 0x3040
movq %r12, (%r14)
movl (%r15), %ecx
movl 0x18(%rbx), %eax
addl %ecx, %eax
decl %eax
movl %eax, 0x18(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jl 0x10c67
leaq 0xd075(%rip), %rdi      # 0x1dcd0
leaq 0xd07e(%rip), %rsi      # 0x1dce0
callq 0x10c73
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_shuffle.c
// Function: shuffle
int * shuffle( int arr[], int len_arr)
{
 if(len_arr > RAND_MAX)
  err(errno,"shuffling array length %d longer than RAND_MAX: %d",len_arr,RAND_MAX);
 srand ( time(NULL) );
  int j, temp;
 for (int i = len_arr - 1; i >0; i-- ){
  j = rand() % (i + 1) ;
  temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
 }
 return arr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3310
movl %eax, %edi
callq 0x3270
cmpl $0x2, %ebp
jl 0x10e8c
movl %ebp, %r14d
leaq -0x1(%r14), %r15
callq 0x34c0
cltd
idivl %r14d
movl -0x4(%rbx,%r14,4), %eax
movslq %edx, %rcx
movl (%rbx,%rcx,4), %edx
movl %edx, -0x4(%rbx,%r14,4)
movl %eax, (%rbx,%rcx,4)
cmpq $0x2, %r14
movq %r15, %r14
jg 0x10e63
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_shuffle.c
// Function: shuffleN
int * shuffleN (int n, int base)
{
 int *arr;
 arr = malloc(n*sizeof(int)) ;
 if(arr==NULL) err(errno,"shuffleN");
 for(int i = 0; i < n ; i++)
   arr[i] = i + base;
 return shuffle(arr,n);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movslq %edi, %rdi
shlq $0x2, %rdi
callq 0x3340
testq %rax, %rax
je 0x10eda
testl %ebx, %ebx
jle 0x10eca
movl %ebx, %ecx
movl %ebp, %edx
xorl %esi, %esi
leal (%rdx,%rsi), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x10ebc
movq %rax, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10e41
callq 0x3060
movl (%rax), %edi
leaq 0x66ef(%rip), %rsi      # 0x175d7
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_shuffle.c
// Function: read_dim_shuffle_file
dim_shuffle_t* read_dim_shuffle_file(char *dim_shuffle_file)
{
 int basename_len = strlen(dim_shuffle_file) - strlen(".shuf") ;
 if( strcmp( (dim_shuffle_file + basename_len),".shuf") !=0 )
  err(errno,"read_dim_shuffle_file(): input file %s is not .shuf file",dim_shuffle_file);
 FILE *shuf_in;
 if( (shuf_in = fopen(dim_shuffle_file,"rb")) == NULL)
  err(errno,"read_dim_shuffle_file(): open file %s failed",dim_shuffle_file);
 dim_shuffle_t *dim_shuffle = malloc( sizeof(dim_shuffle_t) );
 fread(&(dim_shuffle->dim_shuffle_stat),sizeof(dim_shuffle_stat_t),1,shuf_in);
 int shuf_arr_len = 1<< 4*dim_shuffle->dim_shuffle_stat.subk ;
 dim_shuffle->shuffled_dim = malloc( sizeof(int)*shuf_arr_len );
 fread(dim_shuffle->shuffled_dim,sizeof(int)*shuf_arr_len,1,shuf_in);
 fclose(shuf_in);
 return dim_shuffle;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3130
addl $-0x5, %eax
movslq %eax, %rdi
addq %rbx, %rdi
leaq 0x4c96(%rip), %rsi      # 0x15ba8
callq 0x32b0
testl %eax, %eax
jne 0x10f93
leaq 0x4145(%rip), %rsi      # 0x15067
movq %rbx, %rdi
callq 0x33a0
testq %rax, %rax
je 0x10fa3
movq %rax, %r14
movl $0x18, %edi
callq 0x3340
movq %rax, %rbx
movl $0x10, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0x30c0
movb 0x8(%rbx), %cl
shlb $0x2, %cl
movl $0x4, %r15d
shll %cl, %r15d
movq %r15, %rdi
callq 0x3340
movq %rax, 0x10(%rbx)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x30c0
movq %r14, %rdi
callq 0x3100
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x681f(%rip), %rsi      # 0x177c0
jmp 0x10fb1
callq 0x3060
movl (%rax), %edi
leaq 0x6848(%rip), %rsi      # 0x177f9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/command_shuffle.c
// Function: parse_shuffle
static error_t parse_shuffle(int key, char* arg, struct argp_state* state) {
  struct arg_shuffle* shuffle = state->input;
  assert( shuffle );
  assert( shuffle->global );
  switch(key)
  {
    case 'k':
  {
   dim_shuffle_stat.k = atoi(arg);
   break;
  }
  case 's':
  {
   dim_shuffle_stat.subk = atoi(arg);
   break;
  }
  case 'l':
  {
   dim_shuffle_stat.drlevel = atoi(arg);
   break;
  }
  case 'o':
  {
   strcpy(shuf_out_file_prefix, arg);
   break;
  }
    case ARGP_KEY_NO_ARGS:
    {
   if(state->argc<2)
   {
       printf("\v");
    argp_state_help(state,stdout,ARGP_HELP_SHORT_USAGE);
    printf("\v");
       argp_state_help(state,stdout,ARGP_HELP_LONG);
       printf("\v");
       return EINVAL;
   }
    }
    break;
  case 999:
  {
   printf("use default values for all options\n");
  }
  break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x110bd
cmpq $0x0, (%rax)
je 0x110dc
movl $0x7, %eax
leal -0x6b(%rdi), %ecx
cmpl $0x8, %ecx
ja 0x11006
leaq 0x65be(%rip), %rdx      # 0x175a8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rsi, %rdi
callq 0x3410
movl %eax, 0xccd3(%rip)      # 0x1dcd4
jmp 0x110b3
cmpl $0x3e7, %edi            # imm = 0x3E7
je 0x110a7
cmpl $0x1000002, %edi        # imm = 0x1000002
jne 0x110b5
movq %rdx, %rbx
xorl %eax, %eax
cmpl $0x1, 0x8(%rdx)
jg 0x110b5
movl $0xb, %edi
callq 0x3050
movq 0xaf9a(%rip), %r14      # 0x1bfd8
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movl $0x16, %eax
jmp 0x110b5
movq %rsi, %rdi
callq 0x3410
movl %eax, 0xcc51(%rip)      # 0x1dcd8
jmp 0x110b3
movq %rsi, %rdi
callq 0x3410
movl %eax, 0xcc45(%rip)      # 0x1dcdc
jmp 0x110b3
leaq 0xcc40(%rip), %rdi      # 0x1dce0
callq 0x3080
jmp 0x110b3
leaq 0x69d1(%rip), %rdi      # 0x17a7f
callq 0x30a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x650b(%rip), %rdi      # 0x175cf
leaq 0x695a(%rip), %rsi      # 0x17a25
leaq 0x6965(%rip), %rcx      # 0x17a37
movl $0x39, %edx
callq 0x3200
leaq 0x698c(%rip), %rdi      # 0x17a6f
leaq 0x693b(%rip), %rsi      # 0x17a25
leaq 0x6946(%rip), %rcx      # 0x17a37
movl $0x3a, %edx
callq 0x3200
nop
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: log_printf
void log_printf(struct arg_global* g, int level, const char* fmt, ...)
{
  va_list ap;
  FILE* f = stdout;
  if(g->verbosity < level)
    return;
  if(level == 0)
    f = stderr;
  va_start(ap, fmt);
  vfprintf(f, fmt, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x11194
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl %esi, (%rdi)
jl 0x111df
testl %esi, %esi
jne 0x111a5
movq 0xae55(%rip), %rax      # 0x1bff8
jmp 0x111ac
movq 0xae2c(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
leaq 0x20(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rax)
movq %rdx, %rsi
movq %rax, %rdx
callq 0x33f0
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: fpathopen
FILE * fpathopen (const char *dpath, const char *fname, const char *mode )
{
  char *fullname = malloc(PATHLEN*sizeof(char));
  sprintf(fullname,"%s/%s",dpath,fname);
 struct stat s;
 if(! ( ( stat(dpath, &s) == 0 ) && S_ISDIR(s.st_mode) ) )
  mkdir(dpath, 0777);
  FILE *fp;
  if( (fp = fopen(fullname, mode) ) == NULL )
    err(errno,"fpathopen()::%s",fullname);
  return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl $0x100, %edi            # imm = 0x100
callq 0x3340
movq %rax, %rbx
leaq 0x4181(%rip), %rsi      # 0x15393
movq %rax, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3430
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x32e0
testl %eax, %eax
jne 0x11243
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x11250
movq %r15, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33a0
testq %rax, %rax
je 0x1126f
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x6aee(%rip), %rsi      # 0x17d6b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: infile_fmt_count
infile_fmt_count_t *infile_fmt_count ( infile_tab_t * infile_tab )
{
 infile_fmt_count_t tmp_fmt_count = {0,0,0,0};
 infile_fmt_count_t* fmt_count = (infile_fmt_count_t*)malloc(sizeof(infile_fmt_count_t));
 *fmt_count = tmp_fmt_count;
 for(int i = 0; i < infile_tab->infile_num; i++ )
 {
  if( isOK_fmt_infile(infile_tab->organized_infile_tab[i].fpath,fasta_fmt,FAS_FMT_SZ) )
   fmt_count->fasta++;
  else if (isOK_fmt_infile (infile_tab->organized_infile_tab[i].fpath, fastq_fmt,FQ_FMT_SZ ) )
   fmt_count->fastq++;
  else if(isOK_fmt_infile (infile_tab->organized_infile_tab[i].fpath, co_fmt,CO_FMT_SZ) )
   fmt_count->co++;
  else if(isOK_fmt_infile (infile_tab->organized_infile_tab[i].fpath, mco_fmt,MCO_FMT_SZ))
   fmt_count->mco++;
  else if(infile_tab->organized_infile_tab[i].fsize != 0)
   err(errno,"infile_fmt_count(): %s is not accept format(.fasta,.fastq,.co)",infile_tab->organized_infile_tab[i].fpath);
 }
 return fmt_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x3340
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
cmpl $0x0, (%rbx)
jle 0x11c2e
leaq 0x4(%r14), %r13
leaq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rax
addq $0xc, %rax
movq %rax, 0x8(%rsp)
movl $0x8, %ebp
xorl %r12d, %r12d
leaq 0xc451(%rip), %r15      # 0x1dfc0
movq 0x8(%rbx), %rax
movq (%rax,%rbp), %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x115d0
movq %r14, %rcx
testl %eax, %eax
jne 0x11bef
movq 0x8(%rbx), %rax
movq (%rax,%rbp), %rdi
leaq 0xc446(%rip), %rsi      # 0x1dfe0
movl $0x2, %edx
callq 0x115d0
movq %r13, %rcx
testl %eax, %eax
jne 0x11bef
movq 0x8(%rbx), %rax
movq (%rax,%rbp), %rdi
leaq 0xc436(%rip), %rsi      # 0x1dff0
movl $0x1, %edx
callq 0x115d0
movq 0x10(%rsp), %rcx
testl %eax, %eax
jne 0x11bef
movq 0x8(%rbx), %rax
movq (%rax,%rbp), %rdi
leaq 0xc41c(%rip), %rsi      # 0x1dff8
movl $0x1, %edx
callq 0x115d0
movq 0x8(%rsp), %rcx
testl %eax, %eax
je 0x11c06
incl (%rcx)
incq %r12
movslq (%rbx), %rax
addq $0x10, %rbp
cmpq %rax, %r12
jl 0x11b6f
jmp 0x11c2e
movq 0x8(%rbx), %rax
cmpq $0x0, -0x8(%rax,%rbp)
je 0x11bf1
movq %rax, %rbx
callq 0x3060
movl (%rax), %edi
movq (%rbx,%rbp), %rdx
leaq 0x62a7(%rip), %rsi      # 0x17ece
xorl %eax, %eax
callq 0x3330
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: get_pathname
const char * get_pathname(const char *fullpath, const char *suf)
{
 char *pathcp = malloc( strlen(fullpath) + 1) ;
 strcpy(pathcp,fullpath);
 *(pathcp + strlen(pathcp) - strlen(suf)) = '\0';
 return pathcp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3130
leaq 0x1(%rax), %rdi
callq 0x3340
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3080
movq %r15, %rdi
callq 0x3130
movq %rax, %r14
addq %r15, %r14
movq %rbx, %rdi
callq 0x3130
subq %rax, %r14
movb $0x0, (%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: find_lgst_primer_2pow
llong find_lgst_primer_2pow(int w)
{
 if( w < 2 || w > 62 ){
  perror("find_1st_primer_after_2pow: argument should between 8 and 62");
  exit(EXIT_FAILURE);
 }
  llong n = ( 1llu << w ) ;
 llong hshsz = (llong) ( (double)n * CTX_SPC_USE_L / LD_FCTR) ;
 printf("w=%d\tspace_sz=%llu\thashsize=%llu\tkmerlimt=%llu\n",w,n,hshsz,(llong)(hshsz*LD_FCTR) ) ;
 llong i = 3, c ; llong prime = 0;
 for(i = n - 1 ; i > (n >> 1) ; i--)
 {
  for ( c = 2 ; c <= (int)pow(i+1,0.5) ; c++ )
  {
   if( i%c == 0 )
    break;
  }
  if( c*c > i ){
   prime = i;
   break;
  }
 }
 printf("nearest prime=%llu\n",prime);
 return prime;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %esi
leal -0x3f(%rsi), %eax
cmpl $-0x3e, %eax
jbe 0x120c7
movl $0x1, %ebx
movl %esi, %ecx
shlq %cl, %rbx
movq %rsi, %rax
shlq $0x34, %rax
movabsq $0x4020000000000000, %rcx # imm = 0x4020000000000000
addq %rax, %rcx
movq %rcx, %xmm0
movsd 0x3290(%rip), %xmm1     # 0x151f0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x3798(%rip), %xmm2     # 0x15710
subsd %xmm2, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movq %rcx, %xmm0
punpckldq 0x309c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x30a4(%rip), %xmm0     # 0x15040
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
cvttsd2si %xmm3, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd %xmm2, %xmm3
cvttsd2si %xmm3, %r8
andq %rdx, %r8
orq %rax, %r8
leaq 0x5f99(%rip), %rdi      # 0x17f67
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3170
movq %rbx, %r14
shrq %r14
xorpd %xmm1, %xmm1
movapd 0x5ac6(%rip), %xmm2     # 0x17ab0
movq %rbx, %rax
decq %rbx
cmpq %r14, %rbx
jbe 0x120a7
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
ucomisd %xmm1, %xmm3
movsd %xmm3, (%rsp)
jb 0x12015
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x1202f
movapd %xmm3, %xmm0
callq 0x3460
movsd (%rsp), %xmm3
movapd 0x5a85(%rip), %xmm2     # 0x17ab0
xorpd %xmm1, %xmm1
andpd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
movl $0x2, %r15d
cmpl $0x2, %eax
jb 0x12098
xorps %xmm4, %xmm4
sqrtsd %xmm3, %xmm4
movsd %xmm4, 0x8(%rsp)
movq %rbx, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
je 0x12098
ucomisd %xmm1, %xmm3
movapd %xmm4, %xmm0
jae 0x12086
movapd %xmm3, %xmm0
callq 0x3460
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm3
movapd 0x5a2e(%rip), %xmm2     # 0x17ab0
xorpd %xmm1, %xmm1
incq %r15
andpd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
cltq
cmpq %rax, %r15
jbe 0x1204f
imulq %r15, %r15
cmpq %rbx, %r15
jbe 0x11fea
jmp 0x120a9
xorl %ebx, %ebx
leaq 0x5ee7(%rip), %rdi      # 0x17f97
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3170
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x34f0
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/global_basic.c
// Function: nextPrime
int nextPrime(int n){
    int j;
    int tag = 0;
    while (1){
        for(j=2;j<=(int)sqrt(n);j++){
            if(n%j == 0){
                tag = 1;
                break;
            }
        }
        if(tag == 1){
            if(n == 0x7FFFFFFF){
                printf("[ERROR] n exceed 0x7FFFFFFF, Can't find a valid prime\n");
                exit(1);
            }
            n++;
            tag = 0;
        }else{
            return n;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
cvtsi2sd %edi, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x120eb
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x12100
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x3460
movsd 0x8(%rsp), %xmm1
cvttsd2si %xmm0, %eax
cmpl $0x2, %eax
jge 0x12112
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
xorpd %xmm2, %xmm2
movl $0x1, %ebp
xorps %xmm3, %xmm3
sqrtsd %xmm1, %xmm3
movsd %xmm1, 0x8(%rsp)
movsd %xmm3, 0x10(%rsp)
incl %ebp
movl %ebx, %eax
cltd
idivl %ebp
testl %edx, %edx
je 0x12166
ucomisd %xmm2, %xmm1
movapd %xmm3, %xmm0
jae 0x1215c
movapd %xmm1, %xmm0
callq 0x3460
movsd 0x10(%rsp), %xmm3
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
cvttsd2si %xmm0, %eax
cmpl %eax, %ebp
jl 0x1212e
jmp 0x12109
cmpl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
je 0x121b1
incl %ebx
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
ucomisd %xmm2, %xmm1
jb 0x12186
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x1219f
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x3460
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
cvttsd2si %xmm0, %eax
cmpl $0x1, %eax
jg 0x12116
jmp 0x12109
leaq 0x5df3(%rip), %rdi      # 0x17fab
callq 0x30a0
movl $0x1, %edi
callq 0x3440
nop
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/iseq2comem.c
// Function: seq2co_global_var_initial
void seq2co_global_var_initial(void)
{
 rand_id = dim_shuffle->dim_shuffle_stat.id ;
 half_ctx_len = dim_shuffle->dim_shuffle_stat.k ;
 half_subctx_len = dim_shuffle->dim_shuffle_stat.subk ;
 half_outctx_len = half_ctx_len - half_subctx_len;
  drlevel = dim_shuffle->dim_shuffle_stat.drlevel;
 hashlimit = hashsize * LD_FCTR ;
 printf("rand_id=%d\thalf_ctx_len=%d\thashsize=%d\thashlimit=%d\n",rand_id,half_ctx_len,hashsize,hashlimit);
 component_num = half_ctx_len - drlevel > COMPONENT_SZ ?
         1LU << 4*(half_ctx_len - drlevel - COMPONENT_SZ ) : 1 ;
 comp_bittl = 64-4*half_ctx_len;
 crvsaddmove = 4*half_ctx_len-2;
 tupmask = _64MASK >> comp_bittl;
 TL = 2*half_ctx_len ;
 domask = ( (1LLU << ( half_subctx_len*4 ) ) - 1 ) << (2*half_outctx_len);
 undomask = ( (1LLU << (half_outctx_len*2)) - 1 )
         << (2*(half_ctx_len + half_subctx_len));
 dim_shuf_arr = dim_shuffle->shuffled_dim;
 dim_shuf_arr_len = 1LLU << (4*half_subctx_len) ;
 dim_start = 0;
 llong subspace_sz = 1LLU << 4*(half_subctx_len - drlevel) ;
 dim_end = dim_start + (subspace_sz > MIN_SUBCTX_DIM_SMP_SZ ?subspace_sz :MIN_SUBCTX_DIM_SMP_SZ);
}

// Assembly:
pushq %rax
movq 0x4c1d4(%rip), %rax     # 0x5e610
movl (%rax), %esi
movl 0x4(%rax), %edx
movl %edx, 0x4c1d1(%rip)     # 0x5e618
movl 0x8(%rax), %ecx
movl %ecx, 0x4c1cc(%rip)     # 0x5e61c
movl %edx, %edi
subl %ecx, %edi
movl %edi, 0x4c1c6(%rip)     # 0x5e620
movl 0xc(%rax), %eax
movl 0x4c1c5(%rip), %ecx     # 0x5e628
cvtsi2sd %rcx, %xmm0
mulsd 0x2d80(%rip), %xmm0     # 0x151f0
movl %eax, 0x4c1ae(%rip)     # 0x5e624
cvttsd2si %xmm0, %r8
movl %r8d, 0x4c1aa(%rip)     # 0x5e62c
leaq 0x5c66(%rip), %rdi      # 0x180ef
xorl %eax, %eax
callq 0x3170
movl 0x4c182(%rip), %eax     # 0x5e618
movl 0x4c188(%rip), %esi     # 0x5e624
movl %eax, %edx
subl %esi, %edx
leal (,%rdx,4), %ecx
addb $-0x1c, %cl
movl $0x1, %edi
shlq %cl, %rdi
cmpl $0x8, %edx
movl $0x1, %ecx
cmovgel %edi, %ecx
movl $0x1, %edi
movl %ecx, 0x4c168(%rip)     # 0x5e630
leal (,%rax,4), %ecx
leal -0x2(,%rax,4), %edx
movl %edx, 0x4c158(%rip)     # 0x5e634
negb %cl
movq $-0x1, %r8
movq $-0x1, %rdx
shrq %cl, %rdx
movq %rdx, 0x4c142(%rip)     # 0x5e638
movl 0x4c120(%rip), %edx     # 0x5e61c
leal (,%rdx,4), %ecx
movq $-0x1, %r9
shlq %cl, %r9
leal (%rax,%rax), %r10d
notq %r9
movb 0x4c106(%rip), %cl      # 0x5e620
addb %cl, %cl
shlq %cl, %r9
shlq %cl, %r8
movl %r10d, 0x4c117(%rip)    # 0x5e640
notq %r8
addl %edx, %eax
addl %eax, %eax
movl %eax, %ecx
shlq %cl, %r8
movq %r9, 0x4c10c(%rip)      # 0x5e648
movq %r8, 0x4c10d(%rip)      # 0x5e650
movq 0x4c0c6(%rip), %rax     # 0x5e610
movq 0x10(%rax), %rax
movq %rax, 0x4c103(%rip)     # 0x5e658
subl %esi, %edx
shll $0x2, %edx
movl %edx, %ecx
shlq %cl, %rdi
cmpq $0x1001, %rdi           # imm = 0x1001
movl $0x1000, %eax           # imm = 0x1000
cmovaeq %rdi, %rax
movl %eax, 0x4c0eb(%rip)     # 0x5e660
popq %rax
retq