LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4972(%rip), %rsi      # 0xa210
movq %rsp, %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
callq 0x6c42
movq %r15, %rdi
callq 0x21e0
movq %rax, %r13
movq %rsp, %rdi
callq 0x6cae
movq 0x494a(%rip), %rdi      # 0xa210
leaq 0x17ce(%rip), %rsi      # 0x709b
callq 0x21a0
testq %rax, %rax
je 0x5976
movq %rax, %r15
andl $0x0, 0x4beb(%rip)      # 0xa4d0
callq 0x2060
cltq
movslq %ebx, %rcx
movq %r13, %rsi
subq %rcx, %rsi
cqto
idivq %rsi
cmpl $0x2, 0x485b(%rip)      # 0xa15c
jne 0x5909
movl 0x485f(%rip), %edx      # 0xa168
movslq %ebp, %rax
movl %edx, (%r12,%rax,4)
movslq %edx, %r12
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2190
leaq 0x188e(%rip), %rdi      # 0x71b7
movl %r12d, %esi
movl %ebx, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2030
testl %ebx, %ebx
movl $0x0, %r12d
cmovgl %ebx, %r12d
cmpq %rbp, %r12
je 0x596c
movq %r15, %rdi
callq 0x2220
movzbl %al, %eax
movl %eax, (%r14,%rbp,4)
cmpl $0xa, %eax
jne 0x5967
movl $0x1, 0x4b69(%rip)      # 0xa4d0
incq %rbp
jmp 0x5944
pushq $0x5d
popq %rdi
callq 0x21f0
jmp 0x598e
movq 0x4893(%rip), %rsi      # 0xa210
leaq 0x1719(%rip), %rdi      # 0x709d
xorl %eax, %eax
callq 0x2030
pushq $-0x1
popq %rbx
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 0x6cae
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5afe
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 0x5afe
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 0x5afd
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 0x5afd
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 0x5afd
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 0x5afd
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 0x5afd
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_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x46fc(%rip), %rsi      # 0xa210
movq %rsp, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x6c42
movq %r14, %rdi
callq 0x21e0
movq %rax, %r15
movq %rsp, %rdi
callq 0x6cae
movq 0x46d4(%rip), %rdi      # 0xa210
leaq 0x1558(%rip), %rsi      # 0x709b
callq 0x21a0
movq %rax, %r14
movl 0x46cf(%rip), %edx      # 0xa220
movl 0x46cd(%rip), %ecx      # 0xa224
leaq 0x167b(%rip), %rdi      # 0x71d9
xorl %r12d, %r12d
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movslq 0x46ae(%rip), %rsi      # 0xa220
movq %r14, %rdi
xorl %edx, %edx
callq 0x2190
movslq 0x46a1(%rip), %rax      # 0xa224
cmpq %rax, %r12
jge 0x5b9c
movq %r14, %rdi
callq 0x2220
movzbl %al, %eax
movl %eax, (%rbx,%r12,4)
incq %r12
jmp 0x5b7c
pushq $0x5d
popq %rdi
callq 0x21f0
movl 0x467a(%rip), %eax      # 0xa224
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6cae
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0x1862(%rip), %rdi      # 0x7433
callq 0x2210
leaq 0x1877(%rip), %rdi      # 0x7454
callq 0x2210
leaq 0x189c(%rip), %rdi      # 0x7485
callq 0x2210
leaq 0x18b3(%rip), %rdi      # 0x74a8
callq 0x2210
leaq 0x18d7(%rip), %rdi      # 0x74d8
callq 0x2210
leaq 0x18fd(%rip), %rdi      # 0x750a
callq 0x2210
leaq 0x192b(%rip), %rdi      # 0x7544
callq 0x2210
leaq 0x1959(%rip), %rdi      # 0x757e
callq 0x2210
leaq 0x1989(%rip), %rdi      # 0x75ba
callq 0x2210
leaq 0x19b3(%rip), %rdi      # 0x75f0
callq 0x2210
leaq 0x19dc(%rip), %rdi      # 0x7625
callq 0x2210
leaq 0x1a17(%rip), %rdi      # 0x766c
callq 0x2210
leaq 0x1a43(%rip), %rdi      # 0x76a4
callq 0x2210
leaq 0x1a6d(%rip), %rdi      # 0x76da
callq 0x2210
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x21f0
movl %ebx, %edi
callq 0x21f0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2c66
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x2750
movq (%r14), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x2713
xorl %r12d, %r12d
cmpq $0x50, %r12
je 0x2713
leaq (%rsp,%r12), %rdi
movq %r15, %rsi
callq 0x2c84
addq $0x28, %r12
testb %al, %al
je 0x26f1
addq $0x8, (%r14)
movb $0x1, %al
jmp 0x2715
xorl %eax, %eax
movb %al, (%rbx)
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
callq 0x2080
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x271b
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c66
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x1c5c
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x2182
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x2178
movsd -0x28(%rbp), %xmm2
movsd %xmm0, -0x30(%rbp)
cvttsd2si %xmm2, %ebx
xorl %r14d, %r14d
xorpd %xmm4, %xmm4
movsd 0x1c13(%rip), %xmm1     # 0x3008
xorpd %xmm3, %xmm3
xorpd %xmm5, %xmm5
cmpl %ebx, %r14d
jg 0x1452
movapd %xmm2, %xmm0
mulsd %xmm5, %xmm0
mulsd -0x20(%rbp), %xmm0
ucomisd %xmm4, %xmm0
jb 0x141b
sqrtsd %xmm0, %xmm0
jmp 0x1445
movsd %xmm3, -0x18(%rbp)
movsd %xmm5, -0x40(%rbp)
callq 0x10a0
movsd -0x40(%rbp), %xmm5
xorpd %xmm4, %xmm4
movsd -0x18(%rbp), %xmm3
movsd -0x28(%rbp), %xmm2
movsd 0x1bc3(%rip), %xmm1     # 0x3008
addsd %xmm0, %xmm3
addsd %xmm1, %xmm5
incl %r14d
jmp 0x13fd
addsd %xmm1, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd 0x1ba5(%rip), %xmm1     # 0x3010
movsd -0x30(%rbp), %xmm0
callq 0x1130
movsd %xmm0, -0x18(%rbp)
movsd 0x1b96(%rip), %xmm1     # 0x3018
movsd -0x38(%rbp), %xmm0
callq 0x1130
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
divsd 0x1b7f(%rip), %xmm1     # 0x3020
maxsd -0x20(%rbp), %xmm1
movsd 0x1b5a(%rip), %xmm0     # 0x3008
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ujjwal-ism[P]Jumping_game/gameUtil.cpp
// Function: GameUtil::isValidPath(std::vector<int, std::allocator<int>>&, Player*, Game*)
bool GameUtil::isValidPath(std::vector<int>& path, Player* player, Game* game){
  std::vector<Square*> board;
  board=game->getBoard();

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

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

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

    return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x58(%rbp)
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movq %rcx, %rdi
callq 0x12c6
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1836
movq (%r14), %rax
cmpl $0x0, (%rax)
je 0x1505
xorl %r15d, %r15d
jmp 0x1580
movq 0x8(%r14), %rax
movslq -0x4(%rax), %rax
movq -0x48(%rbp), %rdx
subq -0x50(%rbp), %rdx
sarq $0x3, %rdx
movq %rdx, -0x30(%rbp)
decq %rdx
xorl %ecx, %ecx
movl $0x0, %r15d
cmpq %rax, %rdx
jne 0x1580
movq -0x30(%rbp), %rax
decl %eax
movq %rax, -0x30(%rbp)
pushq $0x1
popq %r13
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
setbe %r15b
jbe 0x1580
movl (%rax,%r13,4), %r12d
movl %r12d, %ebx
subl %ecx, %ebx
jl 0x1580
cmpl -0x30(%rbp), %r12d
jg 0x1580
movl %ecx, %eax
movq -0x50(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq -0x58(%rbp), %rdx
callq 0x1398
incq %r13
movl %r12d, %ecx
cmpl %eax, %ebx
jle 0x153b
leaq -0x50(%rbp), %rdi
callq 0x193e
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x159d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x193e
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rax
movslq (%rdx,%rax,4), %rdi
addq %rax, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpq %rdi, %rax
jge 0x15ea
movl 0x4(%rdx,%rax,4), %r10d
addl %esi, %r10d
incq %rax
cmpl %r8d, %r10d
jle 0x15c8
movl %r10d, %r8d
movl %eax, %r9d
cmpl %ecx, %r10d
jl 0x15c8
jmp 0x15ed
movl %r9d, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19d72
movq %r14, %rdi
callq 0x19ddc
movb $0x1, %r14b
testb %al, %al
jne 0x187a1
leaq -0x38(%rbp), %rdi
callq 0xa93f0
testb %al, %al
jne 0x187a1
leaq 0xf6d61(%rip), %rdi     # 0x10f4e0
leaq 0xb687e(%rip), %rsi     # 0xcf004
callq 0x84350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8d0e0
movq %rax, %rdi
callq 0x83c30
xorl %r14d, %r14d
leaq -0x38(%rbp), %rdi
callq 0x19dfa
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x19dfa
movq %rbx, %rdi
callq 0x137b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x425e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
movl 0x378(%rbx), %ecx
xorl %edx, %edx
divl %ecx
cmpq %rax, %rbp
jae 0x4229
movl %ebp, %edx
imull %ecx, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3250
movq %r13, %rdi
movq %r12, %rsi
callq 0x3340
movq %r15, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x5716
movq %r13, %rdi
callq 0x3110
movq %r15, %rdi
callq 0x5860
movq (%rbx), %rcx
movl %eax, (%rcx,%rbp,4)
movq %r12, %rdi
callq 0x3110
incq %rbp
movl 0x370(%rbx), %eax
jmp 0x41c8
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x44bd
movl 0x374(%rbx), %ecx
movq (%rbx), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x424f
addl (%rdx,%rsi,4), %eax
incq %rsi
jmp 0x4242
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e52(%rip), %rdi      # 0x90b7
leaq 0x4e66(%rip), %rsi      # 0x90d2
leaq 0x4e71(%rip), %rcx      # 0x90e4
pushq $0x18
popq %rdx
callq 0x3170
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3110
jmp 0x428d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rbx
testq %rbx, %rbx
je 0x235a
leaq 0x5ce4(%rip), %rsi      # 0x8004
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2363
cmpb $0x2d, (%rbx)
jne 0x233d
cmpb $0x68, 0x1(%rbx)
jne 0x233d
cmpb $0x0, 0x2(%rbx)
je 0x2363
leaq 0x5cc7(%rip), %rsi      # 0x800b
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x2374
callq 0x2447
pushq $0x1
popq %rbx
jmp 0x236a
xorl %ebx, %ebx
callq 0x24f0
jmp 0x236a
callq 0x2447
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9c5d(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5d96(%rip), %rdi      # 0x811b
pushq $0x20
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5d9f(%rip), %rdi      # 0x813c
pushq $0x25
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5db0(%rip), %rdi      # 0x8162
pushq $0x27
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5dc3(%rip), %rdi      # 0x818a
pushq $0x21
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5dd0(%rip), %rdi      # 0x81ac
movl $0x97, %esi
movq %rbx, %rdx
callq 0x2200
jmp 0x2368
movq %rdx, %r14
movq %rax, %rdi
callq 0x2050
movq 0x9bd8(%rip), %rcx      # 0xbfd8
movq (%rcx), %rbx
cmpl $0x2, %r14d
jne 0x2428
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x5c18(%rip), %rsi      # 0x8031
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2180
jmp 0x243d
leaq 0x5be6(%rip), %rdi      # 0x8015
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2200
callq 0x21b0
jmp 0x2355
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9b86(%rip), %r14      # 0xbfd8
movq (%r14), %rcx
leaq 0x5bec(%rip), %rdi      # 0x8048
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5bdc(%rip), %rdi      # 0x8050
pushq $0xd
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5bd5(%rip), %rdi      # 0x805e
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 0x5bc8(%rip), %rdi      # 0x8073
pushq $0x45
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rsi
movl %ebp, %edi
callq 0x2120
movq (%r14), %rcx
leaq 0x5bef(%rip), %rdi      # 0x80b9
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x2200
movq (%r14), %rcx
leaq 0x5c0e(%rip), %rdi      # 0x80ed
pushq $0x2d
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %rax
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb $0x0, 0x40(%rdi)
movl %edx, 0x50(%rdi)
testq %rsi, %rsi
je 0x550a
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x3360
movq %rbx, %rdi
callq 0x5cea
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18a9f(%rip), %rax     # 0x1dfb0
movq (%rax), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5c8a
movq %rax, %rbx
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3350
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x56a3
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r15
leaq -0x2c(%rbp), %r12
leaq -0x270(%rbp), %rdi
movq %r14, %rsi
callq 0x3060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x566d
movq %r15, %r13
movq %r15, %rdi
movq %r14, %rsi
leaq 0xe226(%rip), %rdx      # 0x1381d
callq 0x5e18
movq -0x48(%rbp), %r15
movq -0x40(%rbp), %rax
subq %r15, %rax
cmpq $0x40, %rax
jne 0x563d
movq (%r15), %rdi
callq 0x32e0
movl %eax, %r14d
movq 0x20(%r15), %rdi
callq 0x32e0
movl %eax, %r15d
cmpl %r15d, %r14d
jg 0x5659
movl %r14d, -0x2c(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6112
incl %r14d
jmp 0x5624
movq 0x18994(%rip), %rax     # 0x1dfd8
movq (%rax), %rcx
leaq 0xde9e(%rip), %rdi      # 0x134ec
pushq $0x32
popq %rsi
pushq $0x1
popq %rdx
callq 0x3370
movq %r13, %r15
movq %r13, %rdi
callq 0x5eda
leaq -0x68(%rbp), %r14
jmp 0x55c6
leaq -0x270(%rbp), %rdi
callq 0x3070
leaq -0x68(%rbp), %rdi
callq 0x3110
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 0x1892e(%rip), %rax     # 0x1dfd8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xde06(%rip), %rsi      # 0x134bd
xorl %eax, %eax
callq 0x32a0
jmp 0x5682
jmp 0x56c9
movq %rax, %r14
jmp 0x56ef
jmp 0x56c9
movq %rax, %r14
jmp 0x56da
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x5eda
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x270(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x6886
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/./Sampler.h
// Function: Sampler::readSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::vector<unsigned int> readSet(std::string file) {
		std::vector<unsigned int> ret;
		std::ifstream fs(file.c_str());
		if (!fs) {
			fprintf(stderr, "ReadSet() Error : Cannot find file %s\n",file.c_str());
			return ret;
		}
		std::string line;
		int ln = 0;
		while (getline(fs, line)) {
			std::vector<std::string> ex = StrTools::explode(line,const_cast<char *>("\t"));
			// treat ex and pushback...
			if (ex.size() > 0) {
				for (int i = 0 ; i < ex.size(); ++i)
					ret.push_back(atoi(ex[i].c_str()));
			} else {
				fprintf(stderr, "ReadSet() Error : Incorrect file format ?\n");
			}
			++ln;
		}
		fs.close();
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3350
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x5849
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r13
leaq -0x2c(%rbp), %r12
leaq -0x270(%rbp), %rdi
movq %r14, %rsi
callq 0x3060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5813
movq %r13, %rdi
movq %r14, %rsi
leaq 0xe083(%rip), %rdx      # 0x1381d
callq 0x5e18
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq %rax, %rcx
je 0x57e6
xorl %r14d, %r14d
xorl %r15d, %r15d
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r15, %rcx
jbe 0x5802
movq (%rax,%r14), %rdi
callq 0x32e0
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6112
incq %r15
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x20, %r14
jmp 0x57b2
movq 0x187eb(%rip), %rax     # 0x1dfd8
movq (%rax), %rcx
leaq 0xdd69(%rip), %rdi      # 0x13560
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x3370
movq %r13, %rdi
callq 0x5eda
leaq -0x68(%rbp), %r14
jmp 0x576c
leaq -0x270(%rbp), %rdi
callq 0x3070
leaq -0x68(%rbp), %rdi
callq 0x3110
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 0x18788(%rip), %rax     # 0x1dfd8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xdcdc(%rip), %rsi      # 0x13539
xorl %eax, %eax
callq 0x32a0
jmp 0x5828
jmp 0x586f
movq %rax, %r14
jmp 0x5895
jmp 0x586f
movq %rax, %r14
jmp 0x5880
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x5eda
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x270(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x6886
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
movq 0x8(%rbx), %rdi
callq 0x3230
movq 0x10(%rbx), %rdi
callq 0x3230
movq 0x18(%rbx), %rdi
callq 0x3230
movq 0x20(%rbx), %rdi
callq 0x3230
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe228
leaq 0xdbd7(%rip), %rdi      # 0x1358e
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3370
movl 0x5c(%r14), %edx
leaq 0xdbcc(%rip), %rsi      # 0x1359c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32a0
movl 0x58(%r14), %edx
leaq 0xdbc9(%rip), %rsi      # 0x135ae
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x58(%rdi), %r15d
leal -0x1(%rdx), %eax
cmpl %r15d, %eax
cmovbl %edx, %r15d
leaq 0xd9a2(%rip), %rdi      # 0x133bc
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3370
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x5a4c
movq 0x60(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x592c
incq %r12
jmp 0x5a32
leaq 0xd976(%rip), %rdi      # 0x133c9
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6718
leaq 0xda78(%rip), %rdi      # 0x135c7
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3370
movl 0x98(%r14), %edx
leaq 0xda6c(%rip), %rsi      # 0x135d7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd795(%rip), %rsi      # 0x13453
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x32a0
movq (%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xd784(%rip), %rsi      # 0x1345d
xorl %eax, %eax
callq 0x32a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd766(%rip), %rsi      # 0x13471
leaq -0x120(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
leaq 0xd75a(%rip), %r15      # 0x1347d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, (%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xd741(%rip), %rsi      # 0x13480
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, 0x8(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xd726(%rip), %rsi      # 0x1348c
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, 0x10(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xd70b(%rip), %rsi      # 0x13498
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, 0x18(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xd6f0(%rip), %rsi      # 0x134a4
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0xd6d5(%rip), %rsi      # 0x134b0
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5c8a
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rdi
incq %rdi
callq 0x3030
movq %rax, %r15
movq (%r12), %rsi
movq %rax, %rdi
callq 0x31c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x32f0
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %r13
testq %rax, %rax
je 0x5e9d
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x5492
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5f06
movq %r12, %rdi
callq 0x3110
xorl %edi, %edi
movq %r14, %rsi
callq 0x32f0
jmp 0x5e6b
movq %r15, %rdi
callq 0x3270
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5eb9
movq %rax, %r14
jmp 0x5eca
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x5eda
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe228
movl 0x58(%r14), %edx
leaq 0xceab(%rip), %rsi      # 0x135e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32a0
movl 0x5c(%r14), %edx
leaq 0xceb0(%rip), %rsi      # 0x135fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32a0
leaq 0xceb0(%rip), %rdi      # 0x1360f
pushq $0x28
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3370
leaq 0xcec4(%rip), %r15      # 0x13638
xorl %r12d, %r12d
movq 0x80(%r14), %rax
movq 0x88(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x67a7
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x32a0
incq %r12
jmp 0x6777
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/BestFirstStack.cpp
// Function: BestFirstStack::push(Node*)
void BestFirstStack::push(Node* n) {
	n->setId(nbpush++);
	std::vector<unsigned int> set = n->getLS();
	//printf("Node Size : %d\n",set.size());
	double total = 0.0;
	std::vector<double> sum(2,0.0);
	for (int i = 0 ; i < set.size() ; ++i) {
		total += db->getWeight(set[i]);
		sum[db->getOutput(set[i])] += db->getWeight(set[i]);
	}
	Score score;
	double hc = score.getShannonEntropy(sum,total) * total;
	if (hc > 0.0) {
	std::vector<double>::iterator it;
	std::vector< Node* >::iterator itn;
	for( it = values.begin(), itn = s.begin() ; it != values.end(); it++, itn++ )    {
		if (hc <= *it) 
			break;
	}
	values.insert(it,hc);
	
	s.insert(itn,n);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
leaq 0x176ca(%rip), %rax     # 0x1e1f4
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x50(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6c64
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0xc(%rsp), %rcx
callq 0x6cb2
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movq 0x18(%rbx), %rdx
xorpd %xmm0, %xmm0
movq 0x28(%rsp), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x6baa
movl (%rax,%rdi,4), %r8d
movq 0x8(%rdx), %r9
movq 0x28(%rdx), %r10
movsd (%r9,%r8,8), %xmm1
addsd %xmm1, %xmm0
movswq (%r10,%r8,2), %r8
addsd (%rsi,%r8,8), %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %rdi
jmp 0x6b79
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x28(%rsp), %rsi
movsd %xmm0, 0x18(%rsp)
callq 0x10386
movsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x6c21
leaq 0x20(%rbx), %rdi
movq (%rbx), %r14
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rax
cmpq %rax, %rsi
je 0x6c07
movsd (%rsi), %xmm0
ucomisd %xmm1, %xmm0
jae 0x6c07
addq $0x8, %rsi
addq $0x8, %r14
jmp 0x6bee
leaq 0x10(%rsp), %rdx
callq 0x6d08
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d7a
leaq 0x28(%rsp), %rdi
callq 0x6de4
leaq 0x40(%rsp), %rdi
callq 0x6886
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x6c3f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6de4
jmp 0x6c51
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6886
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/BlockDB.cpp
// Function: BlockDB::selectAllGroup() const
std::vector<unsigned int> BlockDB::selectAllGroup() const {
	std::vector<unsigned int> ret;
	for (int i = 0 ; i < nbGroup ; ++i)
		ret.push_back(i);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
cmpl 0x58(%r14), %ebp
jae 0x725a
movl %ebp, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6112
incl %ebp
jmp 0x7241
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6886
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/BlockDB.cpp
// Function: BlockDB::print(_IO_FILE*, bool) const
void BlockDB::print(FILE* out, bool all) const {
	DB::print(out,all);
	fprintf(out,"########## Groups Att. :\n");
	for (int i = 0 ; i < nbGroup ; ++i) {
		for (int j = 0 ; j < groups[i].size() ; ++j)
			fprintf(out,"%d ",groups[i][j]);
		fprintf(out,"\n");
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb66c
leaq 0xc413(%rip), %rdi      # 0x136ac
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3370
leaq 0xc38a(%rip), %r15      # 0x13638
xorl %r12d, %r12d
movl 0x58(%r14), %eax
cmpq %rax, %r12
jae 0x72fe
imulq $0x18, %r12, %r13
xorl %ebp, %ebp
movq 0x60(%r14), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
jbe 0x72ee
movl (%rax,%rbp,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x32a0
incq %rbp
jmp 0x72c0
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3260
incq %r12
jmp 0x72b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/ClassicNodeTree.cpp
// Function: ClassicNodeTree::test(Result&, unsigned int)
void ClassicNodeTree::test(Result &r, unsigned int obj) { 
	Node* n = root;
	std::vector<double> vote(2,0.0);
	while (!n->isLeaf()) {
		n = n->propagate(obj);
	}
	std::vector<unsigned int> list = n->getLS();
	for (int i = 0 ; i < list.size() ; ++i)
		vote[db->getOutput(list[i])]++;
	vote[0] /= list.size();
	vote[1] /= list.size();
	r.prob.push(obj,vote[1],(double)db->getOutput(obj));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rdi), %r12
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x20(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0x7(%rsp), %rcx
callq 0x6cb2
movq %r12, %rdi
callq 0xe4fa
testb %al, %al
jne 0x79ed
movq %r12, %rdi
movl %ebx, %esi
callq 0xe61e
movq %rax, %r12
jmp 0x79d2
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x6c64
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
movq 0x8(%r15), %rax
movq 0x20(%rsp), %rsi
xorl %edi, %edi
movsd 0xbcea(%rip), %xmm0     # 0x13708
cmpq %rdi, %rcx
je 0x7a45
movl (%rdx,%rdi,4), %r8d
movq 0x28(%rax), %r9
movswq (%r9,%r8,2), %r8
movsd (%rsi,%r8,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %rdi
jmp 0x7a1e
cvtsi2sd %rcx, %xmm1
movq 0x20(%rsp), %rcx
movupd (%rcx), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rcx)
addq $0x8, %r14
movl %ebx, %ecx
movq 0x28(%rax), %rax
movswl (%rax,%rcx,2), %eax
cvtsi2sd %eax, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movq %r14, %rdi
movl %ebx, %esi
callq 0xe8ee
leaq 0x8(%rsp), %rdi
callq 0x6886
leaq 0x20(%rsp), %rdi
callq 0x6de4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6886
jmp 0x7ab3
jmp 0x7ab0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6de4
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/ClassicNodeTree.cpp
// Function: ClassicNodeTree::test(std::vector<unsigned int, std::allocator<unsigned int>>*)
Result ClassicNodeTree::test(std::vector<unsigned int> *set) {
	Result r(db);
	for (int i = 0 ; i < set->size() ; ++i) {
		test(r,(*set)[i]);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0xfa38
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x7b0b
movl (%rax,%r12,4), %edx
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
incq %r12
jmp 0x7ae3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xfa56
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/ClassicNodeTree.cpp
// Function: ClassicNodeTree::testnmin(Result&, unsigned int, int)
void ClassicNodeTree::testnmin(Result &r, unsigned int obj,int nmin) { 
	Node* n = root;
	std::vector<double> vote(2,0.0);
	while (!n->isLeaf() && n->getSize() >= nmin) {
		n = n->propagate(obj);
	}
	std::vector<unsigned int> list = n->getLS();
	for (int i = 0 ; i < list.size() ; ++i)
		vote[db->getOutput(list[i])]++;
	vote[0] /= list.size();
	vote[1] /= list.size();
	r.prob.push(obj,vote[1],(double)db->getOutput(obj));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rdi), %r12
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0xf(%rsp), %rcx
callq 0x6cb2
movq %r12, %rdi
callq 0xe4fa
testb %al, %al
jne 0x7b85
cmpl %ebp, 0x58(%r12)
jb 0x7b85
movq %r12, %rdi
movl %ebx, %esi
callq 0xe61e
movq %rax, %r12
jmp 0x7b63
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x6c64
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
movq 0x8(%r15), %rax
movq 0x28(%rsp), %rsi
xorl %edi, %edi
movsd 0xbb52(%rip), %xmm0     # 0x13708
cmpq %rdi, %rcx
je 0x7bdd
movl (%rdx,%rdi,4), %r8d
movq 0x28(%rax), %r9
movswq (%r9,%r8,2), %r8
movsd (%rsi,%r8,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %rdi
jmp 0x7bb6
cvtsi2sd %rcx, %xmm1
movq 0x28(%rsp), %rcx
movupd (%rcx), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rcx)
addq $0x8, %r14
movl %ebx, %ecx
movq 0x28(%rax), %rax
movswl (%rax,%rcx,2), %eax
cvtsi2sd %eax, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movq %r14, %rdi
movl %ebx, %esi
callq 0xe8ee
leaq 0x10(%rsp), %rdi
callq 0x6886
leaq 0x28(%rsp), %rdi
callq 0x6de4
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6886
jmp 0x7c4c
jmp 0x7c49
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6de4
movq %rbx, %rdi
callq 0x3330