LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::FreeSen()
int RNNet::FreeSen(){
    if(sent==NULL) return 0;
    Sentence tmp;
    int i,j;
    while(sent){
        tmp = sent;
        sent=sent->next;
        free(tmp->schar);
        for(i=0;i<tmp->tlen;++i){
            free(tmp->inVec[i]);
            free(tmp->hidLay[i]);
            free(tmp->outLay[i]);
            free(tmp->kLayer[i]);
            free(tmp->energy[i]);
            free(tmp->DLDh[i]);
            free(tmp->DLDo[i]);
            free(tmp->DLDx[i]);
        }
        free(tmp->inVec);
        free(tmp->hidLay);
        free(tmp->kLayer);
        free(tmp->outLay);
        free(tmp->energy);
        free(tmp->eng);
        free(tmp->stdAns);
        free(tmp->DLDh);
        free(tmp->DLDo);
        free(tmp->DLDx);
        free(tmp);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x78(%rax)
jne 0x3547
movl $0x0, -0x4(%rbp)
jmp 0x36e1
jmp 0x3549
movq -0x28(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x36da
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x78(%rax), %rcx
movq 0x70(%rcx), %rcx
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21a0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x364a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3584
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x21a0
jmp 0x3549
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5c00
movq -0x8(%rbp), %rax
cmpq $-0x1, 0x48(%rax)
jle 0x4012
leaq -0x50(%rbp), %rdi
callq 0x5bb0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rax)
leaq -0x50(%rbp), %rdi
callq 0x5be0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5560
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4010
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36f0
jmp 0x3fb2
xorps %xmm0, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5c00
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
cmpq $-0x1, 0x48(%rax)
jle 0x54a2
leaq -0x48(%rbp), %rdi
callq 0x5bb0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rax)
leaq -0x48(%rbp), %rdi
callq 0x5be0
movq -0x20(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5560
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x54a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4340
jmp 0x5442
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x7, -0x2c(%rbp)
jge 0x5503
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2240
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x54d6
movl $0x0, -0x2c(%rbp)
cmpl $0x7, -0x2c(%rbp)
jge 0x554b
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2240
divsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x550a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x5585
movq $0x0, -0x8(%rbp)
jmp 0x55aa
jmp 0x5587
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jle 0x55a2
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5587
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3520
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x55df
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7110
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x5621
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x55e6
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x34(%rcx), %eax
jge 0x56c4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5628
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2969(%rip), %rsi      # 0x8060
callq 0x2190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5804
movq -0x20(%rbp), %rdi
leaq 0x29bb(%rip), %rsi      # 0x80d1
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x298e(%rip), %rsi      # 0x80c5
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rdi
leaq 0x298b(%rip), %rsi      # 0x80d4
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x28(%rbp)
cmpl $0x7, -0x28(%rbp)
jge 0x578b
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x2964(%rip), %rsi      # 0x80dd
movb $0x1, %al
callq 0x21d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5757
movq -0x20(%rbp), %rdi
leaq 0x294b(%rip), %rsi      # 0x80e1
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x28(%rbp)
cmpl $0x7, -0x28(%rbp)
jge 0x57d8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x2917(%rip), %rsi      # 0x80dd
movb $0x1, %al
callq 0x21d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x57a4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x50(%rax), %xmm0
leaq 0x2902(%rip), %rsi      # 0x80ee
movb $0x1, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5700
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x173f(%rip), %rcx      # 0x81b8
movq %rcx, -0xb0(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2430
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movl $0x2, %edx
callq 0x3cd0
jmp 0x6abe
leaq 0x16f7(%rip), %rsi      # 0x81bc
leaq -0x90(%rbp), %rdi
callq 0x56d0
jmp 0x6ad3
leaq -0x90(%rbp), %rdi
movsd 0x16ce(%rip), %xmm0     # 0x81b0
movl $0x2, %esi
callq 0x4f20
jmp 0x6aee
movl $0x0, -0xa8(%rbp)
cmpl $0x0, -0xa8(%rbp)
jge 0x6bbc
movq 0x44cc(%rip), %rdi      # 0xafd8
leaq 0x16af(%rip), %rsi      # 0x81c2
callq 0x2140
movq %rax, -0xc0(%rbp)
jmp 0x6b21
movq -0xc0(%rbp), %rdi
movl -0xa8(%rbp), %esi
callq 0x2220
movq %rax, -0xc8(%rbp)
jmp 0x6b3c
movq -0xc8(%rbp), %rdi
movq 0x4476(%rip), %rsi      # 0xafc0
callq 0x2170
jmp 0x6b51
leaq 0x1660(%rip), %rsi      # 0x81b8
leaq -0x90(%rbp), %rdi
movl $0x2, %edx
callq 0x3cd0
jmp 0x6b6b
leaq -0x90(%rbp), %rdi
movsd 0x1636(%rip), %xmm0     # 0x81b0
movl $0x2, %esi
callq 0x4f20
jmp 0x6b86
jmp 0x6b88
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x6af8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x6c10
jmp 0x6c03
leaq 0x15f5(%rip), %rsi      # 0x81b8
leaq -0x90(%rbp), %rdi
movl $0x2, %edx
callq 0x3cd0
jmp 0x6bd6
leaq 0x15e9(%rip), %rsi      # 0x81c6
leaq -0x90(%rbp), %rdi
callq 0x56d0
jmp 0x6beb
leaq -0x90(%rbp), %rdi
callq 0x6c10
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x2230
nop
// File: huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: fldDic(_IO_FILE*, int)
ChUTF8* fldDic(FILE* fp,int dim){
    ChUTF8* ret = tabCreate();
    char* tmp=(char*)calloc(sizeof(char),7);
    fscanf(fp,"%s\n",tmp);
    std::cout<<tmp<<std::endl;
    int lenTmp,i;
    double dtmp;
    while(fscanf(fp,"%s ",tmp)!=-1){
        lenTmp=retLenUTF8(tmp);
        //std::cout<<tmp<<std::endl;
        ChUTF8 NewS = (ChUTF8)malloc(sizeof(struct chUTF8));
        NewS->schar=(char*)malloc(sizeof(char)*(lenTmp+1));
        memcpy(NewS->schar,tmp,lenTmp);
        NewS->schar[lenTmp]='\0';
        NewS->vecftr=(double*)malloc(sizeof(double)*dim);
        for(i=0;i<dim;++i){
            fscanf(fp,"#%lf#",&dtmp);
            NewS->vecftr[i]=dtmp;
        }
        fgetc(fp);
        hashput(ret,NewS);
        memset(tmp,'\0',7*sizeof(char));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x7850
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x7, %esi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1248(%rip), %rsi      # 0x8072
movb $0x0, %al
callq 0x2260
movq -0x20(%rbp), %rsi
movq 0x419c(%rip), %rdi      # 0xafd8
callq 0x2140
movq %rax, %rdi
movq 0x4175(%rip), %rsi      # 0xafc0
callq 0x2170
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1394(%rip), %rsi      # 0x81f3
movb $0x0, %al
callq 0x2260
cmpl $-0x1, %eax
je 0x6f51
movq -0x20(%rbp), %rdi
callq 0x77d0
movl %eax, -0x24(%rbp)
movl $0x18, %edi
callq 0x21c0
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x20f0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6f26
movq -0x8(%rbp), %rdi
leaq 0x1195(%rip), %rsi      # 0x808f
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x2260
movsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6ee7
movq -0x8(%rbp), %rdi
callq 0x2200
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6fe0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x20a0
jmp 0x6e50
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7880
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6fc3
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2090
cmpl $0x0, %eax
jne 0x6fb5
movb $0x1, -0x1(%rbp)
jmp 0x6fc7
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6f8f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7880
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1192(%rip), %rsi      # 0x81e0
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x18(%rbp)
cmpl $0x20000, -0x18(%rbp)   # imm = 0x20000
jge 0x7106
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x70f6
movq -0x10(%rbp), %rdi
leaq 0x106e(%rip), %rsi      # 0x80f9
movb $0x0, %al
callq 0x21d0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x114f(%rip), %rsi      # 0x81f3
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x70e8
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xfb9(%rip), %rsi       # 0x808f
movb $0x1, %al
callq 0x21d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x70b2
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7079
jmp 0x70f8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x705c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x20000, -0xc(%rbp)    # imm = 0x20000
jge 0x719a
jmp 0x712e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x718d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x21a0
jmp 0x712e
jmp 0x718f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7123
movq -0x8(%rbp), %rdi
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: fcrtDic(_IO_FILE*, _IO_FILE*, int)
void fcrtDic(FILE* infp,FILE* outfp,int dim){
    

    char* tmp=(char*)calloc(sizeof(char),421);
    int lenTmp,i;
	char* sta=tmp;
    ChUTF8* hash = tabCreate();

    while(fscanf(infp,"%s\n",sta)!=-1){
		tmp=sta;
        while(tmp[0]!='\0'){
            lenTmp=retLenUTF8(tmp);
            if(!hIscontain(hash,tmp,lenTmp)){
                ChUTF8 NewS = (ChUTF8)malloc(sizeof(struct chUTF8));
            
                NewS->schar=(char*)malloc(sizeof(char)*(lenTmp+1));
                memcpy(NewS->schar,tmp,lenTmp);
                NewS->schar[lenTmp]='\0';

                NewS->vecftr=(double*)malloc(sizeof(double)*dim);
                for(i=0;i<dim;++i){
                    NewS->vecftr[i]=(rand()%101-50)/50.0;
                }
            
                hashput(hash,NewS);
            }
            tmp+=lenTmp;
        }
        memset(sta,'\0',421*sizeof(char));
    }
    
   
    
    prtHash2File(hash,outfp,dim);
    fflush(outfp);
    
    hashFree(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
movl $0x1a5, %esi            # imm = 0x1A5
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x7850
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xe7c(%rip), %rsi       # 0x8072
movb $0x0, %al
callq 0x2260
cmpl $-0x1, %eax
je 0x732a
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7315
movq -0x20(%rbp), %rdi
callq 0x77d0
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x6f60
testb $0x1, %al
jne 0x72ff
movl $0x18, %edi
callq 0x21c0
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x20f0
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x72f2
callq 0x2040
movl $0x65, %ecx
cltd
idivl %ecx
subl $0x32, %edx
cvtsi2sd %edx, %xmm0
movsd 0xefe(%rip), %xmm1      # 0x81d0
divsd %xmm1, %xmm0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x72ae
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6fe0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x720e
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x20a0
jmp 0x71e7
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x7030
movq -0x10(%rbp), %rdi
callq 0x2180
movq -0x38(%rbp), %rdi
callq 0x7110
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7880
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x77d0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x73d0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x2090
cmpl $0x0, %eax
jne 0x73c2
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x73d8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7398
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x743b
movq -0x8(%rbp), %rdi
callq 0x77d0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x740b
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7700
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x7360
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x77d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x76f2
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x28(%rbp), %xmm2
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7690
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x764b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x20000, -0x24(%rbp)   # imm = 0x20000
jge 0x77ca
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x77ba
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x7360
movq %rax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x77ac
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x776e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x774c
jmp 0x77bc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x772f
addq $0x40, %rsp
popq %rbp
retq
// File: huiwenliuge[P]EmoAnaer/src/DictCreate.hpp
// Function: retLenUTF8(char const*)
inline int retLenUTF8(const char* head){
    int ch=(unsigned char)*head;
    if(ch<0xC0)
        return 1;
    else if(ch<0xE0)
        return 2;
    else if(ch<0xF0)
        return 3;
    else if(ch<0xF8)
        return 4;
    else if(ch<0xFC)
        return 5;
    else
        return 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xc0, -0x14(%rbp)
jge 0x77f4
movl $0x1, -0x4(%rbp)
jmp 0x7843
cmpl $0xe0, -0x14(%rbp)
jge 0x7806
movl $0x2, -0x4(%rbp)
jmp 0x7843
cmpl $0xf0, -0x14(%rbp)
jge 0x7818
movl $0x3, -0x4(%rbp)
jmp 0x7843
cmpl $0xf8, -0x14(%rbp)
jge 0x782a
movl $0x4, -0x4(%rbp)
jmp 0x7843
cmpl $0xfc, -0x14(%rbp)
jge 0x783c
movl $0x5, -0x4(%rbp)
jmp 0x7843
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: huiwenliuge[P]EmoAnaer/src/DictCreate.hpp
// Function: hFuncUTF8(char const*)
inline int hFuncUTF8(const char* head){
    int lenUTF8=retLenUTF8(head);

    if(lenUTF8 < 3){
        int ch=(unsigned char)head[0];
        ch=ch%64;
        return ch*32*64;

    }else{
        int ch1 = (unsigned char)head[0];
        int ch2 = (unsigned char)head[1];
        int ch3 = (unsigned char)head[2];

        int ret,l1,l2,l3;
        l1 = ch1%32;
        l2 = ch2%64;
        l3 = ch3%64;
        ret = l1*64*64+l2*64+l3;
        return ret;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77d0
movl %eax, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x78c4
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x5, %eax
shll $0x6, %eax
movl %eax, -0x4(%rbp)
jmp 0x792b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, -0x34(%rbp)
movl -0x2c(%rbp), %eax
shll $0x6, %eax
shll $0x6, %eax
movl -0x30(%rbp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14ac0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5e00
movq -0x20(%rbp), %rdi
callq 0x6410
testb $0x1, %al
jne 0x5dbb
jmp 0x5e00
movq -0x20(%rbp), %rdi
callq 0xc6d0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xc460
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9990
movq -0x20(%rbp), %rdi
callq 0x6430
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0x24211(%rip), %xmm1    # 0x2a008
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5e25
movq -0x28(%rbp), %rdi
callq 0x9870
movq -0x28(%rbp), %rdi
movl $0x830, %esi            # imm = 0x830
callq 0x32d0
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xc(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x10(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x14(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x13a00
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x139f2
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13a70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, (%rax)
cmpl $0x0, 0x10(%rax)
je 0x13a55
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13a3c
movq -0x18(%rbp), %rdi
callq 0x33d0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movb $0x1, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x263b0
movsd %xmm0, -0x20(%rbp)
movl $0x830, %edi            # imm = 0x830
callq 0x32c0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
movl 0x14(%rax), %r9d
movq %rsp, %rax
movl $0x0, 0x8(%rax)
movq $0x0, (%rax)
callq 0x8d00
jmp 0x13d2e
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x263b0
movq -0x48(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
addsd 0x28(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x14080
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x830, %esi            # imm = 0x830
callq 0x32d0
movq -0x30(%rbp), %rdi
callq 0x3520
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x13db5
movq -0x30(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x13dba
jmp 0x13e67
callq 0x263b0
movsd %xmm0, -0x10(%rbp)
movl $0x830, %edi            # imm = 0x830
callq 0x32c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq 0x18(%rax), %rsi
movl 0x20(%rax), %edx
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
movl 0x14(%rax), %r9d
movq (%rax), %rax
testq %rax, %rax
sete %al
movzbl %al, %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x7df0
jmp 0x13e08
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x263b0
movq -0x30(%rbp), %rdi
subsd -0x10(%rbp), %xmm0
addsd 0x28(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x18(%rbp), %rsi
movq 0x18(%rdi), %rdx
movl 0x20(%rdi), %ecx
cmpq $0x0, (%rdi)
setne %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x14080
movq -0x30(%rbp), %rax
movl $0x0, 0x20(%rax)
movl 0x10(%rax), %eax
movl %eax, %edi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x830, %esi            # imm = 0x830
callq 0x32d0
movq -0x20(%rbp), %rdi
callq 0x3520
// File: 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 %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
testb $0x1, 0x24(%rax)
jne 0x13eb9
jmp 0x14032
movq -0x248(%rbp), %rdi
callq 0x13d90
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x3550
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3150
movb %al, -0x249(%rbp)
jmp 0x13f02
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x13f0e
jmp 0x13f34
movl $0x1, -0x228(%rbp)
jmp 0x14026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x1405e
movl $0x830, %edi            # imm = 0x830
callq 0x32c0
movq %rax, -0x258(%rbp)
jmp 0x13f47
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x76f0
jmp 0x13f5b
movq -0x258(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
callq 0x6430
movl %eax, -0x25c(%rbp)
jmp 0x13f7d
movq -0x230(%rbp), %rdi
callq 0x14c30
movl %eax, -0x260(%rbp)
jmp 0x13f91
movl -0x260(%rbp), %ecx
movl -0x25c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x234(%rbp)
movl -0x234(%rbp), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x268(%rbp)
jmp 0x13fbb
movq -0x268(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rsi
movl -0x234(%rbp), %eax
movl %eax, %edx
leaq -0x218(%rbp), %rdi
callq 0x33b0
jmp 0x13fe6
leaq -0x218(%rbp), %rdi
callq 0x30b0
jmp 0x13ff4
movq -0x248(%rbp), %rdi
movq -0x230(%rbp), %rsi
movq -0x240(%rbp), %rdx
movl -0x234(%rbp), %ecx
movl $0x1, %r8d
callq 0x14080
jmp 0x1401c
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30d0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x258(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
movl $0x830, %esi            # imm = 0x830
callq 0x32d0
leaq -0x218(%rbp), %rdi
callq 0x30d0
movq -0x220(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, (%rax)
jne 0x140e1
testb $0x1, -0x1d(%rbp)
je 0x140cf
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x140cd
movq -0x70(%rbp), %rdi
callq 0x33d0
jmp 0x140cf
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13a70
jmp 0x141f7
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xee90
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rcx
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x14820
movq %rax, -0x78(%rbp)
jmp 0x14108
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, -0x1d(%rbp)
je 0x1414f
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x14133
movq -0x88(%rbp), %rdi
callq 0x33d0
jmp 0x1414f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14ca0
jmp 0x14200
callq 0x263b0
movsd %xmm0, -0x90(%rbp)
jmp 0x1415e
movsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
leaq (%rdi,%rax,4), %rsi
callq 0x14c70
jmp 0x1417d
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x141aa
movl -0x5c(%rbp), %edx
addl $0x1, %edx
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x14184
callq 0x263b0
movsd %xmm0, -0x98(%rbp)
jmp 0x141b9
movq -0x68(%rbp), %rdi
movsd -0x98(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
subsd %xmm0, %xmm1
movsd 0x38(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rdi)
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x14980
jmp 0x141ee
leaq -0x38(%rbp), %rdi
callq 0x14ca0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3520
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x263b0
movsd %xmm0, -0x20(%rbp)
movl $0x830, %edi            # imm = 0x830
callq 0x32c0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
movl 0x14(%rax), %r9d
movzbl -0x15(%rbp), %r10d
andl $0x1, %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x7df0
jmp 0x147cc
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x263b0
movq -0x48(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
addsd 0x28(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x28(%rbp), %rsi
callq 0x13a70
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x830, %esi            # imm = 0x830
callq 0x32d0
movq -0x30(%rbp), %rdi
callq 0x3520
nop