LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yueww[P]TSR/lsh.cpp
// Function: genAllParas(int, double)
void genAllParas(int dim,double w){
    int i;
    for(i=0;i<HASHFUNCNUM;i++){
        aVecParas[i]=genAPara(dim);
        bParas[i]=genBPara(w);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x36b2
movl -0x4(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x3410
movslq -0x14(%rbp), %rax
leaq 0x126b50c(%rip), %rdi   # 0x126eb80
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3a70
leaq -0x30(%rbp), %rdi
callq 0x37e0
movsd -0x10(%rbp), %xmm0
callq 0x3570
movslq -0x14(%rbp), %rcx
leaq 0x126b5ce(%rip), %rax   # 0x126ec70
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3657
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yueww[P]TSR/lsh.cpp
// Function: myHash(tuple4vec)
int myHash(tuple4vec tvec){
    int i,j;
    int index=0;
    double tmp;
    for(i=0;i<HASHFUNCNUM;i++){
        tmp=bParas[i];
        for(j=0;j<VECTORDIM;j++){
            tmp+=aVecParas[i][j]*tvec.vec[j];
        }
        index+=(int)(tmp/W);
    }
    index=index%TABLESIZE;
    if(index<0) return index+TABLESIZE;
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x3782
movslq -0x8(%rbp), %rcx
leaq 0x126b57d(%rip), %rax   # 0x126ec70
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x3759
movslq -0x8(%rbp), %rax
leaq 0x126b46b(%rip), %rdi   # 0x126eb80
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3aa0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cvtsi2sd %eax, %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3704
movsd -0x18(%rbp), %xmm0
movsd 0x6962(%rip), %xmm1     # 0xa0c8
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x36de
movl -0x10(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x37a3
movl -0x10(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x4(%rbp)
jmp 0x37a9
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yueww[P]TSR/flowResort.cpp
// Function: resort()
void resort(){
    int i;
    tuple4vec vec;
    int index;
    for(i=0;i<FLOWSPERPROCESS;i++){
        extractTuple4(&vec,flows[i]);
        index=myHash(vec);
        insertFlowsToBucket(flows[i],index);
        if(hashTable[index].currNum>=BUCKETSIZE){
            printf("export resorted flows from hash bucket!\n");
            //hashTable[index].currNum-=FLOWSPERPROCESS;
            exportResortedFlows(index);
        }
        if(insertedNodeNum>=LINKNODEBUFSIZE){
            printf("export resorted flows from hash table!\n");
            int k;
            int maxk=0;
            for(k=1;k<TABLESIZE;k++){
                if(hashTable[k].currNum>hashTable[maxk].currNum){
                    maxk=k;
                }
            }
            exportResortedFlows(maxk);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0xfa0, -0x4(%rbp)      # imm = 0xFA0
jge 0x529e
movslq -0x4(%rbp), %rax
leaq 0x6ab10f66(%rip), %rsi  # 0x6ab16070
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq -0x50(%rbp), %rdi
movl $0x30, %edx
callq 0x2260
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups -0x30(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x52b0
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x68(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x36c0
movl %eax, -0x1c(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x6ab10eea(%rip), %rsi  # 0x6ab16070
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq -0x98(%rbp), %rdi
movl $0x30, %edx
callq 0x2260
movl -0x1c(%rbp), %edi
movups -0x98(%rbp), %xmm0
movups -0x88(%rbp), %xmm1
movups -0x78(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x5370
movslq -0x1c(%rbp), %rcx
leaq 0x1269aef(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $0x1f40, (%rax)         # imm = 0x1F40
jl 0x51f6
leaq 0x4f4b(%rip), %rdi      # 0xa132
movb $0x0, %al
callq 0x2040
movl -0x1c(%rbp), %edi
callq 0x5480
cmpl $0x3e8000, 0xed39ad0(%rip) # imm = 0x3E8000
jl 0x528e
leaq 0x4f4e(%rip), %rdi      # 0xa15b
movb $0x0, %al
callq 0x2040
movl $0x0, -0xa0(%rbp)
movl $0x1, -0x9c(%rbp)
cmpl $0x400, -0x9c(%rbp)     # imm = 0x400
jge 0x5283
movslq -0x9c(%rbp), %rcx
leaq 0x1269a7e(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movslq -0xa0(%rbp), %rdx
leaq 0x1269a67(%rip), %rcx   # 0x126ecc0
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jle 0x5270
movl -0x9c(%rbp), %eax
movl %eax, -0xa0(%rbp)
jmp 0x5272
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x5228
movl -0xa0(%rbp), %edi
callq 0x5480
jmp 0x5290
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x50f2
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yueww[P]TSR/flowResort.cpp
// Function: extractTuple4(tuple4vec*, flowRecord)
void extractTuple4(tuple4vec *tvec,flowRecord rec){
    int i;
    for(i=0;i<4;i++){
        tvec->vec[i]=rec.srcIp[i];
    }
    for(;i<8;i++){
        tvec->vec[i]=rec.destIp[i-4];
    }
    tvec->vec[i++]=rec.srcPort[0]*0x100+rec.srcPort[1];
    tvec->vec[i]=rec.destPort[0]*0x100+rec.destPort[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x52f3
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52c7
jmp 0x52f5
cmpl $0x8, -0xc(%rbp)
jge 0x5327
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
movzbl 0x4(%rax,%rcx), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52f5
movq -0x18(%rbp), %rcx
movzbl 0x20(%rcx), %eax
shll $0x8, %eax
movzbl 0x21(%rcx), %edx
addl %edx, %eax
movw %ax, %si
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, -0xc(%rbp)
movslq %edx, %rdx
movw %si, (%rax,%rdx,2)
movzbl 0x22(%rcx), %eax
shll $0x8, %eax
movzbl 0x23(%rcx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
popq %rbp
retq
nop
// File: yueww[P]TSR/flowResort.cpp
// Function: insertFlowsToBucket(flowRecord, int)
void insertFlowsToBucket(flowRecord rec,int index){
    //memcpy(flowNodeBuf[insertedNodeNum].rec,rec,FLOWSIZE);
    flowRecordNode *tmp=unusedChainHead;
    memcpy(&(tmp->rec),&rec,FLOWSIZE);
    unusedChainHead=unusedChainHead->next;
    hashTable[index].currNum++;
    flowRecordNode *pF1,*pF2;
    pF1=pF2=&hashTable[index].head;
    while(pF1){
        if(isMatch(&(pF1->rec),&rec)){
            if(pF1==&hashTable[index].head){
                pF1=pF1->next;
                continue;
            }else{
                break;
            }
        }else{
            pF2=pF1;
            pF1=pF1->next;
        }
    }
    pF2->next=tmp;
    tmp->next=pF1;
    insertedNodeNum++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl %edi, -0x4(%rbp)
movq 0xed39936(%rip), %rax   # 0xed3ecc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x30, %edx
callq 0x2260
movq 0xed39919(%rip), %rax   # 0xed3ecc0
movq (%rax), %rax
movq %rax, 0xed3990f(%rip)   # 0xed3ecc0
movslq -0x4(%rbp), %rcx
leaq 0x1269904(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x12698eb(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5448
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x55a0
cmpl $0x0, %eax
je 0x5433
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rdx
leaq 0x12698ac(%rip), %rcx   # 0x126ecc0
shlq $0x6, %rdx
addq %rdx, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x5431
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53e8
jmp 0x5448
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53e8
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl 0xed3986c(%rip), %eax   # 0xed3ecd0
addl $0x1, %eax
movl %eax, 0xed39863(%rip)   # 0xed3ecd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/flowResort.cpp
// Function: exportResortedFlows(int)
void exportResortedFlows(int index){
    flowRecordNode *pF;
    pF=&hashTable[index].head;
    //unusedChainTail->next=pF->next;
    if(unusedChainHead==NULL){
        unusedChainHead=pF->next;
    }else{
        unusedChainTail->next=pF->next;
    }
    int j;
    for(j=0;j<FLOWSPERPROCESS;j++){
        pF=pF->next;
        memcpy(&flowWaitExport[inBase++],&(pF->rec),FLOWSIZE);
    }
    hashTable[index].head.next=pF->next;
    pF->next=NULL;
    unusedChainTail=pF;
    hashTable[index].currNum-=FLOWSPERPROCESS;
    insertedNodeNum-=FLOWSPERPROCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x126982a(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0xed39813(%rip)   # 0xed3ecc0
jne 0x54bf
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xed39803(%rip)   # 0xed3ecc0
jmp 0x54d0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0xed397fb(%rip), %rax   # 0xed3ecc8
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0xfa0, -0x14(%rbp)     # imm = 0xFA0
jge 0x552f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x653d6ffe(%rip), %rax  # 0x653dc4f0
movl (%rax), %eax
movl %eax, %edx
addl $0x1, %edx
leaq 0x653d6ff0(%rip), %rcx  # 0x653dc4f0
movl %edx, (%rcx)
cltq
leaq 0xed397d5(%rip), %rdi   # 0xed3ece0
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x30, %edx
callq 0x2260
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54d7
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x126977f(%rip), %rax   # 0x126ecc0
shlq $0x6, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xed39766(%rip)   # 0xed3ecc8
movslq -0x4(%rbp), %rcx
leaq 0x1269753(%rip), %rax   # 0x126ecc0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %ecx
subl $0xfa0, %ecx            # imm = 0xFA0
movl %ecx, (%rax)
movl 0xed3974c(%rip), %eax   # 0xed3ecd0
subl $0xfa0, %eax            # imm = 0xFA0
movl %eax, 0xed39741(%rip)   # 0xed3ecd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/flowResort.cpp
// Function: isMatch(flowRecord*, flowRecord*)
int isMatch(flowRecord *rec1,flowRecord *rec2){
    if(!memcmp(rec1->srcIp,rec2->srcIp,4)){
        return 1;
    }else if(!memcmp(rec1->destIp,rec2->destIp,4)){
        return 1;
    }else if(!memcmp(rec1->srcPort,rec2->srcPort,2)){
        return 1;
    }else if(!memcmp(rec1->destPort,rec2->destPort,2)){
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x55d1
movl $0x1, -0x4(%rbp)
jmp 0x5662
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x55fb
movl $0x1, -0x4(%rbp)
jmp 0x5662
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movw (%rcx), %cx
movw (%rax), %ax
subw %cx, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5628
movl $0x1, -0x4(%rbp)
jmp 0x5662
movq -0x10(%rbp), %rax
addq $0x22, %rax
movq -0x18(%rbp), %rcx
addq $0x22, %rcx
movw (%rcx), %cx
movw (%rax), %ax
subw %cx, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5655
movl $0x1, -0x4(%rbp)
jmp 0x5662
jmp 0x5657
jmp 0x5659
jmp 0x565b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: yueww[P]TSR/index.cpp
// Function: recordIpIndexNum(leafNode*, flowRecord, int)
void recordIpIndexNum(leafNode *pLeafNode,flowRecord rec,int flag){
    if(flag==1){
        if(pLeafNode->pTails[rec.srcIp[3]]==NULL){
            pLeafNode->pTails[rec.srcIp[3]]=pLeafNode->indexList[rec.srcIp[3]]=&srcIpIndexNodeBuf[currUsedSrcIpIndexNodes];
        }else{
            pLeafNode->pTails[rec.srcIp[3]]->next=&srcIpIndexNodeBuf[currUsedSrcIpIndexNodes];
            pLeafNode->pTails[rec.srcIp[3]]=pLeafNode->pTails[rec.srcIp[3]]->next;
        }
        currUsedSrcIpIndexNodes++;
    }else{
        if(pLeafNode->pTails[rec.destIp[3]]==NULL){
            pLeafNode->pTails[rec.destIp[3]]=pLeafNode->indexList[rec.destIp[3]]=&dstIpIndexNodeBuf[currUsedDstIpIndexNodes];
        }else{
            pLeafNode->pTails[rec.destIp[3]]->next=&dstIpIndexNodeBuf[currUsedDstIpIndexNodes];
            pLeafNode->pTails[rec.destIp[3]]=pLeafNode->pTails[rec.destIp[3]]->next;
        }
        currUsedDstIpIndexNodes++;
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x5bd0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %ecx
cmpq $0x0, 0x800(%rax,%rcx,8)
jne 0x5b6b
movq -0x18(%rbp), %rcx
movslq 0x653d69b9(%rip), %rax  # 0x653dc4f8
leaq 0x2b6fc99a(%rip), %rdx  # 0x2b7024e0
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %esi
movq %rdx, (%rax,%rsi,8)
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %ecx
movq %rdx, 0x800(%rax,%rcx,8)
jmp 0x5bbc
movq -0x18(%rbp), %rcx
movslq 0x653d6982(%rip), %rax  # 0x653dc4f8
leaq 0x2b6fc963(%rip), %rdx  # 0x2b7024e0
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %esi
movq 0x800(%rax,%rsi,8), %rax
movq %rdx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %edx
movq 0x800(%rax,%rdx,8), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movzbl 0x3(%rcx), %ecx
movq %rdx, 0x800(%rax,%rcx,8)
movl 0x653d6936(%rip), %eax  # 0x653dc4f8
addl $0x1, %eax
movl %eax, 0x653d692d(%rip)  # 0x653dc4f8
jmp 0x5c7e
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %ecx
cmpq $0x0, 0x800(%rax,%rcx,8)
jne 0x5c1e
movq -0x18(%rbp), %rcx
movslq 0x653d690a(%rip), %rax  # 0x653dc4fc
leaq 0x34f930e7(%rip), %rdx  # 0x34f98ce0
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %esi
movq %rdx, (%rax,%rsi,8)
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %ecx
movq %rdx, 0x800(%rax,%rcx,8)
jmp 0x5c6f
movq -0x18(%rbp), %rcx
movslq 0x653d68d3(%rip), %rax  # 0x653dc4fc
leaq 0x34f930b0(%rip), %rdx  # 0x34f98ce0
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %esi
movq 0x800(%rax,%rsi,8), %rax
movq %rdx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %edx
movq 0x800(%rax,%rdx,8), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movzbl 0x7(%rcx), %ecx
movq %rdx, 0x800(%rax,%rcx,8)
movl 0x653d6887(%rip), %eax  # 0x653dc4fc
addl $0x1, %eax
movl %eax, 0x653d687e(%rip)  # 0x653dc4fc
popq %rbp
retq
// File: yueww[P]TSR/index.cpp
// Function: judgeExport()
byte judgeExport(){
    byte ret=0;
    if(currUsedSrcIpInnerNodes>INNERNODENUM*THRESHOLD){
        ret|=0x01;
    }else if(currUsedSrcIpLeafNodes>LEAFNODENUM*THRESHOLD){
        ret|=0x02;
    }else if(currUsedDstIpInnerNodes>INNERNODENUM*THRESHOLD){
        ret|=0x04;
    }else if(currUsedDstIpLeafNodes>LEAFNODENUM*THRESHOLD){
        ret|=0x08;
    }else if(currUsedSrcIpIndexNodes>FLOWAMOUNTINMEM*THRESHOLD){
        ret|=0x10;
    }else if(currUsedDstIpIndexNodes>FLOWAMOUNTINMEM*THRESHOLD){
        ret|=0x20;
    }else if(currUsedSrcPortIndexNodes>FLOWAMOUNTINMEM*THRESHOLD){
        ret|=0x40;
    }else if(currUsedDstPortIndexNodes>FLOWAMOUNTINMEM*THRESHOLD){
        ret|=0x80;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, -0x1(%rbp)
cvtsi2sdl 0x653d66a8(%rip), %xmm0 # 0x653dc508
movsd 0x4320(%rip), %xmm1     # 0xa188
ucomisd %xmm1, %xmm0
jbe 0x5e7d
movzbl -0x1(%rbp), %eax
orl $0x1, %eax
movb %al, -0x1(%rbp)
jmp 0x5f82
cvtsi2sdl 0x653d6687(%rip), %xmm0 # 0x653dc50c
movsd 0x4303(%rip), %xmm1     # 0xa190
ucomisd %xmm1, %xmm0
jbe 0x5ea2
movzbl -0x1(%rbp), %eax
orl $0x2, %eax
movb %al, -0x1(%rbp)
jmp 0x5f80
cvtsi2sdl 0x653d6666(%rip), %xmm0 # 0x653dc510
movsd 0x42d6(%rip), %xmm1     # 0xa188
ucomisd %xmm1, %xmm0
jbe 0x5ec7
movzbl -0x1(%rbp), %eax
orl $0x4, %eax
movb %al, -0x1(%rbp)
jmp 0x5f7e
cvtsi2sdl 0x653d6645(%rip), %xmm0 # 0x653dc514
movsd 0x42b9(%rip), %xmm1     # 0xa190
ucomisd %xmm1, %xmm0
jbe 0x5eec
movzbl -0x1(%rbp), %eax
orl $0x8, %eax
movb %al, -0x1(%rbp)
jmp 0x5f7c
cvtsi2sdl 0x653d6604(%rip), %xmm0 # 0x653dc4f8
movsd 0x429c(%rip), %xmm1     # 0xa198
ucomisd %xmm1, %xmm0
jbe 0x5f0e
movzbl -0x1(%rbp), %eax
orl $0x10, %eax
movb %al, -0x1(%rbp)
jmp 0x5f7a
cvtsi2sdl 0x653d65e6(%rip), %xmm0 # 0x653dc4fc
movsd 0x427a(%rip), %xmm1     # 0xa198
ucomisd %xmm1, %xmm0
jbe 0x5f30
movzbl -0x1(%rbp), %eax
orl $0x20, %eax
movb %al, -0x1(%rbp)
jmp 0x5f78
cvtsi2sdl 0x653d65c8(%rip), %xmm0 # 0x653dc500
movsd 0x4258(%rip), %xmm1     # 0xa198
ucomisd %xmm1, %xmm0
jbe 0x5f52
movzbl -0x1(%rbp), %eax
orl $0x40, %eax
movb %al, -0x1(%rbp)
jmp 0x5f76
cvtsi2sdl 0x653d65aa(%rip), %xmm0 # 0x653dc504
movsd 0x4236(%rip), %xmm1     # 0xa198
ucomisd %xmm1, %xmm0
jbe 0x5f74
movzbl -0x1(%rbp), %eax
orl $0x80, %eax
movb %al, -0x1(%rbp)
jmp 0x5f76
jmp 0x5f78
jmp 0x5f7a
jmp 0x5f7c
jmp 0x5f7e
jmp 0x5f80
jmp 0x5f82
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: yueww[P]TSR/myToolFunc.c
// Function: countFiles(char const*, char const*)
int countFiles(const char *path,const char *filter){
    DIR *dp;
    struct dirent *dirp;
    int fileNum=0;
    if((dp=opendir(path))==NULL){
        int mkRes=mkdir(path,0777);
        if(mkRes==-1){
            printf("fail to create dir %s\n",path);
        }
        return 0;
    }
    while((dirp=readdir(dp))!=NULL){
        if(strstr(dirp->d_name,filter)){
            fileNum++;
        }
    }
    return fileNum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2470
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5fec
movq -0x10(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x2130
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x30(%rbp)
jne 0x5fe3
movq -0x10(%rbp), %rsi
leaq 0x41c4(%rip), %rdi      # 0xa1a0
movb $0x0, %al
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x6029
jmp 0x5fee
movq -0x20(%rbp), %rdi
callq 0x2490
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6023
movq -0x28(%rbp), %rdi
addq $0x13, %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
cmpq $0x0, %rax
je 0x6021
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5fee
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/myToolFunc.c
// Function: iToStr(int, char*)
int iToStr(int num,char str[]){
    if(num==0){
        str[1]=0;
        str[0]='0';
        return 0;
    }
    int len=0;
    int tmpNum=num;
    while(tmpNum){
        tmpNum/=10;
        len++;
    }
    str[len--]=0;
    while(num){
        str[len--]=(num%10)+'0';
        num/=10;
    }
    if(len!=-1){
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x606c
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x30, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x60fd
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x6098
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6079
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x8(%rbp)
je 0x60e7
movl -0x8(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
jmp 0x60ae
cmpl $-0x1, -0x14(%rbp)
je 0x60f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60fd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/myToolFunc.c
// Function: getNowTime(char*, int)
void getNowTime(char formatTime[],int len){
    time_t now;
    struct tm *tm_now;
    time(&now);
    tm_now=localtime(&now);
    strftime(formatTime,len,"%Y-%m-%d %H:%M:%S",tm_now);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x22b0
leaq -0x18(%rbp), %rdi
callq 0x21d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x406f(%rip), %rdx      # 0xa1b7
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: isFive(indexNode*)
int isFive(indexNode *ptr){
    indexNode *nPtr=ptr->next;
    if(!nPtr) return 0;
    int i;
    for(i=0;i<5;i++){
        if(nPtr->indexNum-ptr->indexNum>63){
            return i;
        }
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr) return i+1;
    }
    return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6434
movl $0x0, -0x4(%rbp)
jmp 0x6494
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x648d
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
cmpl $0x3f, %eax
jbe 0x645a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6494
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6480
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6494
jmp 0x6482
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x643b
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: isSpecial(indexNode*)
int isSpecial(indexNode *ptr){
    indexNode *nPtr=ptr->next;
    int specialNum=0;
    while(nPtr){
        if(nPtr->indexNum-ptr->indexNum>1){
            break;
        }
        specialNum++;
        ptr=nPtr;
        nPtr=nPtr->next;
    }
    return specialNum; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x64f4
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
subl (%rcx), %eax
cmpl $0x1, %eax
jbe 0x64d5
jmp 0x64f4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x64bb
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: moveToNext(indexNode**, int)
int moveToNext(indexNode **ptr,int steps){
    int moveSteps=0;
    while((*ptr)!=NULL&&(moveSteps<steps)){
        *ptr=(*ptr)->next;
        moveSteps++;
    }
    return moveSteps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x652d
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6536
jmp 0x6553
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6512
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: compress5(indexNode*)
void compress5(indexNode *ptr){
    compressedIndexArr[indexOffset]=UNIT5;
    indexNode *nPtr=ptr->next;
    if(!nPtr) return;
    int i;
    for(i=0;i<5;i++){
        compressedIndexArr[indexOffset]|=((nPtr->indexNum-ptr->indexNum)<<6*i);
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr){
            indexOffset++;
            return;
        }
    }
    indexOffset++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movslq 0x679fb9b1(%rip), %rcx  # 0x67a01f20
leaq 0x653d5faa(%rip), %rax  # 0x653dc520
movl $0xc0000000, (%rax,%rcx,4) # imm = 0xC0000000
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6595
jmp 0x6617
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x6608
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
subl (%rax), %edx
imull $0x6, -0x14(%rbp), %ecx
shll %cl, %edx
movslq 0x679fb965(%rip), %rcx  # 0x67a01f20
leaq 0x653d5f5e(%rip), %rax  # 0x653dc520
orl (%rax,%rcx,4), %edx
leaq 0x653d5f54(%rip), %rax  # 0x653dc520
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x65fb
movl 0x679fb930(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb927(%rip)  # 0x67a01f20
jmp 0x6617
jmp 0x65fd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x659c
movl 0x679fb912(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb909(%rip)  # 0x67a01f20
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: compress3(indexNode*)
void compress3(indexNode *ptr){
    compressedIndexArr[indexOffset]=UNIT3;
    indexNode *nPtr=ptr->next;
    if(!nPtr) return;
    int i;
    for(i=0;i<3;i++){
        compressedIndexArr[indexOffset]|=((nPtr->indexNum-ptr->indexNum)<<10*i);
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr){
            indexOffset++;
            return;
        }
    }
    indexOffset++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movslq 0x679fb8f1(%rip), %rcx  # 0x67a01f20
leaq 0x653d5eea(%rip), %rax  # 0x653dc520
movl $0x80000000, (%rax,%rcx,4) # imm = 0x80000000
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6655
jmp 0x66d7
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x66c8
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
subl (%rax), %edx
imull $0xa, -0x14(%rbp), %ecx
shll %cl, %edx
movslq 0x679fb8a5(%rip), %rcx  # 0x67a01f20
leaq 0x653d5e9e(%rip), %rax  # 0x653dc520
orl (%rax,%rcx,4), %edx
leaq 0x653d5e94(%rip), %rax  # 0x653dc520
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x66bb
movl 0x679fb870(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb867(%rip)  # 0x67a01f20
jmp 0x66d7
jmp 0x66bd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x665c
movl 0x679fb852(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb849(%rip)  # 0x67a01f20
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: isThree(indexNode*)
int isThree(indexNode *ptr){
    indexNode *nPtr=ptr->next;
    if(!nPtr) return 0;
    int i;
    for(i=0;i<3;i++){
        if(nPtr->indexNum-ptr->indexNum>1023){
            return i;
        }
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr) return i+1;
    }
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6704
movl $0x0, -0x4(%rbp)
jmp 0x6766
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x675f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
cmpl $0x3ff, %eax            # imm = 0x3FF
jbe 0x672c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6766
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6752
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6766
jmp 0x6754
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x670b
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: compress2(indexNode*)
void compress2(indexNode *ptr){
    compressedIndexArr[indexOffset]=UNIT2;
    indexNode *nPtr=ptr->next;
    if(!nPtr) return;
    int i;
    for(i=0;i<2;i++){
        compressedIndexArr[indexOffset]|=((nPtr->indexNum-ptr->indexNum)<<15*i);
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr){
            indexOffset++;
            return;
        }
    }
    indexOffset++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movslq 0x679fb7a1(%rip), %rcx  # 0x67a01f20
leaq 0x653d5d9a(%rip), %rax  # 0x653dc520
movl $0x40000000, (%rax,%rcx,4) # imm = 0x40000000
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x67a5
jmp 0x6827
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x6818
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
subl (%rax), %edx
imull $0xf, -0x14(%rbp), %ecx
shll %cl, %edx
movslq 0x679fb755(%rip), %rcx  # 0x67a01f20
leaq 0x653d5d4e(%rip), %rax  # 0x653dc520
orl (%rax,%rcx,4), %edx
leaq 0x653d5d44(%rip), %rax  # 0x653dc520
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x680b
movl 0x679fb720(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb717(%rip)  # 0x67a01f20
jmp 0x6827
jmp 0x680d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67ac
movl 0x679fb702(%rip), %eax  # 0x67a01f20
addl $0x1, %eax
movl %eax, 0x679fb6f9(%rip)  # 0x67a01f20
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/compressIndex.cpp
// Function: isTwo(indexNode*)
int isTwo(indexNode *ptr){
    indexNode *nPtr=ptr->next;
    if(!nPtr) return 0;
    int i;
    for(i=0;i<2;i++){
        if(nPtr->indexNum-ptr->indexNum>32767){
            return i;
        }
        ptr=nPtr;
        nPtr=nPtr->next;
        if(!nPtr) return i+1;
    }
    return 2; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6854
movl $0x0, -0x4(%rbp)
jmp 0x68b6
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x68af
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jbe 0x687c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x68b6
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x68a2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x68b6
jmp 0x68a4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x685b
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: exportDataAndIndex()
int* exportDataAndIndex(){
    char formatTime[128];
    char query[512];
    if(useDb==true){
        getNowTime(formatTime,128);
    }
    int *exportRes=(int *)malloc(sizeof(int)*5);
    exportRes[0]=exportDataFile();
    exportRes[1]=exportIpIndexFile(srcIpRootNode,1);
    exportRes[2]=exportIpIndexFile(dstIpRootNode,2);
    exportRes[3]=exportPortIndexFile(&srcPortIndexTable,1);
    exportRes[4]=exportPortIndexFile(&dstPortIndexTable,2);
    if(useDb==true){
        sprintf(query,"INSERT INTO tsr(data_file,src_ip_index_file,src_port_index_file,dst_ip_index_file,\
            dst_port_index_file,timestamp)values('%s','%s','%s','%s','%s','%s')",dateFileName,\
            srcIpIndexFileName,srcPortIndexFileName,dstIpIndexFileName,dstPortIndexFileName,formatTime);
        if(mysql_real_query(&mysql,query,(unsigned long)strlen(query))){
            printf("mysql_real_query failed!\n");
        }
    }
    return exportRes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
leaq 0x6ab3ecae(%rip), %rax  # 0x6ab45580
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x68ec
leaq -0x80(%rbp), %rdi
movl $0x80, %esi
callq 0x6110
movl $0x14, %edi
callq 0x23a0
movq %rax, -0x288(%rbp)
callq 0x6a40
movl %eax, %ecx
movq -0x288(%rbp), %rax
movl %ecx, (%rax)
leaq 0x651d5bcc(%rip), %rax  # 0x651dc4e0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x6b80
movl %eax, %ecx
movq -0x288(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x651d5bb4(%rip), %rax  # 0x651dc4e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x6b80
movl %eax, %ecx
movq -0x288(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq 0x651d5b9c(%rip), %rdi  # 0x651dc4f0
movl $0x1, %esi
callq 0x6ef0
movl %eax, %ecx
movq -0x288(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0x652d5b7f(%rip), %rdi  # 0x652dc4f0
movl $0x2, %esi
callq 0x6ef0
movl %eax, %ecx
movq -0x288(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq 0x6ab3ebf2(%rip), %rax  # 0x6ab45580
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6a28
leaq -0x280(%rbp), %rdi
leaq -0x80(%rbp), %rax
leaq 0x3819(%rip), %rsi      # 0xa1c9
leaq 0x6ab0f5d9(%rip), %rdx  # 0x6ab15f90
leaq 0x6ab0f5f2(%rip), %rcx  # 0x6ab15fb0
leaq 0x6ab0f62b(%rip), %r8   # 0x6ab15ff0
leaq 0x6ab0f604(%rip), %r9   # 0x6ab15fd0
leaq 0x6ab0f63d(%rip), %r10  # 0x6ab16010
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2080
leaq -0x280(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x2110
movq -0x290(%rbp), %rsi
movq %rax, %rdx
leaq 0x6ab3e6ea(%rip), %rdi  # 0x6ab450f8
callq 0x23c0
cmpl $0x0, %eax
je 0x6a26
leaq 0x384c(%rip), %rdi      # 0xa26b
movb $0x0, %al
callq 0x2040
jmp 0x6a28
movq -0x288(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
nopl (%rax,%rax)
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: exportDataFile()
int exportDataFile(){
    int id=countFiles("./dataDir/","data");
    strcpy(dateFileName,"data");
    char strId[16];
    int res=iToStr(id,strId);
    strcat(dateFileName,strId);
    char path[128];
    strcpy(path,"./dataDir/");
    strcat(path,dateFileName);
    int fd=open(path,O_WRONLY | O_APPEND | O_CREAT,0555);
    if(fd == -1){
        printf("fail to open file %s\n",path);
        return -1;
    }
    int writedBytes=write(fd,flowWaitExport,outBase*FLOWSIZE);
    if(writedBytes==-1){
        printf("write error!\n");
        return -1;
    }
    if(writedBytes<outBase*FLOWSIZE){
        printf("did not write enough data!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x3833(%rip), %rdi      # 0xa285
leaq 0x35fd(%rip), %rsi      # 0xa056
callq 0x5f90
movl %eax, -0x8(%rbp)
leaq 0x6ab0f528(%rip), %rdi  # 0x6ab15f90
leaq 0x35e7(%rip), %rsi      # 0xa056
callq 0x22c0
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x6040
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rsi
leaq 0x6ab0f502(%rip), %rdi  # 0x6ab15f90
callq 0x2510
leaq -0xb0(%rbp), %rdi
leaq 0x37e4(%rip), %rsi      # 0xa285
callq 0x22c0
leaq -0xb0(%rbp), %rdi
leaq 0x6ab0f4dc(%rip), %rsi  # 0x6ab15f90
callq 0x2510
leaq -0xb0(%rbp), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x16d, %edx            # imm = 0x16D
movb $0x0, %al
callq 0x21c0
movl %eax, -0xb4(%rbp)
cmpl $-0x1, -0xb4(%rbp)
jne 0x6afe
leaq -0xb0(%rbp), %rsi
leaq 0x37a2(%rip), %rdi      # 0xa290
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b6e
movl -0xb4(%rbp), %edi
leaq 0x653d59e9(%rip), %rax  # 0x653dc4f4
imull $0x30, (%rax), %eax
movslq %eax, %rdx
leaq 0xed381c8(%rip), %rsi   # 0xed3ece0
callq 0x20e0
movl %eax, -0xb8(%rbp)
cmpl $-0x1, -0xb8(%rbp)
jne 0x6b43
leaq 0x3773(%rip), %rdi      # 0xa2a6
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b6e
movl -0xb8(%rbp), %eax
leaq 0x653d59a4(%rip), %rcx  # 0x653dc4f4
imull $0x30, (%rcx), %ecx
cmpl %ecx, %eax
jge 0x6b65
leaq 0x3756(%rip), %rdi      # 0xa2b4
movb $0x0, %al
callq 0x2040
movl -0xb8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: getFirstLeafNode(innerNode*)
void *getFirstLeafNode(innerNode *rootNode){
    void *pNode=rootNode;
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<256;j++){
            if(((innerNode *)pNode)->nextLevelNodes[j]){
                pNode=((innerNode *)pNode)->nextLevelNodes[j];
                break;
            } 
        }
    }
    return pNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x7128
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x711b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x710e
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x711b
jmp 0x7110
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x70e4
jmp 0x711d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x70d7
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: writeIpIndexFile(char const*)
int writeIpIndexFile(const char *path){
    int writedBytes=writeIndexFile(path,trieNodeArr,sizeof(trieNodeOffset)*trieNodeNum);
    if(writedBytes==-1){
        printf("suffer error when write ip index file!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movslq 0x679fade9(%rip), %rax  # 0x67a01f30
shlq $0xa, %rax
movl %eax, %edx
leaq 0x679fadec(%rip), %rsi  # 0x67a01f40
callq 0x71d0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x7170
leaq 0x31a0(%rip), %rdi      # 0xa309
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: writePortIndexFile(char const*)
int writePortIndexFile(const char *path){
    int writedBytes=writeIndexFile(path,portOffsetTable,65536*sizeof(int));
    if(writedBytes==-1){
        printf("suffer error when write port index file!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6aacedf9(%rip), %rsi  # 0x6aad5f90
movl $0x40000, %edx          # imm = 0x40000
callq 0x71d0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x71b8
leaq 0x3180(%rip), %rdi      # 0xa331
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/exportDataAndIndex.cpp
// Function: writeIndexFile(char const*, void*, int)
int writeIndexFile(const char *path,void *ptr,int size){
    int fd=open(path,O_WRONLY | O_APPEND | O_CREAT,0555);
    if(fd == -1){
        printf("fail to open file %s\n",path);
        return -1;
    }
    int writedPointerBytes=write(fd,ptr,size);
    if(writedPointerBytes==-1){
        printf("write pointer info error!\n");
        return -1;
    }
    if(writedPointerBytes<size){
        printf("did not write enough pointer info!\n");
    }
    int writedIndexNumBytes=write(fd,compressedIndexArr,sizeof(unsigned)*indexOffset);
    if(writedIndexNumBytes==-1){
        printf("write index number error!\n");
        return -1;
    }
    if(writedIndexNumBytes<sizeof(unsigned)*indexOffset){
        printf("do not write enough index number data!\n");
    }
    return writedPointerBytes+writedIndexNumBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x16d, %edx            # imm = 0x16D
movb $0x0, %al
callq 0x21c0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x721f
movq -0x10(%rbp), %rsi
leaq 0x3084(%rip), %rdi      # 0xa290
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72d3
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x20e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x7252
leaq 0x311c(%rip), %rdi      # 0xa35b
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72d3
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7268
leaq 0x3115(%rip), %rdi      # 0xa376
movb $0x0, %al
callq 0x2040
movl -0x20(%rbp), %edi
leaq 0x679facae(%rip), %rax  # 0x67a01f20
movslq (%rax), %rdx
shlq $0x2, %rdx
leaq 0x653d52a0(%rip), %rsi  # 0x653dc520
callq 0x20e0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x72a5
leaq 0x3105(%rip), %rdi      # 0xa39a
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72d3
movslq -0x28(%rbp), %rax
leaq 0x679fac70(%rip), %rcx  # 0x67a01f20
movslq (%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jae 0x72ca
leaq 0x30f2(%rip), %rdi      # 0xa3b5
movb $0x0, %al
callq 0x2040
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: yueww[P]TSR/test.c
// Function: processFunc(void*)
void *processFunc(void *arg){
    //pthread_setcanceltype(PTHREAD_CANCEL_ASYCHRONOUS,NULL);
    //pthread_t pro,con;
    pthread_mutex_init(&mutex,0);
    pthread_cond_init(&cond_p,0);
    pthread_cond_init(&cond_c,0);
    pthread_create(&pro,0,receiveData,0);
    pthread_create(&con,0,outputFlows,0);
    pthread_join(pro,0);
    pthread_join(con,0);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_p);
    pthread_cond_destroy(&cond_c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x59ad(%rip), %rdi      # 0xf2e0
xorl %eax, %eax
movl %eax, %esi
callq 0x2450
leaq 0x59c5(%rip), %rdi      # 0xf308
xorl %eax, %eax
movl %eax, %esi
callq 0x2380
leaq 0x6ab0c6e5(%rip), %rdi  # 0x6ab16038
xorl %eax, %eax
movl %eax, %esi
callq 0x2380
leaq 0x6ab3bc2d(%rip), %rdi  # 0x6ab45590
xorl %eax, %eax
movl %eax, %ecx
leaq -0x6b8e(%rip), %rdx     # 0x2de0
movq %rcx, %rsi
callq 0x2520
leaq 0x6ab3bc1b(%rip), %rdi  # 0x6ab45598
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1158(%rip), %rdx     # 0x8830
movq %rcx, %rsi
callq 0x2520
movq 0x6ab3bbf9(%rip), %rdi  # 0x6ab45590
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
movq 0x6ab3bbf1(%rip), %rdi  # 0x6ab45598
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
leaq 0x5929(%rip), %rdi      # 0xf2e0
callq 0x2340
leaq 0x5945(%rip), %rdi      # 0xf308
callq 0x2530
leaq 0x6ab0c669(%rip), %rdi  # 0x6ab16038
callq 0x2530
ud2
nopw %cs:(%rax,%rax)
// File: yueww[P]TSR/test.c
// Function: processCommand(char const*, char const*)
char *processCommand(const char *opt,const char *name){
    char *command=(char *)malloc(sizeof(char)*COMMANDSIZE);
    if(!strcmp(opt,"-i")){
       strcpy(command,"fprobe -i ");
       strcat(command,name);
       strcat(command," -B 8192 -r 2 -q 10000 localhost:555");
    }else if(!strcmp(opt,"-f")){
       strcpy(command,"cat < ");
       strcat(command,name);
       strcat(command," | fprobe -i - -B 8192 -r 2 -q 10000 -t 10000:10000000 localhost:555");
    }else{
        printf("unknown options!\n");
        free(command);
        command=NULL;
    }
    return command;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0x23a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd35(%rip), %rsi       # 0xa73e
callq 0x2410
cmpl $0x0, %eax
jne 0x9a42
movq -0x18(%rbp), %rdi
leaq 0xd23(%rip), %rsi       # 0xa741
callq 0x22c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2510
movq -0x18(%rbp), %rdi
leaq 0xd11(%rip), %rsi       # 0xa74c
callq 0x2510
jmp 0x9aa7
movq -0x8(%rbp), %rdi
leaq 0xd24(%rip), %rsi       # 0xa771
callq 0x2410
cmpl $0x0, %eax
jne 0x9a86
movq -0x18(%rbp), %rdi
leaq 0xd12(%rip), %rsi       # 0xa774
callq 0x22c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2510
movq -0x18(%rbp), %rdi
leaq 0xcfc(%rip), %rsi       # 0xa77b
callq 0x2510
jmp 0x9aa5
leaq 0xd33(%rip), %rdi       # 0xa7c0
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x2370
movq $0x0, -0x18(%rbp)
jmp 0x9aa7
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: tbjohns[P]BlitzL1/src/solver.h
// Function: BlitzL1::Solver::Solver()
Solver()
    {
      tolerance = 0.0001;
      use_intercept = true;
      verbose = false;
      min_time = -60.0;
      max_time = 3.15569e9;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0xf7a0
movq 0x8(%rsp), %rdi
addq $0xb8, %rdi
callq 0xe940
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0xe940
movq 0x8(%rsp), %rax
movsd 0xc062(%rip), %xmm0     # 0x1c010
movsd %xmm0, 0xd0(%rax)
movb $0x1, 0xd9(%rax)
movb $0x0, 0xd8(%rax)
movsd 0xc03c(%rip), %xmm0     # 0x1c008
movsd %xmm0, 0xe0(%rax)
movsd 0xc024(%rip), %xmm0     # 0x1c000
movsd %xmm0, 0xe8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::Column::l2_norm_centered() const
value_t Column::l2_norm_centered() const
  {
    if (l2_norm_centered_cache == -1.0)
    {
      value_t mean_value = this->mean();
      value_t value_sq = l2_norm_sq() - mean_value * mean_value * length;
      if (value_sq <= 0)
        l2_norm_centered_cache = 0.0;
      else
        l2_norm_centered_cache = sqrt(value_sq);
    }
    return l2_norm_centered_cache;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x20(%rax), %xmm0
movsd 0xbce8(%rip), %xmm1     # 0x1c018
ucomisd %xmm1, %xmm0
jne 0x103f1
jp 0x103f1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm0
movq 0x8(%rax), %xmm2
movaps 0xbca0(%rip), %xmm3     # 0x1c020
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movapd 0xbca4(%rip), %xmm3     # 0x1c030
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x10(%rsp), %xmm0
jb 0x103da
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0x103ef
movsd 0x10(%rsp), %xmm0
callq 0xe900
movq 0x8(%rsp), %rax
movsd %xmm0, 0x20(%rax)
jmp 0x103f1
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
addq $0x28, %rsp
retq