// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/src/diff/Differ.cpp
// Function: ZipDiffWithStream(hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TStreamOutput const*, hdiff_TCompress const*, hpatch_TDecompress*, int, unsigned long, bool*, int)
bool ZipDiffWithStream(const hpatch_TStreamInput* oldZipStream,const hpatch_TStreamInput* newZipStream,
                       const hpatch_TStreamOutput* outDiffStream,
                       const hdiff_TCompress* compressPlugin,hpatch_TDecompress* decompressPlugin,
                       int diffMatchScore,size_t patchStepMemSize,
                       bool* out_isNewZipApkV2SignNoError,int threadNum){
    UnZipper            oldZip;
    UnZipper            newZip;
    std::vector<TByte>  newData;
    std::vector<TByte>  oldData;
    std::vector<TByte>  hdiffzData;
    std::vector<TByte>  out_diffData;
    std::vector<uint32_t> samePairList;
    std::vector<uint32_t> newRefDecompressList;
    std::vector<uint32_t> newRefList;
    std::vector<uint32_t> newRefOtherCompressedList;
    std::vector<uint32_t> newRefCompressedSizeList;
    std::vector<uint32_t> oldRefList;
    bool            result=true;
    bool            _isInClear=false;
    bool            byteByByteEqualCheck=false;
    bool            isNewZipApkV2SignNoError=true;
    size_t          newZipAlignSize=0;
    int             newZipNormalized_compressLevel=kDefaultZlibCompressLevel;
    int             newZipNormalized_compressMemLevel=kDefaultZlibCompressMemLevel;
    int             newZip_otherCompressLevel=0;
    int             newZip_otherCompressMemLevel=0;
    bool            newCompressedDataIsNormalized=false;
    const bool isSD=patchStepMemSize>0;
    
    check(compressPlugin!=0);
    check(decompressPlugin!=0);

    UnZipper_init(&oldZip);
    UnZipper_init(&newZip);
    check(UnZipper_openStream(&oldZip,oldZipStream));
    check(UnZipper_openStream(&newZip,newZipStream,false,false,true));
    
    newZipAlignSize=getBaseAlignSize_unsafe(&newZip);
    if (UnZipper_isHaveApkV2Sign(&newZip)){//precondition (+checkZipIsSame() to complete)
        newZip._isDataNormalized=(newZipAlignSize>0)&&(newZip._dataDescriptorCount==0);
    }else{
        newZip._isDataNormalized=true;
    }
    //if (newZip._isDataNormalized && UnZipper_isHaveApkV2Sign(&newZip)){
        newCompressedDataIsNormalized=getCompressedIsNormalized(&newZip,&newZipNormalized_compressLevel,
                                                                &newZipNormalized_compressMemLevel);
    //}else{
    //    newCompressedDataIsNormalized=getCompressedIsNormalizedBy(&newZip,newZipNormalized_compressLevel,
    //                                                              newZipNormalized_compressMemLevel);
    //}
    newZip._isDataNormalized&=newCompressedDataIsNormalized;
    if (UnZipper_isHaveApkV2Sign(&newZip)){
        if (!getCompressedIsNormalized(&newZip,&newZip_otherCompressLevel,&newZip_otherCompressMemLevel,true)){
            newZip_otherCompressLevel=0;
            newZip_otherCompressMemLevel=0;
        }
    }
    byteByByteEqualCheck=UnZipper_isHaveApkV2Sign(&newZip);
    
    if (newCompressedDataIsNormalized && UnZipper_isHaveApkV2Sign(&oldZip))
        oldZip._isDataNormalized=getCompressedIsNormalizedBy(&oldZip,newZipNormalized_compressLevel,
                                                             newZipNormalized_compressMemLevel);
    isNewZipApkV2SignNoError=checkZipInfo(&oldZip,&newZip);
    if (out_isNewZipApkV2SignNoError) *out_isNewZipApkV2SignNoError=isNewZipApkV2SignNoError;
    //if isNewZipApkV2SignNoError==false ,same info error,but continue;
    
    std::cout<<"ZipDiff with compress plugin: \""<<compressPlugin->compressType()<<"\"\n";
    check(getSamePairList(&newZip,&oldZip,newCompressedDataIsNormalized,
                          newZipNormalized_compressLevel,newZipNormalized_compressMemLevel,
                          samePairList,newRefList,newRefOtherCompressedList,newRefCompressedSizeList));
    newRefDecompressList=newRefList;
    if ((newZip_otherCompressLevel|newZip_otherCompressMemLevel)!=0){
        newRefDecompressList.insert(newRefDecompressList.end(),
                                    newRefOtherCompressedList.begin(),newRefOtherCompressedList.end());
        std::sort(newRefDecompressList.begin(),newRefDecompressList.end());
    }
    check(getOldRefList(&newZip,samePairList,newRefDecompressList,&oldZip,oldRefList));
    std::cout<<"ZipDiff same file count: "<<samePairList.size()/2<<" (all "
    <<UnZipper_fileCount(&newZip)<<")\n";
    std::cout<<"    diff new file count: "<<newRefList.size()+newRefOtherCompressedList.size()<<"\n";
    std::cout<<"     ref old file count: "<<oldRefList.size()<<" (all "
    <<UnZipper_fileCount(&oldZip)<<")\n";
    std::cout<<"     ref old decompress: "
    <<OldStream_getDecompressFileCount(&oldZip,oldRefList.data(),oldRefList.size())<<" file ("
    <<OldStream_getDecompressSumSize(&oldZip,oldRefList.data(),oldRefList.size()) <<" byte!)\n";
    //for (int i=0; i<(int)newRefList.size(); ++i) std::cout<<zipFile_name(&newZip,newRefList[i])<<"\n";
    //for (int i=0; i<(int)newRefOtherCompressedList.size(); ++i) std::cout<<zipFile_name(&newZip,newRefOtherCompressedList[i])<<"\n";
    //for (int i=0; i<(int)oldRefList.size(); ++i) std::cout<<zipFile_name(&oldZip,oldRefList[i])<<"\n";
    
    #define _loadNewAndOldData() \
        if ((newZip_otherCompressLevel|newZip_otherCompressMemLevel)!=0){ \
            check(readZipStreamData(&newZip,newRefDecompressList,std::vector<uint32_t>(),newData)); \
        }else{ \
            check(readZipStreamData(&newZip,newRefList,newRefOtherCompressedList,newData)); \
        } \
        check(readZipStreamData(&oldZip,oldRefList,std::vector<uint32_t>(),oldData));
    _loadNewAndOldData();
    check(HDiffZ(oldData,newData,hdiffzData,compressPlugin,diffMatchScore,patchStepMemSize,threadNum));
    _loadNewAndOldData();
    check(HPatchZ_check(oldData,newData,hdiffzData,decompressPlugin,isSD));
    { std::vector<TByte> _empty; oldData.swap(_empty); }
    { std::vector<TByte> _empty; newData.swap(_empty); }
    
    check(serializeZipDiffData(out_diffData,&newZip,&oldZip,newZipAlignSize,
                               newZipNormalized_compressLevel,newZipNormalized_compressMemLevel,
                               newZip_otherCompressLevel,newZip_otherCompressMemLevel,
                               samePairList,newRefOtherCompressedList,newRefCompressedSizeList,
                               oldRefList,hdiffzData,compressPlugin,isSD?1:0));
    std::cout<<"ZipDiff size: "<<out_diffData.size()<<"\n";
    
    check(outDiffStream->write(outDiffStream,0,out_diffData.data(),out_diffData.data()+out_diffData.size()));
clear:
    _isInClear=true;
    check(UnZipper_close(&newZip));
    check(UnZipper_close(&oldZip));
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
xorl %eax, %eax
movq %rax, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq %rax, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq %rax, 0x170(%rsp)
movaps %xmm0, 0x160(%rsp)
movq %rax, 0x130(%rsp)
movaps %xmm0, 0x120(%rsp)
movq %rax, 0x110(%rsp)
movaps %xmm0, 0x100(%rsp)
movq %rax, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movq %rax, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movq %rax, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movq %rax, 0x150(%rsp)
movaps %xmm0, 0x140(%rsp)
movq %rax, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movl $0x6, 0x1c(%rsp)
movl $0x8, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl %eax, 0x10(%rsp)
testq %rcx, %rcx
je 0xaf4c
movq %r8, %r15
testq %r8, %r8
je 0xaf58
movl %r9d, %ebp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, 0x180(%rsp)
leaq 0x238(%rsp), %rdi
callq 0x3fb0c
leaq 0x188(%rsp), %rdi
callq 0x3fb0c
leaq 0x238(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fb9f
testb %al, %al
je 0xaf64
leaq 0x188(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x3fb9f
testb %al, %al
je 0xaf70
leaq 0x188(%rsp), %rdi
callq 0x7f58
movq %rax, 0x138(%rsp)
movq 0x220(%rsp), %rcx
movb $0x1, %al
cmpq 0x1d8(%rsp), %rcx
jae 0xad26
cmpq $0x0, 0x138(%rsp)
setne %cl
cmpl $0x0, 0x1f8(%rsp)
sete %al
andb %cl, %al
leaq 0x188(%rsp), %rdi
movb %al, 0x89(%rdi)
leaq 0x1c(%rsp), %rsi
leaq 0x18(%rsp), %rdx
xorl %ecx, %ecx
callq 0x7e96
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb %al, 0x211(%rsp)
movq 0x220(%rsp), %rax
cmpq 0x1d8(%rsp), %rax
jae 0xad90
leaq 0x188(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0x7e96
testb %al, %al
jne 0xad90
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x10(%rsp)
cmpb $0x0, 0xf(%rsp)
je 0xadc7
movq 0x2d0(%rsp), %rax
cmpq 0x288(%rsp), %rax
jae 0xadc7
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
leaq 0x238(%rsp), %rdi
xorl %ecx, %ecx
callq 0x7bcb
movb %al, 0x2c1(%rsp)
cmpb $0x1, 0x2c1(%rsp)
jne 0xaddd
leaq 0x50474(%rip), %rdi     # 0x5b24c
callq 0x44e0
leaq 0x238(%rsp), %rdi
callq 0x3f62e
testb %al, %al
je 0xadfa
leaq 0x50477(%rip), %rdi     # 0x5b26c
callq 0x44e0
movq 0x2d0(%rsp), %rax
cmpq 0x288(%rsp), %rax
jae 0xae18
leaq 0x50481(%rip), %rdi     # 0x5b294
callq 0x44e0
leaq 0x238(%rsp), %rdi
callq 0x3faf5
testb %al, %al
je 0xae35
leaq 0x50483(%rip), %rdi     # 0x5b2b3
callq 0x44e0
cmpb $0x1, 0x211(%rsp)
jne 0xae4b
leaq 0x5048c(%rip), %rdi     # 0x5b2d2
callq 0x44e0
leaq 0x188(%rsp), %rdi
callq 0x3f62e
testb %al, %al
je 0xae68
leaq 0x5048f(%rip), %rdi     # 0x5b2f2
callq 0x44e0
movq 0x1d8(%rsp), %rbx
movq 0x220(%rsp), %r12
cmpq %rbx, %r12
jae 0xae89
leaq 0x50496(%rip), %rdi     # 0x5b31a
callq 0x44e0
leaq 0x188(%rsp), %rdi
callq 0x3faf5
movl %ebp, %r13d
testb %al, %al
je 0xaea9
leaq 0x50495(%rip), %rdi     # 0x5b339
callq 0x44e0
cmpq %rbx, %r12
setae %bpl
orb 0x211(%rsp), %bpl
jne 0xaec6
leaq 0x50497(%rip), %rdi     # 0x5b358
callq 0x44e0
cmpq %rbx, %r12
jb 0xaeed
leaq 0x188(%rsp), %rdi
callq 0x3f85e
movb $0x1, %bpl
testb %al, %al
je 0xaeed
leaq 0x504e5(%rip), %rdi     # 0x5b3cb
callq 0x44e0
xorl %ebp, %ebp
movq 0x328(%rsp), %rbx
movl $0xa, %edi
callq 0x4410
testq %rbx, %rbx
je 0xaf07
movb %bpl, (%rbx)
movq 0x710b2(%rip), %r12     # 0x7bfc0
leaq 0x4fb9d(%rip), %rsi     # 0x5aab2
movl $0x1f, %edx
movq %r12, %rdi
callq 0x4370
movl %r13d, %ebp
callq *(%r14)
movq %rax, %rbx
testq %rax, %rax
je 0xaf7c
movq %rbx, %rdi
callq 0x4140
movq 0x71081(%rip), %rdi     # 0x7bfc0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4370
jmp 0xaf95
leaq 0x4fe30(%rip), %rdi     # 0x5ad83
jmp 0xb445
leaq 0x4fe22(%rip), %rdi     # 0x5ad81
jmp 0xb445
leaq 0x4f597(%rip), %rdi     # 0x5a502
jmp 0xb445
leaq 0x4fe25(%rip), %rdi     # 0x5ad9c
jmp 0xb445
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x4560
movq 0x71024(%rip), %rdi     # 0x7bfc0
leaq 0x4e100(%rip), %rsi     # 0x590a3
movl $0x2, %edx
callq 0x4370
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
subq $0x8, %rsp
leaq 0x148(%rsp), %r10
leaq 0xa8(%rsp), %rbx
leaq 0xe8(%rsp), %rax
movzbl 0x17(%rsp), %edx
leaq 0x190(%rsp), %rdi
leaq 0x240(%rsp), %rsi
leaq 0x108(%rsp), %r9
pushq %r10
pushq %rbx
pushq %rax
callq 0x80bb
addq $0x20, %rsp
testb %al, %al
je 0xb306
leaq 0xc0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xbf66
movl 0x10(%rsp), %eax
orl 0x14(%rsp), %eax
je 0xb086
leaq 0xc0(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
callq 0xc0c4
movq 0xc0(%rsp), %r13
movq 0xc8(%rsp), %r12
cmpq %r12, %r13
je 0xb086
movq %r12, %rax
subq %r13, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0xc27f
movq %r13, %rdi
movq %r12, %rsi
callq 0xc362
leaq 0x188(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
leaq 0x238(%rsp), %rcx
leaq 0x60(%rsp), %r8
callq 0xc5b0
testb %al, %al
je 0xb312
movq 0x70f01(%rip), %rdi     # 0x7bfc0
leaq 0x4fa0c(%rip), %rsi     # 0x5aad2
movl $0x19, %edx
callq 0x4370
movq 0x108(%rsp), %rsi
subq 0x100(%rsp), %rsi
sarq $0x2, %rsi
shrq %rsi
movq 0x70ed2(%rip), %rdi     # 0x7bfc0
callq 0x4220
movq %rax, %r12
leaq 0x4f9ef(%rip), %rsi     # 0x5aaec
movl $0x6, %edx
movq %rax, %rdi
callq 0x4370
leaq 0x188(%rsp), %rdi
callq 0x3f577
movq %r12, %rdi
movl %eax, %esi
callq 0x45c0
leaq 0x4e37f(%rip), %rsi     # 0x594a7
movl $0x2, %edx
movq %rax, %rdi
callq 0x4370
movq 0x70e84(%rip), %rdi     # 0x7bfc0
leaq 0x4f9b0(%rip), %rsi     # 0x5aaf3
movl $0x19, %edx
callq 0x4370
movq 0xe8(%rsp), %rax
subq 0xe0(%rsp), %rax
sarq $0x2, %rax
movq 0xa8(%rsp), %rsi
subq 0xa0(%rsp), %rsi
sarq $0x2, %rsi
addq %rax, %rsi
movq 0x70e41(%rip), %rdi     # 0x7bfc0
callq 0x4220
leaq 0x4faed(%rip), %rsi     # 0x5ac78
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
movq 0x70e21(%rip), %rdi     # 0x7bfc0
leaq 0x4f967(%rip), %rsi     # 0x5ab0d
movl $0x19, %edx
callq 0x4370
movq 0x68(%rsp), %rsi
subq 0x60(%rsp), %rsi
sarq $0x2, %rsi
movq 0x70dfb(%rip), %rdi     # 0x7bfc0
callq 0x4220
movq %rax, %r12
leaq 0x4f918(%rip), %rsi     # 0x5aaec
movl $0x6, %edx
movq %rax, %rdi
callq 0x4370
leaq 0x238(%rsp), %rdi
callq 0x3f577
movq %r12, %rdi
movl %eax, %esi
callq 0x45c0
leaq 0x4e2a8(%rip), %rsi     # 0x594a7
movl $0x2, %edx
movq %rax, %rdi
callq 0x4370
movq 0x70dad(%rip), %rdi     # 0x7bfc0
leaq 0x4f90d(%rip), %rsi     # 0x5ab27
movl $0x19, %edx
callq 0x4370
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
leaq 0x238(%rsp), %rdi
callq 0x3da80
movq 0x70d77(%rip), %rdi     # 0x7bfc0
movl %eax, %esi
callq 0x45c0
movq %rax, %r13
leaq 0x4f8e7(%rip), %rsi     # 0x5ab41
movl $0x7, %edx
movq %rax, %rdi
callq 0x4370
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
leaq 0x238(%rsp), %rdi
callq 0x3dac9
movl %eax, %esi
movq %r13, %rdi
callq 0x4220
leaq 0x4f8b3(%rip), %rsi     # 0x5ab49
movl $0x8, %edx
movq %rax, %rdi
callq 0x4370
movl 0x10(%rsp), %eax
orl 0x14(%rsp), %eax
je 0xb31e
movq %rbx, %r12
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x188(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x40(%rsp), %rcx
callq 0x895d
movl %eax, %ebx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb2f6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %bl, %bl
jne 0xb34b
leaq 0x4fe84(%rip), %rdi     # 0x5b185
jmp 0xb445
leaq 0x4fad1(%rip), %rdi     # 0x5adde
jmp 0xb445
leaq 0x4fb99(%rip), %rdi     # 0x5aeb2
jmp 0xb445
leaq 0x188(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x895d
movq %rbx, %r12
testb %al, %al
je 0xb43e
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x238(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x80(%rsp), %rcx
callq 0x895d
movl %eax, %ebx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb391
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %bl, %bl
je 0xb435
movl 0x330(%rsp), %eax
movq 0x320(%rsp), %r13
subq $0x8, %rsp
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x168(%rsp), %rdx
movq %r14, %rcx
movl %ebp, %r8d
movq %r13, %r9
pushq %rax
callq 0xbc2f
addq $0x10, %rsp
movl 0x10(%rsp), %eax
orl 0x14(%rsp), %eax
je 0xb5b4
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x188(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x40(%rsp), %rcx
callq 0x895d
movl %eax, %ebx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb428
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %bl, %bl
jne 0xb5de
jmp 0xb2fa
leaq 0x4fcfc(%rip), %rdi     # 0x5b138
jmp 0xb445
leaq 0x4fac0(%rip), %rdi     # 0x5af05
callq 0x44e0
xorl %ebx, %ebx
leaq 0x188(%rsp), %rdi
callq 0x3fb18
testb %al, %al
jne 0xb46b
leaq 0x4f129(%rip), %rdi     # 0x5a58d
callq 0x44e0
xorl %ebx, %ebx
leaq 0x238(%rsp), %rdi
callq 0x3fb18
testb %al, %al
jne 0xb48a
leaq 0x4f129(%rip), %rdi     # 0x5a5ac
callq 0x44e0
xorl %ebx, %ebx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xb4a1
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x140(%rsp), %rdi
testq %rdi, %rdi
je 0xb4be
movq 0x150(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0xb4db
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0xb4f8
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0xb515
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0xb532
movq 0x110(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0xb54f
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x160(%rsp), %rdi
testq %rdi, %rdi
je 0xb56c
movq 0x170(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xb589
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb5a0
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movl %ebx, %eax
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x188(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x895d
testb %al, %al
je 0xb7c3
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x238(%rsp), %rdi
leaq 0x60(%rsp), %rbp
leaq 0x80(%rsp), %rcx
movq %rbp, %rsi
callq 0x895d
movl %eax, %ebx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb627
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %bl, %bl
je 0xb7be
xorl %eax, %eax
testq %r13, %r13
setne %al
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
subq $0x8, %rsp
leaq 0x168(%rsp), %rbx
movq %rbx, %r8
movq %r15, %r9
pushq %rax
callq 0xbe15
addq $0x10, %rsp
testb %al, %al
je 0xb7c8
movq 0x80(%rsp), %rdi
movq 0x90(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
testq %rdi, %rdi
je 0xb6ac
subq %rdi, %rsi
callq 0x4300
xorps %xmm0, %xmm0
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
testq %rdi, %rdi
je 0xb6d1
subq %rdi, %rsi
callq 0x4300
xorl %r10d, %r10d
testq %r13, %r13
setne %r10b
movslq 0x1c(%rsp), %r8
movslq 0x18(%rsp), %r9
movslq 0x14(%rsp), %rax
movslq 0x10(%rsp), %r11
subq $0x8, %rsp
leaq 0x128(%rsp), %rdi
leaq 0x190(%rsp), %rsi
leaq 0x240(%rsp), %rdx
movq 0x140(%rsp), %rcx
pushq %r10
pushq %r14
pushq %rbx
pushq %rbp
leaq 0x168(%rsp), %r10
pushq %r10
pushq %r12
leaq 0x138(%rsp), %r10
pushq %r10
pushq %r11
pushq %rax
callq 0x8b5c
addq $0x50, %rsp
testb %al, %al
je 0xb7d4
movq 0x70876(%rip), %rdi     # 0x7bfc0
leaq 0x4f401(%rip), %rsi     # 0x5ab52
movl $0xe, %edx
callq 0x4370
movq 0x128(%rsp), %rsi
subq 0x120(%rsp), %rsi
movq 0x7084e(%rip), %rdi     # 0x7bfc0
callq 0x4220
leaq 0x4f4fa(%rip), %rsi     # 0x5ac78
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
movq 0x120(%rsp), %rdx
movq 0x128(%rsp), %rcx
movq 0x180(%rsp), %rdi
xorl %esi, %esi
callq *0x18(%rdi)
movb $0x1, %bl
testl %eax, %eax
jne 0xb44c
leaq 0x4f916(%rip), %rdi     # 0x5b0cf
jmp 0xb445
jmp 0xb435
jmp 0xb43e
leaq 0x4f785(%rip), %rdi     # 0x5af54
jmp 0xb445
leaq 0x4f7c0(%rip), %rdi     # 0x5af9b
jmp 0xb445
jmp 0xb7e6
jmp 0xb7e6
jmp 0xb7e6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb807
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
jmp 0xb807
jmp 0xb804
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xb81e
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x140(%rsp), %rdi
testq %rdi, %rdi
je 0xb83b
movq 0x150(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0xb858
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0xb875
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0xb892
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0xb8af
movq 0x110(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0xb8cc
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x160(%rsp), %rdi
testq %rdi, %rdi
je 0xb8e9
movq 0x170(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xb906
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb91d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45e0