LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::RNNForward_CROSSENTROPY_Nthread(char const*, int)
double RNNet::RNNForward_CROSSENTROPY_Nthread(const char* pathRoot,int Nthread){
    
    char* psen=(char*)calloc(sizeof(char),41);
    int pathrootlen=strlen(pathRoot);   
    strcpy(psen,pathRoot);
    strcpy(psen+pathrootlen,"Material/");
    FreeSen();
    Sentence sentmp=FetchSent(psen);
    free(psen);
    flag = totnum-1;
    
    std::thread th[Nthread];
    int n;
   
    for(n=0;n<Nthread;++n){
        th[n]=std::thread(_Forward_CROSSENTROPY_SingleTask,\
            this,&sentmp,n);
    }
    for(n=0;n<Nthread;++n)
        th[n].join();
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x29, %esi
callq 0x20c0
movq %rax, %r12
movq %r14, %rdi
callq 0x2080
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x2140
movslq %r13d, %rax
movabsq $0x6c6169726574614d, %rcx # imm = 0x6C6169726574614D
movq %rcx, (%r12,%rax)
movw $0x2f, 0x8(%r12,%rax)
movq %r15, %rdi
callq 0x32e6
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f22
movq %rax, -0x58(%rbp)
movq %r12, %rdi
callq 0x21d0
movq %rsp, -0x38(%rbp)
movq 0x50(%r15), %rax
decq %rax
movq %rax, 0x48(%r15)
movl %ebx, %r13d
movq %rsp, %r14
leaq 0xf(,%r13,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %ebx, %ebx
je 0x383e
leaq (,%r13,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20b0
movl $0x0, -0x2c(%rbp)
testl %ebx, %ebx
jle 0x3894
leaq -0x2c(%rbp), %r12
movq %r15, -0x48(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xa6(%rip), %rsi        # 0x390a
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movq %r12, %r8
callq 0x4b00
movslq -0x2c(%rbp), %rax
cmpq $0x0, (%r14,%rax,8)
jne 0x3904
movq -0x50(%rbp), %rcx
movq %rcx, (%r14,%rax,8)
incl %eax
movl %eax, -0x2c(%rbp)
cmpl %ebx, %eax
jl 0x384d
movl $0x0, -0x2c(%rbp)
testl %ebx, %ebx
jle 0x38b8
xorl %eax, %eax
cltq
leaq (%r14,%rax,8), %rdi
callq 0x2250
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
cmpl %ebx, %eax
jl 0x38a1
testl %ebx, %ebx
je 0x38ce
shlq $0x3, %r13
cmpq $0x0, -0x8(%r14,%r13)
jne 0x3904
addq $-0x8, %r13
jne 0x38c0
movq -0x38(%rbp), %rsp
xorps %xmm0, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38e6
testl %ebx, %ebx
je 0x38fc
shlq $0x3, %r13
cmpq $0x0, -0x8(%r14,%r13)
jne 0x3904
addq $-0x8, %r13
jne 0x38ee
movq %rax, %rdi
callq 0x2260
callq 0x2060
nop
// File: /workspace/github_cpp_makefile_star2_O1/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::_Forward_CROSSENTROPY_SingleTask(RNNet*, sentence**, int)
double RNNet::_Forward_CROSSENTROPY_SingleTask(RNNet* rnn,Sentence* sen,int n){
    Sentence tsen = *sen;
    long num = tsen->num;
    std::mutex g_mutex;
    while( rnn->flag > -1){
        g_mutex.lock();
        num = rnn->flag;
        //printf("%ld\n",num);
        rnn->flag--;
        g_mutex.unlock();
        tsen = gonext(tsen,num);
        if(tsen!=NULL){
            //std::cout<<tsen->schar<<std::endl;
            rnn->_Forward_CROSSENTROPY(tsen);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, 0x48(%rdi)
js 0x3988
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2210
testl %eax, %eax
jne 0x3998
movq 0x48(%rbx), %r12
leaq -0x1(%r12), %rax
movq %rax, 0x48(%rbx)
movq %r15, %rdi
callq 0x20f0
testq %r12, %r12
jns 0x396c
xorl %r14d, %r14d
jmp 0x3971
movq 0x70(%r14), %r14
cmpq %r12, (%r14)
jg 0x3968
testq %r14, %r14
je 0x3981
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3418
cmpq $0x0, 0x48(%rbx)
jns 0x393d
xorps %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::_Backward_CROSSENTROPY_SingleTask(RNNet*, sentence**, int)
void RNNet::_Backward_CROSSENTROPY_SingleTask(RNNet* rnn,Sentence* sen,int n){
    Sentence tsen = *sen;
    std::mutex g_mutex;
    long num = tsen->num;
    while(rnn->flag > -1){
        g_mutex.lock();
        num = rnn->flag;
        //printf("%ld\n",num);
        rnn->flag--;
        g_mutex.unlock();
        tsen = gonext(tsen,num);
        if(tsen!=NULL){
            rnn->_Backward_CROSSENTROPY(tsen);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, 0x48(%rdi)
js 0x4862
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2210
testl %eax, %eax
jne 0x486f
movq 0x48(%rbx), %r12
leaq -0x1(%r12), %rax
movq %rax, 0x48(%rbx)
movq %r15, %rdi
callq 0x20f0
testq %r12, %r12
jns 0x4846
xorl %r14d, %r14d
jmp 0x484b
movq 0x70(%r14), %r14
cmpq %r12, (%r14)
jg 0x4842
testq %r14, %r14
je 0x485b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b6c
cmpq $0x0, 0x48(%rbx)
jns 0x4817
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::softmax_add(sentence*, double*, int)
void RNNet::softmax_add(Sentence sen,double* src,int t){
    double normal=0.0;
    int i;
    for(i=0;i<EMOTIONNUM;++i)
        normal+=exp(src[i]);
    
    for(i=0;i<EMOTIONNUM;++i){
        sen->energy[t][i]=exp(src[i])/normal;
     //   std::cout<<sen->energy[t][i]<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movsd %xmm1, -0x28(%rbp)
movsd (%rbx,%r12,8), %xmm0
callq 0x2270
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
incq %r12
cmpq $0x7, %r12
jne 0x4895
movslq %r15d, %r15
xorl %r12d, %r12d
movsd %xmm1, -0x28(%rbp)
movsd (%rbx,%r12,8), %xmm0
callq 0x2270
movsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq $0x7, %r12
jne 0x48bd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4916
movq %rdi, %rax
cmpq %rsi, (%rdi)
jle 0x4918
pushq %rbp
movq %rsp, %rbp
movq 0x70(%rax), %rax
cmpq %rsi, (%rax)
jg 0x490b
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32e6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4936
callq 0x530a
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 0x4939
cmpl $0x0, 0x34(%rbx)
jle 0x49bf
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 0x4965
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1684(%rip), %rsi      # 0x6064
movq %rax, %rdi
callq 0x21c0
testq %r12, %r12
je 0x4ad2
movq %rax, %rbx
leaq 0x16e6(%rip), %r13      # 0x60e1
leaq 0x16f0(%rip), %r15      # 0x60f2
movl $0x2, %esi
movl $0x1, %edx
leaq 0x16c2(%rip), %rdi      # 0x60d5
movq %rbx, %rcx
callq 0x2290
movq 0x8(%r12), %rdx
movl 0x10(%r12), %ecx
movq %rbx, %rdi
leaq 0x169a(%rip), %rsi      # 0x60c9
xorl %eax, %eax
callq 0x2200
movl $0x8, %esi
movl $0x1, %edx
leaq 0x1691(%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 0x4a52
movl $0xc, %esi
movl $0x1, %edx
leaq 0x1661(%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 0x4a8f
movsd 0x50(%r12), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2200
movq 0x70(%r12), %r12
testq %r12, %r12
jne 0x4a02
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14e7(%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 0x3788
leaq 0x14b8(%rip), %rsi      # 0x61bc
leaq -0x98(%rbp), %rdi
callq 0x49c4
leaq -0x98(%rbp), %rdi
movsd 0x1491(%rip), %xmm0     # 0x61b0
movl $0x2, %esi
callq 0x4500
leaq 0x1488(%rip), %rsi      # 0x61b8
leaq -0x98(%rbp), %rdi
movl $0x2, %edx
callq 0x3788
leaq 0x147a(%rip), %rsi      # 0x61c2
leaq -0x98(%rbp), %rdi
callq 0x49c4
leaq -0x98(%rbp), %rdi
callq 0x491a
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4d87
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x491a
movq %rbx, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x4d8f
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpq $0xe0, %rax
jae 0x51a8
andl $0x3f, %eax
shll $0xb, %eax
movq %rax, %rcx
jmp 0x51c4
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), %r12
testq %r12, %r12
setne %r14b
je 0x51f5
movslq %edx, %r15
movq (%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20a0
testl %eax, %eax
je 0x51f5
movq 0x10(%r12), %r12
testq %r12, %r12
setne %r14b
jne 0x51d4
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x521e
andl $0x3f, %eax
shll $0xb, %eax
movq %rax, %rcx
jmp 0x523a
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_O1/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 0xf6f(%rip), %rdi       # 0x61d8
movl $0x12, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2290
movl %ebx, -0x2c(%rbp)
movl %ebx, %r15d
leaq 0xe0b(%rip), %r13       # 0x6093
xorl %ecx, %ecx
movq -0x38(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax,%rcx,8), %r12
testq %r12, %r12
je 0x52eb
movl $0xa, %edi
movq %r14, %rsi
callq 0x21e0
movq (%r12), %rdx
movq %r14, %rdi
leaq 0xf35(%rip), %rsi       # 0x61eb
xorl %eax, %eax
callq 0x2200
cmpl $0x0, -0x2c(%rbp)
jle 0x52e4
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 0x52c5
movq 0x10(%r12), %r12
jmp 0x5296
movq -0x40(%rbp), %rcx
incq %rcx
cmpq $0x20000, %rcx          # imm = 0x20000
jne 0x528a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5346
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 0x531a
incq %r15
cmpq $0x20000, %r15          # imm = 0x20000
jne 0x531a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpq $0xe0, %rax
jae 0x5563
movl %eax, %ecx
andl $0x3f, %ecx
shll $0xb, %ecx
jmp 0x5581
movzbl 0x1(%rbx), %ecx
movzbl 0x2(%rbx), %edx
movl %eax, %esi
andl $0x1f, %esi
andl $0x3f, %ecx
andl $0x3f, %edx
shll $0xc, %esi
shll $0x6, %ecx
orl %esi, %ecx
orq %rdx, %rcx
cmpb $-0x40, %al
movl $0x2, %r14d
sbbq $0x0, %r14
cmpb $-0x20, %al
jb 0x55b1
movl $0x3, %r14d
cmpb $-0x10, %al
jb 0x55b1
movl $0x4, %r14d
cmpb $-0x8, %al
jb 0x55b1
cmpb $-0x4, %al
movl $0x6, %r14d
sbbq $0x0, %r14
movq (%rdi,%rcx,8), %r15
testq %r15, %r15
je 0x55d2
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20a0
testl %eax, %eax
je 0x55d5
movq 0x10(%r15), %r15
jmp 0x55b5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5631
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %edx
cmpb $-0x40, %cl
jb 0x5623
movl $0x2, %edx
cmpb $-0x20, %cl
jb 0x5623
movl $0x3, %edx
cmpb $-0x10, %cl
jb 0x5623
movl $0x4, %edx
cmpb $-0x8, %cl
jb 0x5623
cmpb $-0x4, %cl
movl $0x6, %edx
sbbq $0x0, %rdx
movb (%rdi,%rdx), %cl
addq %rdx, %rdi
incl %eax
testb %cl, %cl
jne 0x55ef
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55e3
movl %eax, %r14d
movslq %eax, %r15
leaq (,%r15,8), %rdi
callq 0x21f0
movq %rax, -0x38(%rbp)
testl %r15d, %r15d
jle 0x57cc
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 0x5541
movb (%r15), %dl
movl $0x1, %ecx
cmpb $-0x40, %dl
jb 0x56e9
movl $0x2, %ecx
cmpb $-0x20, %dl
jb 0x56e9
movl $0x3, %ecx
cmpb $-0x10, %dl
jb 0x56e9
movl $0x4, %ecx
cmpb $-0x8, %dl
jb 0x56e9
cmpb $-0x4, %dl
movl $0x6, %ecx
sbbq $0x0, %rcx
addq %rcx, %r15
movq %r15, -0x40(%rbp)
testq %rax, %rax
je 0x5721
cmpl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %r15
jle 0x57bf
movq 0x8(%rax), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x5709
jmp 0x57bf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5541
movq %rax, %r14
movb (%r15), %cl
movl $0x1, %eax
cmpb $-0x40, %cl
jb 0x5766
movl $0x2, %eax
cmpb $-0x20, %cl
jb 0x5766
movl $0x3, %eax
cmpb $-0x10, %cl
jb 0x5766
movl $0x4, %eax
cmpb $-0x8, %cl
jb 0x5766
cmpb $-0x4, %cl
movl $0x6, %eax
sbbq $0x0, %rax
addq %rax, %r15
testq %r14, %r14
je 0x5721
leaq 0xa7a(%rip), %rdi       # 0x61ef
movq -0x40(%rbp), %r15
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
cmpl $0x0, -0x2c(%rbp)
movsd 0xa41(%rip), %xmm1      # 0x61d0
jle 0x57bf
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 0x57a4
incq %r13
cmpq -0x48(%rbp), %r13
jne 0x5693
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_O1/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 0x58a1
movl %ecx, %ebx
movq %rsi, %r15
movl %ecx, %r13d
xorl %r14d, %r14d
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x5541
movl $0x1, %ecx
cmpb $-0x40, %r12b
jb 0x5859
movl $0x2, %ecx
cmpb $-0x20, %r12b
jb 0x5859
movl $0x3, %ecx
cmpb $-0x10, %r12b
jb 0x5859
movl $0x4, %ecx
cmpb $-0x8, %r12b
jb 0x5859
cmpb $-0x4, %r12b
movl $0x6, %ecx
sbbq $0x0, %rcx
testl %ebx, %ebx
movsd -0x38(%rbp), %xmm0
jle 0x588f
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 0x5870
addq %rcx, %r15
incq %r14
movb (%r15), %r12b
testb %r12b, %r12b
jne 0x5814
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5910
testl %ebx, %ebx
jle 0x590a
movq (%r14), %rsi
movq %r15, %rdi
callq 0x5541
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 0x58f3
movq 0x10(%r14), %r14
jmp 0x58d5
incq %r13
cmpq $0x20000, %r13          # imm = 0x20000
jne 0x58cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb9e0
movq %rax, %rbx
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x5433
cmpb $0x1, (%rbx)
jne 0x5433
movq %rbx, %rdi
callq 0x8f0c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8c64
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f3a
movl 0x4(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x12bd5(%rip), %xmm0    # 0x18008
testq %rbx, %rbx
je 0x5457
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x6e7c
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_O1/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 0xb054
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
testq %rbx, %rbx
je 0xb04b
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_O1/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)
cmpl $0x0, 0x10(%rdi)
je 0xb07f
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb073
callq 0x32c0
movl 0x10(%rbx), %edi
callq 0x3030
movq %rax, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movb $0x1, 0x24(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb11a
movq %rdi, %r14
cmpb $0x0, 0x24(%rdi)
je 0xb11a
movl %edx, %ebx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb190
movl 0x10(%r14), %ecx
movl 0x20(%r14), %eax
subl %eax, %ecx
cmpl %ebx, %ecx
jbe 0xb13b
addq %rax, %rdi
jmp 0xb15a
testq %r15, %r15
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0xb185
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
testq %rax, %rax
je 0xb148
movq %r14, %rdi
callq 0xb24a
movl 0x10(%r14), %eax
decl %eax
cmpl %ebx, %eax
jbe 0xb190
movl 0x20(%r14), %edi
addq 0x18(%r14), %rdi
movl %ebx, %edx
movq %r15, %rsi
callq 0x31d0
testb %bpl, %bpl
je 0xb171
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 0xb1ac
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16167
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 0x6708
addq $0x10, %rsp
callq 0x16167
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 0xb3ec
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb2ec
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0xb2ec
callq 0x16167
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 0x5e1a
callq 0x16167
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 0xb3ec
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_O1/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::insertFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
RLCSABuilder::insertFromFile(const std::string& base_name)
{
  if(!this->ok) { return; }

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

  this->flush();

  std::ifstream input(base_name.c_str(), std::ios_base::binary);
  if(!input) { return; }
  RLCSA* increment = new RLCSA(base_name);
  usint data_size = increment->getSize() + increment->getNumberOfSequences();
  uchar* data = new uchar[data_size];
  input.read((char*)data, data_size);
  input.close();

  this->addRLCSA(increment, data, data_size, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
cmpb $0x1, 0x24(%rdi)
jne 0xb3b5
movq %rsi, %r15
movq %rdi, %rbx
callq 0xb24a
movq (%r15), %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x3430
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0xb3ad
movl $0x830, %edi            # imm = 0x830
callq 0x3230
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5994
movl 0x820(%r14), %r15d
addl 0x4(%r14), %r15d
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %rsp, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x32a0
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %r15d, %ecx
movl $0x1, %r8d
callq 0xb3ec
movq %rsp, %rdi
callq 0x3090
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3240
jmp 0xb3db
jmp 0xb3d8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb4c4
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 0xb82a
movq %rax, %r15
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xb44e
movq %r12, %rdi
callq 0x32c0
callq 0x16167
movsd %xmm0, 0x8(%rsp)
movl %ebp, %r12d
leaq (%r15,%r12,4), %rsi
movq %r15, %rdi
callq 0xba6e
testl %ebp, %ebp
je 0xb486
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 0xb46e
callq 0x16167
subsd 0x8(%rsp), %xmm0
addsd 0x38(%r14), %xmm0
movsd %xmm0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xb91c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb4e4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
jmp 0xb4e4
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xb4db
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 0xb4f5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb50f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addCollection(unsigned char*, unsigned int, bool)
void
RLCSABuilder::addCollection(uchar* sequence, usint length, bool delete_sequence)
{
  double start = readTimer();
  RLCSA* temp = new RLCSA(sequence, length, this->block_size, this->sample_rate, this->threads, delete_sequence);
  this->build_time += readTimer() - start;
  this->setRLCSA(temp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x16167
movsd %xmm0, 0x8(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3230
movq %rax, %r14
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movl 0x14(%rbx), %r9d
movl %ebp, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x5e1a
callq 0x16167
subsd 0x8(%rsp), %xmm0
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, (%rbx)
movb (%r14), %al
andb %al, 0x24(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
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_O1/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 0x16167
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
xorl %r13d, %r13d
testl %ebp, %ebp
je 0xb89f
leaq 0xc(%rsp), %r12
xorl %eax, %eax
movl %eax, %ecx
cmpb $0x0, (%r15,%rcx)
jne 0xb891
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xb883
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xb88e
movq %r14, %rdi
movq %r12, %rdx
callq 0xaab6
incl %r13d
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jb 0xb864
movl %ebp, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, %r12
testl %r13d, %r13d
je 0xb8ec
movl %r13d, %r13d
xorl %ebp, %ebp
movl $0x0, %eax
testq %rbp, %rbp
je 0xb8ca
movq (%r14), %rax
movl -0x4(%rax,%rbp,4), %eax
incl %eax
movq (%rbx), %rdi
movl %eax, %ecx
leaq (%r15,%rcx), %rsi
movq (%r14), %rdx
movl (%rdx,%rbp,4), %edx
subl %eax, %edx
leaq (%r12,%rcx,4), %rcx
callq 0x74ec
incq %rbp
cmpq %rbp, %r13
jne 0xb8b7
movq (%rbx), %rdi
callq 0x6b7e
callq 0x16167
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_O1/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 0x16167
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 0x68c0
testq %r12, %r12
je 0xb96a
movq %r12, %rdi
callq 0x32c0
movq (%rbx), %r12
testq %r12, %r12
je 0xb987
movq %r12, %rdi
callq 0x6e7c
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3240
movq %r14, %rdi
callq 0x6e7c
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3240
movq %r15, (%rbx)
callq 0x16167
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_O1/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 0xb9f5
movq %rbx, %rdi
callq 0xb24a
movq (%rbx), %r14
movq %rbx, %rdi
callq 0xb054
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb24a
movq (%r14), %rdi
testq %rdi, %rdi
je 0xba41
cmpb $0x0, 0x24(%r14)
je 0xba41
movl 0x820(%rdi), %eax
addl 0x4(%rdi), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a56
movl $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43f0
movq %r14, %rdi
callq 0x4280
leaq 0x1497c(%rip), %rdx     # 0x19849
movq %r15, %rdi
movq %rax, %rsi
callq 0x5a10
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4490
movq 0x200d4(%rip), %rsi     # 0x24fc0
leaq 0x8(%rsp), %rdi
callq 0x41c0
leaq 0x78(%rsp), %rdi
callq 0x4120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x200a6(%rip), %rsi     # 0x24fc0
leaq 0x8(%rsp), %rdi
callq 0x41c0
leaq 0x78(%rsp), %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4480
leaq 0x142d9(%rip), %rsi     # 0x1a94e
leaq 0x80(%rsp), %rdi
movl $0x2, %edx
callq 0xe9e4
leaq 0xa8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0xe9ab
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0xea6c
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xe9ab
leaq 0x58(%rsp), %rdi
callq 0xeaec
leaq 0xa8(%rsp), %rdi
callq 0xeaec
leaq 0x80(%rsp), %rdi
callq 0xeaec
leaq 0x8(%rsp), %rdi
callq 0xeaec
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4560
leaq 0xa8(%rsp), %rdi
callq 0x4150
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xeaec
cmpb $-0x1, %r14b
je 0x6735
movzbl %r14b, %eax
testl %eax, %eax
jne 0x6761
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4560
leaq 0xa8(%rsp), %rdi
callq 0x4220
leaq 0xa8(%rsp), %rdi
callq 0xeaec
movq 0x30(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x10, %edx
callq 0x4380
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x61f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x43a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4340
movq 0x1e7f5(%rip), %rax     # 0x24fb8
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 0x42e0
leaq 0x1a0(%rsp), %rdi
callq 0x4120
leaq 0x30(%rsp), %rdi
callq 0xeaec
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r14
retq
jmp 0x6841
jmp 0x6853
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6830
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4340
jmp 0x6830
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x4450
jmp 0x6856
jmp 0x6853
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xeaec
jmp 0x6856
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x6898
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xeaec
jmp 0x686f
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xeaec
jmp 0x6881
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xeaec
jmp 0x6893
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xeaec
movq %rbx, %rdi
callq 0x4510
nop