LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_diff(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*)
bool check_diff(const TByte* newData,const TByte* newData_end,
                const TByte* oldData,const TByte* oldData_end,
                const TByte* diff,const TByte* diff_end){
    hpatch_TStreamInput  newStream;
    hpatch_TStreamInput  oldStream;
    hpatch_TStreamInput  diffStream;
    mem_as_hStreamInput(&newStream,newData,newData_end);
    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
    mem_as_hStreamInput(&diffStream,diff,diff_end);
    return check_diff(&newStream,&oldStream,&diffStream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x85b30
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x85b30
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x85b30
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x1a8a0
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_diff(hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TStreamInput const*)
bool check_diff(const hpatch_TStreamInput*  newData,
                const hpatch_TStreamInput*  oldData,
                const hpatch_TStreamInput*  diff){
    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
    TAutoMem _cache(kACacheBufSize*(1+8));
    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
    _test_rt(patch_stream_with_cache(&out_newData,oldData,diff,
                                     _cache.data()+kACacheBufSize,_cache.data_end()));
    _test_rt(out_newData.isWriteFinish());
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x80000, -0x28(%rbp)   # imm = 0x80000
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x480000, %esi         # imm = 0x480000
callq 0x29c00
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x29c40
movq %rax, -0x98(%rbp)
jmp 0x1a8f4
movq -0x98(%rbp), %rdx
movq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x80000, %ecx          # imm = 0x80000
callq 0x50360
jmp 0x1a912
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x29c40
movq %rax, -0xb0(%rbp)
jmp 0x1a93a
movq -0xb0(%rbp), %rax
addq $0x80000, %rax          # imm = 0x80000
movq %rax, -0xd0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x29c60
movq %rax, -0xc8(%rbp)
jmp 0x1a960
movq -0xc8(%rbp), %r8
movq -0xd0(%rbp), %rcx
movq -0xb8(%rbp), %rdx
movq -0xc0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x87f80
movl %eax, -0xd4(%rbp)
jmp 0x1a98d
movl -0xd4(%rbp), %eax
cmpl $0x0, %eax
jne 0x1a9dd
movq 0xcb631(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x94248(%rip), %rsi     # 0xaebf1
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x1aa30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x29ca0
jmp 0x1aa47
leaq -0x80(%rbp), %rdi
callq 0x29c80
movb %al, -0xd5(%rbp)
jmp 0x1a9ee
movb -0xd5(%rbp), %al
testb $0x1, %al
jne 0x1aa22
jmp 0x1a9fa
movq 0xcb5cf(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x94257(%rip), %rsi     # 0xaec62
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x1aa30
movb $0x1, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x29ca0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_compressed_diff(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, hpatch_TDecompress*)
bool check_compressed_diff(const TByte* newData,const TByte* newData_end,
                           const TByte* oldData,const TByte* oldData_end,
                           const TByte* diff,const TByte* diff_end,
                           hpatch_TDecompress* decompressPlugin){
    hpatch_TStreamInput  newStream;
    hpatch_TStreamInput  oldStream;
    hpatch_TStreamInput  diffStream;
    mem_as_hStreamInput(&newStream,newData,newData_end);
    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
    mem_as_hStreamInput(&diffStream,diff,diff_end);
    return check_compressed_diff(&newStream,&oldStream,&diffStream,decompressPlugin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x85b30
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x85b30
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x85b30
movq 0x10(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x1aae0
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_compressed_diff(hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TDecompress*)
bool check_compressed_diff(const hpatch_TStreamInput*  newData,
                           const hpatch_TStreamInput*  oldData,
                           const hpatch_TStreamInput*  compressed_diff,
                           hpatch_TDecompress* decompressPlugin){
    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
    TAutoMem _cache(kACacheBufSize*(1+6));
    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
    _test_rt(patch_decompress_with_cache(&out_newData,oldData,compressed_diff,decompressPlugin,
                                         _cache.data()+kACacheBufSize,_cache.data_end()));
    _test_rt(out_newData.isWriteFinish());
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x80000, -0x30(%rbp)   # imm = 0x80000
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x380000, %esi         # imm = 0x380000
callq 0x29c00
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x29c40
movq %rax, -0xa0(%rbp)
jmp 0x1ab38
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movl $0x80000, %ecx          # imm = 0x80000
callq 0x50360
jmp 0x1ab59
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x29c40
movq %rax, -0xb8(%rbp)
jmp 0x1ab8c
movq -0xb8(%rbp), %rax
addq $0x80000, %rax          # imm = 0x80000
movq %rax, -0xe0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x29c60
movq %rax, -0xd8(%rbp)
jmp 0x1abb2
movq -0xd8(%rbp), %r9
movq -0xe0(%rbp), %r8
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rdx
movq -0xd0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x88a70
movl %eax, -0xe4(%rbp)
jmp 0x1abe9
movl -0xe4(%rbp), %eax
cmpl $0x0, %eax
jne 0x1ac39
movq 0xcb3d5(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x94087(%rip), %rsi     # 0xaec8c
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0x98(%rbp)
jmp 0x1ac8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x29ca0
jmp 0x1aca6
leaq -0x88(%rbp), %rdi
callq 0x29c80
movb %al, -0xe5(%rbp)
jmp 0x1ac4d
movb -0xe5(%rbp), %al
testb $0x1, %al
jne 0x1ac81
jmp 0x1ac59
movq 0xcb370(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x93ff8(%rip), %rsi     # 0xaec62
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0x98(%rbp)
jmp 0x1ac8f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x29ca0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_single_compressed_diff(hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TStreamInput const*, hpatch_TDecompress*)
bool check_single_compressed_diff(const hpatch_TStreamInput* newData,
                                  const hpatch_TStreamInput* oldData,
                                  const hpatch_TStreamInput* diff,
                                  hpatch_TDecompress* decompressPlugin){
    sspatch_listener_t listener={0};
    listener.import=decompressPlugin;
    listener.onDiffInfo=_check_single_onDiffInfo;
    listener.onPatchFinish=_check_single_onPatchFinish;
        
    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
    TAutoMem _cache(kACacheBufSize*1);
    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);

    _test_rt(patch_single_stream(&listener,&out_newData,oldData,diff,0,0));
    _test_rt(out_newData.isWriteFinish());
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1b7(%rip), %rax       # 0x1af30
movq %rax, -0x38(%rbp)
leaq 0x23c(%rip), %rax       # 0x1afc0
movq %rax, -0x30(%rbp)
movq $0x80000, -0x48(%rbp)   # imm = 0x80000
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x80000, %esi          # imm = 0x80000
callq 0x29c00
movq -0xc8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x29c40
movq %rax, -0xb8(%rbp)
jmp 0x1adc5
movq -0xb8(%rbp), %rdx
movq -0xc0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x80000, %ecx          # imm = 0x80000
callq 0x50360
jmp 0x1ade6
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
leaq -0x40(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movq %r9, %r8
callq 0x8a720
movl %eax, -0xcc(%rbp)
jmp 0x1ae0e
movl -0xcc(%rbp), %eax
cmpl $0x0, %eax
jne 0x1ae5e
movq 0xcb1b0(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x93ef3(%rip), %rsi     # 0xaed1d
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0xb0(%rbp)
jmp 0x1aeb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x29ca0
jmp 0x1aecb
leaq -0xa0(%rbp), %rdi
callq 0x29c80
movb %al, -0xcd(%rbp)
jmp 0x1ae72
movb -0xcd(%rbp), %al
testb $0x1, %al
jne 0x1aea6
jmp 0x1ae7e
movq 0xcb14b(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x93dd3(%rip), %rsi     # 0xaec62
movb $0x0, %al
callq 0x4520
movb $0x0, -0x1(%rbp)
movl $0x1, -0xb0(%rbp)
jmp 0x1aeb4
movb $0x1, -0x1(%rbp)
movl $0x1, -0xb0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x29ca0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: check_single_onDiffInfo(sspatch_listener_t*, hpatch_singleCompressedDiffInfo const*, hpatch_TDecompress**, unsigned char**, unsigned char**)
static hpatch_BOOL _check_single_onDiffInfo(struct sspatch_listener_t* listener,
                                                const hpatch_singleCompressedDiffInfo* info,
                                                hpatch_TDecompress** out_decompressPlugin,
                                                unsigned char** out_temp_cache,
                                                unsigned char** out_temp_cacheEnd){
        size_t memSize=(size_t)(info->stepMemSize+hdiff_kFileIOBufBestSize*3);
        *out_temp_cache=(unsigned char*)malloc(memSize);
        *out_temp_cacheEnd=(*out_temp_cache)+memSize;   
        *out_decompressPlugin=(info->compressType[0]=='\0')?0:(hpatch_TDecompress*)listener->import;
        return hpatch_TRUE;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x180000, %rax         # imm = 0x180000
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x44d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movsbl 0x38(%rax), %eax
cmpl $0x0, %eax
jne 0x1af98
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1afa3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: _hdiff_private__create_compressed_diff(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>&, hdiff_TCompress const*, int, hdiff_private::TSuffixString const*)
void __hdiff_private__create_compressed_diff(const TByte* newData,const TByte* newData_end,
                                             const TByte* oldData,const TByte* oldData_end,
                                             std::vector<TByte>& out_diff,
                                             const hdiff_TCompress* compressPlugin,int kMinSingleMatchScore,
                                             const TSuffixString* sstring){
    TDiffData diff;
    std::vector<TOldCover> covers;
    get_diff(newData,newData_end,oldData,oldData_end,diff,covers,
             kMinSingleMatchScore,false,0,sstring,1);
    serialize_compressed_diff(diff,covers,out_diff,compressPlugin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x18c60
movq -0x80(%rbp), %r9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl 0x10(%rbp), %r8d
movq 0x18(%rbp), %r10
movq %rsp, %rax
movq %r10, 0x18(%rax)
movl %r8d, (%rax)
movl $0x1, 0x28(%rax)
movq $0x1, 0x20(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
leaq -0x50(%rbp), %r8
callq 0x18c80
jmp 0x1b076
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x198b0
jmp 0x1b08d
leaq -0x68(%rbp), %rdi
callq 0x19760
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x19760
movq -0x70(%rbp), %rdi
callq 0x4680
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: get_match_covers_by_block(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, hpatch_TOutputCovers*, unsigned long, unsigned long)
void get_match_covers_by_block(const unsigned char* newData,const unsigned char* newData_end,
                               const unsigned char* oldData,const unsigned char* oldData_end,
                               hpatch_TOutputCovers* out_covers,size_t kMatchBlockSize,size_t threadNum){
    hdiff_TStreamInput oldData_stream;
    mem_as_hStreamInput(&oldData_stream,oldData,oldData_end);
    hdiff_TStreamInput newData_stream;
    mem_as_hStreamInput(&newData_stream,newData,newData_end);
    hdiff_TMTSets_s mtsets={threadNum,threadNum,true,true,false};
    get_match_covers_by_block(&newData_stream,&oldData_stream,out_covers,kMatchBlockSize,&mtsets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x85b30
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x85b30
movq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x1, -0x78(%rbp)
movb $0x1, -0x77(%rbp)
movb $0x0, -0x76(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x88(%rbp), %r8
callq 0x1a710
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: get_match_covers_by_sstring(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, std::vector<hpatch_TCover_sz, std::allocator<hpatch_TCover_sz>>&, int, bool, ICoverLinesListener*, unsigned long, bool)
void get_match_covers_by_sstring(const unsigned char* newData,const unsigned char* newData_end,
                                 const unsigned char* oldData,const unsigned char* oldData_end,
                                 std::vector<hpatch_TCover_sz>& out_covers,int kMinSingleMatchScore,
                                 bool isUseBigCacheMatch,ICoverLinesListener* listener,
                                 size_t threadNum,bool isCanExtendCover){
    TDiffData diff;
    std::vector<TOldCover> covers;
    assert(sizeof(TOldCover)==sizeof(hpatch_TCover_sz));
    { std::vector<hpatch_TCover_sz> tmp; tmp.swap(out_covers); }
    get_diff(newData,newData_end,oldData,oldData_end,diff,covers,
             kMinSingleMatchScore,isUseBigCacheMatch,listener,0,threadNum,isCanExtendCover);
    void* pcovers=&covers;
    out_covers.swap(*(std::vector<hpatch_TCover_sz>*)pcovers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rcx, -0xd0(%rbp)
movq %rdx, %rax
movq -0xd0(%rbp), %rdx
movq %rax, -0xc8(%rbp)
movq %rsi, %rax
movq -0xc8(%rbp), %rsi
movq %rax, -0xc0(%rbp)
movq %rdi, %r10
movq -0xc0(%rbp), %rdi
movb 0x28(%rbp), %al
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %rcx
movb 0x10(%rbp), %cl
movq %r10, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
andb $0x1, %cl
movb %cl, -0x3d(%rbp)
andb $0x1, %al
movb %al, -0x3e(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x18c60
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x29cd0
movq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x29cf0
movq -0xb8(%rbp), %rdi
callq 0x29d50
movq -0xb0(%rbp), %r9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x3c(%rbp), %r8d
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %rbx
movzbl -0x3d(%rbp), %r10d
movzbl -0x3e(%rbp), %r14d
andl $0x1, %r14d
movq %rsp, %rax
movl %r14d, 0x28(%rax)
movq %rbx, 0x20(%rax)
movq %r11, 0x10(%rax)
andl $0x1, %r10d
movl %r10d, 0x8(%rax)
movl %r8d, (%rax)
movq $0x0, 0x18(%rax)
leaq -0x60(%rbp), %r8
callq 0x18c80
jmp 0x1b25f
leaq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x29cf0
leaq -0x78(%rbp), %rdi
callq 0x19760
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x19760
movq -0x98(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x295a0
movq -0x8(%rbp), %rdi
leaq 0x918a7(%rip), %rsi     # 0xadc03
callq 0x295a0
leaq 0x900df(%rip), %rax     # 0xac447
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c37d
movq -0x10(%rbp), %rax
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4180
movq %rax, -0x28(%rbp)
cmpq $0x103, -0x28(%rbp)     # imm = 0x103
jbe 0x1c3e7
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x936d7(%rip), %rsi     # 0xafa86
callq 0x4140
jmp 0x1c3b6
movq -0x40(%rbp), %rdi
movq 0xc9c2f(%rip), %rsi     # 0xe5ff0
movq 0xc9bf8(%rip), %rdx     # 0xe5fc0
callq 0x4630
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x42e0
jmp 0x1c47b
movq -0x20(%rbp), %rdi
movl $0x26, %esi
callq 0x4130
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1c44f
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x936a6(%rip), %rsi     # 0xafac0
callq 0x4140
jmp 0x1c421
movq -0x48(%rbp), %rdi
movq 0xc9bc4(%rip), %rsi     # 0xe5ff0
movq 0xc9b8d(%rip), %rdx     # 0xe5fc0
callq 0x4630
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x42e0
jmp 0x1c47b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x295a0
movb $0x0, -0x35(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x35(%rbp), %rdx
addq $0x1, %rdx
leaq -0x35(%rbp), %rsi
callq 0x287d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1d380
movq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
leaq -0xbc(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x1d3b0
movb %al, -0xd1(%rbp)
jmp 0x1d303
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x1d33f
jmp 0x1d30f
movb $0x0, -0x1(%rbp)
movl $0x1, -0xd0(%rbp)
jmp 0x1d34d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1d470
jmp 0x1d367
movb $0x1, -0x1(%rbp)
movl $0x1, -0xd0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1d470
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x50c(%rip), %rsi       # 0x1d910
callq 0x17f00
cmpl $0x0, %eax
je 0x1d414
movb $0x1, -0x1(%rbp)
jmp 0x1d461
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %r9
addq $0x8c, %r9
leaq 0x4ce(%rip), %rsi       # 0x1d910
callq 0x18560
cmpl $0x0, %eax
je 0x1d45d
movq -0x10(%rbp), %rax
movb $0x1, 0x88(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1d461
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jbe 0x1d8b8
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x1d8ea
movl $0x0, -0x4(%rbp)
jmp 0x1d900
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x60(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x1d973
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4320
movq -0x28(%rbp), %rcx
addq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq 0x68(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x1d9df
movl $0x0, -0x4(%rbp)
jmp 0x1da38
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x4190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1da06
movl $0x0, -0x4(%rbp)
jmp 0x1da38
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x68(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x78(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rdx
movl -0x14(%rbp), %esi
subq %rsi, %rdx
cmpq %rdx, %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0x1dac0
movl $0x0, -0x4(%rbp)
jmp 0x1db0b
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x4320
movq -0x30(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0x1db04
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq 0x90(%rcx), %rax
jae 0x1db02
movl $0x0, -0x4(%rbp)
jmp 0x1db0b
jmp 0x1db04
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::TDiffResearchCover::researchFinish()
void researchFinish(){
        endResearchCover();
        size_t insert=0;
        for (size_t i=0;i<covers.size();++i){
            if (covers[i].length>0)
                covers[insert++]=covers[i];
        }
        covers.resize(insert);
        covers.insert(covers.end(),reCovers.begin(),reCovers.end());
        std::inplace_merge(covers.begin(),covers.begin()+insert,
                           covers.end(),cover_cmp_by_new_t<TOldCover>());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x25640
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x10(%rax), %rdi
callq 0x1a300
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e886
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fb50
cmpq $0x0, 0x10(%rax)
jle 0x1e873
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fb50
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x1fb50
movq -0x80(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x1e875
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1e7ec
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e9f0
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x10(%rax), %rdi
callq 0x1edf0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1ee20
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0x1ee60
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x1edf0
movq -0x88(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1ed40
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rdi
callq 0x1ee60
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rdi
callq 0x1ee60
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x20100
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rdi
callq 0x1edf0
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x25830
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fa60
testb $0x1, %al
jne 0x1eb69
jmp 0x1ec3c
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a300
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movb 0x28(%rax), %al
leaq -0x50(%rbp), %rsi
xorl %r8d, %r8d
andb $0x1, %al
movzbl %al, %r9d
callq 0x1f340
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a300
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ec37
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1fb50
movq -0x70(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x1ebeb
jmp 0x1eb53
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::search_and_dispose_cover(std::vector<(anonymous namespace)::TOldCover, std::allocator<(anonymous namespace)::TOldCover>>&, (anonymous namespace)::TDiffData const&, hdiff_private::TSuffixString const&, int, (anonymous namespace)::TDiffLimit*, bool)
static void search_and_dispose_cover(std::vector<TOldCover>& covers,const TDiffData& diff,
                                     const TSuffixString& sstring,int kMinSingleMatchScore,
                                     TDiffLimit* diffLimit,bool isCanExtendCover){
    const size_t cover_begin=covers.size();
    _search_cover(covers,diff,sstring,diffLimit,isCanExtendCover);
    if (covers.size()>cover_begin)
        _dispose_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a300
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x22c10
movq -0x8(%rbp), %rdi
callq 0x1a300
cmpq -0x38(%rbp), %rax
jbe 0x1f3be
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x22ed0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::mt_data_t::nextBlock(hdiff_TRange*)
bool nextBlock(hdiff_TRange* out_newRange){
            const size_t kNewSize=(diff->newData_end-diff->newData);
            if (listener)
                return listener->next_search_block_MT(listener,out_newRange);
            size_t i=workIndex++;
            hpatch_StreamPos_t pos=i*(hpatch_StreamPos_t)workBlockSize;
            if (pos<kNewSize){
                out_newRange->beginPos=pos;
                pos+=workBlockSize+kPartPepeatSize;
                pos=(pos<=kNewSize)?pos:kNewSize;
                out_newRange->endPos=pos;
                return true;
            }else{
                return false;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq (%rax), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1fab9
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x30(%rax), %rax
movq 0x10(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fb42
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x2a870
movq -0x38(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
imulq 0x20(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1fb3e
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x20(%rax), %rax
addq $0x800, %rax            # imm = 0x800
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x1fb1c
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1fb24
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1fb42
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff_types.h
// Function: hdiff_private::cover_cmp_by_new_t<(anonymous namespace)::TOldCover>::operator()((anonymous namespace)::TOldCover const&, (anonymous namespace)::TOldCover const&)
inline bool operator ()(const TCover& x,const TCover& y){
            if (x.newPos!=y.newPos)
                return x.newPos<y.newPos;
            else
                return x.length<y.length;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x223fc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x22414
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::_dispose_cover(std::vector<(anonymous namespace)::TOldCover, std::allocator<(anonymous namespace)::TOldCover>>&, unsigned long, (anonymous namespace)::TDiffData const&, int, (anonymous namespace)::TDiffLimit*, bool)
static void _dispose_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,
                          int kMinSingleMatchScore,TDiffLimit* diffLimit,bool isCanExtendCover){
    if (isCanExtendCover){
        TFixedFloatSmooth kExtendMinSameRatio=kMinSingleMatchScore*36+254;
        if  (kExtendMinSameRatio<200) kExtendMinSameRatio=200;
        if (kExtendMinSameRatio>800) kExtendMinSameRatio=800;

        extend_cover(covers,cover_begin,diff,kExtendMinSameRatio,diffLimit);//先尝试扩展.
        select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
        extend_cover(covers,cover_begin,diff,kExtendMinSameRatio,diffLimit);//select_cover会删除一些覆盖线,所以重新扩展.
    }else{
        select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x22f85
imull $0x24, -0x1c(%rbp), %eax
addl $0xfe, %eax
cltq
movq %rax, -0x38(%rbp)
cmpq $0xc8, -0x38(%rbp)
jae 0x22f1e
movq $0xc8, -0x38(%rbp)
cmpq $0x320, -0x38(%rbp)     # imm = 0x320
jbe 0x22f30
movq $0x320, -0x38(%rbp)     # imm = 0x320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x240a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x24440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x240a0
jmp 0x22fa6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x24440
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
subq (%rax), %rdi
callq 0x23b60
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23ba0
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rdi
callq 0x23ba0
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
addl $0x0, %eax
movl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HDiff/diff.cpp
// Function: (anonymous namespace)::tryCollinear((anonymous namespace)::TOldCover&, (anonymous namespace)::TOldCover const&, (anonymous namespace)::TDiffData const&, (anonymous namespace)::TDiffLimit*)
static void tryCollinear(TOldCover& lastCover,const TOldCover& matchCover,const TDiffData& diff,TDiffLimit* diffLimit){
    if (lastCover.length<=0) return;
    if (lastCover.isCollinear(matchCover)) return; //已经共线;
    
    TInt linkOldPos=matchCover.oldPos-(matchCover.newPos-lastCover.newPos);
    if ((linkOldPos<0)||(linkOldPos+lastCover.length>(diff.oldData_end-diff.oldData)))
        return;
    if (diffLimit){
        hpatch_TCover cover={ (size_t)linkOldPos,(size_t)lastCover.newPos,(size_t)lastCover.length};
        if (!diffLimit->listener->limitCover(diffLimit->listener,&cover,0))
            return;
    }
    TInt lastCost=getCoverCost(lastCover,diff);
    TInt matchLinkCost=(TInt)getRegionRleCost(diff.newData+lastCover.newPos,lastCover.length,diff.oldData+linkOldPos);
    if (lastCost>=matchLinkCost)
        lastCover.oldPos=linkOldPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jg 0x238b8
jmp 0x239c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23c40
testb $0x1, %al
jne 0x238cb
jmp 0x238d0
jmp 0x239c2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
subq 0x8(%rdx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x23919
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x10(%rcx), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq 0x10(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x2391e
jmp 0x239c2
cmpq $0x0, -0x20(%rbp)
je 0x23968
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
leaq -0x40(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
testb $0x1, %al
jne 0x23966
jmp 0x239c2
jmp 0x23968
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x24050
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
addq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x3d780
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
jl 0x239c2
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)