LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: co2unitllmco
mco_entry_stat_t** co2unitllmco(const char *codirname, int bin_sz, int bin_id, int component_id)
{
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ) ;
 mco_entry_stat_t** mco = calloc(comp_sz, sizeof(mco_entry_stat_t*) );
 gid_arr_llist_t* tmp;
 char cofname[PATHLEN];
 mmp_uint_t mmpcofile;
 unsigned int ind;
 int mod;
 for(unsigned int i = 0 ; i < bin_sz ; i++)
 {
  sprintf(cofname,"%s/%d.%d.co.%d",codirname,bin_id,i,component_id);
  mmpcofile = mmp_uint_arr(cofname);
  int ctx_num = mmpcofile.fsize/sizeof(unsigned int);
  for(int j = 0; j < ctx_num; j++ )
  {
   ind = mmpcofile.mmpco[j];
   if(mco[ind] == NULL) mco[ind] = calloc( 1, sizeof(mco_entry_stat_t) );
   mod = mco[ind]->g_num % GID_ARR_SZ ;
   if(mod == 0)
   {
    if ( (tmp = malloc(sizeof(gid_arr_llist_t)) ) == NULL) err(errno,"co2unitllmco()") ;
    tmp->next = mco[ind]->next;
    mco[ind]->next = tmp ;
   }
   mco[ind]->next->gidobj[mod] = i ;
   mco[ind]->g_num++;
  };
  munmap(mmpcofile.mmpco, mmpcofile.fsize);
 }
 return mco;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %ecx, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
pushq $0x8
popq %rsi
movl $0x10000000, %edi       # imm = 0x10000000
callq 0x32a0
movq %rax, %r12
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
je 0x410b
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
leaq 0x100d5(%rip), %rsi     # 0x1412b
movq 0x10(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl %eax, (%rsp)
movl (%rsp), %r8d
movl 0x8(%rsp), %r9d
xorl %eax, %eax
callq 0x3430
movq %rbx, %rdi
callq 0x39cc
movl (%rsp), %esi
movq %rax, %rbp
movq %rdx, %r13
movq %rax, 0x18(%rsp)
shrq $0x2, %rbp
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x40f4
movl (%r13,%r15,4), %r14d
movq (%r12,%r14,8), %rbx
testq %rbx, %rbx
je 0x40ba
movl (%rbx), %ecx
andq $0xf, %rcx
je 0x40cc
movq 0x8(%rbx), %rax
jmp 0x40ea
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x32a0
movq %rax, %rbx
movq %rax, (%r12,%r14,8)
pushq $0x48
popq %rdi
callq 0x3340
testq %rax, %rax
je 0x4120
movq 0x8(%rbx), %rcx
movq %rcx, 0x40(%rax)
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
movl (%rsp), %esi
movl %esi, (%rax,%rcx,4)
incl (%rbx)
incq %r15
jmp 0x4099
movq %r13, %rdi
movq 0x18(%rsp), %rsi
callq 0x3360
movl (%rsp), %eax
incl %eax
jmp 0x403d
movq %r12, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0x1000c(%rip), %rsi     # 0x1413a
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: llmco2arrmco
gidobj_t** llmco2arrmco(mco_entry_stat_t** llmco)
{
 size_t comp_sz = (1LL << 4*COMPONENT_SZ) ;
 gidobj_t** arrmco = calloc(comp_sz, sizeof(gidobj_t*));
 gidobj_t* current_blkpos_mapin_arrmco;
 gid_arr_llist_t *tmpblk, *tmpptr;
  for(size_t i = 0; i< comp_sz ; i++ ){
  if(llmco[i] == NULL) continue;
  int arr_len = (int)llmco[i]->g_num + 1;
   arrmco[i] = malloc( arr_len * sizeof(gidobj_t) );
  current_blkpos_mapin_arrmco = arrmco[i] + arr_len;
  arrmco[i][0] = llmco[i]->g_num;
  int blk_num = arrmco[i][0] % GID_ARR_SZ == 0 ? arrmco[i][0]/GID_ARR_SZ :arrmco[i][0]/GID_ARR_SZ + 1;
  for(int blk = 0; blk < blk_num; blk++){
   if( blk == 0 ){
    tmpblk = llmco[i]->next;
    if(arrmco[i][0] % GID_ARR_SZ == 0){
     current_blkpos_mapin_arrmco -= GID_ARR_SZ;
     memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj, GID_ARR_SZ * sizeof(gidobj_t));
    }
    else {
     current_blkpos_mapin_arrmco -= arrmco[i][0] % GID_ARR_SZ ;
     memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj, (arrmco[i][0] % GID_ARR_SZ) * sizeof(gidobj_t));
    }
    free(llmco[i]);
   }
   else {
    tmpptr = tmpblk;
    tmpblk = tmpblk->next;
    current_blkpos_mapin_arrmco -= GID_ARR_SZ;
        memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj,GID_ARR_SZ * sizeof(gidobj_t));
    free(tmpptr);
   }
  }
  }
 free(llmco);
 return arrmco;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
pushq $0x8
popq %rsi
movl $0x10000000, %edi       # imm = 0x10000000
callq 0x32a0
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
cmpq $0x10000000, %rbp       # imm = 0x10000000
je 0x4272
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rax
testq %rax, %rax
je 0x426a
movslq (%rax), %r14
leaq 0x4(,%r14,4), %rdi
callq 0x3340
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
leaq (%rax,%r14,4), %r15
addq $0x4, %r15
movl %r14d, (%rax)
movl %r14d, %eax
andl $0xf, %eax
shrl $0x4, %r14d
cmpl $0x1, %eax
sbbl $-0x1, %r14d
xorl %ebx, %ebx
cmpl %ebx, %r14d
je 0x426a
testl %ebx, %ebx
je 0x41f2
movq 0x40(%r12), %r13
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm3, -0x10(%r15)
movups %xmm2, -0x20(%r15)
movups %xmm1, -0x30(%r15)
movups %xmm0, -0x40(%r15)
addq $-0x40, %r15
jmp 0x4258
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq 0x8(%rax), %r13
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rax
movl (%rax), %edx
andq $0xf, %rdx
je 0x4223
shll $0x2, %edx
subq %rdx, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
jmp 0x424f
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm3, -0x10(%r15)
movups %xmm2, -0x20(%r15)
movups %xmm1, -0x30(%r15)
movups %xmm0, -0x40(%r15)
addq $-0x40, %r15
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %r12
movq %r12, %rdi
callq 0x3040
incl %ebx
movq %r13, %r12
jmp 0x41b2
incq %rbp
jmp 0x415c
movq 0x8(%rsp), %rdi
callq 0x3040
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: write_unit_arrmco_file
unsigned int write_unit_arrmco_file(const char* unitmcofname, gidobj_t** arrmco)
{
  FILE *outf;
  if( (outf = fopen(unitmcofname,"wb") ) == NULL ) err(errno,"write_unit_arrmco_file()");
  size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 unsigned int validrow=0;
  for(size_t i = 0; i< comp_sz ; i++ ){
    if(arrmco[i] != NULL){
   validrow++;
   fwrite(&i,sizeof(i),1,outf);
   fwrite(arrmco[i], sizeof(gidobj_t), (unsigned int)arrmco[i][0] + 1, outf);
  }
  }
 fclose(outf);
 return validrow;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xfdc5(%rip), %rsi      # 0x1406a
callq 0x33a0
testq %rax, %rax
je 0x431b
movq %rax, %r14
xorl %r12d, %r12d
pushq $0x1
popq %r13
pushq $0x4
popq %r15
xorl %ebp, %ebp
movq %r12, (%rsp)
cmpq $0x10000000, %r12       # imm = 0x10000000
jae 0x4302
cmpq $0x0, (%rbx,%r12,8)
je 0x42fd
incl %ebp
movq %rsp, %rdi
pushq $0x8
popq %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x3450
movq (%rsp), %r12
movq (%rbx,%r12,8), %rdi
movl (%rdi), %edx
incl %edx
movq %r15, %rsi
movq %r14, %rcx
callq 0x3450
incq %r12
jmp 0x42bf
movq %r14, %rdi
callq 0x3100
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0xfe20(%rip), %rsi      # 0x14149
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: read_unit_arrmco_file
gidobj_t** read_unit_arrmco_file(const char *mco_fncode)
{
 FILE *inf;
 if( (inf = fopen(mco_fncode ,"rb") ) == NULL ) err(errno,"read_unit_arrmco_file()");
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 unsigned int ind ;
 gidobj_t** arrmco = calloc(comp_sz, sizeof(gidobj_t*));
  gidobj_t gid_arr_len;
 while( fread(&ind,sizeof(ind),1,inf) == 1){
  fread(&gid_arr_len, sizeof(gidobj_t), 1 , inf);
  arrmco[ind] = malloc(sizeof(gidobj_t)* ( (unsigned int)gid_arr_len + 1));
  arrmco[ind][0] = gid_arr_len;
  fread( arrmco[ind] + 1, sizeof(gidobj_t), (unsigned int)gid_arr_len , inf);
 }
 fclose(inf);
 return arrmco ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xfd25(%rip), %rsi      # 0x14067
callq 0x33a0
testq %rax, %rax
je 0x43e2
movq %rax, %rbx
pushq $0x8
popq %rsi
movl $0x10000000, %edi       # imm = 0x10000000
callq 0x32a0
movq %rax, %r14
pushq $0x4
popq %r12
pushq $0x1
popq %r13
movq %rsp, %rbp
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x30c0
cmpq $0x1, %rax
jne 0x43c8
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x30c0
movl (%rsp), %r15d
leal 0x1(%r15), %edi
shlq $0x2, %rdi
callq 0x3340
movl 0x4(%rsp), %ecx
movq %rax, (%r14,%rcx,8)
movl %r15d, (%rax)
leaq 0x4(%rax), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x30c0
jmp 0x436e
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0xfd72(%rip), %rsi      # 0x14162
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: free_unit_arrmco
void free_unit_arrmco(gidobj_t** unit_arrmco)
{
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 for(size_t i = 0; i < comp_sz ; i++){
  if(unit_arrmco[i] != NULL)
   free(unit_arrmco[i]);
 }
 free(unit_arrmco);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x10000000, %r14       # imm = 0x10000000
je 0x4418
movq (%rbx,%r14,8), %rdi
callq 0x3040
incq %r14
jmp 0x4401
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/co2mco.c
// Function: precise_est_unitllmco_mem
size_t precise_est_unitllmco_mem(const char *co_dstat_fpath)
{
 FILE *co_stat_fp;
 if( ( co_stat_fp = fopen(co_dstat_fpath,"rb")) == NULL )
   err(errno,"precise_est_unitllmco_mem():%s",co_dstat_fpath);
 co_dstat_t co_dstat_readin;
 fread( &co_dstat_readin, sizeof(co_dstat_t),1,co_stat_fp );
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ) ;
 double ctx_spc_use_rate = (double)co_dstat_readin.all_ctx_ct
  /co_dstat_readin.infile_num/co_dstat_readin.comp_num/comp_sz ;
 printf("ctx_spc_use_rate=%lf\n",ctx_spc_use_rate);
 size_t mem_sz = comp_sz
        *( sizeof(mco_entry_stat_t*)
        + sizeof(mco_entry_stat_t)
        + ( (unsigned int)( ( (double) BIN_SZ * ctx_spc_use_rate ) / GID_ARR_SZ ) + 1 )
         * ( sizeof(gidobj_t) * GID_ARR_SZ + sizeof(gid_arr_llist_t *) )
        );
 fclose(co_stat_fp);
 return mem_sz;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0xfc24(%rip), %rsi      # 0x14067
callq 0x33a0
testq %rax, %rax
je 0x4504
movq %rax, %rbx
leaq 0x18(%rsp), %r14
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
callq 0x30c0
movsd 0x18(%r14), %xmm1
unpcklps 0xfbb9(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xfbc1(%rip), %xmm1     # 0x14040
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cvtsi2sdl 0x14(%r14), %xmm2
cvtsi2sdl 0x10(%r14), %xmm1
divsd %xmm2, %xmm0
divsd %xmm1, %xmm0
mulsd 0xfb69(%rip), %xmm0     # 0x14010
movapd %xmm0, (%rsp)
leaq 0xfce6(%rip), %rdi      # 0x14199
movb $0x1, %al
callq 0x3170
movapd (%rsp), %xmm0
mulsd 0xfb51(%rip), %xmm0     # 0x14018
mulsd 0xfb51(%rip), %xmm0     # 0x14020
cvttsd2si %xmm0, %rax
incl %eax
movabsq $0x480000000, %rcx      # imm = 0x480000000
imulq %rax, %rcx
movabsq $0x180000000, %r14      # imm = 0x180000000
addq %rcx, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x3060
movl (%rax), %edi
leaq 0xfc68(%rip), %rsi      # 0x1417a
movq %r14, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/yhg926[P]public_kssd/./global_basic.h
// Function: check
static inline void check (int test, const char * message, ...)
{
    if (test) {
        va_list args;
        va_start (args, message);
        vfprintf (stderr, message, args);
        va_end (args);
        fprintf (stderr, "\n");
        exit (EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4573
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)
testl %edi, %edi
jne 0x4580
addq $0xd0, %rsp
popq %rbx
retq
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x16a4c(%rip), %rbx     # 0x1aff8
movq (%rbx), %rdi
callq 0x33f0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x3250
pushq $0x1
popq %rdi
callq 0x3440
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
pushq $0x8
popq %r13
pushq $0x1
popq %rbp
leaq 0xe38f(%rip), %r14      # 0x14370
xorl %r12d, %r12d
movq %rdi, (%rsp)
movslq 0x314(%r15), %rax
cmpq %rax, %r12
jge 0x60bf
movq 0x318(%r15), %rax
movq (%rax,%r12,8), %rbx
movq %rbx, %rdi
pushq $0x2e
popq %rsi
callq 0x31d0
leaq 0x1(%rax), %rdi
leaq 0xe24f(%rip), %rsi      # 0x14268
callq 0x32b0
testl %eax, %eax
je 0x6038
leaq 0xe30b(%rip), %rdi      # 0x14334
movl %r12d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3170
jmp 0x60b7
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0x32e0
movq 0x318(%r15), %rax
movq %r12, 0x8(%rsp)
movq (%rax,%r12,8), %rdi
leaq 0xe00b(%rip), %rsi      # 0x14067
callq 0x33a0
testq %rax, %rax
je 0x60d4
movq %rax, %rbx
movq 0x48(%rsp), %r12
xorl %r15d, %r15d
movslq %r15d, %r15
cmpq %r12, %r15
jge 0x60a6
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x30c0
movl 0x10(%rsp), %esi
cvtss2sd 0x14(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x3170
addq $0x8, %r15
jmp 0x6071
movq %rbx, %rdi
callq 0x3100
movq (%rsp), %r15
movq 0x8(%rsp), %r12
incq %r12
jmp 0x5fe8
pushq $0x1
popq %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
movq (%rsp), %rax
movq 0x318(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xe26c(%rip), %rsi      # 0x14362
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x626b
cmpq $0x0, (%rax)
je 0x6284
pushq $0x7
popq %rax
leal -0x62(%rdi), %ecx
cmpl $0x11, %ecx
ja 0x618f
leaq 0xe0a9(%rip), %rdx      # 0x14220
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, 0x150f6(%rip)     # 0x1b280
jmp 0x621c
movq %rdx, %rbx
cmpl $0x1000002, %edi        # imm = 0x1000002
je 0x6223
cmpl $0x1000006, %edi        # imm = 0x1000006
jne 0x621e
movl 0x8(%rbx), %eax
movslq 0x18(%rbx), %rcx
subl %ecx, %eax
movl %eax, 0x153df(%rip)     # 0x1b594
shlq $0x3, %rcx
addq 0x10(%rbx), %rcx
movq %rcx, 0x153d4(%rip)     # 0x1b598
jmp 0x621c
leaq 0x151c7(%rip), %rdi     # 0x1b394
jmp 0x6217
leaq 0x150be(%rip), %rdi     # 0x1b294
jmp 0x6217
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x150a2(%rip)     # 0x1b288
jmp 0x621c
movl $0x1, 0x1509a(%rip)     # 0x1b28c
jmp 0x621c
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x1508e(%rip)     # 0x1b290
jmp 0x621c
movl $0x1, 0x15076(%rip)     # 0x1b284
jmp 0x621c
leaq 0x1527d(%rip), %rdi     # 0x1b494
callq 0x3080
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
cmpl $0x1, 0x8(%rbx)
jg 0x621e
pushq $0xb
popq %rbp
movl %ebp, %edi
callq 0x3050
movq 0x14d9c(%rip), %r14     # 0x1afd8
movq (%r14), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x30e0
movl %ebp, %edi
callq 0x3050
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x30e0
movl %ebp, %edi
callq 0x3050
pushq $0x16
popq %rax
jmp 0x621e
leaq 0xe01e(%rip), %rdi      # 0x14290
leaq 0xe400(%rip), %rsi      # 0x14679
leaq 0xe40d(%rip), %rcx      # 0x1468d
pushq $0x49
jmp 0x629b
leaq 0xe43c(%rip), %rdi      # 0x146c7
leaq 0xe3e7(%rip), %rsi      # 0x14679
leaq 0xe3f4(%rip), %rcx      # 0x1468d
pushq $0x4a
popq %rdx
callq 0x3200
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x6930
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x691d
movl $0x101, %edi            # imm = 0x101
callq 0x3340
movq %rax, %r14
leaq 0xdaac(%rip), %rsi      # 0x14393
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3430
leaq 0xd769(%rip), %rsi      # 0x14067
movq %r14, %rdi
callq 0x33a0
testq %rax, %rax
je 0x6915
movq %rax, %rdi
callq 0x3100
jmp 0x6920
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 0xe3c0(%rip), %rsi      # 0x14cfe
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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 0x69cd
movl $0xf000, %ebp           # imm = 0xF000
andl 0x20(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
je 0x6993
leaq 0x165fc(%rip), %rsi     # 0x1cf80
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x87ff
testl %eax, %eax
je 0x69ad
movq %rsp, %rsi
movq %rbx, (%rsi)
pushq $0x1
popq %rdi
movl %edi, %edx
callq 0x10b57
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x8000, %ebp           # imm = 0x8000
jne 0x69c9
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x98, %rsp
popq %rbx
popq %rbp
jmp 0x10717
xorl %eax, %eax
jmp 0x69a3
callq 0x3060
movl (%rax), %edi
leaq 0xe9ff(%rip), %rsi      # 0x153da
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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 0x6ab7
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 0x1039c
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 0x6a6a
movl $0xf000, %eax           # imm = 0xF000
andl 0x28(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x6a77
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
leaq 0xe11d(%rip), %rsi      # 0x14b9b
leaq 0x1a0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1012b
leaq 0xe101(%rip), %rsi      # 0x14ba6
leaq 0xa0(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3430
leaq 0xa0(%rsp), %rdi
callq 0x103a0
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6b11
movl %r14d, %eax
leaq 0x101c1(%rip), %rcx     # 0x16cc0
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 0x6b2c
pushq $0xc
popq %r15
subl %ecx, %r15d
shrl $0x2, %r15d
pushq $0x1
jmp 0x6b3a
leal -0x27(%rcx), %eax
pushq $-0x4
popq %rsi
cltd
idivl %esi
movl %eax, %r15d
pushq $-0x1
popq %r13
pushq $0x1
popq %r12
shlq %cl, %r12
callq 0x3060
movl (%rax), %edi
addl %ebx, %r13d
addl %r15d, %r13d
movl %r13d, (%rsp)
leaq 0xe053(%rip), %rsi      # 0x14bae
movsd 0xdba5(%rip), %xmm0     # 0x14708
movl %r14d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
movq %r12, %r9
movb $0x1, %al
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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 0x7df5
addq $0x222, %rdi            # imm = 0x222
movl %edx, %esi
jmp 0x10717
movl 0x650(%rdi), %eax
testl %eax, %eax
jle 0x7e0d
movq 0x658(%rdi), %rsi
movl %eax, %edi
jmp 0x10b57
pushq %rax
leaq 0xd5a0(%rip), %rdi      # 0x153b5
callq 0x33b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
callq 0x3130
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x147d6(%rip), %rbp     # 0x1d000
cmpq $0x2, %rbx
je 0x885c
movq (%rbp,%rbx,8), %r13
movq %r13, %rdi
callq 0x3130
movl %r12d, %ecx
subl %eax, %ecx
movslq %ecx, %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
incq %rbx
testl %eax, %eax
jne 0x882a
leaq 0x10(%rsp), %r15
movl (%rsp), %eax
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
leaq 0x6(%rsp), %r13
xorl %ecx, %ecx
movq %rcx, %r12
cmpq %rcx, %rbx
je 0x88b8
movq (%r14,%r12,8), %rdx
movq %r13, %rdi
leaq 0xbaf6(%rip), %rsi      # 0x1437c
xorl %eax, %eax
callq 0x3430
movq %r15, %rdi
callq 0x3130
leaq (%rax,%r15), %rbp
movq %r13, %rdi
callq 0x3130
subq %rax, %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x32b0
leaq 0x1(%r12), %rcx
testl %eax, %eax
jne 0x8870
movslq (%rsp), %rcx
xorl %eax, %eax
cmpq %rcx, %r12
setl %al
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %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, %r14
movl (%rax), %edi
callq 0x3470
leaq 0x9904(%rip), %rsi      # 0x141af
movl %r15d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb564
leaq 0x8(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x34a0
movq 0x30(%r15), %r15
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
movq %r15, %rsi
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3150
movq %rax, %r12
xorl %r13d, %r13d
cmpq $-0x1, %rax
sete %r13b
movl (%r14), %edi
callq 0x3470
leaq 0x98c1(%rip), %rsi      # 0x141c2
movl %r13d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb564
movl %ebp, %edi
callq 0x3220
movq %r15, %rax
movq %r12, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8cea(%rip), %rsi      # 0x141af
movl %r15d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb564
leaq 0x8(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x34a0
movq 0x30(%r15), %r15
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
movq %r15, %rsi
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 0x8ca6(%rip), %rsi      # 0x141c2
movl %r14d, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb564
leaq 0x9d46(%rip), %rsi      # 0x15279
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_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x18(%rsp)
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x18(%rdi), %rax
subl %eax, %ebp
incl %ebp
movl %ebp, 0xc(%rsp)
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq (%rcx,%rax,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 0xc553
pushq $0x1
popq %rsi
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rax
movq 0x40(%rbx), %rdx
leaq 0x90f4(%rip), %rsi      # 0x15652
movq %rax, %rdi
xorl %eax, %eax
callq 0x3430
leaq 0xf8f1(%rip), %rdi      # 0x1be60
pushq $0x8
popq %rcx
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r9
movl %ebp, %esi
movq %r14, %rdx
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 0xf258(%rip), %rdi      # 0x1b800
callq 0x62a4
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7db3(%rip), %rsi      # 0x14393
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 0xc63d
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xc63d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
jne 0xc64a
callq 0x3060
movl $0x11, (%rax)
leaq 0x8d46(%rip), %rsi      # 0x15376
pushq $0x11
popq %rdi
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_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x18(%rdi), %rax
subl %eax, %ebp
incl %ebp
movl %ebp, 0xc(%rsp)
movq 0x10(%rdi), %rcx
movq 0x40(%rdi), %rdi
leaq (%rcx,%rax,8), %r14
addq $-0x8, %r14
movq (%r14), %r12
callq 0x3130
leaq 0x9(%rax), %rdi
callq 0x3340
movq %rax, (%r14)
testq %rax, %rax
jne 0xcb20
pushq $0x1
popq %rsi
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rax
movq 0x40(%rbx), %rdx
leaq 0x9223(%rip), %rsi      # 0x15d4e
movq %rax, %rdi
xorl %eax, %eax
callq 0x3430
leaq 0xf9cc(%rip), %rdi      # 0x1c508
leaq 0x37a8(%rip), %r9       # 0x102eb
pushq $0x8
popq %rcx
leaq 0xc(%rsp), %r15
movl %ebp, %esi
movq %r14, %rdx
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, 0xf97d(%rip)      # 0x1c4f4
jne 0xcb8a
leaq 0xf770(%rip), %rdi      # 0x1c2f0
callq 0xcba3
pushq $0x1
popq %rax
jmp 0xcb96
leaq 0xf75f(%rip), %rdi      # 0x1c2f0
callq 0xcffd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r10d
shlq %cl, %r10
movq 0x8(%rsp), %rdi
movslq %esi, %rdx
addq %r10, %rdx
movl %edx, %r10d
movl %eax, %ecx
shrq %cl, %rdx
movl %r8d, %ecx
shlq %cl, %rdx
andl $0xfff, %r10d           # imm = 0xFFF
pushq $-0x1
popq %rax
movq %rax, %rsi
movl %r9d, %ecx
shlq %cl, %rsi
notq %rsi
movl %r8d, %ecx
shlq %cl, %rsi
movl (%rdi,%r10,4), %ecx
addq %rcx, %rdx
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x18(%rsp)
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x18(%rdi), %rax
subl %eax, %ebp
incl %ebp
movl %ebp, 0xc(%rsp)
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq (%rcx,%rax,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 0xd843
pushq $0x1
popq %rsi
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rax
movq 0x40(%rbx), %rdx
leaq 0x874f(%rip), %rsi      # 0x15f9d
movq %rax, %rdi
xorl %eax, %eax
callq 0x3430
leaq 0xf229(%rip), %rdi      # 0x1ca88
pushq $0x8
popq %rcx
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r9
movl %ebp, %esi
movq %r14, %rdx
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)
pushq $-0x1
popq %rbx
cmpl $0x2, %eax
jl 0xd8c4
movl 0xedd1(%rip), %eax      # 0x1c670
cmpl $0x4, %eax
je 0xd8bc
cmpl $0x3, %eax
je 0xd8b5
cmpl $0x2, %eax
jne 0xd8d3
callq 0xe0c3
jmp 0xd8c1
callq 0xea76
jmp 0xd8c1
callq 0xee97
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jae 0xd8de
callq 0xe48a
xorl %ebx, %ebx
jmp 0xd8c4
cmpl $0x0, 0xed93(%rip)      # 0x1c678
je 0xd8ee
callq 0xf381
jmp 0xd8c4
cmpb $0x0, 0xef93(%rip)      # 0x1c888
je 0xd905
leaq 0xef8a(%rip), %rdi      # 0x1c888
callq 0xd913
jmp 0xd8da
leaq 0x8b96(%rip), %rdi      # 0x164a2
callq 0x30a0
jmp 0xd8c4
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xd2f3(%rip), %rdi      # 0x1c688
leaq 0x53c4(%rip), %rsi      # 0x14760
callq 0x68a5
testq %rax, %rax
je 0xf46b
movq %rax, %rbx
leaq 0x4cb3(%rip), %rsi      # 0x14067
movq %rax, %rdi
callq 0x33a0
testq %rax, %rax
je 0xf48e
movq %rax, %r14
movq %rsp, %rbx
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x30c0
movslq 0x14(%rbx), %r12
leaq (,%r12,4), %rdi
callq 0x3340
movq %rax, %rbx
pushq $0x4
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x30c0
movq %r12, %rdi
shlq $0x8, %rdi
callq 0x3340
movq %rax, %r15
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x30c0
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %r13d
cmovgl %r12d, %r13d
shlq $0x8, %r13
cmpq %r14, %r13
je 0xf44e
leaq (%r15,%r14), %rdi
callq 0x30a0
addq $0x100, %r14            # imm = 0x100
jmp 0xf437
movq %rbx, %rdi
callq 0x3040
movq %r15, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3040
callq 0x3060
movl (%rax), %edi
leaq 0x4f54(%rip), %rsi      # 0x143cd
leaq 0x52e0(%rip), %rdx      # 0x14760
leaq 0xd201(%rip), %rcx      # 0x1c688
xorl %eax, %eax
callq 0x3330
callq 0x3060
movl (%rax), %edi
leaq 0x6bae(%rip), %rsi      # 0x1604a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x18(%rsp)
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x18(%rdi), %rax
subl %eax, %ebp
incl %ebp
movl %ebp, 0xc(%rsp)
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq (%rcx,%rax,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 0x100b3
pushq $0x1
popq %rsi
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3480
movq (%r14), %rax
movq 0x40(%rbx), %rdx
leaq 0x650e(%rip), %rsi      # 0x165cc
movq %rax, %rdi
xorl %eax, %eax
callq 0x3430
leaq 0xcd11(%rip), %rdi      # 0x1cde0
pushq $0x8
popq %rcx
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r9
movl %ebp, %esi
movq %r14, %rdx
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)
cmpl $0x2, %eax
jl 0x1011b
leaq 0xcbc3(%rip), %rdi      # 0x1ccd0
leaq 0xcbcc(%rip), %rsi      # 0x1cce0
callq 0x1012b
jmp 0x1011e
pushq $-0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ebp, %r14d
cmpl $0x1, %r14d
jle 0x10333
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)
movq %r15, %r14
jmp 0x10308
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10387
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
movl %ebp, %esi
cmpq %rcx, %rdx
je 0x10377
leal (%rsi,%rcx), %edi
movl %edi, (%rax,%rcx,4)
incq %rcx
jmp 0x10367
movq %rax, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x102eb
callq 0x3060
movl (%rax), %edi
leaq 0x6242(%rip), %rsi      # 0x165d7
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3130
addl $-0x5, %eax
movslq %eax, %rdi
addq %rbx, %rdi
leaq 0x47e8(%rip), %rsi      # 0x14ba8
callq 0x32b0
testl %eax, %eax
jne 0x10441
leaq 0x3c97(%rip), %rsi      # 0x14067
movq %rbx, %rdi
callq 0x33a0
testq %rax, %rax
je 0x10451
movq %rax, %r14
pushq $0x18
popq %rdi
callq 0x3340
movq %rax, %rbx
pushq $0x10
popq %rsi
pushq $0x1
popq %r15
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x30c0
movb 0x8(%rbx), %cl
shlb $0x2, %cl
pushq $0x4
popq %r12
shll %cl, %r12d
movq %r12, %rdi
callq 0x3340
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x30c0
movq %r14, %rdi
callq 0x3100
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x6371(%rip), %rsi      # 0x167c0
jmp 0x1045f
callq 0x3060
movl (%rax), %edi
leaq 0x639a(%rip), %rsi      # 0x167f9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330