LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: gonext(sentence*, long)
Sentence gonext(Sentence sen,long target){
    Sentence ret=sen;
    if(target < 0) return NULL;
    while(ret->num>target){
        ret = ret->next;
    }
    return ret;
}

// Assembly:
testq %rsi, %rsi
js 0x48f6
movq %rdi, %rax
cmpq %rsi, (%rdi)
jle 0x48f8
pushq %rbp
movq %rsp, %rbp
movq 0x70(%rax), %rax
cmpq %rsi, (%rax)
jg 0x48eb
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::FreeAll()
void RNNet::FreeAll(){
    FreeSen();
    if(ccdict!=NULL) hashFree(ccdict);
    int i,j;
    for(i=0;i<EMOTIONNUM;++i){
        free(k2out[i]);
        free(DLDk2out[i]);
    }
    for(i=0;i<hidlayerNUM;++i){
        free(in2hid[i]);
        free(ro2h[i]);
        free(rh2h[i]);
        free(DLDro2h[i]);
        free(DLDrh2h[i]);
        free(DLDin2hid[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x32ce
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4916
callq 0x52c5
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
incq %r14
cmpq $0x7, %r14
jne 0x4919
cmpl $0x0, 0x34(%rbx)
jle 0x499f
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21d0
incq %r14
movslq 0x34(%rbx), %rax
cmpq %rax, %r14
jl 0x4945
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::prtSent(char const*)
void RNNet::prtSent(const char* path){
    Sentence tmp=sent;

    FILE* fp = fopen(path,"w");
    int i,j;

    while(tmp){
        fprintf(fp,"{\n");
        fprintf(fp,"%s %d\ninVec:{\n",tmp->schar,tmp->tlen);
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<featureNUM;++j)
        //         fprintf(fp,"%f ",tmp->inVec[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\nhidLay:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<hidlayerNUM;++j)
        //         fprintf(fp,"%f ",tmp->hidLay[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\nkLayer:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<hidlayerNUM;++j)
        //         fprintf(fp,"%f ",tmp->kLayer[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\noutLay:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<EMOTIONNUM;++j)
        //         fprintf(fp,"%f ",tmp->outLay[i][j]);
        //     fprintf(fp,"\n");
        // }
        fprintf(fp,"}\neng:{\n");
        for(j=0;j<EMOTIONNUM;++j)
            fprintf(fp,"%f ",tmp->eng[j]);
        fprintf(fp,"\n}\nstdAns:{\n");
        for(j=0;j<EMOTIONNUM;++j)
            fprintf(fp,"%f ",tmp->stdAns[j]);
        fprintf(fp,"\n}\nloss:%f\n\n",tmp->loss);
        tmp=tmp->next;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq 0x78(%rdi), %r12
leaq 0x16a4(%rip), %rsi      # 0x6064
movq %rax, %rdi
callq 0x21c0
testq %r12, %r12
je 0x4ab2
movq %rax, %rbx
leaq 0x1706(%rip), %r13      # 0x60e1
leaq 0x1710(%rip), %r15      # 0x60f2
movl $0x2, %esi
movl $0x1, %edx
leaq 0x16e2(%rip), %rdi      # 0x60d5
movq %rbx, %rcx
callq 0x2290
movq 0x8(%r12), %rdx
movl 0x10(%r12), %ecx
movq %rbx, %rdi
leaq 0x16ba(%rip), %rsi      # 0x60c9
xorl %eax, %eax
callq 0x2200
movl $0x8, %esi
movl $0x1, %edx
leaq 0x16b1(%rip), %rdi      # 0x60d8
movq %rbx, %rcx
callq 0x2290
xorl %r14d, %r14d
movq 0x40(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x2200
incq %r14
cmpq $0x7, %r14
jne 0x4a32
movl $0xc, %esi
movl $0x1, %edx
leaq 0x1681(%rip), %rdi      # 0x60e5
movq %rbx, %rcx
callq 0x2290
xorl %r14d, %r14d
movq 0x48(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x2200
incq %r14
cmpq $0x7, %r14
jne 0x4a6f
movsd 0x50(%r12), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2200
movq 0x70(%r12), %r12
testq %r12, %r12
jne 0x49e2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/debugRNNet.cpp
// Function: main
int main(void){
    RNNet rnn(256,32,"../");
    const char *pa = "../";
    rnn.RNNForward_CROSSENTROPY_Nthread("../",2);    
    rnn.prtSent("SENTN");
    rnn.RNNBackward_CROSSENTROPY_Nthread(0.1,2);
    for(int n=0;n<0;++n){
        std::cout << "n: "<< n <<std::endl;
        rnn.RNNForward_CROSSENTROPY_Nthread("../",2);
        rnn.RNNBackward_CROSSENTROPY_Nthread(0.1,2);
        //rnn.prtSent("SENTN");
    }
    rnn.RNNForward_CROSSENTROPY_Nthread("../",2);
    rnn.prtSent("TSENT");
    //rnn.Save2txt("../");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x1527(%rip), %rbx      # 0x61b8
leaq -0x98(%rbp), %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
movq %rbx, %rcx
callq 0x243c
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x3744
leaq 0x14f8(%rip), %rsi      # 0x61bc
leaq -0x98(%rbp), %rdi
callq 0x49a4
leaq -0x98(%rbp), %rdi
movsd 0x14d1(%rip), %xmm0     # 0x61b0
movl $0x2, %esi
callq 0x44e8
leaq 0x14c8(%rip), %rsi      # 0x61b8
leaq -0x98(%rbp), %rdi
movl $0x2, %edx
callq 0x3744
leaq 0x14ba(%rip), %rsi      # 0x61c2
leaq -0x98(%rbp), %rdi
callq 0x49a4
leaq -0x98(%rbp), %rdi
callq 0x48fa
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4d47
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x48fa
movq %rbx, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x4d4f
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hIscontain(chUTF8**, char*, int)
bool hIscontain(ChUTF8* tab,char* src,int len){

    int offset=hFuncUTF8(src);
    ChUTF8 tmp = tab[offset];
    while(tmp){
        if(strncmp(tmp->schar,src,len)==0)
            return true;
        tmp=tmp->next;
    }

    return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpq $0xe0, %rax
jae 0x5167
andl $0x3f, %eax
shll $0xb, %eax
movq %rax, %rcx
jmp 0x5183
movzbl 0x1(%rbx), %ecx
movzbl 0x2(%rbx), %esi
andl $0x1f, %eax
andl $0x3f, %ecx
andl $0x3f, %esi
shll $0xc, %eax
shll $0x6, %ecx
orl %eax, %ecx
orq %rsi, %rcx
movq (%rdi,%rcx,8), %r15
testq %r15, %r15
je 0x51af
movslq %edx, %r14
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20a0
testl %eax, %eax
sete %al
je 0x51b1
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x518f
jmp 0x51b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashput(chUTF8**, chUTF8*)
void hashput(ChUTF8* tab,ChUTF8 unit){

    int offset;
    offset=hFuncUTF8(unit->schar);
    unit->next=tab[offset];
    tab[offset]=unit;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movzbl (%rdx), %eax
cmpq $0xe0, %rax
jae 0x51d9
andl $0x3f, %eax
shll $0xb, %eax
movq %rax, %rcx
jmp 0x51f5
movzbl 0x1(%rdx), %ecx
movzbl 0x2(%rdx), %edx
andl $0x1f, %eax
andl $0x3f, %ecx
andl $0x3f, %edx
shll $0xc, %eax
shll $0x6, %ecx
orl %eax, %ecx
orq %rdx, %rcx
movq (%rdi,%rcx,8), %rax
movq %rax, 0x10(%rsi)
movq %rsi, (%rdi,%rcx,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: prtHash2File(chUTF8**, _IO_FILE*, int)
void prtHash2File(ChUTF8* tab,FILE* fp,int dim){

    //default size 32*64*64
    int i,j;
    ChUTF8 tmp;
    fprintf(fp,"Standard_Dict_Form");
    for(i=0;i<32*64*64;++i){
        tmp=tab[i];
        while(tmp){
            fprintf(fp,"\n");
            fprintf(fp,"%s ",tmp->schar);
            for(j=0;j<dim;++j)
                fprintf(fp,"#%lf#",tmp->vecftr[j]);
            tmp=tmp->next;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq 0xfb4(%rip), %rdi       # 0x61d8
movl $0x12, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2290
movl %ebx, -0x2c(%rbp)
movl %ebx, %r15d
leaq 0xe50(%rip), %r13       # 0x6093
xorl %ecx, %ecx
movq -0x38(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax,%rcx,8), %r12
testq %r12, %r12
je 0x52a6
movl $0xa, %edi
movq %r14, %rsi
callq 0x21e0
movq (%r12), %rdx
movq %r14, %rdi
leaq 0xf7a(%rip), %rsi       # 0x61eb
xorl %eax, %eax
callq 0x2200
cmpl $0x0, -0x2c(%rbp)
jle 0x529f
xorl %ebx, %ebx
movq 0x8(%r12), %rax
movsd (%rax,%rbx,8), %xmm0
movq %r14, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x2200
incq %rbx
cmpq %rbx, %r15
jne 0x5280
movq 0x10(%r12), %r12
jmp 0x5251
movq -0x40(%rbp), %rcx
incq %rcx
cmpq $0x20000, %rcx          # imm = 0x20000
jne 0x5245
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashFree(chUTF8**)
void hashFree(ChUTF8* tab){

    int i;
    ChUTF8 tmp;

    for(i=0;i<32*64*64;++i){
        while(tab[i]){
            tmp=tab[i];
            tab[i]=tab[i]->next;
            free(tmp->schar);
            free(tmp->vecftr);
            free(tmp);
        }
    }
    free(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %r14
testq %r14, %r14
je 0x5301
movq 0x10(%r14), %rax
movq %rax, (%rbx,%r15,8)
movq (%r14), %rdi
callq 0x21d0
movq 0x8(%r14), %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x21d0
jmp 0x52d5
incq %r15
cmpq $0x20000, %r15          # imm = 0x20000
jne 0x52d5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashget(chUTF8**, char*)
ChUTF8 hashget(ChUTF8* tab,char* src){

    int offset=hFuncUTF8(src);
    int len=retLenUTF8(src);
    ChUTF8 tmp = tab[offset];
    while(tmp){
        if(strncmp(tmp->schar,src,len)==0)
            return tmp;
        tmp=tmp->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl (%rsi), %ecx
cmpl $0xdf, %ecx
ja 0x552b
movl %ecx, %eax
andl $0x3f, %eax
shll $0xb, %eax
cmpb $-0x40, %cl
movl $0x2, %r14d
sbbq $0x0, %r14
jmp 0x555e
movzbl 0x1(%rbx), %eax
movzbl 0x2(%rbx), %edx
movl %ecx, %esi
andl $0x1f, %esi
andl $0x3f, %eax
andl $0x3f, %edx
shll $0xc, %esi
shll $0x6, %eax
orl %esi, %eax
orl %edx, %eax
movl $0x3, %r14d
cmpb $-0x10, %cl
jb 0x555e
movl $0x4, %r14d
cmpb $-0x8, %cl
jae 0x5592
movl %eax, %eax
movq (%rdi,%rax,8), %r15
testq %r15, %r15
je 0x5581
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20a0
testl %eax, %eax
je 0x5584
movq 0x10(%r15), %r15
jmp 0x5564
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $-0x4, %cl
movl $0x6, %r14d
jmp 0x5525
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: strLenUTF8(char*)
int strLenUTF8(char* str){
    int ret=0;
    char* point;
    point = str;
    while(*str!='\0'){
        str+=retLenUTF8(str);
        ++ret;
    }
    return ret;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x55eb
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %edx
cmpb $-0x40, %cl
jb 0x55dd
movl $0x2, %edx
cmpb $-0x20, %cl
jb 0x55dd
movl $0x3, %edx
cmpb $-0x10, %cl
jb 0x55dd
movl $0x4, %edx
cmpb $-0x8, %cl
jb 0x55dd
cmpb $-0x4, %cl
movl $0x6, %edx
sbbq $0x0, %rdx
movb (%rdi,%rdx), %cl
addq %rdx, %rdi
incl %eax
testb %cl, %cl
jne 0x55a9
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: crtInvec(char*, int, chUTF8**)
double** crtInvec(char* str,int invecdim,ChUTF8* tab){

    int senlen=strLenUTF8(str);
    double** ret = (double**)malloc(sizeof(double*)*senlen);
    int i,j;
    char* point=str;
    char* now;
    ChUTF8 tmp;
    for(i=0;i<senlen;++i){
        ret[i]=(double*)malloc(sizeof(double)*invecdim);
        tmp=hashget(tab,point);
        point+=retLenUTF8(point);
    //    std::cout<< tmp->schar << retLenUTF8(point) <<std::endl;
        if(tmp!=NULL){
            for(j=0;j<invecdim;++j){
                ret[i][j]=tmp->vecftr[j];
            }
        }else{
            now=point;            
            do{
                tmp=hashget(tab,now);
                now+=retLenUTF8(now);
            }while(tmp==NULL);
            printf("pre not found \n %s\n ",point);
            for(j=0;j<invecdim;++j){
                ret[i][j]=tmp->vecftr[j]+ret[i-1][j];
                ret[i][j]/=2.0;
            }
        }
    }

    return ret;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
callq 0x559d
movl %eax, %r14d
movslq %eax, %r15
leaq (,%r15,8), %rdi
callq 0x21f0
movq %rax, -0x38(%rbp)
testl %r15d, %r15d
jle 0x5786
movq %r12, %r15
movslq -0x2c(%rbp), %rax
leaq (,%rax,8), %rcx
movq %rcx, -0x50(%rbp)
movl %r14d, %ecx
movq %rcx, -0x48(%rbp)
movl %eax, %r12d
xorl %r13d, %r13d
movq -0x50(%rbp), %rdi
callq 0x21f0
movq %rax, %r14
movq -0x38(%rbp), %rax
movq %r14, (%rax,%r13,8)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x54fc
movb (%r15), %dl
movl $0x1, %ecx
cmpb $-0x40, %dl
jb 0x56a3
movl $0x2, %ecx
cmpb $-0x20, %dl
jb 0x56a3
movl $0x3, %ecx
cmpb $-0x10, %dl
jb 0x56a3
movl $0x4, %ecx
cmpb $-0x8, %dl
jb 0x56a3
cmpb $-0x4, %dl
movl $0x6, %ecx
sbbq $0x0, %rcx
addq %rcx, %r15
movq %r15, -0x40(%rbp)
testq %rax, %rax
je 0x56db
cmpl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %r15
jle 0x5779
movq 0x8(%rax), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x56c3
jmp 0x5779
movq %rbx, %rdi
movq %r15, %rsi
callq 0x54fc
movq %rax, %r14
movb (%r15), %cl
movl $0x1, %eax
cmpb $-0x40, %cl
jb 0x5720
movl $0x2, %eax
cmpb $-0x20, %cl
jb 0x5720
movl $0x3, %eax
cmpb $-0x10, %cl
jb 0x5720
movl $0x4, %eax
cmpb $-0x8, %cl
jb 0x5720
cmpb $-0x4, %cl
movl $0x6, %eax
sbbq $0x0, %rax
addq %rax, %r15
testq %r14, %r14
je 0x56db
leaq 0xac0(%rip), %rdi       # 0x61ef
movq -0x40(%rbp), %r15
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
cmpl $0x0, -0x2c(%rbp)
movsd 0xa87(%rip), %xmm1      # 0x61d0
jle 0x5779
movq 0x8(%r14), %rax
movq -0x38(%rbp), %rdx
movq -0x8(%rdx,%r13,8), %rcx
movq (%rdx,%r13,8), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
addsd (%rcx,%rsi,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %r12
jne 0x575e
incq %r13
cmpq -0x48(%rbp), %r13
jne 0x564d
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: upgradeDict(chUTF8**, char*, double**, int, double)
void upgradeDict(ChUTF8* tab,char* str,double** dInvec,int indim,double lnrt){

    int offset,i,j;
    ChUTF8 dicbody;
    char* now=str;
    j=0;
  //  dicbody=hashget(tab,str);
  //  std::cout<< "dic : "<<dicbody->vecftr[0] << " ";
    while(*now!='\0'){
        dicbody=hashget(tab,now);
    //    std::cout<< dicbody->schar <<std::endl;
        offset=retLenUTF8(now);
        now+=offset;
        for(i=0;i<indim;++i){
    //        std::cout<< dicbody->schar<< " ";
    //        std::cout<< dicbody->vecftr[0] << " ";
            dicbody->vecftr[i]-=dInvec[j][i]*lnrt;
        }
        ++j;
    }
 //   dicbody=hashget(tab,str);
 //   std::cout<< dicbody->vecftr[0] << std::endl;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movb (%rsi), %r12b
testb %r12b, %r12b
je 0x585b
movl %ecx, %ebx
movq %rsi, %r15
movl %ecx, %r13d
xorl %r14d, %r14d
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x54fc
movl $0x1, %ecx
cmpb $-0x40, %r12b
jb 0x5813
movl $0x2, %ecx
cmpb $-0x20, %r12b
jb 0x5813
movl $0x3, %ecx
cmpb $-0x10, %r12b
jb 0x5813
movl $0x4, %ecx
cmpb $-0x8, %r12b
jb 0x5813
cmpb $-0x4, %r12b
movl $0x6, %ecx
sbbq $0x0, %rcx
testl %ebx, %ebx
movsd -0x38(%rbp), %xmm0
jle 0x5849
movq -0x30(%rbp), %rdx
movq (%rdx,%r14,8), %rdx
movq 0x8(%rax), %rax
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r13
jne 0x582a
addq %rcx, %r15
incq %r14
movb (%r15), %r12b
testb %r12b, %r12b
jne 0x57ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: upDictbyTab(chUTF8**, chUTF8**, int, double)
void upDictbyTab(ChUTF8* tab,ChUTF8* ttab,int indim,double lnrt){

    int i,j;
    ChUTF8 tmp,adj;

    for(i=0;i<32*64*64;++i){
        tmp=ttab[i];
        while(tmp){
            adj=hashget(tab,tmp->schar);
            for(j=0;j<indim;++j){
                adj->vecftr[j]-=tmp->vecftr[j];
            }                      
            tmp=tmp->next;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movl %edx, %r12d
xorl %r13d, %r13d
movq -0x30(%rbp), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x58ca
testl %ebx, %ebx
jle 0x58c4
movq (%r14), %rsi
movq %r15, %rdi
callq 0x54fc
movq 0x8(%r14), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x58ad
movq 0x10(%r14), %r14
jmp 0x588f
incq %r13
cmpq $0x20000, %r13          # imm = 0x20000
jne 0x5887
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/merge_rlcsa.cpp
// Function: getRLCSA(CSA::RLCSABuilder&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double
getRLCSA(RLCSABuilder& builder, const std::string& base_name)
{
  double megabytes = 0.0;

  RLCSA* index = builder.getRLCSA();
  if(index != 0 && index->isOk())
  {
    index->printInfo();
    index->reportSize(true);
    index->writeTo(base_name);
    megabytes = index->getSize() / (double)MEGABYTE;
  }

  delete index;
  return megabytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0xbb6c
movq %rax, %rbx
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x5442
cmpb $0x1, (%rbx)
jne 0x5433
movq %rbx, %rdi
callq 0x909a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8df2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f28
movl 0x4(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x12bd5(%rip), %xmm0    # 0x18008
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6e6e
jmp 0x5447
movsd %xmm0, (%rsp)
movl $0x830, %esi            # imm = 0x830
movq %rbx, %rdi
callq 0x3240
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::RLCSABuilder(unsigned int, unsigned int, unsigned int, unsigned int, CSA::RLCSA*)
RLCSABuilder::RLCSABuilder(usint _block_size, usint _sample_rate, usint _buffer_size, usint _threads, RLCSA* _index) :
  block_size(_block_size), sample_rate(_sample_rate), buffer_size(_buffer_size),
  threads(_threads),
  buffer(0)
{
  this->reset();
  this->build_time = this->search_time = this->sort_time = this->merge_time = 0.0;
  
  if(_index != NULL)
  {
    this->setRLCSA(_index);
  }
  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
movq $0x0, 0x18(%rdi)
callq 0xb1c8
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
testq %rbx, %rbx
je 0xb1bf
movq %rbx, (%r14)
movb (%rbx), %al
andb %al, 0x24(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::reset()
void
RLCSABuilder::reset()
{
  this->index = 0;

  if(this->buffer_size != 0)
  {
    delete[] this->buffer;
    this->buffer = new uchar[this->buffer_size];
  }
  this->chars = 0;

  this->ok = true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rdi)
movl 0x10(%rdi), %eax
testl %eax, %eax
je 0xb1f6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb1eb
callq 0x32c0
movl 0x10(%rbx), %eax
movl %eax, %edi
callq 0x3030
movq %rax, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movb $0x1, 0x24(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::insertSequence(char*, unsigned int, bool)
void
RLCSABuilder::insertSequence(char* sequence, usint length, bool delete_sequence)
{
  if(sequence == 0 || length == 0 || !this->ok)
  {
    if(delete_sequence) { delete[] sequence; }
    return;
  }

  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(this->threads);
  #endif

  if(this->buffer == 0)
  {
    this->addLongSequence((uchar*)sequence, length, delete_sequence);
    return;
  }

  if(this->buffer_size - this->chars > length)
  {
    memcpy(this->buffer + this->chars, sequence, length);
    if(delete_sequence) { delete[] sequence; }
    this->chars += length;
    this->buffer[this->chars] = 0;
    this->chars++;
  }
  else
  {
    if(this->chars > 0) { this->flush(); }
    if(length >= this->buffer_size - 1)
    {
      this->addLongSequence((uchar*)sequence, length, delete_sequence);
    }
    else
    {
      memcpy(this->buffer + this->chars, sequence, length);
      if(delete_sequence) { delete[] sequence; }
      this->chars += length;
      this->buffer[this->chars] = 0;
      this->chars++;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r15
testq %rsi, %rsi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0xb294
movq %rdi, %r14
cmpb $0x0, 0x24(%rdi)
je 0xb294
movl %edx, %ebx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb30a
movl 0x10(%r14), %eax
movl 0x20(%r14), %ecx
movl %eax, %edx
subl %ecx, %edx
cmpl %ebx, %edx
jbe 0xb2b5
addq %rcx, %rdi
jmp 0xb2d4
testq %r15, %r15
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0xb2ff
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
testq %rcx, %rcx
je 0xb2c6
movq %r14, %rdi
callq 0xb3c4
movl 0x10(%r14), %eax
decl %eax
cmpl %ebx, %eax
jbe 0xb30a
movl 0x20(%r14), %edi
addq 0x18(%r14), %rdi
movl %ebx, %edx
movq %r15, %rsi
callq 0x31d0
testb %bpl, %bpl
je 0xb2eb
movq %r15, %rdi
callq 0x32c0
addl 0x20(%r14), %ebx
movl %ebx, 0x20(%r14)
movq 0x18(%r14), %rax
movb $0x0, (%rax,%rbx)
incl 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb326
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addLongSequence(unsigned char*, unsigned int, bool)
void
RLCSABuilder::addLongSequence(uchar* sequence, usint length, bool delete_sequence)
{
  double start = readTimer();
  RLCSA* temp = new RLCSA(sequence, length, this->block_size, this->sample_rate, this->threads, 0, false);
  this->build_time += readTimer() - start;
  this->addRLCSA(temp, sequence, length, delete_sequence); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x16787
movsd %xmm0, 0x8(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3230
movq %rax, %r12
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
movl 0x14(%r15), %r9d
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
pushq $0x0
pushq $0x0
callq 0x66d2
addq $0x10, %rsp
callq 0x16787
subsd 0x8(%rsp), %xmm0
addsd 0x28(%r15), %xmm0
movsd %xmm0, 0x28(%r15)
movzbl %bpl, %r8d
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb566
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::flush()
void
RLCSABuilder::flush()
{
  if(this->buffer == 0 || this->chars == 0) { return; }

  double start = readTimer();
  RLCSA* temp = new RLCSA(this->buffer, this->chars, this->block_size, this->sample_rate, this->threads, (this->index == 0));
  this->build_time += readTimer() - start;
  this->addRLCSA(temp, this->buffer, this->chars, (this->index != 0));

  this->chars = 0;
  this->buffer = new uchar[this->buffer_size];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x18(%rdi)
je 0xb466
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0xb466
callq 0x16787
movsd %xmm0, 0x10(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3230
movq %rax, %r14
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movl 0x14(%rbx), %r9d
xorl %eax, %eax
cmpq $0x0, (%rbx)
sete %al
movl %eax, (%rsp)
movq %r14, %rdi
callq 0x5df6
callq 0x16787
subsd 0x10(%rsp), %xmm0
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
movq 0x18(%rbx), %rdx
movl 0x20(%rbx), %ecx
xorl %r8d, %r8d
cmpq $0x0, (%rbx)
setne %r8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb566
movl $0x0, 0x20(%rbx)
movl 0x10(%rbx), %edi
callq 0x3030
movq %rax, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addRLCSA(CSA::RLCSA*, unsigned char*, unsigned int, bool)
void
RLCSABuilder::addRLCSA(RLCSA* increment, uchar* sequence, usint length, bool delete_sequence)
{
  if(this->index == 0)
  {
    if(delete_sequence) { delete[] sequence; }
    this->setRLCSA(increment);
    return;
  }

  std::vector<usint> end_markers;
  usint* ranks = this->getRanks(sequence, length, end_markers);
  if(delete_sequence) { delete[] sequence; }

  double mark = readTimer();
  parallelSort(ranks, ranks + length);
  #pragma omp parallel for schedule(static)
  for(usint i = 0; i < length; i++) { ranks[i] += i + 1; }
  this->sort_time += readTimer() - mark;

  this->mergeRLCSA(increment, ranks, length);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0xb63e
movl %ecx, %ebp
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movapd %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xb9a8
movq %rax, %r15
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xb5c8
movq %r12, %rdi
callq 0x32c0
callq 0x16787
movsd %xmm0, 0x8(%rsp)
movl %ebp, %r12d
leaq (%r15,%r12,4), %rsi
movq %r15, %rdi
callq 0xbbfa
testl %ebp, %ebp
je 0xb600
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
addl %eax, %ecx
incl %ecx
movl %ecx, (%r15,%rax,4)
leaq 0x1(%rax), %rcx
movq %rcx, %rax
cmpq %rcx, %r12
jne 0xb5e8
callq 0x16787
subsd 0x8(%rsp), %xmm0
addsd 0x38(%r14), %xmm0
movsd %xmm0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xbaa8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb65e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
jmp 0xb65e
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xb655
movq %r12, %rdi
callq 0x32c0
movq %rbx, (%r14)
movb (%rbx), %al
andb %al, 0x24(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb66f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb689
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getRanks(unsigned char*, unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>&)
usint*
RLCSABuilder::getRanks(uchar* sequence, usint length, std::vector<usint>& end_markers)
{
  double start = readTimer();

  usint sequences = 0;
  for(usint i = 0; i < length; i++)
  {
    if(sequence[i] == 0) { end_markers.push_back(i); sequences++; }
  }

  usint* ranks = new usint[length];
  #ifdef MULTITHREAD_SUPPORT
  usint chunk = std::max((usint)1, sequences / (8 * this->threads));
  #endif
  #pragma omp parallel for schedule(dynamic, chunk)
  for(usint i = 0; i < sequences; i++)
  {
    usint begin = (i > 0 ? end_markers[i - 1] + 1 : 0);
    this->index->reportPositions(sequence + begin, end_markers[i] - begin, ranks + begin);
  }

  this->index->strip();

  this->search_time += readTimer() - start;
  return ranks;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x16787
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
je 0xba6e
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
xorl %eax, %eax
movl %eax, %ecx
cmpb $0x0, (%r15,%rcx)
jne 0xba17
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xba05
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xba10
movq %r14, %rdi
movq %r12, %rdx
callq 0xac32
incl %r13d
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jb 0xb9e6
movl %ebp, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, %r12
testl %r13d, %r13d
je 0xba78
movl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rax
movl $0x0, %ecx
testq %rbp, %rbp
je 0xba4c
movl -0x4(%rax,%rbp,4), %ecx
incl %ecx
movq (%rbx), %rdi
movl %ecx, %r8d
leaq (%r15,%r8), %rsi
movl (%rax,%rbp,4), %edx
subl %ecx, %edx
leaq (%r12,%r8,4), %rcx
callq 0x74e8
incq %rbp
cmpq %rbp, %r13
jne 0xba39
jmp 0xba78
xorl %edi, %edi
callq 0x3030
movq %rax, %r12
movq (%rbx), %rdi
callq 0x6b70
callq 0x16787
subsd 0x10(%rsp), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::mergeRLCSA(CSA::RLCSA*, unsigned int*, unsigned int)
void
RLCSABuilder::mergeRLCSA(RLCSA* increment, usint* ranks, usint length)
{
  double mark = readTimer();

  RLCSA* merged = new RLCSA(*(this->index), *increment, ranks, this->block_size, this->threads);
  delete[] ranks;
  delete this->index;
  delete increment;
  this->index = merged;

  this->merge_time += readTimer() - mark;

  this->ok &= this->index->isOk();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x16787
movsd %xmm0, (%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3230
movq %rax, %r15
movq (%rbx), %rsi
movl 0x8(%rbx), %r8d
movl 0x14(%rbx), %r9d
movq %rax, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x68b2
testq %r12, %r12
je 0xbaf6
movq %r12, %rdi
callq 0x32c0
movq (%rbx), %r12
testq %r12, %r12
je 0xbb06
movq %r12, %rdi
callq 0x6e6e
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3240
movq %r14, %rdi
callq 0x6e6e
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3240
movq %r15, (%rbx)
callq 0x16787
subsd (%rsp), %xmm0
addsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
movq (%rbx), %rax
movb (%rax), %al
andb %al, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r15, %rdi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getRLCSA()
RLCSA*
RLCSABuilder::getRLCSA()
{
  if(this->chars > 0) { this->flush(); }

  RLCSA* temp = this->index;
  this->reset();

  return temp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0xbb81
movq %rbx, %rdi
callq 0xb3c4
movq (%rbx), %r14
movq %rbx, %rdi
callq 0xb1c8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getBWT(unsigned int&)
char*
RLCSABuilder::getBWT(usint& length)
{
  this->flush();

  if(this->index == 0 || !(this->ok))
  {
    length = 0;
    return 0;
  }

  length = this->index->getSize() + this->index->getNumberOfSequences();
  return (char*)(this->index->readBWT());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb3c4
movq (%r14), %rdi
testq %rdi, %rdi
je 0xbbcd
cmpb $0x0, 0x24(%r14)
je 0xbbcd
movl 0x820(%rdi), %eax
addl 0x4(%rdi), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8be4
movl $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./nlohmann/json.hpp
// Function: nlohmann::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character()
    {
        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == EOF))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x3636
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rdi)
popq %rbx
retq
movq (%rdi), %rax
callq *0x50(%rax)
cmpl $-0x1, %eax
jne 0x3634
movq (%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x2, %esi
callq 0x34e0
pushq $-0x1
popq %rax
jmp 0x3634
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./timestamp_as_string.hpp
// Function: getTimestampAsString[abi:cxx11](std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
std::string getTimestampAsString(std::chrono::time_point<std::chrono::system_clock> chrono_inputTime)
{
    std::time_t inputTime = std::chrono::system_clock::to_time_t(chrono_inputTime);
    std::ostringstream os;
    os << std::put_time(std::localtime(&inputTime), "%c");
    return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %rax
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %rdx, (%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33f0
movq %r14, %rdi
callq 0x3280
leaq 0x148d1(%rip), %rdx     # 0x18849
movq %r15, %rdi
movq %rax, %rsi
callq 0x4abb
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3490
movq 0x20029(%rip), %rsi     # 0x23fc0
leaq 0x8(%rsp), %rdi
callq 0x31c0
leaq 0x78(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x1fffb(%rip), %rsi     # 0x23fc0
leaq 0x8(%rsp), %rdi
callq 0x31c0
leaq 0x78(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./Blockchain.hpp
// Function: Blockchain::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short)
void save(const std::string output_filename = "blockchain.json", const std::int16_t indent = 4)
    {
        std::filesystem::path output_path = std::filesystem::path(std::filesystem::current_path() / "blockchain" / output_filename);

        if(!std::filesystem::exists(output_path.parent_path()))
            std::filesystem::create_directories(output_path.parent_path());

        std::ofstream output_file(output_path);
        output_file << dump();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3480
leaq 0x14279(%rip), %rsi     # 0x1994e
leaq 0x80(%rsp), %rdi
movl $0x2, %edx
callq 0xd856
leaq 0xa8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0xd81d
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0xd8de
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xd81d
leaq 0x58(%rsp), %rdi
callq 0xd95e
leaq 0xa8(%rsp), %rdi
callq 0xd95e
leaq 0x80(%rsp), %rdi
callq 0xd95e
leaq 0x8(%rsp), %rdi
callq 0xd95e
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3560
leaq 0xa8(%rsp), %rdi
callq 0x3150
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xd95e
cmpb $-0x1, %r14b
je 0x5795
movzbl %r14b, %eax
testl %eax, %eax
jne 0x57c1
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3560
leaq 0xa8(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0xd95e
movq 0x30(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x10, %edx
callq 0x3380
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x529a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x33a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x581c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
movq 0x1e795(%rip), %rax     # 0x23fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0xb0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0xa8(%rsp,%rcx)
callq 0x32e0
leaq 0x1a0(%rsp), %rdi
callq 0x3120
leaq 0x30(%rsp), %rdi
callq 0xd95e
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r14
retq
jmp 0x58a1
jmp 0x58b3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5890
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0x5890
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x3450
jmp 0x58b6
jmp 0x58b3
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xd95e
jmp 0x58b6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x58f8
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xd95e
jmp 0x58cf
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xd95e
jmp 0x58e1
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xd95e
jmp 0x58f3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd95e
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./Block.hpp
// Function: Block::Block(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int, Transaction)
Block(std::uint64_t index, std::string previousBlockHash, std::uint32_t difficulty, std::uint32_t maxTransactionsCount, Transaction transaction)
    {
        this->index = index;
        this->previousBlockHash = previousBlockHash;
        this->difficulty = difficulty;
        this->maxTransactionsCount = maxTransactionsCount;
        transactions.push_back(transaction);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x40(%rsp)
movl %r8d, 0xc(%rsp)
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x30(%rsp)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x48(%rdi)
movl $0x3, 0x50(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movq %rax, 0x68(%rdi)
addq $0x70, %rdi
leaq 0x80(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x70(%rbx)
leaq 0x12b02(%rip), %rdx     # 0x18eff
movq %rdi, 0x38(%rsp)
movq %rdx, %rsi
callq 0xd9ec
leaq 0x90(%rbx), %r12
leaq 0xa0(%rbx), %rbp
movq %rbp, 0x90(%rbx)
leaq 0x12482(%rip), %rsi     # 0x188a8
leaq 0x12488(%rip), %rdx     # 0x188b5
movq %r12, %rdi
callq 0xd9ec
movq %r13, (%rbx)
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x31d0
movl %r14d, 0x54(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x50(%rbx)
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x64fc
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6490
movq %rax, %r14
jmp 0x64af
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x6490
movq (%rbp), %rsi
incq %rsi
callq 0x3340
movq 0x38(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x64af
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3340
movq 0x28(%rsp), %rdi
callq 0x6526
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x64d8
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3340
movq 0x8(%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x64f3
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3340
movq %r14, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./Block.hpp
// Function: Block::mine(unsigned int)
void mine(std::uint32_t difficulty = 1)
    {
        std::cout << "Starting mining of block " << index << '\n';
        const auto miningStartTime = std::chrono::system_clock::now();

        do
        {
            ++nounce;
            blockHash = calculateHash();
        } while (!std::all_of(blockHash.begin(), blockHash.begin() + difficulty, [](char & a){
                return a == '0';
            }));

        minedAt = getTimestampAsString(std::chrono::system_clock::now());
        std::cout << "Block "<< index << " mined, nounce " << nounce << ", hash: " << blockHash << '\n'; 
        std::cout << "Took " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - miningStartTime).count() << " milliseconds to mine block\n";
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x1d502(%rip), %rbx     # 0x23fd0
leaq 0x11e0b(%rip), %rsi     # 0x188e0
movl $0x19, %edx
movq %rbx, %rdi
callq 0x33a0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3230
leaq 0x8(%rsp), %r15
movb $0xa, (%r15)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x33a0
callq 0x3060
movq %rax, (%rsp)
leaq 0x8(%r14), %r12
leaq 0x18(%rsp), %rbx
movl %ebp, %ebp
incq 0x48(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6c82
movq %r12, %rdi
movq %r15, %rsi
callq 0x33d0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x6b4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
movq (%r12), %rdi
leaq (%rdi,%rbp), %r13
movq %r13, %rsi
callq 0x708b
cmpq %r13, %rax
jne 0x6b1a
callq 0x3060
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3f29
leaq 0x90(%r14), %rdi
movq %r15, %rsi
callq 0x33d0
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x6b99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
movq 0x1d430(%rip), %r15     # 0x23fd0
leaq 0x11d53(%rip), %rsi     # 0x188fa
movl $0x6, %edx
movq %r15, %rdi
callq 0x33a0
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3230
movq %rax, %r12
leaq 0x11d38(%rip), %rsi     # 0x18901
movl $0xf, %edx
movq %rax, %rdi
callq 0x33a0
movq 0x48(%r14), %rsi
movq %r12, %rdi
callq 0x3230
movq %rax, %r12
leaq 0x11d25(%rip), %rsi     # 0x18911
movl $0x8, %edx
movq %rax, %rdi
callq 0x33a0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r12, %rdi
callq 0x33a0
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x33a0
leaq 0x11cf5(%rip), %rsi     # 0x1891a
movl $0x5, %edx
movq %r15, %rdi
callq 0x33a0
callq 0x3060
subq (%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x3310
leaq 0x11cbb(%rip), %rsi     # 0x18920
movl $0x1c, %edx
movq %rax, %rdi
callq 0x33a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArthoPacini[P]blockchaincpp/./nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&)
void push_back(const basic_json& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
            assert_invariant();
        }

        // add element to array
        m_value.array->push_back(val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xa639
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x3330
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x829a
jmp 0xa63e
cmpl $0x2, %eax
jne 0xa654
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb3f0
movl $0x20, %edi
callq 0x31a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x8a50
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x3190
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xd9ec
leaq 0xe69e(%rip), %rsi      # 0x18d33
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x89df
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x84ca
xorl %ebp, %ebp
leaq 0x194d6(%rip), %rsi     # 0x23b98
leaq 0x7129(%rip), %rdx      # 0x117f2
movq %rbx, %rdi
callq 0x3500
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa6ef
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3340
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa706
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
testb %bpl, %bpl
jne 0xa72c
jmp 0xa734
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa72c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0xa72c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3270
movq %r14, %rdi
callq 0x3510