LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: qrmloadset(int*, int)
int qrmloadset(int *m,int jo){ //c番目を読む
    FILE *fp;
    long long int qsize = std::filesystem::file_size(qname); //qsizeには，ファイルのサイズが書かれているはず
    fp = fopen(qname,"r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int c = qsize/querysuu;
    fseek(fp,jo*c,SEEK_SET); //指定したシークまで移動する
    for(int i=0;i<c;i++) { //c文字
        char chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        if(m[i]==10){jswt=1;}
        if(DEBUGFLAG==1){printf("%c",chr);}
    }
    printf("]");
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5572(%rip), %rsi      # 0xb200
movq %rsp, %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x720c
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
movq %rsp, %rdi
callq 0x7294
movq 0x5548(%rip), %rdi      # 0xb200
leaq 0x23ac(%rip), %rsi      # 0x806b
callq 0x2180
testq %rax, %rax
je 0x5d33
movq %rax, %r15
movslq 0x5481(%rip), %rcx      # 0xb154
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %r14
imull %r14d, %ebp
movslq %ebp, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2170
testl %r14d, %r14d
jle 0x5d27
movl %r14d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%rbx,%r13,4)
cmpl $0xa, %eax
jne 0x5d1f
movl $0x1, 0x57a1(%rip)      # 0xb4c0
incq %r13
cmpq %r13, %r12
jne 0x5d01
movl $0x5d, %edi
callq 0x21d0
jmp 0x5d4e
movq 0x54c6(%rip), %rsi      # 0xb200
leaq 0x232c(%rip), %rdi      # 0x806d
xorl %eax, %eax
callq 0x2030
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7294
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53bd(%rip), %rsi      # 0xb200
movq %rsp, %r15
movq %r15, %rdi
movl $0x2, %edx
callq 0x720c
movq %r15, %rdi
callq 0x21c0
movq %rax, %r13
movq %rsp, %rdi
callq 0x7294
movq 0x5393(%rip), %rdi      # 0xb200
leaq 0x21f7(%rip), %rsi      # 0x806b
callq 0x2180
testq %rax, %rax
je 0x5f1c
movq %rax, %r15
movl $0x0, 0x5631(%rip)      # 0xb4c0
callq 0x2060
cltq
movslq %ebx, %rcx
movq %r13, %rsi
subq %rcx, %rsi
cqto
idivq %rsi
cmpl $0x2, 0x52a1(%rip)      # 0xb14c
jne 0x5eb3
movl 0x52a5(%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 0x22b6(%rip), %rdi      # 0x8187
movl %r12d, %esi
movl %ebx, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2030
testl %ebx, %ebx
jle 0x5f10
movl %ebx, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%r14,%r13,4)
cmpl $0xa, %eax
jne 0x5f08
movl $0x1, 0x55b8(%rip)      # 0xb4c0
incq %r13
cmpq %r13, %r12
jne 0x5eea
movl $0x5d, %edi
callq 0x21d0
jmp 0x5f36
movq 0x52dd(%rip), %rsi      # 0xb200
leaq 0x2143(%rip), %rdi      # 0x806d
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 0x7294
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60a6
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 0x60a6
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 0x60a5
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 0x60a5
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 0x60a5
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 0x60a5
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 0x60a5
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_O1/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 0x5146(%rip), %rsi      # 0xb200
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x720c
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7294
movq 0x5118(%rip), %rdi      # 0xb200
leaq 0x1f7c(%rip), %rsi      # 0x806b
callq 0x2180
movq %rax, %r14
movl 0x5113(%rip), %edx      # 0xb210
movl 0x5111(%rip), %ecx      # 0xb214
leaq 0x209f(%rip), %rdi      # 0x81a9
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movslq 0x50f5(%rip), %rsi      # 0xb210
movq %r14, %rdi
xorl %edx, %edx
callq 0x2170
cmpl $0x0, 0x50e8(%rip)      # 0xb214
jle 0x614f
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2200
movzbl %al, %eax
movl %eax, (%rbx,%r15,4)
incq %r15
movslq 0x50ca(%rip), %rax      # 0xb214
cmpq %rax, %r15
jl 0x6131
movl $0x5d, %edi
callq 0x21d0
movl 0x50b5(%rip), %eax      # 0xb214
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7294
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x227d(%rip), %rdi      # 0x8403
callq 0x21f0
leaq 0x2292(%rip), %rdi      # 0x8424
callq 0x21f0
leaq 0x22b7(%rip), %rdi      # 0x8455
callq 0x21f0
leaq 0x22ce(%rip), %rdi      # 0x8478
callq 0x21f0
leaq 0x22f2(%rip), %rdi      # 0x84a8
callq 0x21f0
leaq 0x2318(%rip), %rdi      # 0x84da
callq 0x21f0
leaq 0x2346(%rip), %rdi      # 0x8514
callq 0x21f0
leaq 0x2374(%rip), %rdi      # 0x854e
callq 0x21f0
leaq 0x23a4(%rip), %rdi      # 0x858a
callq 0x21f0
leaq 0x23ce(%rip), %rdi      # 0x85c0
callq 0x21f0
leaq 0x23f7(%rip), %rdi      # 0x85f5
callq 0x21f0
leaq 0x2432(%rip), %rdi      # 0x863c
callq 0x21f0
leaq 0x245e(%rip), %rdi      # 0x8674
callq 0x21f0
leaq 0x2488(%rip), %rdi      # 0x86aa
callq 0x21f0
movl $0xa, %edi
callq 0x21d0
movl $0xa, %edi
callq 0x21d0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18f0
movq %rsi, (%rsp)
movq (%rax), %rsi
movq %rsi, 0x10(%rsp)
jmp 0x18f7
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 0x19b0
movq (%r14), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x1949
xorl %r12d, %r12d
leaq (%rsp,%r12), %rdi
movq %r15, %rsi
callq 0x1040
testl %eax, %eax
je 0x194d
addq $0x28, %r12
cmpq $0x50, %r12
jne 0x192f
xorl %eax, %eax
jmp 0x1953
addq $0x8, (%r14)
movb $0x1, %al
movb %al, (%rbx)
movq $-0x50, %r14
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x1975
movq (%r15), %rsi
incq %rsi
callq 0x10e0
addq $-0x28, %r15
addq $0x28, %r14
jne 0x1961
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 0x19a7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10e0
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cc6
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x1cbc
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x230a
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x2300
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_O1/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, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rcx, %rdi
callq 0x1326
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x19b0
movq (%r14), %rax
cmpl $0x0, (%rax)
jne 0x15df
movq 0x8(%r14), %rax
movq -0x48(%rbp), %r12
subq -0x50(%rbp), %r12
movslq -0x4(%rax), %rax
sarq $0x3, %r12
leaq -0x1(%r12), %rcx
cmpq %rax, %rcx
jne 0x15df
movq %rbx, -0x58(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
setb %r15b
jb 0x15e2
decl %r12d
xorl %esi, %esi
movl $0x1, %r13d
movl (%rax,%r13,4), %ebx
xorl %eax, %eax
movl %ebx, %r15d
subl %esi, %r15d
jl 0x15bf
cmpl %r12d, %ebx
jg 0x15bf
movl %esi, -0x2c(%rbp)
movl %esi, %eax
movq -0x50(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq -0x58(%rbp), %rdx
callq 0x13d0
cmpl %eax, %r15d
setle %al
jle 0x15bd
movl -0x2c(%rbp), %ebx
movl %ebx, %esi
testb %al, %al
je 0x15df
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
setbe %r15b
ja 0x1589
jmp 0x15e2
xorl %r15d, %r15d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x15f7
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
jmp 0x160b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1623
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x165e
movl %r11d, %r10d
movl %r9d, %eax
cmpl %ecx, %r11d
jge 0x166b
incq %rdi
incl %r9d
cmpq %r8, %rdi
jl 0x1646
jmp 0x166e
movl %r9d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b336
movq %r14, %rdi
callq 0xaaa10
movb $0x1, %r14b
cmpb $-0x1, %al
je 0x18624
movzbl %al, %eax
testl %eax, %eax
jne 0x18689
leaq -0x38(%rbp), %rdi
callq 0xaa6a0
testb %al, %al
jne 0x18689
leaq 0xf7ec8(%rip), %rdi     # 0x110500
leaq 0xb79c5(%rip), %rsi     # 0xd0004
movl $0x1c, %edx
callq 0x84ff0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0xf7ea9(%rip), %rdi     # 0x110500
callq 0x84ff0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x66140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x84af0
movq %rax, %rdi
callq 0x840c0
xorl %r14d, %r14d
leaq -0x38(%rbp), %rdi
callq 0x1b3b6
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1b3b6
movq %rbx, %rdi
callq 0x137c0
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]optimal-seed-solver/fastHASHSolver.cc
// Function: FastHASHSolver::init(unsigned int, unsigned int, unsigned int)
void FastHASHSolver::init(unsigned int readLength, unsigned int seedNum, unsigned int seedLength) {
	this->seedNum = seedNum;
	this->seedLength = seedLength;
	this->readLength = readLength;

	seedFreq.resize(readLength / seedLength);
}

// Assembly:
movl %esi, %eax
movl %edx, 0x374(%rdi)
movl %ecx, 0x378(%rdi)
movl %esi, 0x370(%rdi)
xorl %edx, %edx
divl %ecx
movq %rax, %rsi
jmp 0x47fe
// File: /workspace/github_cpp_makefile_star2_O1/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 0x479b
movq %rdi, %rbx
movl 0x378(%rdi), %ecx
cmpl 0x370(%rdi), %ecx
ja 0x4732
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 0x41e6
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x5dc2
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x46eb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r15, %rdi
callq 0x5f60
movq (%rbx), %rcx
movl %eax, (%rcx,%r12,4)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4716
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 0x4695
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x476b
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 0x4997
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a7a
movl 0x374(%rbx), %ecx
testq %rcx, %rcx
je 0x478a
movq (%rbx), %rdx
xorl %esi, %esi
xorl %eax, %eax
addl (%rdx,%rsi,4), %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x477d
jmp 0x478c
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5915(%rip), %rdi      # 0xa0b7
leaq 0x5929(%rip), %rsi      # 0xa0d2
leaq 0x5934(%rip), %rcx      # 0xa0e4
movl $0x18, %edx
callq 0x3190
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x47d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x47d9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x47f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9dad(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5e16(%rip), %rdi      # 0x804b
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e06(%rip), %rdi      # 0x8053
pushq $0xd
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5dff(%rip), %rdi      # 0x8061
pushq $0x14
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rsi
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x2120
movq (%r14), %rcx
leaq 0x5df2(%rip), %rdi      # 0x8076
pushq $0x45
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rsi
movl %ebp, %edi
callq 0x2120
movq (%r14), %rcx
leaq 0x5e19(%rip), %rdi      # 0x80bc
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e38(%rip), %rdi      # 0x80f0
pushq $0x2d
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9d06(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5e42(%rip), %rdi      # 0x811e
pushq $0x20
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e4b(%rip), %rdi      # 0x813f
pushq $0x25
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e5c(%rip), %rdi      # 0x8165
pushq $0x27
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e6f(%rip), %rdi      # 0x818d
pushq $0x21
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5e7c(%rip), %rdi      # 0x81af
movl $0x97, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
xorl %ebx, %ebx
testq %r14, %r14
jne 0x25af
testq %r14, %r14
jne 0x25a5
callq 0x2640
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5a4e(%rip), %rsi      # 0x8004
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
je 0x25d5
leaq 0x5a42(%rip), %rsi      # 0x800b
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
jne 0x25dc
callq 0x2220
jmp 0x259b
leaq 0x5a2b(%rip), %rsi      # 0x800e
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
jne 0x25f6
callq 0x22c7
jmp 0x259b
callq 0x2220
movl $0x1, %ebx
jmp 0x259b
movq %rdx, %rbx
movq %rax, %rdi
callq 0x2050
movq 0x99c4(%rip), %rcx      # 0xbfd8
movq (%rcx), %rsi
cmpl $0x2, %ebx
jne 0x2626
movq %rax, %rdi
callq 0x2347
jmp 0x262e
movq %rsi, %rdi
callq 0x2366
callq 0x21b0
movl $0x1, %ebx
jmp 0x25a5
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/0asa[P]TTree-source/ContingencyTable.cpp
// Function: ContingencyTable::print()
void ContingencyTable::print() {  
  for (int i = 0 ; i < nbclass ; i++) 
    std::cout << less[i] << "\t";
  std::cout << std::endl;
  for (int i = 0 ; i < nbclass ; i++) 
    std::cout << geq[i] << "\t";
  std::cout << std::endl;
	fprintf(stderr,"- - - - - - - - -\n");
	for (int s = 0 ; s < nbsymbol ; ++s) {
		for (int c = 0 ; c < nbclass ; ++c) {
			fprintf(stderr,"%1.0f\t",table[c][s]);
		}
		fprintf(stderr,"\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x3529
xorl %r13d, %r13d
movq 0x1cadd(%rip), %r14     # 0x1ffd0
leaq 0x1331b(%rip), %r15     # 0x16815
pushq $0x1
popq %r12
movq 0x20(%rbx), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x32f0
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3230
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x34fe
movq 0x1caa0(%rip), %r14     # 0x1ffd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3140
cmpl $0x0, (%rbx)
jle 0x3598
xorl %ebp, %ebp
movq 0x1ca6d(%rip), %r15     # 0x1ffd0
leaq 0x132ab(%rip), %r12     # 0x16815
pushq $0x1
popq %r13
movq 0x38(%rbx), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x32f0
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3230
incq %rbp
movslq (%rbx), %rax
cmpq %rax, %rbp
jl 0x356e
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3140
movq 0x1ca14(%rip), %r15     # 0x1ffd8
movq (%r15), %rcx
leaq 0x131f2(%rip), %rdi     # 0x167c0
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x3360
cmpl $0x0, 0x4(%rbx)
jle 0x3634
xorl %r12d, %r12d
leaq 0x131ea(%rip), %r14     # 0x167d3
cmpl $0x0, (%rbx)
jle 0x361d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r13), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x3290
incq %rbp
movslq (%rbx), %rax
addq $0x18, %r13
cmpq %rax, %rbp
jl 0x35f3
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3270
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x35e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c538(%rip), %r15     # 0x1ffd8
movq (%r15), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x3270
movq (%r15), %rcx
leaq 0x130f9(%rip), %rdi     # 0x16bb0
pushq $0x2e
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x3360
movq (%r15), %rcx
leaq 0x1310f(%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_O1/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 0x63e0
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 0x6d50
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x19bc9(%rip), %rax     # 0x1ffb0
movq (%rax), %rcx
movq %rcx, (%rbx)
movq (%rax), %rax
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 0x6cf0
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x642b
movq (%r12), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x65a9
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6563
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
leaq 0x1032c(%rip), %rdx     # 0x16815
callq 0x6e70
movq -0x68(%rbp), %r13
movq -0x60(%rbp), %rax
subq %r13, %rax
cmpq $0x40, %rax
jne 0x655c
movq (%r13), %rdi
callq 0x32d0
movl %eax, %r14d
movq 0x20(%r13), %rdi
callq 0x32d0
cmpl %eax, %r14d
jg 0x654e
movl %eax, %r13d
incl %r13d
movl %r14d, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x653a
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6546
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7252
incl %r14d
cmpl %r14d, %r13d
jne 0x651f
leaq -0x68(%rbp), %rdi
callq 0x6f6a
jmp 0x64a3
callq 0x33a4
jmp 0x654e
leaq -0x270(%rbp), %rdi
callq 0x3070
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6588
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 0x6588
jmp 0x65bc
movq %rax, %r14
jmp 0x65f2
jmp 0x65bc
movq %rax, %r14
jmp 0x65cd
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x6f6a
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x65e6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6606
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3340
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x679c
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r13
leaq -0x2c(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6756
movq %r13, %rdi
movq %r15, %rsi
leaq 0x1014b(%rip), %rdx     # 0x16815
callq 0x6e70
movq %r13, %r15
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x674f
movq -0x48(%rbp), %rax
cmpq %rax, -0x40(%rbp)
je 0x6734
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rax,%r14), %rdi
callq 0x32d0
movl %eax, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x670e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6719
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7252
incq %r13
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r14
cmpq %r13, %rcx
ja 0x66ec
movq %r15, %r13
movq %r15, %rdi
callq 0x6f6a
leaq -0x270(%rbp), %r14
leaq -0x68(%rbp), %r15
jmp 0x6685
callq 0x33ea
jmp 0x6734
leaq -0x270(%rbp), %rdi
callq 0x3070
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x677b
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 %r15, %rdi
callq 0x33c6
jmp 0x677b
jmp 0x67af
movq %rax, %r14
jmp 0x67e5
jmp 0x67af
movq %rax, %r14
jmp 0x67c0
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x6f6a
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x67d9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3210
leaq -0x270(%rbp), %rdi
callq 0x3090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x67f9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/0asa[P]TTree-source/./Logs.h
// Function: Logs::flush()
void flush() {
		fflush(_main);
		//fflush(_err);
		fflush(_roc);
		fflush(_varimp);
		fflush(_groupimp);
		fflush(_dot);
		fflush(_tree);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3240
movq 0x8(%rbx), %rdi
callq 0x3240
movq 0x10(%rbx), %rdi
callq 0x3240
movq 0x18(%rbx), %rdi
callq 0x3240
movq 0x20(%rbx), %rdi
callq 0x3240
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10a50
leaq 0xfc25(%rip), %rdi      # 0x1658e
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movl 0x5c(%r14), %edx
leaq 0xfc16(%rip), %rsi      # 0x1659c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
movl 0x58(%r14), %edx
leaq 0xfc13(%rip), %rsi      # 0x165ae
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf7f8(%rip), %rdi      # 0x163bc
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
testl %r15d, %r15d
jle 0x6c1c
movl %r15d, %r12d
xorl %r13d, %r13d
leaq 0xf9a3(%rip), %r15      # 0x1658b
movq 0xa0(%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0x1124e
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x3360
incq %r13
cmpq %r13, %r12
jne 0x6be8
leaq 0xf7a6(%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_O1/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 0x766c
leaq 0xfa5e(%rip), %rdi      # 0x165c7
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movl 0x98(%r14), %edx
leaq 0xfa4e(%rip), %rsi      # 0x165d7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ce8
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_O1/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 0xf72f(%rip), %rsi      # 0x16453
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3290
movq (%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xf71e(%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_O1/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 0xf700(%rip), %rsi      # 0x16471
leaq -0x120(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
leaq 0xf6f4(%rip), %r15      # 0x1647d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, (%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xf6db(%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 0xf6c0(%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 0xf6a5(%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 0xf68a(%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 0xf66f(%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 0x6cf0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6f1f
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 0x77bc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6fd4
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x6f0d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
xorl %edi, %edi
movq %r14, %rsi
callq 0x32e0
movq %rax, %r13
testq %rax, %rax
jne 0x6ed2
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 0x6f3c
movq %rax, %r14
jmp 0x6f59
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x6f59
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x6f6a
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10a50
movl 0x58(%r14), %edx
leaq 0xef57(%rip), %rsi      # 0x165e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
movl 0x5c(%r14), %edx
leaq 0xef5c(%rip), %rsi      # 0x165fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3290
leaq 0xef5c(%rip), %rdi      # 0x1660f
movl $0x28, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3360
movq 0x80(%r14), %rax
cmpq %rax, 0x88(%r14)
je 0x770d
leaq 0xef5c(%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 0x76df
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3270