LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: void (anonymous namespace)::_outType<hdiff_TCompress const>(std::vector<unsigned char, std::allocator<unsigned char>>&, hdiff_TCompress const*, char const*)
static void _outType(std::vector<TByte>& out_data,T* compressPlugin,const char* versionType=kHDiffVersionType){
        //type version
        pushCStr(out_data,versionType);
        pushCStr(out_data,"&");
        {//compressType
            const char* compressType="";
            if (compressPlugin)
                compressType=compressPlugin->compressType();
            size_t compressTypeLen=strlen(compressType);
            check(compressTypeLen<=hpatch_kMaxPluginTypeLength);
            check(0==strchr(compressType,'&'));
            pushCStr(out_data,compressType);
        }
        const TByte _cstrEndTag='\0';//c string end tag
        pushBack(out_data,&_cstrEndTag,(&_cstrEndTag)+1);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x11e52
leaq 0x4136b(%rip), %rsi     # 0x4f3fe
movq %rbx, %rdi
callq 0x11e52
testq %r14, %r14
je 0xe0a8
callq *(%r14)
movq %rax, %r14
jmp 0xe0af
leaq 0x41bca(%rip), %r14     # 0x4fc79
movq %r14, %rdi
callq 0x4150
cmpq $0x104, %rax            # imm = 0x104
jae 0xe0f8
pushq $0x26
popq %rsi
movq %r14, %rdi
callq 0x4110
testq %rax, %rax
jne 0xe114
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11e52
leaq 0x8(%rsp), %rdx
movb $0x0, -0x1(%rdx)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x11c20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x43455(%rip), %rsi     # 0x5155f
movq %rax, %rdi
callq 0x4120
jmp 0xe12e
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x43473(%rip), %rsi     # 0x51599
movq %rax, %rdi
callq 0x4120
movq 0x66eb3(%rip), %rsi     # 0x74fe8
movq 0x66e7c(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
jmp 0xe146
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_lite_diff_open(unsigned char const*, unsigned char const*, hpi_compressType*)
bool check_lite_diff_open(const hpi_byte* lite_diff,const hpi_byte* lite_diff_end,
                          hpi_compressType* out_compress_type){
    TPatchiListener listener;
    listener.diffData_cur=lite_diff;
    listener.diffData_end=lite_diff_end;
    hpi_pos_t saved_newSize;
    hpi_pos_t saved_uncompressSize;
    if (!_try_open_hpatchi_and_inplace(listener,out_compress_type,
                                       &saved_newSize,&saved_uncompressSize)) return false;
    return true;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x8(%rsp), %rax
andq $0x0, 0x20(%rax)
andq $0x0, 0x90(%rax)
movq %rdi, 0x30(%rax)
movq %rsi, 0x38(%rax)
leaq 0x4(%rsp), %r8
movq %rsp, %rcx
movq %rax, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0xe9d2
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xea5a
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xea5a
movq %rbx, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: try_open_hpatchi_and_inplace((anonymous namespace)::TPatchiListener&, hpi_compressType*, unsigned int*, unsigned int*)
static
bool _try_open_hpatchi_and_inplace(TPatchiListener& listener,hpi_compressType* out_compress_type,
                                   hpi_pos_t* out_newSize,hpi_pos_t* out_uncompressSize){
    listener.isInplacePatch=false;
    listener.extraSafeSize=0;
    const hpi_byte* diffData_cur_bck=listener.diffData_cur;
    if (hpatch_lite_open(&listener,listener._read_diff,out_compress_type,out_newSize,out_uncompressSize))
        return true;
    listener.diffData_cur=diffData_cur_bck;//reread diffData from 0 pos
    if (hpatchi_inplace_open(&listener,listener._read_diff,out_compress_type,out_newSize,out_uncompressSize,&listener.extraSafeSize)){
        listener.isInplacePatch=true;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, 0x88(%rdi)
andl $0x0, 0x8c(%rdi)
movq 0x30(%rdi), %r13
leaq 0x282(%rip), %rsi       # 0xec84
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb19f
movb $0x1, %bpl
testl %eax, %eax
jne 0xea49
leaq 0x8c(%rbx), %r9
movq %r13, 0x30(%rbx)
leaq 0x25b(%rip), %rsi       # 0xec84
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb544
testl %eax, %eax
je 0xea47
movb $0x1, 0x88(%rbx)
jmp 0xea49
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TPatchiListener::_read_diff_dec(void*, unsigned char*, unsigned int*)
static hpi_BOOL _read_diff_dec(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
        TPatchiListener& self=*(TPatchiListener*)inputStream;
        hpi_size_t r_size=*data_size;
        if (r_size>self.uncompressSize){
            r_size=(hpi_size_t)self.uncompressSize;
            *data_size=(hpi_size_t)self.uncompressSize;
        }
        if (!self.decompressPlugin->decompress_part(self.decompresser,out_data,out_data+r_size))
            return hpi_FALSE;
        self.uncompressSize-=r_size;
        return hpi_TRUE;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdx), %ebp
movl 0x60(%rdi), %eax
cmpl %eax, %ebp
jbe 0xec5f
movl %eax, (%rdx)
movl %eax, %ebp
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rax
movl %ebp, %edx
addq %rsi, %rdx
callq *0x18(%rax)
testl %eax, %eax
je 0xec7b
subl %ebp, 0x60(%rbx)
pushq $0x1
popq %rax
jmp 0xec7d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TPatchiListener::_read_diff(void*, unsigned char*, unsigned int*)
static hpi_BOOL _read_diff(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
        TPatchiListener& self=*(TPatchiListener*)inputStream;
        const hpi_byte* cur=self.diffData_cur;
        size_t d_size=self.diffData_end-cur;
        size_t r_size=*data_size;
        if (r_size>d_size){
            r_size=d_size;
            *data_size=(hpi_size_t)r_size;
        }
        memcpy(out_data,cur,r_size);
        self.diffData_cur=cur+r_size;
        return hpi_TRUE;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %rax
subq %r14, %rax
movl (%rdx), %r15d
cmpq %r15, %rax
jae 0xeca4
movl %eax, (%rdx)
movq %rax, %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x42c0
addq %r15, %r14
movq %r14, 0x30(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TPatchiListener::_write_new(hpatchi_listener_t*, unsigned char const*, unsigned int)
static hpi_BOOL _write_new(struct hpatchi_listener_t* listener,const hpi_byte* data,hpi_size_t data_size){
        TPatchiListener& self=*(TPatchiListener*)listener;
        if (data_size>(size_t)(self.newData_end-self.newData_cur)) 
            return hpi_FALSE;
        if (0!=memcmp(self.newData_cur,data,data_size))
            return hpi_FALSE;
        self.newData_cur+=data_size;
        self.newData_cur_pos+=data_size;
        return hpi_TRUE;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq 0x68(%rdi), %r15
movq 0x70(%rdi), %rax
subq %r15, %rax
xorl %ebp, %ebp
cmpq %r14, %rax
jb 0xed01
movq %rdi, %rbx
movq %r15, %rdi
movq %r14, %rdx
callq 0x4350
testl %eax, %eax
jne 0xed01
addq %r14, %r15
movq %r15, 0x68(%rbx)
addq %r14, 0x90(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TPatchiListener::_read_old(hpatchi_listener_t*, unsigned int, unsigned char*, unsigned int)
static hpi_BOOL _read_old(struct hpatchi_listener_t* listener,hpi_pos_t read_from_pos,hpi_byte* out_data,hpi_size_t data_size){
        TPatchiListener& self=*(TPatchiListener*)listener;
        size_t dsize=self.oldData_end-self.oldData;
        if ((read_from_pos>dsize)|(data_size>(size_t)(dsize-read_from_pos))) return hpi_FALSE;
        memcpy(out_data,self.oldData+(size_t)read_from_pos,data_size);
        if (self.isInplacePatch){
            if (read_from_pos<self.newData_cur_pos)
                return hpi_FALSE;
        }
        return hpi_TRUE;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movq 0x78(%rdi), %rsi
movq 0x80(%rdi), %rdi
subq %rsi, %rdi
movl %eax, %r14d
subq %r14, %rdi
setb %r8b
movl %ecx, %eax
cmpq %rax, %rdi
setb %cl
xorl %ebp, %ebp
orb %r8b, %cl
jne 0xed61
addq %r14, %rsi
movq %rdx, %rdi
movq %rax, %rdx
callq 0x42c0
cmpb $0x1, 0x88(%rbx)
jne 0xed5e
cmpq %r14, 0x90(%rbx)
ja 0xed61
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: hdiff_streamDataIsEqual
hpatch_BOOL hdiff_streamDataIsEqual(const hpatch_TStreamInput* x,const hpatch_TStreamInput* y){
    const hpatch_StreamPos_t ssize=x->streamSize;
    if (ssize!=y->streamSize) return hpatch_FALSE;
    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
    hdiff_private::TAutoMem _cache(kACacheBufSize*2);
    hpatch_byte* bufx=_cache.data();
    hpatch_byte* bufy=bufx+kACacheBufSize;
    for (hpatch_StreamPos_t i=0; i<ssize; ){
        const hpatch_StreamPos_t maxdSize=ssize-i;
        size_t dataSize=(size_t)(kACacheBufSize<=maxdSize?kACacheBufSize:maxdSize);
        check(x->read(x,i,bufx,bufx+dataSize));
        check(y->read(y,i,bufy,bufy+dataSize));
        if (0!=memcmp(bufx,bufy,dataSize))
            return hpatch_FALSE;
        i+=dataSize;
    }
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rax
xorl %r15d, %r15d
movq %rax, 0x8(%rsp)
cmpq 0x8(%rsi), %rax
jne 0xee1e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x100000, %esi         # imm = 0x100000
movq %r15, %rdi
callq 0x11e94
movq (%r15), %r15
leaq 0x80000(%r15), %r12
xorl %r13d, %r13d
movq %r13, %rbp
movq 0x8(%rsp), %r13
subq %rbp, %r13
jbe 0xee08
movl $0x80000, %eax          # imm = 0x80000
cmpq %rax, %r13
cmovaeq %rax, %r13
leaq (%r15,%r13), %rcx
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq *0x10(%r14)
testl %eax, %eax
je 0xee4c
leaq (%r12,%r13), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq *0x10(%rbx)
testl %eax, %eax
je 0xee30
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4350
addq %rbp, %r13
testl %eax, %eax
je 0xedb1
xorl %r15d, %r15d
cmpq %rbp, 0x8(%rsp)
setbe %r15b
leaq 0x10(%rsp), %rdi
callq 0x13a5c
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x41df9(%rip), %rsi     # 0x50c3b
movq %rax, %rdi
callq 0x4120
jmp 0xee66
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x41db0(%rip), %rsi     # 0x50c0e
movq %rax, %rdi
callq 0x4120
movq 0x6617b(%rip), %rsi     # 0x74fe8
movq 0x66144(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
jmp 0xee7e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
jmp 0xee90
jmp 0xee8d
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x13a5c
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::_fsearch_and_dispose_cover_thread(std::vector<(anonymous namespace)::TOldCover, std::allocator<(anonymous namespace)::TOldCover>>*, (anonymous namespace)::mt_data_t*)
static void _fsearch_and_dispose_cover_thread(std::vector<TOldCover>* _covers,mt_data_t* mt){
        std::vector<TOldCover>& covers=*_covers;
        const TDiffData& diff=*mt->diff;
        hdiff_TRange newRange;
        while (mt->nextBlock(&newRange)){
            TDiffData diff_part=diff;
            diff_part.newData=diff.newData+(size_t)newRange.beginPos;
            diff_part.newData_end=diff.newData+(size_t)newRange.endPos;
            size_t coverCountBack=covers.size();
            first_search_and_dispose_cover(covers,diff_part,*mt->sstring,mt->kMinSingleMatchScore,mt->isCanExtendCover);
            for (size_t i=coverCountBack;i<covers.size();++i)
                covers[i].newPos+=(TInt)newRange.beginPos;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rbp
pushq $0x18
popq %r12
leaq 0x10(%rsp), %r15
movq %rbp, %rcx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf39b
movq %rsp, %rsi
callq *0x30(%rdi)
testl %eax, %eax
je 0xf45c
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
jmp 0xf3d6
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x1
popq %rcx
lock
xaddq %rcx, 0x30(%rbx)
movq 0x20(%rbx), %rdx
imulq %rdx, %rcx
cmpq %rax, %rcx
jae 0xf45c
movq %rcx, (%rsp)
addq %rcx, %rdx
addq $0x800, %rdx            # imm = 0x800
cmpq %rax, %rdx
cmovbq %rdx, %rax
movq %rax, 0x8(%rsp)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq (%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
addq %rdx, %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r12
movq %rax, %r13
movq 0x8(%rbx), %rdx
movl 0x18(%rbx), %ecx
movzbl 0x28(%rbx), %r9d
movq %r14, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0xf62f
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %r12
movq (%rsp), %rcx
imulq $0x18, %r13, %rdx
addq %rsi, %rdx
addq $0x8, %rdx
cmpq %rax, %r13
jae 0xf454
addq %rcx, (%rdx)
incq %r13
addq $0x18, %rdx
jmp 0xf443
movq (%rbx), %rcx
jmp 0xf379
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::getCoverCtrlCost((anonymous namespace)::TOldCover const&, (anonymous namespace)::TOldCover const&)
inline static TInt getCoverCtrlCost(const TOldCover& cover,const TOldCover& lastCover){
        static const int kUnLinkOtherScore=0;//0--2
        return _getIntCost<TInt,TUInt>((TInt)(cover.oldPos-lastCover.oldPos))
             + _getUIntCost((TUInt)cover.length)
             + _getUIntCost((TUInt)(cover.newPos-lastCover.newPos)) + kUnLinkOtherScore;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
subq (%rsi), %rax
movq %rax, %rdi
negq %rdi
cmovsq %rax, %rdi
addq %rdi, %rdi
callq 0x10817
movl %eax, %ebp
movq 0x10(%r14), %rdi
callq 0x10817
movl %eax, %r15d
movq 0x8(%r14), %rdi
subq 0x8(%rbx), %rdi
callq 0x10817
addl %r15d, %eax
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: long (anonymous namespace)::getEqualLengthLimit<0l>(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*)
static TInt getEqualLengthLimit(const TByte* x,const TByte* x_end,
                          const TByte* y,const TByte* y_end){
    const TInt xLen=(TInt)(x_end-x);
    const TInt yLen=(TInt)(y_end-y);
    TInt maxEqLen=(xLen<yLen)?xLen:yLen;
    if (kMaxEqLenLimit)
        maxEqLen=(maxEqLen<=kMaxEqLenLimit)?maxEqLen:kMaxEqLenLimit;
    for (TInt i=0; i<maxEqLen; ++i) {
        if (x[i]!=y[i])
            return i;
    }
    return maxEqLen;
}

// Assembly:
movq %rcx, %rax
subq %rdi, %rsi
subq %rdx, %rax
cmpq %rax, %rsi
cmovlq %rsi, %rax
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
cmpq %rsi, %rcx
je 0x1080f
movb (%rdi,%rsi), %r8b
cmpb (%rdx,%rsi), %r8b
jne 0x1080c
incq %rsi
jmp 0x107f8
movq %rsi, %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/compress_detect.h
// Function: unsigned int hdiff_private::_getUIntCost<unsigned long>(unsigned long)
static unsigned int _getUIntCost(_UInt v){
    if ((sizeof(_UInt)<8)||((v>>28)>>28)==0) {
        int cost=1;
        _UInt t;
        if ((t=(v>>28))) { v=t; cost+=4; }
        if ((t=(v>>14))) { v=t; cost+=2; }
        if ((t=(v>> 7))) { v=t; ++cost; }
        return cost;
    }else{
        return 9;
    }
}

// Assembly:
movq %rdi, %rax
shrq $0x38, %rax
jne 0x10865
movq %rdi, %rax
shrq $0x1c, %rax
xorl %ecx, %ecx
cmpq $0x10000000, %rdi       # imm = 0x10000000
setae %cl
cmovbq %rdi, %rax
leal 0x1(,%rcx,4), %edx
movq %rax, %rsi
shrq $0xe, %rsi
cmpq $0x4000, %rax           # imm = 0x4000
cmovbq %rax, %rsi
leal 0x3(,%rcx,4), %ecx
cmovbl %edx, %ecx
xorl %eax, %eax
cmpq $0x7f, %rsi
seta %al
addl %ecx, %eax
retq
pushq $0x9
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TOldCover::Link((anonymous namespace)::TOldCover const&)
inline void Link(const TOldCover& next){//共线的2覆盖线合并链接.
            assert(isCollinear(next));
            assert(oldPos<=next.oldPos);
            length = (next.oldPos-oldPos)+next.length;
        }

// Assembly:
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rsi), %rdx
addq %rcx, %rdx
movq (%rsi), %rax
movq 0x8(%rdi), %r8
addq %rax, %r8
cmpq %r8, %rdx
jne 0x10893
subq %rcx, %rax
jl 0x108ac
addq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
popq %rax
retq
leaq 0x4056f(%rip), %rdi     # 0x50e09
leaq 0x40096(%rip), %rsi     # 0x50937
leaq 0x40573(%rip), %rcx     # 0x50e1b
pushq $0x5d
jmp 0x108c3
leaq 0x405a7(%rip), %rdi     # 0x50e5a
leaq 0x4007d(%rip), %rsi     # 0x50937
leaq 0x4055a(%rip), %rcx     # 0x50e1b
pushq $0x5e
popq %rdx
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::select_cover(std::vector<(anonymous namespace)::TOldCover, std::allocator<(anonymous namespace)::TOldCover>>&, unsigned long, (anonymous namespace)::TDiffData const&, int, (anonymous namespace)::TDiffLimit*, bool)
static void select_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,
                         int kMinSingleMatchScore,TDiffLimit* diffLimit,bool isCanExtendCover){
    if (diffLimit==0){
        TCompressDetect  nocover_detect;
        TCompressDetect  cover_detect;
        _select_cover(covers,cover_begin,diff,kMinSingleMatchScore,nocover_detect,cover_detect,0,isCanExtendCover);
    }else{
        _select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit->nocover_detect,
                      diffLimit->cover_detect,diffLimit,isCanExtendCover);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %r9d, %ebp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
je 0x10b17
movq %r8, %rax
movq 0x28(%r8), %r8
movq 0x30(%rax), %r9
movzbl %bpl, %r10d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
pushq %r10
pushq %rax
callq 0x10c2f
addq $0x70, %rsp
jmp 0x10b60
leaq 0x30(%rsp), %rdi
callq 0x192d4
movq %rsp, %rdi
callq 0x192d4
movzbl %bpl, %eax
leaq 0x30(%rsp), %r8
movq %rsp, %r9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
pushq %rax
pushq $0x0
callq 0x10c2f
popq %rax
popq %rcx
movq %rsp, %rdi
callq 0x1934a
leaq 0x30(%rsp), %rdi
callq 0x1934a
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1934a
jmp 0x10b79
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1934a
movq %rbx, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::getCanExtendLength(long, long, int, long, long, (anonymous namespace)::TDiffData const&, unsigned long)
static TInt getCanExtendLength(TInt oldPos,TInt newPos,int inc,TInt newPos_min,TInt lastNewEnd,
                                   const TDiffData& diff,const TFixedFloatSmooth kExtendMinSameRatio){
        static const unsigned int kSmoothLength=4;

        TFixedFloatSmooth curBestSameRatio=0;
        TInt curBestLength=0;
        TUInt curSameCount=0;
        const TFixedFloatSmooth kLimitSameCount=(~(TFixedFloatSmooth)0)/kFixedFloatSmooth_base;
        for (TUInt length=1; (oldPos>=0)&&(oldPos<(diff.oldData_end-diff.oldData))
             &&(newPos>=newPos_min)&&(newPos<lastNewEnd); ++length,oldPos+=inc,newPos+=inc) {
            if (diff.oldData[oldPos]==diff.newData[newPos]){
                ++curSameCount;
                
                if (curSameCount>= kLimitSameCount) break; //for curSameCount*kFixedFloatSmooth_base
                const TFixedFloatSmooth curSameRatio= (curSameCount*kFixedFloatSmooth_base)
                                                      /(length+kSmoothLength);
                if (curSameRatio>=curBestSameRatio){
                    curBestSameRatio=curSameRatio;
                    curBestLength=length;
                }
            }
        }
        if ((curBestSameRatio<kExtendMinSameRatio)||(curBestLength<=2)){
            curBestLength=0;
        }
        
        return curBestLength;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%r9), %r11
movq (%r9), %r14
movq 0x10(%r9), %r15
subq %r15, %r11
movslq %edx, %r12
movabsq $0x5, %r13
xorl %ebx, %ebx
movabsq $0x3ffffffffffffe, %rbp # imm = 0x3FFFFFFFFFFFFE
xorl %r9d, %r9d
xorl %r10d, %r10d
testq %rdi, %rdi
js 0x10c0e
cmpq %r11, %rdi
jge 0x10c0e
cmpq %rcx, %rsi
jl 0x10c0e
cmpq %r8, %rsi
jge 0x10c0e
movb (%r15,%rdi), %al
cmpb (%r14,%rsi), %al
jne 0x10c03
incq %r10
cmpq %rbp, %r10
ja 0x10c0e
movq %r10, %rax
shlq $0xa, %rax
xorl %edx, %edx
divq %r13
cmpq %rbx, %rax
cmovaq %rax, %rbx
leaq -0x4(%r13), %rax
cmovaeq %rax, %r9
addq %r12, %rdi
addq %r12, %rsi
incq %r13
jmp 0x10bc2
xorl %eax, %eax
cmpq $0x3, %r9
cmovlq %rax, %r9
cmpq 0x38(%rsp), %rbx
cmovbq %rax, %r9
movq %r9, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::_clipLenByLimit(unsigned long long&, unsigned long long)
static inline hpatch_StreamPos_t _clipLenByLimit(hpatch_StreamPos_t& clen,hpatch_StreamPos_t kMaxLen){
        hpatch_StreamPos_t alen=clen;
        assert(alen>kMaxLen);
        do{
            alen=(alen+1)>>1;
        } while (alen>kMaxLen);
        clen-=alen;
        return alen;
    }

// Assembly:
movq (%rdi), %rcx
cmpq %rsi, %rcx
jbe 0x11099
movq %rcx, %rax
incq %rax
shrq %rax
cmpq %rsi, %rax
ja 0x11087
subq %rax, %rcx
movq %rcx, (%rdi)
retq
pushq %rax
leaq 0x3fe56(%rip), %rdi     # 0x50ef7
leaq 0x3f88f(%rip), %rsi     # 0x50937
leaq 0x3fe55(%rip), %rcx     # 0x50f04
movl $0x21a, %edx            # imm = 0x21A
callq 0x4230
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TDiffResearchCover::endResearchCover()
inline void endResearchCover(){
        if (limitCoverHitEndPos_back!=_kNullCoverHitEndPos){
            TOldCover& cover=covers[limitCoverIndex_back];
            cover.oldPos+=(TInt)limitCoverHitEndPos_back;
            cover.newPos+=(TInt)limitCoverHitEndPos_back;
            cover.length-=(TInt)limitCoverHitEndPos_back;
            limitCoverHitEndPos_back=_kNullCoverHitEndPos;
        }
    }

// Assembly:
movq 0x60(%rdi), %rax
cmpq $-0x1, %rax
je 0x1128e
movq 0x10(%rdi), %rcx
movq (%rcx), %rcx
imulq $0x18, 0x58(%rdi), %rdx
movdqu (%rcx,%rdx), %xmm0
movq %rax, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, (%rcx,%rdx)
subq %rax, 0x10(%rcx,%rdx)
orq $-0x1, 0x60(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/pack_uint.h
// Function: hdiff_private::pushBack(std::vector<unsigned char, std::allocator<unsigned char>>&, hpatch_TStreamInput const*)
static void pushBack(std::vector<unsigned char>& out_buf,const hpatch_TStreamInput* data){
    const size_t kStepSize=hpatch_kStreamCacheSize*2;
    unsigned char buf[kStepSize];
    out_buf.reserve(out_buf.size()+(size_t)data->streamSize);
    hpatch_StreamPos_t curPos=0;
    while (curPos<data->streamSize){
        size_t len=kStepSize;
        if (curPos+len>data->streamSize)
            len=(size_t)(data->streamSize-curPos);
        if (!data->read(data,curPos,buf,buf+len))
            throw std::runtime_error("pushBack() data->read() error!");
        pushBack(out_buf,buf,len);
        curPos+=len;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
addq 0x8(%rbx), %rsi
movq %rdi, 0x8(%rsp)
callq 0x12116
xorl %r15d, %r15d
movl $0x2000, %ebp           # imm = 0x2000
leaq 0x10(%rsp), %r12
movq 0x8(%rbx), %rax
movq %rax, %r14
subq %r15, %r14
jbe 0x11bcb
leaq (%r15,%rbp), %rcx
cmpq %rax, %rcx
cmovbeq %rbp, %r14
leaq (%rsp,%r14), %r13
addq $0x10, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq *0x10(%rbx)
testl %eax, %eax
je 0x11bdd
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x11c20
addq %r14, %r15
jmp 0x11b84
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3f5f5(%rip), %rsi     # 0x511e4
movq %rax, %rdi
callq 0x4120
movq 0x633ea(%rip), %rsi     # 0x74fe8
movq 0x633b3(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::hpi_getSavedSizeBytes(unsigned long)
static inline TByte hpi_getSavedSizeBytes(TUInt size){
        check(size==(hpi_pos_t)size);
        TByte bytes=0; 
        while (size>0){
            ++bytes;
            size>>=8;
        }
        return bytes;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
shrq $0x20, %rax
jne 0x11d8b
xorl %eax, %eax
testq %rdi, %rdi
je 0x11d83
incb %al
shrq $0x8, %rdi
jmp 0x11d76
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3f79f(%rip), %rsi     # 0x5153c
movq %rax, %rdi
callq 0x4120
movq 0x6323c(%rip), %rsi     # 0x74fe8
movq 0x63205(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::hpi_saveSize(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)
static inline void hpi_saveSize(std::vector<TByte>& buf,TUInt size){
        check(size==(hpi_pos_t)size);
        while (size>0){
            buf.push_back((TByte)size);
            size>>=8;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
shrq $0x20, %rax
jne 0x11e0f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %r15
testq %rbx, %rbx
je 0x11e05
movb %bl, 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x13ab6
shrq $0x8, %rbx
jmp 0x11deb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3f71b(%rip), %rsi     # 0x5153c
movq %rax, %rdi
callq 0x4120
movq 0x631b8(%rip), %rsi     # 0x74fe8
movq 0x63181(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/suffix_string.h
// Function: hdiff_private::TSuffixString::SA(long) const
inline TInt SA(TInt i)const{//return m_SA[i];//排好序的后缀字符串数组.
        if (isUseLargeSA())
            return m_SA_large[i];
        else
            return (TInt)m_SA_limit[i];
    }

// Assembly:
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x1f, %rax
je 0x120b2
movq 0x28(%rdi), %rax
movq (%rax,%rsi,8), %rax
retq
movq 0x10(%rdi), %rax
movslq (%rax,%rsi,4), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h
// Function: hdiff_private::TVectorAsStreamOutput::_read(hpatch_TStreamOutput const*, unsigned long long, unsigned char*, unsigned char*)
static hpatch_BOOL _read(const struct hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
                             unsigned char* out_data,unsigned char* out_data_end){
        const TVectorAsStreamOutput* self=(const TVectorAsStreamOutput*)stream->streamImport;
        const std::vector<unsigned char>& src=self->dst;
        size_t readLen=out_data_end-out_data;
        if (readFromPos+readLen>src.size()) return hpatch_FALSE;
        memcpy(out_data,src.data()+(size_t)readFromPos,readLen);
        return hpatch_TRUE;
    }

// Assembly:
movq (%rdi), %rax
movq 0x20(%rax), %rax
subq %rdx, %rcx
leaq (%rcx,%rsi), %rdi
movq (%rax), %r8
movq 0x8(%rax), %r9
subq %r8, %r9
xorl %eax, %eax
cmpq %r9, %rdi
ja 0x121d8
pushq %rax
addq %rsi, %r8
movq %rdx, %rdi
movq %r8, %rsi
movq %rcx, %rdx
callq 0x42c0
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h
// Function: hdiff_private::TVectorAsStreamOutput::_write(hpatch_TStreamOutput const*, unsigned long long, unsigned char const*, unsigned char const*)
static hpatch_BOOL _write(const hpatch_TStreamOutput* stream,
                            const hpatch_StreamPos_t writeToPos,
                            const unsigned char* data,const unsigned char* data_end){
        TVectorAsStreamOutput* self=(TVectorAsStreamOutput*)stream->streamImport;
        std::vector<unsigned char>& dst=self->dst;
        size_t writeLen=(size_t)(data_end-data);
        if (writeToPos>dst.size()) return hpatch_FALSE;
        if  (dst.size()==writeToPos){
            dst.insert(dst.end(),data,data_end);
        }else{
            if (writeToPos+writeLen!=(size_t)(writeToPos+writeLen)) return hpatch_FALSE;
            if (dst.size()<writeToPos+writeLen)
                dst.resize((size_t)(writeToPos+writeLen));
            memcpy(&dst[(size_t)writeToPos],data,writeLen);
        }
        return hpatch_TRUE;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq (%rdi), %rax
movq 0x20(%rax), %r12
movq %rcx, %r14
subq %rdx, %r14
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq %rsi, %rdx
subq %rdi, %rdx
xorl %eax, %eax
cmpq %r15, %rdx
jb 0x12240
jne 0x1221a
movq %r12, %rdi
movq %rbx, %rdx
callq 0x87d8
jmp 0x1223d
leaq (%r14,%r15), %rsi
cmpq %rsi, %rdx
jae 0x1222f
movq %r12, %rdi
callq 0x843c
movq (%r12), %rdi
addq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x42c0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/covers.h
// Function: hdiff_private::TCoversBuf::_push_cover(hpatch_TOutputCovers*, hpatch_TCover const*)
static hpatch_BOOL _push_cover(struct hpatch_TOutputCovers* out_covers,const TCover* cover){
        TCoversBuf* self=(TCoversBuf*)out_covers;
        if (self->_isCover32) {
            hpatch_TCover32 c32;
            c32.oldPos=(hpatch_uint32_t)cover->oldPos;
            c32.newPos=(hpatch_uint32_t)cover->newPos;
            c32.length=(hpatch_uint32_t)cover->length;
            self->m_covers_limit.push_back(c32);
            self->_update(self->m_covers_limit);
        }else{
            self->m_covers_larger.push_back(*cover);
            self->_update(self->m_covers_larger);
        }
        return hpatch_TRUE;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x122e5
movdqu (%rsi), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
movq %rsp, %rax
movq %xmm0, (%rax)
movl 0x10(%rsi), %ecx
movl %ecx, 0x8(%rax)
leaq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x12530
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
subq %rcx, %rax
pushq $0xc
jmp 0x122fb
leaq 0x40(%rbx), %rdi
callq 0x12554
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/private_diff/mem_buf.h
// Function: hdiff_private::TAutoMem::realloc(unsigned long)
inline void realloc(size_t newSize){
            if (newSize<=capacity()){
                _data_end=_data+newSize;
            }else{
                unsigned char* _new_data=(unsigned char*)::realloc(_data,newSize);
                if (_new_data==0) throw std::runtime_error("TAutoMem::TAutoMem() realloc() error!");
                _data=_new_data;
                _data_end=_new_data+newSize;
                _capacity_end=_data_end;
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rax
subq %rdi, %rax
cmpq %rsi, %rax
jae 0x13a0a
movq %r14, %rsi
callq 0x4560
testq %rax, %rax
je 0x13a19
movq %rax, (%rbx)
addq %rax, %r14
movq %r14, 0x8(%rbx)
movq %r14, 0x10(%rbx)
jmp 0x13a11
addq %r14, %rdi
movq %rdi, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3d955(%rip), %rsi     # 0x51380
movq %rax, %rdi
callq 0x4120
movq 0x615ae(%rip), %rsi     # 0x74fe8
movq 0x61577(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: hdiff_private::TMatchBlock::getPackedCover()
void TMatchBlock::getPackedCover(){
    std::sort(blockCovers.begin(),blockCovers.end(),cover_cmp_by_old_t<hpatch_TCover>());
    _getPackedCovers<false>(oldData_end-oldData,blockCovers,packedCoversForOld);
    std::sort(blockCovers.begin(),blockCovers.end(),cover_cmp_by_new_t<hpatch_TCover>());
    _getPackedCovers<true>(newData_end-newData,blockCovers,packedCoversForNew);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movq 0x48(%rbx), %rsi
callq 0x15013
movq 0x18(%rbx), %rax
movq %rax, (%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rbx), %r14
movq 0x40(%rbx), %rbp
movq 0x48(%rbx), %r12
xorl %eax, %eax
xorl %r13d, %r13d
cmpq %r12, %rbp
jae 0x13cc9
movq (%rbp), %rcx
movq %rcx, %r15
subq %rax, %r15
jbe 0x13cb8
movq %rax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x12554
addq %r15, %r13
movq 0x10(%rbp), %rax
addq (%rbp), %rax
jmp 0x13cc3
addq 0x10(%rbp), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
addq $0x18, %rbp
jmp 0x13c7e
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
subq %rax, %rcx
jb 0x13da8
je 0x13cf5
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %r14, %rdi
callq 0x12554
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x130f4
movq (%rbx), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rbx), %r14
movq 0x40(%rbx), %rbp
movq 0x48(%rbx), %r13
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
xorl %r12d, %r12d
cmpq %r13, %rbp
jae 0x13d71
movq 0x8(%rbp), %rcx
movq %rcx, %r15
subq %rax, %r15
jbe 0x13d60
movq %rax, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12554
addq %r15, %r12
movq 0x10(%rbp), %rax
addq 0x8(%rbp), %rax
jmp 0x13d6b
addq 0x10(%rbp), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
addq $0x18, %rbp
jmp 0x13d28
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
subq %rax, %rcx
jb 0x13dbf
je 0x13d99
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %r14, %rdi
callq 0x12554
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d9b1(%rip), %rdi     # 0x51760
leaq 0x3d90d(%rip), %rsi     # 0x516c3
leaq 0x3d9b4(%rip), %rcx     # 0x51771
jmp 0x13dd4
leaq 0x3d99a(%rip), %rdi     # 0x51760
leaq 0x3d8f6(%rip), %rsi     # 0x516c3
leaq 0x3da27(%rip), %rcx     # 0x517fb
pushq $0x43
popq %rdx
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: hdiff_private::doPackData(unsigned char*, unsigned char*, std::vector<hpatch_TCover, std::allocator<hpatch_TCover>> const&)
static unsigned char* doPackData(unsigned char* data,unsigned char* data_end,
                                     const std::vector<TPackedCover>& packedCovers){
        unsigned char* dst=data;
        for (size_t i=0;i<packedCovers.size();++i){
            const TPackedCover& cv=packedCovers[i];
            assert(dst==data+cv.newPos);
            memmove(data+cv.newPos,data+cv.oldPos,(size_t)cv.length);
            dst=data+cv.newPos+cv.length;
        }
        return dst;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %r15
xorl %r12d, %r12d
pushq $0x18
popq %r13
movq (%rbx), %rbp
movq 0x8(%rbx), %rax
subq %rbp, %rax
cqto
idivq %r13
cmpq %rax, %r12
jae 0x13e72
movq -0x8(%rbp,%r15), %rax
addq %r14, %rax
cmpq %rax, %rdi
jne 0x13e84
movq -0x10(%rbp,%r15), %rsi
addq %r14, %rsi
movq (%rbp,%r15), %rdx
callq 0x4540
movq -0x8(%rbp,%r15), %rdi
addq %r14, %rdi
addq (%rbp,%r15), %rdi
incq %r12
addq $0x18, %r15
jmp 0x13e29
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d824(%rip), %rdi     # 0x516af
leaq 0x3d831(%rip), %rsi     # 0x516c3
leaq 0x3d859(%rip), %rcx     # 0x516f2
pushq $0x6f
popq %rdx
callq 0x4230
nop
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: hdiff_private::doUnpackData(unsigned char*, unsigned char*, std::vector<hpatch_TCover, std::allocator<hpatch_TCover>> const&)
static void doUnpackData(unsigned char* data,unsigned char* data_end,
                             const std::vector<TPackedCover>& packedCovers){
        unsigned char* lastEnd=data_end;
        for (size_t i=packedCovers.size();i>0;--i){
            const TPackedCover& cv=packedCovers[i-1];
            unsigned char* dst=data+cv.oldPos;
            memmove(dst,data+cv.newPos,(size_t)cv.length);
            unsigned char* dstEnd=dst+cv.length;
            memset(dstEnd,0,lastEnd-dstEnd);
            lastEnd=dst;
        }
        memset(data+0,0,lastEnd-data);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq 0x8(%rdx), %rax
movq %rdx, (%rsp)
subq (%rdx), %rax
movq %rdi, %r14
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
imulq $0x18, %rax, %rbp
addq $-0x8, %rbp
subq $0x1, %r12
jb 0x146db
movq (%rsp), %rax
movq (%rax), %rbx
movq -0x10(%rbx,%rbp), %r13
addq %r14, %r13
movq -0x8(%rbx,%rbp), %rsi
addq %r14, %rsi
movq (%rbx,%rbp), %rdx
movq %r13, %rdi
callq 0x4540
movq (%rbx,%rbp), %rdi
addq %r13, %rdi
subq %rdi, %r15
xorl %esi, %esi
movq %r15, %rdx
callq 0x41f0
addq $-0x18, %rbp
movq %r13, %r15
jmp 0x14695
subq %r14, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: hdiff_private::TCoversOptim::_insert_cover(ICoverLinesListener*, IDiffInsertCover*, void*, unsigned long, bool, unsigned long long*, unsigned long long*)
void TCoversOptim::_insert_cover(ICoverLinesListener* listener,IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32,
                                    hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize){
    TCoversOptim* self=(TCoversOptim*)listener;
    if (self->matchBlock!=0){
        _check((hpatch_StreamPos_t)(self->matchBlock->newData_end_cur-self->matchBlock->newData)==*newSize,"unpackData error!");
        _check((hpatch_StreamPos_t)(self->matchBlock->oldData_end_cur-self->matchBlock->oldData)==*oldSize,"unpackData error!");
        self->matchBlock->unpackData(diffi,pcovers,coverCount,isCover32);
        *newSize=self->matchBlock->newData_end_cur-self->matchBlock->newData;
        *oldSize=self->matchBlock->oldData_end_cur-self->matchBlock->oldData;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x14778
movq %r9, %rbx
movq 0x10(%rdi), %rax
subq (%rdi), %rax
cmpq (%r9), %rax
jne 0x1477e
movq 0x20(%rsp), %r15
movq 0x28(%rdi), %rax
subq 0x18(%rdi), %rax
cmpq (%r15), %rax
jne 0x1479a
movzbl %r8b, %r8d
callq 0x13ea2
movq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
subq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rcx
subq 0x18(%rax), %rcx
movq %rcx, (%r15)
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3cecd(%rip), %rsi     # 0x5165d
movq %rax, %rdi
callq 0x4120
jmp 0x147b4
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3ceb1(%rip), %rsi     # 0x5165d
movq %rax, %rdi
callq 0x4120
movq 0x6082d(%rip), %rsi     # 0x74fe8
movq 0x607f6(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
jmp 0x147cc
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: hdiff_private::loadOldAndNewStream(hdiff_private::TAutoMem&, hpatch_TStreamInput const*, hpatch_TStreamInput const*)
void loadOldAndNewStream(TAutoMem& out_mem,const hpatch_TStreamInput* oldStream,const hpatch_TStreamInput* newStream){
    size_t old_size=oldStream?(size_t)oldStream->streamSize:0;
    size_t new_size=(size_t)newStream->streamSize;
    _check(newStream->streamSize==new_size,"loadOldAndNew() streamSize");
    if (old_size) _check(oldStream->streamSize+newStream->streamSize==old_size+new_size,"loadOldAndNew() streamSize");
    out_mem.realloc(old_size+new_size);
    if (old_size) _check(oldStream->read(oldStream,0,out_mem.data(),out_mem.data()+old_size),"loadOldAndNew() oldStream->read");
    _check(newStream->read(newStream,0,out_mem.data()+old_size,out_mem.data()+old_size+new_size),"loadOldAndNew() newStream->read");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x1483f
movq %rsi, %r13
movq 0x8(%rsi), %r12
movq 0x8(%rbx), %r14
testq %r12, %r12
je 0x14843
leaq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x139d4
movq (%r15), %rdx
leaq (%rdx,%r12), %rcx
movq %r13, %rdi
xorl %esi, %esi
callq *0x10(%r13)
testl %eax, %eax
jne 0x14851
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3ce3a(%rip), %rsi     # 0x5166f
movq %rax, %rdi
callq 0x4120
jmp 0x1488d
movq 0x8(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x139d4
xorl %r12d, %r12d
addq (%r15), %r12
addq %r12, %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
callq *0x10(%rbx)
testl %eax, %eax
je 0x14873
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x41c0
movq %rax, %rbx
leaq 0x3ce0a(%rip), %rsi     # 0x5168f
movq %rax, %rdi
callq 0x4120
movq 0x60754(%rip), %rsi     # 0x74fe8
movq 0x6071d(%rip), %rdx     # 0x74fb8
movq %rbx, %rdi
callq 0x45b0
jmp 0x148a5
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/match_block.cpp
// Function: create_compressed_diff_block(unsigned char*, unsigned char*, unsigned char*, unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>&, hdiff_TCompress const*, int, bool, unsigned long, unsigned long)
void create_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
                                  unsigned char* oldData,unsigned char* oldData_end,
                                  std::vector<unsigned char>& out_diff,const hdiff_TCompress* compressPlugin,
                                  int kMinSingleMatchScore,bool isUseBigCacheMatch,
                                  size_t matchBlockSize,size_t threadNum){
    if (matchBlockSize==0){
        create_compressed_diff(newData,newData_end,oldData,oldData_end,
                               out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,0,threadNum);
        return;
    }
    TCoversOptimMB<TMatchBlock> coversOp(newData,newData_end,oldData,oldData_end,matchBlockSize,threadNum);
    create_compressed_diff(newData,coversOp.matchBlock->newData_end_cur,oldData,coversOp.matchBlock->oldData_end_cur,
                           out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,&coversOp,threadNum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
movq 0x128(%rsp), %r11
movq 0x120(%rsp), %r9
movb 0x118(%rsp), %bpl
movl 0x110(%rsp), %r10d
testq %r9, %r9
je 0x14965
subq $0x8, %rsp
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
pushq %r11
callq 0x14e34
popq %rax
popq %rcx
movq 0x40(%r13), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rax), %rcx
movzbl %bpl, %eax
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %r8
movq %rbx, %r9
pushq 0x128(%rsp)
pushq %r13
pushq %rax
movl 0x128(%rsp), %eax
pushq %rax
callq 0xc695
addq $0x20, %rsp
leaq 0x50(%rsp), %rdi
callq 0x14ff0
addq $0xd8, %rsp
jmp 0x1498e
movzbl %bpl, %eax
movq %r12, %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r8, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %r11
pushq $0x0
pushq %rax
pushq %r10
callq 0xc695
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x14ff0
movq %rbx, %rdi
callq 0x4600