LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/command_composite.c
// Function: read_abv
int read_abv (composite_opt_t *composite_opt){
 for(int i =0; i<composite_opt->num_remaining_args;i++){
    const char *ext = strrchr(composite_opt->remaining_args[i],'.');
    if(strcmp(ext + 1, binVec_suffix) != 0){
      printf("%dth argument %s is not a .abv file, skipped\n",i,composite_opt->remaining_args[i]);
      continue;
    }
  struct stat st;
    stat(composite_opt->remaining_args[i], &st);
    binVec_t tmp_abv ;
  FILE *abvfh;;
    if(( abvfh = fopen(composite_opt->remaining_args[i],"rb") ) == NULL) err(errno, "read_abv():%s",composite_opt->remaining_args[i]);
  for(int l=0; l< st.st_size; l+=sizeof(binVec_t)) {
     fread(&tmp_abv,sizeof(binVec_t),1,abvfh);
   printf("%d\t%f\n",tmp_abv.ref_idx,tmp_abv.pct);
  }
  fclose(abvfh);
 }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x314(%rcx), %eax
jge 0x75b0
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2e, %esi
callq 0x31b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
leaq 0x14d77(%rip), %rsi     # 0x1c200
callq 0x3280
cmpl $0x0, %eax
je 0x74bc
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x14e1c(%rip), %rdi     # 0x1c2cc
movb $0x0, %al
callq 0x3150
jmp 0x75a2
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x32b0
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x14b62(%rip), %rsi     # 0x1c057
callq 0x3370
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
jne 0x752f
callq 0x3050
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x14dd2(%rip), %rsi     # 0x1c2fa
movb $0x0, %al
callq 0x3300
movl $0x0, -0xbc(%rbp)
movslq -0xbc(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x7596
movq -0xb8(%rbp), %rcx
leaq -0xb0(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x30a0
movl -0xb0(%rbp), %esi
movss -0xac(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x14d8c(%rip), %rdi     # 0x1c308
movb $0x1, %al
callq 0x3150
movslq -0xbc(%rbp), %rax
addq $0x8, %rax
movl %eax, -0xbc(%rbp)
jmp 0x7539
movq -0xb8(%rbp), %rdi
callq 0x30e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7446
movl $0x1, %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/command_composite.c
// Function: comparator_measure
int comparator_measure (const void *a, const void *b){
 float rtv = tmp_measure[*(int*)a] - tmp_measure[*(int*)b] ;
  if(rtv > 0) return 1;
 else if(rtv < 0) return -1;
 else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x1cee5(%rip), %rax     # 0x244b8
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x1ced2(%rip), %rax     # 0x244b8
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x760d
movl $0x1, -0x4(%rbp)
jmp 0x7626
xorps %xmm0, %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x761f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7626
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jge 0x8291
callq 0x3050
movl (%rax), %edi
movq -0x10(%rbp), %rdx
leaq 0x14a04(%rip), %rsi     # 0x1cc8e
movb $0x0, %al
callq 0x3300
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x8320
movl $0x101, %edi            # imm = 0x101
callq 0x3310
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x14061(%rip), %rsi     # 0x1c32b
movb $0x0, %al
callq 0x3400
movq -0xb0(%rbp), %rdi
leaq 0x13d78(%rip), %rsi     # 0x1c057
callq 0x3370
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0x830a
movq -0xb8(%rbp), %rdi
callq 0x30e0
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8328
movq -0xb0(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0x8328
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x122, %rdi            # imm = 0x122
leaq -0xa0(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jge 0x838b
callq 0x3050
movl (%rax), %edi
movq -0x10(%rbp), %rdx
addq $0x122, %rdx            # imm = 0x122
leaq 0x15026(%rip), %rsi     # 0x1d3aa
movb $0x0, %al
callq 0x3300
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x83be
movq -0x10(%rbp), %rdi
addq $0x122, %rdi            # imm = 0x122
leaq 0x1bbc1(%rip), %rsi     # 0x23f70
movl $0x7, %edx
callq 0xad80
cmpl $0x0, %eax
je 0x83e8
movq -0x10(%rbp), %rax
addq $0x122, %rax            # imm = 0x122
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0x16ee0
movq %rax, -0x8(%rbp)
jmp 0x841d
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x8415
movq -0x10(%rbp), %rdi
addq $0x122, %rdi            # imm = 0x122
movl $0x1, %esi
callq 0x167c0
movq %rax, -0x8(%rbp)
jmp 0x841d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
leaq -0x220(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
callq 0x3070
leaq -0x220(%rbp), %rdi
leaq 0x13ed8(%rip), %rsi     # 0x1c339
callq 0x3280
cmpl $0x0, %eax
jne 0x8557
xorl %eax, %eax
movl %eax, %edi
callq 0x32e0
movl %eax, %edi
callq 0x3240
callq 0x3490
movl %eax, -0x230(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x22c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c4(%rbp)
callq 0x162a0
movl %eax, %ecx
movl -0x2c4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x228(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x224(%rbp)
movq -0x8(%rbp), %rdi
addq $0x322, %rdi            # imm = 0x322
leaq -0x2c0(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jne 0x84f3
movl -0x2a8(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x8508
movq -0x8(%rbp), %rdi
addq $0x322, %rdi            # imm = 0x322
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3080
leaq -0x120(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x322, %rdx            # imm = 0x322
leaq 0x1460a(%rip), %rsi     # 0x1cb2b
movb $0x0, %al
callq 0x3400
leaq -0x120(%rbp), %rsi
leaq -0x230(%rbp), %rdi
callq 0x15f20
leaq -0x220(%rbp), %rdi
leaq -0x120(%rbp), %rdx
leaq 0x145e6(%rip), %rsi     # 0x1cb36
movb $0x0, %al
callq 0x3400
leaq -0x220(%rbp), %rdi
callq 0x16300
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0xc(%rcx), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0xc(%rcx), %eax
shll $0x2, %eax
subl $0x8, %eax
subl $0x7, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x85c3
cmpl $0x18, -0x14(%rbp)
jle 0x863e
cmpl $0x0, -0x14(%rbp)
jge 0x85de
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x85f8
movl -0x14(%rbp), %eax
subl $0x18, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
addl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x3050
movl (%rax), %edi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x10(%rbp), %r9
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
leaq 0x14512(%rip), %rsi     # 0x1cb3e
movsd 0x14074(%rip), %xmm0    # 0x1c6a8
movl %eax, (%rsp)
movb $0x1, %al
callq 0x3300
movslq -0x14(%rbp), %rcx
leaq 0x16557(%rip), %rax     # 0x1eba0
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x44b(%rax), %eax
cmpl $0x0, %eax
jne 0x9ff5
movl $0x1, -0x14(%rbp)
jmp 0x9ffc
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x222, %rdi            # imm = 0x222
leaq 0x1232b(%rip), %rsi     # 0x1c339
callq 0x3280
cmpl $0x0, %eax
je 0xa031
movq -0x10(%rbp), %rdi
addq $0x222, %rdi            # imm = 0x222
movl -0x14(%rbp), %esi
callq 0x167c0
movq %rax, -0x8(%rbp)
jmp 0xa075
movq -0x10(%rbp), %rax
cmpl $0x0, 0x650(%rax)
jle 0xa061
movq -0x10(%rbp), %rax
movl 0x650(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x658(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x16ee0
movq %rax, -0x8(%rbp)
jmp 0xa075
leaq 0x1331d(%rip), %rdi     # 0x1d385
callq 0x3380
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x2, -0x30(%rbp)
jge 0xae3f
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, -0x150(%rbp)
movslq -0x30(%rbp), %rcx
leaq 0x19227(%rip), %rax     # 0x23ff0
movq (%rax,%rcx,8), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x150(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rax
addq %rax, %rdi
movslq -0x30(%rbp), %rcx
leaq 0x191f8(%rip), %rax     # 0x23ff0
movq (%rax,%rcx,8), %rsi
callq 0x3280
cmpl $0x0, %eax
jne 0xae2f
leaq -0x140(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3070
movslq -0x34(%rbp), %rax
movb $0x0, -0x140(%rbp,%rax)
leaq -0x140(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xae3f
jmp 0xae31
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xada4
movl $0x0, -0x144(%rbp)
movl -0x144(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xaee9
leaq -0x2a(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x144(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x114a2(%rip), %rsi     # 0x1c314
movb $0x0, %al
callq 0x3400
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x160(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x158(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x3110
movq -0x158(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
leaq -0x2a(%rbp), %rsi
callq 0x3280
cmpl $0x0, %eax
jne 0xaed3
movl $0x1, -0x4(%rbp)
jmp 0xaeef
jmp 0xaed5
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0xae49
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/command_dist.c
// Function: mco_co_mmpdist_core
static inline ctx_obj_ct_t * mco_co_mmpdist_core(gidobj_t** unit_arrmco, char *co_fcode_in, ctx_obj_ct_t * ctx_obj_ct_in )
{
  mmp_uint_t mmpcofile;
  mmpcofile = mmp_uint_arr(co_fcode_in);
  unsigned int ind,mcogid;
  int ctx_num = mmpcofile.fsize/sizeof(unsigned int);
 for(int n = 0; n < ctx_num; n++){
    ind = mmpcofile.mmpco[n];
    if(unit_arrmco[ind] != NULL){
      for(unsigned int k = 1; k< unit_arrmco[ind][0] + 1; k++ ){
        mcogid = unit_arrmco[ind][k] ;
        ctx_obj_ct_in[mcogid]++ ;
     }
    }
  }
  munmap(mmpcofile.mmpco, mmpcofile.fsize);
 return ctx_obj_ct_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10130
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0xb6d7
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xb6ca
movl $0x1, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0x3c(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0xb6c8
movq -0x8(%rbp), %rax
movl -0x3c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x4c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl -0x40(%rbp), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb682
jmp 0xb6ca
jmp 0xb6cc
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xb657
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3330
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/./global_basic.h
// Function: mmp_any
static inline mmp_any_t mmp_any (char *fname)
{
  mmp_any_t filemmp;
  int fd;
  struct stat s;
  fd = open (fname, O_RDONLY);
  check (fd < 0, "open %s failed: %s", fname, strerror (errno));
  fstat (fd, & s);
  filemmp.fsize = s.st_size;
  filemmp.mmp = mmap(NULL, s.st_size , PROT_READ, MAP_PRIVATE, fd, 0);
  check ( filemmp.mmp == MAP_FAILED, "mmap %s failed: %s", fname, strerror (errno));
  close(fd);
  return filemmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0xc8(%rbp)
movb %sil, %al
movb %al, -0xb1(%rbp)
callq 0x3350
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0xd4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xd4(%rbp), %edi
movq -0xd0(%rbp), %rdx
movq %rax, %rcx
movb -0xb1(%rbp), %al
leaq 0xe853(%rip), %rsi      # 0x1c19f
callq 0xe860
movl -0x1c(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x3470
movl -0xc8(%rbp), %eax
movq -0x80(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x80(%rbp), %rsi
movl -0x1c(%rbp), %r8d
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x3130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq $-0x1, %rax
sete %al
movzbl %al, %eax
movl %eax, -0xc4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xc4(%rbp), %edi
movq -0xc0(%rbp), %rdx
movq %rax, %rcx
movb -0xb1(%rbp), %al
leaq 0xe7db(%rip), %rsi      # 0x1c1b2
callq 0xe860
movl -0x1c(%rbp), %edi
callq 0x3200
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3350
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xcc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xcc(%rbp), %edi
movq -0xc8(%rbp), %rdx
movq %rax, %rcx
leaq 0xd9fc(%rip), %rsi      # 0x1c19f
movb $0x0, %al
callq 0xe860
movl -0x1c(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x3470
movq -0x80(%rbp), %rsi
movl -0x1c(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x3130
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xbc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xbc(%rbp), %edi
movq -0xb8(%rbp), %rdx
movq %rax, %rcx
leaq 0xd98f(%rip), %rsi      # 0x1c1b2
movb $0x0, %al
callq 0xe860
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xea10(%rip), %rsi      # 0x1d249
movb $0x0, %al
callq 0x3290
movl -0x1c(%rbp), %edi
callq 0x3200
movq -0x18(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x3330
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31f0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3110
movq %rax, %rdi
addq $0x5, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10301
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x3450
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xd255(%rip), %rsi      # 0x1d56c
movb $0x0, %al
callq 0x3400
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq 0x12b24(%rip), %rdi     # 0x22e50
movl $0x8, %ecx
leaq -0x1c(%rbp), %r8
leaq -0x18(%rbp), %r9
callq 0x3250
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
leaq 0x12484(%rip), %rdi     # 0x227f0
callq 0x78e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x3310
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xbf71(%rip), %rsi      # 0x1c32b
movb $0x0, %al
callq 0x3400
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jne 0x1043a
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x1043a
movq -0xa8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jne 0x10427
callq 0x3050
movl $0x11, (%rax)
callq 0x3050
movl (%rax), %edi
movq -0xa8(%rbp), %rdx
leaq 0xcf26(%rip), %rsi      # 0x1d346
movb $0x0, %al
callq 0x3300
movq -0xa8(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3080
jmp 0x10459
movq -0x8(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3080
movq -0xa8(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3080
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3110
movq %rax, %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10bb5
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x3450
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xd09d(%rip), %rsi      # 0x1dc68
movb $0x0, %al
callq 0x3400
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x12918(%rip), %rdi     # 0x234f8
movl $0x8, %ecx
leaq -0x14(%rbp), %r8
leaq 0x5580(%rip), %r9       # 0x16170
callq 0x3250
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
testb $0x1, 0x128c1(%rip)     # 0x234e4
je 0x10c36
leaq 0x126b4(%rip), %rdi     # 0x232e0
callq 0x10c50
movl %eax, -0x4(%rbp)
jmp 0x10c45
leaq 0x126a3(%rip), %rdi     # 0x232e0
callq 0x11300
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
shlq %cl, %rax
movslq -0x8(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
andq $0xfff, %rcx            # imm = 0xFFF
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
shrq %cl, %rax
movl -0x14(%rbp), %ecx
shlq %cl, %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movl -0x14(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rdx
movl -0x18(%rbp), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
movq -0x30(%rbp), %rdx
andq -0x38(%rbp), %rdx
movl -0x14(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl $0x1, %esi
shlq %cl, %rsi
movq %rsi, %rcx
subq $0x1, %rcx
andq %rcx, %rdx
movl -0x18(%rbp), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq $0x0, -0x8(%rbp)
leaq 0xecd9(%rip), %rdi      # 0x23660
addq $0x18, %rdi
leaq 0x7d5e(%rip), %rsi      # 0x1c6f0
callq 0x8250
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x149c9
callq 0x3050
movl (%rax), %edi
leaq 0x79cf(%rip), %rsi      # 0x1c37f
leaq 0x7d39(%rip), %rdx      # 0x1c6f0
leaq 0xeca2(%rip), %rcx      # 0x23660
addq $0x18, %rcx
movb $0x0, %al
callq 0x3300
movq -0x8(%rbp), %rdi
leaq 0x7683(%rip), %rsi      # 0x1c057
callq 0x3370
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x149fc
callq 0x3050
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0x9526(%rip), %rsi      # 0x1df1b
movb $0x0, %al
callq 0x3300
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x30a0
movslq -0x1c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3310
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movl -0x1c(%rbp), %eax
shll $0x8, %eax
movslq %eax, %rdi
callq 0x3310
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x30a0
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x14a99
movq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rsi
leaq 0x89e3(%rip), %rdi      # 0x1d46a
movb $0x0, %al
callq 0x3150
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x14a69
movq -0x38(%rbp), %rdi
callq 0x3040
movq -0x40(%rbp), %rdi
callq 0x3040
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31f0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3110
movq %rax, %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15e81
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0xc, %edx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x3450
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x85e3(%rip), %rsi      # 0x1e47a
movb $0x0, %al
callq 0x3400
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
leaq 0xdf24(%rip), %rdi      # 0x23dd0
movl $0x8, %ecx
leaq -0x24(%rbp), %r8
leaq -0x20(%rbp), %r9
callq 0x3250
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
cmpl $0x1, -0x24(%rbp)
jle 0x15f03
leaq 0xddce(%rip), %rdi      # 0x23cc0
leaq 0xddd7(%rip), %rsi      # 0x23cd0
callq 0x15f20
movl %eax, -0x4(%rbp)
jmp 0x15f0a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jle 0x161a5
callq 0x3050
movl (%rax), %edi
movl -0xc(%rbp), %edx
leaq 0x82ec(%rip), %rsi      # 0x1e485
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, %al
callq 0x3300
xorl %eax, %eax
movl %eax, %edi
callq 0x32e0
movl %eax, %edi
callq 0x3240
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x16212
callq 0x3490
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x161be
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3310
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1625b
callq 0x3050
movl (%rax), %edi
leaq 0x8264(%rip), %rsi      # 0x1e4b8
movb $0x0, %al
callq 0x3300
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x16286
movl -0x14(%rbp), %edx
addl -0x8(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16262
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x16170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/command_shuffle.c
// Function: add_len_drlevel2subk
int add_len_drlevel2subk(void)
{
 int min_smp_len = 0, min_subctx_dim_smp_sz;
  min_subctx_dim_smp_sz = MIN_SUBCTX_DIM_SMP_SZ;
  while( min_subctx_dim_smp_sz >>= 1){ min_smp_len++; };
  return ceil((float)min_smp_len/4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1000, -0x8(%rbp)     # imm = 0x1000
movl -0x8(%rbp), %eax
sarl %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x162ce
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x162b6
cvtsi2ssl -0x4(%rbp), %xmm0
movss 0x6409(%rip), %xmm1     # 0x1c6e4
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3460
cvttsd2si %xmm0, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
subq $0x5, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
leaq 0x680a(%rip), %rsi      # 0x1cb38
callq 0x3280
cmpl $0x0, %eax
je 0x16351
callq 0x3050
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0x8357(%rip), %rsi      # 0x1e6a1
movb $0x0, %al
callq 0x3300
movq -0x8(%rbp), %rdi
leaq 0x5cfb(%rip), %rsi      # 0x1c057
callq 0x3370
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x16384
callq 0x3050
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0x835d(%rip), %rsi      # 0x1e6da
movb $0x0, %al
callq 0x3300
movl $0x18, %edi
callq 0x3310
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x10, %esi
movl $0x1, %edx
callq 0x30a0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
shll $0x2, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x2, %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x30a0
movq -0x18(%rbp), %rdi
callq 0x30e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16438
jmp 0x16457
leaq 0x803e(%rip), %rdi      # 0x1e47d
leaq 0x84c0(%rip), %rsi      # 0x1e906
movl $0x39, %edx
leaq 0x84c6(%rip), %rcx      # 0x1e918
callq 0x31e0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x16463
jmp 0x16482
leaq 0x84e6(%rip), %rdi      # 0x1e950
leaq 0x8495(%rip), %rsi      # 0x1e906
movl $0x3a, %edx
leaq 0x849b(%rip), %rcx      # 0x1e918
callq 0x31e0
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x6b, %eax
je 0x164cc
jmp 0x1648f
movl -0x24(%rbp), %eax
subl $0x6c, %eax
je 0x164f4
jmp 0x16499
movl -0x24(%rbp), %eax
subl $0x6f, %eax
je 0x16508
jmp 0x164a3
movl -0x24(%rbp), %eax
subl $0x73, %eax
je 0x164e0
jmp 0x164ad
movl -0x24(%rbp), %eax
subl $0x3e7, %eax            # imm = 0x3E7
je 0x1658c
jmp 0x164bd
movl -0x24(%rbp), %eax
subl $0x1000002, %eax        # imm = 0x1000002
je 0x1651d
jmp 0x1659c
movq -0x10(%rbp), %rdi
callq 0x33e0
movl %eax, 0xd7e9(%rip)      # 0x23cc4
jmp 0x165a5
movq -0x10(%rbp), %rdi
callq 0x33e0
movl %eax, 0xd7d9(%rip)      # 0x23cc8
jmp 0x165a5
movq -0x10(%rbp), %rdi
callq 0x33e0
movl %eax, 0xd7c9(%rip)      # 0x23ccc
jmp 0x165a5
movq -0x10(%rbp), %rsi
leaq 0xd7bd(%rip), %rdi      # 0x23cd0
callq 0x3070
jmp 0x165a5
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jge 0x1658a
leaq 0x5d74(%rip), %rdi      # 0x1c2a2
movb $0x0, %al
callq 0x3150
movq -0x18(%rbp), %rdi
movq 0xba98(%rip), %rax      # 0x21fd8
movq (%rax), %rsi
movl $0x2, %edx
callq 0x30c0
leaq 0x5d4e(%rip), %rdi      # 0x1c2a2
movb $0x0, %al
callq 0x3150
movq -0x18(%rbp), %rdi
movq 0xba72(%rip), %rax      # 0x21fd8
movq (%rax), %rsi
movl $0x8, %edx
callq 0x30c0
leaq 0x5d28(%rip), %rdi      # 0x1c2a2
movb $0x0, %al
callq 0x3150
movl $0x16, -0x4(%rbp)
jmp 0x165ac
jmp 0x165a5
leaq 0x83cd(%rip), %rdi      # 0x1e960
movb $0x0, %al
callq 0x3150
jmp 0x165a5
movl $0x7, -0x4(%rbp)
jmp 0x165ac
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1666b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xb946(%rip), %rax      # 0x21fd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x166a6
jmp 0x166f3
cmpl $0x0, -0xc(%rbp)
jne 0x166ba
movq 0xb945(%rip), %rax      # 0x21ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x33c0
leaq -0x30(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x3310
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x5bf3(%rip), %rsi      # 0x1c32b
movb $0x0, %al
callq 0x3400
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jne 0x16766
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x16774
movq -0x8(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3080
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3370
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
jne 0x167a7
callq 0x3050
movl (%rax), %edi
movq -0x20(%rbp), %rdx
leaq 0x848b(%rip), %rsi      # 0x1ec2b
movb $0x0, %al
callq 0x3300
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/global_basic.c
// Function: str_suffix_match
int str_suffix_match(char *str, const char *suf)
{
 int ret = 0;
 if( (strlen(str) > strlen(suf)) && (strcmp( (str + strlen(str) - strlen(suf)),suf) == 0) )
  ret = 1;
 return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x179f5
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq -0x28(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
cmpl $0x0, %eax
jne 0x179f5
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, %rdx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)