LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: findintop(int, int)
void findintop(int tg,int pofs){ //NS列からtgを探す
    if(DEBUGFLAG==1){printf("\n[%d]を探す(%d)",tg,dc2s[loops-1]);}
    int len = 0;
    for(int y1 = 0;y1<Sizelist[0];y1++){
        if(DEBUGFLAG==1){printf("[%d]答え",NS[y1]);}
        if(NS[y1]==tg-dc2s[loops-1]){
            printf(" %d",len+pofs);
            if(ans<1000 && CHECKFLAG==1){checkans[ans]=len+pofs;}
            ans++;
        }
        len+= D3access(NS[y1]+dc2s[loops-1]);
    }
    //printf("\nend of searching.(%d)[%d]",len,tg);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x892b(%rip), %eax      # 0xe1b0
jge 0x5941
movq 0x8ba6(%rip), %rax      # 0xe438
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x4(%rbp), %ecx
movl 0x88fa(%rip), %edx      # 0xe19c
subl $0x1, %edx
movslq %edx, %rsi
leaq 0x8a41(%rip), %rdx      # 0xe2f0
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jne 0x5904
movl -0xc(%rbp), %esi
addl -0x8(%rbp), %esi
leaq 0x5ca8(%rip), %rdi      # 0xb56b
movb $0x0, %al
callq 0x2030
cmpl $0x3e8, 0x8b54(%rip)    # imm = 0x3E8
jge 0x58f5
xorl %eax, %eax
testb $0x1, %al
jne 0x58de
jmp 0x58f5
movl -0xc(%rbp), %edx
addl -0x8(%rbp), %edx
movslq 0x8b3d(%rip), %rcx      # 0xe428
leaq 0x8bee(%rip), %rax      # 0xe4e0
movl %edx, (%rax,%rcx,4)
movl 0x8b2d(%rip), %eax      # 0xe428
addl $0x1, %eax
movl %eax, 0x8b24(%rip)      # 0xe428
movq 0x8b2d(%rip), %rax      # 0xe438
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x8884(%rip), %eax      # 0xe19c
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x89cb(%rip), %rax      # 0xe2f0
addl (%rax,%rcx,4), %edi
callq 0x46f0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x587c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_locate.cpp
// Function: findinround1(int, int, int)
void findinround1(int tg,int round,int pofs){
    if(round==loops){return findintop(tg,pofs);}
    //あるラウンドから文字[tg]を探す
    //printf("%d(+%d)",tg,pofs); //引き継いだズレ値を記録
    int e2[2];
    int rofs = 0;
    if(round>1){rofs=dc2s[round-1];}
    for(int y8=dc2s[round];y8<dc2s[round+1];y8++){
        int ofs = 0;
        //printf("\n[%d(%d)]",y8,D_2[y8+1]-D_2[y8]);
        std::vector<int> x;
        xdisp(x,y8);
        for(int y9=0;y9<x.size();y9++){
            //printf(" %d",rofs+D[y9]);
            if(rofs+x[y9]==tg){
                //if(round>15){printf("\n発見(%d,%d[+%d])",tg,ofs+pofs,ofs);}
                findinround1(y8,round+1,pofs+ofs);
            }
            if(round>0){ofs+=D3access(rofs+x[y9]);}else{ofs++;}
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x8832(%rip), %eax      # 0xe19c
jne 0x597c
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x5860
jmp 0x5ac3
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x599f
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x8957(%rip), %rax      # 0xe2f0
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x8946(%rip), %rax      # 0xe2f0
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x892d(%rip), %rcx      # 0xe2f0
cmpl (%rcx,%rdx,4), %eax
jge 0x5ac1
movl $0x0, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x9db0
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x34c0
jmp 0x59ee
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9d90
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x5aaa
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9dd0
movq %rax, %rcx
movl -0x5c(%rbp), %eax
addl (%rcx), %eax
cmpl -0x4(%rbp), %eax
jne 0x5a66
movl -0x1c(%rbp), %edi
movl -0x8(%rbp), %esi
incl %esi
movl -0xc(%rbp), %edx
movl -0x20(%rbp), %eax
addl %eax, %edx
callq 0x5950
jmp 0x5a4d
jmp 0x5a66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9df0
jmp 0x5ac9
cmpl $0x0, -0x8(%rbp)
jle 0x5a91
movl -0x18(%rbp), %eax
movl %eax, -0x60(%rbp)
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9dd0
movl -0x60(%rbp), %edi
addl (%rax), %edi
callq 0x46f0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x5a9a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5a9c
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x59f5
leaq -0x38(%rbp), %rdi
callq 0x9df0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x59b0
jmp 0x5ac3
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x65f7(%rip), %rsi      # 0xe210
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x2, %edx
callq 0x9e50
movq -0x78(%rbp), %rdi
callq 0x2200
movq %rax, -0x70(%rbp)
jmp 0x7c3a
leaq -0x50(%rbp), %rdi
callq 0x9f30
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x65be(%rip), %rdi      # 0xe210
leaq 0x33e2(%rip), %rsi      # 0xb03b
callq 0x21c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7ca4
movq 0x65a0(%rip), %rsi      # 0xe210
leaq 0x33c6(%rip), %rdi      # 0xb03d
movb $0x0, %al
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7d4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9f30
jmp 0x7d59
movq -0x28(%rbp), %rax
movslq 0x64b5(%rip), %rcx      # 0xe164
cqto
idivq %rcx
movl %eax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
imull -0x60(%rbp), %eax
movslq %eax, %rsi
xorl %edx, %edx
callq 0x21b0
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x60(%rbp), %eax
jge 0x7d39
movq -0x20(%rbp), %rdi
callq 0x2230
movb %al, -0x65(%rbp)
movsbl -0x65(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsbl -0x65(%rbp), %eax
cmpl $0x0, %eax
jge 0x7d14
movsbl -0x65(%rbp), %edx
addl $0x100, %edx            # imm = 0x100
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
cmpl $0xa, (%rax,%rcx,4)
jne 0x7d2c
movl $0x1, 0x67a4(%rip)      # 0xe4d0
jmp 0x7d2e
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x7cd3
leaq 0x347f(%rip), %rdi      # 0xb1bf
movb $0x0, %al
callq 0x2030
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x5eaa(%rip), %rsi      # 0xe210
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x2, %edx
callq 0x9e50
movq -0x68(%rbp), %rdi
callq 0x2200
movq %rax, -0x60(%rbp)
jmp 0x8387
leaq -0x48(%rbp), %rdi
callq 0x9f30
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x5e71(%rip), %rdi      # 0xe210
leaq 0x2c95(%rip), %rsi      # 0xb03b
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movl 0x5e67(%rip), %edx      # 0xe220
movl 0x5e65(%rip), %ecx      # 0xe224
leaq 0x2e3b(%rip), %rdi      # 0xb201
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rdi
movslq 0x5e48(%rip), %rsi      # 0xe220
xorl %edx, %edx
callq 0x21b0
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl 0x5e35(%rip), %eax      # 0xe224
jge 0x8450
movq -0x18(%rbp), %rdi
callq 0x2230
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x58(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jge 0x8443
movsbl -0xd(%rbp), %edx
addl $0x100, %edx            # imm = 0x100
movq -0x8(%rbp), %rax
movslq -0x58(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x8443
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9f30
jmp 0x846a
jmp 0x8445
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x83e6
leaq 0x2d68(%rip), %rdi      # 0xb1bf
movb $0x0, %al
callq 0x2030
movl 0x5dc0(%rip), %eax      # 0xe224
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
leaq 0x2d98(%rip), %rdi      # 0xb223
movb $0x0, %al
callq 0x2030
leaq 0x2dac(%rip), %rdi      # 0xb245
movb $0x0, %al
callq 0x2030
leaq 0x2dd0(%rip), %rdi      # 0xb277
movb $0x0, %al
callq 0x2030
leaq 0x2de6(%rip), %rdi      # 0xb29b
movb $0x0, %al
callq 0x2030
leaq 0x2e09(%rip), %rdi      # 0xb2cc
movb $0x0, %al
callq 0x2030
leaq 0x2e2e(%rip), %rdi      # 0xb2ff
movb $0x0, %al
callq 0x2030
leaq 0x2e5b(%rip), %rdi      # 0xb33a
movb $0x0, %al
callq 0x2030
leaq 0x2e88(%rip), %rdi      # 0xb375
movb $0x0, %al
callq 0x2030
leaq 0x2eb7(%rip), %rdi      # 0xb3b2
movb $0x0, %al
callq 0x2030
leaq 0x2ee0(%rip), %rdi      # 0xb3e9
movb $0x0, %al
callq 0x2030
leaq 0x2f08(%rip), %rdi      # 0xb41f
movb $0x0, %al
callq 0x2030
leaq 0x2f42(%rip), %rdi      # 0xb467
movb $0x0, %al
callq 0x2030
leaq 0x2f6d(%rip), %rdi      # 0xb4a0
movb $0x0, %al
callq 0x2030
leaq 0x2f96(%rip), %rdi      # 0xb4d7
movb $0x0, %al
callq 0x2030
leaq 0x2d26(%rip), %rdi      # 0xb275
movb $0x0, %al
callq 0x2030
leaq 0x2d18(%rip), %rdi      # 0xb275
movb $0x0, %al
callq 0x2030
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdx, -0xd8(%rbp)
movq %rsi, %rax
movq -0xd8(%rbp), %rsi
movq %rdi, -0xd0(%rbp)
movq %rdi, %rdx
movq %rdx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4450
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2fb0
jmp 0x2d7d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x2e10
movq -0xd0(%rbp), %rdi
leaq 0x23d0(%rip), %rsi      # 0x5176
callq 0x4490
movl $0x1, -0x94(%rbp)
jmp 0x2f18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
movq -0x78(%rbp), %rax
leaq -0x70(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0xe0(%rbp)
je 0x2e0b
movq -0xe0(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3220
movq -0xe8(%rbp), %rax
leaq -0x70(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0xe0(%rbp)
jne 0x2ddd
jmp 0x2fa2
leaq -0x70(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rax
addq $0x50, %rax
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
cmpq -0xb0(%rbp), %rax
je 0x2efb
movq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x44b0
movb %al, -0xe9(%rbp)
jmp 0x2e78
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x2e84
jmp 0x2ee2
movq -0xd0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movb $0x1, -0xb9(%rbp)
leaq -0xb9(%rbp), %rsi
callq 0x44e0
movl $0x1, -0x94(%rbp)
jmp 0x2f18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x100(%rbp)
addq $0x50, %rax
movq %rax, -0xf8(%rbp)
jmp 0x2f6f
jmp 0x2ee4
movq -0xa8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xa8(%rbp)
jmp 0x2e3b
movq -0xd0(%rbp), %rdi
leaq 0x226d(%rip), %rsi      # 0x5176
callq 0x4490
movl $0x1, -0x94(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x110(%rbp)
addq $0x50, %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0x118(%rbp)
callq 0x3220
movq -0x110(%rbp), %rcx
movq -0x118(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x108(%rbp)
jne 0x2f2e
movq -0xc8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xf8(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0x120(%rbp)
callq 0x3220
movq -0x100(%rbp), %rcx
movq -0x120(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xf8(%rbp)
jne 0x2f6f
jmp 0x2fa2
movq -0x80(%rbp), %rdi
callq 0x2200
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b30
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b10
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48b0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4890
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cvttsd2si -0x20(%rbp), %ecx
cmpl %ecx, %eax
jg 0x1c27
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x44(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x1090
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1bee
movsd 0x33f9(%rip), %xmm1     # 0x5028
addsd -0x20(%rbp), %xmm1
movsd 0x33ec(%rip), %xmm0     # 0x5028
divsd %xmm1, %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x33c9(%rip), %xmm1     # 0x5020
callq 0x1140
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x33aa(%rip), %xmm1     # 0x5018
callq 0x1140
movsd %xmm0, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
divsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd 0x337c(%rip), %xmm1     # 0x5010
callq 0x1140
movsd 0x3367(%rip), %xmm1     # 0x5008
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x1cc0
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x1cca
leaq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x1cca
movq -0x78(%rbp), %rdi
movsd 0x3352(%rip), %xmm0     # 0x5028
movsd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x2390
cvttsd2si (%rax), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23d0
movq -0x28(%rbp), %rdi
callq 0x1310
movq %rax, -0x70(%rbp)
jmp 0x1d3b
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x23f0
jmp 0x1d4a
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2640
cmpl $0x0, (%rax)
je 0x1d86
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1ed6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x26a0
jmp 0x1eed
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2660
movq -0x88(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x2640
movslq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1410
movq %rax, %rcx
movq -0x80(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x1ddd
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1ed6
movl $0x0, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1410
subq $0x1, %rax
movl %eax, -0x58(%rbp)
movl $0x1, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2660
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ecb
movq -0x18(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
callq 0x2640
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x1e4c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1ed6
movl -0x60(%rbp), %eax
cmpl -0x58(%rbp), %eax
jle 0x1e61
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1ed6
movl -0x60(%rbp), %eax
movl -0x54(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x98(%rbp)
movslq -0x54(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2680
movq -0x78(%rbp), %rdi
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1b90
movl %eax, -0x94(%rbp)
jmp 0x1e9a
movl -0x98(%rbp), %eax
movl -0x94(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1eb7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1ed6
movl -0x60(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1dfb
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x26a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rdx
movslq -0x14(%rbp), %rsi
addl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jg 0x1f8e
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
cmpl -0x28(%rbp), %eax
jle 0x1f81
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x1f6a
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f94
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f83
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1f22
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x2, %edx
callq 0x1afb0
movq -0x58(%rbp), %rdi
callq 0x1b090
movb %al, -0x49(%rbp)
jmp 0x18780
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x18804
jmp 0x18789
leaq -0x38(%rbp), %rdi
callq 0xae2c0
movb %al, -0x59(%rbp)
jmp 0x18797
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x18802
jmp 0x187a0
leaq 0xfed39(%rip), %rdi     # 0x1174e0
leaq 0xbb866(%rip), %rsi     # 0xd4014
callq 0x89220
movq %rax, -0x68(%rbp)
jmp 0x187b9
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x91fb0
movq %rax, -0x70(%rbp)
jmp 0x187cc
movq -0x70(%rbp), %rdi
leaq 0x70329(%rip), %rsi     # 0x88b00
callq 0x87d10
jmp 0x187de
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x1880f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b0c0
jmp 0x18823
jmp 0x18804
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b0c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x137b0
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
movl %eax, 0x374(%rdi)
movl 0x4(%rsp), %eax
movl %eax, 0x378(%rdi)
movl 0xc(%rsp), %eax
movl %eax, 0x370(%rdi)
movl 0xc(%rsp), %eax
xorl %edx, %edx
divl 0x4(%rsp)
movl %eax, %eax
movl %eax, %esi
callq 0x6250
addq $0x18, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x34a0
movq 0x30(%rsp), %rcx
movl 0x370(%rcx), %ecx
cmpq %rcx, %rax
jne 0x5ffd
jmp 0x601c
leaq 0xf0b3(%rip), %rdi      # 0x150b7
leaq 0xf0c7(%rip), %rsi      # 0x150d2
movl $0x18, %edx
leaq 0xf0cd(%rip), %rcx      # 0x150e4
callq 0x31d0
movl $0x0, 0xa4(%rsp)
movq 0x30(%rsp), %rcx
movl 0xa4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x370(%rcx), %eax
xorl %edx, %edx
divl 0x378(%rcx)
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0x614b
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rsi
movl 0xa4(%rsp), %eax
movl 0x378(%rcx), %ecx
movl %ecx, %edx
imull %edx, %eax
movl %eax, %edx
leaq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x32d0
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rsi
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3140
jmp 0x60a2
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x1, %edx
callq 0xa360
jmp 0x60b8
leaq 0x60(%rsp), %rdi
callq 0x31b0
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0xa5c0
movl %eax, 0x4(%rsp)
jmp 0x60d6
movq 0x30(%rsp), %rdi
movslq 0xa4(%rsp), %rsi
callq 0x62f0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x80(%rsp), %rdi
callq 0x31b0
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x6027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6139
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x31b0
leaq 0x80(%rsp), %rdi
callq 0x31b0
jmp 0x61cb
movq 0x30(%rsp), %rdi
callq 0x6350
movq 0x30(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0x6380
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6310
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movl 0x38(%rsp), %eax
cmpl 0x374(%rcx), %eax
jae 0x61bf
movq 0x30(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x62f0
movl (%rax), %eax
addl 0x3c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x6188
movl 0x3c(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24ae
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x8c56(%rip), %rsi      # 0xb004
callq 0x21a0
cmpl $0x0, %eax
je 0x23d4
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x8c45(%rip), %rsi      # 0xb00b
callq 0x21a0
cmpl $0x0, %eax
jne 0x2476
callq 0x24c0
jmp 0x23db
movl $0x0, -0x4(%rbp)
jmp 0x24b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x2447
movq -0x20(%rbp), %rdi
callq 0x2060
movq %rax, -0x30(%rbp)
movq 0xcbc5(%rip), %rax      # 0xefd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x8c02(%rip), %rsi      # 0xb034
movb $0x0, %al
callq 0x21c0
movl $0x1, -0x4(%rbp)
callq 0x21f0
jmp 0x24b7
movq -0x20(%rbp), %rdi
callq 0x2060
movq 0xcb81(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bb7(%rip), %rsi      # 0xb018
movb $0x0, %al
callq 0x21c0
movl $0x1, -0x4(%rbp)
callq 0x21f0
jmp 0x24b7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x8b8a(%rip), %rsi      # 0xb00e
callq 0x21a0
cmpl $0x0, %eax
jne 0x249e
callq 0x2590
jmp 0x2495
movl $0x0, -0x4(%rbp)
jmp 0x24b7
callq 0x24c0
jmp 0x24a5
movl $0x1, -0x4(%rbp)
jmp 0x24b7
callq 0x2610
jmp 0x24b5
jmp 0x24b7
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
movq 0xcb0d(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b76(%rip), %rsi      # 0xb04b
movb $0x0, %al
callq 0x21c0
movq 0xcaf5(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b66(%rip), %rsi      # 0xb053
movb $0x0, %al
callq 0x21c0
movq 0xcadd(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b5c(%rip), %rsi      # 0xb061
movb $0x0, %al
callq 0x21c0
movq 0xcac5(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bff(%rip), %rsi      # 0xb11c
movb $0x0, %al
callq 0x21c0
movq 0xcaad(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b41(%rip), %rsi      # 0xb076
movb $0x0, %al
callq 0x21c0
movq 0xca95(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bcf(%rip), %rsi      # 0xb11c
movb $0x0, %al
callq 0x21c0
movq 0xca7d(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b57(%rip), %rsi      # 0xb0bc
movb $0x0, %al
callq 0x21c0
movq 0xca65(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b73(%rip), %rsi      # 0xb0f0
movb $0x0, %al
callq 0x21c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/gpp.cpp
// Function: (anonymous namespace)::display_version()
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 %rbp
movq %rsp, %rbp
movq 0xca3d(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b79(%rip), %rsi      # 0xb11e
movb $0x0, %al
callq 0x21c0
movq 0xca25(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b82(%rip), %rsi      # 0xb13f
movb $0x0, %al
callq 0x21c0
movq 0xca0d(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8b90(%rip), %rsi      # 0xb165
movb $0x0, %al
callq 0x21c0
movq 0xc9f5(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8ba0(%rip), %rsi      # 0xb18d
movb $0x0, %al
callq 0x21c0
movq 0xc9dd(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8baa(%rip), %rsi      # 0xb1af
movb $0x0, %al
callq 0x21c0
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3350
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x50(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x670d
movq -0x30(%rbp), %rdi
movq 0x3a8e4(%rip), %rax     # 0x40fa8
movq (%rax), %rcx
movq %rcx, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
movq (%rax), %rcx
movq %rcx, 0x18(%rdi)
movq (%rax), %rcx
movq %rcx, 0x20(%rdi)
movq (%rax), %rax
movq %rax, 0x28(%rdi)
callq 0x7680
jmp 0x66f4
jmp 0x672d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3170
jmp 0x6733
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rdi
callq 0x3340
jmp 0x6720
movq -0x30(%rbp), %rdi
callq 0x7710
jmp 0x672b
jmp 0x672d
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x32e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x20e20
movq -0x10(%rbp), %rdi
leaq 0x294da(%rip), %rsi     # 0x30616
movb $0x0, %al
callq 0x3360
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x5c(%rax), %edx
leaq 0x294cf(%rip), %rsi     # 0x30624
movb $0x0, %al
callq 0x3360
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x58(%rax), %edx
leaq 0x294c8(%rip), %rsi     # 0x30636
movb $0x0, %al
callq 0x3360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/./RandomForest.h
// Function: RandomForest::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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x71ed
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x58(%rcx), %eax
jbe 0x71f7
movq -0x20(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x29242(%rip), %rsi     # 0x30444
movb $0x0, %al
callq 0x3360
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x723c
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x7060
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7210
movq -0x10(%rbp), %rdi
leaq 0x2920a(%rip), %rsi     # 0x30451
movb $0x0, %al
callq 0x3360
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb630
movq -0x10(%rbp), %rdi
leaq 0x29253(%rip), %rsi     # 0x3064f
movb $0x0, %al
callq 0x3360
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x98(%rax), %edx
leaq 0x29247(%rip), %rsi     # 0x3065f
movb $0x0, %al
callq 0x3360
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x3260
jmp 0x760e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3260
jmp 0x761d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3260
jmp 0x762c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3260
jmp 0x763b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3260
jmp 0x764a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3260
jmp 0x7659
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3170
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8360
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3220
leaq -0x10(%rbp), %rdi
callq 0x31c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3110
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x28e0c(%rip), %rsi     # 0x304db
movb $0x0, %al
callq 0x3360
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x28ded(%rip), %rsi     # 0x304e5
movb $0x0, %al
callq 0x3360
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x148(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x148(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28d9d(%rip), %rsi     # 0x304f9
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28d94(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, (%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x140(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x140(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28d56(%rip), %rsi     # 0x30508
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28d3e(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, 0x8(%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x138(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x138(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28d0b(%rip), %rsi     # 0x30514
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28ce7(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, 0x10(%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x130(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x130(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28cc0(%rip), %rsi     # 0x30520
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28c90(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, 0x18(%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x128(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x128(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28c75(%rip), %rsi     # 0x3052c
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28c39(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, 0x20(%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x120(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x120(%rbp), %rdi
movq %rax, %rdx
movq -0x118(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x28c2a(%rip), %rsi     # 0x30538
movb $0x0, %al
callq 0x3060
leaq -0x110(%rbp), %rdi
leaq 0x28be2(%rip), %rsi     # 0x30505
callq 0x32f0
movq -0x118(%rbp), %rdi
movq %rax, 0x28(%rdi)
callq 0x7680
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7c20
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rdi
incq %rdi
callq 0x3030
movq %rax, -0x70(%rbp)
jmp 0x7a15
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3230
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x7b00
movq -0x40(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x33f0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x65d0
jmp 0x7a90
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7c40
jmp 0x7a9f
leaq -0x60(%rbp), %rdi
callq 0x3170
leaq -0x61(%rbp), %rdi
callq 0x32b0
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x33b0
movq %rax, -0x40(%rbp)
jmp 0x7a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7b3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7af5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3170
leaq -0x61(%rbp), %rdi
callq 0x32b0
jmp 0x7b3d
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7b1d
movq -0xa0(%rbp), %rdi
callq 0x3330
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7b30
movq -0x80(%rbp), %rdi
callq 0x7bc0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x7bc0
movq -0x30(%rbp), %rdi
callq 0x33e0
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x20e20
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x58(%rax), %edx
leaq 0x25009(%rip), %rsi     # 0x3066c
movb $0x0, %al
callq 0x3360
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x5c(%rax), %edx
leaq 0x2500a(%rip), %rsi     # 0x30686
movb $0x0, %al
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0x25009(%rip), %rsi     # 0x30697
movb $0x0, %al
callq 0x3360
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x80, %rdi
callq 0x8bf0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xb6fb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x80, %rdi
movslq -0x14(%rbp), %rsi
callq 0xb720
movq -0x30(%rbp), %rdi
movl (%rax), %edx
leaq 0x24fd7(%rip), %rsi     # 0x306c0
movb $0x0, %al
callq 0x3360
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb69c
movq -0x10(%rbp), %rdi
leaq 0x24f0e(%rip), %rsi     # 0x30614
movb $0x0, %al
callq 0x3360
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 0asa[P]TTree-source/BestFirstStack.cpp
// Function: BestFirstStack::pop()
Node* BestFirstStack::pop() {
	Node *ret = s[s.size()-1];
	s.pop_back();
	values.pop_back();
	return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcb20
movq (%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xcb00
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0xcb40
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0xcb60
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x67b0
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x58(%rcx), %eax
jae 0xf1b4
movq (%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x7b90
jmp 0xf18c
jmp 0xf18e
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xf166
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6830
jmp 0xf1d3
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xf1c9
movq (%rsp), %rdi
callq 0x6830
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nopl (%rax)