LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: patch_stream_with_cache
hpatch_BOOL patch_stream_with_cache(const struct hpatch_TStreamOutput* out_newData,
                                    const struct hpatch_TStreamInput*  oldData,
                                    const struct hpatch_TStreamInput*  serializedDiff,
                                    TByte*   temp_cache,TByte* temp_cache_end){
    hpatch_BOOL     result;
    hpatch_TCovers* covers=0;//not need close before return
    hpatch_BOOL    isReadError=hpatch_FALSE;
    _patch_cache(&covers,&oldData,out_newData->streamSize,serializedDiff,hpatch_FALSE,0,
                _kCachePatCount,&temp_cache,&temp_cache_end,&isReadError);
    if (isReadError) return _hpatch_FALSE;
    result=_patch_stream_with_cache(out_newData,oldData,serializedDiff,covers,
                                    temp_cache,temp_cache_end);
    //if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
leaq -0x28(%rbp), %r11
leaq -0x30(%rbp), %r10
leaq -0x44(%rbp), %rax
movq $0x8, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x88030
cmpl $0x0, -0x44(%rbp)
je 0x87ffe
movl $0x0, -0x4(%rbp)
jmp 0x88024
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x88620
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: patch_decompress_with_cache
hpatch_BOOL patch_decompress_with_cache(const hpatch_TStreamOutput* out_newData,
                                        const hpatch_TStreamInput*  oldData,
                                        const hpatch_TStreamInput*  compressedDiff,
                                        hpatch_TDecompress* decompressPlugin,
                                        TByte* temp_cache,TByte* temp_cache_end){
    hpatch_BOOL     result;
    hpatch_TCovers* covers=0; //need close before return
    hpatch_BOOL    isReadError=hpatch_FALSE;
    _patch_cache(&covers,&oldData,out_newData->streamSize,compressedDiff,hpatch_TRUE,
                 decompressPlugin,_kCacheDecCount,&temp_cache,&temp_cache_end,&isReadError);
    if (isReadError) return _hpatch_FALSE;
    result=_patch_decompress_cache(out_newData,0,oldData,compressedDiff,decompressPlugin,
                                   covers,temp_cache,temp_cache_end);
    if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %r8d
leaq -0x30(%rbp), %r11
leaq -0x38(%rbp), %r10
leaq -0x4c(%rbp), %rax
movq $0x6, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x88030
cmpl $0x0, -0x4c(%rbp)
je 0x88af4
movl $0x0, -0x4(%rbp)
jmp 0x88b4a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x30(%rbp), %r10
movq -0x38(%rbp), %rax
xorl %esi, %esi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x88b60
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x88b44
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x88b44
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: hpatch_coverList_open_serializedDiff
hpatch_BOOL hpatch_coverList_open_serializedDiff(hpatch_TCoverList* out_coverList,
                                                 const hpatch_TStreamInput*  serializedDiff){
    TByte* temp_cache;
    TByte* temp_cache_end;
    _TPackedCovers* packedCovers=0;
    _THDiffHead     diffHead;
    assert((out_coverList!=0)&&(out_coverList->ICovers==0));
    temp_cache=out_coverList->_buf;
    temp_cache_end=temp_cache+sizeof(out_coverList->_buf);
    if (!_packedCovers_open(&packedCovers,&diffHead,serializedDiff,
                            temp_cache,temp_cache_end))
        return _hpatch_FALSE;
    out_coverList->ICovers=&packedCovers->base.ICovers;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x891eb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x891eb
jmp 0x8920a
leaq 0x2bb65(%rip), %rdi     # 0xb4d57
leaq 0x2b7e1(%rip), %rsi     # 0xb49da
movl $0x7ae, %edx            # imm = 0x7AE
leaq 0x2bb82(%rip), %rcx     # 0xb4d87
callq 0x4270
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4000, %rax           # imm = 0x4000
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x89270
cmpl $0x0, %eax
jne 0x8924b
movl $0x0, -0x4(%rbp)
jmp 0x8925d
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: hpatch_coverList_open_compressedDiff
hpatch_BOOL hpatch_coverList_open_compressedDiff(hpatch_TCoverList* out_coverList,
                                                 const hpatch_TStreamInput*  compressedDiff,
                                                 hpatch_TDecompress*         decompressPlugin){
    TByte* temp_cache;
    TByte* temp_cache_end;
    _TCompressedCovers* compressedCovers=0;
    hpatch_compressedDiffInfo diffInfo;
    assert((out_coverList!=0)&&(out_coverList->ICovers==0));
    temp_cache=out_coverList->_buf;
    temp_cache_end=temp_cache+sizeof(out_coverList->_buf);
    if (!_compressedCovers_open(&compressedCovers,&diffInfo,compressedDiff,decompressPlugin,
                                temp_cache,temp_cache_end))
        return _hpatch_FALSE;
    out_coverList->ICovers=&compressedCovers->base.ICovers;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x89452
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x89452
jmp 0x89471
leaq 0x2b8fe(%rip), %rdi     # 0xb4d57
leaq 0x2b57a(%rip), %rsi     # 0xb49da
movl $0x7bf, %edx            # imm = 0x7BF
leaq 0x2b97e(%rip), %rcx     # 0xb4dea
callq 0x4270
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4000, %rax           # imm = 0x4000
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x894e0
cmpl $0x0, %eax
jne 0x894b9
movl $0x0, -0x4(%rbp)
jmp 0x894cb
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: compressed_stream_as_uncompressed
hpatch_BOOL compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream,hpatch_StreamPos_t uncompressedSize,
                                              hpatch_TDecompress* decompressPlugin,const hpatch_TStreamInput* compressedStream,
                                              hpatch_StreamPos_t compressed_pos,hpatch_StreamPos_t compressed_end){
    hpatch_TUncompresser_t* self=uncompressedStream;
    assert(decompressPlugin!=0);
    assert(self->_decompressHandle==0);
    self->_decompressHandle=decompressPlugin->open(decompressPlugin,uncompressedSize,compressedStream,
                                                   compressed_pos,compressed_end);
    if (self->_decompressHandle==0) return _hpatch_FALSE;
    self->_decompressPlugin=decompressPlugin;
    
    self->base.streamImport=self;
    self->base.streamSize=uncompressedSize;
    self->base.read=_TUncompresser_read;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x89861
jmp 0x89880
leaq 0x27cb7(%rip), %rdi     # 0xb151f
leaq 0x2b16b(%rip), %rsi     # 0xb49da
movl $0x81d, %edx            # imm = 0x81D
leaq 0x2b5e8(%rip), %rcx     # 0xb4e63
callq 0x4270
movq -0x40(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8988d
jmp 0x898ac
leaq 0x2b686(%rip), %rdi     # 0xb4f1a
leaq 0x2b13f(%rip), %rsi     # 0xb49da
movl $0x81e, %edx            # imm = 0x81E
leaq 0x2b5bc(%rip), %rcx     # 0xb4e63
callq 0x4270
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq *%rax
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x898e9
movl $0x0, -0x4(%rbp)
jmp 0x89922
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
leaq 0x759(%rip), %rcx       # 0x8a070
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: close_compressed_stream_as_uncompressed
void close_compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream){
    hpatch_TUncompresser_t* self=uncompressedStream;
    if (self==0) return;
    if (self->_decompressHandle==0) return;
    self->_decompressPlugin->close(self->_decompressPlugin,self->_decompressHandle);
    self->_decompressHandle=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x89dbd
jmp 0x89df4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x89dca
jmp 0x89df4
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: sspatch_covers_nextCover
hpatch_BOOL sspatch_covers_nextCover(sspatch_covers_t* self){
    hpatch_BOOL inc_oldPos_sign=(*(self->covers_cache))>>(8-1);
    self->lastOldEnd=self->cover.oldPos+self->cover.length;
    self->lastNewEnd=self->cover.newPos+self->cover.length;
    if (!hpatch_unpackUIntWithTag(&self->covers_cache,self->covers_cacheEnd,&self->cover.oldPos,1)) return _hpatch_FALSE;
    if (inc_oldPos_sign==0)
        self->cover.oldPos+=self->lastOldEnd;
    else
        self->cover.oldPos=self->lastOldEnd-self->cover.oldPos;
    if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.newPos)) return _hpatch_FALSE;
    self->cover.newPos+=self->lastNewEnd;
    if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.length)) return _hpatch_FALSE;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
sarl $0x7, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
movl $0x1, %ecx
callq 0x85a10
cmpl $0x0, %eax
jne 0x8a13b
movl $0x0, -0x4(%rbp)
jmp 0x8a1e4
cmpl $0x0, -0x14(%rbp)
jne 0x8a157
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x8a16f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
subq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
addq $0x8, %rdx
xorl %ecx, %ecx
callq 0x85a10
cmpl $0x0, %eax
jne 0x8a19c
movl $0x0, -0x4(%rbp)
jmp 0x8a1e4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x85a10
cmpl $0x0, %eax
jne 0x8a1dd
movl $0x0, -0x4(%rbp)
jmp 0x8a1e4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch_private.h
// Function: TOutStreamCache_init
static hpatch_inline void _TOutStreamCache_init(_TOutStreamCache* self,const hpatch_TStreamOutput*  dstStream,
                                                unsigned char* aCache,hpatch_size_t aCacheSize){
    self->writeToPos=0;
    self->cacheCur=0;
    self->dstStream=dstStream;
    self->cacheBuf=aCache;
    self->cacheEnd=aCacheSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: rle0_decoder_init
static void _rle0_decoder_init(rle0_decoder_t* self,const unsigned char* code,const unsigned char* code_end){
    self->code=code;
    self->code_end=code_end;
    self->len0=0;
    self->lenv=0;
    self->isNeedDecode0=hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: patch_add_old_with_rle0
static  hpatch_BOOL _patch_add_old_with_rle0(_TOutStreamCache* outCache,rle0_decoder_t* rle0_decoder,
                                             const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
                                             hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
    while (addLength>0){
        hpatch_size_t decodeStep=aCacheSize;
        if (decodeStep>addLength)
            decodeStep=(hpatch_size_t)addLength;
        if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
        if (!_rle0_decoder_add(rle0_decoder,aCache,decodeStep)) return _hpatch_FALSE;
        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
        oldPos+=decodeStep;
        addLength-=decodeStep;
    }
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x8a403
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x8a379
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x40(%rbp), %rcx
callq *%rax
cmpl $0x0, %eax
jne 0x8a3a5
movl $0x0, -0x4(%rbp)
jmp 0x8a40a
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x8cce0
cmpl $0x0, %eax
jne 0x8a3c4
movl $0x0, -0x4(%rbp)
jmp 0x8a40a
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x873d0
cmpl $0x0, %eax
jne 0x8a3e3
movl $0x0, -0x4(%rbp)
jmp 0x8a40a
movq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8a354
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: TDiffToSingleStream_init
void TDiffToSingleStream_init(TDiffToSingleStream* self,const hpatch_TStreamInput* diffStream){
    self->base.streamImport=self;
    self->base.streamSize=diffStream->streamSize;
    self->base.read=_TDiffToSingleStream_read;
    self->base._private_reserved=0;
    self->diffStream=diffStream;
    self->readedSize=0;
    self->cachedBufBegin=_TDiffToSingleStream_kBufSize;
    self->isInSingleStream=hpatch_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x4e(%rip), %rcx        # 0x8a4d0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x1000, 0x30(%rax)     # imm = 0x1000
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: arrayCovers_read_cover
static hpatch_BOOL _arrayCovers_read_cover(struct hpatch_TCovers* covers,hpatch_TCover* out_cover){
    _TArrayCovers* self=(_TArrayCovers*)covers;
    hpatch_size_t i=self->cur_index;
    if (i<self->coverCount){
        if (self->is32){
            const hpatch_TCCover32* pCover=((const hpatch_TCCover32*)self->pCCovers)+i;
            out_cover->oldPos=pCover->oldPos;
            out_cover->newPos=pCover->newPos;
            out_cover->length=pCover->length;
        }else{
            const hpatch_TCCover64* pCover=((const hpatch_TCCover64*)self->pCCovers)+i;
            out_cover->oldPos=pCover->oldPos;
            out_cover->newPos=pCover->newPos;
            out_cover->length=pCover->length;
        }
        self->cur_index=i+1;
        return hpatch_TRUE;
    }else{
        return _hpatch_FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x8b044
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x8afe6
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8b02b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x8b04b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: getMaxCachedLen
static hpatch_size_t _getMaxCachedLen(const _TArrayCovers* src_covers,
                                      TByte* temp_cache,TByte* temp_cache_end,TByte* cache_buf_end){
    const hpatch_size_t kMaxCachedLen  =~((hpatch_size_t)0);//允许缓存的最长单个数据长度;
    hpatch_StreamPos_t mlen=0;
    hpatch_StreamPos_t sum=0;
    const hpatch_size_t coverCount=src_covers->coverCount;
    hpatch_size_t i;
    _TArrayCovers cur_covers=*src_covers;
    hpatch_size_t cacheSize=temp_cache_end-temp_cache;
    hpatch_StreamPos_t memSize=arrayCovers_memSize(src_covers->coverCount,src_covers->is32);
    _cache_alloc(cur_covers.pCCovers,void,memSize,temp_cache,temp_cache_end); //fail return 0
    memcpy(cur_covers.pCCovers,src_covers->pCCovers,(hpatch_size_t)memSize);
    _arrayCovers_sort_by_len(&cur_covers);
    
    for (i=0; i<coverCount;++i) {
        mlen=_arrayCovers_get_len(&cur_covers,i);
        sum+=mlen;
        if (sum<=cacheSize){
            continue;
        }else{
            --mlen;
            break;
        }
    }
    if (mlen>kMaxCachedLen)
        mlen=kMaxCachedLen;
    return (hpatch_size_t)mlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $-0x1, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x40, %edx
callq 0x4320
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x8aec0
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq -0xa0(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jae 0x8b0f9
movq $0x0, -0x8(%rbp)
jmp 0x8b1e1
movq -0x18(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0xa0(%rbp), %rdx
callq 0x4320
leaq -0x90(%rbp), %rdi
callq 0x8ba80
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x8b1ca
cmpl $0x0, -0x58(%rbp)
je 0x8b16d
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x2, %rcx
movl 0x8(%rax,%rcx,4), %eax
movq %rax, -0xa8(%rbp)
jmp 0x8b185
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x2, %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x98(%rbp), %rax
ja 0x8b1ab
jmp 0x8b1b9
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8b1ca
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x8b144
cmpq $-0x1, -0x38(%rbp)
jbe 0x8b1d9
movq $-0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: arrayCovers_sort_by_len
static void _arrayCovers_sort_by_len(_TArrayCovers* self){
    if (self->is32)
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_len_32);
    else
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x8bab9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x10, %edx
leaq 0x2e(%rip), %rcx        # 0x8bae0
callq 0x46f0
jmp 0x8bada
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x20, %edx
leaq 0x5b(%rip), %rcx        # 0x8bb30
callq 0x46f0
addq $0x10, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: arrayCovers_sort_by_old
static void _arrayCovers_sort_by_old(_TArrayCovers* self){
    if (self->is32)
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_old_32);
    else
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x8bbc9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x10, %edx
leaq 0x8e(%rip), %rcx        # 0x8bc50
callq 0x46f0
jmp 0x8bbea
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x20, %edx
leaq 0xbb(%rip), %rcx        # 0x8bca0
callq 0x46f0
addq $0x10, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: arrayCovers_sort_by_new
static void _arrayCovers_sort_by_new(_TArrayCovers* self){
    if (self->is32)
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_new_32);
    else
        qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x8bc29
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x10, %edx
leaq 0xde(%rip), %rcx        # 0x8bd00
callq 0x46f0
jmp 0x8bc4a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x20, %edx
leaq 0x10b(%rip), %rcx       # 0x8bd50
callq 0x46f0
addq $0x10, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: TBytesRle_load_stream_init
hpatch_inline
static void _TBytesRle_load_stream_init(_TBytesRle_load_stream* loader){
    loader->memSetLength=0;
    loader->memSetValue=0;//nil;
    loader->memCopyLength=0;
    _TStreamCacheClip_init(&loader->ctrlClip,0,0,0,0,0);
    _TStreamCacheClip_init(&loader->rleCodeClip,0,0,0,0,0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x871e0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x871e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: rle_decode_skip
static hpatch_BOOL _rle_decode_skip(struct _TBytesRle_load_stream* rle_loader,hpatch_StreamPos_t copyLength){
    while (copyLength>0) {
        hpatch_size_t len=(~(hpatch_size_t)0);
        if (len>copyLength)
            len=(hpatch_size_t)copyLength;
        if (!_TBytesRle_load_stream_decode_skip(rle_loader,len)) return _hpatch_FALSE;
        copyLength-=len;
    }
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x8c361
movq $-0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x8c331
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x8c500
cmpl $0x0, %eax
jne 0x8c350
movl $0x0, -0x4(%rbp)
jmp 0x8c368
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x8c310
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: patch_add_old_with_rle
static  hpatch_BOOL _patch_add_old_with_rle(_TOutStreamCache* outCache,_TBytesRle_load_stream* rle_loader,
                                            const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
                                            hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
    while (addLength>0){
        hpatch_size_t decodeStep=aCacheSize;
        if (decodeStep>addLength)
            decodeStep=(hpatch_size_t)addLength;
        if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
        if (!_TBytesRle_load_stream_decode_add(rle_loader,aCache,decodeStep)) return _hpatch_FALSE;
        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
        oldPos+=decodeStep;
        addLength-=decodeStep;
    }
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x8c453
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x8c3c9
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x40(%rbp), %rcx
callq *%rax
cmpl $0x0, %eax
jne 0x8c3f5
movl $0x0, -0x4(%rbp)
jmp 0x8c45a
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x8c500
cmpl $0x0, %eax
jne 0x8c414
movl $0x0, -0x4(%rbp)
jmp 0x8c45a
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x873d0
cmpl $0x0, %eax
jne 0x8c433
movl $0x0, -0x4(%rbp)
jmp 0x8c45a
movq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8c3a4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: TBytesRle_load_stream_isFinish
hpatch_inline
static hpatch_BOOL _TBytesRle_load_stream_isFinish(const _TBytesRle_load_stream* loader){
    return(loader->memSetLength==0)
        &&(loader->memCopyLength==0)
        &&(_TStreamCacheClip_isFinish(&loader->rleCodeClip))
        &&(_TStreamCacheClip_isFinish(&loader->ctrlClip));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x9(%rbp)
jne 0x8c4f4
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x9(%rbp)
jne 0x8c4f4
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdx
movq -0x8(%rbp), %rax
subq 0x48(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x68(%rcx), %rax
addq %rax, %rdx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdx, %rcx
movb %al, -0x9(%rbp)
jne 0x8c4f4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
subq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdx
subq 0x38(%rdx), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: covers_init
static void _covers_init(_TCovers* covers,hpatch_StreamPos_t coverCount,
                         TStreamCacheClip* code_inc_oldPosClip,
                         TStreamCacheClip* code_inc_newPosClip,
                         TStreamCacheClip* code_lengthsClip,
                         hpatch_BOOL  isOldPosBackNeedAddLength){
    covers->ICovers.leave_cover_count=_covers_leaveCoverCount;
    covers->ICovers.read_cover=_covers_read_cover;
    covers->ICovers.is_finish=_covers_is_finish;
    covers->ICovers.close=_covers_close_nil;
    covers->coverCount=coverCount;
    covers->newPosBack=0;
    covers->oldPosBack=0;
    covers->code_inc_oldPosClip=code_inc_oldPosClip;
    covers->code_inc_newPosClip=code_inc_newPosClip;
    covers->code_lengthsClip=code_lengthsClip;
    covers->isOldPosBackNeedAddLength=isOldPosBackNeedAddLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
leaq 0x89(%rip), %rcx        # 0x8c990
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x9b(%rip), %rcx        # 0x8c9b0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x25c(%rip), %rcx       # 0x8cb80
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq -0x1a43(%rip), %rcx     # 0x8aef0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: covers_is_finish
static  hpatch_BOOL _covers_is_finish(const struct hpatch_TCovers* covers){
    _TCovers* self=(_TCovers*)covers;
    return _TStreamCacheClip_isFinish(self->code_lengthsClip)
        && _TStreamCacheClip_isFinish(self->code_inc_newPosClip)
        && _TStreamCacheClip_isFinish(self->code_inc_oldPosClip);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
subq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq 0x20(%rcx), %rax
addq %rax, %rdx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jne 0x8cc49
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
subq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq 0x20(%rcx), %rax
addq %rax, %rdx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jne 0x8cc49
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq 0x20(%rdx), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libHDiffPatch/HPatch/patch.c
// Function: compressedCovers_close
static hpatch_BOOL _compressedCovers_close(hpatch_TCovers* covers){
    hpatch_BOOL result=hpatch_TRUE;
    _TCompressedCovers* self=(_TCompressedCovers*)covers;
    if (self){
        if (self->decompresser.decompressHandle){
            result=self->decompresser.decompressPlugin->close(self->decompresser.decompressPlugin,
                                                              self->decompresser.decompressHandle);
            self->decompresser.decompressHandle=0;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8cccb
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x8ccc9
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0xa8(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0xb0(%rcx), %rsi
callq *%rax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0xb0(%rax)
jmp 0x8cccb
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: get_block_dev_size
static hpatch_BOOL _get_block_dev_size(const char* blkdev,hpatch_uint64_t* bsize){
	int fd;
    assert(blkdev&&bsize);

    fd=open(blkdev,O_RDONLY);
	if (fd == -1){
		LOG_ERR("%s","_get_block_dev_size() open");
		return hpatch_FALSE;
	}

	if (ioctl(fd,BLKGETSIZE64,bsize) == -1) {
		LOG_ERR("%s","_get_block_dev_size() ioctl");
		close(fd);
		return hpatch_FALSE;
	}

	close(fd);
	return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8d150
cmpq $0x0, -0x18(%rbp)
je 0x8d150
jmp 0x8d16f
leaq 0x28991(%rip), %rdi     # 0xb5ae8
leaq 0x287be(%rip), %rsi     # 0xb591c
movl $0x3d, %edx
leaq 0x2898c(%rip), %rcx     # 0xb5af6
callq 0x4270
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4650
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x8d1ad
movq 0x58e44(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x28777(%rip), %rsi     # 0xb590d
leaq 0x2899a(%rip), %rdx     # 0xb5b37
movb $0x0, %al
callq 0x4520
movl $0x0, -0x4(%rbp)
jmp 0x8d204
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rdx
movl $0x80081272, %esi       # imm = 0x80081272
movb $0x0, %al
callq 0x4510
cmpl $-0x1, %eax
jne 0x8d1f5
movq 0x58e04(%rip), %rax     # 0xe5fd0
movq (%rax), %rdi
leaq 0x28737(%rip), %rsi     # 0xb590d
leaq 0x28975(%rip), %rdx     # 0xb5b52
movb $0x0, %al
callq 0x4520
movl -0x1c(%rbp), %edi
callq 0x4730
movl $0x0, -0x4(%rbp)
jmp 0x8d204
movl -0x1c(%rbp), %edi
callq 0x4730
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_getTempPathName
hpatch_BOOL hpatch_getTempPathName(const char* path_utf8,char* out_tempPath_utf8,char* out_tempPath_end){
    //use tmpnam()?
#define _AddingLen 8
    size_t i;
    size_t len=strlen(path_utf8);
    if ((len>0)&&(path_utf8[len-1]==kPatch_dirSeparator)) --len; //without '/'
    if (len+(4+_AddingLen)>(size_t)(out_tempPath_end-out_tempPath_utf8)) { _set_errno_new(ENAMETOOLONG); return hpatch_FALSE; }
    memcpy(out_tempPath_utf8,path_utf8,len);
    out_tempPath_utf8+=len;
    for (i=1; i<1000; ++i) {
        hpatch_TPathType tmpPathType;
        char adding[_AddingLen]={'0','0','0','.','t','m','p','\0'};
        adding[2]+=i%10;    adding[1]+=(i/10)%10;   adding[0]+=(i/100)%10;
        memcpy(out_tempPath_utf8,adding,sizeof(adding));
        if (!_hpatch_getPathStat_noEndDirSeparator(out_tempPath_utf8,&tmpPathType,0,0)) return hpatch_FALSE;
        if (tmpPathType==kPathType_notExist)
            return hpatch_TRUE; //ok
    }
    return hpatch_FALSE;
#undef _AddingLen
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x8d259
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8d259
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0xc, %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x8d28a
jmp 0x8d273
callq 0x4050
movl $0x24, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d37d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4320
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x28(%rbp)
cmpq $0x3e8, -0x28(%rbp)     # imm = 0x3E8
jae 0x8d376
movq 0x286e8(%rip), %rax     # 0xb59ac
movq %rax, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movsbq -0x3a(%rbp), %rax
addq %rdx, %rax
movb %al, -0x3a(%rbp)
movq -0x28(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movsbq -0x3b(%rbp), %rax
addq %rdx, %rax
movb %al, -0x3b(%rbp)
movq -0x28(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movsbq -0x3c(%rbp), %rax
addq %rdx, %rax
movb %al, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8cf80
cmpl $0x0, %eax
jne 0x8d354
movl $0x0, -0x4(%rbp)
jmp 0x8d37d
cmpl $0x0, -0x34(%rbp)
jne 0x8d363
movl $0x1, -0x4(%rbp)
jmp 0x8d37d
jmp 0x8d365
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8d2af
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_renamePath
hpatch_BOOL hpatch_renamePath(const char* oldPath_utf8,const char* newPath_utf8){
    _path_noEndDirSeparator(oldPath,oldPath_utf8); {
        _path_noEndDirSeparator(newPath,newPath_utf8); {
#if (_IS_USED_WIN32_UTF8_WAPI)
            int     wsize;
            wchar_t oldPath_w[hpatch_kPathMaxSize];
            wchar_t newPath_w[hpatch_kPathMaxSize];
            wsize=_utf8FileName_to_w(oldPath,oldPath_w,hpatch_kPathMaxSize);
            if (wsize<=0) return hpatch_FALSE;
            wsize=_utf8FileName_to_w(newPath,newPath_w,hpatch_kPathMaxSize);
            if (wsize<=0) return hpatch_FALSE;
            return 0==_wrename(oldPath_w,newPath_w);
#else
            return 0==rename(oldPath,newPath);
#endif
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0x1028(%rbp)
cmpq $0x1000, -0x1028(%rbp) # imm = 0x1000
jb 0x8d3d9
jmp 0x8d3c2
callq 0x4050
movl $0x24, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d4e4
cmpq $0x0, -0x1028(%rbp)
jbe 0x8d40d
movq -0x10(%rbp), %rax
movq -0x1028(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8d40d
movq -0x1028(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x1028(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1028(%rbp), %rdx
callq 0x4320
movq -0x1028(%rbp), %rax
movb $0x0, -0x1020(%rbp,%rax)
movq -0x18(%rbp), %rdi
callq 0x4180
movq %rax, -0x2038(%rbp)
cmpq $0x1000, -0x2038(%rbp) # imm = 0x1000
jb 0x8d466
jmp 0x8d452
callq 0x4050
movl $0x24, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d4e4
cmpq $0x0, -0x2038(%rbp)
jbe 0x8d49a
movq -0x18(%rbp), %rax
movq -0x2038(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8d49a
movq -0x2038(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x2038(%rbp)
leaq -0x2030(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x2038(%rbp), %rdx
callq 0x4320
movq -0x2038(%rbp), %rax
movb $0x0, -0x2030(%rbp,%rax)
leaq -0x1020(%rbp), %rdi
leaq -0x2030(%rbp), %rsi
callq 0x4250
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_makeNewDir
hpatch_BOOL hpatch_makeNewDir(const char* dirName_utf8){
    hpatch_TPathType type;
    _path_noEndDirSeparator(path,dirName_utf8);
    if (!_hpatch_getPathStat_noEndDirSeparator(path,&type,0,0)) return hpatch_FALSE; //error
    switch (type) {
        case kPathType_dir :{ return hpatch_TRUE; } break; //exist
        case kPathType_file:{ _set_errno_new(EPERM); return hpatch_FALSE; } break; //error, not overwite
        case kPathType_notExist:{
#if (_IS_USED_WIN32_UTF8_WAPI)
            int     wsize;
            wchar_t path_w[hpatch_kPathMaxSize];
            wsize=_utf8FileName_to_w(path,path_w,hpatch_kPathMaxSize);
            if (wsize<=0) return hpatch_FALSE;
            return 0==_wmkdir(path_w);
#else
#   ifdef _MSC_VER
            return 0==_mkdir(path);
#   else
#       if defined(__MINGW32__) && defined(_WIN32)
            return 0==mkdir(path);
#       else
            const mode_t kDefalutMode=S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;//0755
            return 0==mkdir(path,kDefalutMode);
#       endif
#   endif
#endif
        } break;
    }
    return hpatch_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0x1028(%rbp)
cmpq $0x1000, -0x1028(%rbp) # imm = 0x1000
jb 0x8d705
jmp 0x8d6ee
callq 0x4050
movl $0x24, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d801
cmpq $0x0, -0x1028(%rbp)
jbe 0x8d739
movq -0x10(%rbp), %rax
movq -0x1028(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8d739
movq -0x1028(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x1028(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1028(%rbp), %rdx
callq 0x4320
movq -0x1028(%rbp), %rax
movb $0x0, -0x1020(%rbp,%rax)
leaq -0x1020(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8cf80
cmpl $0x0, %eax
jne 0x8d784
movl $0x0, -0x4(%rbp)
jmp 0x8d801
movl -0x14(%rbp), %eax
movl %eax, -0x1030(%rbp)
testl %eax, %eax
je 0x8d7cc
jmp 0x8d793
movl -0x1030(%rbp), %eax
subl $0x1, %eax
je 0x8d7b6
jmp 0x8d7a0
movl -0x1030(%rbp), %eax
subl $0x2, %eax
jne 0x8d7fa
jmp 0x8d7ad
movl $0x1, -0x4(%rbp)
jmp 0x8d801
jmp 0x8d7b8
callq 0x4050
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d801
movl $0x1ed, -0x102c(%rbp)   # imm = 0x1ED
leaq -0x1020(%rbp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x41b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8d801
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_getIsExecuteFile
hpatch_BOOL hpatch_getIsExecuteFile(const char* fileName){
#ifdef _WIN32
    return hpatch_FALSE; // now, not need execute info
#else
    hpatch_TPathType type;
    size_t           st_mode=0;
    if (!_hpatch_getPathStat_noEndDirSeparator(fileName,&type,0,&st_mode)) return hpatch_FALSE;
    if (type!=kPathType_file) return hpatch_FALSE;// now, not need execute info
    return (((mode_t)st_mode&S_IXUSR)!=0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x20(%rbp), %rcx
callq 0x8cf80
cmpl $0x0, %eax
jne 0x8d847
movl $0x0, -0x4(%rbp)
jmp 0x8d86b
cmpl $0x1, -0x14(%rbp)
je 0x8d856
movl $0x0, -0x4(%rbp)
jmp 0x8d86b
movq -0x20(%rbp), %rax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_setIsExecuteFile
hpatch_BOOL hpatch_setIsExecuteFile(const char* fileName){
#ifdef _WIN32
    return hpatch_TRUE; // now, not need execute info
#else
    hpatch_TPathType type;
    size_t           st_mode=0;
    if (!_hpatch_getPathStat_noEndDirSeparator(fileName,&type,0,&st_mode)) return hpatch_FALSE;
    return 0==chmod(fileName,(mode_t)st_mode|S_IXUSR|S_IXGRP|S_IXOTH);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x20(%rbp), %rcx
callq 0x8cf80
cmpl $0x0, %eax
jne 0x8d8b7
movl $0x0, -0x4(%rbp)
jmp 0x8d8e0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
orl $0x40, %esi
orl $0x8, %esi
orl $0x1, %esi
callq 0x4370
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)