LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: qrmload(int*, int, int, int*)
int qrmload(int *m,int c,int jo,int *anst){ //mの中に，english.001.2 の中からc文字をランダムに選択して保存する
    char chr;
    FILE *fp;
    long long int qsize = std::filesystem::file_size(qname);
    fp = fopen(qname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int i = 0;
    jswt = 0;
    int rlen = rand()%(qsize-c);
    if(runmode==2){rlen = qstart;}
    anst[jo] = rlen;
    fseek(fp,rlen,SEEK_SET);
    printf("\nrlen[%d]から[%d]文字(%lld)\n[",rlen,c,qsize);
    if(CHECKFLAG == 1){checkpz[0]=rlen;checkpz[1]=c;} //記憶
    for(i=0;i<c;i++) { //c文字
        chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        if(m[i]==10){jswt=1;}
        //printf("\n%x(%d)",m[i],i);
        //if(DEBUGFLAG==1){printf("%c",m[i]);}
    }
    printf("]");
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x5461(%rip), %rsi      # 0xb200
movq %rsp, %r15
movq %r15, %rdi
movl $0x2, %edx
callq 0x71c6
movq %r15, %rdi
callq 0x21c0
movq %rax, %r13
movq %rsp, %rdi
callq 0x724e
movq 0x5437(%rip), %rdi      # 0xb200
leaq 0x22cb(%rip), %rsi      # 0x809b
callq 0x2180
testq %rax, %rax
je 0x5e78
movq %rax, %r15
movl $0x0, 0x56d5(%rip)      # 0xb4c0
callq 0x2060
cltq
movslq %ebx, %rcx
movq %r13, %rsi
subq %rcx, %rsi
cqto
idivq %rsi
cmpl $0x2, 0x5345(%rip)      # 0xb14c
jne 0x5e0f
movl 0x5349(%rip), %edx      # 0xb158
movslq %ebp, %rax
movl %edx, (%r12,%rax,4)
movslq %edx, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2170
leaq 0x238a(%rip), %rdi      # 0x81b7
movl %r12d, %esi
movl %ebx, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2030
testl %ebx, %ebx
jle 0x5e6c
movl %ebx, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%r14,%r13,4)
cmpl $0xa, %eax
jne 0x5e64
movl $0x1, 0x565c(%rip)      # 0xb4c0
incq %r13
cmpq %r13, %r12
jne 0x5e46
movl $0x5d, %edi
callq 0x21d0
jmp 0x5e92
movq 0x5381(%rip), %rsi      # 0xb200
leaq 0x2217(%rip), %rdi      # 0x809d
xorl %eax, %eax
callq 0x2030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x724e
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: bitload(bool*, unsigned char, int, int)
int bitload(bool *ar,unsigned char a2,int p,int mx){
    int a = a2;
    //if(mote==1){printf("<%d>",a);}
    ar[p+0] = a/128;a-=ar[p+0]*128;
    //if(mote==1){printf("<%d>",a);}
    if(p+1<mx){ar[p+1] = a/64;a-=ar[p+1]*64;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    if(p+2<mx){ar[p+2] = a/32;a-=ar[p+2]*32;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    if(p+3<mx){ar[p+3] = a/16;a-=ar[p+3]*16;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    //if(mx-5<=p && mx< 120000 && mx > 90000){printf(" / %d < %d(%d) / ",p+4,mx,ar[p+4]);exit(5);}
    if(p+4<mx){ar[p+4] = a/8;a-=ar[p+4]*8;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    //if(mx-5<=p && mx< 120000 && mx > 90000){printf(" / %d < %d(%d) / ",p+4,mx,ar[p+4]);exit(5);} 
    if(p+5<mx){ar[p+5] = a/4;a-=ar[p+5]*4;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    if(p+6<mx){ar[p+6] = a/2;a-=ar[p+6]*2;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    if(p+7<mx){ar[p+7] = a/1;a-=ar[p+7]*1;}else{return -1;}
    //if(mote==1){printf("<%d>",a);}
    if(p+8>=mx){return -1;}
    return 0;
}

// Assembly:
movslq %edx, %r8
movl %esi, %eax
shrb $0x7, %al
movb %al, (%rdi,%r8)
leaq 0x1(%r8), %r10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r10d
jge 0x6002
movzbl %sil, %r9d
andb $-0x80, %sil
movzbl %sil, %esi
subl %esi, %r9d
leal -0x40(%r9), %r11d
cmpl $-0x7f, %r11d
setb (%rdi,%r10)
leaq 0x2(%r8), %r10
cmpl %ecx, %r10d
jge 0x6002
pushq %rbx
xorl %esi, %esi
cmpl $-0x7f, %r11d
setae %sil
shll $0x6, %esi
leal (%rsi,%r9), %ebx
addl $-0x60, %ebx
cmpl $-0x3f, %ebx
setb (%rdi,%r10)
leaq 0x3(%r8), %r10
cmpl %ecx, %r10d
jge 0x6001
addl %r9d, %esi
addl $-0x40, %esi
xorl %r11d, %r11d
cmpl $-0x3f, %ebx
setae %r11b
shll $0x5, %r11d
leal (%r11,%rsi), %ebx
addl $-0x30, %ebx
cmpl $-0x1f, %ebx
setb (%rdi,%r10)
leaq 0x4(%r8), %r9
cmpl %ecx, %r9d
jge 0x6001
addl %r11d, %esi
addl $-0x20, %esi
xorl %r10d, %r10d
cmpl $-0x1f, %ebx
setae %r10b
shll $0x4, %r10d
leal (%r10,%rsi), %ebx
addl $-0x18, %ebx
cmpl $-0xf, %ebx
setb (%rdi,%r9)
leaq 0x5(%r8), %r9
cmpl %ecx, %r9d
jge 0x6001
addl %r10d, %esi
addl $-0x10, %esi
xorl %r11d, %r11d
cmpl $-0xf, %ebx
setae %r11b
leal (%rsi,%r11,8), %ebx
addl $-0xc, %ebx
cmpl $-0x7, %ebx
setb (%rdi,%r9)
leaq 0x6(%r8), %r10
cmpl %ecx, %r10d
jge 0x6001
leal (%rsi,%r11,8), %esi
addl $-0x8, %esi
xorl %r9d, %r9d
cmpl $-0x7, %ebx
setae %r9b
leal (%rsi,%r9,4), %r11d
addl $-0x6, %r11d
cmpl $-0x3, %r11d
setb (%rdi,%r10)
addq $0x7, %r8
cmpl %ecx, %r8d
jge 0x6001
leal (%rsi,%r9,4), %eax
addl $-0x4, %eax
xorl %esi, %esi
cmpl $-0x3, %r11d
setae %sil
leal -0x2(,%rsi,2), %esi
addl %eax, %esi
setne (%rdi,%r8)
addl $0x8, %edx
xorl %eax, %eax
cmpl %ecx, %edx
setge %al
negl %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: qrmreload(int*, int)
int qrmreload(int *m,int c){ //mの中に，english.001.2 の中からc文字をもう一度選択して保存する
    char chr;FILE *fp;
    long long int qsize = std::filesystem::file_size(qname);
    fp = fopen(qname, "r"); // open file or return null
    printf("\n[%lld]rlen[%d]から[%d]文字\n[",qsize,checkpz[0],checkpz[1]);
    fseek(fp,checkpz[0],SEEK_SET); //指定したシークまで移動する
    for(int i=0;i<checkpz[1];i++) { //c文字
        chr = fgetc(fp);
        m[i] = chr;
        //if(DEBUGFLAG==1){printf("%c",chr);}
        if(chr<0){m[i]=chr + 256;}
    }
    printf("]");
    return checkpz[1];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x51ea(%rip), %rsi      # 0xb200
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x71c6
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x724e
movq 0x51bc(%rip), %rdi      # 0xb200
leaq 0x2050(%rip), %rsi      # 0x809b
callq 0x2180
movq %rax, %r14
movl 0x51b7(%rip), %edx      # 0xb210
movl 0x51b5(%rip), %ecx      # 0xb214
leaq 0x2173(%rip), %rdi      # 0x81d9
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movslq 0x5199(%rip), %rsi      # 0xb210
movq %r14, %rdi
xorl %edx, %edx
callq 0x2170
cmpl $0x0, 0x518c(%rip)      # 0xb214
jle 0x60ab
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%rbx,%r15,4)
incq %r15
movslq 0x516e(%rip), %rax      # 0xb214
cmpq %rax, %r15
jl 0x608d
movl $0x5d, %edi
callq 0x21d0
movl 0x5159(%rip), %eax      # 0xb214
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x724e
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead 'codeindex' and search using <queryfile>. \n");
    printf(": ./gcis_uni_locate -q <queryfile>\n");
    printf("\nYou can set the indexfile by using option -i. \n");
    printf(": ./gcis_uni_locate -i <indexfile> -q <queryfile>\n");
    printf("\nYou can set the location mode 0 ~ 4 by using option -m. \n");
    printf("mode 3 is used by default.(defined 'MMODE' in this code.)\n");
    printf(": ./gcis_uni_locate -i <indexfile> -q <queryfile> -m <mode>\n");
    printf("\nYou can set the number of query by using option -r. \n");
    printf("10 is used by default.(defined 'MREP' in this code.)\n");
    printf(": ./gcis_uni_locate -i <indexfile> -q <queryfile> -m <mode> -r <times>\n");
    printf("\nYou can set the length of pattern by using option -l. \n");
    printf("10 is used by default.(defined 'MLONG' in this code.)\n");
    printf(": ./gcis_uni_locate -i <indexfile> -q <queryfile> -m <mode> -l <length>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0x2351(%rip), %rdi      # 0x8433
callq 0x21f0
leaq 0x2366(%rip), %rdi      # 0x8454
callq 0x21f0
leaq 0x238b(%rip), %rdi      # 0x8485
callq 0x21f0
leaq 0x23a2(%rip), %rdi      # 0x84a8
callq 0x21f0
leaq 0x23c6(%rip), %rdi      # 0x84d8
callq 0x21f0
leaq 0x23ec(%rip), %rdi      # 0x850a
callq 0x21f0
leaq 0x241a(%rip), %rdi      # 0x8544
callq 0x21f0
leaq 0x2448(%rip), %rdi      # 0x857e
callq 0x21f0
leaq 0x2478(%rip), %rdi      # 0x85ba
callq 0x21f0
leaq 0x24a2(%rip), %rdi      # 0x85f0
callq 0x21f0
leaq 0x24cb(%rip), %rdi      # 0x8625
callq 0x21f0
leaq 0x2506(%rip), %rdi      # 0x866c
callq 0x21f0
leaq 0x2532(%rip), %rdi      # 0x86a4
callq 0x21f0
leaq 0x255c(%rip), %rdi      # 0x86da
callq 0x21f0
movl $0xa, %edi
callq 0x21d0
movl $0xa, %edi
callq 0x21d0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::maybe<void> to::parse<char const*>(char**&, to::key, char const*)
maybe<void> parse(char**& argp, key k0, Tail... krest) {
    key keys[] = { std::move(k0), std::move(krest)... };

    const char* arg = argp[0];
    if (!arg) return nothing;

    for (const key& k: keys) {
        if (k.label==arg) {
            ++argp;
            return true;
        }
    }
    return nothing;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
leaq 0x10(%rdx), %rax
cmpq %rax, %rsi
je 0x186d
movq %rsi, (%rsp)
movq (%rax), %rsi
movq %rsi, 0x10(%rsp)
jmp 0x1874
movups (%rax), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rdx), %rsi
leaq 0x28(%rsp), %rdi
movq %rsi, -0x20(%rdi)
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
movl 0x20(%rdx), %eax
movl %eax, -0x8(%rdi)
movq %rcx, %rsi
callq 0x192c
movq (%r14), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x18c6
xorl %r12d, %r12d
leaq (%rsp,%r12), %rdi
movq %r15, %rsi
callq 0x1040
testl %eax, %eax
je 0x18ca
addq $0x28, %r12
cmpq $0x50, %r12
jne 0x18ac
xorl %eax, %eax
jmp 0x18d0
addq $0x8, (%r14)
movb $0x1, %al
movb %al, (%rbx)
movq $-0x50, %r14
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x18f2
movq (%r15), %rsi
incq %rsi
callq 0x10e0
addq $-0x28, %r15
addq $0x28, %r14
jne 0x18de
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1924
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10e0
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/ujjwal-ism[P]Jumping_game/gameUtil.cpp
// Function: GameUtil::compute(Square*, Player*)
int GameUtil::compute(Square* square, Player* player){
  
  double chi = player->getChi();
  double weight = player->getWeight();
  double teleporterEnergy = square->getTeleporterEnergy();
  double cannonPowder = square->getCannonPowder();

  double teleporterCompute = 0;
  for(int i = 0; i <= ((int)chi);i++){
    teleporterCompute += sqrt(chi * i * teleporterEnergy);
  }
  teleporterCompute *= 1.0/(1.0 + chi);

  double a= pow(cannonPowder,1.7);
  double b= pow(weight,1.5);
  double t=a/b;
  double cannonCompute = pow(t,2)/9.8;

  return std::max(cannonCompute > teleporterCompute ? cannonCompute : teleporterCompute, 1.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdx, %rdi
callq 0x1cca
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x1cc0
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x2306
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x22fc
movsd -0x28(%rbp), %xmm1
movsd %xmm0, -0x30(%rbp)
cvttsd2si %xmm1, %ebx
testl %ebx, %ebx
js 0x1489
incl %ebx
xorpd %xmm3, %xmm3
movsd 0x1bd8(%rip), %xmm4     # 0x3008
xorpd %xmm5, %xmm5
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm5, %xmm0
mulsd -0x20(%rbp), %xmm0
ucomisd %xmm3, %xmm0
jb 0x1451
sqrtsd %xmm0, %xmm0
jmp 0x147b
movsd %xmm2, -0x18(%rbp)
movsd %xmm5, -0x40(%rbp)
callq 0x1090
movsd -0x40(%rbp), %xmm5
movsd 0x1b9b(%rip), %xmm4     # 0x3008
xorpd %xmm3, %xmm3
movsd -0x18(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm2
addsd %xmm4, %xmm5
decl %ebx
jne 0x1438
jmp 0x148d
xorpd %xmm2, %xmm2
movsd 0x1b73(%rip), %xmm0     # 0x3008
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x1b62(%rip), %xmm1     # 0x3010
movsd -0x30(%rbp), %xmm0
callq 0x1130
movsd %xmm0, -0x18(%rbp)
movsd 0x1b53(%rip), %xmm1     # 0x3018
movsd -0x38(%rbp), %xmm0
callq 0x1130
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
divsd 0x1b3c(%rip), %xmm1     # 0x3020
maxsd -0x20(%rbp), %xmm1
movsd 0x1b17(%rip), %xmm0     # 0x3008
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ujjwal-ism[P]Jumping_game/gameUtil.cpp
// Function: GameUtil::isValidPath(std::vector<int, std::allocator<int>>&, Player*, Game*)
bool GameUtil::isValidPath(std::vector<int>& path, Player* player, Game* game){
  std::vector<Square*> board;
  board=game->getBoard();

  if(path[0] !=0)
    return false;
  if(path[path.size()-1] !=board.size()-1)
    return false;

  int prev=0;
  int totaldist = board.size()-1;
  for (int i = 1; i < path.size(); ++i)
  {
      int p=path[i];
      if(p<prev)
        return false;
      if(p>totaldist)
        return false;

      int distance = p-prev;
      if(distance > compute(board[prev],player))
        return false;
      prev = p;
  }

    return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x58(%rbp)
movq %rsi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rcx, %rdi
callq 0x1326
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x19a4
movq (%r12), %rax
cmpl $0x0, (%rax)
movq -0x50(%rbp), %rdi
jne 0x15d8
movq 0x8(%r12), %rcx
movslq -0x4(%rcx), %rdx
movq -0x48(%rbp), %r8
subq %rdi, %r8
sarq $0x3, %r8
movq %r8, -0x30(%rbp)
leaq -0x1(%r8), %rsi
cmpq %rdx, %rsi
jne 0x15d8
subq %rax, %rcx
movb $0x1, %r15b
cmpq $0x5, %rcx
jb 0x15db
movq -0x30(%rbp), %rcx
decl %ecx
movq %rcx, -0x30(%rbp)
xorl %ecx, %ecx
movl $0x1, %r13d
xorl %r15d, %r15d
movl (%rax,%r13,4), %r14d
movl %r14d, %ebx
subl %ecx, %ebx
jl 0x1601
cmpl -0x30(%rbp), %r14d
jg 0x1601
movl %ecx, %eax
movq -0x50(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq -0x58(%rbp), %rdx
callq 0x13d0
cmpl %eax, %ebx
jg 0x15fe
incq %r13
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movl %r14d, %ecx
cmpq %r13, %rdx
ja 0x1590
movb $0x1, %r15b
jmp 0x1601
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x15ec
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x10d0
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq -0x50(%rbp), %rdi
jmp 0x15db
jmp 0x1609
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1621
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O3/ujjwal-ism[P]Jumping_game/gameUtil.cpp
// Function: GameUtil::max_distance(int, int*, int)
int GameUtil::max_distance(int index,int board_passed[],int size){
  int prev = -1;
  int loc;
  for (int i = index+1; i <=index+board_passed[index]; ++i)
  {
    if(index+board_passed[i] > prev){
      if(index+board_passed[i] >= size-1){
        return i;
      }
      prev = index+board_passed[i];
      loc = i;
    }
  }
  return loc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
decl %ecx
movslq %esi, %rdi
movslq (%rdx,%rdi,4), %r8
addq %rdi, %r8
leal 0x1(%rdi), %r9d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl 0x4(%rdx,%rdi,4), %r11d
addl %esi, %r11d
cmpl %r10d, %r11d
jle 0x165c
movl %r11d, %r10d
movl %r9d, %eax
cmpl %ecx, %r11d
jge 0x1669
incq %rdi
incl %r9d
cmpq %r8, %rdi
jl 0x1644
jmp 0x166c
movl %r9d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jackz314[P]bars-to-bwav/./bars-to-bwav.cpp
// Function: createDirIfNotExist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool createDirIfNotExist(const string& pathToCreate){
    //create output directory if it doesn't exist
    filesystem::path dir(pathToCreate);
    if(!filesystem::exists(dir)){
        if(!filesystem::create_directory(dir)){
            cout << "Failed to create directory: " << pathToCreate << endl;
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x1b234
movq %r14, %rdi
callq 0xaa940
movb $0x1, %r14b
cmpb $-0x1, %al
je 0x18624
movzbl %al, %eax
testl %eax, %eax
jne 0x18689
leaq -0x38(%rbp), %rdi
callq 0xaa5d0
testb %al, %al
jne 0x18689
leaq 0xf7ec8(%rip), %rdi     # 0x110500
leaq 0xb79c5(%rip), %rsi     # 0xd0004
movl $0x1c, %edx
callq 0x84f20
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0xf7ea9(%rip), %rdi     # 0x110500
callq 0x84f20
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x66070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x84a20
movq %rax, %rdi
callq 0x83ff0
xorl %r14d, %r14d
leaq -0x38(%rbp), %rdi
callq 0x1b2b4
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1b2b4
movq %rbx, %rdi
callq 0x137c0
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/fastHASHSolver.cc
// Function: FastHASHSolver::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int FastHASHSolver::solveDNA(string DNA) {
	assert(DNA.length() == readLength);

	for (int i = 0; i < readLength / seedLength; i++) {
		string seed = DNA.substr(i * seedLength, seedLength);

		tree.query(seed);
		seedFreq[i] = tree.frequency();
	}

	sort(seedFreq.begin(), seedFreq.end() );

#ifdef DEBUG	
	for (int i = 0; i < readLength / seedLength; i++)
		cout << seedFreq[i] << " ";

	cout << endl;
#endif

	unsigned int totalFreq = 0;
	for (int i = 0; i < seedNum; i++)
		totalFreq += seedFreq[i];

	return totalFreq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x370(%rdi), %eax
cmpq %rax, 0x8(%rsi)
jne 0x47a7
movq %rdi, %rbx
movl 0x378(%rdi), %ecx
cmpl %eax, %ecx
ja 0x473e
movq %rsi, %r14
leaq 0x18(%rbx), %r15
leaq 0x38(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x28(%rsp), %r13
movl %r12d, %edx
imull %ecx, %edx
movl %ecx, %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3290
movq %rbp, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x41ec
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x5d54
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x46f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r15, %rdi
callq 0x5edc
movq (%rbx), %rcx
movl %eax, (%rcx,%r12,4)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4722
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
incq %r12
movl 0x370(%rbx), %eax
movl 0x378(%rbx), %ecx
xorl %edx, %edx
divl %ecx
cmpq %rax, %r12
jb 0x46a1
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x4777
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x49a9
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a8c
movl 0x374(%rbx), %ecx
testq %rcx, %rcx
je 0x4796
movq (%rbx), %rdx
xorl %esi, %esi
xorl %eax, %eax
addl (%rdx,%rsi,4), %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x4789
jmp 0x4798
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5909(%rip), %rdi      # 0xa0b7
leaq 0x591d(%rip), %rsi      # 0xa0d2
leaq 0x5928(%rip), %rcx      # 0xa0e4
movl $0x18, %edx
callq 0x3190
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x47e5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x47e5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4801
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/gpp.cpp
// Function: (anonymous namespace)::usage()
void usage() {
        fprintf(stderr, "Usage:\n");
        fprintf(stderr, "  gpp < FILE\n");
        fprintf(stderr, "  echo MACROS | gpp\n");
        fprintf(stderr, "\n");
        fprintf(stderr, "      macro syntax overview:    #define x y           macro(arg,...)\n");
        fprintf(stderr, "\n");
        fprintf(stderr, " --version  : display version information and exit\n");
        fprintf(stderr, " -h, --help : display this message and exit\n\n");
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x9d9d(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5e03(%rip), %rdi      # 0x8048
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5df3(%rip), %rdi      # 0x8050
pushq $0xd
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5dec(%rip), %rdi      # 0x805e
pushq $0x14
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rsi
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x2130
movq (%r14), %rcx
leaq 0x5ddf(%rip), %rdi      # 0x8073
pushq $0x45
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rsi
movl %ebp, %edi
callq 0x2130
movq (%r14), %rcx
leaq 0x5e06(%rip), %rdi      # 0x80b9
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5e25(%rip), %rdi      # 0x80ed
pushq $0x2d
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/gpp.cpp
// Function: main.cold.1
void display_version() {
        fprintf(stderr, PACKAGE_STRING "\n");
        fprintf(stderr, "Copyright (C) 1996-2001 Denis Auroux\n");
        fprintf(stderr, "Copyright (C) 2003-2017 Tristan Miller\n");
        fprintf(stderr, "Copyright (C) 2018 Giumo Clanjor\n");
        fprintf(stderr,
            "This is free software; see the source for copying conditions.  There is NO\n"
            "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
        );
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9cf6(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5e2f(%rip), %rdi      # 0x811b
pushq $0x20
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5e38(%rip), %rdi      # 0x813c
pushq $0x25
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5e49(%rip), %rdi      # 0x8162
pushq $0x27
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5e5c(%rip), %rdi      # 0x818a
pushq $0x21
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r14), %rcx
leaq 0x5e69(%rip), %rdi      # 0x81ac
movl $0x97, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/gpp.cpp
// Function: main
int main(int argc, char *argv[]) try
{
    (void) argc;

    for (auto arg = argv + 1; *arg; arg++) {
        if (strcmp(*arg, "--help") == 0 || strcmp(*arg, "-h") == 0) {
            usage();
            return EXIT_SUCCESS;
        }

        if (strcmp(*arg, "--version") == 0) {
            display_version();
            return EXIT_SUCCESS;
        }

        usage();
        return EXIT_FAILURE;
    }

    libgpp::preprocess_stdin_to_stdout();
}
catch (std::exception const& e) {
    fprintf(stderr, "\e[1;31m ERROR \e[0m %s\n", e.what());
    return EXIT_FAILURE;
}
catch (...) {
    fprintf(stderr, "\e[1;31m UNKNOWN ERROR \e[0m\n");
    return EXIT_FAILURE;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
jne 0x2571
xorl %ebx, %ebx
callq 0x25f4
movl %ebx, %eax
popq %rbx
retq
leaq 0x5a8c(%rip), %rsi      # 0x8004
movq %rbx, %rdi
callq 0x2170
testl %eax, %eax
jne 0x258b
callq 0x2230
jmp 0x25b4
cmpb $0x2d, (%rbx)
jne 0x259c
cmpb $0x68, 0x1(%rbx)
jne 0x259c
cmpb $0x0, 0x2(%rbx)
je 0x2584
leaq 0x5a68(%rip), %rsi      # 0x800b
movq %rbx, %rdi
callq 0x2170
testl %eax, %eax
jne 0x25b8
callq 0x22d7
xorl %ebx, %ebx
jmp 0x256d
callq 0x2230
movl $0x1, %ebx
jmp 0x256d
movq %rdx, %rbx
movq %rax, %rdi
callq 0x2050
movq 0x9a02(%rip), %rcx      # 0xbfd8
movq (%rcx), %rsi
cmpl $0x2, %ebx
jne 0x25e8
movq %rax, %rdi
callq 0x2357
jmp 0x25bd
movq %rsi, %rdi
callq 0x237b
jmp 0x25bd
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/TrueBestFirstStack.cpp
// Function: TrueBestFirstStack::push(Node*)
void TrueBestFirstStack::push(Node* n) {
	fprintf(stderr,"\n");
	fprintf(stderr,"Error - this stack does not support basic use\n");
	fprintf(stderr,"      - True Best First push need att cand list\n");
	fprintf(stderr,"\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x1c520(%rip), %r15     # 0x1ffd8
movq (%r15), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x3270
movq (%r15), %rcx
leaq 0x130e1(%rip), %rdi     # 0x16bb0
pushq $0x2e
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x3360
movq (%r15), %rcx
leaq 0x130f7(%rip), %rdi     # 0x16bdf
pushq $0x30
popq %rsi
movq %r14, %rdx
callq 0x3360
movq (%r15), %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Logs.h
// Function: Logs::Logs(char*, unsigned int)
Logs(char* p = NULL, unsigned int c = 0) {
		counter = c;
		if (p == NULL) {
			_main = stdout;
		//	_err = stderr;
			_roc = stdout;
			_varimp = stdout;
			_groupimp = stdout;
			_dot = stdout;
			_tree = stdout;
			init();
		} else {
			prefix = p;
			prefixit();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r12
movq %r12, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movb $0x0, 0x40(%rdi)
movl %edx, 0x50(%rdi)
testq %rsi, %rsi
je 0x641e
movq %rsi, %r15
leaq 0x30(%rbx), %r14
movq %rsi, %rdi
callq 0x3100
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x32c0
movq %rbx, %rdi
callq 0x6d8e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x19b8b(%rip), %rax     # 0x1ffb0
movq (%rax), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6d2e
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x6466
movq (%r12), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Sampler.h
// Function: Sampler::readStartEndSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::vector<unsigned int> readStartEndSet(std::string file) {
		std::vector<unsigned int> ret;
		std::ifstream fs(file.c_str());
		if (!fs) {
			fprintf(stderr, "ReadStartEndSet() Error : Cannot find file %s\n",file.c_str());
			return ret;
		}
		std::string line;
		int ln = 0;
		while (getline(fs, line)) {
			std::vector<std::string> ex = StrTools::explode(line,const_cast<char *>("\t"));
			// treat ex and pushback start to end...
			if (ex.size() == 2) {
				int start = atoi(ex[0].c_str());
				int end = atoi(ex[1].c_str());
				for (int i = start ; i <= end ; ++i)
					ret.push_back(i);
			} else {
				fprintf(stderr, "ReadStartEndSet() Error : Incorrect file format ?\n");
			}
			++ln;
		}
		fs.close();
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq -0x270(%rbp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x65f9
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x50(%rbp), %r15
leaq -0x68(%rbp), %r14
leaq (%rax,%rbp), %rdi
addq $-0x270, %rdi           # imm = 0xFD90
movl $0xa, %esi
callq 0x31e0
movsbl %al, %edx
leaq -0x270(%rbp), %rdi
movq %r15, %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x65b3
movq %r14, %rdi
movq %r15, %r12
movq %r15, %rsi
leaq 0x102ef(%rip), %rdx     # 0x16815
callq 0x6eae
movq %r14, %r15
movq -0x68(%rbp), %r13
movq -0x60(%rbp), %rax
subq %r13, %rax
cmpq $0x40, %rax
jne 0x65ac
movq (%r13), %rdi
callq 0x32d0
movl %eax, %r14d
movq 0x20(%r13), %rdi
callq 0x32d0
cmpl %eax, %r14d
jg 0x658e
movl %eax, %r13d
incl %r13d
movl %r14d, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x657a
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6586
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x729c
incl %r14d
cmpl %r14d, %r13d
jne 0x655f
movq %r15, %r14
movq %r15, %rdi
callq 0x6fa8
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
movq %r12, %r15
jmp 0x64dd
callq 0x33a4
jmp 0x658e
leaq -0x270(%rbp), %rdi
callq 0x3070
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x65d8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3380
jmp 0x65d8
jmp 0x6607
jmp 0x6607
movq %rax, %r14
jmp 0x6618
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x6fa8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6631
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6651
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Sampler.h
// Function: Sampler::readSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::vector<unsigned int> readSet(std::string file) {
		std::vector<unsigned int> ret;
		std::ifstream fs(file.c_str());
		if (!fs) {
			fprintf(stderr, "ReadSet() Error : Cannot find file %s\n",file.c_str());
			return ret;
		}
		std::string line;
		int ln = 0;
		while (getline(fs, line)) {
			std::vector<std::string> ex = StrTools::explode(line,const_cast<char *>("\t"));
			// treat ex and pushback...
			if (ex.size() > 0) {
				for (int i = 0 ; i < ex.size(); ++i)
					ret.push_back(atoi(ex[i].c_str()));
			} else {
				fprintf(stderr, "ReadSet() Error : Incorrect file format ?\n");
			}
			++ln;
		}
		fs.close();
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq -0x270(%rbp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x67e0
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r15
leaq (%rax,%rbp), %rdi
addq $-0x270, %rdi           # imm = 0xFD90
movl $0xa, %esi
callq 0x31e0
movsbl %al, %edx
leaq -0x270(%rbp), %rdi
movq %r14, %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x679a
movq %r15, %rdi
movq %r14, %rsi
leaq 0x10106(%rip), %rdx     # 0x16815
callq 0x6eae
movq -0x48(%rbp), %r15
movq -0x40(%rbp), %r12
cmpq %r15, %r12
je 0x6793
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r15,%r14), %rdi
callq 0x32d0
movl %eax, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6749
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x675d
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x729c
movq -0x48(%rbp), %r15
movq -0x40(%rbp), %r12
incq %r13
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
addq $0x20, %r14
cmpq %r13, %rax
ja 0x6727
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x6fa8
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x68(%rbp), %r14
jmp 0x66c9
callq 0x33ea
jmp 0x6773
leaq -0x270(%rbp), %rdi
callq 0x3070
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x67bf
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x33c6
jmp 0x67bf
jmp 0x67ee
jmp 0x67ee
movq %rax, %r14
jmp 0x67ff
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x6fa8
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x6818
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6838
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./RandomForest.h
// Function: RandomForest::print(_IO_FILE*)
void print(FILE* out = stdout) { 
		Learner::print(out); 
		fprintf(out,"RANDOMFOREST\n");
		fprintf(out,"K parameter : %d\n",k); 
		fprintf(out,"NbTrees : %d\n",nbtree); 
		//for (int i = 0 ; i < nbtree ; ++i) {
		//	fprintf(out,"___________________TREE %d INFOS\n",i+1);
		//	term[i]->print(out);
		//}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10a2c
leaq 0xfbe7(%rip), %rdi      # 0x1658e
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movl 0x5c(%r14), %edx
leaq 0xfbd8(%rip), %rsi      # 0x1659c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
movl 0x58(%r14), %edx
leaq 0xfbd5(%rip), %rsi      # 0x165ae
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./RandomTTForest.h
// Function: RandomTTForest::dotit(_IO_FILE*, int)
void dotit(FILE* out = stdout, int maxt = 0) {
		if (maxt == 0 || maxt > nbtree) { maxt = nbtree; }
		fprintf(out,"digraph G {\n");
		for (int i = 0 ; i < maxt ; ++i) {
			term[i]->dotit(out);
		}
		fprintf(out,"}\n");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x98(%rdi), %r15d
leal -0x1(%rdx), %eax
cmpl %r15d, %eax
cmovbl %edx, %r15d
leaq 0xf7ba(%rip), %rdi      # 0x163bc
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
testl %r15d, %r15d
jle 0x6c5a
movl %r15d, %r12d
xorl %r13d, %r13d
leaq 0xf965(%rip), %r15      # 0x1658b
movq 0xa0(%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0x1121e
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x3360
incq %r13
cmpq %r13, %r12
jne 0x6c26
leaq 0xf768(%rip), %rdi      # 0x163c9
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./RandomTTForest.h
// Function: RandomTTForest::print(_IO_FILE*) const
void print(FILE* out = stdout) const { 
		GroupLearner::print(out);
		fprintf(out,"RANDOMTTFOREST\n");
		fprintf(out,"NbTree = %d\n",nbtree);
		//for (int i = 0 ; i < nbtree ; ++i) {
		//	fprintf(out,"___________________TREE %d INFOS\n",i+1);
		//	term[i]->print(out);
		//}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x76e0
leaq 0xfa20(%rip), %rdi      # 0x165c7
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movl 0x98(%r14), %edx
leaq 0xfa10(%rip), %rsi      # 0x165d7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Logs.h
// Function: Logs::~Logs()
~Logs() {
		fclose(_main);
		//fclose(_err);
		fclose(_roc);
		fclose(_varimp);
		fclose(_groupimp);
		fclose(_dot);
		fclose(_tree);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x31f0
movq 0x8(%rbx), %rdi
callq 0x31f0
movq 0x10(%rbx), %rdi
callq 0x31f0
movq 0x18(%rbx), %rdi
callq 0x31f0
movq 0x20(%rbx), %rdi
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0x31f0
movq 0x30(%rbx), %rdi
addq $0x40, %rbx
cmpq %rbx, %rdi
je 0x6d26
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3210
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Logs.h
// Function: Logs::init()
void init() {
		// write date into log
		time_t theTime;
		time( &theTime );
		tm *t = localtime( &theTime );
		fprintf(_main,"Time : %s",asctime(t));
		fprintf(_main,"Prefix output : %s\n",prefix.c_str());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3160
movq (%rbx), %r14
movq %rax, %rdi
callq 0x30f0
leaq 0xf6f1(%rip), %rsi      # 0x16453
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3290
movq (%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xf6e0(%rip), %rsi      # 0x1645d
xorl %eax, %eax
callq 0x3290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./Logs.h
// Function: Logs::prefixit()
void prefixit() {
		char tmp[256];
		sprintf(tmp, "%s_%04d.log",prefix.c_str(),counter);		_main = fopen(tmp,"wb");
		sprintf(tmp, "%s_%04d.roc",prefix.c_str(),counter);		_roc = fopen(tmp,"wb");
		sprintf(tmp, "%s_%04d.vim",prefix.c_str(),counter);		_varimp = fopen(tmp,"wb");
		sprintf(tmp, "%s_%04d.gim",prefix.c_str(),counter);		_groupimp = fopen(tmp,"wb");
		sprintf(tmp, "%s_%04d.dot",prefix.c_str(),counter);		_dot = fopen(tmp,"wb");
		sprintf(tmp, "%s_%04d.tree",prefix.c_str(),counter);		_tree = fopen(tmp,"wb");
		//sprintf(tmp, "%s_%04d.err",prefix.c_str(),counter);		_err = fopen(tmp,"wb");
		init();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
movl 0x50(%rdi), %ecx
leaq 0xf6c2(%rip), %rsi      # 0x16471
leaq -0x120(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
leaq 0xf6b6(%rip), %r15      # 0x1647d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, (%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf69d(%rip), %rsi      # 0x16480
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x8(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf682(%rip), %rsi      # 0x1648c
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x10(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf667(%rip), %rsi      # 0x16498
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x18(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf64c(%rip), %rsi      # 0x164a4
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf631(%rip), %rsi      # 0x164b0
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6d2e
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./StrTools.h
// Function: StrTools::explode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char*)
static std::vector<std::string> explode(std::string &str, char* delim) {
		std::vector<std::string> ret;
		char* strcopy = new char[str.size()+1];
		strcpy(strcopy,str.c_str());
		char* result = strtok(strcopy,delim);
		while (result != NULL) {
			//fprintf(stderr,"[%s]",result);
			ret.push_back((std::string)result);
			result = strtok(NULL, delim);
		}
		delete[] strcopy;
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
incq %rdi
callq 0x3030
movq %rax, %r15
movq (%r12), %rsi
movq %rax, %rdi
callq 0x31c0
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x32e0
testq %rax, %rax
je 0x6f5d
movq %rax, %r13
leaq -0x40(%rbp), %r15
leaq -0x50(%rbp), %r12
movq %r15, -0x50(%rbp)
movq %r13, %rdi
callq 0x3100
leaq (%rax,%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x7834
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7016
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x6f4b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
xorl %edi, %edi
movq %r14, %rsi
callq 0x32e0
movq %rax, %r13
testq %rax, %rax
jne 0x6f10
movq -0x30(%rbp), %rdi
callq 0x3280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f7a
movq %rax, %r14
jmp 0x6f97
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x6f97
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x6fa8
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/./GroupLearner.h
// Function: GroupLearner::print(_IO_FILE*) const
void print(FILE* out = stdout) const {
		Learner::print(out);
		fprintf(out,"Internal Complexity = %d\n",internalComp);
		fprintf(out,"Internal K = %d\n",kint);
		fprintf(out,"########## Group Candidate Attributes :\n");
		for (int i = 0 ; i < groupcand.size() ; ++i)
			fprintf(out,"%d ",groupcand[i]);
		fprintf(out,"\n");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10a2c
movl 0x58(%r14), %edx
leaq 0xeee3(%rip), %rsi      # 0x165e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
movl 0x5c(%r14), %edx
leaq 0xeee8(%rip), %rsi      # 0x165fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
leaq 0xeee8(%rip), %rdi      # 0x1660f
movl $0x28, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movq 0x80(%r14), %rax
cmpq %rax, 0x88(%r14)
je 0x7781
leaq 0xeee8(%rip), %r15      # 0x16638
xorl %r12d, %r12d
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3290
incq %r12
movq 0x80(%r14), %rax
movq 0x88(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x7753
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/BestFirstStack.cpp
// Function: BestFirstStack::push(Node*)
void BestFirstStack::push(Node* n) {
	n->setId(nbpush++);
	std::vector<unsigned int> set = n->getLS();
	//printf("Node Size : %d\n",set.size());
	double total = 0.0;
	std::vector<double> sum(2,0.0);
	for (int i = 0 ; i < set.size() ; ++i) {
		total += db->getWeight(set[i]);
		sum[db->getOutput(set[i])] += db->getWeight(set[i]);
	}
	Score score;
	double hc = score.getShannonEntropy(sum,total) * total;
	if (hc > 0.0) {
	std::vector<double>::iterator it;
	std::vector< Node* >::iterator itn;
	for( it = values.begin(), itn = s.begin() ; it != values.end(); it++, itn++ )    {
		if (hc <= *it) 
			break;
	}
	values.insert(it,hc);
	
	s.insert(itn,n);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, 0x48(%rsp)
leaq 0x187ea(%rip), %rax     # 0x201ec
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x50(%rsi)
leaq 0x20(%rsp), %rdi
callq 0x7b86
movl $0x10, %edi
callq 0x3200
movq %rax, 0x8(%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x18(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
subq %rcx, %rdx
je 0x7a95
sarq $0x2, %rdx
movq 0x18(%rbx), %rdi
movq 0x8(%rdi), %rsi
movq 0x28(%rdi), %rdi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movl (%rcx,%r8,4), %r9d
movsd (%rsi,%r9,8), %xmm1
addsd %xmm1, %xmm0
movswq (%rdi,%r9,2), %r9
addsd (%rax,%r9,8), %xmm1
movsd %xmm1, (%rax,%r9,8)
incq %r8
cmpq %r8, %rdx
jne 0x7a6c
jmp 0x7a99
xorpd %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x54(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x1326a
movsd 0x38(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rsp)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x7b10
leaq 0x20(%rbx), %rdi
movq (%rbx), %r14
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rax
cmpq %rax, %rsi
je 0x7af6
movsd (%rsi), %xmm0
ucomisd %xmm1, %xmm0
jae 0x7af6
addq $0x8, %rsi
addq $0x8, %r14
jmp 0x7add
leaq 0x40(%rsp), %rdx
callq 0x7c06
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c9a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b27
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7b3e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x7b48
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b67
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
jmp 0x7b67
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7b7e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/BlockDB.cpp
// Function: BlockDB::selectAllGroup() const
std::vector<unsigned int> BlockDB::selectAllGroup() const {
	std::vector<unsigned int> ret;
	for (int i = 0 ; i < nbGroup ; ++i)
		ret.push_back(i);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x0, 0x58(%rsi)
je 0x8069
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
movl %ebp, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8056
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8061
movq %rbx, %rdi
movq %r15, %rdx
callq 0x729c
incl %ebp
cmpl 0x58(%r14), %ebp
jb 0x803c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x808e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/BlockDB.cpp
// Function: BlockDB::print(_IO_FILE*, bool) const
void BlockDB::print(FILE* out, bool all) const {
	DB::print(out,all);
	fprintf(out,"########## Groups Att. :\n");
	for (int i = 0 ; i < nbGroup ; ++i) {
		for (int j = 0 ; j < groups[i].size() ; ++j)
			fprintf(out,"%d ",groups[i][j]);
		fprintf(out,"\n");
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd7b2
leaq 0xe5f9(%rip), %rdi      # 0x166ac
movl $0x19, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
cmpl $0x0, 0x58(%r14)
je 0x8130
leaq 0xe565(%rip), %r15      # 0x16638
xorl %r12d, %r12d
movq 0x60(%r14), %rcx
leaq (%r12,%r12,2), %r13
movq (%rcx,%r13,8), %rax
cmpq %rax, 0x8(%rcx,%r13,8)
je 0x8117
xorl %ebp, %ebp
movl (%rax,%rbp,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3290
incq %rbp
movq 0x60(%r14), %rcx
movq (%rcx,%r13,8), %rax
movq 0x8(%rcx,%r13,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x80eb
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3270
incq %r12
movl 0x58(%r14), %eax
cmpq %rax, %r12
jb 0x80d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop